// 创建网格
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;
}
