void NgammaT::calcVelScale(){ for (int i = 0; i < 3; i++ ) { for (int j = 0; j < 3; j++ ) { vScale(i, j) = eta(i, j); if (i == j) { vScale(i, j) += thermostat.first; } } } }
Intersect Sphere::intersect(Ray r) { Intersect::Intersect ret = *new Intersect::Intersect(); std::vector<float> d = r.getDir(); std::vector<float> e = r.getEye(); std::vector<float> eminusp(3); eminusp[0] = e[0] - position[0]; eminusp[1] = e[1] - position[1]; eminusp[2] = e[2] - position[2]; float ddotd = d[0]*d[0]+d[1]*d[1]+d[2]*d[2]; float empdot = eminusp[0]*eminusp[0] + eminusp[1]*eminusp[1] + eminusp[2]*eminusp[2]; float ddoteminusp = d[0]*eminusp[0] + d[1]*eminusp[1] + d[2]*eminusp[2]; float discriminant = sqrt(ddoteminusp * ddoteminusp - ddotd*(empdot - radius*radius)); if (discriminant >= 0) { ret.setHit(true); float scalar = -1.0f; float * scale = &scalar; std::vector<float> scaled(3); scaled = vScale(-1, d); //scaled[0] = d[0]*(-1); //scaled[1] = d[1]*(-1); //scaled[2] = d[2]*(-1); float sdotemp = scaled[0]*eminusp[0] + scaled[1]*eminusp[1] + scaled[2]*eminusp[2]; ret.setPoint(r.project((sdotemp+discriminant)/ddotd)); } return ret; }
void CBodyFX::CreateMarker(LTVector & vPos, LTBOOL bSame) { if (!m_pClientDE || !g_pGameClientShell || !m_hServerObject) return; if (!bSame) return; ObjectCreateStruct createStruct; INIT_OBJECTCREATESTRUCT(createStruct); CString str = g_pClientButeMgr->GetSpecialFXAttributeString("TeamSprite"); LTFLOAT fScaleMult = g_pClientButeMgr->GetSpecialFXAttributeFloat("TeamScale"); LTFLOAT fAlpha = g_pClientButeMgr->GetSpecialFXAttributeFloat("TeamAlpha"); LTVector vScale(1.0f,1.0f,1.0f); VEC_MULSCALAR(vScale, vScale, fScaleMult); SAFE_STRCPY(createStruct.m_Filename, (char *)(LPCSTR)str); createStruct.m_ObjectType = OT_SPRITE; createStruct.m_Flags = FLAG_VISIBLE | FLAG_FOGDISABLE | FLAG_NOLIGHT; createStruct.m_Pos = vPos; m_hMarker = m_pClientDE->CreateObject(&createStruct); if (!m_hMarker) return; m_pClientDE->SetObjectScale(m_hMarker, &vScale); LTFLOAT r, g, b, a; m_pClientDE->GetObjectColor(m_hServerObject, &r, &g, &b, &a); m_pClientDE->SetObjectColor(m_hObject, r, g, b, (fAlpha * a)); }
void IMU::orthonormalize(float inputDCM[3][3]) { // Takes 700 us. // Orthogonalize the i and j unit vectors (DCMDraft2 Eqn. 19). errDCM = vDotP(inputDCM[0], inputDCM[1]); vScale(inputDCM[1], -errDCM/2, dDCM[0]); // i vector correction vScale(inputDCM[0], -errDCM/2, dDCM[1]); // j vector correction vAdd(inputDCM[0], dDCM[0], inputDCM[0]); vAdd(inputDCM[1], dDCM[1], inputDCM[1]); // k = i x j vCrossP(inputDCM[0], inputDCM[1], inputDCM[2]); // Normalize all three vectors. vNorm(inputDCM[0]); vNorm(inputDCM[1]); vNorm(inputDCM[2]); }
//-- Cube --------------------------------------------------------------------- // //----------------------------------------------------------------------------- void Renderer::Cube( float nx, float ny, float nz, float x, float y, float z ) { // 4-------5 // /| /| // 0-------1 | // | 7-----|-6 // |/ |/ // 3-------2 PushMatrix(); Translate( ( nx + x ) * 0.5f, ( ny + y ) * 0.5f, ( nz + z ) * 0.5f ); DiffuseUVCubeVertexShader* pShader = NULL; if ( g_envMapSet ) { pShader = &DiffuseUVEnvCubeVertexShader::StaticType; } else { pShader = &DiffuseUVCubeVertexShader::StaticType; } CommitTransforms( pShader ); CommitTextureState(); PopMatrix(); D3DXVECTOR4 vScale( ( x - nx ) * 0.5f, ( y - ny ) * 0.5f, ( z - nz ) * 0.5f, 1.0f ); pShader->SetScale( &vScale ); pShader->SetColour( &g_fColour ); m_pD3DDevice->SetVertexShader( pShader->GetVertexShader() ); m_pD3DDevice->SetVertexDeclaration( g_pPosNormalColUVDeclaration ); m_pD3DDevice->SetStreamSource( 0, g_pCubeVbuffer, 0, sizeof( PosColNormalUVVertex ) ); m_pD3DDevice->SetIndices( g_pCubeIbuffer ); m_pD3DDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, 24, 0, 12 ); m_pD3DDevice->SetStreamSource( 0, NULL, 0, sizeof( PosColNormalUVVertex ) ); m_pD3DDevice->SetIndices( NULL ); } // Cube
Intersect Triangle::intersect(Ray r) { Intersect::Intersect ret = *new Intersect::Intersect(); float a = v1.getX() - v2.getX(); float b = v1.getY() - v2.getY(); float c = v1.getZ() - v2.getZ(); float d = v1.getX() - v3.getX(); float e = v1.getY() - v3.getY(); float f = v1.getZ() - v3.getZ(); float g = r.getDir().at(0); float h = r.getDir().at(1); float i = r.getDir().at(2); float j = v1.getX() - r.getEye().at(0); float k = v1.getY() - r.getEye().at(1); float l = v1.getZ() - r.getEye().at(2); float eiminushf = e*i - h*f; float gfminusdi = g*f - d*i; float dhminuseg = d*h - e*g; float akminusjb = a*k - j*b; float jcminusal = j*c - a*l; float blminuskc = b*l - k*c; float m = a*(eiminushf) + b*(gfminusdi) + c*(dhminuseg); float beta = (j*(eiminushf) + k*(gfminusdi) + l*(dhminuseg))/m; if (beta < 0) {return ret;} float gamma = (i*(akminusjb) + h*(jcminusal) + g*(blminuskc))/m; if (gamma < 0 || beta+gamma > 1) {return ret;} float t = (-1)*(f*(akminusjb) + e*(jcminusal) + d*(blminuskc))/m; std::vector<float> p; std::vector<float> vec1 = v1.toVec(); std::vector<float> vec2 = v2.toVec(); std::vector<float> vec3 = v3.toVec(); std::vector<float> sub1 = vSub(&vec2, &vec1); std::vector<float> sub2 = vSub(&vec3, &vec1); std::vector<float> scaled1 = vScale(&beta, &sub1); std::vector<float> scaled2 = vScale(&gamma, &sub2); std::vector<float> added1 = vAdd(&vec1, &scaled1); p = vAdd(&added1, &scaled2); ret.setPoint(p); return ret; }
void AttachedTorch_cl::InitFunction() { SetVisibleBitmask( 0 ); SetCastShadows(FALSE); m_pShadowCaster = Vision::Game.CreateEntity("VisBaseEntity_cl", GetPosition(), "Data\\Vision\\Samples\\Engine\\Common\\Models\\Warrior\\TorchBottom.MODEL"); m_pShadowCaster->AttachToParent(this); m_pShadowCaster->SetVisibleBitmask( 0 ); m_pShadowCaster->SetCastShadows( FALSE ); hkvVec3 vScale(2.5f, 2.5f, 1.0f); m_pShadowCaster->SetScaling(vScale); }
void SecurityCamera::CreateLight() { // Create the light...and attach it to the camera... ObjectCreateStruct theStruct; INIT_OBJECTCREATESTRUCT(theStruct); theStruct.m_Pos = m_vPos; g_pServerButeMgr->GetSecurityCameraString(SCS_GREEN_LIGHT, theStruct.m_Filename, ARRAY_LEN(theStruct.m_Filename)); theStruct.m_Flags = FLAG_VISIBLE; // | FLAG_GLOWSPRITE; theStruct.m_Flags2 = FLAG2_ADDITIVE; theStruct.m_ObjectType = OT_SPRITE; HCLASS hClass = g_pLTServer->GetClass("BaseClass"); LPBASECLASS pSprite = g_pLTServer->CreateObject(hClass, &theStruct); if (!pSprite) return; m_hLight = pSprite->m_hObject; // Don't eat ticks please... ::SetNextUpdate(m_hLight, UPDATE_NEVER); m_eLightColor = eGreen; LTVector vScale(1, 1, 1); vScale.x = g_pServerButeMgr->GetSecurityCameraFloat("LightScale"); vScale.y = vScale.x; g_pLTServer->ScaleObject(m_hLight, &vScale); // Attach the sprite to the the camera... LTVector vOffset(0, 0, 0); LTRotation rOffset; HATTACHMENT hAttachment; LTRESULT dRes = g_pLTServer->CreateAttachment(m_hObject, m_hLight, "Light", &vOffset, &rOffset, &hAttachment); if (dRes != LT_OK) { g_pLTServer->RemoveObject(m_hLight); m_hLight = LTNULL; return; } }
HOBJECT CDebrisMgr::CreateDebris(uint8 nDebrisId, const LTVector &vPos, uint8 nNumber) { DEBRIS* pDebris = GetDebris(nDebrisId); if (!pDebris) return LTNULL; if (pDebris->nNumModels < 1 || !pDebris->szModel[0][0] || nNumber < 1) return LTNULL; LTVector vScale(1.0f, 1.0f, 1.0f); vScale *= GetRandom(pDebris->fMinScale, pDebris->fMaxScale); // Determine the debris model to use, if nNumber is greater than the maximum // number of models, wrap around to a valid index // int nMaxIndex = pDebris->nNumModels - 1; int nIndex = nNumber-1; while (nIndex > nMaxIndex) { nIndex -= pDebris->nNumModels; } char* pFilename = pDebris->szModel[nIndex]; if (!pFilename) return LTNULL; ObjectCreateStruct createStruct; INIT_OBJECTCREATESTRUCT(createStruct); createStruct.m_ObjectType = OT_MODEL; SAFE_STRCPY(createStruct.m_Filename, pFilename); createStruct.m_Flags = FLAG_VISIBLE; // | FLAG_NOLIGHT; createStruct.m_Pos = vPos; pDebris->blrSkinReader.CopyList(0, createStruct.m_SkinNames[0], MAX_CS_FILENAME_LEN+1); pDebris->blrRenderStyleReader.CopyList(0, createStruct.m_RenderStyleNames[0], MAX_CS_FILENAME_LEN+1); HOBJECT hObj = g_pLTClient->CreateObject(&createStruct); //Add code to set alpha!!!! //TO DO!!! g_pLTClient->SetObjectScale(hObj, &vScale); return hObj; }
void BlMeshBase::LoadMeshNode() { std::string strPath = m_lpThisAB->GetSimulator()->ProjectPath(); std::string strMeshFile; if(m_lpThisRB->IsCollisionObject() && m_lpThisMesh->CollisionMeshType() == "CONVEX") strMeshFile = m_lpThisMesh->ConvexMeshFile(); else strMeshFile = m_lpThisMesh->MeshFile(); std::string strFile = AnimatSim::GetFilePath(strPath, strMeshFile); m_osgBaseMeshNode = GetBlSimulator()->MeshMgr()->LoadMesh(strFile); if(!m_osgBaseMeshNode.valid()) CreateDefaultMesh(); m_osgBaseMeshNode->setName(m_lpThisAB->Name() + "_MeshNodeBase"); //Enforce turning on of lighting for this object. Some meshes have this turned off by default (3DS in particular) //This did not fix the problem. //m_osgBaseMeshNode->getOrCreateStateSet()->setMode( GL_LIGHTING, osg::StateAttribute::OVERRIDE | osg::StateAttribute::ON ); CStdFPoint vScale(1, 1, 1); //If this is a convex collision object then it does not get scaled here. That is done //when it is converted into a collision mesh by the editor. Otherwise use the scaling. if( !(m_lpThisMesh->IsCollisionObject() && m_lpThisMesh->CollisionMeshType() == "CONVEX") ) vScale= m_lpThisMesh->Scale(); osg::Matrix osgScaleMatrix = osg::Matrix::identity(); osgScaleMatrix.makeScale(vScale.x, vScale.y, vScale.z); m_osgMeshNode = new osg::MatrixTransform(osgScaleMatrix); m_osgMeshNode->getOrCreateStateSet()->setMode(GL_NORMALIZE, osg::StateAttribute::ON); m_osgMeshNode->addChild(m_osgBaseMeshNode.get()); m_osgMeshNode->setName(m_lpThisAB->Name() + "_MeshNode"); }
void CProjectileFX::CreateFlare(LTVector & vPos, LTRotation & rRot) { if (!m_pClientDE || !m_hServerObject) return; ObjectCreateStruct createStruct; createStruct.Clear(); if (!m_pProjectileFX->szFlareSprite[0]) return; SAFE_STRCPY(createStruct.m_Filename, m_pProjectileFX->szFlareSprite); createStruct.m_ObjectType = OT_SPRITE; createStruct.m_Flags = FLAG_VISIBLE; VEC_COPY(createStruct.m_Pos, vPos); createStruct.m_Rotation = rRot; m_hFlare = m_pClientDE->CreateObject(&createStruct); if (!m_hFlare) return; LTFLOAT fScale = m_pProjectileFX->fFlareScale; LTVector vScale(fScale, fScale, 1.0f); m_pClientDE->SetObjectScale(m_hFlare, &vScale); }
void vHavokShapeFactory::GetHktDependencies(VResourceSnapshot &snapshot, VisStaticMeshInstance_cl *pMeshInstance) { VASSERT(pMeshInstance != NULL); // Get scale hkvVec3 vScale(hkvNoInitialization); ExtractScaling(pMeshInstance->GetTransform(), vScale); // There is no real way to figure out if a convex or mesh shape is required and the filename is based on that. // So try them both. // Convex version { VStaticString<FS_MAX_PATH> szCachedShapeName(pMeshInstance->GetMesh()->GetFilename()); bool shrinkToFit = false; //how do if true / can it be true for static mesh? vHavokCachedShape::GetConvexShapePath(szCachedShapeName, vScale, shrinkToFit); IVFileInStream *pIn = Vision::File.Open(szCachedShapeName); if (pIn) { snapshot.AddFileDependency(pMeshInstance->GetMesh(), szCachedShapeName, pIn->GetSize() ); pIn->Close(); return; } } // Mesh version { VStaticString<FS_MAX_PATH> szCachedShapeName(pMeshInstance->GetMesh()->GetFilename()); vHavokCachedShape::GetMeshShapePath(szCachedShapeName, vScale, pMeshInstance->GetCollisionBehavior(), pMeshInstance->GetWeldingType()); IVFileInStream *pIn = Vision::File.Open(szCachedShapeName); if (pIn) { snapshot.AddFileDependency(pMeshInstance->GetMesh(), szCachedShapeName, pIn->GetSize() ); pIn->Close(); return; } } }
/* * Normalize vector <v_in> (scale it so its length becomes 1) and put the result * into <v_out>. */ void vNorm(Vector *v_out, Vector *v_in) { double len = vLen(v_in); vScale(v_out, v_in, 1 / len); }
hkRefNew<hkpShape> vHavokShapeFactory::CreateShapeFromStaticMeshInstances(const VisStaticMeshInstCollection &meshInstances, int iCreationFlags, const char **szShapeCacheId) { int iCount = meshInstances.GetLength(); VVERIFY_OR_RET_VAL(iCount>0 && szShapeCacheId!=NULL, NULL); // Actual mesh scale, which is only used for caching. hkvVec3 vScale(hkvNoInitialization); ExtractScaling(meshInstances[0]->GetTransform(), vScale); char szShapeId[512]; const bool bAllowStaticMeshCaching = vHavokPhysicsModule_GetDefaultWorldRuntimeSettings().m_bEnableShapeCaching==TRUE; const vHavokPhysicsModule *pModule = vHavokPhysicsModule::GetInstance(); VASSERT(pModule != NULL); const bool bForceHktShapeCaching = pModule->IsHktShapeCachingEnforced(); // For single mesh instances the per instance welding type is used. For merged mesh instances the global merged welding type is used. VisWeldingType_e eWeldingType = (iCount==1) ? meshInstances[0]->GetWeldingType() : (VisWeldingType_e)vHavokPhysicsModule_GetWorldSetupSettings().m_iMergedStaticWeldingType; const bool bAllowPerTriCollisionInfo = iCreationFlags & VShapeCreationFlags_ALLOW_PERTRICOLINFO; const bool bShrinkByCvxRadius = iCreationFlags & VShapeCreationFlags_SHRINK; // Check whether shape has been already cached for this mesh with the respective scaling. // We are just caching single static mesh instances and no static mesh collections. hkpShape *pCachedShape = HK_NULL; if (iCount == 1) { // first, find the convex version GetIDStringForConvexShape(szShapeId, meshInstances[0]->GetMesh()->GetFilename(), vScale, bShrinkByCvxRadius); pCachedShape = FindShape(szShapeId, szShapeCacheId); if (!pCachedShape) { // then find the mesh version GetIDStringForMeshShape(szShapeId, meshInstances[0]->GetMesh()->GetFilename(), vScale, meshInstances[0]->GetCollisionBehavior(), eWeldingType); pCachedShape = FindShape(szShapeId, szShapeCacheId); } if (pCachedShape) { pCachedShape->addReference(); return pCachedShape; } if (bAllowStaticMeshCaching) { // first, find the convex version pCachedShape = vHavokCachedShape::LoadConvexShape(meshInstances[0]->GetMesh(), vScale, bShrinkByCvxRadius); if (pCachedShape) { *szShapeCacheId = AddShape(szShapeId, pCachedShape); #ifdef HK_DEBUG_SLOW const hkClass* loadedClassType = hkVtableClassRegistry::getInstance().getClassFromVirtualInstance(pCachedShape); HK_ASSERT2(0x5432c902, loadedClassType && (hkString::strCmp( loadedClassType->getName(), "hkvConvexVerticesShape" ) == 0), "Serialized in a unexpected cached Havok shape type!"); #endif return pCachedShape; } else { // then find the mesh version pCachedShape = vHavokCachedShape::LoadMeshShape(meshInstances[0]->GetMesh(), vScale, meshInstances[0]->GetCollisionBehavior(), eWeldingType); } if (pCachedShape ) { *szShapeCacheId = AddShape(szShapeId, pCachedShape); #ifdef HK_DEBUG_SLOW const hkClass* loadedClassType = hkVtableClassRegistry::getInstance().getClassFromVirtualInstance(pCachedShape); HK_ASSERT2(0x5432c902, loadedClassType && (hkString::strCmp( loadedClassType->getName(), "hkvBvCompressedMeshShape" ) == 0), "Serialized in a unexpected cached Havok shape type!"); #endif hkvBvCompressedMeshShape *pCompressedMeshShape = reinterpret_cast<hkvBvCompressedMeshShape*>(pCachedShape); pCompressedMeshShape->SetupMaterials(); return pCachedShape; } else if(!Vision::Editor.IsInEditor() && !bForceHktShapeCaching) { Vision::Error.Warning("Cached HKT file for %s is missing. Please generate HKT file (see documentation for details).", meshInstances[0]->GetMesh()->GetFilename()); } } } // Get the reference transformation. We use the first static mesh as reference // transformation, and thus as the position of the corresponding rigid body. hkvMat4 referenceTransform = meshInstances[0]->GetTransform(); // Remove any scaling from the reference matrix. This one has to be applied to // the Havok shapes, and thus needs to be part of the mesh transforms. referenceTransform.setScalingFactors(hkvVec3 (1)); // We need the inverse referenceTransform to transform each instance into reference space referenceTransform.invert(); referenceTransform.setRow (3, hkvVec4 (0, 0, 0, 1)); // Determine collision type from first static mesh instance. const VisStaticMeshInstance_cl *pMeshInstance = meshInstances[0]; VisStaticMesh_cl *pMesh = pMeshInstance->GetMesh(); IVCollisionMesh *pColMesh = pMesh->GetCollisionMesh(true, true); const bool bIsConvex = pColMesh->GetType()==VIS_COLMESH_GEOTYPE_CONVEXHULL; // Only create a convex shape if a single mesh instance is used, since otherwise merging multiple mesh instances in one single convex hull // will provide in most cases not the desired behavior. Moreover we can only create either a convex hull or a concave mesh shape, therefore // mesh instances with different collision type can't be merged into one shape. hkpShape *pShape = (bIsConvex && iCount==1) ? CreateConvexShapeFromStaticMeshInstances(meshInstances, referenceTransform, bShrinkByCvxRadius) : CreateMeshShapeFromStaticMeshInstances(meshInstances, referenceTransform, bAllowPerTriCollisionInfo, eWeldingType); // We are just caching single static mesh instances and no static mesh collections. if (iCount == 1) { *szShapeCacheId = AddShape(szShapeId, pShape); // Only cache shape to HKT file when inside vForge or when enforced. if ((Vision::Editor.IsInEditor() && bAllowStaticMeshCaching) || bForceHktShapeCaching) { if (bIsConvex) vHavokCachedShape::SaveConvexShape(meshInstances[0]->GetMesh(), vScale, bShrinkByCvxRadius, (hkvConvexVerticesShape*)pShape); else vHavokCachedShape::SaveMeshShape(meshInstances[0]->GetMesh(), vScale, meshInstances[0]->GetCollisionBehavior(), eWeldingType, (hkvBvCompressedMeshShape*)pShape); } } return pShape; }
bool WorldModel::CreateServerMark(CLIENTWEAPONFX & theStruct) { // See if we should create a mark, or simply move one of the GameBase's // marks. // If the GameBase has the max number of marks or this mark is very close // to a pre-existing mark, just move that mark to the new position. HOBJECT hMoveObj = LTNULL; HOBJECT hFarObj = LTNULL; uint32 nNumMarks = m_MarkList.size( ); LTFLOAT fClosestMarkDist = REGION_DIAMETER; LTFLOAT fFarthestMarkDist = 0.0f; uint8 nNumInRegion = 0; LTVector vPos; for( ObjRefNotifierList::iterator iter = m_MarkList.begin( ); iter != m_MarkList.end( ); iter++ ) { HOBJECT hObj = *iter; if( !hObj ) continue; HATTACHMENT hAttachment = NULL; if (LT_OK == g_pLTServer->FindAttachment( m_hObject, hObj, &hAttachment)) { LTransform transform; g_pCommonLT->GetAttachmentTransform(hAttachment, transform, LTTRUE); vPos = transform.m_Pos; } LTFLOAT fDist = VEC_DISTSQR(vPos, theStruct.vPos); if (fDist < REGION_DIAMETER) { if (fDist < fClosestMarkDist) { fClosestMarkDist = fDist; hMoveObj = hObj; } if (++nNumInRegion > MAX_MARKS_IN_REGION) { // Just move this mark to the correct pos... hMoveObj = hMoveObj ? hMoveObj : hObj; break; } } if (fDist > fFarthestMarkDist) { fFarthestMarkDist = fDist; hFarObj = hObj; } } // If we've got the max number of marks on this object, just move // the closest one to the new position... if (nNumMarks >= MAX_MARKS_PER_OBJECT) { if( !hMoveObj ) { if( hFarObj ) { hMoveObj = hFarObj; } else { HOBJECT hFirstMark = *m_MarkList.begin( ); hMoveObj = hFirstMark; } } } else { hMoveObj = LTNULL; // Need to create one... } // Re-setup the object to move it... if (hMoveObj && IsKindOf(hMoveObj, "CServerMark")) { CServerMark* pMoveMark = (CServerMark*) g_pLTServer->HandleToObject(hMoveObj); if (!pMoveMark) return false; // Since this mark is already attached to us, remove the attachment DetachObject( pMoveMark->m_hObject ); if( !AttachServerMark( *pMoveMark, (CLIENTWEAPONFX)theStruct)) { g_pLTServer->RemoveObject( pMoveMark->m_hObject ); RemoveMarkFromList( pMoveMark->m_hObject ); pMoveMark = NULL; return false; } return true; } // Okay, no luck, need to create a new mark... ObjectCreateStruct createStruct; INIT_OBJECTCREATESTRUCT(createStruct); LTFLOAT fScaleAdjust = 1.0f; if (!GetImpactSprite((SurfaceType)theStruct.nSurfaceType, fScaleAdjust, theStruct.nAmmoId, createStruct.m_Filename, ARRAY_LEN(createStruct.m_Filename))) { return false; } createStruct.m_ObjectType = OT_SPRITE; createStruct.m_Flags = FLAG_VISIBLE | FLAG_NOLIGHT | FLAG_ROTATEABLESPRITE; createStruct.m_Pos = theStruct.vPos; createStruct.m_Rotation = LTRotation(theStruct.vSurfaceNormal, LTVector(0.0f, 1.0f, 0.0f)); AMMO const *pAmmo = g_pWeaponMgr->GetAmmo(theStruct.nAmmoId); if( !pAmmo ) return false; static HCLASS hClass = g_pLTServer->GetClass("CServerMark"); CServerMark* pMark = (CServerMark*) g_pLTServer->CreateObject(hClass, &createStruct); if (!pMark) return false; // Randomly adjust the mark's scale to add a bit o spice... if (pAmmo->pImpactFX) { LTFLOAT fScale = fScaleAdjust * pAmmo->pImpactFX->fMarkScale; LTVector vScale(fScale, fScale, fScale); g_pLTServer->ScaleObject(pMark->m_hObject, &vScale); } if( !AttachServerMark( *pMark, (CLIENTWEAPONFX)theStruct)) { g_pLTServer->RemoveObject( pMark->m_hObject ); pMark = NULL; return false; } AddMarkToList( pMark->m_hObject ); return true; }
void VCoronaManager::RenderCorona (VCoronaCandidate& coronaCandidate, VTextureObject*& pTexture) { #ifdef SUPPORTS_CORONAS VCoronaComponent *pCorona = coronaCandidate.m_pCorona; VisRenderContext_cl* pContext = VisRenderContext_cl::GetCurrentContext(); VisLightSource_cl* pLight = (VisLightSource_cl*)pCorona->GetOwner(); hkvVec3 vLightPos(hkvNoInitialization); pLight->GetVirtualPosition(vLightPos, pContext); hkvVec3 vEyePos(hkvNoInitialization); pContext->GetCamera()->GetPosition(vEyePos); hkvVec3 vDir = pContext->GetCamera()->GetDirection(); // Corona texture VTextureObject *pTex = pCorona->GetCoronaTexture(); if (pTex == NULL) return; if (pTexture != pTex) { pTexture = pTex; Vision::RenderLoopHelper.BindMeshTexture(pTexture,0); } // Get light color VColorRef color = pLight->GetColor(); hkvVec3 vDist = vLightPos - vEyePos; float fEyeDist = vDir.dot(vDist); //determine if camera is in light cone if the light is directional float fDirectionalDampening = 1.0f; if ( pLight->GetType() == VIS_LIGHT_SPOTLIGHT && pCorona->GetOnlyVisibleInSpotLight() ) { fDirectionalDampening = 0.0f; float fConeAngle = pLight->GetProjectionAngle(); float fConeLength = pLight->GetRadius(); hkvVec3 fConeDirection = pLight->GetDirection(); fConeDirection.normalize(); hkvVec3 vLightEyeDist = vEyePos - vLightPos; //#2 check if the camera is inside the angle of the cone float cosinusAngle = (vLightEyeDist/vLightEyeDist.getLength()).dot(fConeDirection); float fDegree = hkvMath::acosDeg(cosinusAngle); float normRadius = fDegree / (fConeAngle/2.0f); if (normRadius < 1.0f) { //hardcoded falloff. For better performance, we avoid sampling the projection texture here. const float fEpsilon = 64.0f/256.0f; const float fQuadFactor = 1.0f/fEpsilon - 1.0f; fDirectionalDampening = 1.0f / (1.0f + fQuadFactor*normRadius*normRadius); // scale the function so that the value is exactly 0.0 at the edge and 1.0 in the center fDirectionalDampening = (fDirectionalDampening - fEpsilon) / (1.0f - fEpsilon); } } // Fog params float fFogDampening = 1.0f; if (pLight->GetType() != VIS_LIGHT_DIRECTED && Vision::World.IsLinearDepthFogEnabled()) { const VFogParameters &fog = Vision::World.GetFogParameters(); float fFogStart = fog.fDepthStart; float fFogEnd = fog.fDepthEnd; float fFogFactor = (fFogEnd > fFogStart) ? ((fEyeDist - fFogStart) / (fFogEnd - fFogStart)) : 0.f; fFogDampening = 1.0f - hkvMath::clamp(fFogFactor, 0.0f, 1.0f); } // Get corona rotation float fRotation = 0.0f; hkvVec4 vRotation(1.0f, 0.0f, 0.0f, 1.0f); if (pCorona->CoronaFlags & VIS_CORONASCALE_ROTATING) { fRotation = hkvMath::mod (fEyeDist * 0.5f, 360.f); vRotation.x = hkvMath::cosDeg (fRotation); vRotation.y = -hkvMath::sinDeg (fRotation); vRotation.z = -vRotation.y; vRotation.w = vRotation.x; } // Texture dimensions int iSizeX, iSizeY, depth; pTex->GetTextureDimensions(iSizeX, iSizeY, depth); hkvVec4 vScale(0.0f, 0.0f, 0.0f, 0.0f); int iMainWidth, iMainHeight, iWidth, iHeight; pContext->GetSize(iWidth, iHeight); VisRenderContext_cl::GetMainRenderContext()->GetSize(iMainWidth, iMainHeight); // Preserve texture aspect ratio int iTexHeight = pTex->GetTextureHeight(); int iTexWidth = pTex->GetTextureWidth(); // Perspective scaling // This scaling ensures roughly the same size on 720p as the old implementation. vScale.z = iTexWidth * pCorona->CoronaScaling * 0.25f; vScale.w = iTexHeight * pCorona->CoronaScaling * 0.25f; // Screen-space scaling // This scaling ensures roughly the same size on 720p as the old implementation. const float fScaleFactor = pCorona->CoronaScaling * iMainHeight / 11.0f; vScale.x = ((float)iTexWidth / 128.0f) * fScaleFactor * (float(iWidth) / float(iMainWidth)); vScale.y = ((float)iTexHeight / 128.0f) * fScaleFactor * (float(iHeight) / float(iMainHeight)); vScale.x *= 2.0f / iWidth; vScale.y *= 2.0f / iHeight; // Scale by visibility if (pCorona->CoronaFlags & VIS_CORONASCALE_VISIBLEAREA) { vScale.x *= coronaCandidate.m_fCurrentVisibility; vScale.y *= coronaCandidate.m_fCurrentVisibility; vScale.z *= coronaCandidate.m_fCurrentVisibility; vScale.w *= coronaCandidate.m_fCurrentVisibility; } VCompiledShaderPass* pShader = m_spCoronaTechnique->GetShader(0); VShaderConstantBuffer *pVertexConstBuffer = pShader->GetConstantBuffer(VSS_VertexShader); // xyz = worldspace position, w = 1.0 if VIS_CORONASCALE_DISTANCE is true, otherwise zero. pVertexConstBuffer->SetSingleParameterF("coronaPosition", vLightPos.x, vLightPos.y, vLightPos.z, (pCorona->CoronaFlags & VIS_CORONASCALE_DISTANCE) ? 1.0f : 0.0f); // xyz = light color, w = corona visibility. pVertexConstBuffer->SetSingleParameterF("coronaColor", color.r/255.0f, color.g/255.0f, color.b/255.0f, coronaCandidate.m_fCurrentVisibility * fFogDampening * fDirectionalDampening); // xyzw = 2x2 rotation matrix. float2x2 is not supported in shader model 2, so a float4 is used and multiplication is done manually in the shader. pVertexConstBuffer->SetSingleParameterF("coronaRotation", vRotation.x, vRotation.y, vRotation.z, vRotation.w); // xy = screen-space scaling. zw = view-space scaling. pVertexConstBuffer->SetSingleParameterF("coronaScale", vScale.x, vScale.y, vScale.z, vScale.w); Vision::RenderLoopHelper.RenderMeshes(pShader, VisMeshBuffer_cl::MB_PRIMTYPE_TRILIST, 0, 2, 6); #endif }
bool CLTBBouncyChunkFX::Update(float tmFrameTime) { // Base class update first if (!CBaseFX::Update(tmFrameTime)) return false; if ((m_hImpactSound) && (m_pLTClient->IsDone(m_hImpactSound))) { m_pLTClient->SoundMgr()->KillSound(m_hImpactSound); m_hImpactSound = NULL; } // Set the object scale LTVector vScale(m_scale, m_scale, m_scale); m_pLTClient->SetObjectScale(m_hBouncyChunk, &vScale); LTVector vCur; m_pLTClient->GetObjectPos(m_hBouncyChunk, &vCur); // Compute the new position of the chunk LTVector vNew = vCur; vNew += m_vVel * tmFrameTime; m_vVel += GetProps()->m_vGravity * tmFrameTime; // Move the object and collide against the world ClientIntersectQuery ciq; ClientIntersectInfo cii; ciq.m_From = vCur; ciq.m_To = vNew; if (m_pLTClient->IntersectSegment(&ciq, &cii)) { vNew = cii.m_Point + cii.m_Plane.m_Normal; vCur = vNew; // Compute the reflected velocity LTVector N = cii.m_Plane.m_Normal; LTVector L = m_vVel; L.x = -L.x; L.y = -L.y; L.z = -L.z; LTVector vReflected = N * 2.0f; vReflected *= (N.Dot(L)); vReflected -= L; vReflected.Norm(); vReflected *= (m_vVel.Mag() * 0.7f); m_vVel = vReflected; const char *sImpactSound = GetProps()->m_sImpactSound; if (sImpactSound[0] != '.') { // Play the bounce sound PlaySoundInfo psi; memset(&psi, 0, sizeof(PlaySoundInfo)); psi.m_dwFlags = PLAYSOUND_GETHANDLE | PLAYSOUND_CTRL_VOL | PLAYSOUND_CLIENT | PLAYSOUND_TIME | PLAYSOUND_3D | PLAYSOUND_REVERB; psi.m_nVolume = 50; strcpy(psi.m_szSoundName, GetProps()->m_sImpactSound); psi.m_nPriority = 0; psi.m_vPosition = m_vPos; psi.m_fInnerRadius = 100; psi.m_fOuterRadius = 300; if (!m_hImpactSound) { if (m_pLTClient->SoundMgr()->PlaySound(&psi, m_hImpactSound) == LT_OK) { m_hImpactSound = psi.m_hSound; } } } } m_pLTClient->SetObjectPos(m_hBouncyChunk, &vNew); m_pLTClient->SetObjectColor(m_hBouncyChunk, m_red, m_green, m_blue, m_alpha); m_pLTClient->SetObjectPos(m_hObject, &vNew); // Success !! return true; }
vec2 symmetricUnitBall() { return vScale(rfloat(), uniformUnitCirc()); }
void GGbsModel::MultiAniFrame(){ D3DXMATRIX matWldTrans; D3DXMATRIX matWldRotate; D3DXMATRIX matWldScale; D3DXMatrixIdentity(&matWldTrans); D3DXMatrixIdentity(&matWldRotate); D3DXMatrixIdentity(&matWldScale); D3DXQUATERNION qR, qS; D3DXMATRIX matCalc; D3DXMatrixIdentity(&matCalc); //m_fTickFrame = 6400.0f; m_fTickFrame += g_fSecPerFrame * m_fFrameSpeed *m_fTickPerFrame; if (m_fTickFrame >= m_fLastFrame * m_fTickPerFrame /*마지막 프레임 틱수*/) { m_fTickFrame = 0.0f; } //m_fTickFrame += 1000.0f; //if (m_fTickFrame >= 8000.0f /*마지막 프레임 틱수*/) //{ // m_fTickFrame = 0.0f; //} for (int i = 0; i < m_vGeomObj.size() ; i++) { if (m_vGeomObj[i]->m_bUsed == false) continue; D3DXMatrixIdentity(&m_vGeomObj[i]->m_matCalculation); matWldRotate = m_vGeomObj[i]->m_matWldRotate; matWldTrans = m_vGeomObj[i]->m_matWldTrans; matWldScale = m_vGeomObj[i]->m_matWldScale; D3DXQuaternionRotationMatrix(&qR, &matWldRotate); D3DXQuaternionRotationMatrix(&qS, &matWldScale); //for (int j = 0; j < m_vGeomObj[i]->m_vObj.size(); j++) { //if (m_vGeomObj[i].get()->m_bHasAniTrack) { //Translation if (m_vGeomObj[i].get()->m_vPosTrack.size() != 0) { GAnimTrack* pStartTrack = NULL; GAnimTrack* pEndTrack = NULL; //현재 Tick이 어디인지 찾자. GetAnimationTrack(m_fTickFrame, &pStartTrack, &pEndTrack, ANITRACK_TYPE_POS, i); //애니메이션 보간. D3DXVECTOR3 vResultVector; D3DXVECTOR3 vP1 = pStartTrack->vecVector; D3DXVECTOR3 vP2 = pEndTrack->vecVector; float fTValue = (m_fTickFrame - pStartTrack->iTick) / (pEndTrack->iTick - pStartTrack->iTick); if(pStartTrack != pEndTrack){ D3DXVec3Lerp(&vResultVector, &vP1, &vP2, fTValue); //T행렬 값 대입 matWldTrans._41 = vResultVector.x; matWldTrans._42 = vResultVector.y; matWldTrans._43 = vResultVector.z; } else { //T행렬 값 대입 matWldTrans._41 = pStartTrack->vecVector.x; matWldTrans._42 = pStartTrack->vecVector.y; matWldTrans._43 = pStartTrack->vecVector.z; } } //Rotation if (m_vGeomObj[i].get()->m_vRotTrack.size() != 0) { GAnimTrack* pStartTrack = NULL; GAnimTrack* pEndTrack = NULL; //D3DXQUATERNION qR; //현재 Tick이 어디인지 찾자. GetAnimationTrack(m_fTickFrame, &pStartTrack, &pEndTrack, ANITRACK_TYPE_ROT, i); //사원수간의 보간.. if (pStartTrack == NULL && pEndTrack == NULL) { qR = m_vGeomObj[i].get()->m_vRotTrack[0]->qRotate;// = m_vGeomObj[i].get()->m_qRotation; } else if (pStartTrack == NULL) { qR;// = m_vGeomObj[i].get()->m_qRotation; float fTValue = (m_fTickFrame - 0) / (pEndTrack->iTick - 0); D3DXQuaternionSlerp(&qR, &qR, &pEndTrack->qRotate, fTValue); } else if (pEndTrack == NULL) { qR = m_vGeomObj[i].get()->m_vRotTrack[m_vGeomObj[i].get()->m_vRotTrack.size() - 1].get()->qRotate; float fTValue = ((m_fTickFrame - pStartTrack->iTick) / (m_fFrameSpeed*m_fTickPerFrame)); D3DXQuaternionSlerp(&qR, &qR, &qR, fTValue); } else { qR = pStartTrack->qRotate; float fTValue = (m_fTickFrame - pStartTrack->iTick) / (pEndTrack->iTick - pStartTrack->iTick); D3DXQuaternionSlerp(&qR, &qR, &pEndTrack->qRotate, fTValue); } //사원수에서 행렬로 변환. D3DXMatrixRotationQuaternion(&matWldRotate, &qR);// 사원수에서 행렬로 변환 } //Scale if (m_vGeomObj[i].get()->m_vSclTrack.size() != 0) { GAnimTrack* pStartTrack = NULL; GAnimTrack* pEndTrack = NULL; D3DXMATRIX matScaleRot, matInvScaleRot; D3DXMatrixIdentity(&matScaleRot); D3DXMatrixIdentity(&matInvScaleRot); //D3DXQUATERNION qS; float fStartTick = 0.0f, fEndTick = 0.0f; D3DXVECTOR3 vScale(m_vGeomObj[i].get()->m_matWldScale._11, m_vGeomObj[i].get()->m_matWldScale._22, m_vGeomObj[i].get()->m_matWldScale._33); //현재 Tick이 어디인지 찾자. GetAnimationTrack(m_fTickFrame, &pStartTrack, &pEndTrack, ANITRACK_TYPE_SCL, i); //신축트랙 보간 if (pStartTrack == NULL) { //vScale = m_vGeomObj[i].get()->m_vecTM_SCALE; //D3DXQuaternionRotationAxis(&qS, &m_vGeomObj[i].get()->m_vecTM_SCALE_AXIS, m_vGeomObj[i].get()->m_fTM_SCALEAXISANG); fStartTick = 0.0f; fEndTick = pEndTrack->iTick; } else if (pEndTrack == NULL) { vScale = pStartTrack->vecVector; qS = pStartTrack->qRotate; fStartTick = pStartTrack->iTick; fEndTick = pStartTrack->iTick + (m_fFrameSpeed*m_fTickPerFrame); } else { vScale = pStartTrack->vecVector; qS = pStartTrack->qRotate; fStartTick = pStartTrack->iTick; fEndTick = pEndTrack->iTick; } float fTValue = (m_fTickFrame - fStartTick) / (fEndTick - fStartTick); D3DXVec3Lerp(&vScale, &vScale, &pEndTrack->vecVector, fTValue); D3DXQuaternionSlerp(&qS, &qS, &pEndTrack->qRotate, fTValue); //사원수 -> 행렬로 변환등... D3DXMatrixScaling(&matWldScale, vScale.x, vScale.y, vScale.z); D3DXMatrixRotationQuaternion(&matScaleRot, &qS); D3DXMatrixInverse(&matInvScaleRot, NULL, &matScaleRot); matWldScale = matInvScaleRot * matWldScale * matScaleRot; } if (m_vGeomObj[i].get()->m_pParentObj != NULL) { m_vGeomObj[i].get()->m_matCalculation = matCalc = matWldScale * matWldRotate * matWldTrans * m_vGeomObj[i].get()->m_pParentObj->m_matCalculation; int iTest = 0; // 인버스 매트릭스 확인 코드. D3DXVECTOR3 v0, v1, v2, v3; v0 = m_vGeomObj[i].get()->m_matCalculation.m[0]; v1 = m_vGeomObj[i].get()->m_matCalculation.m[1]; v2 = m_vGeomObj[i].get()->m_matCalculation.m[2]; D3DXVec3Cross(&v3, &v1, &v2); if (D3DXVec3Dot(&v3, &v0) < 0.0f) { D3DXMATRIX matW; D3DXMatrixScaling(&matW, -1.0f, -1.0f, -1.0f); D3DXMatrixMultiply(&m_vGeomObj[i].get()->m_matCalculation, &m_vGeomObj[i].get()->m_matCalculation, &matW); } } else { m_vGeomObj[i].get()->m_matCalculation = matCalc = matWldScale * matWldRotate * matWldTrans; int iTest = 0; // 인버스 매트릭스 확인 코드. D3DXVECTOR3 v0, v1, v2, v3; v0 = m_vGeomObj[i].get()->m_matCalculation.m[0]; v1 = m_vGeomObj[i].get()->m_matCalculation.m[1]; v2 = m_vGeomObj[i].get()->m_matCalculation.m[2]; D3DXVec3Cross(&v3, &v1, &v2); if (D3DXVec3Dot(&v3, &v0) < 0.0f) { D3DXMATRIX matW; D3DXMatrixScaling(&matW, -1.0f, -1.0f, -1.0f); D3DXMatrixMultiply(&m_vGeomObj[i].get()->m_matCalculation, &m_vGeomObj[i].get()->m_matCalculation, &matW); } } } //} //} //최종행렬. }
D3DXMATRIX GAnimation::Interpolate(GMesh* pMesh, D3DXMATRIX* matParents, float fFrameTick, TScene tScene) { // TM = AnimMat * ParentTM; // AaniMat = TM * Inverse(ParentTM) D3DXQUATERNION qR, qS; D3DXMATRIX matAnim, matPos, matRotate, matScale, matCalculation; D3DXMatrixIdentity(&matCalculation); matRotate = pMesh->m_matWorldRotate; matPos = pMesh->m_matWorldTrans; matScale = pMesh->m_matWorldScale; D3DXQuaternionRotationMatrix(&qR, &matRotate); D3DXQuaternionRotationMatrix(&qS, &matScale); // fFrameTick = m_Scene.iFirstFrame * m_Scene.iTickPerFrame + CurFame; float fStartTick = tScene.iFirstFrame * tScene.iTickPerFrame; float fEndTick = 0.0f; TAnimTrack* pStartTrack = NULL; TAnimTrack* pEndTrack = NULL; if (pMesh->m_pRotTrack.size()) { // pStartTrack를 찾을수 있으면 if (GetAnimationTrack(fFrameTick, pMesh->m_pRotTrack, &pStartTrack, &pEndTrack)) { qR = pStartTrack->qRotate; fStartTick = pStartTrack->iTick; } if (pEndTrack) { fEndTick = pEndTrack->iTick; D3DXQuaternionSlerp(&qR, &qR, &pEndTrack->qRotate, (fFrameTick - fStartTick) / (fEndTick - fStartTick)); } D3DXMatrixRotationQuaternion(&matRotate, &qR); } pStartTrack = NULL; pEndTrack = NULL; D3DXVECTOR3 Trans(matPos._41, matPos._42, matPos._43); if (pMesh->m_pPosTrack.size()) { // pStartTrack를 찾을수 있으면 if (GetAnimationTrack(fFrameTick, pMesh->m_pPosTrack, &pStartTrack, &pEndTrack)) { Trans = pStartTrack->vVector; fStartTick = pStartTrack->iTick; } if (pEndTrack) { fEndTick = pEndTrack->iTick; D3DXVec3Lerp(&Trans, &Trans, &pEndTrack->vVector, (fFrameTick - fStartTick) / (fEndTick - fStartTick)); } D3DXMatrixTranslation(&matPos, Trans.x, Trans.y, Trans.z); } pStartTrack = NULL; pEndTrack = NULL; D3DXMATRIX matScaleRot, matInvScaleRot; D3DXVECTOR3 vScale(matScale._11, matScale._22, matScale._33); if (pMesh->m_pSclTrack.size()) { // pStartTrack를 찾을수 있으면 if (GetAnimationTrack(fFrameTick, pMesh->m_pSclTrack, &pStartTrack, &pEndTrack)) { vScale = pStartTrack->vVector; qS = pStartTrack->qRotate; fStartTick = pStartTrack->iTick; } if (pEndTrack) { fEndTick = pEndTrack->iTick; D3DXVec3Lerp(&vScale, &vScale, &pEndTrack->vVector, (fFrameTick - fStartTick) / (fEndTick - fStartTick)); D3DXQuaternionSlerp(&qS, &qS, &pEndTrack->qRotate, (fFrameTick - fStartTick) / (fEndTick - fStartTick)); } D3DXMatrixScaling(&matScale, vScale.x, vScale.y, vScale.z); D3DXMatrixRotationQuaternion(&matScaleRot, &qS); D3DXMatrixInverse(&matInvScaleRot, NULL, &matScaleRot); matScale = matInvScaleRot * matScale * matScaleRot; } pStartTrack = NULL; pEndTrack = NULL; float fCurAlpha, fNextAlpha, fOffSet; fCurAlpha = 0.0f; fNextAlpha = 0.0f; if (pMesh->m_pVisTrack.size()) { // pStartTrack를 찾을수 있으면 if (GetAnimationTrack(fFrameTick, pMesh->m_pVisTrack, &pStartTrack, &pEndTrack)) { fCurAlpha = pStartTrack->vVector.x; fStartTick = pStartTrack->iTick; } if (pEndTrack) { fNextAlpha = pEndTrack->vVector.x; fEndTick = pEndTrack->iTick; fOffSet = (fFrameTick - fStartTick) / (fEndTick - fStartTick); fNextAlpha = (fNextAlpha - fCurAlpha)*fOffSet; } pMesh->m_fVisibility = (fCurAlpha + fNextAlpha); } else { pMesh->m_fVisibility = 1.0f; } D3DXMatrixMultiply(&matAnim, &matScale, &matRotate); matAnim._41 = matPos._41; matAnim._42 = matPos._42; matAnim._43 = matPos._43; // 최종 에미메이션 행렬을 완성한다. D3DXMatrixMultiply(&matCalculation, &matAnim, matParents); // 인버스 매트릭스 확인 코드. D3DXVECTOR3 v0, v1, v2, v3; v0 = pMesh->m_matCalculation.m[0]; v1 = pMesh->m_matCalculation.m[1]; v2 = pMesh->m_matCalculation.m[2]; D3DXVec3Cross(&v3, &v1, &v2); if (D3DXVec3Dot(&v3, &v0) < 0.0f) { D3DXMATRIX matW; D3DXMatrixScaling(&matW, -1.0f, -1.0f, -1.0f); D3DXMatrixMultiply(&matCalculation, &pMesh->m_matCalculation, &matW); } return matCalculation; }
void GGbsModel::SingleAniFrame() { D3DXMATRIX matWldTrans; D3DXMATRIX matWldRotate; D3DXMATRIX matWldScale; D3DXMatrixIdentity(&matWldTrans); D3DXMatrixIdentity(&matWldRotate); D3DXMatrixIdentity(&matWldScale); m_fTickFrame += g_fSecPerFrame * m_fFrameSpeed *m_fTickPerFrame; if (m_fTickFrame >= m_fLastFrame * m_fTickPerFrame /*마지막 프레임 틱수*/) { m_fTickFrame = 0.0f; } if (m_vGeomObj[0].get()->m_bHasAniTrack) { //Translation if (m_vGeomObj[0].get()->m_vPosTrack.size() != 0) { GAnimTrack* pStartTrack = NULL; GAnimTrack* pEndTrack = NULL; //현재 Tick이 어디인지 찾자. GetAnimationTrack(m_fTickFrame, &pStartTrack, &pEndTrack, ANITRACK_TYPE_POS); //애니메이션 보간. D3DXVECTOR3 vResultVector; D3DXVECTOR3 vP1 = pStartTrack->vecVector; D3DXVECTOR3 vP2 = pEndTrack->vecVector; float fTValue = (m_fTickFrame - pStartTrack->iTick) / (pEndTrack->iTick - pStartTrack->iTick); D3DXVec3Lerp(&vResultVector, &vP1, &vP2, fTValue); //T행렬 값 대입 matWldTrans._41 = vResultVector.x; matWldTrans._42 = vResultVector.y; matWldTrans._43 = vResultVector.z; } //Rotation if (m_vGeomObj[0].get()->m_vRotTrack.size() != 0) { GAnimTrack* pStartTrack = NULL; GAnimTrack* pEndTrack = NULL; D3DXQUATERNION qR; //현재 Tick이 어디인지 찾자. GetAnimationTrack(m_fTickFrame, &pStartTrack, &pEndTrack, ANITRACK_TYPE_ROT); //사원수간의 보간.. if (pStartTrack == NULL) { qR = m_vGeomObj[0].get()->m_qRotation; float fTValue = (m_fTickFrame - 0) / (pEndTrack->iTick - 0); D3DXQuaternionSlerp(&qR, &qR, &pEndTrack->qRotate, fTValue); } else if (pEndTrack == NULL) { qR = m_vGeomObj[0].get()->m_vRotTrack[m_vGeomObj[0].get()->m_vRotTrack.size() - 1].get()->qRotate; float fTValue = ((m_fTickFrame - pStartTrack->iTick) / (m_fFrameSpeed*m_fTickPerFrame)); D3DXQuaternionSlerp(&qR, &qR, &qR, fTValue); } else { qR = pStartTrack->qRotate; float fTValue = (m_fTickFrame - pStartTrack->iTick) / (pEndTrack->iTick - pStartTrack->iTick); D3DXQuaternionSlerp(&qR, &qR, &pEndTrack->qRotate, fTValue); } //사원수에서 행렬로 변환. D3DXMatrixRotationQuaternion(&matWldRotate, &qR);// 사원수에서 행렬로 변환 } //Scale if (m_vGeomObj[0].get()->m_vSclTrack.size() != 0) { GAnimTrack* pStartTrack = NULL; GAnimTrack* pEndTrack = NULL; D3DXMATRIX matScaleRot, matInvScaleRot; D3DXMatrixIdentity(&matScaleRot); D3DXMatrixIdentity(&matInvScaleRot); D3DXQUATERNION qS; float fStartTick = 0.0f, fEndTick = 0.0f; D3DXVECTOR3 vScale(m_vGeomObj[0].get()->m_matWldScale._11, m_vGeomObj[0].get()->m_matWldScale._22, m_vGeomObj[0].get()->m_matWldScale._33); //현재 Tick이 어디인지 찾자. GetAnimationTrack(m_fTickFrame, &pStartTrack, &pEndTrack, ANITRACK_TYPE_SCL); //신축트랙 보간 if (pStartTrack == NULL) { //vScale = m_vGeomObj[0].get()->m_vecTM_SCALE; D3DXQuaternionRotationAxis(&qS, &m_vGeomObj[0].get()->m_vecTM_SCALE_AXIS, m_vGeomObj[0].get()->m_fTM_SCALEAXISANG); fStartTick = 0.0f; fEndTick = pEndTrack->iTick; } else if (pEndTrack == NULL) { vScale = pStartTrack->vecVector; qS = pStartTrack->qRotate; fStartTick = pStartTrack->iTick; fEndTick = pStartTrack->iTick + (m_fFrameSpeed*m_fTickPerFrame); } else { vScale = pStartTrack->vecVector; qS = pStartTrack->qRotate; fStartTick = pStartTrack->iTick; fEndTick = pEndTrack->iTick; } float fTValue = (m_fTickFrame - fStartTick) / (fEndTick - fStartTick); D3DXVec3Lerp(&vScale, &vScale, &pEndTrack->vecVector, fTValue); D3DXQuaternionSlerp(&qS, &qS, &pEndTrack->qRotate, fTValue); //사원수 -> 행렬로 변환등... D3DXMatrixScaling(&matWldScale, vScale.x, vScale.y, vScale.z); D3DXMatrixRotationQuaternion(&matScaleRot, &qS); D3DXMatrixInverse(&matInvScaleRot, NULL, &matScaleRot); matWldScale = matInvScaleRot * matWldScale * matScaleRot; } m_vGeomObj[0].get()->m_matCalculation = matWldScale * matWldRotate * matWldTrans; } }
LTBOOL CFolderPlayer::CreatePlayerModel(LTBOOL bNewSkin /* = LTTRUE */) { HOBJECT hCamera = g_pGameClientShell->GetInterfaceCamera(); if (!hCamera) return LTFALSE; if (!strlen(m_szPlayerModel)) return LTFALSE; char temp[128]; strcpy(temp,m_szPlayerModel); char *pTemp = strtok(temp,","); strcpy(m_szModName,pTemp); pTemp = strtok(NULL,","); if (pTemp) strcpy(m_szStyleName,pTemp); if ( bNewSkin ) { uint32 cSkins = 0; uint32 cHeads = 0; char szTag[128]; char szValue[128]; sprintf(szTag, "%s_%s", temp, m_szStyleName); _strlwr(szTag); m_pSkinCtrl->RemoveAll(); m_pHeadCtrl->RemoveAll(); char szRestoreSkin[256]; char szRestoreHead[256]; strcpy(szRestoreSkin, m_szPlayerSkin); *strchr(szRestoreSkin, ',') = 0; strcpy(szRestoreHead, m_szPlayerHead); *strchr(szRestoreHead, ',') = 0; if (g_pModelButeMgr->GetButeMgr()->Exist(szTag)) { sprintf(szValue, "Skin%d", cSkins); while ( g_pModelButeMgr->GetButeMgr()->Exist(szTag, szValue) ) { char szName[256]; strcpy(szName, (const char*)g_pModelButeMgr->GetButeMgr()->GetString(szTag, szValue)); char* pch = strchr(szName, ','); *pch++ = 0; strcpy(m_aszSkins[cSkins], pch); HSTRING hstr = g_pLTClient->CreateString(szName); m_pSkinCtrl->AddString(hstr); g_pLTClient->FreeString(hstr); if ( m_bRestoreSkinHead ) { if ( !strcmp(szName, szRestoreSkin) ) { m_nSkinNum = cSkins; m_pSkinCtrl->UpdateData(LTFALSE); } } cSkins++; sprintf(szValue, "Skin%d", cSkins); } sprintf(szValue, "Head%d", cHeads); while ( g_pModelButeMgr->GetButeMgr()->Exist(szTag, szValue) ) { char szName[256]; strcpy(szName, (const char*)g_pModelButeMgr->GetButeMgr()->GetString(szTag, szValue)); char* pch = strchr(szName, ','); *pch++ = 0; strcpy(m_aszHeads[cHeads], pch); HSTRING hstr = g_pLTClient->CreateString(szName); m_pHeadCtrl->AddString(hstr); g_pLTClient->FreeString(hstr); if ( m_bRestoreSkinHead ) { if ( !strcmp(szName, szRestoreHead) ) { m_nHeadNum = cHeads; m_pHeadCtrl->UpdateData(LTFALSE); } } cHeads++; sprintf(szValue, "Head%d", cHeads); } } ASSERT(cSkins != 0 && cHeads != 0); } m_bRestoreSkinHead = LTFALSE; BSCREATESTRUCT bcs; LTVector vPos, vU, vR, vF, vTemp, vScale(1.0f,1.0f,1.0f); LTRotation rRot; char modName[128]; char animName[128]; char skinName[128]; char skin2Name[128]; if ( bNewSkin ) { sprintf(m_szPlayerSkin, "%s,%s", g_pLTClient->GetStringData(m_pSkinCtrl->GetString(m_nSkinNum)), m_aszSkins[m_nSkinNum]); sprintf(m_szPlayerHead, "%s,%s", g_pLTClient->GetStringData(m_pHeadCtrl->GetString(m_nHeadNum)), m_aszHeads[m_nHeadNum]); } g_pLayoutMgr->GetFolderCustomString((eFolderID)m_nFolderID,"CharAnim",animName,sizeof(animName)); ModelId eModelId = g_pModelButeMgr->GetModelId(m_szModName); ModelStyle eModelStyle = g_pModelButeMgr->GetStyle(m_szStyleName); const char* pFilename = g_pModelButeMgr->GetMultiModelFilename(eModelId, eModelStyle); SAFE_STRCPY(modName, pFilename); const char* pSkin = strchr(m_szPlayerSkin, ',')+1; SAFE_STRCPY(skinName, pSkin); const char* pSkin2 = strchr(m_szPlayerHead, ',')+1; SAFE_STRCPY(skin2Name, pSkin2); g_pLTClient->GetObjectPos(hCamera, &vPos); g_pLTClient->GetObjectRotation(hCamera, &rRot); g_pLTClient->GetRotationVectors(&rRot, &vU, &vR, &vF); VEC_SET(vScale,1.0f,1.0f,1.0f); VEC_MULSCALAR(vScale, vScale, g_pLayoutMgr->GetFolderCustomFloat((eFolderID)m_nFolderID,"CharScale")); LTVector vModPos = g_pLayoutMgr->GetFolderCustomVector((eFolderID)m_nFolderID,"CharPos"); LTFLOAT fRot = g_pLayoutMgr->GetFolderCustomFloat((eFolderID)m_nFolderID,"CharRotation"); fRot = MATH_PI + DEG2RAD(fRot); g_pLTClient->RotateAroundAxis(&rRot, &vU, fRot); VEC_MULSCALAR(vTemp, vF, vModPos.z); VEC_MULSCALAR(vTemp, vTemp, g_pInterfaceResMgr->GetXRatio()); VEC_ADD(vPos, vPos, vTemp); VEC_MULSCALAR(vTemp, vR, vModPos.x); VEC_ADD(vPos, vPos, vTemp); VEC_MULSCALAR(vTemp, vU, vModPos.y); VEC_ADD(vPos, vPos, vTemp); VEC_COPY(bcs.vPos, vPos); bcs.rRot = rRot; VEC_COPY(bcs.vInitialScale, vScale); VEC_COPY(bcs.vFinalScale, vScale); VEC_SET(bcs.vInitialColor, 1.0f, 1.0f, 1.0f); VEC_SET(bcs.vFinalColor, 1.0f, 1.0f, 1.0f); bcs.bUseUserColors = LTTRUE; bcs.pFilename = modName; bcs.pSkin = skinName; bcs.pSkin2 = skin2Name; bcs.dwFlags = FLAG_VISIBLE | FLAG_FOGDISABLE | FLAG_NOLIGHT; bcs.nType = OT_MODEL; bcs.fInitialAlpha = 1.0f; bcs.fFinalAlpha = 1.0f; bcs.fLifeTime = 1000000.0f; bcs.bLoop = LTTRUE; if (m_CharSFX.Init(&bcs)) { m_CharSFX.CreateObject(g_pLTClient); g_pInterfaceMgr->AddInterfaceSFX(&m_CharSFX, IFX_WORLD); if (m_CharSFX.GetObject()) { HMODELANIM hAnim = g_pLTClient->GetAnimIndex(m_CharSFX.GetObject(),animName); if (hAnim != -1) g_pLTClient->SetModelAnimation(m_CharSFX.GetObject(),hAnim); ClearAttachFX(); int reqID[MAX_INT_ATTACHMENTS]; int numReq = g_pAttachButeMgr->GetRequirementIDs(m_szModName,m_szStyleName,reqID,MAX_INT_ATTACHMENTS); for (int i = 0; i < numReq; i++) { INT_ATTACH acs; acs.fScale = g_pLayoutMgr->GetFolderCustomFloat((eFolderID)m_nFolderID,"CharScale"); acs.nAttachmentID = g_pAttachButeMgr->GetRequirementAttachment(reqID[i]); CString socket = g_pAttachButeMgr->GetRequirementSocket(reqID[i]); acs.pszSocket = (char *)(LPCTSTR)socket; CreateAttachFX(&acs); } int numAtt = g_pLayoutMgr->GetFolderNumAttachments((eFolderID)m_nFolderID); for (i = 0; i < numAtt; i++) { char szTemp[128]; char *pName = LTNULL; char *pSocket = LTNULL; g_pLayoutMgr->GetFolderAttachment( (eFolderID)m_nFolderID, i, szTemp, 128); pName = strtok(szTemp,";"); pSocket = strtok(NULL,";"); INT_ATTACH acs; acs.fScale = g_pLayoutMgr->GetFolderCustomFloat((eFolderID)m_nFolderID,"CharScale"); acs.nAttachmentID = g_pAttachButeMgr->GetAttachmentIDByName(pName); acs.pszSocket = pSocket; CreateAttachFX(&acs); } } return LTTRUE; } return LTFALSE; }
/************************************************************************************************ * Move ball forward * ************************************************************************************************/ void cBall::MoveForward() { this->Pos = vAdd(this->Pos, vScale(this->Dir, this->Vel)); }
vec2 symmetricBall(float radius) { return vScale(rfloat() * radius, uniformUnitCirc()); }
bool CLTBBouncyChunkFX::Init(ILTClient *pClientDE, FX_BASEDATA *pBaseData, const CBaseFXProps *pProps) { // Perform base class initialisation if (!CBaseFX::Init(pClientDE, pBaseData, pProps)) return false; LTVector vChunkDir = GetProps()->m_vChunkDir; if (pBaseData->m_bUseTargetData) { vChunkDir = pBaseData->m_vTargetNorm; } LTVector vPos; LTRotation rRot; if (m_hParent) { m_pLTClient->GetObjectPos(m_hParent, &vPos); m_pLTClient->GetObjectRotation(m_hParent, &rRot); } else { vPos = m_vCreatePos; rRot = m_rCreateRot; } float scale; CalcScale(m_tmElapsed, GetProps()->m_tmLifespan, &scale); LTVector vScale(scale, scale, scale); ObjectCreateStruct ocs; INIT_OBJECTCREATESTRUCT(ocs); ocs.m_ObjectType = OT_MODEL; ocs.m_Flags = FLAG_NOLIGHT | FLAG_VISIBLE; ocs.m_Pos = vPos + GetProps()->m_vOffset; ocs.m_Rotation = rRot; ocs.m_Scale = vScale; strcpy(ocs.m_Filename, GetProps()->m_sModelName); strcpy(ocs.m_SkinName, GetProps()->m_sSkinName); m_hBouncyChunk = m_pLTClient->CreateObject(&ocs); // Setup an initial vector for the velocity LTVector vOther; vOther.x = 1.0f; vOther.y = 0.0f; vOther.z = 1.0f; vOther.Norm(); LTVector vRight = vChunkDir.Cross(vOther); LTVector vUp = vRight.Cross(vOther); m_vVel = vRight * (-GetProps()->m_fChunkSpread + (float)(rand() % (int)(GetProps()->m_fChunkSpread * 2.0f))); m_vVel += vUp * (-GetProps()->m_fChunkSpread + (float)(rand() % (int)(GetProps()->m_fChunkSpread * 2.0f))); m_vVel += vChunkDir * GetProps()->m_fChunkSpeed; m_vVel.Norm(GetProps()->m_fChunkSpeed); // Create the base object CreateDummyObject(); // Success !! return true; }
void CFolderWeaponControls::CreateModelSFX() { // no model = no SFX if (!strlen(m_szModel)) return; HOBJECT hCamera = g_pGameClientShell->GetInterfaceCamera(); if (!hCamera) return; BSCREATESTRUCT bcs; LTVector vPos, vU, vR, vF, vTemp, vScale(1.0f,1.0f,1.0f); LTRotation rRot; g_pLTClient->GetObjectPos(hCamera, &vPos); g_pLTClient->GetObjectRotation(hCamera, &rRot); g_pLTClient->GetRotationVectors(&rRot, &vU, &vR, &vF); g_pLTClient->RotateAroundAxis(&rRot, &vU, MATH_HALFPI); g_pLTClient->RotateAroundAxis(&rRot, &vR, -0.3f); VEC_MULSCALAR(vScale, vScale, m_fScale); LTVector vModPos = g_pLayoutMgr->GetFolderCustomVector((eFolderID)m_nFolderID,"ModelPos"); VEC_ADD(vModPos,vModPos,m_vOffset); VEC_MULSCALAR(vTemp, vF, vModPos.z); VEC_MULSCALAR(vTemp, vTemp, g_pInterfaceResMgr->GetXRatio()); VEC_ADD(vPos, vPos, vTemp); VEC_MULSCALAR(vTemp, vR, vModPos.x); VEC_ADD(vPos, vPos, vTemp); VEC_MULSCALAR(vTemp, vU, vModPos.y); VEC_ADD(vPos, vPos, vTemp); VEC_COPY(bcs.vPos, vPos); bcs.rRot = rRot; VEC_COPY(bcs.vInitialScale, vScale); VEC_COPY(bcs.vFinalScale, vScale); VEC_SET(bcs.vInitialColor, 1.0f, 1.0f, 1.0f); VEC_SET(bcs.vFinalColor, 1.0f, 1.0f, 1.0f); bcs.bUseUserColors = LTTRUE; bcs.pFilename = m_szModel; bcs.pSkin = m_szSkin; bcs.dwFlags = FLAG_VISIBLE | FLAG_FOGDISABLE | FLAG_NOLIGHT; bcs.nType = OT_MODEL; bcs.fInitialAlpha = 1.0f; bcs.fFinalAlpha = 1.0f; bcs.fLifeTime = 1000000.0f; if (m_ModelSFX.Init(&bcs)) { m_ModelSFX.CreateObject(g_pLTClient); g_pInterfaceMgr->AddInterfaceSFX(&m_ModelSFX, IFX_NORMAL); m_fSFXRot = g_pLayoutMgr->GetFolderCustomFloat((eFolderID)m_nFolderID,"ModelRotSpeed"); } }
bool CFallingStuffFX::Update(float tmFrameTime) { // Base class update first m_vLastPos = m_vPos; if (!CBaseFX::Update(tmFrameTime)) return false; //increment our emission time by the elapsed frame time m_tmElapsedEmission += tmFrameTime; if (!IsShuttingDown() && !IsSuspended() && (m_tmElapsedEmission > GetProps()->m_tmFallingStuffFXEmission)) { ObjectCreateStruct ocs; INIT_OBJECTCREATESTRUCT(ocs); LTVector vScale; vScale.Init(m_scale, m_scale, m_scale); LTVector vInterp; LTVector vInterpCur = m_vPos; // Calculate interpolant for particle system if (GetProps()->m_nFallingStuffFXEmission) { vInterp = m_vPos - m_vLastPos; vInterp /= (float)GetProps()->m_nFallingStuffFXEmission; } for (uint32 i = 0; i < GetProps()->m_nFallingStuffFXEmission; i ++) { ocs.m_ObjectType = OT_SPRITE; ocs.m_Flags = FLAG_VISIBLE | FLAG_NOLIGHT | FLAG_ROTATABLESPRITE; // Compute the initial position float xRand = GetProps()->m_fRadius * ((-10000.0f + (rand() % 20000)) / 10000.0f); float zRand = GetProps()->m_fRadius * ((-10000.0f + (rand() % 20000)) / 10000.0f); ocs.m_Pos = m_vPos + (m_vRight * xRand) + (m_vUp * zRand); ocs.m_Scale = vScale; strcpy(ocs.m_Filename, GetProps()->m_sSpriteName); // Move the start point vInterpCur += vInterp; HLOCALOBJ hNewSprite = m_pLTClient->CreateObject(&ocs); if (hNewSprite) { // Create a new sprite FALLING_THING *pNewSprite = debug_new( FALLING_THING ); if (GetProps()->m_nImpactCreate) { if (g_dwSplash > (uint32)GetProps()->m_nImpactCreate) { pNewSprite->m_bSplash = true; g_dwSplash = 0; } else { pNewSprite->m_bSplash = false; } } else { pNewSprite->m_bSplash = false; } g_dwSplash ++; if (pNewSprite) { LTVector v; // Compute the initial velocity v = m_vPlaneDir * GetProps()->m_fVel; pNewSprite->m_hObject = hNewSprite; pNewSprite->m_vVel = v; pNewSprite->m_tmElapsed = 0.0f; pNewSprite->m_vPos = ocs.m_Pos; pNewSprite->m_vLastPos = ocs.m_Pos; m_collSprites.AddTail(pNewSprite); } } } m_tmElapsedEmission = 0.0f; // And store the last position m_vLastPos = m_vPos; } LTMatrix mSpin; if (GetProps()->m_bUseSpin) { // Setup rotation LTMatrix vRight; LTMatrix vUp; LTMatrix vForward; LTMatrix vTmp; Mat_SetupRot(&vRight, &m_vRight, m_xRot); Mat_SetupRot(&vUp, &m_vUp, m_yRot); Mat_SetupRot(&vForward, &m_vPlaneDir, m_zRot); MatMul(&vTmp, &vRight, &vUp); MatMul(&mSpin, &vTmp, &vForward); m_xRot += GetProps()->m_vRotAdd.x * tmFrameTime; m_yRot += GetProps()->m_vRotAdd.y * tmFrameTime; m_zRot += GetProps()->m_vRotAdd.z * tmFrameTime; } // Get the camera rotation LTRotation orient; m_pLTClient->GetObjectRotation(m_hCamera, &orient); LTRotation dRot(orient); LTVector vF = orient.Forward(); float rot = (float)atan2(vF.x, vF.z); // Update the sprites.... CLinkListNode<FALLING_THING *> *pNode = m_collSprites.GetHead(); CLinkListNode<FALLING_THING *> *pDelNode; while (pNode) { pDelNode = NULL; FALLING_THING *pSprite = pNode->m_Data; //adjust our elapsed time pSprite->m_tmElapsed += tmFrameTime; // Check for expiration if (pSprite->m_tmElapsed > GetProps()->m_tmSpriteLifespan) { // Destroy this object m_pLTClient->RemoveObject(pSprite->m_hObject); pDelNode = pNode; } else { // Update !! pSprite->m_vLastPos = pSprite->m_vPos; pSprite->m_vPos += (pSprite->m_vVel * tmFrameTime); // Rotate if neccessary TVector3<float> vPos = pSprite->m_vPos; if (GetProps()->m_bUseSpin) { MatVMul_InPlace(&mSpin, &vPos); } // Add in wind vPos += (GetProps()->m_vWind * GetProps()->m_fWindAmount) * tmFrameTime; // Setup the new sprite position LTVector vPos2 = vPos; m_pLTClient->SetObjectPos(pSprite->m_hObject, &vPos2); // Setup the colour float r, g, b, a; m_pLTClient->GetObjectColor(pSprite->m_hObject, &r, &g, &b, &a); CalcColour(pSprite->m_tmElapsed, GetProps()->m_tmSpriteLifespan, &r, &g, &b, &a); m_pLTClient->SetObjectColor(pSprite->m_hObject, r, g, b, a); // Setup the scale float scale = 0.1f; CalcScale(pSprite->m_tmElapsed, GetProps()->m_tmSpriteLifespan, &scale); LTVector vScale; vScale.Init(scale, scale * GetProps()->m_fStretchMul, scale); m_pLTClient->SetObjectScale(pSprite->m_hObject, &vScale); // Setup the rotation dRot = LTRotation(0, 0, 0, 1); LTRotation orient(dRot); orient.Rotate( orient.Up(), rot ); m_pLTClient->SetObjectRotation(pSprite->m_hObject, &orient); // Check to see if we need to start a splash sprite if (pSprite->m_bSplash) { ClientIntersectQuery ciq; ClientIntersectInfo cii; ciq.m_From = pSprite->m_vLastPos; ciq.m_To = pSprite->m_vPos; if ((GetProps()->m_sImpactSpriteName[0]) && (m_pLTClient->IntersectSegment(&ciq, &cii))) { // Create a splash sprite SPLASH *pSplash = debug_new( SPLASH ); ObjectCreateStruct ocs; INIT_OBJECTCREATESTRUCT(ocs); LTVector vScale; vScale.Init(0.0f, 0.0f, 0.0f); ocs.m_ObjectType = OT_SPRITE; ocs.m_Flags = FLAG_VISIBLE | FLAG_ROTATABLESPRITE | FLAG_NOLIGHT; ocs.m_Pos = cii.m_Point + (cii.m_Plane.m_Normal * 2.0f); ocs.m_Scale = vScale; LTRotation dOrient( cii.m_Plane.m_Normal, LTVector(0.0f, 1.0f, 0.0f) ); strcpy(ocs.m_Filename, GetProps()->m_sImpactSpriteName); pSplash->m_hObject = m_pLTClient->CreateObject(&ocs); pSplash->m_scale = 0.0f; LTRotation orient(dRot); m_pLTClient->SetObjectRotation(pSplash->m_hObject, &orient); pSplash->m_tmElapsed = 0.0f; m_collSplashes.AddTail(pSplash); // Destroy this object m_pLTClient->RemoveObject(pSprite->m_hObject); // Delete the sprite pDelNode = pNode; } } } pNode = pNode->m_pNext; if (pDelNode) m_collSprites.Remove(pDelNode); } // Update our splashes CLinkListNode<SPLASH *> *pSplashNode = m_collSplashes.GetHead(); while (pSplashNode) { CLinkListNode<SPLASH *> *pDelNode = NULL; SPLASH *pSplash = pSplashNode->m_Data; //update the elapsed time on the splash pSplash->m_tmElapsed += tmFrameTime; // Calculate the new scale float scale = GetProps()->m_fImpactScale1 + ((GetProps()->m_fImpactScale2 - GetProps()->m_fImpactScale1) * (pSplash->m_tmElapsed / GetProps()->m_tmImpactLifespan)); LTVector vScale(scale, scale, scale); m_pLTClient->SetObjectScale(pSplash->m_hObject, &vScale); float r, g, b, a; m_pLTClient->GetObjectColor(pSplash->m_hObject, &r, &g, &b, &a); a = (float)(int)(pSplash->m_tmElapsed / GetProps()->m_tmImpactLifespan); if (a < 0.0f) a = 0.0f; if (a > 1.0f) a = 1.0f; m_pLTClient->SetObjectColor(pSplash->m_hObject, r, g, b, a); if (pSplash->m_tmElapsed > GetProps()->m_tmImpactLifespan) { m_pLTClient->RemoveObject(pSplash->m_hObject); pDelNode = pSplashNode; } pSplashNode = pSplashNode->m_pNext; if (pDelNode) m_collSplashes.Remove(pDelNode); } // Success !! return true; }
//=============================================== // Unit Tests //=============================================== int main() { // set for command line argument -t to run unit tests. bool test = true; if (test) { std::cout<<"\n=================\nBegin UNIT TESTS\n=================\n\n"; Light::Light n = *new Light::Light(0, 1, 1, 0, 0.5, 0.5, 0.5); n.print(); Intersect::Intersect i = *new Intersect::Intersect(); if(i.isHit()) { std::cout<<"INCORRECT! hit is true.\n\n"; } else { std::cout<<"CORRECT! hit is false.\n\n"; i.setHit(true); } if(i.isHit()) { std::cout<<"CORRECT! hit is true.\n\n"; } else { std::cout<<"INCORRECT! hit is false.\n\n"; } std::vector<float> ptest(3); ptest[0] = 0; ptest[1] = 1; ptest[2] = 2; i.setPoint(ptest); std::vector<float> p = i.getPoint(); std::cout<< "[" << p[0] << ", " << p[1] << ", " << p[2] << "]\n"; Vertex::Vertex a = *new Vertex::Vertex(0,0,0); Vertex::Vertex b = *new Vertex::Vertex(1,0,0); Vertex::Vertex c = *new Vertex::Vertex(0,1,0); a.print(); a = a.sub(b); a.print(); std::vector<float> d = c.toVec(); std::cout<<"vec ["<< d[0] << ", " << d[1] << ", " << d[2] << "]\n"; Vertex::Vertex e1 = *new Vertex::Vertex(d); e1.print(); Vertex a1 = *new Vertex::Vertex(0,1,0); Vertex b1 = *new Vertex::Vertex(1,-1,0); Vertex c1 = *new Vertex::Vertex(-1,-1,0); Triangle t = *new Triangle::Triangle(a1,b1,c1); p[0] = 0; p[1] = 0; p[2] = 0; std::vector<float> e(3); e[0] = 0; e[1] = 0; e[2] = 3; Ray::Ray r = *new Ray::Ray(e, p); i = t.intersect(r); if (i.isHit()) { std::cout<<"Triangle Intersected - OKAY\n"; } Sphere::Sphere s = *new Sphere::Sphere(1, p); if (s.intersect(r).isHit()) { std::cout<<"Sphere Intersected - OKAY\n"; } e[0] = 0; e[1] = -4; e[2] = -4; p[0] = 1; p[1] = 1; p[2] = -1; r.setEye(e); r.setPoint(p); std::cout<<"projected "; vPrint(r.project(1.5)); PPM* ppm = new PPM(640, 480, 255); int val; for (float h = 0; h<480; h++) { for (float w =0; w<640; w++) { val = h;//std::min(255, (int)((w/639)*255.0f)); ppm->addPixel(*(new Pixel::Pixel(val, val, val))); } } ppm->save("output"); /* for (float h = 0; h < 3; h++) { for (float w = 0; w< ppm->getW(); w++) { std::cout<<w<<" "; ppm->getPixel(w, h).print(); } } */ std::cout<<"End PPM tests\n"; Pixel::Pixel px = *new Pixel::Pixel(255, 255, 255); Pixel::Pixel black = *new Pixel::Pixel(0,0,0); Pixel::Pixel pfloat = *new Pixel::Pixel(1.0f, 0.9f, 0.05f); Pixel::Pixel pmax = *new Pixel::Pixel(2.0f, 1.0f, 0.5f); px.print(); black.print(); black.add(px); black.print(); pfloat.print(); pmax.print(); std::vector<float> test1(3); test1[0] = 1; test1[1] = 0; test1[2] = 0.5; std::vector<float> test2(3); test2[0] = 0; test2[1] = 1; test2[2] = 0.5; std::cout<<vDot(test1, test2)<<"\n"; vPrint(vSub(test1, test2)); vPrint(vAdd(test1, test2)); vPrint(vMult(test1, test2)); vPrint(normalize(test1)); vPrint(normalize(test2)); vPrint(vCross(test1, test2)); vPrint(vScale(-1, test1)); std::cout<<"\n=================\nEnd UNIT TESTS\n=================\n\n"; return 0; } else { return 0; } }
void Box3D::UpdateTransformMatrix() { m_TransformMatrix.Identity(); if ( m_TranslateMode == modeNone ) { return; } else if ( m_TranslateMode == modeMove ) { m_TransformMatrix.SetTranslation( m_vTranslation ); return; } else if ( m_TranslateMode == modeScale ) { Vector vScale( 1,1,1); Vector vMove(0,0,0); Vector vSize = bmaxs-bmins; for ( int i=0; i<3; i++ ) { float handle = m_TranslateHandle[i]; if ( vSize[i] == 0 ) continue; if ( handle > 0 ) { vScale[i] = (m_vTranslation[i]+vSize[i]) / vSize[i]; vMove[i] = m_vTranslation[i] / 2; } else if ( handle < 0 ) { vScale[i] = (-m_vTranslation[i]+vSize[i]) / vSize[i]; vMove[i] = m_vTranslation[i] / 2; } } m_TransformMatrix = m_TransformMatrix.Scale( vScale ); m_TransformMatrix.SetTranslation( vMove ); } else if ( m_TranslateMode == modeShear ) { Vector vSize = bmaxs-bmins; int axisS = -1; // shear axis that wont change int axisA = -1; // first shear axis int axisB = -1; // second shear axis for ( int i=0; i<3; i++ ) { float handle = m_TranslateHandle[i]; if ( handle > 0 ) { Assert( axisS == -1); axisS = i; } else if ( handle < 0 ) { Assert( axisS == -1); axisS = i; vSize *= -1; } else { if ( axisA == -1 ) axisA = i; else axisB = i; } } Assert( (axisA!=-1) && (axisB!=-1) && (axisS!=-1) ); m_TransformMatrix.m[axisA][axisS] = (m_vTranslation[axisA])/(vSize[axisS]); m_TransformMatrix.m[axisB][axisS] = (m_vTranslation[axisB])/(vSize[axisS]); } else if ( m_TranslateMode == modeRotate ) { QAngle angle = *(QAngle*)&m_vTranslation; // buuuhhh m_TransformMatrix.SetupMatrixOrgAngles( vec3_origin, angle ); } // apply m_vTranslationFixPoint offset Vector offset; m_TransformMatrix.V3Mul( m_vTranslationFixPoint, offset ); offset = m_vTranslationFixPoint - offset; m_TransformMatrix.m[0][3] += offset[0]; m_TransformMatrix.m[1][3] += offset[1]; m_TransformMatrix.m[2][3] += offset[2]; }
LTBOOL CSearchLightFX::Update() { if (!m_pClientDE || !m_hServerObject || m_bWantRemove || !m_hBeam) return LTFALSE; uint32 dwFlags = 0; // Update the lens flare... m_LensFlare.Update(); // Hide/show the fx if necessary... if (m_hServerObject) { uint32 dwUserFlags; m_pClientDE->GetObjectUserFlags(m_hServerObject, &dwUserFlags); if (!(dwUserFlags & USRFLG_VISIBLE)) // Hide fx { if (m_hBeam) { dwFlags = m_pClientDE->GetObjectFlags(m_hBeam); m_pClientDE->SetObjectFlags(m_hBeam, dwFlags & ~FLAG_VISIBLE); } if (m_hLight) { dwFlags = m_pClientDE->GetObjectFlags(m_hLight); m_pClientDE->SetObjectFlags(m_hLight, dwFlags & ~FLAG_VISIBLE); } return LTTRUE; } else // Make all fx visible { if (m_hBeam) { dwFlags = m_pClientDE->GetObjectFlags(m_hBeam); m_pClientDE->SetObjectFlags(m_hBeam, dwFlags | FLAG_VISIBLE); } if (m_hLight) { dwFlags = m_pClientDE->GetObjectFlags(m_hLight); m_pClientDE->SetObjectFlags(m_hLight, dwFlags | FLAG_VISIBLE); } } } // Update the position/rotation of the beam... LTVector vPos; m_pClientDE->GetObjectPos(m_hServerObject, &vPos); LTRotation rRot; m_pClientDE->GetObjectRotation(m_hServerObject, &rRot); LTVector vU, vR, vF; m_pClientDE->GetRotationVectors(&rRot, &vU, &vR, &vF); // See how long to make the beam... LTVector vDest = vPos + (vF * m_cs.fBeamLength); IntersectInfo iInfo; IntersectQuery qInfo; qInfo.m_Flags = INTERSECT_OBJECTS | IGNORE_NONSOLID; qInfo.m_FilterFn = AttackerLiquidFilterFn; qInfo.m_pUserData = m_hServerObject; qInfo.m_From = vPos; qInfo.m_To = vDest; if (g_pLTClient->IntersectSegment(&qInfo, &iInfo)) { vDest = iInfo.m_Point; } LTVector vDir = vDest - vPos; LTFLOAT fDistance = vDir.Mag(); vDir.Norm(); LTVector vNewPos = vPos + vDir * fDistance/2.0f; m_pClientDE->AlignRotation(&rRot, &vDir, NULL); if (m_cs.fBeamRotTime > 0.0f) { m_fBeamRotation += (360.0f/m_cs.fBeamRotTime * g_pGameClientShell->GetFrameTime()); m_fBeamRotation = m_fBeamRotation > 360.0f ? m_fBeamRotation - 360.0f : m_fBeamRotation; m_pClientDE->RotateAroundAxis(&rRot, &vDir, DEG2RAD(m_fBeamRotation)); } m_pClientDE->SetObjectRotation(m_hBeam, &rRot); m_pClientDE->SetObjectPos(m_hBeam, &vNewPos); LTVector vScale(m_cs.fBeamRadius, m_cs.fBeamRadius, fDistance); m_pClientDE->SetObjectScale(m_hBeam, &vScale); // Move the dynamic light... if (m_hLight) { vDest -= (vDir * 5.0f); m_pClientDE->SetObjectPos(m_hLight, &vDest); } return LTTRUE; }