void CRenderingContext::RenderText(const tstring& sText, unsigned iLength, FTFont* pFont) { TAssert(m_pShader); if (!m_pShader) return; CRenderContext& oContext = GetContext(); if (iLength == -1) iLength = sText.length(); TAssert(m_pShader->m_iPositionAttribute >= 0); TAssert(m_pShader->m_aiTexCoordAttributes[0] >= 0); if (!oContext.m_bProjectionUpdated) SetUniform("mProjection", oContext.m_mProjection); if (!oContext.m_bViewUpdated) SetUniform("mView", oContext.m_mView); // Take the position out and let FTGL do it. It looks sharper that way. Matrix4x4 mTransformations = oContext.m_mTransformations; Vector vecPosition = mTransformations.GetTranslation(); mTransformations.SetTranslation(Vector()); SetUniform("mGlobal", mTransformations); oContext.m_bProjectionUpdated = oContext.m_bViewUpdated = oContext.m_bTransformUpdated = true; ftglSetAttributeLocations(m_pShader->m_iPositionAttribute, m_pShader->m_aiTexCoordAttributes[0]); pFont->Render(sText.c_str(), iLength, FTPoint(vecPosition.x, vecPosition.y, vecPosition.z)); }
void ResizeMap(FileMappingInfo* mapping_info, size_t minimum_size) { munmap(mapping_info->m_memory, mapping_info->m_memory_size); struct stat file_statbuf; fstat(mapping_info->m_file_handle, &file_statbuf); int file_size = file_statbuf.st_size; // I'm not sure this will ever happen. If years go by and this assert is // never hit then the fstat and the next tmax below can be removed. TAssert(file_size <= minimum_size); minimum_size = tmax(minimum_size, file_size); int page_size = sysconf(_SC_PAGESIZE); int remainder = stb_mod_eucl(minimum_size, page_size); int aligned_size; if (remainder) aligned_size = minimum_size - stb_mod_eucl(minimum_size, page_size) + page_size; else aligned_size = tmax(minimum_size, page_size); int truncated = ftruncate(mapping_info->m_file_handle, aligned_size); TAssert(truncated == 0); mapping_info->m_memory_size = aligned_size; mapping_info->m_memory = mmap(nullptr, aligned_size, PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED, mapping_info->m_file_handle, 0); }
void CRenderingContext::SetPositionBuffer(size_t iOffset, size_t iStride) { TAssert(iOffset%4 == 0); // Should be multiples of four because it's offsets in bytes and we're always working with floats or doubles TAssert(m_pShader->m_iPositionAttribute != ~0); glEnableVertexAttribArray(m_pShader->m_iPositionAttribute); glVertexAttribPointer(m_pShader->m_iPositionAttribute, 3, GL_FLOAT, false, iStride, BUFFER_OFFSET(iOffset)); }
virtual btScalar addSingleResult(btCollisionWorld::LocalConvexResult& convexResult, bool normalInWorldSpace) { if (!m_pController->IsColliding()) return 1; if (convexResult.m_hitCollisionObject == m_me) return btScalar(1.0); if (convexResult.m_hitCollisionObject->getBroadphaseHandle()->m_collisionFilterGroup & CG_TRIGGER) return 1; if (!convexResult.m_hitCollisionObject->hasContactResponse()) return btScalar(1.0); if ((size_t)convexResult.m_hitCollisionObject->getUserPointer() >= GameServer()->GetMaxEntities()) { size_t iIndex = (size_t)convexResult.m_hitCollisionObject->getUserPointer() - GameServer()->GetMaxEntities(); CBaseEntity* pControllerEntity = m_pController->GetEntity(); TAssert(pControllerEntity); if (pControllerEntity) { TAssert(normalInWorldSpace); if (!pControllerEntity->ShouldCollideWithExtra(iIndex, Vector(convexResult.m_hitPointLocal))) return 1; } } else { CEntityHandle<CBaseEntity> hCollidedEntity((size_t)convexResult.m_hitCollisionObject->getUserPointer()); TAssert(hCollidedEntity != NULL); if (hCollidedEntity.GetPointer()) { CBaseEntity* pControllerEntity = m_pController->GetEntity(); TAssert(pControllerEntity); if (pControllerEntity) { TAssert(normalInWorldSpace); if (!pControllerEntity->ShouldCollideWith(hCollidedEntity, Vector(convexResult.m_hitPointLocal))) return 1; } } } btVector3 hitNormalWorld; if (normalInWorldSpace) { hitNormalWorld = convexResult.m_hitNormalLocal; } else { ///need to transform normal into worldspace hitNormalWorld = convexResult.m_hitCollisionObject->getWorldTransform().getBasis()*convexResult.m_hitNormalLocal; } btScalar dotUp = m_up.dot(hitNormalWorld); if (dotUp < 0) return btScalar(1.0); return ClosestConvexResultCallback::addSingleResult (convexResult, normalInWorldSpace); }
void CRenderingContext::CreateVBO(size_t& iVBO, size_t& iVBOSize) { TAssert(m_pRenderer); if (!m_pRenderer) return; TAssert(s_avecVertices.size()); if (!s_avecVertices.size()) return; TAssert(m_iDrawMode == GL_TRIANGLES); size_t iDataSize = 0; iDataSize += s_avecVertices.size()*3; for (size_t i = 0; i < s_aavecTexCoords.size(); i++) iDataSize += s_aavecTexCoords[i].size()*2; iDataSize += s_avecNormals.size()*3; tvector<float> aflData; aflData.reserve(iDataSize); TAssert(!s_avecNormals.size() || s_avecVertices.size() == s_avecNormals.size()); for (size_t i = 0; i < s_aavecTexCoords.size(); i++) TAssert(!s_aavecTexCoords[i].size() || s_avecVertices.size() == s_aavecTexCoords[i].size()); for (size_t i = 0; i < s_avecVertices.size(); i++) { Vector& vecVert = s_avecVertices[i]; aflData.push_back(vecVert.x); aflData.push_back(vecVert.y); aflData.push_back(vecVert.z); if (s_avecNormals.size()) { Vector& vecNormal = s_avecNormals[i]; aflData.push_back(vecNormal.x); aflData.push_back(vecNormal.y); aflData.push_back(vecNormal.z); } for (size_t j = 0; j < s_aavecTexCoords.size(); j++) { if (s_aavecTexCoords[j].size()) { Vector2D& vecUV = s_aavecTexCoords[j][i]; aflData.push_back(vecUV.x); aflData.push_back(vecUV.y); } } } iVBO = m_pRenderer->LoadVertexDataIntoGL(aflData.size()*sizeof(float), aflData.data()); iVBOSize = s_avecVertices.size(); }
void CRenderingContext::SetTexCoordBuffer(size_t iOffset, size_t iStride, size_t iChannel) { TAssert(iChannel >= 0 && iChannel < MAX_TEXTURE_CHANNELS); if (m_pShader->m_aiTexCoordAttributes[iChannel] == ~0) return; TAssert(iOffset%4 == 0); // Should be multiples of four because it's offsets in bytes and we're always working with floats or doubles glEnableVertexAttribArray(m_pShader->m_aiTexCoordAttributes[iChannel]); glVertexAttribPointer(m_pShader->m_aiTexCoordAttributes[iChannel], 2, GL_FLOAT, false, iStride, BUFFER_OFFSET(iOffset)); }
size_t CShaderLibrary::GetProgram(const tstring& sName) { TAssert(Get()); if (!Get()) return 0; TAssert(Get()->GetShader(sName)); if (!Get()->GetShader(sName)) return 0; return Get()->GetShader(sName)->m_iProgram; }
void CRenderingContext::SetCustomIntBuffer(const char* pszName, size_t iSize, size_t iOffset, size_t iStride) { int iAttribute = glGetAttribLocation(m_iProgram, pszName); TAssert(iAttribute != ~0); if (iAttribute == ~0) return; TAssert(iOffset%4 == 0); // Should be multiples of four because it's offsets in bytes and we're always working with floats or doubles glEnableVertexAttribArray(iAttribute); glVertexAttribIPointer(iAttribute, iSize, GL_INT, iStride, BUFFER_OFFSET(iOffset)); }
DoubleVector CTreeManager::GetTreeOrigin(const CTreeAddress& oAddress) const { TAssert(oAddress.IsValid()); if (!oAddress.IsValid()) return DoubleVector(); const CChunkTrees* pChunkTrees = GetChunkTrees(oAddress.iTerrain, oAddress.vecMin); TAssert(pChunkTrees); if (!pChunkTrees) return DoubleVector(); return pChunkTrees->GetTreeOrigin(oAddress.iTree); }
void CALLBACK GLDebugCallback(GLenum iSource, GLenum iType, GLuint id, GLenum iSeverity, GLsizei iLength, const GLchar* pszMessage, GLvoid* pUserParam) { if (iType != GL_DEBUG_TYPE_PERFORMANCE_ARB) { TAssert(iSeverity != GL_DEBUG_SEVERITY_HIGH_ARB); TAssert(iSeverity != GL_DEBUG_SEVERITY_MEDIUM_ARB); } if (gl_debug.GetBool()) { tstring sMessage = "OpenGL Debug Message ("; if (iSource == GL_DEBUG_SOURCE_API_ARB) sMessage += "Source: API "; else if (iSource == GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB) sMessage += "Source: Window System "; else if (iSource == GL_DEBUG_SOURCE_SHADER_COMPILER_ARB) sMessage += "Source: Shader Compiler "; else if (iSource == GL_DEBUG_SOURCE_THIRD_PARTY_ARB) sMessage += "Source: Third Party "; else if (iSource == GL_DEBUG_SOURCE_APPLICATION_ARB) sMessage += "Source: Application "; else if (iSource == GL_DEBUG_SOURCE_OTHER_ARB) sMessage += "Source: Other "; if (iType == GL_DEBUG_TYPE_ERROR_ARB) sMessage += "Type: Error "; else if (iType == GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB) sMessage += "Type: Deprecated Behavior "; else if (iType == GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB) sMessage += "Type: Undefined Behavior "; else if (iType == GL_DEBUG_TYPE_PORTABILITY_ARB) sMessage += "Type: Portability "; else if (iType == GL_DEBUG_TYPE_PERFORMANCE_ARB) sMessage += "Type: Performance "; else if (iType == GL_DEBUG_TYPE_OTHER_ARB) sMessage += "Type: Other "; if (iSeverity == GL_DEBUG_SEVERITY_HIGH_ARB) sMessage += "Severity: High) "; else if (iSeverity == GL_DEBUG_SEVERITY_MEDIUM_ARB) sMessage += "Severity: Medium) "; else if (iSeverity == GL_DEBUG_SEVERITY_LOW_ARB) sMessage += "Severity: Low) "; sMessage += convertstring<GLchar, tchar>(pszMessage) + "\n"; TMsg(convertstring<GLchar, tchar>(sMessage).c_str()); } }
void CTreeManager::RemoveTree(const CTreeAddress& oAddress) { TAssert(oAddress.IsValid()); if (!oAddress.IsValid()) return; CChunkTrees* pChunkTrees = GetChunkTrees(oAddress.iTerrain, oAddress.vecMin); TAssert(pChunkTrees); if (!pChunkTrees) return; pChunkTrees->RemoveTree(oAddress.iTree); }
bool CAOGenerator::Texel(size_t w, size_t h, size_t& iTexel, bool bUseMask) { if (w < 0 || h < 0 || w >= m_iWidth || h >= m_iHeight) return false; TAssert(m_iHeight == m_iWidth); // This formula is actually wrong unless the thing is a perfect square iTexel = m_iHeight*(m_iHeight-h-1) + w; TAssert(iTexel >= 0 && iTexel < m_iWidth * m_iHeight); if (bUseMask && !m_bPixelMask[iTexel]) return false; return true; }
void CToyUtil::AddSceneAreaVisible(size_t iSceneArea, size_t iVisible) { TAssert(iSceneArea < m_asSceneAreas.size()); if (iSceneArea >= m_asSceneAreas.size()) return; TAssert(iVisible < m_asSceneAreas.size()); if (iVisible >= m_asSceneAreas.size()) return; if (IsVisibleFrom(iSceneArea, iVisible)) return; m_asSceneAreas[iSceneArea].m_aiVisibleAreas.push_back(iVisible); }
bool CTexelGenerator::Texel(size_t w, size_t h, size_t& iTexel, size_t tw, size_t th, bool* abMask) { if (w < 0 || h < 0 || w >= tw || h >= th) return false; TAssert(tw == th); // This formula is actually wrong unless the thing is a perfect square iTexel = th*(th-h-1) + w; TAssert(iTexel >= 0 && iTexel < tw * th); if (abMask && !abMask[iTexel]) return false; return true; }
void CStructure::SetPhysicsTransform(const Matrix4x4& m) { CPlanet* pPlanet = GameData().GetPlanet(); if (!pPlanet) { SetLocalTransform(TMatrix(m)); return; } if (!pPlanet->GetChunkManager()->HasGroupCenter()) { SetLocalTransform(TMatrix(m)); return; } GameData().SetGroupTransform(m); TMatrix mLocalTransform(pPlanet->GetChunkManager()->GetGroupCenterToPlanetTransform() * m); CBaseEntity* pMoveParent = GetMoveParent(); TAssert(pMoveParent); if (pMoveParent) { while (pMoveParent != pPlanet) { mLocalTransform = pMoveParent->GetLocalTransform().InvertedRT() * mLocalTransform; pMoveParent = pMoveParent->GetMoveParent(); } } SetLocalTransform(mLocalTransform); }
void CRenderingContext::RenderBillboard(const CMaterialHandle& hMaterial, float flRadius, Vector vecUp, Vector vecRight) { TAssert(hMaterial.IsValid()); if (!hMaterial.IsValid()) return; vecUp *= flRadius; vecRight *= flRadius; // Clear out any existing rotation so that they don't interfere with the billboarding below. GetContext().m_mTransformations.SetAngles(EAngle(0, 0, 0)); GetContext().m_bTransformUpdated = false; if (GetContext().m_hMaterial != hMaterial) UseMaterial(hMaterial); BeginRenderTriFan(); TexCoord(0.0f, 1.0f); Vertex(-vecRight + vecUp); TexCoord(0.0f, 0.0f); Vertex(-vecRight - vecUp); TexCoord(1.0f, 0.0f); Vertex(vecRight - vecUp); TexCoord(1.0f, 1.0f); Vertex(vecRight + vecUp); EndRender(); }
CChunkTrees* CTreeManager::AddChunkTrees(size_t iTerrain, const DoubleVector2D& vecMin) { CChunkAddress oChunkAddress; oChunkAddress.iTerrain = iTerrain; oChunkAddress.vecMin = vecMin; CTerrainChunk* pTheChunkWereLookingFor = nullptr; for (size_t i = 0; i < m_pPlanet->GetChunkManager()->GetNumChunks(); i++) { CTerrainChunk* pChunk = m_pPlanet->GetChunkManager()->GetChunk(i); if (!pChunk) continue; if (pChunk->GetTerrain() != iTerrain) continue; if (pChunk->GetMin2D() != vecMin) continue; pTheChunkWereLookingFor = pChunk; break; } TAssert(pTheChunkWereLookingFor); DoubleMatrix4x4 mChunk; if (pTheChunkWereLookingFor) mChunk = pTheChunkWereLookingFor->GetChunkToPlanet(); return &m_aChunkTrees.insert(tpair<CChunkAddress, CChunkTrees>(oChunkAddress, CChunkTrees(this, mChunk))).first->second; }
void CEditorPanel::TargetEntityChangedCallback(const tstring& sArgs) { CLevel* pLevel = LevelEditor()->GetLevel(); if (!pLevel) return; auto pOutput = GetCurrentOutput(); if (!pOutput) return; pOutput->m_sTargetName = m_hOutputEntityNameText->GetText(); tvector<tstring> asTargets; for (size_t i = 0; i < pLevel->GetEntityData().size(); i++) { auto* pEntity = &pLevel->GetEntityData()[i]; if (!pEntity) continue; if (!pEntity->GetName().length()) continue; CEntityRegistration* pRegistration = CBaseEntity::GetRegisteredEntity("C"+pEntity->GetClass()); TAssert(pRegistration); if (!pRegistration) continue; asTargets.push_back(pEntity->GetName()); } m_hOutputEntityNameText->SetAutoCompleteCommands(asTargets); LayoutInput(); }
size_t CToyUtil::AddSceneArea(const tstring& sFileName) { CToy* pArea = new CToy(); bool bRead = CToyUtil::Read(GetGameDirectory() + T_DIR_SEP + sFileName, pArea); if (!bRead) { delete pArea; TAssert(bRead); TError("Couldn't find scene area " + sFileName + "\n"); return ~0; } CSceneArea& oSceneArea = m_asSceneAreas.push_back(); oSceneArea.m_sFileName = sFileName; oSceneArea.m_aabbArea = pArea->GetVisBounds(); // I'm visible to myself. oSceneArea.m_aiNeighboringAreas.push_back(m_asSceneAreas.size()-1); delete pArea; return m_asSceneAreas.size()-1; }
CGameServer::~CGameServer() { GameNetwork()->SetCallbacks(NULL, NULL, NULL, NULL); if (m_pWorkListener) m_pWorkListener->BeginProgress(); if (m_pWorkListener) m_pWorkListener->SetAction("Scrubbing database", CBaseEntity::GetEntityRegistration().size()); DestroyAllEntities(tvector<tstring>()); GamePhysics()->RemoveAllEntities(); for (size_t i = 0; i < m_apLevels.size(); i++) m_apLevels[i].reset(); if (m_pCameraManager) delete m_pCameraManager; if (m_pWorkListener) m_pWorkListener->EndProgress(); TAssert(s_pGameServer == this); s_pGameServer = NULL; }
NTSTATUS INTERNAL ReadReport( __in PDEVICE_EXTENSION DevExt, __in PIRP Irp, __out BOOLEAN *fSentDown ) { NTSTATUS status; PIO_STACK_LOCATION irpsp = IoGetCurrentIrpStackLocation(Irp); ULONG DataLen = irpsp->Parameters.DeviceIoControl.OutputBufferLength; TEnter(Func, ("(DevExt=%p,Irp=%p,IrpSp=%p)", DevExt, Irp, irpsp)); TAssert(Irp->UserBuffer != NULL); if (DataLen != sizeof(HID_INPUT_REPORT)) { status = STATUS_INVALID_BUFFER_SIZE; LogError(ERRLOG_INVALID_BUFFER_SIZE, status, UNIQUE_ERRID(0x60), NULL, NULL); TWarn(("Invalid input report size (len=%d,Expected=%d).", DataLen, sizeof(HID_INPUT_REPORT))); } else { status = OemReadReport(DevExt, Irp, fSentDown); } TExit(Func, ("=%x", status)); return status; } //ReadReport
void CLobbyPanel::BeginGameCallback(int iConnection, INetworkListener*, class CNetworkParameters*) { TAssert(iConnection == CONNECTION_LOBBY); CDigitanksLevel* pLevel = CDigitanksGame::GetLevel(CGameLobbyClient::L_GetInfoValue(_T("level_file"))); if (!pLevel) return; CVar::SetCVar(_T("game_level"), pLevel->GetFile()); DigitanksWindow()->GetLobbyPanel()->SetVisible(false); const char* pszPort = DigitanksWindow()->GetCommandLineSwitchValue("--port"); int iPort = pszPort?atoi(pszPort):0; if (LobbyNetwork()->IsHost()) GameNetwork()->CreateHost(iPort); else GameNetwork()->ConnectToHost(convertstring<tchar, char>(DigitanksWindow()->GetLobbyPanel()->m_sHost).c_str(), iPort); if (GameNetwork()->IsConnected()) DigitanksWindow()->Restart(GAMETYPE_FROM_LOBBY); else DigitanksWindow()->Restart(GAMETYPE_MENU); }
void CReflectionProxy::Spawn() { TAssert(!s_pProxy); s_pProxy = this; BaseClass::Spawn(); }
void Matrix4x4::SetRotation(float flAngle, const Vector& v) { // Normalize beforehand TAssert(fabs(v.LengthSqr() - 1) < 0.000001f); // c = cos(angle), s = sin(angle), t = (1-c) // [ xxt+c xyt-zs xzt+ys ] // [ yxt+zs yyt+c yzt-xs ] // [ zxt-ys zyt+xs zzt+c ] float x = v.x; float y = v.y; float z = v.z; float c = cos(flAngle*(float)M_PI/180); float s = sin(flAngle*(float)M_PI/180); float t = 1-c; m[0][0] = x*x*t + c; m[1][0] = x*y*t - z*s; m[2][0] = x*z*t + y*s; m[0][1] = y*x*t + z*s; m[1][1] = y*y*t + c; m[2][1] = y*z*t - x*s; m[0][2] = z*x*t - y*s; m[1][2] = z*y*t + x*s; m[2][2] = z*z*t + c; }
void CToyEditor::ManipulatorUpdated(const tstring& sArguments) { // Grab this before GetToyToModify since that does a layout and clobbers the list. size_t iSelected = m_pSourcePanel->m_pPhysicsShapes->GetSelectedNodeId(); tvector<tstring> asTokens; strtok(sArguments, asTokens); TAssert(asTokens.size() == 2); TAssert(stoi(asTokens[1]) == iSelected); TAssert(iSelected != ~0); if (iSelected >= ToyEditor()->GetToy().m_aShapes.size()) return; ToyEditor()->GetToyToModify().m_aShapes[iSelected].m_trsTransform = Manipulator()->GetTRS(); }
Vector CToy::GetPhysicsBoxHalfSize(size_t iBox) { TRS& trs = GetPhysicsBox(iBox); TAssert(trs.m_angRotation.p == 0); TAssert(trs.m_angRotation.y == 0); TAssert(trs.m_angRotation.r == 0); Matrix4x4 mTRS = trs.GetMatrix4x4(); AABB aabbBox = s_aabbBoxDimensions; aabbBox.m_vecMins = mTRS*aabbBox.m_vecMins; aabbBox.m_vecMaxs = mTRS*aabbBox.m_vecMaxs; return aabbBox.m_vecMaxs - aabbBox.Center(); }
void CRenderingContext::EndRender() { TAssert(m_pShader); if (!m_pShader) { UseProgram("model"); if (!m_pShader) return; } SetUniform("mProjection", GetContext().m_mProjection); SetUniform("mView", GetContext().m_mView); SetUniform("mGlobal", GetContext().m_mTransformations); if (m_bTexCoord && m_pShader->m_iTexCoordAttribute != ~0) { glEnableVertexAttribArray(m_pShader->m_iTexCoordAttribute); glVertexAttribPointer(m_pShader->m_iTexCoordAttribute, 2, GL_FLOAT, false, 0, m_aavecTexCoords[0].data()); } if (m_bNormal && m_pShader->m_iNormalAttribute != ~0) { glEnableVertexAttribArray(m_pShader->m_iNormalAttribute); glVertexAttribPointer(m_pShader->m_iNormalAttribute, 3, GL_FLOAT, false, 0, m_avecNormals.data()); } if (m_bColor && m_pShader->m_iColorAttribute != ~0) { glEnableVertexAttribArray(m_pShader->m_iColorAttribute); glVertexAttribPointer(m_pShader->m_iColorAttribute, 3, GL_UNSIGNED_BYTE, true, sizeof(::Color), m_aclrColors.data()); } TAssert(m_pShader->m_iPositionAttribute != ~0); glEnableVertexAttribArray(m_pShader->m_iPositionAttribute); glVertexAttribPointer(m_pShader->m_iPositionAttribute, 3, GL_FLOAT, false, 0, m_avecVertices.data()); glDrawArrays(m_iDrawMode, 0, m_avecVertices.size()); glDisableVertexAttribArray(m_pShader->m_iPositionAttribute); if (m_pShader->m_iTexCoordAttribute != ~0) glDisableVertexAttribArray(m_pShader->m_iTexCoordAttribute); if (m_pShader->m_iNormalAttribute != ~0) glDisableVertexAttribArray(m_pShader->m_iNormalAttribute); if (m_pShader->m_iColorAttribute != ~0) glDisableVertexAttribArray(m_pShader->m_iColorAttribute); }
void CChunkTrees::Load() { TAssert(m_pManager->m_pPlanet->GetChunkManager()->HasGroupCenter()); TAssert(m_avecOrigins.size()); TAssert(!m_aiPhysicsBoxes.size()); DoubleMatrix4x4 mPlanetToGroup = m_pManager->m_pPlanet->GetChunkManager()->GetPlanetToGroupCenterTransform(); float flScale = (float)CScalableFloat::ConvertUnits(1, m_pManager->m_pPlanet->GetScale(), SCALE_METER); for (size_t i = 0; i < m_avecOrigins.size(); i++) { size_t iPhysicsBox = GamePhysics()->AddExtraBox(mPlanetToGroup * (m_avecOrigins[i]*flScale), Vector(1, 5, 1)); m_aiPhysicsBoxes.push_back(iPhysicsBox); } }
DoubleVector CChunkTrees::GetTreeOrigin(size_t iTree) const { TAssert(iTree < m_avecOrigins.size()); if (iTree >= m_avecOrigins.size()) return DoubleVector(); return m_avecOrigins[iTree]; }
void CCharacterController::updateAction(btCollisionWorld* pCollisionWorld, btScalar deltaTime) { if (!m_bColliding) return; TAssert(dynamic_cast<CCharacter*>(GetEntity())); static_cast<CCharacter*>(GetEntity())->CharacterMovement(pCollisionWorld, deltaTime); }