void CTLSprite::Render(Fvector &pos, u32 color, float radius, float angle) { FVF::TL P; P.transform (pos, Device.mFullTransform); if (P.p.w<=0) return; float cx = Device._x2real(P.p.x); float cy = Device._y2real(P.p.y); float sz = (UI->GetRenderWidth()*radius)/P.p.w; if (sz<1.5f) return; // Rotation float _sin1=_sin(angle),_cos1=_cos(angle); float _sin2=_sin(angle+PI_DIV_2),_cos2=_cos(angle+PI_DIV_2); mesh.m[0].p.x = cx+sz*_sin1; mesh.m[0].p.y = cy+sz*_cos1; mesh.m[1].p.x = cx-sz*_sin2; mesh.m[1].p.y = cy-sz*_cos2; mesh.m[2].p.x = cx+sz*_sin2; mesh.m[2].p.y = cy+sz*_cos2; mesh.m[3].p.x = cx-sz*_sin1; mesh.m[3].p.y = cy-sz*_cos1; mesh.setdepth (P.p.z, P.p.w); mesh.setcolor (color); DU_impl.DrawPrimitiveTL(D3DPT_TRIANGLESTRIP,2,(FVF::TL*)&mesh,4,false,false); }
void CDrawUtilities::DrawSpotLight(const Fvector& p, const Fvector& d, float range, float phi, u32 clr) { Fmatrix T; Fvector p1; float H,P; float da = PI_MUL_2/LINE_DIVISION; float b = range*_cos(PI_DIV_2-phi/2); float a = range*_sin(PI_DIV_2-phi/2); d.getHP (H,P); T.setHPB (H,P,0); T.translate_over(p); _VertexStream* Stream = &RCache.Vertex; u32 vBase; FVF::L* pv = (FVF::L*)Stream->Lock(LINE_DIVISION*2+2,vs_L->vb_stride,vBase); for (float angle=0; angle<PI_MUL_2; angle+=da){ float _sa =_sin(angle); float _ca =_cos(angle); p1.x = b * _ca; p1.y = b * _sa; p1.z = a; T.transform_tiny(p1); // fill VB pv->set (p,clr); pv++; pv->set (p1,clr); pv++; } p1.mad (p,d,range); pv->set (p,clr); pv++; pv->set (p1,clr); pv++; Stream->Unlock (LINE_DIVISION*2+2,vs_L->vb_stride); // and Render it as triangle list DU_DRAW_DP (D3DPT_LINELIST,vs_L,vBase,LINE_DIVISION+1); }
void CDetailManager::hw_Render() { // Render-prepare Fvector4 dir1,dir2; float tm_rot1 = (PI_MUL_2*Device.fTimeGlobal/swing_current.rot1); float tm_rot2 = (PI_MUL_2*Device.fTimeGlobal/swing_current.rot2); dir1.set (_sin(tm_rot1),0,_cos(tm_rot1),0).normalize().mul(swing_current.amp1); dir2.set (_sin(tm_rot2),0,_cos(tm_rot2),0).normalize().mul(swing_current.amp2); // Setup geometry and DMA RCache.set_Geometry (hw_Geom); // Wave0 float scale = 1.f/float(quant); Fvector4 wave; wave.set (1.f/5.f, 1.f/7.f, 1.f/3.f, Device.fTimeGlobal*swing_current.speed); RCache.set_c (&*hwc_consts, scale, scale, ps_r__Detail_l_aniso, ps_r__Detail_l_ambient); // consts RCache.set_c (&*hwc_wave, wave.div(PI_MUL_2)); // wave RCache.set_c (&*hwc_wind, dir1); // wind-dir hw_Render_dump (&*hwc_array, 1, 0, c_hdr ); // Wave1 wave.set (1.f/3.f, 1.f/7.f, 1.f/5.f, Device.fTimeGlobal*swing_current.speed); RCache.set_c (&*hwc_wave, wave.div(PI_MUL_2)); // wave RCache.set_c (&*hwc_wind, dir2); // wind-dir hw_Render_dump (&*hwc_array, 2, 0, c_hdr ); // Still RCache.set_c (&*hwc_s_consts,scale, scale, scale, 1.f); RCache.set_c (&*hwc_s_xform, Device.mFullTransform); hw_Render_dump (&*hwc_s_array, 0, 1, c_hdr ); }
//////////////////////////////////////////////////////////////////////////////////////////////// // Функция ConeSphereIntersection // Пересечение конуса (не ограниченного) со сферой // Необходима для определения пересечения копыта плоти с баунд-сферой крысы // Параметры: ConeVertex - вершина конуса, ConeAngle - угол конуса (между поверхностью и высотой) // ConeDir - направление конуса, SphereCenter - центр сферы, SphereRadius - радиус сферы bool CAI_Flesh::ConeSphereIntersection(Fvector ConeVertex, float ConeAngle, Fvector ConeDir, Fvector SphereCenter, float SphereRadius) { float fInvSin = 1.0f/_sin(ConeAngle); float fCosSqr = _cos(ConeAngle)*_cos(ConeAngle); Fvector kCmV; kCmV.sub(SphereCenter,ConeVertex); Fvector kD = kCmV; Fvector tempV = ConeDir; tempV.mul (SphereRadius* fInvSin); kD.add (tempV); float fDSqrLen = kD.square_magnitude(); float fE = kD.dotproduct(ConeDir); if ( fE > 0.0f && fE*fE >= fDSqrLen*fCosSqr ) { float fSinSqr = _sin(ConeAngle)*_sin(ConeAngle); fDSqrLen = kCmV.square_magnitude(); fE = -kCmV.dotproduct(ConeDir); if ( fE > 0.0f && fE*fE >= fDSqrLen*fSinSqr ) { float fRSqr = SphereRadius*SphereRadius; return fDSqrLen <= fRSqr; } else return true; } return false; }
void calculate () { dwFrame = Device.dwFrame; // Calc wind-vector3, scale float tm_rot = PI_MUL_2*Device.fTimeGlobal/ps_r__Tree_w_rot; //wind.set (_sin(tm_rot),0,_cos(tm_rot),0); wind.normalize (); wind.mul(ps_r__Tree_w_amp); // dir1*amplitude #ifdef TREE_WIND_EFFECT CEnvDescriptor& E = *g_pGamePersistent->Environment().CurrentEnv; float fValue = E.m_fTreeAmplitudeIntensity; wind.set(_sin(tm_rot), 0, _cos(tm_rot), 0); wind.normalize(); #if RENDER!=R_R1 wind.mul(fValue); // dir1*amplitude #else // R1 wind.mul(ps_r__Tree_w_amp); // dir1*amplitude #endif //-RENDER!=R_R1 #else //!TREE_WIND_EFFECT wind.set(_sin(tm_rot), 0, _cos(tm_rot), 0); wind.normalize(); wind.mul(ps_r__Tree_w_amp); // dir1*amplitude #endif //-TREE_WIND_EFFECT scale = 1.f/float(FTreeVisual_quant); // setup constants wave.set (ps_r__Tree_Wave.x, ps_r__Tree_Wave.y, ps_r__Tree_Wave.z, Device.fTimeGlobal*ps_r__Tree_w_speed); // wave wave.div (PI_MUL_2); }
double cos (double phi) { long periode = floor (phi / PIBY2 + 0.125); double reduced = phi - PIBY2 * periode; switch (periode&3) { default: return _cos (reduced); case 1: return -_sin (reduced); case 2: return -_cos (reduced); case 3: return _sin (reduced); } }
void rotation_(float x, float y, const float angle, float& x_, float& y_) { float _sc = _cos(angle); float _sn = _sin(angle); x_= x*_sc+y*_sn; y_= y*_sc-x*_sn; }
// // Generate the derivative of a rotation matrix about a principal axis // void rotation_principal_axis_to_deriv_matrix(char axis, float angle, Matrix m) { float cos_a, sin_a; ZeroMemory(m,sizeof(Matrix)); cos_a = _cos(angle); sin_a = _sin(angle); switch (axis) { case 'x': case 'X': m[1][1] = -sin_a; m[2][1] = -cos_a; m[1][2] = cos_a; m[2][2] = -sin_a; break; case 'y': case 'Y': m[0][0] = -sin_a; m[2][0] = cos_a; m[0][2] = -cos_a; m[2][2] = -sin_a; break; default: m[0][0] = -sin_a; m[1][0] = -cos_a; m[0][1] = cos_a; m[1][1] = -sin_a; break; } }
void rotation_principal_axis_to_matrix(char axis, float angle, Matrix m) { float cos_a, sin_a; cpmatrix(m, idmat); cos_a = _cos(angle); sin_a = _sin(angle); switch (axis) { case 'x': case 'X': m[1][1] = cos_a; m[2][1] = -sin_a; m[1][2] = sin_a; m[2][2] = cos_a; break; case 'y': case 'Y': m[0][0] = cos_a; m[2][0] = sin_a; m[0][2] = -sin_a; m[2][2] = cos_a; break; default: m[0][0] = cos_a; m[1][0] = -sin_a; m[0][1] = sin_a; m[1][1] = cos_a; break; } }
// // Construct a general rotation matrix given an angle and axis // void rotation_axis_to_matrix(float axis[3], float angle, Matrix R) { float cos_a, sin_a; float s1, s2, s3; cos_a = _cos(angle); sin_a = _sin(angle); // Assume axis is normalized #if 0 // float normal[3]; // cpvector(normal,axis); // unitize(normal); // s1 = normal[0]; // s2 = normal[1]; // s3 = normal[2]; #else s1 = axis[0]; s2 = axis[1]; s3 = axis[2]; #endif float s1s1 = s1*s1; float s1s2 = s1*s2; float s1s3 = s1*s3; float s2s2 = s2*s2; float s2s3 = s2*s3; float s3s3 = s3*s3; float cos_as1s2 = cos_a * s1s2; float cos_as1s3 = cos_a * s1s3; float cos_as2s3 = cos_a * s2s3; float s1sin_a = s1*sin_a; float s2sin_a = s2*sin_a; float s3sin_a = s3*sin_a; float *r = (float *)R; *r++ = s1s1 + cos_a * (1 - s1s1); *r++ = s1s2 - cos_as1s2 + s3sin_a; *r++ = s1s3 - cos_as1s3 - s2sin_a; *r++ = 0; *r++ = s1s2 - cos_as1s2 - s3sin_a; *r++ = s2s2 + cos_a * (1 - s2s2); *r++ = s2s3 - cos_as2s3 + s1sin_a; *r++ = 0; *r++ = s1s3 - cos_as1s3 + s2sin_a; *r++ = s2s3 - cos_as2s3 - s1sin_a; *r++ = s3s3 + cos_a * (1 - s3s3); *r++ = 0; *r++ = 0; *r++ = 0; *r++ = 0; *r = 1; }
EAPI void eina_matrix3_rotate(Eina_Matrix3 *m, double rad) { double c, s; #if 0 c = cosf(rad); s = sinf(rad); #else /* normalize the angle between -pi,pi */ rad = fmod(rad + M_PI, 2 * M_PI) - M_PI; c = _cos(rad); s = _sin(rad); #endif Eina_Matrix3 tmp; MATRIX_XX(&tmp) = c; MATRIX_XY(&tmp) = -s; MATRIX_XZ(&tmp) = 0; MATRIX_YX(&tmp) = s; MATRIX_YY(&tmp) = c; MATRIX_YZ(&tmp) = 0; MATRIX_ZX(&tmp) = 0; MATRIX_ZY(&tmp) = 0; MATRIX_ZZ(&tmp) = 1; eina_matrix3_compose(m, &tmp, m); }
void CDetailManager::hw_Render() { // Render-prepare // Update timer // Can't use RDEVICE.fTimeDelta since it is smoothed! Don't know why, but smoothed value looks more choppy! float fDelta = RDEVICE.fTimeGlobal-m_global_time_old; if ( (fDelta<0) || (fDelta>1)) fDelta = 0.03; m_global_time_old = RDEVICE.fTimeGlobal; m_time_rot_1 += (PI_MUL_2*fDelta/swing_current.rot1); m_time_rot_2 += (PI_MUL_2*fDelta/swing_current.rot2); m_time_pos += fDelta*swing_current.speed; //float tm_rot1 = (PI_MUL_2*RDEVICE.fTimeGlobal/swing_current.rot1); //float tm_rot2 = (PI_MUL_2*RDEVICE.fTimeGlobal/swing_current.rot2); float tm_rot1 = m_time_rot_1; float tm_rot2 = m_time_rot_2; Fvector4 dir1,dir2; dir1.set (_sin(tm_rot1),0,_cos(tm_rot1),0).normalize().mul(swing_current.amp1); dir2.set (_sin(tm_rot2),0,_cos(tm_rot2),0).normalize().mul(swing_current.amp2); // Setup geometry and DMA RCache.set_Geometry (hw_Geom); // Wave0 float scale = 1.f/float(quant); Fvector4 wave; //wave.set (1.f/5.f, 1.f/7.f, 1.f/3.f, RDEVICE.fTimeGlobal*swing_current.speed); wave.set (1.f/5.f, 1.f/7.f, 1.f/3.f, m_time_pos); RCache.set_c (&*hwc_consts, scale, scale, ps_r__Detail_l_aniso, ps_r__Detail_l_ambient); // consts RCache.set_c (&*hwc_wave, wave.div(PI_MUL_2)); // wave RCache.set_c (&*hwc_wind, dir1); // wind-dir hw_Render_dump (&*hwc_array, 1, 0, c_hdr ); // Wave1 //wave.set (1.f/3.f, 1.f/7.f, 1.f/5.f, RDEVICE.fTimeGlobal*swing_current.speed); wave.set (1.f/3.f, 1.f/7.f, 1.f/5.f, m_time_pos); RCache.set_c (&*hwc_wave, wave.div(PI_MUL_2)); // wave RCache.set_c (&*hwc_wind, dir2); // wind-dir hw_Render_dump (&*hwc_array, 2, 0, c_hdr ); // Still RCache.set_c (&*hwc_s_consts,scale, scale, scale, 1.f); RCache.set_c (&*hwc_s_xform, RDEVICE.mFullTransform); hw_Render_dump (&*hwc_s_array, 0, 1, c_hdr ); }
float get_circle_equation(const float ee[3], const float axis[3], const float pos_axis[3], float upper_len, float lower_len, float c[3], float u[3], float v[3], float n[3]) { float wn = norm((float *)ee); float radius; cpvector(n, ee); unitize(n); // Use law of cosines to get angle between first spherical joint // and revolute joint float alpha; if (!law_of_cosines(wn, upper_len, lower_len, alpha)) return 0; // center of circle (origin is location of first S joint) vecscalarmult(c, n, _cos(alpha) * upper_len); radius = _sin(alpha) * upper_len; float temp[3]; // // A little kludgy. If the goal is behind the joint instead // of in front of it, we reverse the angle measurement by // inverting the normal vector // if (DOT(n,pos_axis) < 0.0) vecscalarmult(n,n,-1.0); vecscalarmult(temp, n, DOT(axis,n)); vecsub(u, (float *)axis, temp); unitize(u); crossproduct(v, n, u); #if 0 printf("Circle equation\n"); printf("c = [%lf,%lf,%lf]\n", c[0], c[1], c[2]); printf("u = [%lf,%lf,%lf]\n", u[0], u[1], u[2]); printf("v = [%lf,%lf,%lf]\n", v[0], v[1], v[2]); printf("n = [%lf,%lf,%lf]\n", n[0], n[1], n[2]); printf("r = %lf\n", radius); #endif return radius; }
void axistoq(Quaternion q,float angle,float axis[]) { float f; f = (float)_sin(angle/2); q[0] = (float)_cos(angle/2); q[1] = axis[0] * f; q[2] = axis[1] * f; q[3] = axis[2] * f; }
void CDrawUtilities::DrawFlag(const Fvector& p, float heading, float height, float sz, float sz_fl, u32 clr, BOOL bDrawEntity){ // fill VB _VertexStream* Stream = &RCache.Vertex; u32 vBase; FVF::L* pv = (FVF::L*)Stream->Lock(2,vs_L->vb_stride,vBase); pv->set (p,clr); pv++; pv->set (p.x,p.y+height,p.z,clr); pv++; Stream->Unlock (2,vs_L->vb_stride); // and Render it as triangle list DU_DRAW_DP (D3DPT_LINELIST,vs_L,vBase,1); if (bDrawEntity){ // fill VB float rx = _sin(heading); float rz = _cos(heading); FVF::L* pv = (FVF::L*)Stream->Lock(6,vs_L->vb_stride,vBase); sz *= 0.8f; pv->set (p.x,p.y+height,p.z,clr); pv++; pv->set (p.x+rx*sz,p.y+height,p.z+rz*sz,clr); pv++; sz *= 0.5f; pv->set (p.x,p.y+height*(1.f-sz_fl*.5f),p.z,clr); pv++; pv->set (p.x+rx*sz*0.6f,p.y+height*(1.f-sz_fl*.5f),p.z+rz*sz*0.75f,clr); pv++; pv->set (p.x,p.y+height*(1.f-sz_fl),p.z,clr); pv++; pv->set (p.x+rx*sz,p.y+height*(1.f-sz_fl),p.z+rz*sz,clr); pv++; Stream->Unlock (6,vs_L->vb_stride); // and Render it as line list DU_DRAW_DP (D3DPT_LINELIST,vs_L,vBase,3); }else{ // fill VB FVF::L* pv = (FVF::L*)Stream->Lock(6,vs_L->vb_stride,vBase); pv->set (p.x,p.y+height*(1.f-sz_fl),p.z,clr); pv++; pv->set (p.x,p.y+height,p.z,clr); pv++; pv->set (p.x+_sin(heading)*sz,((pv-2)->p.y+(pv-1)->p.y)/2,p.z+_cos(heading)*sz,clr); pv++; pv->set (*(pv-3)); pv++; pv->set (*(pv-2)); pv++; pv->set (*(pv-4)); pv++; Stream->Unlock (6,vs_L->vb_stride); // and Render it as triangle list DU_DRAW_DP (D3DPT_TRIANGLELIST,vs_L,vBase,2); } }
/* evaluates cos x - 1 for |x| <= pi. This function may underflow, which is indicated by the return value 0 */ char _cosminus1( floatnum x, int digits) { float_abs(x); if (float_cmp(x, &cPiDiv4) <= 0) return _cosminus1ltPiDiv4(x, digits); _cos(x, digits); float_sub(x, x, &c1, digits); return 1; }
/* Given an axis and angle, compute quaternion. */ quat & axis_to_quat(quat& q, const vec3& a, const nv_scalar phi) { vec3 tmp(a.x, a.y, a.z); normalize(tmp); nv_scalar s = _sin(phi/nv_two); q.x = s * tmp.x; q.y = s * tmp.y; q.z = s * tmp.z; q.w = _cos(phi/nv_two); return q; }
char float_cos( floatnum x, int digits) { if (!chckmathparam(x, digits)) return 0; if (float_getexponent(x) >= DECPRECISION - 1 || !_trigreduce(x, digits)) return _seterror(x, EvalUnstable); _cos(x, digits); return 1; }
BOOL CDeflector::OA_Place (Face *owner) { // It is not correct to rely solely on normal-split-angle for lmaps - imagine smooth sphere float cosa = normal.dotproduct(owner->N); if (cosa<_cos(deg2rad(g_params.m_sm_angle+1))) return FALSE; UVtri T; T.owner = owner; owner->pDeflector = this; UVpolys.push_back (T); return TRUE; }
void __fastcall__ tgi_arc (int x, int y, unsigned char rx, unsigned char ry, unsigned sa, unsigned ea) /* Draw an ellipse arc with center at x/y and radii rx/ry using the current ** drawing color. The arc covers the angle between sa and ea (startangle and ** endangle), which must be in the range 0..360 (otherwise the function may ** bevave unextectedly). */ { int x1, y1, x2, y2; unsigned char inc; unsigned char done = 0; /* Bail out if there's nothing to do */ if (sa > ea) { return; } /* Determine the number of segments to use. This may be refined ... */ if (rx + ry >= 25) { inc = 12; } else { inc = 24; } /* Calculate the start coords */ x1 = x + tgi_imulround (rx, _cos (sa)); y1 = y - tgi_imulround (ry, _sin (sa)); do { sa += inc; if (sa >= ea) { sa = ea; done = 1; } x2 = x + tgi_imulround (rx, _cos (sa)); y2 = y - tgi_imulround (ry, _sin (sa)); tgi_line (x1, y1, x2, y2); x1 = x2; y1 = y2; } while (!done); }
quat::quat(const vec3& axis, nv_scalar angle) { nv_scalar len = axis.norm(); if (len) { nv_scalar invLen = 1 / len; nv_scalar angle2 = angle / 2; nv_scalar scale = _sin(angle2) * invLen; x = scale * axis[0]; y = scale * axis[1]; z = scale * axis[2]; w = _cos(angle2); } }
void calculate () { dwFrame = Device.dwFrame; // Calc wind-vector3, scale float tm_rot = PI_MUL_2*Device.fTimeGlobal/ps_r__Tree_w_rot; wind.set (_sin(tm_rot),0,_cos(tm_rot),0); wind.normalize (); wind.mul(ps_r__Tree_w_amp); // dir1*amplitude scale = 1.f/float(FTreeVisual_quant); // setup constants wave.set (ps_r__Tree_Wave.x, ps_r__Tree_Wave.y, ps_r__Tree_Wave.z, Device.fTimeGlobal*ps_r__Tree_w_speed); // wave wave.div (PI_MUL_2); }
void random_dir(Fvector& tgt_dir, const Fvector& src_dir, float dispersion) { float sigma = dispersion/3.f; float alpha = clampr (_nrand(sigma),-dispersion,dispersion); float theta = Random.randF (0,PI); float r = tan (alpha); Fvector U,V,T; Fvector::generate_orthonormal_basis (src_dir,U,V); U.mul (r*_sin(theta)); V.mul (r*_cos(theta)); T.add (U,V); tgt_dir.add (src_dir,T).normalize(); }
static void _set_plane_x_y(struct atc_plane *plane, int time_dif) { int aux = ((int)(_cos(plane->heading) * plane->speed * time_dif + plane->x ) ) % MAX_LEN; if( aux < 0 ){ aux = MAX_LEN + aux; } plane->x = aux; aux = (int)(_sin(plane->heading) * plane->speed * time_dif + plane->y ) % MAX_HEIGHT; if( aux < 0 ){ aux = MAX_HEIGHT + aux; } plane->y = aux; }
void bonesBone::Turn(u32 dt) { float PI_DIV_2m = 8 * PI_DIV_6 / 3; float PIm = PI_DIV_2m * 2; float cur_speed = params.r_speed * _cos(PI_DIV_2m - PIm * _abs(params.target_yaw - params.cur_yaw) / params.dist_yaw); float dy; dy = cur_speed * dt / 1000; // учитываем милисек и радианную меры if (_abs(params.target_yaw - params.cur_yaw) < dy) params.cur_yaw = params.target_yaw; else params.cur_yaw += ((params.target_yaw > params.cur_yaw) ? dy : -dy); }
void CDrawUtilities::OnDeviceCreate() { Device.seqRender.Add (this,REG_PRIORITY_LOW-1000); m_SolidBox.CreateFromData (D3DPT_TRIANGLELIST,DU_BOX_NUMFACES, D3DFVF_XYZ|D3DFVF_DIFFUSE,du_box_vertices, DU_BOX_NUMVERTEX, du_box_faces, DU_BOX_NUMFACES*3); m_SolidCone.CreateFromData (D3DPT_TRIANGLELIST,DU_CONE_NUMFACES, D3DFVF_XYZ|D3DFVF_DIFFUSE,du_cone_vertices, DU_CONE_NUMVERTEX, du_cone_faces, DU_CONE_NUMFACES*3); m_SolidSphere.CreateFromData (D3DPT_TRIANGLELIST,DU_SPHERE_NUMFACES, D3DFVF_XYZ|D3DFVF_DIFFUSE,du_sphere_vertices, DU_SPHERE_NUMVERTEX, du_sphere_faces, DU_SPHERE_NUMFACES*3); m_SolidSpherePart.CreateFromData(D3DPT_TRIANGLELIST,DU_SPHERE_PART_NUMFACES,D3DFVF_XYZ|D3DFVF_DIFFUSE,du_sphere_part_vertices, DU_SPHERE_PART_NUMVERTEX, du_sphere_part_faces, DU_SPHERE_PART_NUMFACES*3); m_SolidCylinder.CreateFromData (D3DPT_TRIANGLELIST,DU_CYLINDER_NUMFACES, D3DFVF_XYZ|D3DFVF_DIFFUSE,du_cylinder_vertices, DU_CYLINDER_NUMVERTEX, du_cylinder_faces, DU_CYLINDER_NUMFACES*3); m_WireBox.CreateFromData (D3DPT_LINELIST, DU_BOX_NUMLINES, D3DFVF_XYZ|D3DFVF_DIFFUSE,du_box_vertices, DU_BOX_NUMVERTEX, du_box_lines, DU_BOX_NUMLINES*2); m_WireCone.CreateFromData (D3DPT_LINELIST, DU_CONE_NUMLINES, D3DFVF_XYZ|D3DFVF_DIFFUSE,du_cone_vertices, DU_CONE_NUMVERTEX, du_cone_lines, DU_CONE_NUMLINES*2); m_WireSphere.CreateFromData (D3DPT_LINELIST, DU_SPHERE_NUMLINES, D3DFVF_XYZ|D3DFVF_DIFFUSE,du_sphere_verticesl, DU_SPHERE_NUMVERTEXL, du_sphere_lines, DU_SPHERE_NUMLINES*2); m_WireSpherePart.CreateFromData (D3DPT_LINELIST, DU_SPHERE_PART_NUMLINES,D3DFVF_XYZ|D3DFVF_DIFFUSE,du_sphere_part_vertices, DU_SPHERE_PART_NUMVERTEX, du_sphere_part_lines, DU_SPHERE_PART_NUMLINES*2); m_WireCylinder.CreateFromData (D3DPT_LINELIST, DU_CYLINDER_NUMLINES, D3DFVF_XYZ|D3DFVF_DIFFUSE,du_cylinder_vertices, DU_CYLINDER_NUMVERTEX, du_cylinder_lines, DU_CYLINDER_NUMLINES*2); for(int i=0;i<LINE_DIVISION;i++){ float angle = M_PI * 2.f * (i / (float)LINE_DIVISION); float _sa=_sin(angle), _ca=_cos(angle); circledef1[i].x = _ca; circledef1[i].y = _sa; circledef1[i].z = 0; circledef2[i].x = 0; circledef2[i].y = _ca; circledef2[i].z = _sa; circledef3[i].x = _sa; circledef3[i].y = 0; circledef3[i].z = _ca; } // initialize identity box Fbox bb; bb.set(-0.505f,-0.505f,-0.505f, 0.505f,0.505f,0.505f); for (i=0; i<8; i++){ Fvector S; Fvector p; bb.getpoint(i,p); S.set((float)SIGN(p.x),(float)SIGN(p.y),(float)SIGN(p.z)); boxvert[i*6+0].set(p); boxvert[i*6+1].set(p.x-S.x*0.25f,p.y,p.z); boxvert[i*6+2].set(p); boxvert[i*6+3].set(p.x,p.y-S.y*0.25f,p.z); boxvert[i*6+4].set(p); boxvert[i*6+5].set(p.x,p.y,p.z-S.z*0.25f); } // create render stream vs_L.create (FVF::F_L,RCache.Vertex.Buffer(),RCache.Index.Buffer()); vs_TL.create (FVF::F_TL,RCache.Vertex.Buffer(),RCache.Index.Buffer()); vs_LIT.create (FVF::F_LIT,RCache.Vertex.Buffer(),RCache.Index.Buffer()); m_Font = new CGameFont("stat_font"); }
void setup_obliquity( JULIAN *ptr ) { double temp, eps; temp = ( -1.81e-3 * ptr->jd_cent ) + 5.9e-3; temp *= ptr->jd_cent; temp += 4.6845e1; temp *= ptr->jd_cent; eps = 2.345229444e1 - ( temp / 3600.0 ); obliquity = eps; eps = d2r( eps ); sin_obliquity = _sin( eps ); cos_obliquity = _cos( eps ); tan_obliquity = _tan( eps ); }
/*Returns 0 if plane crashed or landed, else returns 1, also calculates plane position and modifies it on the plane tuple*/ int calculate_position(struct atc_plane* plane, time_t new_time) { int time_dif = new_time - plane->time; int aux = (int)(_cos(plane->elevation) * plane->speed * time_dif + plane->z ) ; if( aux < 0 ){ int time_of_crash = new_time - plane->time - ( (aux*(-1))/(_sin(plane->elevation) * plane->speed) ); plane->time = time_of_crash; _set_plane_x_y(plane, time_of_crash); _crashed_or_landed(plane); return 0; } else{ plane->z = aux; _set_plane_x_y(plane, time_dif); return 1; } }
inline void evalcircle(const float c[3], const float u[3], const float v[3], float radius, float angle, float p[3]) { // p = o + r*cos(f)*u + r*sin(f)*v float temp[3]; cpvector(p, c); vecscalarmult(temp, (float*)u, radius*_cos(angle)); vecadd(p, p, temp); vecscalarmult(temp, (float*)v, radius*_sin(angle)); vecadd(p, p, temp); }
void light::spatial_move () { switch(flags.type) { case IRender_Light::REFLECTED : case IRender_Light::POINT : { spatial.sphere.set (position, range); } break; case IRender_Light::SPOT : { // minimal enclosing sphere around cone VERIFY2 (cone < deg2rad(121.f), "Too large light-cone angle. Maybe you have passed it in 'degrees'?"); if (cone>=PI_DIV_2) { // obtused-angled spatial.sphere.P.mad (position,direction,range); spatial.sphere.R = range * tanf(cone/2.f); } else { // acute-angled spatial.sphere.R = range / (2.f * _sqr(_cos(cone/2.f))); spatial.sphere.P.mad (position,direction,spatial.sphere.R); } } break; case IRender_Light::OMNIPART : { // is it optimal? seems to be... //spatial.sphere.P.mad (position,direction,range); //spatial.sphere.R = range; // This is optimal. const float fSphereR = range*RSQRTDIV2; spatial.sphere.P.mad (position,direction,fSphereR); spatial.sphere.R = fSphereR; } break; } // update spatial DB ISpatial::spatial_move (); #if (RENDER==R_R2) || (RENDER==R_R3) if (flags.bActive) gi_generate (); svis.invalidate (); #endif }