int main() { //**************// //** jVector2 **// //**************// // Create an "empty" jVector2: (0,0) jVector2 vector1; // Create "partial" jVector2: (5,0) jVector2 vector2(5.0f); // Create "full" jVector2: (1,2) jVector2 vector3(1.0f, 2.0f); // print the vectors out std::cout << vector1.toString() << std::endl; std::cout << vector2.toString() << std::endl; std::cout << vector3.toString() << std::endl; // add two vectors together jVector2 sum23 = vector2 + vector3; std::cout << sum23.toString() << std::endl; // subtract two vectors jVector2 diff = jVector2(6.0f, 4.0f) - jVector2(10.0f, 2.0f); std::cout << diff.toString() << std::endl; // multiply vector by scalar std::cout << (vector3 * 1.25f).toString() << std::endl; // divide vector by scalar std::cout << (sum23 / 10.0f).toString() << std::endl; // test equality std::cout << (sum23 == diff) << std::endl; // test inequality std::cout << (diff != vector1) << std::endl; // get magnitude std::cout << vector3.magnitude_sqr() << std::endl; // normalize vector std::cout << (vector3.normalized()).toString() << std::endl; //////////////////////////////////////////////////// // jVector3 jVector3 vector_1; jVector3 vector_2(5.0f); jVector3 vector_3(1.0f, 2.0f, 3.0f); std::cout << vector_1.toString() << std::endl; std::cout << vector_2.toString() << std::endl; std::cout << vector_3.toString() << std::endl; // This will be put into the jDebug namespace/class. /* #ifdef linux #else // And this is why programming for Windows sucks... HANDLE h_stdout = GetStdHandle( STD_OUTPUT_HANDLE ); CONSOLE_SCREEN_BUFFER_INFO csbi; GetConsoleScreenBufferInfo( h_stdout, &csbi ); // Foreground B G R I // Colors 0 0 1 1 // Background B G R I // Colors 0 0 0 1 // All together, 00110001 is like this: SetConsoleTextAttribute( h_stdout, 0x31 ); std::cout << vector_1 << std::endl; SetConsoleTextAttribute( h_stdout, csbi.wAttributes ); #endif */ jDebug::LogError("An error has occurred!"); jDebug::LogWarning("A warning has occurred!"); jDebug::Log("A notification has appeared."); jDebug::AddLogger("main", "logs/main.log"); jDebug::LogError("main", "A test error to be found in main.log"); jDebug::Log("main", "A test notification to be found in main.log"); // Don't forget your cleanup! jDebug::DestructLoggers(); return 0; }
vector3 normalize() { float norm = sqrt(x*x + y*y + z*z); return vector3(x / norm, y / norm, z / norm); }
Vector4T& normalize3 (double len = 1.0) { vector3().normalize(len); return *this; }
//------------------------------------------------------------------------------ bool OBOpenDXCubeFormat::ReadMolecule( OBBase* pOb, OBConversion* pConv ) { OBMol* pmol = pOb->CastAndClear<OBMol>(); if(pmol == 0) return false; istream& ifs = *pConv->GetInStream(); const char* title = pConv->GetTitle(); char buffer[BUFF_SIZE]; stringstream errorMsg; if (!ifs) return false; // We are attempting to read past the end of the file pmol->SetTitle(title); while (ifs.good() && ifs.getline(buffer,BUFF_SIZE)) { if (buffer[0] == '#') continue; // comment line if (EQn(buffer, "object", 6)) break; } if (!ifs) return false; // ran out of lines vector<string> vs; tokenize(vs, buffer); // Number of grid points (voxels) vector<int> voxels(3); if (!EQn(buffer, "object", 6) || vs.size() != 8) return false; else { voxels[0] = atoi(vs[5].c_str()); voxels[1] = atoi(vs[6].c_str()); voxels[2] = atoi(vs[7].c_str()); } double x, y, z; if (!ifs.getline(buffer, BUFF_SIZE) || !EQn(buffer, "origin", 6)) return false; else { tokenize(vs, buffer); if (vs.size() != 4) return false; x = atof(vs[1].c_str()); y = atof(vs[2].c_str()); z = atof(vs[3].c_str()); } vector3 origin(x, y, z); // now three lines with the x, y, and z axes vector<vector3> axes; for (unsigned int i = 0; i < 3; ++i) { if (!ifs.getline(buffer, BUFF_SIZE) || !EQn(buffer, "delta", 5)) return false; else { tokenize(vs, buffer); if (vs.size() != 4) return false; x = atof(vs[1].c_str()); y = atof(vs[2].c_str()); z = atof(vs[3].c_str()); axes.push_back(vector3(x, y, z)); } } // Two remaining header lines before the data: /* object 2 class gridconnections counts nx ny nz object 3 class array type double rank 0 times n data follows */ if (!ifs.getline(buffer, BUFF_SIZE) || !EQn(buffer, "object", 6)) return false; if (!ifs.getline(buffer, BUFF_SIZE) || !EQn(buffer, "object", 6)) return false; pmol->BeginModify(); pmol->SetDimension(3); OBGridData *gd = new OBGridData; gd->SetAttribute("OpenDX"); // get all values as one vector<double> char *endptr; vector<double> values; int n = voxels[0]*voxels[1]*voxels[2]; int line = 0; values.reserve(n); while (ifs.getline(buffer, BUFF_SIZE)) { ++line; if (EQn(buffer, "attribute", 9)) break; // we're finished with reading data -- although we should probably have a voxel check in here too tokenize(vs, buffer); if (vs.size() == 0) { errorMsg << "Problem reading the OpenDX grid file: cannot" << " read line " << line << ", there does not appear to be any data in it.\n" << buffer << "\n"; obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obError); return false; } for (unsigned int l = 0; l < vs.size(); ++l) { values.push_back(strtod(static_cast<const char*>(vs[l].c_str()), &endptr)); } } gd->SetNumberOfPoints(voxels[0], voxels[1], voxels[2]); gd->SetLimits(origin, axes[0], axes[1], axes[2]); gd->SetUnit(OBGridData::ANGSTROM); gd->SetOrigin(fileformatInput); // i.e., is this data from a file or determined by Open Babel gd->SetValues(values); // set the values pmol->SetData(gd); // store the grids in the OBMol pmol->EndModify(); // Trailing control lines /* attribute "dep" string "positions" object "regular positions regular connections" class field component "positions" value 1 component "connections" value 2 component "data" value 3 */ if (!ifs.getline(buffer, BUFF_SIZE) || !EQn(buffer, "object", 6)) return false; if (!ifs.getline(buffer, BUFF_SIZE) || !EQn(buffer, "component", 9)) return false; if (!ifs.getline(buffer, BUFF_SIZE) || !EQn(buffer, "component", 9)) return false; if (!ifs.getline(buffer, BUFF_SIZE) || !EQn(buffer, "component", 9)) return false; // clean out any remaining blank lines std::streampos ipos; do { ipos = ifs.tellg(); ifs.getline(buffer,BUFF_SIZE); } while(strlen(buffer) == 0 && !ifs.eof() ); ifs.seekg(ipos); return true; }
Tmpl8::Frustum::Frustum() { ////////////////////////////////// Viewspace frustum //////////////////////////////////////// // didn't quit finish it. float top = -(SCRHEIGHT / 2) + 1; float left = -(SCRWIDTH / 2) + 1; float bottom = (SCRHEIGHT / 2) - 1; float right = (SCRWIDTH / 2) - 1; float nearp = 1.0f; float farp = 50; float FoV = 0.003; for(unsigned int i = 0; i < 6; ++i) { m_Plane[i] = new Plane(); } vector3 nv1, nv2, nv3, nv4; vector3 fv1, fv2, fv3, fv4; nv1.x = left * nearp / FoV; nv1.y = top * nearp / FoV; nv1.z = nearp; nv2.x = left * nearp / FoV; nv2.y = bottom * nearp / FoV; nv2.z = nearp; nv3.x = right * nearp / FoV; nv3.y = top * nearp / FoV; nv3.z = nearp; nv4.x = right * nearp / FoV; nv4.y = bottom * nearp / FoV; nv4.z = nearp; fv1.x = left * farp / FoV; fv1.y = top * farp / FoV; fv1.z = farp; fv2.x = left * farp / FoV; fv2.y = bottom * farp / FoV; fv2.z = farp; fv3.x = right * farp / FoV; fv3.y = top * farp / FoV; fv3.z = farp; fv4.x = right * farp / FoV; fv4.y = bottom * farp / FoV; fv4.z = farp; //Left vector3 edge1 = nv1 - nv2; vector3 edge2 = nv1 - fv1; vector3 normal = edge1.Cross(edge2); float length = normal.Length(); normal.Normalize(); m_Plane[Frustum::PLANE_LEFT]->SetNormal(normal); m_Plane[Frustum::PLANE_LEFT]->SetDistance(0); //Right edge1 = nv4 - nv3; edge2 = nv3 - fv3; normal = edge1.Cross(edge2); normal.Normalize(); m_Plane[Frustum::PLANE_RIGHT]->SetNormal(normal); m_Plane[Frustum::PLANE_RIGHT]->SetDistance(0); //Top edge1 = nv4 - nv2; edge2 = nv2 - fv2; normal = edge2.Cross(edge1); normal.Normalize(); m_Plane[Frustum::PLANE_TOP]->SetNormal(normal); m_Plane[Frustum::PLANE_TOP]->SetDistance(0); //bottom edge1 = nv3 - nv1; edge2 = nv1 - fv1; normal = edge1.Cross(edge2); normal.Normalize(); m_Plane[Frustum::PLANE_BOTTOM]->SetNormal(normal); m_Plane[Frustum::PLANE_BOTTOM]->SetDistance(0); m_Plane[Frustum::PLANE_NEAR]->SetNormal(vector3(0, 0, 1)); m_Plane[Frustum::PLANE_NEAR]->SetDistance(nearp); m_Plane[Frustum::PLANE_FAR]->SetNormal(vector3(0, 0, -1)); m_Plane[Frustum::PLANE_FAR]->SetDistance(-farp); }
CUniversalJoint::CUniversalJoint(): AxisParams(2) { AxisParams[0].Axis = vector3(0.0f, 0.0f, 1.0f); AxisParams[1].Axis = vector3(0.0f, 1.0f, 0.0f); }
void AppClass::InitVariables(void) { //Set the camera position m_pCameraMngr->SetPositionTargetAndView( vector3(0.0f, 2.5f, 15.0f),//Camera position vector3(0.0f, 2.5f, 0.0f),//What Im looking at REAXISY);//What is up m_pCameraMngr->SetCameraMode(CAMERAMODE::CAMROTHOZ); //Instance objects to display the game elements m_pMeshMngr->InstanceSphere(0.3f, 5, RERED, "Ball"); m_pMeshMngr->InstanceCuboid(vector3(20, 1, 1), REPURPLE, "BoxT"); m_pMeshMngr->InstanceCuboid(vector3(20, 1, 1), REPURPLE, "BoxB"); m_pMeshMngr->InstanceCuboid(vector3(1, 11, 1), REGREEN, "BoxL"); m_pMeshMngr->InstanceCuboid(vector3(1, 11, 1), REGREEN, "BoxR"); m_pMeshMngr->InstanceCuboid(vector3(0.5, 3, 0.5), REBLUE, "PalletL"); m_pMeshMngr->InstanceCuboid(vector3(0.5, 3, 0.5), REBLUE, "PalletR"); //Create game objects based on the loaded objects m_pBall = new MyEntityClass("Ball"); m_pBoxT = new MyEntityClass("BoxT"); m_pBoxB = new MyEntityClass("BoxB"); m_pBoxL = new MyEntityClass("BoxL"); m_pBoxR = new MyEntityClass("BoxR"); m_pPalletL = new MyEntityClass("PalletL"); m_pPalletR = new MyEntityClass("PalletR"); //Set properties of the objects m_pBall->SetVelocity(vector3(0.11f, 0.11f, 0.0f)); m_pBoxT->SetModelMatrix(glm::translate(vector3(0, 5, 0))); m_pBoxB->SetModelMatrix(glm::translate(vector3(0, -5, 0))); m_pBoxR->SetModelMatrix(glm::translate(vector3(10.5, 0, 0))); }
void AppClass::ProcessKeyboard(void) { bool bModifier = false; float fSpeed = 0.01f; #pragma region ON PRESS/RELEASE DEFINITION static bool bLastF1 = false, bLastF2 = false, bLastF3 = false, bLastF4 = false, bLastF5 = false, bLastF6 = false, bLastF7 = false, bLastF8 = false, bLastF9 = false, bLastF10 = false, bLastEscape = false; #define ON_KEY_PRESS_RELEASE(key, pressed_action, released_action){ \ bool pressed = sf::Keyboard::isKeyPressed(sf::Keyboard::key); \ if(pressed){ \ if(!bLast##key) pressed_action;}/*Just pressed? */\ else if(bLast##key) released_action;/*Just released?*/\ bLast##key = pressed; } //remember the state #pragma endregion #pragma region Modifiers if(sf::Keyboard::isKeyPressed(sf::Keyboard::LShift) || sf::Keyboard::isKeyPressed(sf::Keyboard::RShift)) bModifier = true; #pragma endregion if (sf::Keyboard::isKeyPressed(sf::Keyboard::R)) { m_v3Orientation = vector3(0.0f); something = quaternion(vector3(0.0f, 0.0f, 0.0f)); } if (sf::Keyboard::isKeyPressed(sf::Keyboard::X)) { if (!bModifier) { m_v3Orientation.x += 1.0f; something = something * quaternion(vector3(PI * 0.01f, 0, 0)); } else { m_v3Orientation.x -= 1.0f; something = something * quaternion(-vector3(PI * 0.01f, 0, 0)); } } if (sf::Keyboard::isKeyPressed(sf::Keyboard::Y)) { if (!bModifier) { m_v3Orientation.y += 1.0f; something = something * quaternion(vector3(PI * 0.01f, 0, 0)); } else { m_v3Orientation.y -= 1.0f; something = something * quaternion(-vector3(0.0f, -PI * 0.01f, 0)); } } if (sf::Keyboard::isKeyPressed(sf::Keyboard::Z)) { if (!bModifier) { m_v3Orientation.z += 1.0f; something = something * quaternion(vector3(PI * 0.01f, 0, 0)); } else { m_v3Orientation.z -= 1.0f; something = something * quaternion(-vector3(0, 0, -PI * 0.01f)); } } #pragma region Camera Positioning if(bModifier) fSpeed *= 10.0f; if(sf::Keyboard::isKeyPressed(sf::Keyboard::W)) m_pCameraMngr->MoveForward(fSpeed); if(sf::Keyboard::isKeyPressed(sf::Keyboard::S)) m_pCameraMngr->MoveForward(-fSpeed); if(sf::Keyboard::isKeyPressed(sf::Keyboard::A)) m_pCameraMngr->MoveSideways(-fSpeed); if(sf::Keyboard::isKeyPressed(sf::Keyboard::D)) m_pCameraMngr->MoveSideways(fSpeed); m_pCameraMngr->CalculateView(); #pragma endregion #pragma region Other Actions ON_KEY_PRESS_RELEASE(Escape, NULL, PostMessage(m_pWindow->GetHandler(), WM_QUIT, NULL, NULL)) #pragma endregion }
vector3 vector3::sym(vector3 v1)//V关于N的对称就是2(N*V)*N-V { double k=2*(this->x*v1.x+this->y*v1.y+this->z*v1.z)/(v1.x*v1.x+v1.y*v1.y+v1.z*v1.z); return vector3(v1.x*k-this->x,v1.y*k-this->y,v1.z*k-this->z); }
bool XSFFormat::ReadMolecule(OBBase* pOb, OBConversion* pConv) { OBMol* pmol = pOb->CastAndClear<OBMol>(); if(pmol==NULL) return false; //Define some references so we can use the old parameter names istream &ifs = *pConv->GetInStream(); OBMol &mol = *pmol; const char* title = pConv->GetTitle(); char buffer[BUFF_SIZE]; string str; double x,y,z; OBAtom *atom; vector3 translationVectors[3]; int numTranslationVectors = 0; vector<string> vs; vector<vector3> atomPositions; bool createdAtoms = false; int atomicNum; mol.BeginModify(); while (ifs.getline(buffer, BUFF_SIZE)) { if (buffer[0] == '#') continue; // comment if (strstr(buffer, "ATOMS") != NULL) { // Minimum of 4 columns -- AtNum, x, y, z (forces) // where AtNum stands for atomic number (or symbol), while X Y Z are ifs.getline(buffer, BUFF_SIZE); tokenize(vs, buffer); while (vs.size() >= 4) { if (!createdAtoms) { atom = mol.NewAtom(); //set atomic number atomicNum = OBElements::GetAtomicNum(vs[0].c_str()); if (atomicNum == 0) { atomicNum = atoi(vs[0].c_str()); } atom->SetAtomicNum(atomicNum); } x = atof((char*)vs[1].c_str()); y = atof((char*)vs[2].c_str()); z = atof((char*)vs[3].c_str()); atomPositions.push_back(vector3(x, y, z)); // we may have a movie or animation ifs.getline(buffer, BUFF_SIZE); tokenize(vs, buffer); } createdAtoms = true; // don't run NewAtom() anymore } else if ( strstr(buffer, "PRIMVEC") || strstr(buffer, "CONVVEC") ) { // translation vectors numTranslationVectors = 0; // if we have an animation while (numTranslationVectors < 3 && ifs.getline(buffer,BUFF_SIZE)) { tokenize(vs,buffer); // we really need to check that it's 3 entries only if (vs.size() < 3) return false; // timvdm 18/06/2008 x = atof((char*)vs[0].c_str()); y = atof((char*)vs[1].c_str()); z = atof((char*)vs[2].c_str()); translationVectors[numTranslationVectors++].Set(x, y, z); } } else if (strstr(buffer, "PRIMCOORD") != NULL) { // read the coordinates ifs.getline(buffer, BUFF_SIZE); tokenize(vs, buffer); if (vs.size() < 2) return false; int numAtoms = atoi(vs[0].c_str()); for (int a = 0; a < numAtoms; ++a) { if (!ifs.getline(buffer,BUFF_SIZE)) break; tokenize(vs,buffer); if (vs.size() < 4) break; if (!createdAtoms) { atom = mol.NewAtom(); //set atomic number atomicNum = OBElements::GetAtomicNum(vs[0].c_str()); if (atomicNum == 0) { atomicNum = atoi(vs[0].c_str()); } atom->SetAtomicNum(atomicNum); } x = atof((char*)vs[1].c_str()); y = atof((char*)vs[2].c_str()); z = atof((char*)vs[3].c_str()); atomPositions.push_back(vector3(x, y, z)); } } } mol.EndModify(); int natom = mol.NumAtoms(); int numConformers = atomPositions.size() / natom; for (int i = 0; i < numConformers; ++i) { double *coordinates = new double[natom * 3]; for (int j = 0; j < natom; ++j) { vector3 currentPosition = atomPositions[i*natom + j]; coordinates[j*3] = currentPosition.x(); coordinates[j*3 + 1] = currentPosition.y(); coordinates[j*3 + 2] = currentPosition.z(); } mol.AddConformer(coordinates); } // Delete first conformer, created by EndModify, bunch of 0s mol.DeleteConformer(0); // Set geometry to last one mol.SetConformer(mol.NumConformers() - 1); if (!pConv->IsOption("b",OBConversion::INOPTIONS)) mol.ConnectTheDots(); if (!pConv->IsOption("s",OBConversion::INOPTIONS) && !pConv->IsOption("b",OBConversion::INOPTIONS)) mol.PerceiveBondOrders(); // Add final properties mol.SetTitle(title); if (numTranslationVectors == 3) { OBUnitCell *uc = new OBUnitCell; uc->SetOrigin(fileformatInput); uc->SetData(translationVectors[0], translationVectors[1], translationVectors[2]); mol.SetData(uc); } return(true); }
vector3 rotate_vector( vector3 const& v, quat const& q ) { quat p = quat(v.x(), v.y(), v.z(), 0); quat tp = q * p * q.inverse(); return vector3(tp.qx(), tp.qy(), tp.qz()); }
void AppClass::Update(void) { //Sets the camera m_pCameraMngr->SetPositionTargetAndView(vector3(0.0f, 25.0f, 0.0f), vector3(0.0f, 0.0f, 0.0f), -REAXISZ); //Update the system's time m_pSystem->UpdateTime(); //Update the mesh manager's time without updating for collision detection m_pMeshMngr->Update(); //First person camera movement if (m_bFPC == true) CameraRotation(); //Call the arcball method ArcBall(); //Adds all loaded instance to the render list m_pMeshMngr->AddInstanceToRenderList("ALL"); //This matrices will just orient the objects to the camera matrix4 rotateX = glm::rotate(IDENTITY_M4, 90.0f, vector3(1.0f, 0.0f, 0.0f)); matrix4 rotateY = glm::rotate(IDENTITY_M4, 90.0f, vector3(0.0f, 1.0f, 0.0f)); //This matrices will hold the relative transformation of the Moon and the Earth matrix4 distanceEarth = glm::translate(11.0f, 0.0f, 0.0f); matrix4 distanceMoon = glm::translate(2.0f, 0.0f, 0.0f); //Earth's orbit around the Sun matrix4 orbitEarth = glm::rotate(IDENTITY_M4, m_fEarthTimer, vector3(0.0f, 1.0f, 0.0f)); //Earth's rotation on its own axis matrix4 rotationEarth = glm::rotate(IDENTITY_M4, m_fEarthTimer * 28.0f, vector3(0.0f, 1.0f, 0.0f)); //Moon's orbit around the Earth matrix4 orbitMoon = glm::rotate(IDENTITY_M4, m_fMoonTimer, vector3(0.0f, -1.0f, 0.0f)); //Moon's rotation around its own axis matrix4 rotationMoon = glm::rotate(IDENTITY_M4, m_fMoonTimer, vector3(0.0f, 1.0f, 0.0f)); //I will calculate the Earth position in space relative to the Sun (which is in global space) matrix4 earthsSpace = orbitEarth * distanceEarth;//the translation depends on the orientation of the space (Earths orbit) m_m4Earth = earthsSpace * rotationEarth;//the rotation of the Earth will depend on the new space m_m4Earth = m_m4Earth * rotateX;//Will orient the Earth to the camera now //I will calculate the moon's position in space relative to the Earth (earthsSpace) matrix4 moonsSpace = orbitMoon * distanceMoon;//the moon's translation depends on its orientation (Moons orbit) m_m4Moon = earthsSpace * moonsSpace;//Then we place the moons space in therms of the earth space m_m4Moon = m_m4Moon * rotateY * rotateX;//Then we orient the Moon to the camera) printf("Earth Day: %.3f, Moon Day: %.3f\r", m_fEarthTimer, m_fMoonTimer);//print the Frames per Second //Indicate the FPS int nFPS = m_pSystem->GetFPS(); //Print info on the screen m_pMeshMngr->PrintLine(m_pSystem->GetAppName(), REYELLOW); m_pMeshMngr->Print("Earth Day: ", REWHITE); m_pMeshMngr->PrintLine(std::to_string(m_fEarthTimer), REBLUE); m_pMeshMngr->Print("Moon Day: ", REWHITE); m_pMeshMngr->PrintLine(std::to_string(m_fMoonTimer), REBLUE); m_pMeshMngr->Print("FPS:"); m_pMeshMngr->Print(std::to_string(nFPS), RERED); m_fMoonTimer++;//Increase moon timer m_fEarthTimer = m_fMoonTimer / 28.0f; //divide by the moon's day }
glm::mat4 Camera::GetView() { return glm::lookAt(vector3(position.x, position.y, position.z), vector3(target.x, target.y, target.z), vector3(up.x, up.y, up.z)); }
// dir3D conversions to/from different RHCoordSyst3's vector3 dirWCStoLCS(vector3 vDir1, RHCoordSys3 LCS) { normalize(vDir1); return vector3(dot(vDir1,LCS[0]),dot(vDir1,LCS[1]),dot(vDir1,LCS[2])); }
void ApplicationClass::GenerateBoundingBox(matrix4 a_mModelToWorld, String a_sInstanceName) { if(m_pMeshMngr->IsInstanceCreated(a_sInstanceName)) { static bool bInitialized = false; static vector3 vCenterPoint; static float fDistance; if(!bInitialized) { std::vector<vector3> lVertices = m_pMeshMngr->m_pModelMngr->GetVertices(a_sInstanceName); unsigned int nVertices = lVertices.size(); vCenterPoint = lVertices[0]; vector3 v3Max(lVertices[0]); vector3 v3Min(lVertices[0]); for(unsigned int nVertex = 1; nVertex < nVertices; nVertex++) { //m_v3Centroid += lVertices[nVertex]; if(v3Min.x > lVertices[nVertex].x) v3Min.x = lVertices[nVertex].x; else if(v3Max.x < lVertices[nVertex].x) v3Max.x = lVertices[nVertex].x; if(v3Min.y > lVertices[nVertex].y) v3Min.y = lVertices[nVertex].y; else if(v3Max.y < lVertices[nVertex].y) v3Max.y = lVertices[nVertex].y; if(v3Min.z > lVertices[nVertex].z) v3Min.z = lVertices[nVertex].z; else if(v3Max.z < lVertices[nVertex].z) v3Max.z = lVertices[nVertex].z; } vCenterPoint = (v3Min + v3Max) / 2.0f; m_pMeshMngr->AddAxisToQueue(a_mModelToWorld * glm::translate(vCenterPoint)); fDistance = glm::distance(vCenterPoint, lVertices[0]); for(unsigned int nVertex = 1; nVertex < nVertices; nVertex++) { float fDistanceNew = glm::distance(vCenterPoint, lVertices[nVertex]); if(fDistance < fDistanceNew) fDistance = fDistanceNew; } bInitialized = true; } m_pMeshMngr->AddCubeToQueue(a_mModelToWorld * glm::translate(vCenterPoint) * glm::scale(vector3(fDistance * 2.0f)), MERED, MERENDER::WIRE); } }
vector3 vector3::operator*(double t) { return vector3(x*t,y*t,z*t); }
void ApplicationClass::Update (void) { m_pSystem->UpdateTime(); //Update the system m_pMeshMngr->Update(); //Updates the mesh information float fTimeSpan = m_pSystem->StopClock(); //Check the time difference between this method calls static float fRunTime = 0.0f; fRunTime += fTimeSpan; //update the run time count //matrix4 m4Steve = glm::rotate(matrix4(IDENTITY), fRunTime * 15, vector3( 0.0f,-1.0f, 0.0f)); matrix4 m4Steve = glm::translate(vector3( 0.0f,0.0f, 0.0f)); matrix4 m4Zombie = glm::translate(vector3(-6.0f, 0.0f, 0.0f)); matrix4 m4Cow = glm::translate(vector3(-3.0f, 0.0f, 0.0f)); matrix4 m4Pig = glm::translate(vector3(6.0f, 0.0f, 0.0f)); m_pMeshMngr->SetModelMatrix(m4Steve, "Steve"); m_pMeshMngr->SetModelMatrix(m_m4Creeper, "Creeper"); m_pMeshMngr->SetModelMatrix(m4Pig, "Pig"); m_pMeshMngr->SetModelMatrix(m4Zombie, "Zombie"); m_pMeshMngr->SetModelMatrix(m4Cow, "Cow"); #pragma region Method //GenerateBoundingBox(mA,"A"); #pragma endregion #pragma region Bounding Box Class //pBoundingBox1->GenerateBoundingBox("Steve"); //pBoundingBox2->GenerateBoundingBox("Creeper"); //pBoundingBox1->AddBoxToRenderList(m4Steve, MEYELLOW, true); //pBoundingBox2->AddBoxToRenderList(m_m4Creeper, MEYELLOW, true); #pragma endregion #pragma region Bounding Box Manager m_pBSMngr->GenerateBoundingBox("Steve"); m_pBSMngr->GenerateBoundingBox("Creeper"); m_pBSMngr->GenerateBoundingBox("Cow"); m_pBSMngr->GenerateBoundingBox("Zombie"); m_pBSMngr->GenerateBoundingBox("Pig"); m_pBSMngr->SetBoundingBoxSpace(m4Steve, "Steve"); m_pBSMngr->SetBoundingBoxSpace(m_m4Creeper, "Creeper"); m_pBSMngr->SetBoundingBoxSpace(m4Cow, "Cow"); m_pBSMngr->SetBoundingBoxSpace(m4Pig, "Pig"); m_pBSMngr->SetBoundingBoxSpace(m4Zombie, "Zombie"); m_pBSMngr->CalculateCollision(); m_pBSMngr->AddBoxToRenderList("ALL"); #pragma endregion m_pMeshMngr->AddInstanceToRenderList(); //First person camera movement if(m_bFPC == true) CameraRotation(); m_pCamera->PrintInfo(); printf("FPS: %d\r", m_pSystem->FPS);//print the Frames per Second }
vector3 vector3::operator-(vector3 t) { return vector3(x-t.x,y-t.y,z-t.z); }
Intersection Cylindre::intersect(Rayon* r) { Intersection inter; double a; double b; double c; double delta; double t, t1, t2; /* equation du Cylindre y²+z²=rayon² avec 0<x<longueur=height * (dy.t+py)²+(dz.t+pz)²=rayon² * (dy²+dz²)t²+(dy.py+dz.pz)t+(py²+pz²-rayon²)=0 * at²+bt+c=0 */ inter.setObjet(this); a=pow(r->getDirection().y,2)+pow(r->getDirection().z,2); b=(r->getDirection().y*r->getPosition().y)+(r->getDirection().z*r->getPosition().z); c=pow(r->getPosition().y,2)+pow(r->getPosition().z,2)-pow(this->r,2); //calcul du discriminant delta = pow(b,2)-4*a*c; if (delta <= 0) { inter.setDistance(DBL_MAX); //distance infinie (pas d'intersection) //si py²+pz²-rayon²<=0 ou c<0 //on se situe sur l'alignement du cylindre if(c<0){ if( (this->height!=0) && (r->getPosition().x>this->height || (r->getPosition().x>=0.0 && r->getPosition().x<this->height))){ if(r->getDirection().x!=0.0){ t = (this->height-r->getPosition().x)/r->getDirection().x; inter.setPoint( vector3(this->height, t * r->getDirection().y + r->getPosition().y, t * r->getDirection().z + r->getPosition().z) ); if(t>EPSILON && c<=0){ inter.setDistance ( (inter.getPoint()-r->getPosition()).Length() ); }else{ inter.setDistance(DBL_MAX); } }else{ inter.setDistance ( DBL_MAX ); } } if( (this->height!=0) && (r->getPosition().x<this->height || (r->getPosition().x>0.0 && r->getPosition().x<=this->height))){ if(r->getDirection().x!=0.0){ t = (-r->getPosition().x)/r->getDirection().x; inter.setPoint(vector3(0.0, t * r->getDirection().y + r->getPosition().y, t * r->getDirection().z + r->getPosition().z) ); if(t>EPSILON && c<=0){ inter.setDistance ( (inter.getPoint()-r->getPosition()).Length() ); }else{ inter.setDistance(DBL_MAX); } }else{ inter.setDistance(DBL_MAX); } } } }else{ //deux solutions t1 = (-b + sqrt (delta)) / 2*a; t2 = (-b - sqrt (delta)) / 2*a; if (t1 <= EPSILON && t2 <= EPSILON){ inter.setDistance(DBL_MAX); }else{ if ((t1 <= t2 && t1 > EPSILON) || (t2 < t1 && t2 < EPSILON)){ t = t1; }else if ((t2 < t1 && t2 > EPSILON) || (t1 < t2 && t1 < EPSILON)){ t = t2; } inter.setPoint(vector3(t * r->getDirection().x + r->getPosition().x, t * r->getDirection().x + r->getPosition().x, t * r->getDirection().z + r->getPosition().z)); inter.setDistance ( (inter.getPoint()-r->getPosition()).Length() ); if( (this->height!=0) && (inter.getPoint().x>this->height) || (r->getPosition().x>this->height && c<=0)){ if(r->getDirection().x!=0.0){ t = (this->height-r->getPosition().x)/r->getDirection().x; inter.setPoint(vector3(this->height, t * r->getDirection().y + r->getPosition().y, t * r->getDirection().z + r->getPosition().z) ); if(t>EPSILON && c<=0){ inter.setDistance ( (inter.getPoint()-r->getPosition()).Length() ); }else{ inter.setDistance(DBL_MAX); } }else{ inter.setDistance(DBL_MAX); } } if( (this->height!=0) && (inter.getPoint().x<0.0) || (r->getPosition().x<0.0 && c<=0)){ if(r->getDirection().x!=0.0){ t = (-r->getPosition().x)/r->getDirection().x; inter.setPoint(vector3(0.0, t * r->getDirection().y + r->getPosition().y, t * r->getDirection().z + r->getPosition().z) ); if(t>EPSILON){ inter.setDistance ( (inter.getPoint()-r->getPosition()).Length() ); }else{ inter.setDistance(DBL_MAX); } }else{ inter.setDistance(DBL_MAX); } } } } //TODO: la normale return (inter); }
vector3 vector3::operator+(vector3 t) { return vector3(x+t.x,y+t.y,z+t.z); }
void CCharEntity::OnStepBefore() { if (IsCollisionEnabled() && !IsRagdollActive()) { CEnvInfo EnvInfo; vector3 Pos = GetTransform().pos_component(); Pos.y += Height; float DistanceToGround; if (EnvQueryMgr->GetEnvInfoAt(Pos, EnvInfo, Height + 0.1f, GetUniqueID())) { DistanceToGround = Pos.y - Height - EnvInfo.WorldHeight; GroundMtl = EnvInfo.Material; } else { DistanceToGround = FLT_MAX; GroundMtl = InvalidMaterial; } CRigidBody* pMasterBody = Composite->GetMasterBody(); bool BodyIsEnabled = IsEnabled(); vector3 AngularVel = pMasterBody->GetAngularVelocity(); vector3 LinearVel = pMasterBody->GetLinearVelocity(); vector3 DesiredLVelChange = DesiredLinearVel - LinearVel; if (DistanceToGround <= 0.f) { // No torques now, angular velocity changes by impulse immediately to desired value bool Actuated = DesiredAngularVel != AngularVel.y; if (Actuated) { if (!BodyIsEnabled) SetEnabled(true); pMasterBody->SetAngularVelocity(vector3(0.f, DesiredAngularVel, 0.f)); } if (!DesiredLVelChange.isequal(vector3::Zero, 0.0001f)) { if (!Actuated) { Actuated = true; SetEnabled(true); } // Vertical movement for non-flying actors is impulse (jump). // Since speed if already clamped to actor caps, we save vertical desired velocity as is. // Spring force pushes us from below the ground. //!!!!!!!!!!!!!!! //!!!calc correct impulse for the spring! //!!!!!!!!!!!!!!! float VerticalDesVelChange = DesiredLVelChange.y - (50.0f * DistanceToGround); float Mass = pMasterBody->GetMass(); //!!!remove calcs for Y, it is zero (optimization)! dVector3 ODEForce; dWorldImpulseToForce(Level->GetODEWorldID(), dReal(Level->GetStepSize()), DesiredLVelChange.x * Mass, 0.f, DesiredLVelChange.z * Mass, ODEForce); float SqForceMagnitude = (float)dCalcVectorLengthSquare3(ODEForce); if (SqForceMagnitude > 0.f) { float MaxForceMagnitude = Mass * MaxHorizAccel; float SqMaxForceMagnitude = MaxForceMagnitude * MaxForceMagnitude; if (SqForceMagnitude > SqMaxForceMagnitude) dScaleVector3(ODEForce, MaxForceMagnitude / n_sqrt(SqForceMagnitude)); dBodyAddForce(pMasterBody->GetODEBodyID(), ODEForce[0], ODEForce[1], ODEForce[2]); } if (VerticalDesVelChange != 0.f) { dWorldImpulseToForce(Level->GetODEWorldID(), dReal(Level->GetStepSize()), 0.f, VerticalDesVelChange * Mass, 0.f, ODEForce); dBodyAddForce(pMasterBody->GetODEBodyID(), ODEForce[0], ODEForce[1], ODEForce[2]); } } if (BodyIsEnabled && !Actuated && DistanceToGround > -0.002f) { const float FreezeThreshold = 0.00001f; //???use TINY? bool AVelIsAlmostZero = n_fabs(AngularVel.y) < FreezeThreshold; bool LVelIsAlmostZero = n_fabs(LinearVel.x) * (float)Level->GetStepSize() < FreezeThreshold && n_fabs(LinearVel.z) * (float)Level->GetStepSize() < FreezeThreshold; if (AVelIsAlmostZero) pMasterBody->SetAngularVelocity(vector3::Zero); if (LVelIsAlmostZero) pMasterBody->SetLinearVelocity(vector3::Zero); if (AVelIsAlmostZero && LVelIsAlmostZero) SetEnabled(false); } } //???!!!else (when falling) apply damping?! } // NOTE: do NOT call the parent class, we don't need any damping }
vector3 vector3::cross(vector3 t)//可能有叉乘出的方向问题 { return vector3(y*t.z-z*t.y,z*t.x-x*t.z,x*t.y-y*t.x); }
void AppClass::ProcessKeyboard(void) { bool bModifier = false; float fSpeed = 0.01f; #pragma region ON_KEY_PRESS_RELEASE static bool bLastF1 = false, bLastF2 = false, bLastF3 = false, bLastF4 = false, bLastF5 = false, bLastF6 = false, bLastF7 = false, bLastF8 = false, bLastF9 = false, bLastF10 = false, bLastEscape = false, bLastF = false; #define ON_KEY_PRESS_RELEASE(key, pressed_action, released_action){ \ bool pressed = sf::Keyboard::isKeyPressed(sf::Keyboard::key); \ if(pressed){ \ if(!bLast##key) pressed_action;}/*Just pressed? */\ else if(bLast##key) released_action;/*Just released?*/\ bLast##key = pressed; } //remember the state #pragma endregion #pragma region Modifiers if(sf::Keyboard::isKeyPressed(sf::Keyboard::LShift) || sf::Keyboard::isKeyPressed(sf::Keyboard::RShift)) bModifier = true; #pragma endregion #pragma region Camera Positioning if(bModifier) fSpeed *= 10.0f; if (sf::Keyboard::isKeyPressed(sf::Keyboard::W)) { m_pCameraMngr->MoveForward(fSpeed); CameraManager->MoveForward(fSpeed); } if (sf::Keyboard::isKeyPressed(sf::Keyboard::S)) { m_pCameraMngr->MoveForward(-fSpeed); CameraManager->MoveForward(-fSpeed); } if (sf::Keyboard::isKeyPressed(sf::Keyboard::A)) { m_pCameraMngr->MoveSideways(-fSpeed); CameraManager->MoveHorizontal(-fSpeed); } if (sf::Keyboard::isKeyPressed(sf::Keyboard::D)) { m_pCameraMngr->MoveSideways(fSpeed); CameraManager->MoveHorizontal(fSpeed); } if (sf::Keyboard::isKeyPressed(sf::Keyboard::Q)) { m_pCameraMngr->MoveVertical(-fSpeed); CameraManager->MoveVertical(fSpeed); } if (sf::Keyboard::isKeyPressed(sf::Keyboard::E)) { m_pCameraMngr->MoveVertical(fSpeed); CameraManager->MoveVertical(-fSpeed); } if (sf::Keyboard::isKeyPressed(sf::Keyboard::X)) { CameraManager->ChangePitch(fSpeed); } if (sf::Keyboard::isKeyPressed(sf::Keyboard::Z)) { CameraManager->ChangeRoll(fSpeed); } if (sf::Keyboard::isKeyPressed(sf::Keyboard::Y)) { CameraManager->ChangeYaw(fSpeed); } #pragma endregion #pragma region Model Positioning if (sf::Keyboard::isKeyPressed(sf::Keyboard::X)) { if (!bModifier) m_v3Rotation += vector3( 1.0f, 0.0f, 0.0f); else m_v3Rotation += vector3(-1.0f, 0.0f, 0.0f); } if (sf::Keyboard::isKeyPressed(sf::Keyboard::Y)) { if (!bModifier) m_v3Rotation += vector3( 0.0f, 1.0f, 0.0f); else m_v3Rotation += vector3( 0.0f,-1.0f, 0.0f); } if (sf::Keyboard::isKeyPressed(sf::Keyboard::Z)) { if (!bModifier) m_v3Rotation += vector3(0.0f, 0.0f, 1.0f); else m_v3Rotation += vector3(0.0f, 0.0f,-1.0f); } if (sf::Keyboard::isKeyPressed(sf::Keyboard::R)) { m_v3Rotation = vector3(0.0f, 0.0f, 0.0f); } #pragma endregion #pragma region Other Actions ON_KEY_PRESS_RELEASE(Escape, NULL, PostMessage(m_pWindow->GetHandler(), WM_QUIT, NULL, NULL)); ON_KEY_PRESS_RELEASE(F1, NULL, m_pCameraMngr->SetCameraMode(CAMPERSP)); ON_KEY_PRESS_RELEASE(F2, NULL, m_pCameraMngr->SetCameraMode(CAMROTHOZ)); ON_KEY_PRESS_RELEASE(F3, NULL, m_pCameraMngr->SetCameraMode(CAMROTHOY)); ON_KEY_PRESS_RELEASE(F4, NULL, m_pCameraMngr->SetCameraMode(CAMROTHOX)); static bool bFPSControll = false; ON_KEY_PRESS_RELEASE(F, bFPSControll = !bFPSControll, m_pCameraMngr->SetFPS(bFPSControll)); #pragma endregion }
void bigTree::subdivideTree(MeshManagerSingleton* m_pMeshMngr, std::vector<BoundingObjectClass*> objectsList) { //Recursively divides the space in the world //Might as well check for collisions here, too //They only collide if they are in the same box for(std::size_t i = 0; i < objectsList.size(); i++){ if (objectsList[i]->IsColliding(*octBO)) { objectsInside.push_back(objectsList[i]); } } if (objectsInside.size() == maxObjects) { isLeaf = true; } else if (objectsInside.size() > maxObjects) { if (treeLevel < maxLevels && isLeaf == false) { vector3 childCentroid; float childSize = octSize/4.0f; //I believe collision calls would be made in here? for (int i = 0; i < 8; i++) { childCentroid = centroid; // Front // --------- // | 3 | 2 | // --------- // | 0 | 1 | // --------- if(i == 0){ childCentroid += vector3(-childSize, -childSize, childSize); } else if(i == 1){ childCentroid += vector3(childSize, -childSize, childSize); } else if(i == 2){ childCentroid += vector3(childSize, childSize, childSize); } else if(i == 3){ childCentroid += vector3(-childSize, childSize, childSize); } // Back // --------- // | 7 | 6 | // --------- // | 4 | 5 | // --------- else if(i == 4){ childCentroid += vector3(-childSize, -childSize, -childSize); } else if(i == 5){ childCentroid += vector3(childSize, -childSize, -childSize); } else if(i == 6){ childCentroid += vector3(childSize, childSize, -childSize); } else if(i == 7){ childCentroid += vector3(-childSize, childSize, -childSize); } children[i] = new bigTree(m_pMeshMngr, objectsInside, treeLevel + 1, octID + i, childCentroid, childSize * 2.0f); } } } }
GLuint createSpherePositions() { int nfloats = sphereAttributeCount(n)*3; // number of floats in the buffer int bufferSize = nfloats*sizeof(float); positions = (float*) malloc(bufferSize); float* p = positions; GLuint spherePositionsId; // // we refine each side of an octahedron // cf http://paulbourke.net/miscellaneous/sphere_cylinder/ // refine(0, triangle(vector3(0.0f, 1.0f, 0.0f), vector3(0.0f, 0.0f, 1.0f), vector3(1.0f, 0.0f, 0.0f)), &p); refine(0, triangle(vector3(0.0f, 1.0f, 0.0f), vector3(1.0f, 0.0f, 0.0f), vector3(0.0f, 0.0f, -1.0f)), &p); refine(0, triangle(vector3(0.0f, 1.0f, 0.0f), vector3(0.0f, 0.0f, -1.0f), vector3(-1.0f, 0.0f, 0.0f)), &p); refine(0, triangle(vector3(0.0f, 1.0f, 0.0f), vector3(-1.0f, 0.0f, 0.0f), vector3(0.0f, 0.0f, 1.0f)), &p); refine(0, triangle(vector3(0.0f, -1.0f, 0.0f), vector3(1.0f, 0.0f, 0.0f), vector3(0.0f, 0.0f, 1.0f)), &p); refine(0, triangle(vector3(0.0f, -1.0f, 0.0f), vector3(0.0f, 0.0f, 1.0f), vector3(-1.0f, 0.0f, 0.0f)), &p); refine(0, triangle(vector3(0.0f, -1.0f, 0.0f), vector3(-1.0f, 0.0f, 0.0f), vector3(0.0f, 0.0f, -1.0f)), &p); refine(0, triangle(vector3(0.0f, -1.0f, 0.0f), vector3(0.0f, 0.0f, -1.0f), vector3(1.0f, 0.0f, 0.0f)), &p); glGenBuffers(1, &spherePositionsId); glBindBuffer(GL_ARRAY_BUFFER, spherePositionsId); glBufferData(GL_ARRAY_BUFFER, nfloats*sizeof(float), positions, GL_STATIC_DRAW); //free(positions); return spherePositionsId; }
void bigTree::Render(MeshManagerSingleton* m_pMeshMngr) { m_pMeshMngr->AddCubeToQueue(glm::translate(centroid) * glm::scale(vector3(octSize, octSize, octSize)), MERED, MERENDER::WIRE); }
vector3 midPoint(vector3 p1, vector3 p2) { return vector3((p1.x + p2.x) / 2, (p1.y + p2.y) / 2, (p1.z + p2.z) / 2); }
void bigTree::createTree(MeshManagerSingleton* m_pMeshMngr, std::vector<BoundingObjectClass*> objectsList, std::vector<float> objectSizes) { vector3 minPos; vector3 maxPos; minPos = objectsList[0]->GetCentroidGlobal() - objectSizes[0]; maxPos = objectsList[0]->GetCentroidGlobal() + objectSizes[0]; for(std::size_t i = 0; i < objectsList.size(); i++){ if (minPos.x > objectsList[i]->GetCentroidGlobal().x - objectSizes[i]){ minPos.x = objectsList[i]->GetCentroidGlobal().x - objectSizes[i]; } else if (maxPos.x < objectsList[i]->GetCentroidGlobal().x + objectSizes[i]){ maxPos.x = objectsList[i]->GetCentroidGlobal().x + objectSizes[i]; } if (minPos.y > objectsList[i]->GetCentroidGlobal().y - objectSizes[i]){ minPos.y = objectsList[i]->GetCentroidGlobal().y - objectSizes[i]; } else if (maxPos.y < objectsList[i]->GetCentroidGlobal().y + objectSizes[i]){ maxPos.y = objectsList[i]->GetCentroidGlobal().y + objectSizes[i]; } if (minPos.z > objectsList[i]->GetCentroidGlobal().z - objectSizes[i]){ minPos.z = objectsList[i]->GetCentroidGlobal().z - objectSizes[i]; } else if (maxPos.z < objectsList[i]->GetCentroidGlobal().z + objectSizes[i]){ maxPos.z = objectsList[i]->GetCentroidGlobal().z + objectSizes[i]; } } centroid = (minPos + maxPos) / 2.0f; if (octSize < glm::distance(vector3(minPos.x, 0, 0), vector3(maxPos.x, 0, 0))){ octSize = glm::distance(vector3(minPos.x, 0, 0), vector3(maxPos.x, 0, 0)); } if (octSize < glm::distance(vector3(minPos.y, 0, 0), vector3(maxPos.y, 0, 0))){ octSize = glm::distance(vector3(minPos.y, 0, 0), vector3(maxPos.y, 0, 0)); } if (octSize < glm::distance(vector3(minPos.z, 0, 0), vector3(maxPos.z, 0, 0))){ octSize = glm::distance(vector3(minPos.z, 0, 0), vector3(maxPos.z, 0, 0)); } }
void AppClass::Update(void) { //Update the system's time m_pSystem->UpdateTime(); //Update the mesh manager's time without updating for collision detection m_pMeshMngr->Update(); //First person camera movement if (m_bFPC == true) CameraRotation(); //Call the arcball method ArcBall(); //Lets us know how much time has passed since the last call double fTimeSpan = m_pSystem->LapClock(); //cumulative time static double fRunTime = 0.0f; fRunTime += fTimeSpan; static int nIndex = 0; if (fRunTime > fDuration) { fRunTime = 0.0f; nIndex++; if (nIndex == static_cast<int>(m_lPositions.size())) { nIndex = 0; } } vector3 v3Vector1; vector3 v3Vector2; if (nIndex >= static_cast<int>(m_lPositions.size()) - 1) { v3Vector1 = m_lPositions[static_cast<int>(m_lPositions.size()) - 1]; v3Vector2 = m_lPositions[0]; } else { v3Vector1 = m_lPositions[nIndex]; v3Vector2 = m_lPositions[nIndex + 1]; } float fPercent = MapValue(static_cast<float>(fRunTime), 0.0f, fDuration, 0.0f, 1.0f); vector3 v3Position = glm::lerp(v3Vector1, v3Vector2, fPercent); m_pMeshMngr->SetModelMatrix(glm::translate(v3Position), "WallEye"); for (int i = 0; i < static_cast<int>(m_lPositions.size()); i++) { m_pMeshMngr->AddSphereToRenderList(glm::translate(m_lPositions[i]) * glm::scale(vector3(0.1f)), RERED, SOLID); } //Adds all loaded instance to the render list m_pMeshMngr->AddInstanceToRenderList("ALL"); //Indicate the FPS int nFPS = m_pSystem->GetFPS(); //print info into the console printf("\rfTimeSpan: %.3f, fRunSpan: %.3f, fDuration: %.3f ", fTimeSpan, fRunTime, fDuration); //Print info on the screen m_pMeshMngr->PrintLine(m_pSystem->GetAppName(), REYELLOW); m_pMeshMngr->Print("nIndex: "); m_pMeshMngr->PrintLine(std::to_string(nIndex)); m_pMeshMngr->Print("fTimeSpan: "); m_pMeshMngr->PrintLine(std::to_string(fTimeSpan)); m_pMeshMngr->Print("fRunSpan: "); m_pMeshMngr->PrintLine(std::to_string(fRunTime)); m_pMeshMngr->Print("fDuration: "); m_pMeshMngr->PrintLine(std::to_string(fDuration)); m_pMeshMngr->Print("FPS:"); m_pMeshMngr->Print(std::to_string(nFPS), RERED); }
matrix4 MyCameraSingleton::GetCameraPlane(void) { SystemSingleton* pSystem = SystemSingleton::GetInstance(); float fSize = pSystem->GetWindowWidth() / static_cast<float>(pSystem->GetWindowHeight()); return GetCameraSpaceAdjusted() * glm::translate(vector3(0.0f, 0.0f, -1.2085f)) * glm::scale(vector3(fSize, 1.0f, 0.0f)); }