623 lines
15 KiB
C++
623 lines
15 KiB
C++
//
|
|
// Created by neo on 2019-08-15.
|
|
//
|
|
|
|
#include "../pinball.h"
|
|
|
|
//----- (0100400B) --------------------------------------------------------
|
|
signed int rectangle_clip(int *a1, int *a2, DWORD *a3)
|
|
{
|
|
int v3; // edi
|
|
int v4; // edx
|
|
int v5; // esi
|
|
int v6; // ebx
|
|
int v7; // edx
|
|
int v9; // [esp+Ch] [ebp-8h]
|
|
int v10; // [esp+10h] [ebp-4h]
|
|
int v11; // [esp+1Ch] [ebp+8h]
|
|
|
|
v3 = *a1;
|
|
v9 = a1[1];
|
|
v10 = a1[3];
|
|
v4 = *a2 + a2[2];
|
|
v11 = a1[2];
|
|
v5 = a2[1] + a2[3];
|
|
if ( v3 + v11 < *a2 )
|
|
return 0;
|
|
if ( v3 >= v4 )
|
|
return 0;
|
|
v6 = v9;
|
|
if ( v9 + v10 < a2[1] || v9 >= v5 )
|
|
return 0;
|
|
if ( v3 < *a2 )
|
|
{
|
|
v11 += v3 - *a2;
|
|
v3 = *a2;
|
|
}
|
|
if ( v3 + v11 > v4 )
|
|
v11 = v4 - v3;
|
|
v7 = v10;
|
|
if ( v9 < a2[1] )
|
|
{
|
|
v7 = v9 - a2[1] + v10;
|
|
v6 = a2[1];
|
|
}
|
|
if ( v7 + v6 > v5 )
|
|
v7 = v5 - v6;
|
|
if ( !v11 || !v7 )
|
|
return 0;
|
|
if ( a3 )
|
|
{
|
|
*a3 = v3;
|
|
a3[1] = v6;
|
|
a3[2] = v11;
|
|
a3[3] = v7;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
//----- (010040C2) --------------------------------------------------------
|
|
int enclosing_box(DWORD *a1, DWORD *a2, DWORD *a3)
|
|
{
|
|
int v3; // esi
|
|
int v4; // edi
|
|
int v5; // eax
|
|
bool v6; // sf
|
|
unsigned __int8 v7; // of
|
|
int v8; // edx
|
|
int v9; // ecx
|
|
int v10; // eax
|
|
int result; // eax
|
|
int v12; // [esp+8h] [ebp-8h]
|
|
int v13; // [esp+Ch] [ebp-4h]
|
|
int v14; // [esp+18h] [ebp+8h]
|
|
int v15; // [esp+1Ch] [ebp+Ch]
|
|
|
|
v3 = *a1;
|
|
v4 = a1[1];
|
|
v13 = a1[2];
|
|
v12 = a1[3];
|
|
v5 = *a2;
|
|
v7 = __OFSUB__(*a2, *a1);
|
|
v6 = *a2 - *a1 < 0;
|
|
v14 = a2[1];
|
|
v8 = a2[2];
|
|
v9 = a2[3];
|
|
v15 = *a2;
|
|
if ( v6 ^ v7 )
|
|
{
|
|
v13 += v3 - v5;
|
|
v3 = v5;
|
|
}
|
|
if ( v14 < v4 )
|
|
{
|
|
v12 += v4 - v14;
|
|
v4 = v14;
|
|
}
|
|
if ( v8 + v5 > v3 + v13 )
|
|
v13 = v15 + v8 - v3;
|
|
v10 = v12;
|
|
if ( v9 + v14 > v12 + v4 )
|
|
v10 = v14 + v9 - v4;
|
|
a3[1] = v4;
|
|
a3[3] = v10;
|
|
result = v13;
|
|
*a3 = v3;
|
|
a3[2] = v13;
|
|
return result;
|
|
}
|
|
|
|
//----- (010077C4) --------------------------------------------------------
|
|
BOOL center_in(HWND hWnd, HWND a2)
|
|
{
|
|
HWND v2; // eax
|
|
LONG v3; // ebx
|
|
int v4; // edi
|
|
int v5; // ecx
|
|
int v6; // eax
|
|
struct tagRECT v8; // [esp+Ch] [ebp-30h]
|
|
struct tagRECT Rect; // [esp+1Ch] [ebp-20h]
|
|
struct tagRECT v10; // [esp+2Ch] [ebp-10h]
|
|
|
|
GetWindowRect(hWnd, &Rect);
|
|
GetWindowRect(a2, &v8);
|
|
v2 = GetDesktopWindow();
|
|
GetWindowRect(v2, &v10);
|
|
if ( fullscrn_display_changed )
|
|
{
|
|
v10.bottom = 480;
|
|
v10.left = 0;
|
|
v10.top = 0;
|
|
v3 = 640;
|
|
v10.right = 640;
|
|
Rect.left = 0;
|
|
Rect.top = 0;
|
|
Rect.right = 640;
|
|
Rect.bottom = 480;
|
|
}
|
|
else
|
|
{
|
|
v3 = v10.right;
|
|
}
|
|
v4 = v8.bottom - v8.top;
|
|
v5 = Rect.left + (Rect.right + v8.left - v8.right - Rect.left) / 2;
|
|
v6 = Rect.top + (Rect.bottom + v8.top - v8.bottom - Rect.top) / 2;
|
|
if ( v8.right - v8.left + v5 > v3 )
|
|
v5 = v3 - (v8.right - v8.left);
|
|
if ( v4 + v6 > v10.bottom )
|
|
v6 = v10.bottom - v4;
|
|
if ( v5 < v10.left )
|
|
v5 = v10.left;
|
|
if ( v6 < v10.top )
|
|
v6 = v10.top;
|
|
return MoveWindow(a2, v5, v6, v8.right - v8.left, v8.bottom - v8.top, 0);
|
|
}
|
|
// 1024EF4: using guessed type int fullscrn_display_changed;
|
|
|
|
//----- (01008AE9) --------------------------------------------------------
|
|
double normalize_2d(float *a1)
|
|
{
|
|
double result; // st7
|
|
|
|
result = sqrt(*a1 * *a1 + a1[1] * a1[1]);
|
|
if ( 0.0 != result )
|
|
{
|
|
*a1 = 1.0 / result * *a1;
|
|
a1[1] = 1.0 / result * a1[1];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//----- (01008B34) --------------------------------------------------------
|
|
double ray_intersect_circle(float *a1, float *a2)
|
|
{
|
|
double v2; // st7
|
|
double v3; // st7
|
|
double v4; // st6
|
|
double result; // st7
|
|
long double v6; // st5
|
|
float v7; // [esp+0h] [ebp-Ch]
|
|
float v8; // [esp+4h] [ebp-8h]
|
|
|
|
v7 = *a2 - *a1;
|
|
v2 = a2[1] - a1[1];
|
|
v8 = v2;
|
|
v3 = v2 * a1[4] + v7 * a1[3];
|
|
if ( v3 < 0.0 )
|
|
return 1000000000.0;
|
|
v4 = v8 * v8 + v7 * v7;
|
|
if ( v4 < a2[3] )
|
|
return v3 - sqrt(a2[3] - v4 + v3 * v3);
|
|
v6 = a2[3] - v4 + v3 * v3;
|
|
if ( v6 < 0.0 )
|
|
return 1000000000.0;
|
|
result = v3 - sqrt(v6);
|
|
if ( result < 0.0 || result > a1[6] )
|
|
return 1000000000.0;
|
|
return result;
|
|
}
|
|
|
|
//----- (01008BEB) --------------------------------------------------------
|
|
int line_init(int a1, float a2, float a3, float a4, float a5)
|
|
{
|
|
float *v5; // esi
|
|
int v6; // edx
|
|
double v7; // st7
|
|
double v8; // st6
|
|
double v9; // st7
|
|
bool v10; // pf
|
|
int result; // eax
|
|
|
|
v5 = (float *)(a1 + 12);
|
|
*(float *)(a1 + 12) = a4 - a2;
|
|
*(float *)(a1 + 16) = a5 - a3;
|
|
normalize_2d((float *)(a1 + 12));
|
|
v7 = *(float *)(v6 + 16);
|
|
*(float *)v6 = *(float *)(v6 + 16);
|
|
v8 = -*(float *)(a1 + 12);
|
|
*(float *)(v6 + 4) = v8;
|
|
*(float *)(v6 + 24) = -(v7 * a2) - v8 * a3;
|
|
if ( *(float *)(a1 + 12) >= 0.000000001 || *v5 <= -0.000000001 )
|
|
{
|
|
v9 = a4;
|
|
v10 = a2 >= (double)a4;
|
|
result = LODWORD(a2);
|
|
}
|
|
else
|
|
{
|
|
*v5 = 0.0;
|
|
v9 = a5;
|
|
v10 = a3 >= (double)a5;
|
|
result = LODWORD(a3);
|
|
}
|
|
if ( v10 )
|
|
{
|
|
*(float *)(v6 + 28) = v9;
|
|
*(DWORD *)(v6 + 32) = result;
|
|
}
|
|
else
|
|
{
|
|
*(float *)(v6 + 32) = v9;
|
|
*(DWORD *)(v6 + 28) = result;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//----- (01008C8F) --------------------------------------------------------
|
|
double ray_intersect_line(float *a1, float *a2)
|
|
{
|
|
double v2; // st7
|
|
double result; // st7
|
|
double v4; // st6
|
|
bool v5; // c0
|
|
bool v6; // c3
|
|
double v7; // st6
|
|
|
|
v2 = a2[1] * a1[4] + a1[3] * *a2;
|
|
if ( v2 < 0.0 )
|
|
{
|
|
result = -((*a1 * *a2 + a1[1] * a2[1] + a2[6]) / v2);
|
|
if ( result >= -a1[7] && result <= a1[6] )
|
|
{
|
|
a2[9] = result * a1[3] + *a1;
|
|
v4 = result * a1[4] + a1[1];
|
|
a2[10] = v4;
|
|
if ( 0.0 == a2[3] )
|
|
{
|
|
if ( v4 >= a2[7] )
|
|
{
|
|
v5 = v4 < a2[8];
|
|
v6 = v4 == a2[8];
|
|
goto LABEL_9;
|
|
}
|
|
}
|
|
else if ( a2[7] <= (double)a2[9] )
|
|
{
|
|
v7 = a2[9];
|
|
v5 = v7 < a2[8];
|
|
v6 = v7 == a2[8];
|
|
LABEL_9:
|
|
if ( v5 || v6 )
|
|
return result;
|
|
return 1000000000.0;
|
|
}
|
|
}
|
|
}
|
|
return 1000000000.0;
|
|
}
|
|
|
|
//----- (01008D4E) --------------------------------------------------------
|
|
float *proj_matrix_vector_multiply(float *a1, float *a2, float *a3)
|
|
{
|
|
double v3; // st7
|
|
double v4; // st6
|
|
double v5; // st5
|
|
float *result; // eax
|
|
|
|
v3 = *a2;
|
|
v4 = a2[1];
|
|
v5 = a2[2];
|
|
result = a1;
|
|
*a3 = v5 * a1[2] + v4 * a1[1] + v3 * *a1 + a1[3];
|
|
a3[1] = v5 * result[6] + v4 * result[5] + v3 * result[4] + result[7];
|
|
a3[2] = v5 * result[10] + v4 * result[9] + v3 * result[8] + result[11];
|
|
return result;
|
|
}
|
|
|
|
//----- (01008DB8) --------------------------------------------------------
|
|
float *cross(float *a1, float *a2, float *a3)
|
|
{
|
|
float *v3; // ecx
|
|
float *result; // eax
|
|
|
|
v3 = a2;
|
|
result = a1;
|
|
*a3 = a2[2] * a1[1] - a2[1] * a1[2];
|
|
a3[1] = -(*result * v3[2] - *v3 * result[2]);
|
|
a3[2] = *result * v3[1] - *v3 * result[1];
|
|
return result;
|
|
}
|
|
|
|
//----- (01008DFF) --------------------------------------------------------
|
|
double magnitude(float *a1)
|
|
{
|
|
long double v1; // st7
|
|
double result; // st7
|
|
|
|
v1 = *a1 * *a1 + a1[1] * a1[1] + a1[2] * a1[2];
|
|
if ( v1 == 0.0 )
|
|
result = 0.0;
|
|
else
|
|
result = sqrt(v1);
|
|
return result;
|
|
}
|
|
|
|
//----- (01008E4B) --------------------------------------------------------
|
|
int proj_init(int a1, int a2, int a3, int a4)
|
|
{
|
|
float *v4; // edx
|
|
float *v5; // eax
|
|
signed int v6; // esi
|
|
int result; // eax
|
|
|
|
v4 = (float *)&proj_matrix;
|
|
do
|
|
{
|
|
v5 = v4;
|
|
v6 = 4;
|
|
do
|
|
{
|
|
*v5 = *(float *)((char *)v5 + a1 - (DWORD)&proj_matrix);
|
|
v5 += 4;
|
|
--v6;
|
|
}
|
|
while ( v6 );
|
|
++v4;
|
|
}
|
|
while ( (signed int)v4 < (signed int)&unk_1028170 );
|
|
flt_1028198 = 0.0;
|
|
proj_d = a2;
|
|
flt_1028194 = 0.0;
|
|
proj_centerx = a3;
|
|
result = a4;
|
|
proj_centery = a4;
|
|
flt_1028190 = 0.0;
|
|
flt_102819C = 1.0;
|
|
return result;
|
|
}
|
|
// 1028138: using guessed type int proj_centery;
|
|
// 102813C: using guessed type int proj_centerx;
|
|
// 1028140: using guessed type int proj_d;
|
|
// 1028190: using guessed type float flt_1028190;
|
|
// 1028194: using guessed type float flt_1028194;
|
|
// 1028198: using guessed type float flt_1028198;
|
|
// 102819C: using guessed type float flt_102819C;
|
|
|
|
//----- (01008EBA) --------------------------------------------------------
|
|
int proj_recenter(int a1, int a2)
|
|
{
|
|
int result; // eax
|
|
|
|
proj_centerx = a1;
|
|
result = a2;
|
|
proj_centery = a2;
|
|
return result;
|
|
}
|
|
// 1028138: using guessed type int proj_centery;
|
|
// 102813C: using guessed type int proj_centerx;
|
|
|
|
//----- (01008ED8) --------------------------------------------------------
|
|
void proj_z_distance(float *a1)
|
|
{
|
|
char v1; // [esp+0h] [ebp-Ch]
|
|
|
|
proj_matrix_vector_multiply((float *)&proj_matrix, a1, (float *)&v1);
|
|
magnitude((float *)&v1);
|
|
}
|
|
|
|
//----- (01008F03) --------------------------------------------------------
|
|
double proj_xform_to_2d(float *a1, DWORD *a2)
|
|
{
|
|
double v2; // st7
|
|
double v3; // st6
|
|
double result; // st7
|
|
float v5; // [esp+0h] [ebp-Ch]
|
|
float v6; // [esp+4h] [ebp-8h]
|
|
float v7; // [esp+8h] [ebp-4h]
|
|
|
|
proj_matrix_vector_multiply((float *)&proj_matrix, a1, &v5);
|
|
if ( 0.0 == v7 )
|
|
v2 = 999999.88;
|
|
else
|
|
v2 = *(float *)&proj_d / v7;
|
|
v3 = v6 * v2;
|
|
*a2 = (signed __int64)(v5 * v2 + *(float *)&proj_centerx);
|
|
result = 1.0;
|
|
a2[1] = (signed __int64)(v3 + *(float *)&proj_centery);
|
|
return result;
|
|
}
|
|
// 1028138: using guessed type int proj_centery;
|
|
// 102813C: using guessed type int proj_centerx;
|
|
// 1028140: using guessed type int proj_d;
|
|
|
|
|
|
//----- (01013340) --------------------------------------------------------
|
|
BOOL overlapping_box(struct rectangle_type *a1, struct rectangle_type *a2, struct rectangle_type *a3)
|
|
{
|
|
int v3; // esi
|
|
int v4; // edi
|
|
int v5; // esi
|
|
int v6; // esi
|
|
int v7; // edi
|
|
|
|
if ( *(DWORD *)a1 >= *(DWORD *)a2 )
|
|
{
|
|
*(DWORD *)a3 = *(DWORD *)a2;
|
|
v3 = *((DWORD *)a1 + 2) - *(DWORD *)a2;
|
|
v4 = *(DWORD *)a1;
|
|
}
|
|
else
|
|
{
|
|
*(DWORD *)a3 = *(DWORD *)a1;
|
|
v3 = *((DWORD *)a2 + 2) - *(DWORD *)a1;
|
|
v4 = *(DWORD *)a2;
|
|
}
|
|
*((DWORD *)a3 + 2) = v3 + v4 + 1;
|
|
v5 = *((DWORD *)a1 + 1);
|
|
if ( v5 >= *((DWORD *)a2 + 1) )
|
|
{
|
|
*((DWORD *)a3 + 1) = *((DWORD *)a2 + 1);
|
|
v6 = *((DWORD *)a1 + 3) - *((DWORD *)a2 + 1);
|
|
v7 = *((DWORD *)a1 + 1);
|
|
}
|
|
else
|
|
{
|
|
*((DWORD *)a3 + 1) = v5;
|
|
v6 = *((DWORD *)a2 + 3) - *((DWORD *)a1 + 1);
|
|
v7 = *((DWORD *)a2 + 1);
|
|
}
|
|
*((DWORD *)a3 + 3) = v6 + v7 + 1;
|
|
return *((DWORD *)a3 + 2) <= *((DWORD *)a2 + 2) + *((DWORD *)a1 + 2)
|
|
&& *((DWORD *)a3 + 3) <= *((DWORD *)a2 + 3) + *((DWORD *)a1 + 3);
|
|
}
|
|
|
|
//----- (01015935) --------------------------------------------------------
|
|
void throw_ball(struct TBall *a1, struct vector_type *a2, float a3, float a4, float a5)
|
|
{
|
|
struct TBall *v5; // ebx
|
|
int v6; // eax
|
|
float v7; // ST04_4
|
|
struct TBall *v8; // [esp+18h] [ebp+8h]
|
|
|
|
v5 = a1;
|
|
*(DWORD *)((char *)a1 + 106) = 0;
|
|
*(DWORD *)((char *)a1 + 54) = *(DWORD *)a2;
|
|
*(DWORD *)((char *)a1 + 58) = *((DWORD *)a2 + 1);
|
|
*(DWORD *)((char *)a1 + 62) = *((DWORD *)a2 + 2);
|
|
v6 = _rand();
|
|
v7 = (1.0 - ((double)v6 * 0.00003051850947599719 + (double)v6 * 0.00003051850947599719)) * a3;
|
|
RotateVector((struct TBall *)((char *)a1 + 54), v7);
|
|
v8 = (struct TBall *)_rand();
|
|
*(float *)((char *)v5 + 66) = (1.0
|
|
- ((double)(signed int)v8 * 0.00003051850947599719
|
|
+ (double)(signed int)v8 * 0.00003051850947599719))
|
|
* (a4
|
|
* a5)
|
|
+ a4;
|
|
}
|
|
|
|
//----- (0101B43A) --------------------------------------------------------
|
|
double distance_to_flipper(struct ray_type *a1, struct ray_type *a2)
|
|
{
|
|
signed int v2; // edi
|
|
double v3; // st7
|
|
double v4; // st7
|
|
double v5; // st7
|
|
double v6; // st7
|
|
float *v7; // eax
|
|
double v8; // st7
|
|
DWORD *v10; // esi
|
|
DWORD *v11; // esi
|
|
float v12; // [esp+8h] [ebp-4h]
|
|
|
|
v12 = 1000000000.0;
|
|
v2 = -1;
|
|
v3 = ray_intersect_line((float *)a1, (float *)&lineA);
|
|
if ( v3 < 1000000000.0 )
|
|
{
|
|
v12 = v3;
|
|
v2 = 0;
|
|
}
|
|
v4 = ray_intersect_circle((float *)a1, (float *)&circlebase);
|
|
if ( v4 < v12 )
|
|
{
|
|
v12 = v4;
|
|
v2 = 2;
|
|
}
|
|
v5 = ray_intersect_circle((float *)a1, (float *)&circleT1);
|
|
if ( v5 < v12 )
|
|
{
|
|
v12 = v5;
|
|
v2 = 3;
|
|
}
|
|
v6 = ray_intersect_line((float *)a1, (float *)&lineB);
|
|
if ( v6 < v12 )
|
|
{
|
|
v12 = v6;
|
|
v2 = 1;
|
|
}
|
|
if ( !a2 || v12 >= 1000000000.0 )
|
|
return v12;
|
|
if ( v2 != -1 )
|
|
{
|
|
if ( v2 )
|
|
{
|
|
if ( v2 != 1 )
|
|
{
|
|
if ( v2 == 2 )
|
|
{
|
|
v7 = (float *)((char *)a2 + 12);
|
|
*(float *)a2 = v12 * *((float *)a1 + 3) + *(float *)a1;
|
|
*((float *)a2 + 1) = v12 * *((float *)a1 + 4) + *((float *)a1 + 1);
|
|
*((float *)a2 + 3) = *(float *)a2 - circlebase;
|
|
v8 = *((float *)a2 + 1) - *(float *)&dword_1025664;
|
|
}
|
|
else
|
|
{
|
|
if ( v2 != 3 )
|
|
return v12;
|
|
v7 = (float *)((char *)a2 + 12);
|
|
*(float *)a2 = v12 * *((float *)a1 + 3) + *(float *)a1;
|
|
*((float *)a2 + 1) = v12 * *((float *)a1 + 4) + *((float *)a1 + 1);
|
|
*((float *)a2 + 3) = *(float *)a2 - circleT1;
|
|
v8 = *((float *)a2 + 1) - *(float *)&dword_1025674;
|
|
}
|
|
*((float *)a2 + 4) = v8;
|
|
normalize_2d(v7);
|
|
return v12;
|
|
}
|
|
*((DWORD *)a2 + 3) = lineB;
|
|
*((DWORD *)a2 + 4) = *((DWORD *)&lineB + 1);
|
|
*((DWORD *)a2 + 5) = *((DWORD *)&lineB + 2);
|
|
v10 = &unk_10256E4;
|
|
}
|
|
else
|
|
{
|
|
*((DWORD *)a2 + 3) = lineA;
|
|
*((DWORD *)a2 + 4) = *((DWORD *)&lineA + 1);
|
|
*((DWORD *)a2 + 5) = *((DWORD *)&lineA + 2);
|
|
v10 = &unk_10256A4;
|
|
}
|
|
*(DWORD *)a2 = *v10;
|
|
v11 = v10 + 1;
|
|
*((DWORD *)a2 + 1) = *v11;
|
|
*((DWORD *)a2 + 2) = v11[1];
|
|
return v12;
|
|
}
|
|
return 1000000000.0;
|
|
}
|
|
// 1025664: using guessed type int dword_1025664;
|
|
// 1025674: using guessed type int dword_1025674;
|
|
|
|
//----- (0101CBB1) --------------------------------------------------------
|
|
void RotatePt(struct vector_type *a1, float a2, float a3, struct vector_type *a4)
|
|
{
|
|
double v4; // st7
|
|
double v5; // st6
|
|
|
|
v4 = *(float *)a1 - *(float *)a4;
|
|
v5 = *((float *)a1 + 1) - *((float *)a4 + 1);
|
|
*(float *)a1 = v4 * a3 - v5 * a2 + *(float *)a4;
|
|
*((float *)a1 + 1) = v4 * a2 + v5 * a3 + *((float *)a4 + 1);
|
|
}
|
|
|
|
//----- (0101CBF5) --------------------------------------------------------
|
|
long double Distance(struct vector_type *a1, struct vector_type *a2)
|
|
{
|
|
double v2; // st7
|
|
double v3; // st6
|
|
|
|
v2 = *(float *)a1 - *(float *)a2;
|
|
v3 = *((float *)a1 + 1) - *((float *)a2 + 1);
|
|
return sqrt(v3 * v3 + v2 * v2);
|
|
}
|
|
|
|
//----- (0101CC23) --------------------------------------------------------
|
|
double Distance_Squared(float a1, float a2, int a3, float a4, float a5, int a6)
|
|
{
|
|
return (a2 - a5) * (a2 - a5) + (a1 - a4) * (a1 - a4);
|
|
}
|
|
|
|
//----- (0101CC4B) --------------------------------------------------------
|
|
double DotProduct(const struct vector_type *a1, const struct vector_type *a2)
|
|
{
|
|
return *((float *)a1 + 1) * *((float *)a2 + 1) + *(float *)a1 * *(float *)a2;
|
|
}
|
|
|
|
//----- (0101CC6B) --------------------------------------------------------
|
|
void SinCos(float a1, float *a2, float *a3)
|
|
{
|
|
*a2 = sin(a1);
|
|
*a3 = cos(a1);
|
|
}
|