// 创建网格 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; }
void createMeshWithMaterial(String fileName) { String matFileNameSuffix = ".material"; String matName1 = "red"; String matFileName1 = matName1 + matFileNameSuffix; MaterialPtr matPtr = MaterialManager::getSingleton().create(matName1, "General"); Pass* pass = matPtr->getTechnique(0)->getPass(0); pass->setDiffuse(1.0, 0.1, 0.1, 0); String matName2 = "green"; String matFileName2 = matName2 + matFileNameSuffix; matPtr = MaterialManager::getSingleton().create(matName2, "General"); pass = matPtr->getTechnique(0)->getPass(0); pass->setDiffuse(0.1, 1.0, 0.1, 0); String matName3 = "blue"; String matFileName3 = matName3 + matFileNameSuffix; matPtr = MaterialManager::getSingleton().create(matName3, "General"); pass = matPtr->getTechnique(0)->getPass(0); pass->setDiffuse(0.1, 0.1, 1.0, 0); String matName4 = "yellow"; String matFileName4 = matName4 + matFileNameSuffix; matPtr = MaterialManager::getSingleton().create(matName4, "General"); pass = matPtr->getTechnique(0)->getPass(0); pass->setDiffuse(1.0, 1.0, 0.1, 0); ManualObject* manObj = OGRE_NEW ManualObject("mesh"); manObj->begin(matName1, RenderOperation::OT_TRIANGLE_LIST); manObj->position(0, 50, 0); manObj->position(50, 50, 0); manObj->position(0, 100, 0); manObj->triangle(0, 1, 2); manObj->position(50, 100, 0); manObj->position(0, 100, 0); manObj->position(50, 50, 0); manObj->triangle(3, 4, 5); manObj->end(); manObj->begin(matName2, RenderOperation::OT_LINE_LIST); manObj->position(0, 100, 0); manObj->position(-50, 50, 0); manObj->position(-50, 0, 0); manObj->position(-50, 50, 0); manObj->position(-100, 0, 0); manObj->position(-50, 0, 0); manObj->end(); manObj->begin(matName3, RenderOperation::OT_LINE_STRIP); manObj->position(50, 100, 0); manObj->position(100, 50, 0); manObj->position(100, 0, 0); manObj->position(150, 0, 0); manObj->end(); manObj->begin(matName4, RenderOperation::OT_POINT_LIST); manObj->position(50, 0, 0); manObj->position(0, 0, 0); manObj->end(); manObj->convertToMesh(fileName); OGRE_DELETE manObj; }
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 }
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 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; }
//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 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(); }
// 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; }
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 DebugDisplay::drawCube( AxisAlignedBox bbox ) { oht_assert_threadmodel(ThrMdl_Main); ManualObject * pManObj = _pSceneManager->createManualObject(); rollbackTransforms(bbox); pManObj->begin(getCurrentMaterial(), RenderOperation::OT_LINE_LIST); const Vector3 m0 = bbox.getMinimum(), mN = bbox.getMaximum(); pManObj->position(m0.x, m0.y, m0.z); pManObj->position(mN.x, m0.y, m0.z); pManObj->position(m0.x, m0.y, m0.z); pManObj->position(m0.x, mN.y, m0.z); pManObj->position(m0.x, m0.y, m0.z); pManObj->position(m0.x, m0.y, mN.z); pManObj->position(mN.x, mN.y, m0.z); pManObj->position(mN.x, m0.y, m0.z); pManObj->position(mN.x, mN.y, m0.z); pManObj->position(m0.x, mN.y, m0.z); pManObj->position(mN.x, mN.y, m0.z); pManObj->position(mN.x, mN.y, mN.z); pManObj->position(m0.x, mN.y, mN.z); pManObj->position(m0.x, mN.y, m0.z); pManObj->position(m0.x, mN.y, mN.z); pManObj->position(m0.x, m0.y, mN.z); pManObj->position(m0.x, mN.y, mN.z); pManObj->position(mN.x, mN.y, mN.z); pManObj->position(mN.x, m0.y, mN.z); pManObj->position(m0.x, m0.y, mN.z); pManObj->position(mN.x, m0.y, mN.z); pManObj->position(mN.x, m0.y, m0.z); pManObj->position(mN.x, m0.y, mN.z); pManObj->position(mN.x, mN.y, mN.z); pManObj->end(); _pScNode->attachObject(pManObj); }
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); }
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); }
// 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; }
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 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 ); }
//--------------------------------------------------------------------- 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(); }
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); }
Entity* OctreeNode::getOctreeGrid(SceneManager *sceneManager) { if (!mOctreeGrid) { mGridPositionCount = 0; mNodeI++; ManualObject* manual = sceneManager->createManualObject(); manual->begin("BaseWhiteNoLighting", RenderOperation::OT_LINE_LIST); manual->colour((Real)1.0, (Real)0.0, (Real)0.0); buildOctreeGridLines(manual); manual->end(); StringUtil::StrStreamType meshName; meshName << "VolumeOctreeGridMesh" << mNodeI; manual->convertToMesh(meshName.str()); StringUtil::StrStreamType entityName; entityName << "VolumeOctreeGrid" << mNodeI; mOctreeGrid = sceneManager->createEntity(entityName.str(), meshName.str()); } return mOctreeGrid; }
void MeshWithoutIndexDataTests::testCreateLineList() { ManualObject* lineList = OGRE_NEW ManualObject("line"); lineList->begin("BaseWhiteNoLighting", RenderOperation::OT_LINE_LIST); lineList->position(0, 50, 0); lineList->position(50, 100, 0); lineList->position(50, 50, 0); lineList->position(100, 100, 0); lineList->position(0, 50, 0); lineList->position(50, 50, 0); lineList->end(); String fileName = "lineList.mesh"; MeshPtr lineListMesh = lineList->convertToMesh(fileName); OGRE_DELETE lineList; CPPUNIT_ASSERT(lineListMesh->getNumSubMeshes() == 1); CPPUNIT_ASSERT(lineListMesh->getSubMesh(0)->indexData->indexCount == 0); RenderOperation rop; lineListMesh->getSubMesh(0)->_getRenderOperation(rop); CPPUNIT_ASSERT(rop.useIndexes == false); CPPUNIT_ASSERT(lineListMesh->getSubMesh(0)->vertexData->vertexCount == 6); MeshSerializer meshWriter; meshWriter.exportMesh(lineListMesh.get(), fileName); mMeshMgr->remove( fileName ); ResourceGroupManager::getSingleton().addResourceLocation(".", "FileSystem"); MeshPtr loadedLineList = mMeshMgr->load(fileName, "General"); remove(fileName.c_str()); CPPUNIT_ASSERT(loadedLineList->getNumSubMeshes() == 1); CPPUNIT_ASSERT(loadedLineList->getSubMesh(0)->indexData->indexCount == 0); loadedLineList->getSubMesh(0)->_getRenderOperation(rop); CPPUNIT_ASSERT(rop.useIndexes == false); CPPUNIT_ASSERT(loadedLineList->getSubMesh(0)->vertexData->vertexCount == 6); mMeshMgr->remove( fileName ); }
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); }
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()); }
Entity* DualGridGenerator::getDualGrid(SceneManager *sceneManager) { if (!mDualGrid && mDualCells.size() > 0) { ManualObject* manual = sceneManager->createManualObject(); manual->begin("BaseWhiteNoLighting", RenderOperation::OT_LINE_LIST); manual->colour((Real)0.0, (Real)1.0, (Real)0.0); manual->estimateVertexCount(mDualCells.size() * 8); manual->estimateIndexCount(mDualCells.size() * 24); uint32 baseIndex = 0; for (VecDualCell::iterator it = mDualCells.begin(); it != mDualCells.end(); ++it) { MeshBuilder::addCubeToManualObject( manual, it->mC0, it->mC1, it->mC2, it->mC3, it->mC4, it->mC5, it->mC6, it->mC7, baseIndex); } manual->end(); mDualGridI++; StringUtil::StrStreamType meshName; meshName << "VolumeDualGridGridMesh" << mDualGridI; manual->convertToMesh(meshName.str()); StringUtil::StrStreamType entityName; entityName << "VolumeDualGrid" << mDualGridI; mDualGrid = sceneManager->createEntity(entityName.str(), meshName.str()); } return mDualGrid; }
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; }
// source: // http://www.ogre3d.org/forums/viewtopic.php?p=301318&sid=ce193664e1d3d7c4af509e6f4e2718c6 ManualObject* createCubeMesh(Ogre::String name, Ogre::String matName) { ManualObject* cube = new ManualObject(name); cube->begin(matName); cube->position(0.5,-0.5,1.0);cube->normal(0.408248,-0.816497,0.408248);cube->textureCoord(1,0); cube->position(-0.5,-0.5,0.0);cube->normal(-0.408248,-0.816497,-0.408248);cube->textureCoord(0,1); cube->position(0.5,-0.5,0.0);cube->normal(0.666667,-0.333333,-0.666667);cube->textureCoord(1,1); cube->position(-0.5,-0.5,1.0);cube->normal(-0.666667,-0.333333,0.666667);cube->textureCoord(0,0); cube->position(0.5,0.5,1.0);cube->normal(0.666667,0.333333,0.666667);cube->textureCoord(1,0); cube->position(-0.5,-0.5,1.0);cube->normal(-0.666667,-0.333333,0.666667);cube->textureCoord(0,1); cube->position(0.5,-0.5,1.0);cube->normal(0.408248,-0.816497,0.408248);cube->textureCoord(1,1); cube->position(-0.5,0.5,1.0);cube->normal(-0.408248,0.816497,0.408248);cube->textureCoord(0,0); cube->position(-0.5,0.5,0.0);cube->normal(-0.666667,0.333333,-0.666667);cube->textureCoord(0,1); cube->position(-0.5,-0.5,0.0);cube->normal(-0.408248,-0.816497,-0.408248);cube->textureCoord(1,1); cube->position(-0.5,-0.5,1.0);cube->normal(-0.666667,-0.333333,0.666667);cube->textureCoord(1,0); cube->position(0.5,-0.5,0.0);cube->normal(0.666667,-0.333333,-0.666667);cube->textureCoord(0,1); cube->position(0.5,0.5,0.0);cube->normal(0.408248,0.816497,-0.408248);cube->textureCoord(1,1); cube->position(0.5,-0.5,1.0);cube->normal(0.408248,-0.816497,0.408248);cube->textureCoord(0,0); cube->position(0.5,-0.5,0.0);cube->normal(0.666667,-0.333333,-0.666667);cube->textureCoord(1,0); cube->position(-0.5,-0.5,0.0);cube->normal(-0.408248,-0.816497,-0.408248);cube->textureCoord(0,0); cube->position(-0.5,0.5,1.0);cube->normal(-0.408248,0.816497,0.408248);cube->textureCoord(1,0); cube->position(0.5,0.5,0.0);cube->normal(0.408248,0.816497,-0.408248);cube->textureCoord(0,1); cube->position(-0.5,0.5,0.0);cube->normal(-0.666667,0.333333,-0.666667);cube->textureCoord(1,1); cube->position(0.5,0.5,1.0);cube->normal(0.666667,0.333333,0.666667);cube->textureCoord(0,0); cube->triangle(0,1,2); cube->triangle(3,1,0); cube->triangle(4,5,6); cube->triangle(4,7,5); cube->triangle(8,9,10); cube->triangle(10,7,8); cube->triangle(4,11,12); cube->triangle(4,13,11); cube->triangle(14,8,12); cube->triangle(14,15,8); cube->triangle(16,17,18); cube->triangle(16,19,17); cube->end(); return cube; }
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; }