/** * CActor::setPosition * @date Modified Mar 07, 2006 */ void CActor::setOrientation(D3DXVECTOR3 &vOrient) { // make sure the length of the orientation is about one float fLength= D3DXVec3Dot(&vOrient, &vOrient); if(fLength > 1.02f || fLength < 0.98f) { // normalize the orientation vector fLength = fastSqrtf(fLength); fLength = 1.0f/fLength; vOrient *= fLength; } // find the new right axis of the matrix with the current up vector D3DXVECTOR3 vRight(m_ActorMatrix._21/m_vScale.x, m_ActorMatrix._22/m_vScale.y, m_ActorMatrix._23/m_vScale.z); D3DXVec3Cross(&vRight, &vRight, &vOrient); D3DXVec3Normalize(NULL, &vRight, &vRight); // set the matrix with the scale back in it m_ActorMatrix._11 = vRight.x*m_vScale.x; m_ActorMatrix._12 = vRight.y*m_vScale.y; m_ActorMatrix._13 = vRight.z*m_vScale.z; m_ActorMatrix._31 = vOrient.x*m_vScale.x; m_ActorMatrix._32 = vOrient.y*m_vScale.y; m_ActorMatrix._33 = vOrient.z*m_vScale.z; }
void M2EffectRender::UpdateParicles() { if (!ParticleData_.gpEffect10) return; //if (fElapsedTime > 0.1f) fElapsedTime = 0.1f; D3DXVECTOR3 vEye; GetCamera()->getFrom(vEye); D3DXMATRIX mView; memcpy(&mView, GetCamera()->getViewMatrix(), SIZE16); D3DXVECTOR3 vRight( mView._13, mView._23, mView._33 ); D3DXVECTOR3 vUp( mView._12, mView._22, mView._32 ); D3DXVECTOR3 vFoward( mView._11, mView._21, mView._31 ); D3DXVec3Normalize( &vRight, &vRight ); D3DXVec3Normalize( &vUp, &vUp ); D3DXVec3Normalize( &vFoward, &vFoward ); //gpvRight->SetFloatVector( ( float* )&vRight ); //gpvUp->SetFloatVector( ( float* )&vUp ); //gpvForward->SetFloatVector( ( float* )&vFoward ); ParticleData_.gpvEyePt->SetFloatVector( ( float* )&vEye ); ParticleVertex* pVerts = NULL; M2ParticleSystem* ps ; for (size_t i=0; i < Owner_->header.nParticleEmitters; ++i) { ps = &Owner_->particleSystems[i]; ID3D11Resource* pRes = ParticleData_.ParticleBuffers.at(i); D3D11_MAPPED_SUBRESOURCE Data; HRESULT hr = GetApp()->GetContext()->Map( pRes, 0, D3D11_MAP_WRITE_DISCARD, 0, &Data ); if (FAILED(hr)) assert(false); pVerts = (ParticleVertex*)Data.pData; CopyParticlesToVertexBuffer(i, ps, pVerts, vEye, -vFoward, vUp ); GetApp()->GetContext()->Unmap(pRes, 0); } }
void M2EffectRender::CopyRibbonsToVertexBuffer( int index, M2RibbonEmitter& Ribbon, RibbonVertex* pVB ) { noVec3 vRight(0,0,-1); noVec3 vUp(0,1,0); UINT iVBIndex = 0; uint32 gNumActiveParticles = 0; for (size_t i=0; i< 1 ; i++) { std::list<M2RibbonSegment>::iterator it = Ribbon.segs.begin(); float l = 0; for (; it != Ribbon.segs.end(); ++it) { float u = l/Ribbon.length; pVB[iVBIndex].pos = it->pos + Ribbon.tabove * it->up; pVB[iVBIndex].uv = noVec2(u, 0); pVB[iVBIndex].color = Ribbon.tcolor; pVB[++iVBIndex].pos = it->pos - Ribbon.tbelow * it->up; pVB[iVBIndex].uv = noVec2(u,1); pVB[iVBIndex].color = Ribbon.tcolor; ++iVBIndex; gNumActiveParticles ++; l += it->len; } if (Ribbon.segs.size() > 1) { // last segment...? --it; pVB[iVBIndex].pos = it->pos + Ribbon.tabove * it->up + (it->len/it->len0) * it->back; pVB[iVBIndex].uv = noVec2(1, 0); pVB[iVBIndex].color = Ribbon.tcolor; pVB[++iVBIndex].pos = it->pos - Ribbon.tbelow * it->up + (it->len/it->len0) * it->back; pVB[iVBIndex].uv = noVec2(1,1); pVB[iVBIndex].color = Ribbon.tcolor; gNumActiveParticles++; } } RibbonData_.gNumActiveParticles.at(index) = gNumActiveParticles; }
void VFreeCamera::ProcessInput(float fTimeDiff) { hkvVec3 vMoveDelta = hkvVec3::ZeroVector(); // Handle movement. hkvVec3 vForward(hkvNoInitialization), vRight(hkvNoInitialization), vUp(hkvNoInitialization); GetCurrentMoveAxes(vForward, vRight, vUp); float fMaxSpeed = m_fMoveSpeed; if (m_pInputMap->GetTrigger(CONTROL_SPEED_FAST)) fMaxSpeed *= 3.0f; else if (m_pInputMap->GetTrigger(CONTROL_SPEED_FASTER)) fMaxSpeed *= 9.0f; // Accumulate move directions (multiply in order to take analog input into account). vMoveDelta += vForward * m_pInputMap->GetTrigger(CONTROL_MOVE_FORWARD); vMoveDelta -= vForward * m_pInputMap->GetTrigger(CONTROL_MOVE_BACKWARD); vMoveDelta -= vRight * m_pInputMap->GetTrigger(CONTROL_MOVE_RIGHT); vMoveDelta += vRight * m_pInputMap->GetTrigger(CONTROL_MOVE_LEFT); vMoveDelta += vUp * m_pInputMap->GetTrigger(CONTROL_MOVE_UP); vMoveDelta -= vUp * m_pInputMap->GetTrigger(CONTROL_MOVE_DOWN); vMoveDelta *= fMaxSpeed; // Clamp movement, so that moving diagonally is not faster than moving straight when using digital input. const float fSpeed = vMoveDelta.getLength(); if (fSpeed > fMaxSpeed) vMoveDelta.setLength(fMaxSpeed); vMoveDelta *= fTimeDiff; // Look around. const float dx = m_pInputMap->GetTrigger(CONTROL_HORIZONTAL_LOOK); const float dy = m_pInputMap->GetTrigger(CONTROL_VERTICAL_LOOK); hkvVec3 vOrientation = GetOrientation(); vOrientation.x += -dx * m_fSensitivity; vOrientation.y = hkvMath::clamp(vOrientation.y + dy * m_fSensitivity, -89.5f, 89.5f); SetOrientation(vOrientation); // Apply delta. if (GetPhysicsObject() != NULL) { IncMotionDeltaWorldSpace(vMoveDelta); } else { IncPosition(vMoveDelta); } }
BOOL VWallmarkManager::TryAlignWallmark( const hkvVec3& vCenter, const hkvVec3& vNormal, float fSize, float fRotation, hkvVec3& vNewCenter, hkvMat3 &alignment, float fEpsilon ) { VISION_PROFILE_FUNCTION(PROFILING_WALLMARK_CREATION); hkvVec3 vNewNormal(hkvNoInitialization); float fTraceRad = fSize; if (!IsTracePointOnPlane(vCenter,vNormal,fTraceRad,fEpsilon,vNewNormal)) return false; hkvVec3 vRight(hkvNoInitialization),vUp(hkvNoInitialization),vRotRight(hkvNoInitialization),vRotUp(hkvNoInitialization), vDummy(hkvNoInitialization); if (hkvMath::Abs (vNewNormal.x)>0.5f) vRight.set(0.f,1.f,0.f); else vRight.set(1.f,0.f,0.f); vUp = vNewNormal.cross(vRight); vRight = vNewNormal.cross(vUp); float fSin = hkvMath::sinDeg (fRotation); float fCos = hkvMath::cosDeg (fRotation); vRotRight = vRight * fCos + vUp * fSin; vRotUp = vRight * -fSin + vUp * fCos; vRotRight.setLength(fSize*0.5f); vRotUp.setLength(fSize*0.5f); alignment.setAxisXYZ (vNewNormal,vRotRight,vRotUp); vNewCenter = vCenter + vNewNormal*fEpsilon; // check corners: if (!IsTracePointOnPlane(vCenter+vRotRight+vRotUp,vNewNormal,fTraceRad,fEpsilon,vDummy)) return false; if (!IsTracePointOnPlane(vCenter+vRotRight-vRotUp,vNewNormal,fTraceRad,fEpsilon,vDummy)) return false; if (!IsTracePointOnPlane(vCenter-vRotRight+vRotUp,vNewNormal,fTraceRad,fEpsilon,vDummy)) return false; if (!IsTracePointOnPlane(vCenter-vRotRight-vRotUp,vNewNormal,fTraceRad,fEpsilon,vDummy)) return false; return TRUE; }
//---------------------------------------------------------- /// Set Look At /// /// Set the camera orientation, target and position /// @param Position /// @param Look target /// @param Up direction //---------------------------------------------------------- void Transform::SetLookAt(const Core::Vector3& invPos, const Core::Vector3& invTarget, const Core::Vector3& invUp) { Core::Vector3 vUp(invUp); Core::Vector3 vForward(invTarget - invPos); vForward.Normalise(); Core::Vector3 vRight(Vector3::CrossProduct(vUp, vForward)); vUp = Core::Vector3::CrossProduct(vForward, vRight); vUp.Normalise(); vRight.Normalise(); Core::Quaternion cRot(vRight, vUp, vForward); cRot.Normalise(); SetPositionScaleOrientation(invPos, mvScale, cRot); }
int totalNQueens(int n) { // Start typing your C/C++ solution below // DO NOT write int main() function vector<bool> vCol(n); vector<bool> vLeft(2 * n - 1); vector<bool> vRight(2 * n - 1); int ans = 0; for (int i = 0; i < n; i++) { vCol[i] = false; } for (int i = 0; i < 2 * n - 1; i++) { vLeft[i] = vRight[i] = false; } vector<int> a; DFS(ans, a, vCol, vLeft, vRight, 0, n); return ans; }
const mtx& mtx::view(const vec3& pos, const vec3& at, const vec3& up) { vec3 vLook(at - pos); vLook.normalize(); vec3 vRight(up.cross(vLook)); vRight.normalize(); vec3 vUp(vLook.cross(vRight)); vUp.normalize(); _11 = vRight.x ; _12 = vUp.x ; _13 = vLook.x ; _14 = 0.0f; _21 = vRight.y ; _22 = vUp.y ; _23 = vLook.y ; _24 = 0.0f; _31 = vRight.z ; _32 = vUp.z ; _33 = vLook.z ; _34 = 0.0f; _41 = -vRight.dot(pos); _42 = -vUp.dot(pos); _43 = -vLook.dot(pos); _44 = 1.0f; return *this; }
void CubeReflector::updateFace( const ReflectParams ¶ms, U32 faceidx ) { GFXDEBUGEVENT_SCOPE( CubeReflector_UpdateFace, ColorI::WHITE ); // store current matrices GFXTransformSaver saver; // set projection to 90 degrees vertical and horizontal F32 left, right, top, bottom; MathUtils::makeFrustum( &left, &right, &top, &bottom, M_HALFPI_F, 1.0f, mDesc->nearDist ); GFX->setFrustum( left, right, bottom, top, mDesc->nearDist, mDesc->farDist ); // We don't use a special clipping projection, but still need to initialize // this for objects like SkyBox which will use it during a reflect pass. gClientSceneGraph->setNonClipProjection( GFX->getProjectionMatrix() ); // Standard view that will be overridden below. VectorF vLookatPt(0.0f, 0.0f, 0.0f), vUpVec(0.0f, 0.0f, 0.0f), vRight(0.0f, 0.0f, 0.0f); switch( faceidx ) { case 0 : // D3DCUBEMAP_FACE_POSITIVE_X: vLookatPt = VectorF( 1.0f, 0.0f, 0.0f ); vUpVec = VectorF( 0.0f, 1.0f, 0.0f ); break; case 1 : // D3DCUBEMAP_FACE_NEGATIVE_X: vLookatPt = VectorF( -1.0f, 0.0f, 0.0f ); vUpVec = VectorF( 0.0f, 1.0f, 0.0f ); break; case 2 : // D3DCUBEMAP_FACE_POSITIVE_Y: vLookatPt = VectorF( 0.0f, 1.0f, 0.0f ); vUpVec = VectorF( 0.0f, 0.0f,-1.0f ); break; case 3 : // D3DCUBEMAP_FACE_NEGATIVE_Y: vLookatPt = VectorF( 0.0f, -1.0f, 0.0f ); vUpVec = VectorF( 0.0f, 0.0f, 1.0f ); break; case 4 : // D3DCUBEMAP_FACE_POSITIVE_Z: vLookatPt = VectorF( 0.0f, 0.0f, 1.0f ); vUpVec = VectorF( 0.0f, 1.0f, 0.0f ); break; case 5: // D3DCUBEMAP_FACE_NEGATIVE_Z: vLookatPt = VectorF( 0.0f, 0.0f, -1.0f ); vUpVec = VectorF( 0.0f, 1.0f, 0.0f ); break; } // create camera matrix VectorF cross = mCross( vUpVec, vLookatPt ); cross.normalizeSafe(); MatrixF matView(true); matView.setColumn( 0, cross ); matView.setColumn( 1, vLookatPt ); matView.setColumn( 2, vUpVec ); matView.setPosition( mObject->getPosition() ); matView.inverse(); GFX->setWorldMatrix(matView); renderTarget->attachTexture( GFXTextureTarget::Color0, cubemap, faceidx ); GFX->setActiveRenderTarget( renderTarget ); GFX->clear( GFXClearStencil | GFXClearTarget | GFXClearZBuffer, gCanvasClearColor, 1.0f, 0 ); SceneRenderState reflectRenderState ( gClientSceneGraph, SPT_Reflect, SceneCameraState::fromGFX() ); reflectRenderState.getMaterialDelegate().bind( REFLECTMGR, &ReflectionManager::getReflectionMaterial ); reflectRenderState.setDiffuseCameraTransform( params.query->cameraMatrix ); reflectRenderState.disableAdvancedLightingBins(true); // render scene LIGHTMGR->registerGlobalLights( &reflectRenderState.getCullingFrustum(), false ); gClientSceneGraph->renderSceneNoLights( &reflectRenderState, mDesc->objectTypeMask ); LIGHTMGR->unregisterAllLights(); // Clean up. renderTarget->resolve(); }
void ParticleSystem::draw() { /* // just draw points: glDisable(GL_TEXTURE_2D); glDisable(GL_LIGHTING); glColor4f(1,1,1,1); glBegin(GL_POINTS); for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) { glVertex3fv(it->tpos); } glEnd(); glEnable(GL_LIGHTING); glEnable(GL_TEXTURE_2D); */ // setup blend mode switch (blend) { case 0: glDisable(GL_BLEND); glDisable(GL_ALPHA_TEST); break; case 1: glEnable(GL_BLEND); glBlendFunc(GL_SRC_COLOR, GL_ONE); glDisable(GL_ALPHA_TEST); break; case 2: glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_ALPHA_TEST); break; case 3: glDisable(GL_BLEND); glEnable(GL_ALPHA_TEST); break; case 4: glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE); glDisable(GL_ALPHA_TEST); break; } //glDisable(GL_LIGHTING); //glDisable(GL_CULL_FACE); //glDepthMask(GL_FALSE); // glPushName(texture); _texture->bind(); /* if (supportPointSprites && rows==1 && cols==1) { // This is how will our point sprite's size will be modified by // distance from the viewer float quadratic[] = {0.1f, 0.0f, 0.5f}; //float quadratic[] = {0.88f, 0.001f, 0.000004f}; glPointParameterfvARB( GL_POINT_DISTANCE_ATTENUATION_ARB, quadratic); // Query for the max point size supported by the hardware float maxSize = 512.0f; //glGetFloatv(GL_POINT_SIZE_MAX_ARB, &maxSize ); // Clamp size to 100.0f or the sprites could get a little too big on some // of the newer graphic cards. My ATI card at home supports a max point // size of 1024.0f! //if( maxSize > 100.0f ) // maxSize = 100.0f; glPointSize(maxSize); // The alpha of a point is calculated to allow the fading of points // instead of shrinking them past a defined threshold size. The threshold // is defined by GL_POINT_FADE_THRESHOLD_SIZE_ARB and is not clamped to // the minimum and maximum point sizes. glPointParameterfARB(GL_POINT_FADE_THRESHOLD_SIZE_ARB, 60.0f); glPointParameterfARB(GL_POINT_SIZE_MIN_ARB, 1.0f ); glPointParameterfARB(GL_POINT_SIZE_MAX_ARB, maxSize ); // Specify point sprite texture coordinate replacement mode for each texture unit glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE); // Render point sprites... glEnable(GL_POINT_SPRITE_ARB); glBegin(GL_POINTS); { for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) { glPointSize(it->size); glTexCoord2fv(tiles[it->tile].tc[0]); glColor4fv(it->color); glVertex3fv(it->pos); } } glEnd(); glDisable(GL_POINT_SPRITE_ARB); glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_FALSE); } else { // Old slow method */ Vec3D vRight(1, 0, 0); Vec3D vUp(0, 1, 0); // position stuff const float f = 1;//0.707106781f; // sqrt(2)/2 Vec3D bv0 = Vec3D(-f, +f, 0); Vec3D bv1 = Vec3D(+f, +f, 0); Vec3D bv2 = Vec3D(+f, -f, 0); Vec3D bv3 = Vec3D(-f, -f, 0); if (billboard) { float modelview[16]; glGetFloatv(GL_MODELVIEW_MATRIX, modelview); vRight = Vec3D(modelview[0], modelview[4], modelview[8]); vUp = Vec3D(modelview[1], modelview[5], modelview[9]); // Spherical billboarding //vUp = Vec3D(0,1,0); // Cylindrical billboarding } /* * type: * 0 "normal" particle * 1 large quad from the particle's origin to its position (used in Moonwell water effects) * 2 seems to be the same as 0 (found some in the Deeprun Tram blinky-lights-sign thing) */ if (type == 0 || type == 2) { //! \todo figure out type 2 (deeprun tram subway sign) // - doesn't seem to be any different from 0 -_- // regular particles if (billboard) { glBegin(GL_QUADS); //! \todo per-particle rotation in a non-expensive way?? :| for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) { if (tiles.size() - 1 < it->tile) // Alfred, 2009.08.07, error prevent break; const float size = it->size;// / 2; glColor4fv(it->color); glTexCoord2fv(tiles[it->tile].tc[0]); glVertex3fv(it->pos - (vRight + vUp) * size); glTexCoord2fv(tiles[it->tile].tc[1]); glVertex3fv(it->pos + (vRight - vUp) * size); glTexCoord2fv(tiles[it->tile].tc[2]); glVertex3fv(it->pos + (vRight + vUp) * size); glTexCoord2fv(tiles[it->tile].tc[3]); glVertex3fv(it->pos - (vRight - vUp) * size); } glEnd(); } else { glBegin(GL_QUADS); for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) { if (tiles.size() - 1 < it->tile) // Alfred, 2009.08.07, error prevent break; glColor4fv(it->color); glTexCoord2fv(tiles[it->tile].tc[0]); glVertex3fv(it->pos + it->corners[0] * it->size); glTexCoord2fv(tiles[it->tile].tc[1]); glVertex3fv(it->pos + it->corners[1] * it->size); glTexCoord2fv(tiles[it->tile].tc[2]); glVertex3fv(it->pos + it->corners[2] * it->size); glTexCoord2fv(tiles[it->tile].tc[3]); glVertex3fv(it->pos + it->corners[3] * it->size); } glEnd(); } } else if (type == 1) { // Sphere particles // particles from origin to position /* bv0 = mbb * Vec3D(0,-1.0f,0); bv1 = mbb * Vec3D(0,+1.0f,0); bv0 = mbb * Vec3D(-1.0f,0,0); bv1 = mbb * Vec3D(1.0f,0,0); */ glBegin(GL_QUADS); for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) { if (tiles.size() - 1 < it->tile) // Alfred, 2009.08.07, error prevent break; glColor4fv(it->color); glTexCoord2fv(tiles[it->tile].tc[0]); glVertex3fv(it->pos + bv0 * it->size); glTexCoord2fv(tiles[it->tile].tc[1]); glVertex3fv(it->pos + bv1 * it->size); glTexCoord2fv(tiles[it->tile].tc[2]); glVertex3fv(it->origin + bv1 * it->size); glTexCoord2fv(tiles[it->tile].tc[3]); glVertex3fv(it->origin + bv0 * it->size); } glEnd(); } //} //glEnable(GL_LIGHTING); //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); //glDepthMask(GL_TRUE); //glColor4f(1.0f, 1.0f, 1.0f, 1.0f); }
void VFmodManager::RunTick(float fTimeDelta) { if (!IsInitialized()) return; VISION_PROFILE_FUNCTION(PROFILING_FMOD_OVERALL); // profiling scope { VISION_PROFILE_FUNCTION(PROFILING_FMOD_PUREUPDATE); VASSERT(m_pEventSystem!=NULL); // update Fmod listener attributes VisObject3D_cl *pListener = m_pListenerObject ? m_pListenerObject : Vision::Camera.GetMainCamera(); if (!pListener) return; hkvVec3 vCamPos = pListener->GetPosition(); hkvVec3 vDir(pListener->GetObjDir()), vRight(pListener->GetObjDir_Right()), vUp(pListener->GetObjDir_Up()); vUp = -vUp; // compensate for coordinate system m_pEventSystem->set3DListenerAttributes(0, (FMOD_VECTOR *)&vCamPos, NULL, (FMOD_VECTOR *)&vDir, (FMOD_VECTOR *)&vUp); // no speed (yet) // update all sound objects SoundInstances().Update(); // update all events Events().Update(); // update Fmod event system m_fTimeLeftOver += fTimeDelta; if (m_fTimeLeftOver > m_config.fTimeStep) { m_pEventSystem->update(); #ifdef VFMOD_SUPPORTS_NETWORK if (m_config.bUseNetworkSystem) FMOD::NetEventSystem_Update(); #endif m_fTimeLeftOver = hkvMath::mod (m_fTimeLeftOver, m_config.fTimeStep); } } // do not purge sounds/ events in vForge, in order to allow toggling playback via hotspot button if (Vision::Editor.IsInEditor()) return; if (m_bAnyStopped) { VISION_PROFILE_FUNCTION(PROFILING_FMOD_PURGE); // all sounds/ events that have finished playing are removed from handling SoundInstances().PurgeNotPlaying(); Events().PurgeNotPlaying(); m_bAnyStopped = false; // reset any stopped flag } }
void TextExplainNode::UpdateText(Node* rootWidget, const string* text, int cfgId) { auto node_TextExplain = rootWidget->getChildByName<Node*>("Node_TextExplain"); node_TextExplain->setVisible(true); auto layout_FullScreen = node_TextExplain->getChildByName<Layout*>("Layout_FullScreen"); layout_FullScreen->setVisible(true); layout_FullScreen->setTouchEnabled(true); layout_FullScreen->setSwallowTouches(false); layout_FullScreen->addClickEventListener([=](Ref* sender) { node_TextExplain->setVisible(false); layout_FullScreen->setVisible(false); layout_FullScreen->setTouchEnabled(false); }); auto layout_Background = node_TextExplain->getChildByName<Layout*>("Layout_Background"); auto text_Explain = layout_Background->getChildByName<Text*>("Text_Explain"); text_Explain->setString(text->c_str()); auto layout_restrain = layout_Background->getChildByName<Layout*>("Layout_Restrain"); if ( cfgId == 0 || (cfgId / 1000000 != 205) ) { layout_restrain->setVisible(false); return; } layout_restrain->setVisible(true); auto layout_propMain = layout_restrain->getChildByName<Layout*>("Layout_PropMain"); UIUtils::getInstance()->showProperImg(layout_propMain, cfgId, false); CfgDataRow dataRow(cfgId); // 属性配置表的id与item的属性字段id不统一,故作如下转换 auto properId = (int)ProCfgId::CfgBaseId + dataRow.GetValue(CfgField::PropertyID)->asInt(); CfgDataRow proDataRow(properId); // 1001 ~ 1005 float result = 1.0; vector<int> vLeft(2, 0); vector<int> vRight(2, 0); int leftIdx = 0; int rightIdx = 0; for (int proId = 1001; proId <= 1005; ++proId) { switch (proId) { case (int)ProCfgId::MeleeCo : result = proDataRow.GetValue(CfgField::MeleeCo_F)->asFloat(); break; case (int)ProCfgId::FighterCo : result = proDataRow.GetValue(CfgField::FighterCo_F)->asFloat(); break; case (int)ProCfgId::MagicCo : result = proDataRow.GetValue(CfgField::MagicCo_F)->asFloat(); break; case (int)ProCfgId::RangedCo : result = proDataRow.GetValue(CfgField::RangedCo_F)->asFloat(); break; case (int)ProCfgId::FlyingCo : result = proDataRow.GetValue(CfgField::FlyingCo_F)->asFloat(); break; } if (result < 1) { vLeft[leftIdx++] = proId; } else if(result > 1) { vRight[rightIdx++] = proId; } } int i = 1; for(int proId : vLeft) { auto leftProNode = layout_restrain->getChildByName(StringUtils::format("Layout_PropLeft%d", i++)); UIUtils::getInstance()->showRealProper(leftProNode, proId, false); } i = 1; for(int proId : vRight) { auto RightProNode = layout_restrain->getChildByName(StringUtils::format("Layout_PropRight%d", i++)); UIUtils::getInstance()->showRealProper(RightProNode, proId, false); } // 技能、buff、属性描述 auto text_Buff = layout_restrain->getChildByName<Text *>("Text_Buff"); auto text_Skill = layout_restrain->getChildByName<Text *>("Text_Skill"); auto text_Attr = layout_restrain->getChildByName<Text *>("Text_Attr"); auto vi_skill = dataRow.GetValue(CfgField::SkillID_V)->asValueVector(); auto iter_skill = vi_skill.begin(); auto skillId = iter_skill->asInt(); CfgDataRow dataRow_Skill(skillId); auto langText = MultiLanguage::getInstance()->GetText((int)LanguageIdEnum::SkillId); langText += MultiLanguage::getInstance()->GetText(dataRow_Skill.GetValue(CfgField::Name)->asInt()); text_Skill->setString(langText); auto bufferData = dataRow_Skill.GetValue(CfgField::BuffID_V)->asValueVector(); if (!bufferData.empty()) { auto iter_buff = bufferData.begin(); auto bufferId = iter_buff->asInt(); langText = MultiLanguage::getInstance()->GetText((int)LanguageIdEnum::BufferId); CfgDataRow dataRow_Buffer(bufferId); langText += MultiLanguage::getInstance()->GetText(dataRow_Buffer.GetValue(CfgField::Name)->asInt()); text_Buff->setString(langText); text_Buff->setVisible(true); }else { text_Buff->setVisible(false); } langText = MultiLanguage::getInstance()->GetText((int)LanguageIdEnum::LifeId); langText += StringUtils::format("%d", dataRow.GetValue(CfgField::Hp)->asInt()); langText += " " + MultiLanguage::getInstance()->GetText((int)LanguageIdEnum::PowerId); langText += StringUtils::format("%d", dataRow.GetValue(CfgField::Atk)->asInt()); langText += " " + MultiLanguage::getInstance()->GetText((int)LanguageIdEnum::SpeedId); langText += StringUtils::format("%g", dataRow.GetValue(CfgField::Spd_F)->asFloat()); text_Attr->setString(langText); }
void VFmodManager::RunTick(float fTimeDelta) { VISION_PROFILE_FUNCTION(PROFILING_FMOD_OVERALL); if (!IsInitialized()) { if (!IsOutputDevicePresent()) InitDevice(); return; } // profiling scope { VISION_PROFILE_FUNCTION(PROFILING_FMOD_PUREUPDATE); VASSERT(m_pEventSystem!=NULL); // update Fmod listener attributes VisObject3D_cl *pListener = m_pListenerObject; if (pListener == NULL) { // The listener is the main camera. Check for teleportation since the last Fmod update, in // which case we won't use the position difference to calculate the listener speed. VisContextCamera_cl* pCamera = Vision::Camera.GetMainCamera(); VisRenderContext_cl* pContext = VisRenderContext_cl::GetMainRenderContext(); if (pCamera != NULL && pContext != NULL) { if (m_bLastListenerPositionValid && pCamera->GetLastTeleported() > m_iFrameOfLastUpdate) m_bLastListenerPositionValid = false; m_iFrameOfLastUpdate = pContext->GetLastRenderedFrame(); pListener = pCamera; } } if (!pListener) return; hkvVec3 vCamPos = pListener->GetPosition(); hkvVec3 vDir(pListener->GetObjDir()), vRight(pListener->GetObjDir_Right()), vUp(pListener->GetObjDir_Up()); // Determine the camera velocity based on the previous known position hkvVec3 vCamVel(m_bLastListenerPositionValid && (fTimeDelta > 0.f) ? (vCamPos - m_vLastListenerPosition) * (1.f / fTimeDelta) : hkvVec3::ZeroVector()); m_vLastListenerPosition = vCamPos; m_bLastListenerPositionValid = true; vUp = -vUp; // compensate for coordinate system m_pEventSystem->set3DListenerAttributes(0, (FMOD_VECTOR *)&vCamPos, (FMOD_VECTOR *)&vCamVel, (FMOD_VECTOR *)&vDir, (FMOD_VECTOR *)&vUp); // update all sound objects SoundInstances().Update(fTimeDelta); // update all events Events().Update(fTimeDelta); // update Fmod event system m_fTimeLeftOver += fTimeDelta; if (m_fTimeLeftOver > m_config.fTimeStep) { m_pEventSystem->update(); #ifdef VFMOD_SUPPORTS_NETWORK if (m_config.bUseNetworkSystem) FMOD::NetEventSystem_Update(); #endif m_fTimeLeftOver = hkvMath::mod (m_fTimeLeftOver, m_config.fTimeStep); } } // do not purge sounds/ events in vForge, in order to allow toggling playback via hotspot button if (Vision::Editor.IsInEditor()) return; if (m_bAnyStopped) { VISION_PROFILE_FUNCTION(PROFILING_FMOD_PURGE); // all sounds/ events that have finished playing are removed from handling SoundInstances().PurgeNotPlaying(); Events().PurgeNotPlaying(); m_bAnyStopped = false; // reset any stopped flag } }
//----------------------------------------------------------------------------- void CPUTCameraControllerFPS::Update(float deltaSeconds) { if( !mpCamera ) { return; } float speed = mfMoveSpeed * deltaSeconds; if (keyPressed[KEY_SHIFT] == CPUT_KEY_DOWN || keyPressed[KEY_CTRL] == CPUT_KEY_DOWN) { speed *= 0.1f; } float4x4 *pParentMatrix = mpCamera->GetParentMatrix(); float3 vRight(pParentMatrix->getXAxis()); float3 vUp(pParentMatrix->getYAxis()); float3 vLook(pParentMatrix->getZAxis()); float3 vPositionDelta(0.0f); int rotateX = 0; int rotateY = 0; bool bRotate = false; // Added the ability to toggle on/off rotation mode if (keyPressed[KEY_SPACE] == CPUT_KEY_DOWN) { bRotate = true; } if(keyPressed[KEY_W] == CPUT_KEY_DOWN) { vPositionDelta += vLook * speed; rotateY = -1; } if(keyPressed[KEY_A] == CPUT_KEY_DOWN) { vPositionDelta += vRight * -speed; rotateX = -1; } if(keyPressed[KEY_S] == CPUT_KEY_DOWN) { vPositionDelta += vLook * -speed; rotateY = 1; } if(keyPressed[KEY_D] == CPUT_KEY_DOWN) { vPositionDelta += vRight * speed; rotateX = 1; } if(keyPressed[KEY_E] == CPUT_KEY_DOWN) { vPositionDelta += vUp * speed; } if(keyPressed[KEY_Q] == CPUT_KEY_DOWN) { vPositionDelta += vUp * -speed; } if (bRotate && (rotateX || rotateY)) { // this lets you rotate the camera with the keyboard if you don't have a mouse. like if you only have one // usb slot available on a mobile. float nDeltaX = (float)(rotateX) * speed * 10.0f; float nDeltaY = (float)(rotateY) * speed * 10.0f; float4x4 rotationX = float4x4RotationX(nDeltaY*mfLookSpeed); float4x4 rotationY = float4x4RotationY(nDeltaX*mfLookSpeed); float3 position = mpCamera->GetPosition(); mpCamera->SetPosition(0.0f, 0.0f, 0.0f); // Rotate about camera center float4x4 parent = *mpCamera->GetParentMatrix(); float4x4 orientation = rotationX *parent * rotationY; orientation.orthonormalize(); mpCamera->SetParentMatrix( orientation ); mpCamera->SetPosition( position.x, position.y, position.z ); // Move back to original position } else { float x,y,z; mpCamera->GetPosition( &x, &y, &z ); mpCamera->SetPosition( x+vPositionDelta.x, y+vPositionDelta.y, z+vPositionDelta.z ); } mpCamera->Update(); //Compute animation as an offset from the current position mpCamera->mPosition += float3( vPositionDelta.x, vPositionDelta.y, vPositionDelta.z ); //END return; }
void M2EffectRender::CopyParticlesToVertexBuffer( uint32 index, class M2ParticleSystem* ps, ParticleVertex* pVB, D3DXVECTOR3 vEye, D3DXVECTOR3 _vRight, D3DXVECTOR3 _vUp ) { noVec3 vRight(0,0,-1); noVec3 vUp(0,1,0); // position stuff const float f = 1;//0.707106781f; // sqrt(2)/2 noVec3 bv0 = noVec3(-f,+f,0); noVec3 bv1 = noVec3(-f,-f,0); noVec3 bv2 = noVec3(+f,-f,0); noVec3 bv3 = noVec3(+f,+f,0); UINT iVBIndex = 0; uint32 gNumActiveParticles = 0; for (size_t i=0; i< 1 ; i++) { if (ps->billboard) { vRight.Set(_vRight.x, _vRight.y, _vRight.z); vUp.Set(_vUp.x, _vUp.y, _vUp.z); } if (ps->ParticleType==0 || ps->ParticleType==2) { for (ParticleList::iterator it = ps->particles.begin(); it != ps->particles.end(); ++it) { if (ps->tiles.size() - 1 < it->tile) // Alfred, 2009.08.07, error prevent break; //if (gNumActiveParticles >= MAX_PARTICLES) // return; M2Particle &p = *it; const float size = it->size;// / 2; if (ps->billboard) { // 0 ---- 3 // // // 1 ---- 2 // // Tri 0 (0,1,3) // it->pos˼ center noVec3 v0 = it->pos - (vRight - vUp) * size; noVec3 v1 = it->pos - (vRight + vUp) * size; noVec3 v2 = it->pos + (vRight - vUp) * size; noVec3 v3 = it->pos + (vRight + vUp) * size; pVB[iVBIndex].pos = v0; pVB[iVBIndex].color = it->color; pVB[iVBIndex].uv = ps->tiles[it->tile].tc[0]; pVB[iVBIndex+1].pos = v1; pVB[iVBIndex+1].color = it->color; pVB[iVBIndex+1].uv = ps->tiles[it->tile].tc[3]; pVB[iVBIndex+2].pos = v3; pVB[iVBIndex+2].color = it->color; pVB[iVBIndex+2].uv = ps->tiles[it->tile].tc[1]; pVB[iVBIndex+3].pos = v2; pVB[iVBIndex+3].color = it->color; pVB[iVBIndex+3].uv = ps->tiles[it->tile].tc[2]; pVB[iVBIndex+4].pos = v3; pVB[iVBIndex+4].color = it->color; pVB[iVBIndex+4].uv = ps->tiles[it->tile].tc[1]; pVB[iVBIndex+5].pos = v1; pVB[iVBIndex+5].color = it->color; pVB[iVBIndex+5].uv = ps->tiles[it->tile].tc[3]; //if (frame > 10 && frame < 20) { /* for (int i = 0; i < 6; i++) { LOG_INFO << "Particle : " << iVBIndex +i << " " << pVB[iVBIndex +i].pos.x << " " << pVB[iVBIndex +i].pos.y << " " << pVB[iVBIndex +i].pos.z;*/ /*noVec3 Pos = (mView * mProj) * pVB[iVBIndex +i].pos; LOG_INFO << "Particle : " << iVBIndex +i << " " << Pos.x << " " << Pos.y << " " << Pos.z;*/ //} } } else { // // Tri 0 (0,1,3) pVB[iVBIndex].pos = it->pos + it->corners[3] * size; pVB[iVBIndex].color = it->color; pVB[iVBIndex].uv = ps->tiles[it->tile].tc[3]; pVB[iVBIndex+1].pos = it->pos + it->corners[0] * size; pVB[iVBIndex+1].color = it->color; pVB[iVBIndex+1].uv = ps->tiles[it->tile].tc[0]; pVB[iVBIndex+2].pos = it->pos + it->corners[2] * size; pVB[iVBIndex+2].color = it->color; pVB[iVBIndex+2].uv = ps->tiles[it->tile].tc[2]; // // Tri 1 (3,1,2) pVB[iVBIndex+3].pos = it->pos + it->corners[1] * size; pVB[iVBIndex+3].color = it->color; pVB[iVBIndex+3].uv = ps->tiles[it->tile].tc[1]; pVB[iVBIndex+4].pos = it->pos + it->corners[2] * size; pVB[iVBIndex+4].color = it->color; pVB[iVBIndex+4].uv = ps->tiles[it->tile].tc[2]; pVB[iVBIndex+5].pos = it->pos + it->corners[0] * size; pVB[iVBIndex+5].color = it->color; pVB[iVBIndex+5].uv = ps->tiles[it->tile].tc[0]; } iVBIndex+=6; gNumActiveParticles++; } } else if (ps->ParticleType==1) { // Sphere particles for (ParticleList::iterator it = ps->particles.begin(); it != ps->particles.end(); ++it) { if (ps->tiles.size() - 1 < it->tile) // Alfred, 2009.08.07, error prevent break; // // // Tri 0 (0,1,3) // pVB[iVBIndex+2].pos = it->pos + it->corners[1] * size; // pVB[iVBIndex+2].color = it->color; // pVB[iVBIndex+2].uv = ps->tiles[it->tile].tc[1]; // pVB[iVBIndex+1].pos = it->pos + bv1 * it->size; // pVB[iVBIndex+1].color = it->color; // pVB[iVBIndex+1].uv = ps->tiles[it->tile].tc[3]; // pVB[iVBIndex].pos = it->pos + bv0 * it->size; // pVB[iVBIndex].color = it->color; // pVB[iVBIndex].uv = ps->tiles[it->tile].tc[0]; // // // Tri 1 (3,1,2) // pVB[iVBIndex+5].pos = it->pos + it->corners[3] * size; // pVB[iVBIndex+5].color = it->color; // pVB[iVBIndex+5].uv = ps->tiles[it->tile].tc[2]; // pVB[iVBIndex+4].pos = it->pos + it->corners[2] * size; // pVB[iVBIndex+4].color = it->color; // pVB[iVBIndex+4].uv = ps->tiles[it->tile].tc[3]; // pVB[iVBIndex+3].pos = it->pos + it->corners[1] * size; // pVB[iVBIndex+3].color = it->color; // pVB[iVBIndex+3].uv = ps->tiles[it->tile].tc[1]; // iVBIndex+=6; // gNumActiveParticles+=6; // noVec3 bv0 = noVec3(-f,+f,0); // noVec3 bv1 = noVec3(-f,-f,0); // // glTexCoord2fv(tiles[it->tile].tc[0]); // glVertex3fv(it->pos + bv0 * it->size); // glTexCoord2fv(tiles[it->tile].tc[1]); // glVertex3fv(it->pos + bv1 * it->size); // glTexCoord2fv(tiles[it->tile].tc[2]); // glVertex3fv(it->origin + bv1 * it->size); // glTexCoord2fv(tiles[it->tile].tc[3]); // glVertex3fv(it->origin + bv0 * it->size); } } } ParticleData_.gNumActiveParticles.at(index) = gNumActiveParticles; }
void CCampathDrawer::OnPostRenderAllTools() { // Actually we are often called twice per frame due to an engine bug(?), once after 3d skybox // and once after world is drawn, maybe we will be even called more times, // but we can not care about that for now. if(!m_Draw) return; if(!m_VertexShader) { m_VertexShader = g_AfxShaders.GetVertexShader("afx_line_vs20.fxo"); } IDirect3DVertexShader9 * vertexShader = m_VertexShader->GetVertexShader(); if(!m_PixelShader) { m_PixelShader = g_AfxShaders.GetPixelShader("afx_line_ps20.fxo"); } IDirect3DPixelShader9 * pixelShader = m_PixelShader->GetPixelShader(); if(!(m_Device && vertexShader && m_PixelShader && g_VEngineClient)) { static bool firstError = true; if(firstError) { firstError = false; Tier0_Msg( "AFXERROR: CCampathDrawer::OnEndScene: Missing required dependencies:%s%s%s%s.\n", !m_Device ? " m_Device" : "", !vertexShader ? " vertexShader" : "", !pixelShader ? " pixelShader" : "", !g_VEngineClient ? " g_VEngineClient" : "" ); } return; } // Save device state: IDirect3DPixelShader9 * oldPixelShader = 0; m_Device->GetPixelShader(&oldPixelShader); if(oldPixelShader) oldPixelShader->AddRef(); IDirect3DVertexShader9 * oldVertexShader = 0; m_Device->GetVertexShader(&oldVertexShader); if(oldVertexShader) oldVertexShader->AddRef(); IDirect3DVertexBuffer9 * oldVertexBuffer = 0; UINT oldVertexBufferOffset; UINT oldVertexBufferStride; m_Device->GetStreamSource(0, &oldVertexBuffer, &oldVertexBufferOffset, &oldVertexBufferStride); // this is done already according to doc: // if(oldVertexBuffer) oldVertexBuffer->AddRef(); IDirect3DIndexBuffer9 * oldIndexBuffer = 0; m_Device->GetIndices(&oldIndexBuffer); // this is done already according to doc: // if(oldIndexBuffer) oldIndexBuffer->AddRef(); IDirect3DVertexDeclaration9 * oldDeclaration; m_Device->GetVertexDeclaration(&oldDeclaration); if(oldDeclaration) oldDeclaration->AddRef(); DWORD oldFVF; m_Device->GetFVF(&oldFVF); FLOAT oldCViewProj[4][4]; m_Device->GetVertexShaderConstantF(8, oldCViewProj[0], 4); FLOAT oldCScreenInfo[4]; m_Device->GetVertexShaderConstantF(48, oldCScreenInfo, 1); FLOAT oldCPlane0[4]; m_Device->GetVertexShaderConstantF(49, oldCPlane0, 1); FLOAT oldCPlaneN[4]; m_Device->GetVertexShaderConstantF(50, oldCPlaneN, 1); DWORD oldSrgbWriteEnable; m_Device->GetRenderState(D3DRS_SRGBWRITEENABLE, &oldSrgbWriteEnable); DWORD oldColorWriteEnable; m_Device->GetRenderState(D3DRS_COLORWRITEENABLE, &oldColorWriteEnable); DWORD oldZEnable; m_Device->GetRenderState(D3DRS_ZENABLE, &oldZEnable); DWORD oldZWriteEnable; m_Device->GetRenderState(D3DRS_ZWRITEENABLE, &oldZWriteEnable); DWORD oldZFunc; m_Device->GetRenderState(D3DRS_ZFUNC, &oldZFunc); DWORD oldAlphaTestEnable; m_Device->GetRenderState(D3DRS_ALPHATESTENABLE, &oldAlphaTestEnable); DWORD oldSeparateAlphaBlendEnable; m_Device->GetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, &oldSeparateAlphaBlendEnable); DWORD oldAlphaBlendEnable; m_Device->GetRenderState(D3DRS_ALPHABLENDENABLE, &oldAlphaBlendEnable); DWORD oldBlendOp; m_Device->GetRenderState(D3DRS_BLENDOP, &oldBlendOp); DWORD oldSrcBlend; m_Device->GetRenderState(D3DRS_SRCBLEND, &oldSrcBlend); DWORD oldDestBlend; m_Device->GetRenderState(D3DRS_DESTBLEND, &oldDestBlend); DWORD oldCullMode; m_Device->GetRenderState(D3DRS_CULLMODE, &oldCullMode); // Draw: { //Vector3 vvForward, vvUp, vvRight, vvPos; double curTime = g_Hook_VClient_RenderView.GetCurTime(); bool inCampath = 1 <= g_Hook_VClient_RenderView.m_CamPath.GetSize() && g_Hook_VClient_RenderView.m_CamPath.GetLowerBound() <= curTime && curTime <= g_Hook_VClient_RenderView.m_CamPath.GetUpperBound(); bool campathCanEval = g_Hook_VClient_RenderView.m_CamPath.CanEval(); bool campathEnabled = g_Hook_VClient_RenderView.m_CamPath.Enabled_get(); bool cameraMightBeSelected = false; m_Device->SetRenderState(D3DRS_SRGBWRITEENABLE, FALSE); m_Device->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_ALPHA|D3DCOLORWRITEENABLE_BLUE|D3DCOLORWRITEENABLE_GREEN|D3DCOLORWRITEENABLE_RED); m_Device->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); m_Device->SetRenderState(D3DRS_ZWRITEENABLE, FALSE); m_Device->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL); m_Device->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); m_Device->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, FALSE); m_Device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); m_Device->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD); m_Device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA); m_Device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA); m_Device->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); m_Device->SetVertexShader(vertexShader); m_WorldToScreenMatrix = g_VEngineClient->WorldToScreenMatrix(); m_Device->SetVertexShaderConstantF(8, m_WorldToScreenMatrix.m[0], 4); // Provide view plane info for line clipping: { double plane0[4]={0,0,0,1}; double planeN[4]={1,0,0,1}; //double planeR[4]={0,-1,0,1}; //double planeU[4]={0,0,1,1}; unsigned char P[4]; unsigned char Q[4]; double L[4][4]; double U[4][4]; double M[4][4] = { m_WorldToScreenMatrix.m[0][0], m_WorldToScreenMatrix.m[0][1], m_WorldToScreenMatrix.m[0][2], 0, m_WorldToScreenMatrix.m[1][0], m_WorldToScreenMatrix.m[1][1], m_WorldToScreenMatrix.m[1][2], 0, m_WorldToScreenMatrix.m[2][0], m_WorldToScreenMatrix.m[2][1], m_WorldToScreenMatrix.m[2][2], 0, m_WorldToScreenMatrix.m[3][0], m_WorldToScreenMatrix.m[3][1], m_WorldToScreenMatrix.m[3][2], -1, }; double b0[4] = { 0 -m_WorldToScreenMatrix.m[0][3], 0 -m_WorldToScreenMatrix.m[1][3], 0 -m_WorldToScreenMatrix.m[2][3], -m_WorldToScreenMatrix.m[3][3], }; double bN[4] = { 0 -m_WorldToScreenMatrix.m[0][3], 0 -m_WorldToScreenMatrix.m[1][3], 1 -m_WorldToScreenMatrix.m[2][3], -m_WorldToScreenMatrix.m[3][3], }; /* double bR[4] = { 1 -m_WorldToScreenMatrix.m[0][3], 0 -m_WorldToScreenMatrix.m[1][3], 0 -m_WorldToScreenMatrix.m[2][3], -m_WorldToScreenMatrix.m[3][3], }; double bU[4] = { 0 -m_WorldToScreenMatrix.m[0][3], 1 -m_WorldToScreenMatrix.m[1][3], 0 -m_WorldToScreenMatrix.m[2][3], -m_WorldToScreenMatrix.m[3][3], }; */ if(!LUdecomposition(M, P, Q, L, U)) { Tier0_Warning("AFXERROR in CCampathDrawer::OnPostRenderAllTools: LUdecomposition failed\n"); } else { SolveWithLU(L, U, P, Q, b0, plane0); SolveWithLU(L, U, P, Q, bN, planeN); //SolveWithLU(L, U, P, Q, bR, planeR); //SolveWithLU(L, U, P, Q, bU, planeU); } /* vvPos = Vector3(plane0[0], plane0[1], plane0[2]); vvForward = Vector3(planeN[0] -vvPos.X, planeN[1] -vvPos.Y, planeN[2]-vvPos.Z); vvForward.Normalize(); vvRight = Vector3(planeR[0] -vvPos.X, planeR[1] -vvPos.Y, planeR[2]-vvPos.Z); vvRight.Normalize(); vvUp = Vector3(planeU[0] -vvPos.X, planeU[1] -vvPos.Y, planeU[2]-vvPos.Z); vvUp.Normalize(); */ /* Tier0_Msg("CCampathDrawer::OnPostRenderAllTools: curTime = %f\n",curTime); Tier0_Msg("M[0]=%f %f %f %f\nM[1]=%f %f %f %f\nM[2]=%f %f %f %f\nM[3]=%f %f %f %f\n", M[0][0],M[0][1],M[0][2],M[0][3], M[1][0],M[1][1],M[1][2],M[1][3], M[2][0],M[2][1],M[2][2],M[2][3], M[3][0],M[3][1],M[3][2],M[3][3]); Tier0_Msg("b0[0]=%f %f %f %f\n", b0[0], b0[1], b0[2], b0[3]); Tier0_Msg("bN[0]=%f %f %f %f\n", bN[0], bN[1], bN[2], bN[3]); Tier0_Msg("plane0=%f %f %f %f\n", plane0[0], plane0[1], plane0[2], plane0[3]); Tier0_Msg("planeN=%f %f %f %f\n", planeN[0], planeN[1], planeN[2], planeN[3]); */ FLOAT vPlane0[4] = {(float)plane0[0], (float)plane0[1], (float)plane0[2], 0.0f}; Vector3 planeNormal(planeN[0] -plane0[0], planeN[1] -plane0[1], planeN[2] -plane0[2]); planeNormal.Normalize(); FLOAT vPlaneN[4] = {(float)planeNormal.X, (float)planeNormal.Y, (float)planeNormal.Z, 0.0f}; m_Device->SetVertexShaderConstantF(49, vPlane0, 1); m_Device->SetVertexShaderConstantF(50, vPlaneN, 1); } m_Device->SetPixelShader(pixelShader); m_Device->SetFVF(CCampathDrawer_VertexFVF); int screenWidth, screenHeight; g_VEngineClient->GetScreenSize(screenWidth, screenHeight); FLOAT newCScreenInfo[4] = { 0 != screenWidth ? 1.0f / screenWidth : 0.0f, 0 != screenHeight ? 1.0f / screenHeight : 0.0f, 0.0, 0.0f}; // Draw trajectory: if(2 <= g_Hook_VClient_RenderView.m_CamPath.GetSize() && campathCanEval) { if(m_RebuildDrawing) { // Rebuild trajectory points. // This operation can be quite expensive (up to O(N^2)), // so it should be done only when s.th. // changed (which is what we do here). m_TrajectoryPoints.clear(); CamPathIterator last = g_Hook_VClient_RenderView.m_CamPath.GetBegin(); CamPathIterator it = last; TempPoint * pts = new TempPoint[c_CameraTrajectoryMaxPointsPerInterval]; for(++it; it != g_Hook_VClient_RenderView.m_CamPath.GetEnd(); ++it) { double delta = it.GetTime() -last.GetTime(); for(size_t i = 0; i<c_CameraTrajectoryMaxPointsPerInterval; i++) { double t = last.GetTime() + delta*((double)i/(c_CameraTrajectoryMaxPointsPerInterval-1)); CamPathValue cpv = g_Hook_VClient_RenderView.m_CamPath.Eval(t); pts[i].t = t; pts[i].y = Vector3(cpv.X, cpv.Y, cpv.Z); pts[i].nextPt = i+1 <c_CameraTrajectoryMaxPointsPerInterval ? &(pts[i+1]) : 0; } RamerDouglasPeucker(&(pts[0]), &(pts[c_CameraTrajectoryMaxPointsPerInterval-1]), c_CameraTrajectoryEpsilon); // add all points except the last one (to avoid duplicates): for(TempPoint * pt = &(pts[0]); pt && pt->nextPt; pt = pt->nextPt) { m_TrajectoryPoints.push_back(pt->t); } last = it; } // add last point: m_TrajectoryPoints.push_back(pts[c_CameraTrajectoryMaxPointsPerInterval-1].t); delete pts; m_RebuildDrawing = false; } newCScreenInfo[2] = c_CameraTrajectoryPixelWidth; m_Device->SetVertexShaderConstantF(48, newCScreenInfo, 1); AutoPolyLineStart(); std::list<double>::iterator itPts = m_TrajectoryPoints.begin(); CamPathIterator itKeysLast = g_Hook_VClient_RenderView.m_CamPath.GetBegin(); CamPathIterator itKeysNext = itKeysLast; ++itKeysNext; bool hasLastPt = false; bool hasNextPt = false; bool hasCurPt = false; double lastPtTime; CamPathValue lastPtValue; double curPtTime; CamPathValue curPtValue; double nextPtTime; CamPathValue nextPtValue; do { if(hasNextPt) { hasLastPt = true; lastPtTime = curPtTime; lastPtValue = curPtValue; hasCurPt = true; curPtTime = nextPtTime; curPtValue = nextPtValue; hasNextPt = false; } else { hasCurPt = true; curPtTime = *itPts; curPtValue = g_Hook_VClient_RenderView.m_CamPath.Eval(curPtTime); ++itPts; } while(itKeysNext.GetTime() < curPtTime) { itKeysLast = itKeysNext; ++itKeysNext; } if(itPts != m_TrajectoryPoints.end()) { hasNextPt = true; nextPtTime = *itPts; nextPtValue = g_Hook_VClient_RenderView.m_CamPath.Eval(nextPtTime); ++itPts; } else { // current point is last point. hasNextPt = false; nextPtValue = curPtValue; } if(!hasLastPt) { // current point is first point. lastPtValue = curPtValue; } // emit current point: { double deltaTime = abs(curTime -curPtTime); DWORD colour; // determine colour: if(deltaTime < 1.0) { double t = (deltaTime -0.0)/1.0; colour = D3DCOLOR_RGBA( ValToUCCondInv(255.0*t, curPtValue.Selected), ValToUCCondInv(255, curPtValue.Selected), ValToUCCondInv(0, curPtValue.Selected), (unsigned char)(127*(1.0-t))+128 ); } else if(deltaTime < 2.0) { double t = (deltaTime -1.0)/1.0; colour = D3DCOLOR_RGBA( ValToUCCondInv(255, curPtValue.Selected), ValToUCCondInv(255.0*(1.0-t), curPtValue.Selected), ValToUCCondInv(0, curPtValue.Selected), (unsigned char)(64*(1.0-t))+64 ); } else { colour = D3DCOLOR_RGBA( ValToUCCondInv(255, curPtValue.Selected), ValToUCCondInv(0, curPtValue.Selected), ValToUCCondInv(0, curPtValue.Selected), 64 ); } AutoPolyLinePoint( Vector3(lastPtValue.X,lastPtValue.Y,lastPtValue.Z) , Vector3(curPtValue.X,curPtValue.Y,curPtValue.Z) , colour , Vector3(nextPtValue.X,nextPtValue.Y,nextPtValue.Z)); } } while(hasNextPt); AutoPolyLineFlush(); } // Draw keyframes: { newCScreenInfo[2] = c_CampathCrossPixelWidth; m_Device->SetVertexShaderConstantF(48, newCScreenInfo, 1); bool lpSelected = false; double lpTime; /*if(0 < g_Hook_VClient_RenderView.m_CamPath.GetSize()) { // Test for not too unlikely hard case: CamPathValue cpv = g_Hook_VClient_RenderView.m_CamPath.GetBegin().GetValue(); Vector3 current(cpv.X+76, cpv.Y+76, cpv.Z+76); Vector3 previous(current.X+76, current.Y-1*4, current.Z); Vector3 next(current.X+76, current.Y+1*4, current.Z); Vector3 next2(current.X, current.Y+2*4, current.Z); Vector3 next3(current.X+76, current.Y+3*4, current.Z); Vector3 next4(current.X, current.Y+4*4, current.Z); Vector3 next5(current.X+76, current.Y+5*4, current.Z); AutoPolyLineStart(); AutoPolyLinePoint(previous, previous, D3DCOLOR_RGBA(255,0,0,255), current); AutoPolyLinePoint(previous, current, D3DCOLOR_RGBA(255,0,0,255), next); AutoPolyLinePoint(current, next, D3DCOLOR_RGBA(255,0,0,255), next2); AutoPolyLinePoint(next, next2, D3DCOLOR_RGBA(255,0,0,255), next3); AutoPolyLinePoint(next2, next3, D3DCOLOR_RGBA(255,0,0,255), next4); AutoPolyLinePoint(next3, next4, D3DCOLOR_RGBA(255,0,0,255), next5); AutoPolyLinePoint(next4, next5, D3DCOLOR_RGBA(255,0,0,255), next5); AutoPolyLineFlush(); }*/ /*if(0 < g_Hook_VClient_RenderView.m_CamPath.GetSize()) { CamPathValue cpv = g_Hook_VClient_RenderView.m_CamPath.GetBegin().GetValue(); float x = cpv.X * m_WorldToScreenMatrix.m[0][0] + cpv.Y * m_WorldToScreenMatrix.m[0][1] + cpv.Z * m_WorldToScreenMatrix.m[0][2] +m_WorldToScreenMatrix.m[0][3]; float y = cpv.X * m_WorldToScreenMatrix.m[1][0] + cpv.Y * m_WorldToScreenMatrix.m[1][1] + cpv.Z * m_WorldToScreenMatrix.m[1][2] +m_WorldToScreenMatrix.m[1][3]; float z = cpv.X * m_WorldToScreenMatrix.m[2][0] + cpv.Y * m_WorldToScreenMatrix.m[2][1] + cpv.Z * m_WorldToScreenMatrix.m[2][2] +m_WorldToScreenMatrix.m[2][3]; float w = cpv.X * m_WorldToScreenMatrix.m[3][0] + cpv.Y * m_WorldToScreenMatrix.m[3][1] + cpv.Z * m_WorldToScreenMatrix.m[3][2] +m_WorldToScreenMatrix.m[3][3]; float iw = w ? 1/w : 0; Tier0_Msg("pt: %f %f %f %f -> %f %f %f %f\n",x,y,z,w,x*iw,y*iw,z*iw,w*iw); }*/ for(CamPathIterator it = g_Hook_VClient_RenderView.m_CamPath.GetBegin(); it != g_Hook_VClient_RenderView.m_CamPath.GetEnd(); ++it) { double cpT = it.GetTime(); CamPathValue cpv = it.GetValue(); cameraMightBeSelected = cameraMightBeSelected || lpSelected && cpv.Selected && lpTime <= curTime && curTime <= cpT; lpSelected = cpv.Selected; lpTime = cpT; double deltaTime = abs(curTime -cpT); bool selected = cpv.Selected; DWORD colour; // determine colour: if(deltaTime < 1.0) { double t = (deltaTime -0.0)/1.0; colour = D3DCOLOR_RGBA( ValToUCCondInv(255.0*t, selected), ValToUCCondInv(255, selected), ValToUCCondInv(0, selected), (unsigned char)(127*(1.0-t))+128 ); } else if(deltaTime < 2.0) { double t = (deltaTime -1.0)/1.0; colour = D3DCOLOR_RGBA( ValToUCCondInv(255, selected), ValToUCCondInv(255.0*(1.0-t), selected), ValToUCCondInv(0, selected), (unsigned char)(64*(1.0-t))+64 ); } else { colour = D3DCOLOR_RGBA( ValToUCCondInv(255, selected), ValToUCCondInv(0, selected), ValToUCCondInv(0, selected), 64 ); } // x / forward line: AutoSingleLine( Vector3(cpv.X -c_CampathCrossRadius, cpv.Y, cpv.Z), colour, Vector3(cpv.X +c_CampathCrossRadius, cpv.Y, cpv.Z), colour ); // y / left line: AutoSingleLine( Vector3(cpv.X, cpv.Y -c_CampathCrossRadius, cpv.Z), colour, Vector3(cpv.X, cpv.Y +c_CampathCrossRadius, cpv.Z), colour ); // z / up line: AutoSingleLine( Vector3(cpv.X, cpv.Y, cpv.Z -c_CampathCrossRadius), colour, Vector3(cpv.X, cpv.Y, cpv.Z +c_CampathCrossRadius), colour ); } AutoSingleLineFlush(); } // Draw wireframe camera: if(inCampath && campathCanEval) { newCScreenInfo[2] = c_CameraPixelWidth; m_Device->SetVertexShaderConstantF(48, newCScreenInfo, 1); DWORD colourCam = campathEnabled ? D3DCOLOR_RGBA( ValToUCCondInv(255,cameraMightBeSelected), ValToUCCondInv(0,cameraMightBeSelected), ValToUCCondInv(255,cameraMightBeSelected), 128) : D3DCOLOR_RGBA( ValToUCCondInv(255,cameraMightBeSelected), ValToUCCondInv(255,cameraMightBeSelected), ValToUCCondInv(255,cameraMightBeSelected), 128); DWORD colourCamUp = campathEnabled ? D3DCOLOR_RGBA( ValToUCCondInv(0,cameraMightBeSelected), ValToUCCondInv(255,cameraMightBeSelected), ValToUCCondInv(0,cameraMightBeSelected), 128) : D3DCOLOR_RGBA( ValToUCCondInv(0,cameraMightBeSelected), ValToUCCondInv(0,cameraMightBeSelected), ValToUCCondInv(0,cameraMightBeSelected), 128); CamPathValue cpv = g_Hook_VClient_RenderView.m_CamPath.Eval(curTime); // limit to values as RenderView hook: cpv.Fov = max(1,cpv.Fov); cpv.Fov = min(179,cpv.Fov); double forward[3], right[3], up[3]; QEulerAngles ang = cpv.R.ToQREulerAngles().ToQEulerAngles(); MakeVectors(ang.Roll, ang.Pitch, ang.Yaw, forward, right, up); Vector3 vCp(cpv.X, cpv.Y, cpv.Z); Vector3 vForward(forward); Vector3 vUp(up); Vector3 vRight(right); //Tier0_Msg("----------------",curTime); //Tier0_Msg("currenTime = %f",curTime); //Tier0_Msg("vCp = %f %f %f\n", vCp.X, vCp.Y, vCp.Z); double a = sin(cpv.Fov * M_PI / 360.0) * c_CameraRadius; double b = a; int screenWidth, screenHeight; g_VEngineClient->GetScreenSize(screenWidth, screenHeight); double aspectRatio = screenWidth ? (double)screenHeight / (double)screenWidth : 1.0; b *= aspectRatio; Vector3 vLU = vCp +(double)c_CameraRadius * vForward -a * vRight +b * vUp; Vector3 vRU = vCp +(double)c_CameraRadius * vForward +a * vRight +b * vUp; Vector3 vLD = vCp +(double)c_CameraRadius * vForward -a * vRight -b * vUp; Vector3 vRD = vCp +(double)c_CameraRadius * vForward +a * vRight -b * vUp; Vector3 vMU = vLU +(vRU -vLU)/2; Vector3 vMUU = vMU +(double)c_CameraRadius * vUp; AutoSingleLine(vCp, colourCam, vLD, colourCam); AutoSingleLine(vCp, colourCam, vRD, colourCam); AutoSingleLine(vCp, colourCam, vLU, colourCam); AutoSingleLine(vCp, colourCam, vRU, colourCam); AutoSingleLine(vLD, colourCam, vRD, colourCam); AutoSingleLine(vRD, colourCam, vRU, colourCam); AutoSingleLine(vRU, colourCam, vLU, colourCam); AutoSingleLine(vLU, colourCam, vLD, colourCam); AutoSingleLine(vMU, colourCam, vMUU, colourCamUp); AutoSingleLineFlush(); // /* colourCam = D3DCOLOR_RGBA(255, 0, 0, 255); colourCamUp = D3DCOLOR_RGBA(255, 255, 0, 255); vCp = vvPos; vForward = vvForward; vUp = vvUp; vRight = vvRight; //Tier0_Msg("vCp2 = %f %f %f\n", vCp.X, vCp.Y, vCp.Z); vLU = vCp +(double)c_CameraRadius * vForward -a * vRight +b * vUp; vRU = vCp +(double)c_CameraRadius * vForward +a * vRight +b * vUp; vLD = vCp +(double)c_CameraRadius * vForward -a * vRight -b * vUp; vRD = vCp +(double)c_CameraRadius * vForward +a * vRight -b * vUp; vMU = vLU +(vRU -vLU)/2; vMUU = vMU +(double)c_CameraRadius * vUp; AutoSingleLine(vCp, colourCam, vLD, colourCam); AutoSingleLine(vCp, colourCam, vRD, colourCam); AutoSingleLine(vCp, colourCam, vLU, colourCam); AutoSingleLine(vCp, colourCam, vRU, colourCam); AutoSingleLine(vLD, colourCam, vRD, colourCam); AutoSingleLine(vRD, colourCam, vRU, colourCam); AutoSingleLine(vRU, colourCam, vLU, colourCam); AutoSingleLine(vLU, colourCam, vLD, colourCam); AutoSingleLine(vMU, colourCam, vMUU, colourCamUp); AutoSingleLineFlush(); */ } } // Restore device state: m_Device->SetPixelShader(oldPixelShader); if(oldPixelShader) oldPixelShader->Release(); m_Device->SetVertexShader(oldVertexShader); if(oldVertexShader) oldVertexShader->Release(); m_Device->SetStreamSource(0, oldVertexBuffer, oldVertexBufferOffset, oldVertexBufferStride); if(oldVertexBuffer) oldVertexBuffer->Release(); m_Device->SetIndices(oldIndexBuffer); if(oldIndexBuffer) oldIndexBuffer->Release(); m_Device->SetFVF(oldFVF); m_Device->SetVertexDeclaration(oldDeclaration); if(oldDeclaration) oldDeclaration->Release(); m_Device->SetVertexShaderConstantF(8, oldCViewProj[0], 4); m_Device->SetVertexShaderConstantF(48, oldCScreenInfo, 1); m_Device->SetVertexShaderConstantF(49, oldCPlane0, 1); m_Device->SetVertexShaderConstantF(50, oldCPlaneN, 1); m_Device->SetRenderState(D3DRS_CULLMODE, oldCullMode); m_Device->SetRenderState(D3DRS_DESTBLEND, oldDestBlend); m_Device->SetRenderState(D3DRS_SRCBLEND, oldSrcBlend); m_Device->SetRenderState(D3DRS_BLENDOP, oldBlendOp); m_Device->SetRenderState(D3DRS_ALPHABLENDENABLE, oldAlphaBlendEnable); m_Device->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, oldSeparateAlphaBlendEnable); m_Device->SetRenderState(D3DRS_ALPHATESTENABLE, oldAlphaTestEnable); m_Device->SetRenderState(D3DRS_ZFUNC, oldZFunc); m_Device->SetRenderState(D3DRS_ZWRITEENABLE, oldZWriteEnable); m_Device->SetRenderState(D3DRS_ZENABLE, oldZEnable); m_Device->SetRenderState(D3DRS_COLORWRITEENABLE, oldColorWriteEnable); m_Device->SetRenderState(D3DRS_SRGBWRITEENABLE, oldSrgbWriteEnable); }
void VisMouseCamera_cl::TickFunction(float fTimeDiff) { hkvVec3 vMove = hkvVec3::ZeroVector(); BOOL bUpDownMode = FALSE; float dx = m_pInputMap->GetTrigger(API_CAMERA_HORIZONTAL_LOOK); float dy = m_pInputMap->GetTrigger(API_CAMERA_VERTICAL_LOOK); if (m_pInputMap->GetTrigger(API_CAMERA_ACTION_1) && m_pInputMap->GetTrigger(API_CAMERA_ACTION_2)) bUpDownMode = TRUE; else if (m_pInputMap->GetTrigger(API_CAMERA_ACTION_2)) m_SpeedMode = 1; else if (m_pInputMap->GetTrigger(API_CAMERA_ACTION_3)) m_SpeedMode = 2; else m_SpeedMode = 0; // handle keyboard status #if !defined(_VISION_MOBILE) && !defined(_VISION_WINRT) if (m_pInputMap->GetTrigger(API_CAMERA_ANY_ACTION)) #endif { hkvVec3 vDir(hkvNoInitialization), vRight(hkvNoInitialization), vUp(hkvNoInitialization); vUp.set(0.f,0.f,1.f); if (GetPhysicsObject()) { // local space vDir.set(1.f,0.f,0.f); vRight.set(0.f,1.f,0.f); } else { hkvMat3 mat(hkvNoInitialization); GetRotationMatrix(mat); vDir = mat.getAxis(0); vRight = mat.getAxis(1); } float fMaxSpeed = m_fMoveSpeed; if (m_SpeedMode == 1) fMaxSpeed *= 3.0f; else if (m_SpeedMode == 2) fMaxSpeed *= 9.0f; // Accumulate move directions (multiply in order to take analog input into account). vMove += vDir * m_pInputMap->GetTrigger(API_CAMERA_MOVE_FORWARD); vMove -= vDir * m_pInputMap->GetTrigger(API_CAMERA_MOVE_BACKWARD); vMove -= vRight * m_pInputMap->GetTrigger(API_CAMERA_MOVE_RIGHT); vMove += vRight * m_pInputMap->GetTrigger(API_CAMERA_MOVE_LEFT); vMove += vUp * m_pInputMap->GetTrigger(API_CAMERA_MOVE_UP); vMove -= vUp * m_pInputMap->GetTrigger(API_CAMERA_MOVE_DOWN); vMove *= fMaxSpeed; // Clamp movement, so that moving diagonally is not faster than moving straight // when using digital input. const float fSpeed = vMove.getLength(); if (fSpeed > fMaxSpeed) vMove.setLength(fMaxSpeed); vMove *= fTimeDiff; } if (m_pInputMap->GetTrigger(API_CAMERA_LOOK_CHANGED)) { if (bUpDownMode) { IncOrientation(-dx * m_fSensitivity, 0, 0); vMove.z -= dy * m_fUpDownSpeed; } else { IncOrientation(-dx * m_fSensitivity, dy * m_fSensitivity, 0); } } switch(m_walkMode) { case WALK: // constrain vMove to the ground float len = vMove.getLength(); vMove.z = 0.f; vMove.setLength(len); break; } if (GetPhysicsObject()) { IncMotionDeltaLocalSpace(vMove); } else { IncPosition( vMove ); } }
void World::Render() { if( !mWorldInitialized ) return; Renderer* renderer = GraphicSubsystem::Instance()->GetRenderer(); GD_ASSERT(renderer); UInt32 viewWidth = renderer->GetRenderTarget()->GetWidth(); UInt32 viewHeight = renderer->GetRenderTarget()->GetHeight(); // Init. //renderer->BeginScene( Renderer::PointList ); renderer->SetViewport( 0, 0, viewWidth, viewHeight ); renderer->SetClearColor(Color4f(0.0f, 0.0f, 0.0f, 1.0f)); renderer->SetRenderState( Renderer::Texture2D, false ); renderer->SetRenderState( Renderer::DepthTest, true ); //renderer->SetRenderState( Renderer::Lighting, true ); //renderer->SetCulling( Renderer::CullBackFace ); // Render. renderer->Clear( Renderer::ColorBuffer | Renderer::DepthBuffer ); renderer->SetMatrixMode(Renderer::ProjectionMatrix); renderer->LoadIdentity(); Camera* currentCamera = GetCurrentCamera(); renderer->Perspective(currentCamera->GetFovAngle(), viewWidth / static_cast<Float>(viewHeight), currentCamera->GetNearView(), currentCamera->GetFarView()); renderer->SetMatrixMode(Renderer::ModelViewMatrix); renderer->LoadIdentity(); currentCamera->ApplyViewMatrix(); /* Light light; light.mPosition = Vector3f( 4.32f, -3.0f, -3.4f ).Normalize(); light.mAmbient = Color4f(1.0f,1.0f, 1.0f,1.0f); light.mDiffuse = Color4f(1.0f,1.0f, 1.0f,1.0f); light.mSpecular = Color4f(1.0f,1.0f, 1.0f,1.0f); light.mType = Renderer::LightDirectional; renderer->SetRenderState( Renderer::Light_i, true, 0 ); renderer->SetLight( 0, light );*/ #if 0 Matrix4d modelView; renderer->GetModelViewMatrix( modelView ); Vector3f vRight( modelView[0], modelView[4], modelView[8] ); Vector3f vUp( modelView[1], modelView[5], modelView[9] ); Vector3f vBottomLeft = light.mPosition + (-vRight - vUp).Normalize() * 2; Vector3f vBottomRight = light.mPosition + ( vRight - vUp).Normalize() * 2; Vector3f vTopRight = light.mPosition + ( vRight + vUp).Normalize() * 2; Vector3f vTopLeft = light.mPosition + (-vRight + vUp).Normalize() * 2; /*renderer->SetRenderState( Renderer::DepthMask, false ); renderer->SetRenderState( Renderer::Lighting, false ); renderer->SetRenderState( Renderer::Blend, true ); renderer->SetBlendFunc( Renderer::BlendSrcAlpha, Renderer::BlendOne );*/ renderer->SetRenderState( Renderer::Lighting, false ); renderer->DrawQuad( vBottomLeft, vBottomRight, vTopRight, vTopLeft, false ); renderer->SetRenderState( Renderer::Lighting, true ); #endif renderer->SetAmbiantColor( Color4f(1.0f, 1.0f, 1.0f, 1.0f) ); /*Light lightPoint; lightPoint.mPosition = currentCamera->GetPosition(); lightPoint.mAmbient = Color4f(0.00f,0.00f, 0.00f,1.0f); lightPoint.mDiffuse = Color4f(1.0f,1.0f, 1.0f,1.0f); lightPoint.mSpecular = Color4f(1.0f,1.0f, 1.0f,1.0f); lightPoint.mType = Renderer::LightPoint; lightPoint.mAttenuationConstant = 0; lightPoint.mAttenuationLinear = 0; lightPoint.mAttenuationQuadratic = 0.01f; renderer->SetRenderState( Renderer::Light_i, true, 0 ); renderer->SetLight( 0, lightPoint );*/ // Get the frustum. Matrix4f modelViewMatrix; Matrix4f projectionMatrix; Frustum frustum; renderer->GetModelViewMatrix(modelViewMatrix); renderer->GetProjectionMatrix(projectionMatrix); frustum.CalculateFrustum(projectionMatrix, modelViewMatrix); mNbRenderedEntities = 0; // Render the objects in the world. /* List<Entity*> visibleEntities; mSpacePartition->Query(frustum, visibleEntities); */ List<Entity*>::const_iterator itEntity; for( itEntity = mEntities.begin(); itEntity != mEntities.end(); ++itEntity ) { if( *itEntity != currentCamera ) { // Do frustum culling. if((*itEntity)->GetClass() != Terrain::StaticClass() && (*itEntity)->GetClass() != SkyDome::StaticClass()) { BoundingBox boundingBox = (*itEntity)->GetBoundingBox(); if( (*itEntity)->GetClass() != ParticleEmitter::StaticClass() ) { Matrix4f translation = Matrix4f::Translation((*itEntity)->GetPosition()); Matrix4f rotation; (*itEntity)->GetOrientation().ToMatrix(rotation); Matrix4f trsMatrix = rotation * translation; boundingBox.SetMin( boundingBox.Min() * trsMatrix ); boundingBox.SetMax( boundingBox.Max() * trsMatrix ); } if( frustum.BoxInFrustum(boundingBox) ) { mNbRenderedEntities++; } else { continue; } } renderer->PushMatrix(); if( String((*itEntity)->GetClass()->GetName()) == "SkyDome" ) renderer->Translate(currentCamera->GetPosition()-Vector3f(0,100,0) ); else renderer->Translate((*itEntity)->GetPosition()); renderer->Rotate((*itEntity)->GetOrientation()); if( (*itEntity)->IsSelected() ) (*itEntity)->RenderSelected(); (*itEntity)->Render(); renderer->PopMatrix(); } } renderer->SetMatrixMode(Renderer::ModelViewMatrix); renderer->LoadIdentity(); currentCamera->ApplyViewMatrix(); //renderer->EndScene(); }