void BoxPrimitive::drawBox() { ManualObject* manualObject = getManualObject(); manualObject->clear(); std::vector<Vector3> corners; corners.reserve(8); Vector3 vmin = mSize.getMinimum(); Vector3 vmax = mSize.getMaximum(); manualObject->begin(mMaterialName); manualObject->position(vmin); // 0 manualObject->position(Vector3(vmax.x, vmin.y, vmin.z)); // 1 manualObject->position(Vector3(vmax.x, vmax.y, vmin.z)); // 2 manualObject->position(Vector3(vmin.x, vmax.y, vmin.z)); // 3 manualObject->position(Vector3(vmax.x, vmin.y, vmax.z)); // 4 manualObject->position(Vector3(vmin.x, vmin.y, vmax.z)); // 5 manualObject->position(Vector3(vmin.x, vmax.y, vmax.z)); // 6 manualObject->position(vmax); // 7 manualObject->quad(0, 3, 2, 1); manualObject->quad(0, 5, 6, 3); manualObject->quad(0, 1, 4, 5); manualObject->quad(7, 2, 3, 6); manualObject->quad(7, 4, 1, 2); manualObject->quad(7, 6, 5, 4); manualObject->end(); }
//------------------------------------------------------------------------------------- void HelloOGRE::createScene(void) { using namespace Ogre; Ogre::Entity* ogreHead = mSceneMgr->createEntity("Head", "7.mesh"); //Ogre::Entity* cube = mSceneMgr->createEntity("cube","abc.mesh"); Ogre::SceneNode* headNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("Head"); headNode->attachObject(ogreHead); ManualObject * axis = mSceneMgr->createManualObject("Axis"); axis->begin("line",Ogre::RenderOperation::OperationType::OT_LINE_LIST); axis->position(0.0f,0.0f,0.0f); axis->position(20.0f,0.0f,0.0f); axis->end(); headNode->attachObject(axis); // Set ambient light mSceneMgr->setAmbientLight(Ogre::ColourValue(1.0,0.5, 0.0)); mSceneMgr->setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_ADDITIVE); mSceneMgr->setSkyDome(true,"Examples/Rockwall"); //mSceneMgr->setSkyPlane(true,"Example/" // Create a light Ogre::Light* l = mSceneMgr->createLight("MainLight"); l->setDiffuseColour(0.0f,1.0f,0.0f); l->setPosition(20,80,50); l->setDirection(0.0,0.0,0.0); }
// util //--------------------------------------------------------------------------------------------------------------- ManualObject* App::Create2D(const String& mat, Real s, bool dyn) { ManualObject* m = mSceneMgr->createManualObject(); m->setDynamic(dyn); m->setUseIdentityProjection(true); m->setUseIdentityView(true); m->setCastShadows(false); m->estimateVertexCount(4); m->begin(mat, RenderOperation::OT_TRIANGLE_STRIP); m->position(-s,-s*asp, 0); m->textureCoord(0, 1); m->position( s,-s*asp, 0); m->textureCoord(1, 1); m->position(-s, s*asp, 0); m->textureCoord(0, 0); m->position( s, s*asp, 0); m->textureCoord(1, 0); m->end(); //TODO:replace OT_TRIANGLE_FAN with a more friendly version for D3D11 as it is not supported /* m->estimateVertexCount(6); m->begin(mat, RenderOperation::OT_TRIANGLE_LIST); m->position(-s,-s*asp, 0); m->textureCoord(0, 1); m->position( s,-s*asp, 0); m->textureCoord(1, 1); m->position( s, s*asp, 0); m->textureCoord(1, 0); m->position(-s, s*asp, 0); m->textureCoord(0, 0); m->position(-s,-s*asp, 0); m->textureCoord(0, 1); m->position( s, s*asp, 0); m->textureCoord(1, 0); m->end(); */ AxisAlignedBox aabInf; aabInf.setInfinite(); m->setBoundingBox(aabInf); // always visible m->setRenderQueueGroup(RQG_Hud2); return m; }
// utility - create VDrift model in Ogre //------------------------------------------------------------------------------------------------------- ManualObject* App::CreateModel(SceneManager* sceneMgr, const String& mat, class VERTEXARRAY* a, Vector3 vPofs, bool flip, bool track, const String& name) { int verts = a->vertices.size(); if (verts == 0) return NULL; int tcs = a->texcoords[0].size(); //- int norms = a->normals.size(); int faces = a->faces.size(); // norms = verts, verts % 3 == 0 ManualObject* m; if (name == "") m = sceneMgr->createManualObject(); else m = sceneMgr->createManualObject(name); m->begin(mat, RenderOperation::OT_TRIANGLE_LIST); int t = 0; if (track) { for (int v = 0; v < verts; v += 3) { m->position(a->vertices[v+0], a->vertices[v+2], -a->vertices[v+1]); if (norms) m->normal( a->normals [v+0], a->normals [v+2], -a->normals [v+1]); if (t < tcs) { m->textureCoord(a->texcoords[0][t], a->texcoords[0][t+1]); t += 2; } } for (int f = 0; f < faces; ++f) m->index(a->faces[f]); }else if (flip) { for (int v = 0; v < verts; v += 3) { m->position(a->vertices[v], a->vertices[v+1], a->vertices[v+2]); if (norms) m->normal( a->normals [v], a->normals [v+1], a->normals [v+2]); if (t < tcs) { m->textureCoord(a->texcoords[0][t], a->texcoords[0][t+1]); t += 2; } } for (int f = 0; f < faces; f += 3) { m->index(a->faces[f+2]); m->index(a->faces[f+1]); m->index(a->faces[f]); } }else { for (int v = 0; v < verts; v += 3) { m->position(-a->vertices[v+1]+vPofs.x, -a->vertices[v+2]+vPofs.y, a->vertices[v]+vPofs.z); if (norms) m->normal( -a->normals [v+1], -a->normals [v+2], a->normals [v]); if (t < tcs) { m->textureCoord(a->texcoords[0][t], a->texcoords[0][t+1]); t += 2; } } for (int f = 0; f < faces; f += 3) { m->index(a->faces[f+2]); m->index(a->faces[f+1]); m->index(a->faces[f]); } } m->end(); return m; }
void HelloOgre::createManual(){ Ogre::SceneManager* mSceneMgr= OgreApp::I()->getSceneManager(); #if 1 ManualObject* manual = mSceneMgr->createManualObject("manual"); // specify the material (by name) and rendering type manual->begin("BaseWhiteNoLighting", RenderOperation::OT_LINE_LIST); // manual->begin("BaseWhiteNoLighting", RenderOperation::OT_TRIANGLE_STRIP); // define start and end point manual->position(-100, -100, -100 ); manual->position(100, 100, 100 ); manual->colour( 1.0f, 1.0f, 1.0f, 1.0f ); // tell Ogre, your definition has finished manual->end(); // add ManualObject to the RootSceneNode (so it will be visible) mSceneMgr->getRootSceneNode()->attachObject(manual); #endif #if 1 // Create a manual object for 2D manual = mSceneMgr->createManualObject("manual2"); // Use identity view/projection matrices manual->setUseIdentityProjection(true); manual->setUseIdentityView(true); manual->begin("BaseWhiteNoLighting", RenderOperation::OT_LINE_STRIP); manual->position(-0.2, -0.2, 0.0); manual->position( 0.2, -0.2, 0.0); manual->position( 0.2, 0.2, 0.0); manual->position(-0.2, 0.2, 0.0); manual->index(0); manual->index(1); manual->index(2); manual->index(3); manual->index(0); manual->end(); // Use infinite AAB to always stay visible AxisAlignedBox aabInf; aabInf.setInfinite(); manual->setBoundingBox(aabInf); // Render just before overlays manual->setRenderQueueGroup(RENDER_QUEUE_OVERLAY - 1); // Attach to scene mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(manual); #endif }
ManualObject* SnowTerrain::createDebugNormals(Ogre::SceneManager* mSceneMgr) { ManualObject* manual = mSceneMgr->createManualObject("NormalsDebug"); float *heights = getTerrainHeightData(); Vector4 *normals = getTerrainNormalData(); manual->begin("BaseWhiteNoLighting", RenderOperation::OT_LINE_LIST); int terrainSize = getTerrain()->getSize(); int terrainWorldSize = getTerrain()->getWorldSize(); for(int z = 0; z < terrainSize; ++z) { for(int x = 0; x < terrainSize; ++x) { int i = ((terrainSize)*(terrainSize) ) - (z+1)*terrainSize + (x+1); Vector3 n = Vector3(normals[i].x, normals[i].y, normals[i].z); float h = heights[i]; Real factor = (Real)terrainSize - 1.0f; Real invFactor = 1.0f / factor; float mScale = terrainWorldSize / (Real)(terrainSize); Real mBase = -terrainWorldSize * 0.5; Vector3 mPos = Ogre::Vector3(terrainWorldSize * 0.5, 0, terrainWorldSize * 0.5); Vector3 worldPos; worldPos.x = x * mScale + mBase + mPos.x; worldPos.y = h + mPos.y; worldPos.z = z * mScale + mBase + mPos.z; // convert back to "normal map" colors (0/1 float instead of -1/1 float, also rgb=>xzy) manual->colour((n.x + 1)*0.5, (n.z + 1)*0.5, (n.y + 1)*0.5); // draw line manual->position(worldPos); manual->position(worldPos + 3*n); //manual->index(i); //manual->index(1); } } manual->end(); //OGRE_FREE(normals); return manual; }
void OgreDisplay::createCylinderMesh(std::string name, std::string material) { //make a cube mesh ManualObject* cylinderMesh = sceneMgr->createManualObject("cylinder"); cylinderMesh->begin(material, RenderOperation::OT_TRIANGLE_LIST); for(double i = 0.0; i < Math::PI * 2; i += Math::PI / 5) { cylinderMesh->position(cos(i), 1, sin(i)); cylinderMesh->textureCoord(i / (Math::PI * 2), 1.0); Ogre::Vector3 myNormal(cos(i), 0, sin(i)); myNormal.normalise(); cylinderMesh->normal(myNormal); } for(double i = 0.0; i < Math::PI * 2; i += Math::PI / 5) { cylinderMesh->position(cos(i), -1, sin(i)); cylinderMesh->textureCoord(i / (Math::PI * 2), 0.0); Ogre::Vector3 myNormal(cos(i), 0, sin(i)); myNormal.normalise(); cylinderMesh->normal(myNormal); } for(int i = 0; i < 10; i++) { cylinderMesh->triangle(i, (i+1) % 10, ((i + 10) % 20)); } for(int i = 10; i < 20; i++) { cylinderMesh->triangle(i, (i+1) % 10, (i+1) % 10 + 10); } cylinderMesh->position(0, 1, 0); cylinderMesh->textureCoord(0.5, 0.5); cylinderMesh->position(0, -1, 0); cylinderMesh->textureCoord(0.5, 0.5); for(int i = 0; i < 10; i++) { cylinderMesh->triangle(20, (i+1) % 10, i); cylinderMesh->triangle(21, ((i+10) % 10) + 10, ((i+ 11) % 10) + 10); } cylinderMesh->end(); cylinderMesh->convertToMesh(name); }
// 创建网格 ManualObject* AxisGridPlugin::createGrid(float width , float height , float interval) { // 创建网格对象 static size_t s_index = 0; ManualObject *gridObject = m_worldEditor->getDisplaySystem()->getMainSceneMgr()->createManualObject( "GridObject" + StringConverter::toString(s_index)); // 用黑色画中间线 gridObject->begin(m_worldEditor->getDisplaySystem()->getColorMaterial(ColourValue::Black) , RenderOperation::OT_LINE_LIST); gridObject->position(-width , 0 , 0); gridObject->position(width , 0 , 0); gridObject->position(0 , 0 , -height); gridObject->position(0 , 0 , height); gridObject->end(); // 画普通线 gridObject->begin(m_worldEditor->getDisplaySystem()->getColorMaterial(ColourValue(0.37,0.37,0.37)) , RenderOperation::OT_LINE_LIST); for(float x = -width ; x <= width ; x += interval) { if(abs(x) > 0.0001f) { gridObject->position(x , 0 , -height); gridObject->position(x , 0 , height); } } for(float y = -height ; y <= height ; y += interval) { if(abs(y) > 0.0001f) { gridObject->position(-width , 0 , y); gridObject->position(width , 0 , y); } } gridObject->end(); return gridObject; }
Ogre::SceneNode* Terminal::createTexturedRect(std::string object_name, std::string texture_name, float left, float top, float right, float bottom) { MaterialPtr material = MaterialManager::getSingleton().create(object_name,Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); material->getTechnique(0)->getPass(0)->createTextureUnitState(texture_name); material->getTechnique(0)->getPass(0)->setDepthCheckEnabled(false); material->getTechnique(0)->getPass(0)->setDepthWriteEnabled(true); material->getTechnique(0)->getPass(0)->setLightingEnabled(false); // Ogre::Rectangle2D* rect = new Ogre::Rectangle2D(true); ManualObject* manual = Entropy::getSingletonPtr()->mSceneMgr->createManualObject(object_name); manual->setUseIdentityProjection(true); manual->setUseIdentityView(true); manual->begin(object_name, RenderOperation::OT_TRIANGLE_STRIP); manual->position(left, bottom, 0.0); manual->position(left, top, 0.0); manual->position(right, bottom, 0.0); manual->position(right, top, 0.0); manual->index(0); manual->index(1); manual->index(2); manual->index(3); manual->end(); // rect->setCorners(left,top,right,bottom); // rect->setMaterial(object_name); manual->setRenderQueueGroup(RENDER_QUEUE_OVERLAY); Ogre::AxisAlignedBox aabInf; aabInf.setInfinite(); manual->setBoundingBox(aabInf); Ogre::SceneNode* rect_node = Entropy::getSingletonPtr()->mSceneMgr->getRootSceneNode()->createChildSceneNode(object_name); rect_node->attachObject(manual); // rect->setVisible(false); // rect_node->setPosition(0,0,0); return rect_node; }
void pathDrawerState::dibujaLinea(size_t idFrom, size_t idTo) { ManualObject* manual = _sceneMgr->createManualObject("line_" + to_string(idFrom)); manual->begin("BaseWhiteNoLighting", RenderOperation::OT_LINE_LIST); Vector3 aux(vMarcas[idFrom]._nodoMarca->getPosition()); aux.y = _planeRoadNode->getPosition().y + 1; manual->position(aux); //start aux = vMarcas[idTo]._nodoMarca->getPosition(); aux.y = _planeRoadNode->getPosition().y + 1; manual->position(aux); //end manual->end(); _sceneMgr->getRootSceneNode()->attachObject(manual); cout << "nombre entity linea: " << manual->getName() << endl; }
void App::CreateRacingLine() { //void ROADPATCH::AddRacinglineScenenode(SCENENODE * node, ROADPATCH * nextpatch, ManualObject* m = mSceneMgr->createManualObject(); m->begin("track/Racingline", RenderOperation::OT_TRIANGLE_LIST); int ii = 0; const std::list <ROADSTRIP>& roads = pGame->track.GetRoadList(); for (std::list <ROADSTRIP>::const_iterator it = roads.begin(); it != roads.end(); ++it) { const std::list <ROADPATCH>& pats = (*it).GetPatchList(); for (std::list <ROADPATCH>::const_iterator i = pats.begin(); i != pats.end(); ++i) { const VERTEXARRAY* a = &((*i).racingline_vertexarray); if (!a) continue; int verts = a->vertices.size(); if (verts == 0) continue; int faces = a->faces.size(); for (int v = 0; v < verts; v += 3) m->position(a->vertices[v+0], a->vertices[v+2], -a->vertices[v+1]); for (int f = 0; f < faces; ++f) m->index(ii + a->faces[f]); ii += verts/3; } } m->setCastShadows(false); m->end(); hud->ndLine = mSceneMgr->getRootSceneNode()->createChildSceneNode(); hud->ndLine->attachObject(m); //ndLine->setVisible(pSet->racingline); }
void MeshWithoutIndexDataTests::testCreateLineWithMaterial() { String matName = "lineMat"; MaterialPtr matPtr = MaterialManager::getSingleton().create(matName, "General"); Pass* pass = matPtr->getTechnique(0)->getPass(0); pass->setDiffuse(1.0, 0.1, 0.1, 0); ManualObject* line = OGRE_NEW ManualObject("line"); line->begin(matName, RenderOperation::OT_LINE_LIST); line->position(0, 50, 0); line->position(50, 100, 0); line->end(); String fileName = "lineWithMat.mesh"; MeshPtr lineMesh = line->convertToMesh(fileName); OGRE_DELETE line; CPPUNIT_ASSERT(lineMesh->getNumSubMeshes() == 1); CPPUNIT_ASSERT(lineMesh->getSubMesh(0)->indexData->indexCount == 0); RenderOperation rop; lineMesh->getSubMesh(0)->_getRenderOperation(rop); CPPUNIT_ASSERT(rop.useIndexes == false); CPPUNIT_ASSERT(lineMesh->getSubMesh(0)->vertexData->vertexCount == 2); MeshSerializer meshWriter; meshWriter.exportMesh(lineMesh.get(), fileName); MaterialSerializer matWriter; matWriter.exportMaterial( MaterialManager::getSingleton().getByName(matName), matName + ".material" ); mMeshMgr->remove( fileName ); ResourceGroupManager::getSingleton().addResourceLocation(".", "FileSystem"); MeshPtr loadedLine = mMeshMgr->load(fileName, "General"); remove(fileName.c_str()); remove((matName + ".material").c_str()); CPPUNIT_ASSERT(loadedLine->getNumSubMeshes() == 1); CPPUNIT_ASSERT(loadedLine->getSubMesh(0)->indexData->indexCount == 0); loadedLine->getSubMesh(0)->_getRenderOperation(rop); CPPUNIT_ASSERT(rop.useIndexes == false); CPPUNIT_ASSERT(lineMesh->getSubMesh(0)->vertexData->vertexCount == 2); mMeshMgr->remove( fileName ); }
//this makes the cube mesh used to represent a voxel. void OgreDisplay::createVoxelMesh() { ManualObject* manual = sceneMgr->createManualObject("voxel"); manual->begin("BaseWhite", RenderOperation::OT_TRIANGLE_LIST); manual->position(-0.5, -0.5, -0.5); //0 manual->position(-0.5, -0.5, 0.5); //1 manual->position(0.5, -0.5, 0.5); //2 manual->position(0.5, -0.5, -0.5); //3 manual->position(-0.5, 0.5, -0.5); //4 manual->position(-0.5, 0.5, 0.5); //5 manual->position(0.5, 0.5, 0.5); //6 manual->position(0.5, 0.5, -0.5); //7 manual->quad(0,1,2,3); manual->quad(4,5,6,7); manual->quad(0,1,4,5); manual->quad(2,3,6,7); manual->quad(1,2,5,6); manual->quad(0,3,4,7); manual->end(); manual->convertToMesh("voxel"); }
void VideoManager::createQuad(String name,String material_name,float left,float top,float right,float bottom) { ManualObject* model = OgreManager::getSingleton().getSceneManager()->createManualObject(name); model->begin(material_name); model->position(right,bottom,0); model->textureCoord(1,1); model->position(right,top ,0); model->textureCoord(1,0); model->position(left ,top ,0); model->textureCoord(0,0); model->position(left ,top ,0); model->textureCoord(0,0); model->position(right,bottom,0); model->textureCoord(1,1); model->position(left, bottom,0); model->textureCoord(0,1); model->end(); // make the model 2D model->setUseIdentityProjection(true); model->setUseIdentityView(true); // and atach it to the root node SceneNode* node = OgreManager::getSingleton().getSceneManager()->getRootSceneNode()->createChildSceneNode(); node->attachObject(model); }
void DebugDisplay::drawTriangle( Vector3 t0, Vector3 t1, Vector3 t2 ) { oht_assert_threadmodel(ThrMdl_Main); ManualObject * pManObj = _pSceneManager->createManualObject(); rollbackTransforms(t0); rollbackTransforms(t1); rollbackTransforms(t2); pManObj->begin(getCurrentMaterial(), RenderOperation::OT_TRIANGLE_LIST); pManObj->position(t0); pManObj->position(t1); pManObj->position(t2); pManObj->end(); _pScNode->attachObject(pManObj); }
void TutorialApplication::createScene(void) { m_SceneMgr->setAmbientLight(Ogre::ColourValue(0.7f, 0.7f, 0.7f)); // Render the bottom grid using lines Ogre::ManualObject *man = m_SceneMgr->createManualObject("grid"); man->begin("BaseWhiteNoLighting", Ogre::RenderOperation::OT_LINE_LIST); for (Real i = -GRID_SIZE + GRID_SPACING; i < GRID_SIZE; i += GRID_SPACING) { man->position(i, 0, -GRID_SIZE); man->position(i, 0, GRID_SIZE); man->position(-GRID_SIZE, 0, i); man->position(GRID_SIZE, 0, i); } man->end(); m_SceneMgr->getRootSceneNode()->attachObject(man); // Create the cursor plane ManualObject *plane = m_SceneMgr->createManualObject("basePlane"); plane->begin("BaseWhiteNoLighting", RenderOperation::OT_TRIANGLE_STRIP); plane->position(0, 0, 0); plane->position(0, 0, CURSOR_SIZE); plane->position(CURSOR_SIZE, 0, 0); plane->position(CURSOR_SIZE, 0, CURSOR_SIZE); plane->end(); m_cursorNode = m_SceneMgr->getRootSceneNode()->createChildSceneNode("cursorNode"); m_cursorNode->attachObject(plane); // Create all possible cones, so they can be shown later m_pointNode = m_SceneMgr->getRootSceneNode()->createChildSceneNode("coneBase"); for (Vector3 coneDir : CONE_CASES) { std::vector<Vector3> seenList; SceneNode *childNode = m_pointNode->createChildSceneNode(); m_coneNodes.push_back(childNode); createCones(nullptr, seenList, childNode, m_pointNode->getPosition(), coneDir); } assert (m_coneNodes.size() == CONE_CASES.size()); m_pointNode->setVisible(false, true); }
void MeshWithoutIndexDataTests::testCreateLineStrip() { ManualObject* lineStrip = new ManualObject("line"); lineStrip->begin("BaseWhiteNoLighting", RenderOperation::OT_LINE_STRIP); lineStrip->position(50, 100, 0); lineStrip->position(0, 50, 0); lineStrip->position(50, 50, 0); lineStrip->position(100, 100, 0); lineStrip->end(); String fileName = "lineStrip.mesh"; MeshPtr lineStripMesh = lineStrip->convertToMesh(fileName); delete lineStrip; CPPUNIT_ASSERT(lineStripMesh->getNumSubMeshes() == 1); CPPUNIT_ASSERT(lineStripMesh->getSubMesh(0)->indexData->indexCount == 0); RenderOperation rop; lineStripMesh->getSubMesh(0)->_getRenderOperation(rop); CPPUNIT_ASSERT(rop.useIndexes == false); CPPUNIT_ASSERT(lineStripMesh->getSubMesh(0)->vertexData->vertexCount == 4); MeshSerializer meshWriter; meshWriter.exportMesh(lineStripMesh.get(), fileName); mMeshMgr->remove( mMeshMgr->getByName(fileName) ); ResourceGroupManager::getSingleton().addResourceLocation(".", "FileSystem"); MeshPtr loadedLineStrip = mMeshMgr->load(fileName, "General"); remove(fileName.c_str()); CPPUNIT_ASSERT(loadedLineStrip->getNumSubMeshes() == 1); CPPUNIT_ASSERT(loadedLineStrip->getSubMesh(0)->indexData->indexCount == 0); loadedLineStrip->getSubMesh(0)->_getRenderOperation(rop); CPPUNIT_ASSERT(rop.useIndexes == false); CPPUNIT_ASSERT(loadedLineStrip->getSubMesh(0)->vertexData->vertexCount == 4); mMeshMgr->remove( mMeshMgr->getByName(fileName) ); }
void MeshWithoutIndexDataTests::testCreatePointList() { ManualObject* pointList = OGRE_NEW ManualObject("line"); pointList->begin("BaseWhiteNoLighting", RenderOperation::OT_POINT_LIST); pointList->position(50, 100, 0); pointList->position(0, 50, 0); pointList->position(50, 50, 0); pointList->position(100, 100, 0); pointList->end(); String fileName = "pointList.mesh"; MeshPtr pointListMesh = pointList->convertToMesh(fileName); OGRE_DELETE pointList; CPPUNIT_ASSERT(pointListMesh->getNumSubMeshes() == 1); CPPUNIT_ASSERT(pointListMesh->getSubMesh(0)->indexData->indexCount == 0); RenderOperation rop; pointListMesh->getSubMesh(0)->_getRenderOperation(rop); CPPUNIT_ASSERT(rop.useIndexes == false); CPPUNIT_ASSERT(pointListMesh->getSubMesh(0)->vertexData->vertexCount == 4); MeshSerializer meshWriter; meshWriter.exportMesh(pointListMesh.get(), fileName); mMeshMgr->remove( fileName ); ResourceGroupManager::getSingleton().addResourceLocation(".", "FileSystem"); MeshPtr loadedPointList = mMeshMgr->load(fileName, "General"); remove(fileName.c_str()); CPPUNIT_ASSERT(loadedPointList->getNumSubMeshes() == 1); CPPUNIT_ASSERT(loadedPointList->getSubMesh(0)->indexData->indexCount == 0); loadedPointList->getSubMesh(0)->_getRenderOperation(rop); CPPUNIT_ASSERT(rop.useIndexes == false); CPPUNIT_ASSERT(loadedPointList->getSubMesh(0)->vertexData->vertexCount == 4); mMeshMgr->remove( fileName ); }
void DebugDisplay::drawPoint( Vector3 p ) { oht_assert_threadmodel(ThrMdl_Main); ManualObject * pManObj = _pSceneManager->createManualObject(); rollbackTransforms(p); pManObj->begin(getCurrentMaterial(), RenderOperation::OT_POINT_LIST); pManObj->position(p); pManObj->end(); _pScNode->attachObject(pManObj); }
ManualObject* ShowNormalsGenerator::buildManualObject() const { if (mTriangleBuffer == NULL) OGRE_EXCEPT(Ogre::Exception::ERR_INVALID_STATE, "The input triangle buffer must not be null", "Procedural::ShowNormalsGenerator::buildManualObject()"); SceneManager* sceneMgr = Ogre::Root::getSingleton().getSceneManagerIterator().begin()->second; if (sceneMgr == NULL) OGRE_EXCEPT(Ogre::Exception::ERR_INVALID_STATE, "Scene Manager must be set in Root", "Procedural::ShowNormalsGenerator::buildManualObject()"); ManualObject* manual = sceneMgr->createManualObject(); manual->begin("BaseWhiteNoLighting", RenderOperation::OT_LINE_LIST); const std::vector<TriangleBuffer::Vertex>& vertices = mTriangleBuffer->getVertices(); for (std::vector<TriangleBuffer::Vertex>::const_iterator it = vertices.begin(); it!= vertices.end(); ++it) { manual->position(it->mPosition); manual->position(it->mPosition + it->mNormal * mSize); if (mVisualStyle == VS_ARROW) { Vector3 axis2 = it->mNormal.perpendicular(); Vector3 axis3 = it->mNormal.crossProduct(axis2); manual->position(it->mPosition + it->mNormal * mSize); manual->position(it->mPosition + (.8f * it->mNormal + .1f * axis2) * mSize); manual->position(it->mPosition + it->mNormal * mSize); manual->position(it->mPosition + .8f * (it->mNormal - .1f * axis2) * mSize); manual->position(it->mPosition + it->mNormal * mSize); manual->position(it->mPosition + .8f * ( it->mNormal + .1f * axis3)* mSize); manual->position(it->mPosition + it->mNormal * mSize); manual->position(it->mPosition + .8f * (it->mNormal - .1f * axis3)* mSize); } } manual->end(); return manual; }
// Sky Dome //------------------------------------------------------------------------------------- void CScene::CreateSkyDome(String sMater, Vector3 sc, float yaw) { ManualObject* m = app->mSceneMgr->createManualObject(); m->begin(sMater, RenderOperation::OT_TRIANGLE_LIST); // divisions- quality int ia = 32*2, ib = 24,iB = 24 +1/*below_*/, i=0; //int ia = 4, ib = 4, i=0; // angles, max float a,b; const float B = PI_d/2.f, A = 2.f*PI_d; float bb = B/ib, aa = A/ia; // add ia += 1; // up/dn y ) for (b = 0.f; b <= B+bb/*1*/*iB; b += bb) { float cb = sinf(b), sb = cosf(b); float y = sb; // circle xz o for (a = 0.f; a <= A; a += aa, ++i) { float x = cosf(a)*cb, z = sinf(a)*cb; m->position(x,y,z); m->textureCoord(a/A, b/B); if (a > 0.f && b > 0.f) // rect 2tri { m->index(i-1); m->index(i); m->index(i-ia); m->index(i-1); m->index(i-ia); m->index(i-ia-1); } } } m->end(); AxisAlignedBox aab; aab.setInfinite(); m->setBoundingBox(aab); // always visible m->setRenderQueueGroup(RQG_Sky); m->setCastShadows(false); #ifdef SR_EDITOR m->setVisibilityFlags(RV_Sky); // hide on minimap #endif app->ndSky = app->mSceneMgr->getRootSceneNode()->createChildSceneNode(); app->ndSky->attachObject(m); app->ndSky->setScale(sc); Quaternion q; q.FromAngleAxis(Degree(-yaw), Vector3::UNIT_Y); app->ndSky->setOrientation(q); }
ProceduralManualObject* createProceduralParticleSystem() { particleSystem = static_cast<ProceduralManualObject*> (mSceneMgr->createMovableObject("ParticleGSEntity", ProceduralManualObjectFactory::FACTORY_TYPE_NAME)); particleSystem->setMaterial("Ogre/ParticleGS/Display"); //Generate the geometry that will seed the particle system ManualObject* particleSystemSeed = mSceneMgr->createManualObject("ParticleSeed"); //This needs to be the initial launcher particle particleSystemSeed->begin("Ogre/ParticleGS/Display", RenderOperation::OT_POINT_LIST); particleSystemSeed->position(0,0,0); //Position particleSystemSeed->textureCoord(1); //Timer particleSystemSeed->textureCoord(0); //Type particleSystemSeed->textureCoord(0,0,0); //Velocity particleSystemSeed->end(); //Generate the RenderToBufferObject RenderToVertexBufferSharedPtr r2vbObject = HardwareBufferManager::getSingleton().createRenderToVertexBuffer(); r2vbObject->setRenderToBufferMaterialName("Ogre/ParticleGS/Generate"); //Apply the random texture TexturePtr randomTexture = RandomTools::generateRandomVelocityTexture(); r2vbObject->getRenderToBufferMaterial()->getTechnique(0)->getPass(0)-> getTextureUnitState("RandomTexture")->setTextureName( randomTexture->getName(), randomTexture->getTextureType()); r2vbObject->setOperationType(RenderOperation::OT_POINT_LIST); r2vbObject->setMaxVertexCount(16000); r2vbObject->setResetsEveryUpdate(false); VertexDeclaration* vertexDecl = r2vbObject->getVertexDeclaration(); size_t offset = 0; offset += vertexDecl->addElement(0, offset, VET_FLOAT3, VES_POSITION).getSize(); //Position offset += vertexDecl->addElement(0, offset, VET_FLOAT1, VES_TEXTURE_COORDINATES, 0).getSize(); //Timer offset += vertexDecl->addElement(0, offset, VET_FLOAT1, VES_TEXTURE_COORDINATES, 1).getSize(); //Type offset += vertexDecl->addElement(0, offset, VET_FLOAT3, VES_TEXTURE_COORDINATES, 2).getSize(); //Velocity //Bind the two together particleSystem->setRenderToVertexBuffer(r2vbObject); particleSystem->setManualObject(particleSystemSeed); //Set bounds AxisAlignedBox aabb; aabb.setMinimum(-100,-100,-100); aabb.setMaximum(100,100,100); particleSystem->setBoundingBox(aabb); return particleSystem; }
void MeshWithoutIndexDataTests::testEdgeList() { String fileName = "testEdgeList.mesh"; ManualObject* line = OGRE_NEW ManualObject("line"); line->begin("BaseWhiteNoLighting", RenderOperation::OT_LINE_LIST); line->position(0, 50, 0); line->position(50, 100, 0); line->end(); MeshPtr mesh = line->convertToMesh(fileName); OGRE_DELETE line; // whole mesh must not contain index data, for this test CPPUNIT_ASSERT(mesh->getNumSubMeshes() == 1); CPPUNIT_ASSERT(mesh->getSubMesh(0)->indexData->indexCount == 0); mesh->buildEdgeList(); MeshSerializer meshWriter; // if it does not crash here, test is passed meshWriter.exportMesh(mesh.get(), fileName); remove(fileName.c_str()); mMeshMgr->remove( fileName ); }
ManualObject* CHud::Create2D(const String& mat, SceneManager* sceneMgr, Real s, // scale pos bool dyn, bool clr, Real mul, Vector2 ofs, uint32 vis, uint8 rndQue, int cnt) { ManualObject* m = sceneMgr->createManualObject(); m->setDynamic(dyn); m->setUseIdentityProjection(true); m->setUseIdentityView(true); m->setCastShadows(false); m->estimateVertexCount(cnt * 4); m->begin(mat, cnt > 1 ? RenderOperation::OT_TRIANGLE_LIST : RenderOperation::OT_TRIANGLE_STRIP); const static Vector2 uv[4] = { Vector2(0.f,1.f),Vector2(1.f,1.f),Vector2(0.f,0.f),Vector2(1.f,0.f) }; for (int i=0; i < cnt; ++i) { m->position(-s,-s*asp, 0); m->textureCoord(uv[0]*mul + ofs); if (clr) m->colour(0,1,0); m->position( s,-s*asp, 0); m->textureCoord(uv[1]*mul + ofs); if (clr) m->colour(0,0,0); m->position(-s, s*asp, 0); m->textureCoord(uv[2]*mul + ofs); if (clr) m->colour(1,1,0); m->position( s, s*asp, 0); m->textureCoord(uv[3]*mul + ofs); if (clr) m->colour(1,0,0); } if (cnt > 1) for (int i=0; i < cnt; ++i) { int n = i*4; m->quad(n,n+1,n+3,n+2); } m->end(); AxisAlignedBox aabInf; aabInf.setInfinite(); m->setBoundingBox(aabInf); // always visible m->setVisibilityFlags(vis); m->setRenderQueueGroup(rndQue); //RQG_Hud2 return m; }
ManualObject *Debugging::createPathgridPoints(const ESM::Pathgrid *pathgrid) { ManualObject *result = mSceneMgr->createManualObject(); const float height = POINT_MESH_BASE * sqrtf(2); result->begin(PATHGRID_POINT_MATERIAL, RenderOperation::OT_TRIANGLE_STRIP); bool first = true; uint32 startIndex = 0; for(ESM::Pathgrid::PointList::const_iterator it = pathgrid->mPoints.begin(); it != pathgrid->mPoints.end(); it++, startIndex += 6) { Vector3 pointPos(it->mX, it->mY, it->mZ); if (!first) { // degenerate triangle from previous octahedron result->index(startIndex - 4); // 2nd point of previous octahedron result->index(startIndex); // start point of current octahedron } result->position(pointPos + Vector3(0, 0, height)); // 0 result->position(pointPos + Vector3(-POINT_MESH_BASE, -POINT_MESH_BASE, 0)); // 1 result->position(pointPos + Vector3(POINT_MESH_BASE, -POINT_MESH_BASE, 0)); // 2 result->position(pointPos + Vector3(POINT_MESH_BASE, POINT_MESH_BASE, 0)); // 3 result->position(pointPos + Vector3(-POINT_MESH_BASE, POINT_MESH_BASE, 0)); // 4 result->position(pointPos + Vector3(0, 0, -height)); // 5 result->index(startIndex + 0); result->index(startIndex + 1); result->index(startIndex + 2); result->index(startIndex + 5); result->index(startIndex + 3); result->index(startIndex + 4); // degenerates result->index(startIndex + 4); result->index(startIndex + 5); result->index(startIndex + 5); // end degenerates result->index(startIndex + 1); result->index(startIndex + 4); result->index(startIndex + 0); result->index(startIndex + 3); result->index(startIndex + 2); first = false; } result->end(); result->setVisibilityFlags (RV_Debug); return result; }
//--------------------------------------------------------------------- void PFile::addGroup( const Group &group, ManualObject &mo ,const String &sub_name, const String &material_base_name ,const Ogre::Bone *bone ) const { size_t material_index( 0 ); if( group.has_texture ) { material_index = group.texture_index + 1; } String material_name( material_base_name + "/" + Ogre::StringConverter::toString( material_index ) ); const uint16 bone_handle( bone->getHandle() ); const Ogre::Vector3 bone_position( getPosition( bone ) ); size_t index( 0 ); size_t vertex_count( group.num_polygons * 3 ); size_t index_count( vertex_count ); size_t polygon_end_index( group.polygon_start_index + group.num_polygons ); mo.begin( sub_name, material_name, vertex_count, index_count ); for( size_t p( group.polygon_start_index ); p < polygon_end_index; ++p ) { const PolygonDefinition& polygon( m_polygon_definitions[p] ); for( int i(3); i--; ) { uint32 v( group.vertex_start_index +polygon.vertex[i] ) ,n( 0 + polygon.normal[i] ) ,t( group.texture_coordinate_start_index +polygon.vertex[i] ); Ogre::Vector3 pos( m_vertices[ v ] ); mo.position((STATIC_ROTATION * (pos / HRCFile::kDownScaler)) + bone_position); mo.colour( m_vertex_colors[ v ] ); mo.normal( STATIC_ROTATION * m_normals[ n ] ); if( group.has_texture ) { mo.textureCoord(m_texture_coordinates[t]); } mo.bone( index, bone_handle ); mo.index( index++ ); } } mo.end(); }
Entity* MeshBuilder::generateWithManualObject(SceneManager *sceneManager, const String &name, const String &material) { ManualObject* manual = sceneManager->createManualObject(); manual->begin(material, RenderOperation::OT_TRIANGLE_LIST); for (VecVertex::const_iterator iter = mVertices.begin(); iter != mVertices.end(); ++iter) { manual->position(Vector3(iter->x, iter->y, iter->z)); manual->normal(Vector3(iter->nX, iter->nY, iter->nZ)); } for (VecIndices::const_iterator iter = mIndices.begin(); iter != mIndices.end(); ++iter) { manual->index(*iter); } manual->end(); StringUtil::StrStreamType meshName; meshName << name << "ManualObject"; MeshManager::getSingleton().remove(meshName.str()); manual->convertToMesh(meshName.str()); return sceneManager->createEntity(name, meshName.str()); }
ManualObject *Debugging::createPathgridLines(const ESM::Pathgrid *pathgrid) { ManualObject *result = mSceneMgr->createManualObject(); result->begin(PATHGRID_LINE_MATERIAL, RenderOperation::OT_LINE_LIST); for(ESM::Pathgrid::EdgeList::const_iterator it = pathgrid->mEdges.begin(); it != pathgrid->mEdges.end(); ++it) { const ESM::Pathgrid::Edge &edge = *it; const ESM::Pathgrid::Point &p1 = pathgrid->mPoints[edge.mV0], &p2 = pathgrid->mPoints[edge.mV1]; Vector3 direction = (Vector3(p2.mX, p2.mY, p2.mZ) - Vector3(p1.mX, p1.mY, p1.mZ)); Vector3 lineDisplacement = direction.crossProduct(Vector3::UNIT_Z).normalisedCopy(); lineDisplacement = lineDisplacement * POINT_MESH_BASE + Vector3(0, 0, 10); // move lines up a little, so they will be less covered by meshes/landscape result->position(Vector3(p1.mX, p1.mY, p1.mZ) + lineDisplacement); result->position(Vector3(p2.mX, p2.mY, p2.mZ) + lineDisplacement); } result->end(); result->setVisibilityFlags (RV_Debug); return result; }
///--------------------------------------------------------------------------------------------------------------- // Update HUD ///--------------------------------------------------------------------------------------------------------------- void CHud::Update(int carId, float time) { PROFILER.beginBlock("g.hud"); // update HUD elements for all cars that have a viewport (local or replay) //----------------------------------------------------------------------------------- int cnt = std::min(6/**/, (int)app->carModels.size()); // all cars int cntC = std::min(4/**/, cnt - (app->isGhost2nd && !app->bRplPlay ? 1 : 0)); // all vis plr int c; // gui viewport - done once for all if (carId == -1) for (c = 0; c < cntC; ++c) if (app->carModels[c]->eType == CarModel::CT_LOCAL) { // hud rpm,vel float vel=0.f, rpm=0.f, clutch=1.f; int gear=1; GetVals(c,&vel,&rpm,&clutch,&gear); // update all mini pos tri for (int i=0; i < cnt; ++i) UpdRot(c, i, vel, rpm); } /// all minimap car pos-es rot const static Real tc[4][2] = {{0,1}, {1,1}, {0,0}, {1,0}}; const float z = pSet->size_minipos; // tri size if (carId == -1 && moPos) { moPos->beginUpdate(0); const int plr = app->mSplitMgr->mNumViewports; for (int v = 0; v < plr; ++v) // all viewports { const Hud& h = hud[v]; const float sc = pSet->size_minimap * app->mSplitMgr->mDims[v].avgsize; const Vector3& pos = h.ndMap->getPosition(); for (c = 0; c < cntC; ++c) // all mini pos for one car { const SMiniPos& sp = h.vMiniPos[c]; const ColourValue& clr = app->carModels[c]->color; for (int p=0; p < 4; ++p) // all 4 points { float x = pos.x + (sp.x + sp.px[p]*z)*sc; float y = pos.y + (sp.y + sp.py[p]*z)*sc*asp; moPos->position(x, y, 0); moPos->textureCoord(tc[p][0], tc[p][1]); moPos->colour(clr); } } } int ii = plr * cntC; for (int i=0; i < ii; ++i) { int n = i*4; moPos->quad(n,n+1,n+3,n+2); } moPos->end(); } // track% local, updated always for (c = 0; c < cntC; ++c) { CarModel* cm = app->carModels[c]; if (cm->eType == CarModel::CT_LOCAL || cm->eType == CarModel::CT_REPLAY) cm->UpdTrackPercent(); } if (carId == -1 || app->carModels.empty()) { PROFILER.endBlock("g.hud"); return; } #ifdef DEBUG assert(carId >= 0); assert(carId < app->carModels.size()); #endif CarModel* pCarM = app->carModels[carId]; CAR* pCar = pCarM ? pCarM->pCar : 0; float vel=0.f, rpm=0.f, clutch=1.f; int gear=1; GetVals(carId,&vel,&rpm,&clutch,&gear); Hud& h = hud[carId]; /// multiplayer // ----------------------------------------------------------------------------------- static float tm = 0.f; tm += time; if (tm > 0.2f /**/&& app->mClient/**/) // not every frame, each 0.2s // if (pSet->game.isNetw) .. { // sort winners std::list<CarModel*> cms; for (c=0; c < cnt; ++c) cms.push_back(app->carModels[c]); cms.sort(SortWin); //stable_sort(cms.begin(), cms.end(), SortWin); String msg = ""; int place = 1; // assing places for (std::list<CarModel*>::iterator it = cms.begin(); it != cms.end(); ++it) { CarModel* cm = *it; bool end = app->pGame->timer.GetCurrentLap(cm->iIndex) >= pSet->game.num_laps; cm->iWonPlace = end ? place++ : 0; // when ended race // detect change (won), can happen more than once, if time diff < ping delay if (cm->iWonPlace != cm->iWonPlaceOld) { cm->iWonPlaceOld = cm->iWonPlace; cm->iWonMsgTime = gPar.timeWonMsg; if (cm->iIndex == 0) // for local player, show end wnd app->mWndNetEnd->setVisible(true); } if (cm->iWonMsgTime > 0.f) { cm->iWonMsgTime -= tm; if (cm->iWonPlace != 0) msg += cm->sDispName + " " + TR("#{FinishedCommaPlace}") + ": " + toStr(cm->iWonPlace) + "\n"; } } if (app->mClient && /*ap->pGame->timer.pretime <= 0.f &&*/ app->pGame->timer.waiting) msg += TR("#{NetWaitingForOthers}")+"...\n"; // chat 2 last lines if (gui->sChatLast1 != "") msg += gui->sChatLast1 + "\n"; if (gui->sChatLast2 != "") msg += gui->sChatLast2; ++gui->iChatMove; if (gui->iChatMove >= 10) //par 2sec { gui->iChatMove = 0; gui->sChatLast1 = gui->sChatLast2; gui->sChatLast2 = ""; } // upd hud msgs if (txMsg) { txMsg->setCaption(msg); bckMsg->setVisible(!msg.empty()); } // upd end list if (app->mWndNetEnd->getVisible()) { MyGUI::MultiList2* li = gui->liNetEnd; li->removeAllItems(); for (std::list<CarModel*>::iterator it = cms.begin(); it != cms.end(); ++it) { CarModel* cm = *it; String clr = StrClr(cm->color); li->addItem(""/*clr+ toStr(c+1)*/, 0); int l = li->getItemCount()-1; li->setSubItemNameAt(1,l, clr+ (cm->iWonPlace == 0 ? "--" : toStr(cm->iWonPlace))); li->setSubItemNameAt(2,l, clr+ cm->sDispName); li->setSubItemNameAt(3,l, clr+ StrTime( cm->iWonPlace == 0 ? 0.f : app->pGame->timer.GetPlayerTimeTot(cm->iIndex) )); //li->setSubItemNameAt(4,l, clr+ fToStr(cm->iWonMsgTime,1,3)); li->setSubItemNameAt(4,l, clr+ StrTime( app->pGame->timer.GetBestLapRace(cm->iIndex) )); li->setSubItemNameAt(5,l, clr+ toStr( app->pGame->timer.GetCurrentLap(cm->iIndex) )); } } tm = 0.f; } /// opponents list // ----------------------------------------------------------------------------------- bool visOpp = h.txOpp[0] && pSet->show_opponents; if (visOpp && pCarM && pCarM->pMainNode) { std::list<CarModel*> cms; // sorted list for (c=0; c < cnt; ++c) { // cars only CarModel* cm = app->carModels[c]; if (!cm->isGhost()) { if (app->bRplPlay) cm->trackPercent = app->carPoses[app->iCurPoses[c]][c].percent; cms.push_back(cm); } } if (pSet->opplist_sort) cms.sort(SortPerc); for (c=0; c < cnt; ++c) { // add last, if visible, ghost1 (dont add 2nd) and track's ghost CarModel* cm = app->carModels[c]; if (cm->eType == (app->isGhost2nd ? CarModel::CT_GHOST2 : CarModel::CT_GHOST) && pSet->rpl_ghost || cm->isGhostTrk() && pSet->rpl_trackghost) { cm->trackPercent = app->carPoses[app->iCurPoses[c]][c].percent; // ghost,rpl cms.push_back(cm); } } bool bGhostEnd = app->pGame->timer.GetPlayerTime(0) > app->ghplay.GetTimeLength(); String s0,s1,s2; // Track% Dist Nick ColourValue clr; c = 0; for (std::list<CarModel*>::iterator it = cms.begin(); it != cms.end(); ++it) { CarModel* cm = *it; if (cm->pMainNode) { bool bGhost = cm->isGhost() && !cm->isGhostTrk(); bool bGhostVis = (app->ghplay.GetNumFrames() > 0) && pSet->rpl_ghost; bool bGhEmpty = bGhost && !bGhostVis; // dist ----------- if (cm == pCarM || bGhEmpty) // no dist to self or to empty ghost s1 += "\n"; else { Vector3 v = cm->pMainNode->getPosition() - pCarM->pMainNode->getPosition(); float dist = v.length(); // meters Real h = std::min(60.f, dist) / 60.f; clr.setHSB(0.5f - h * 0.4f, 1, 1); s1 += StrClr(clr)+ fToStr(dist,0,3)+"m\n"; } // percent % ----------- if (bGhEmpty || cm->isGhostTrk()) s0 += "\n"; else { float perc = bGhost && bGhostEnd ? 100.f : cm->trackPercent; clr.setHSB(perc*0.01f * 0.4f, 0.7f, 1); s0 += StrClr(clr)+ fToStr(perc,0,3)+"%\n"; } // nick name ----------- if (cm->eType != CarModel::CT_REPLAY) { s2 += StrClr(cm->color)+ cm->sDispName; bool end = app->pGame->timer.GetCurrentLap(cm->iIndex) >= pSet->game.num_laps && (app->mClient || pSet->game.local_players > 1); // multiplay or split if (end) // place (1) s2 += " (" + toStr(cm->iWonPlace) + ")"; } s2 += "\n"; ++c; } } // upd pos, size if (h.lastOppH != c) { h.lastOppH = c; int y = c*25 +4, yo = h.yOpp - y-4; for (int n=0; n < 3; ++n) { h.txOpp[n]->setPosition(h.xOpp + n*65+5, yo + 3); h.txOpp[n]->setSize(90,y); } h.bckOpp->setPosition(h.xOpp, yo); h.bckOpp->setSize(230,y); } h.txOpp[0]->setCaption(s0); h.txOpp[1]->setCaption(s1); h.txOpp[2]->setCaption(s2); } // Set motion blur intensity for this viewport, depending on car's linear velocity //----------------------------------------------------------------------------------- if (pSet->blur) { // use velocity squared to achieve an exponential motion blur float speed = pCar->GetVelocity().MagnitudeSquared(); // peak at 250 kmh (=69 m/s), 69² = 4761 // motion blur slider: 1.0 = peak at 100 km/h 0.0 = peak at 400 km/h -> 0.5 = peak at 250 km/h // lerp(100, 400, 1-motionBlurIntensity) float peakSpeed = 100 + (1-pSet->blur_int) * (400-100); float intens = fabs(speed) / pow((peakSpeed/3.6f), 2); // higher fps = less perceived motion blur time a frame will be still visible on screen: // each frame, 1-intens of the original image is lost // example (intens = 0.7): // frame 1: full img frame 2: 0.7 * image // frame 3: 0.7² * image frame 4: 0.7³ * image // portion of image visible after 'n' frames: pow(intens, n); // example 1: 60 fps 0.7³ image after 4 frames: 0.066 sec // example 2: 120 fps 0.7³ image after 4 frames: 0.033 sec // now: need to achieve *same* time for both fps values // to do this, adjust intens // (1.0/fps) * pow(intens, n) == (1.0/fps2) * pow(intens2, n) // set n=4 intens_new = sqrt(sqrt((intens^4 * fpsReal/desiredFps)) intens = sqrt(sqrt( pow(intens, 4) * ((1.0f/time) / 120.0f) )); intens = std::min(intens, 0.9f); // clamp to 0.9f app->motionBlurIntensity = intens; } /// gear, vel texts ----------------------------- if (h.txVel && h.txGear && pCar) { float cl = clutch*0.8f + 0.2f; if (gear == -1) { h.txGear->setCaption("R"); h.txGear->setTextColour(Colour(0.3,1,1,cl)); } else if (gear == 0) { h.txGear->setCaption("N"); h.txGear->setTextColour(Colour(0.3,1,0.3,cl)); } else if (gear > 0 && gear < 8) { h.txGear->setCaption(toStr(gear)); h.txGear->setTextColour(Colour(1,1-gear*0.1,0.2,cl)); } h.txVel->setCaption(fToStr(fabs(vel),0,3)); float k = pCar->GetSpeedometer() * 3.6f * 0.0025f; // vel clr #define m01(x) std::min(1.0f, std::max(0.0f, (float) (x) )) h.txVel->setTextColour(Colour(m01(k*2), m01(0.5+k*1.5-k*k*2.5), m01(1+k*0.8-k*k*3.5))); } // boost fuel (time) ------ if (h.txBFuel && pCar && h.txBFuel->getVisible()) { h.txBFuel->setCaption(fToStr(pCar->dynamics.boostFuel,1,3)); } // damage % ------ if (h.txDamage && pCar && h.txDamage->getVisible()) { float d = std::min(100.f, pCar->dynamics.fDamage); //h.txDamage->setCaption(TR("#{Damage}\n ")+fToStr(d,0,3)+" %"); d*=0.01f; h.txDamage->setCaption(fToStr(d,0,3)+" %"); d*=0.01f; float e = std::min(1.f, 0.8f + d*2.f); h.txDamage->setTextColour(Colour(e-d*d*0.4f, std::max(0.f, e-d), std::max(0.f, e-d*2.f) )); } // abs, tcs on ------ if (h.txAbs && h.txTcs && pCar) { bool vis = pCar->GetABSEnabled(); h.txAbs->setVisible(vis); if (vis) h.txAbs->setAlpha(pCar->GetABSActive() ? 1.f : 0.6f); vis = pCar->GetTCSEnabled(); h.txTcs->setVisible(vis); if (vis) h.txTcs->setAlpha(pCar->GetTCSActive() ? 1.f : 0.6f); } /// times, race pos ----------------------------- if (pSet->show_times && pCar) { TIMER& tim = app->pGame->timer; bool hasLaps = pSet->game.local_players > 1 || pSet->game.champ_num >= 0 || pSet->game.chall_num >= 0 || app->mClient; if (hasLaps) { // place if (pCarM->iWonPlace > 0 && h.txPlace) { String s = TR("--- "+toStr(pCarM->iWonPlace)+" #{TBPlace} ---"); h.txPlace->setCaption(s); const static Colour clrPlace[4] = { Colour(0.4,1,0.2), Colour(1,1,0.3), Colour(1,0.7,0.2), Colour(1,0.5,0.2) }; h.txPlace->setTextColour(clrPlace[pCarM->iWonPlace-1]); h.bckPlace->setVisible(true); } } // times ------------------------------ bool cur = pCarM->iCurChk >= 0 && !app->vTimeAtChks.empty(); float ghTimeES = cur ? app->vTimeAtChks[pCarM->iCurChk] : 0.f; float part = ghTimeES / app->fLastTime; // fraction which track ghost has driven bool coldStart = tim.GetCurrentLap(carId) == 1; // was 0 float carMul = app->GetCarTimeMul(pSet->game.car[carId], pSet->game.sim_mode); //| cur float ghTimeC = ghTimeES + (coldStart ? 0 : 1); float ghTime = ghTimeC * carMul; // scaled float diffT = pCarM->timeAtCurChk - ghTime; // cur car diff at chk float diff = 0.f; // on hud //!- if (pCarM->updTimes || pCarM->updLap) { pCarM->updTimes = false; // track time, points float last = tim.GetLastLap(carId), best = tim.GetBestLap(carId, pSet->game.trackreverse); float timeCur = last < 0.1f ? best : last; float timeTrk = app->data->tracks->times[pSet->game.track]; bool b = timeTrk > 0.f && timeCur > 0.f; //bool coldStart = tim.GetCurrentLap(carId) == 1; // was 0 float time = (/*place*/1 * app->data->cars->magic * timeTrk + timeTrk) / carMul; // trk time (for 1st place) //float t1pl = data->carsXml.magic * timeTrk; float points = 0.f, curPoints = 0.f; int place = app->GetRacePos(timeCur, timeTrk, carMul, coldStart, &points); //| cur float timCC = timeTrk + (coldStart ? 0 : 1); float timCu = timCC * carMul; diff = pCarM->timeAtCurChk + /*(coldStart ? 1:0)*carMul*/ - time * part; ///new float chkPoints = 0.f; // cur, at chk, assume diff time later than track ghost int chkPlace = app->GetRacePos(timCu + diffT, timeTrk, carMul, coldStart, &chkPoints); bool any = cur || b; h.sTimes = "\n#80E080" + StrTime(time)+ "\n#D0D040" + (cur ? toStr( chkPlace ) : "--")+ "\n#F0A040" + (cur ? fToStr(chkPoints,1,3) : "--"); float dlap = last - time; h.sLap = "#D0E8FF"+TR("#{TBLapResults}") + "\n#80C8FF" + StrTime(last)+ (last > 0.f ? String(" ") + (dlap > 0.f ? "#80E0FF+" : "#60FF60-") + fToStr(fabs(dlap), 1,3) : "")+ "\n#80E0E0" + StrTime(best)+ "\n#80E080" + StrTime(time)+ "\n#D0D040" + (b ? toStr(place) : "--")+ "\n#F0A040" + (b ? fToStr(points,1,3) : "--"); if (h.txLap) h.txLap->setCaption(h.sLap); } if (h.txTimes) h.txTimes->setCaption( (hasLaps ? "#A0E0D0"+toStr(tim.GetCurrentLap(carId)+1)+" / "+toStr(pSet->game.num_laps) : "") + "\n#A0E0E0" + StrTime(tim.GetPlayerTime(carId))+ (cur ? String(" ") + (diff > 0.f ? "#80E0FF+" : "#60FF60-")+ fToStr(fabs(diff), 1,3) : "")+ h.sTimes+ "\n#E0B090" + fToStr(pCarM->trackPercent,0,1)+"%" ); if (h.txLap) { //if (pCarM->updLap) //{ pCarM->updLap = false; //h.txLap->setCaption(h.sLap); //} float a = std::min(1.f, pCarM->fLapAlpha * 2.f); bool hasRoad = app->scn->road && app->scn->road->getNumPoints() > 2; bool vis = pSet->show_times && hasRoad && a > 0.f; if (vis) { if (app->iLoad1stFrames == -2) //bLoading) // fade out { pCarM->fLapAlpha -= !hasRoad ? 1.f : time * gPar.fadeLapResults; if (pCarM->fLapAlpha < 0.f) pCarM->fLapAlpha = 0.f; } h.bckLap->setAlpha(a); h.txLapTxt->setAlpha(a); h.txLap->setAlpha(a); } h.bckLap->setVisible(vis); h.txLapTxt->setVisible(vis); h.txLap->setVisible(vis); } } // checkpoint warning -------- if (app->scn->road && h.bckWarn && pCarM) { /* checks debug * if (ov[0].oU) { //"ghost: " + GetTimeString(ghost.GetTimeLength()) + " " + toStr(ghost.GetNumFrames()) + "\n" + //"ghplay: " + GetTimeString(ghplay.GetTimeLength()) + " " + toStr(ghplay.GetNumFrames()) + "\n" + ov[0].oU->setCaption(String("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n") + " st " + toStr(pCarM->bInSt ? 1:0) + " in" + toStr(pCarM->iInChk) + " | cur" + toStr(pCarM->iCurChk) + " > next " + toStr(pCarM->iNextChk) + " | Num " + toStr(pCarM->iNumChks) + " / All " + toStr(road->mChks.size())); } /**/ if (pCarM->bWrongChk) pCarM->fChkTime = gPar.timeShowChkWarn; bool show = pCarM->fChkTime > 0.f; if (show) pCarM->fChkTime -= time; h.bckWarn->setVisible(show && pSet->show_times); } // race countdown ------ if (h.txCountdown) { bool vis = app->pGame->timer.pretime > 0.f && !app->pGame->timer.waiting; if (vis) h.txCountdown->setCaption(fToStr(app->pGame->timer.pretime,1,3)); h.txCountdown->setVisible(vis); } // camera cur ------ if (h.txCam) { FollowCamera* cam = pCarM->fCam; if (cam && cam->updName) { cam->updName = false; h.txCam->setCaption(cam->sName); } } //------------------------------------------------------------------------------------------------------------------- /// debug infos //------------------------------------------------------------------------------------------------------------------- static int oldTxtClr = -2; // clr upd if (oldTxtClr != pSet->car_dbgtxtclr) { oldTxtClr = pSet->car_dbgtxtclr; UpdDbgTxtClr(); } // car debug text -------- static bool oldCarTxt = false; if (pCar && ov[0].oU) { if (pSet->car_dbgtxt) { std::stringstream s1,s2,s3,s4; pCar->DebugPrint(s1, true, false, false, false); ov[0].oU->setCaption(s1.str()); pCar->DebugPrint(s2, false, true, false, false); ov[1].oU->setCaption(s2.str()); pCar->DebugPrint(s3, false, false, true, false); ov[2].oU->setCaption(s3.str()); pCar->DebugPrint(s4, false, false, false, true); ov[3].oU->setCaption(s4.str()); }else if (pSet->car_dbgtxt != oldCarTxt) { ov[0].oU->setCaption(""); /*ovU[1]->setCaption(""); ovU[2]->setCaption(""); ovU[3]->setCaption("");*/ } } oldCarTxt = pSet->car_dbgtxt; // profiling times -------- if (pSet->profilerTxt && ov[1].oU) { PROFILER.endCycle(); static int frame=0; ++frame; if (frame > 10) //par { frame = 0; std::string sProf = PROFILER.getAvgSummary(quickprof::MILLISECONDS); //sProf = "PROF "+fToStr(1000.f/PROFILER.getAvgDuration(" frameSt",quickprof::MILLISECONDS), 2,4); ov[1].oU->setCaption(sProf); } //if (newPosInfos.size() > 0) //ov[3].oU->setCaption("carm: " + toStr(ap->carModels.size()) + " newp: " + toStr((*newPosInfos.begin()).pos)); } // bullet profiling text -------- static bool oldBltTxt = false; if (ov[1].oU) { if (pSet->bltProfilerTxt) { static int cc = 0; ++cc; if (cc > 40) { cc = 0; std::stringstream os; bltDumpAll(os); ov[1].oU->setCaption(os.str()); } } else if (pSet->bltProfilerTxt != oldBltTxt) ov[1].oU->setCaption(""); } oldBltTxt = pSet->bltProfilerTxt; // wheels slide, susp bars -------- if (pSet->car_dbgbars && pCar) { const Real xp = 80, yp = -530, ln = 20, y4 = 104; //const static char swh[4][6] = {"F^L<","F^R>","RvL<","RvR>"}; for (int w=0; w < 4; ++w) if (ov[3-w].oL && ov[3-w].oR && ov[3-w].oS) { float slide = /*-1.f*/0.f, sLong = 0.f, sLat = 0.f; float squeal = pCar->GetTireSquealAmount((WHEEL_POSITION)w, &slide, &sLong, &sLat); //MATHVECTOR<float,3> vwhVel = pCar->dynamics.GetWheelVelocity((WHEEL_POSITION)w); //float whVel = vwhVel.Magnitude() * 3.6f; /** // info static char ss[256]; sprintf(ss, "%s %6.3f %6.3f %6.3f %6.3f\n", swh[w], sLong/4.f, sLat/3.f, slide, squeal); ColourValue clr; clr.setHSB( slide/20.f, 0.8f, 1.f ); //clr.a = min(0.f, slide/2.f); ovL[3-w]->setCaption(String(ss)); ovL[3-w]->setColour(clr); //ovL[3-w]->setPosition(0.f, 230 + w*22); /**/ // bar meters | float susp = pCar->dynamics.GetSuspension(WHEEL_POSITION(w)).GetDisplacementPercent(); sLong = fabs(sLong); float slng = sLong / sLong * powf(sLong, 0.3f); // slide*20.f ov[3-w].oR->setPosition(slng * 14.f +xp, yp + w*ln); ov[3-w].oL->setPosition(sLat * 14.f +xp, yp + w*ln +y4); ov[3-w].oS->setPosition(susp * 70.f +xp, yp + w*ln -y4); } if (ov[4].oL) ov[4].oL->setPosition(xp, yp + -20 +y4+3); if (ov[4].oS) ov[4].oS->setPosition(xp + 70, yp + -20 -104-3); //ov[3-w].oR->setCaption("|"); ov[3-w].oR->setColour(ColourValue(0.6,1.0,0.7)); } // input values /*if (pCar && ap->pGame && ap->pGame->profilingmode) { const std::vector<float>& inp = pCar->dynamics.inputsCopy; if (ov[2].oU && inp.size() == CARINPUT::ALL) { sprintf(s, " Throttle %5.2f\n Brake %5.2f\n Steer %5.2f\n" " Handbrake %5.2f\n Boost %5.2f\n Flip %5.2f\n" ,inp[CARINPUT::THROTTLE], inp[CARINPUT::BRAKE], -inp[CARINPUT::STEER_LEFT]+inp[CARINPUT::STEER_RIGHT] ,inp[CARINPUT::HANDBRAKE],inp[CARINPUT::BOOST], inp[CARINPUT::FLIP] ); ov[2].oU->setCaption(String(s)); } }/**/ // wheels ter mtr, surface info --------- if (pSet->car_dbgsurf && pCar) { String ss = ""; ss = pCarM->txtDbgSurf; // surfaces info /*ss += "\n"; for (int i=0; i < ap->pGame->track.tracksurfaces.size(); ++i) ss += String(ap->pGame->track.tracksurfaces[i].name.c_str()) + "\n";/**/ //ovCarDbg->show(); if (ov[4].oX) { //ov[4].oL->setTop(400); ov[4].oX->setCaption(ss); } } /// tire vis circles + + + + if (pCar && moTireVis[0] && pSet->car_tirevis) { const Real z = 6000.f / pSet->tc_r, zy = pSet->tc_xr, m_z = 2.f * z; // scale, max factor const int na = 32; // circle quality const Real ad = 2.f*PI_d/na, u = 0.02f; // u line thickness const ColourValue cb(0.8,0.8,0.8),cl(0.2,1,0.2),cr(0.9,0.4,0),cc(1,1,0); for (int i=0; i < 4; ++i) { const CARDYNAMICS& cd = pCar->dynamics; const CARWHEEL::SlideSlip& t = cd.wheel[i].slips; float d = cd.wheel_contact[i].GetDepth() - 2*cd.wheel[i].GetRadius(); bool off = !(d > -0.1f && d <= -0.01f); // not in air //bool on = cd.wheel_contact[i].GetColObj(); ManualObject* m = moTireVis[i]; m->beginUpdate(0); // back + m->position(-1,0,0); m->colour(cb); m->position( 1,0,0); m->colour(cb); m->position(0,-1,0); m->colour(cb); m->position(0, 1,0); m->colour(cb); // tire, before combine Real lx = off ? 0.f : t.preFy/z*zy, ly = off ? 0.f : t.preFx/z; for (int y=-1; y<=1; ++y) for (int x=-1; x<=1; ++x) { m->position(0 +x*u, 0 +y*u, 0); m->colour(cr); m->position(lx +x*u, ly +y*u, 0); m->colour(cr); } // tire line / lx = off ? 0.f : t.Fy/z*zy; ly = off ? 0.f : t.Fx/z; for (int y=-2; y<=2; ++y) for (int x=-2; x<=2; ++x) { m->position(0 +x*u, 0 +y*u, 0); m->colour(cl); m->position(lx +x*u, ly +y*u, 0); m->colour(cl); } // max circle o Real rx = off || t.Fym > m_z ? 0.f : t.Fym/z, ry = off || t.Fxm > m_z ? 0.f : t.Fxm/z, a = 0.f; Vector3 p(0,0,0),po(0,0,0); for (int n=0; n <= na; ++n) { p.x = rx*cosf(a)*zy; p.y =-ry*sinf(a); if (n > 0) { m->position(po); m->colour(cc); m->position(p); m->colour(cc); } a += ad; po = p; } m->end(); } } PROFILER.endBlock("g.hud"); }
//--------------------------------------------------------------------- void Grid3DPageStrategy::updateDebugDisplay(Page* p, SceneNode* sn) { uint8 dbglvl = mManager->getDebugDisplayLevel(); if (dbglvl) { // we could try to avoid updating the geometry every time here, but this // wouldn't easily deal with paging parameter changes. There shouldn't // be that many pages anyway, and this is debug after all, so update every time int32 x, y, z; Grid3DPageStrategyData* stratData = static_cast<Grid3DPageStrategyData*>( p->getParentSection()->getStrategyData()); stratData->calculateCell(p->getID(), &x, &y, &z); Grid3DPageStrategyData* data = static_cast<Grid3DPageStrategyData*>(p->getParentSection()->getStrategyData()); // Determine our centre point, we'll anchor here Vector3 midPoint; data->getMidPointGridSpace(x, y, z, midPoint); sn->setPosition(midPoint); //--- Get coordinates, relative to midPoint : Vector3 corners[8]; Vector3 hSize = 0.500f * stratData->getCellSize(); for (int i = 0; i < 8; ++i) { corners[i].x = i&1 ? hSize.x : -hSize.x; corners[i].z = i&2 ? hSize.y : -hSize.y; corners[i].y = i&4 ? hSize.z : -hSize.z; } //--- Get a material String matName = "Ogre/G3D/Debug"; MaterialPtr mat = MaterialManager::getSingleton().getByName(matName); if (mat.isNull()) { mat = MaterialManager::getSingleton().create(matName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); Pass* pass = mat->getTechnique(0)->getPass(0); pass->setLightingEnabled(false); pass->setVertexColourTracking(TVC_AMBIENT); pass->setDepthWriteEnabled(false); mat->load(); } ManualObject* mo = 0; bool update = sn->numAttachedObjects() > 0; if( update ) { mo = static_cast<ManualObject*>(sn->getAttachedObject(0)); mo->beginUpdate(0); } else { mo = p->getParentSection()->getSceneManager()->createManualObject(); mo->begin(matName, RenderOperation::OT_LINE_STRIP); } ColourValue vcol = ColourValue::Green; mo->position(corners[0]); mo->colour(vcol); // First Square... mo->position(corners[1]); mo->colour(vcol); mo->position(corners[3]); mo->colour(vcol); mo->position(corners[2]); mo->colour(vcol); mo->position(corners[0]); mo->colour(vcol); mo->position(corners[4]); mo->colour(vcol); // 0-4 link + second square and mo->position(corners[5]); mo->colour(vcol); mo->position(corners[7]); mo->colour(vcol); mo->position(corners[6]); mo->colour(vcol); mo->position(corners[4]); mo->colour(vcol); mo->position(corners[5]); mo->colour(vcol); // 5-1 link mo->position(corners[1]); mo->colour(vcol); mo->position(corners[3]); mo->colour(vcol); // 3-7 link mo->position(corners[7]); mo->colour(vcol); mo->position(corners[6]); mo->colour(vcol); // 6-2 link mo->position(corners[2]); mo->colour(vcol); mo->end(); if(!update) sn->attachObject(mo); } }