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 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
}
// 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);
}
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 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);
}
// 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
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());
}
void App::CreateRoadBezier()
{
ManualObject* m = mSceneMgr->createManualObject();
//m->begin("pipeGlass", RenderOperation::OT_TRIANGLE_LIST);
m->begin("roadAsphalt", RenderOperation::OT_TRIANGLE_LIST);
int ii=0;
#ifdef SR_EDITOR
const std::list <ROADSTRIP>& roads = track->GetRoadList();
#else
const std::list <ROADSTRIP>& roads = pGame->track.GetRoadList();
#endif
for (std::list <ROADSTRIP>::const_iterator it = roads.begin(); it != roads.end(); ++it)
{
#define VDR_LEN // to get whole track length
#ifdef VDR_LEN
MATHVECTOR<float,3> vec0; float length = 0.f;
#endif
const std::list <ROADPATCH>& pats = (*it).GetPatchList();
for (std::list <ROADPATCH>::const_iterator i = pats.begin(); i != pats.end(); ++i)
{
float p[16][3]; int a=0;
for (int y=0; y<4; ++y)
for (int x=0; x<4; ++x)
{
const MATHVECTOR<float,3>& vec = (*i).GetPatch().GetPoint(x,y);
p[a][0] = vec[2]; p[a][1] = vec[1] + 0.2f/*ofs up*/; p[a][2] = -vec[0]; a++;
#ifdef VDR_LEN
if (x==1 && y==1 /*&& it == roads.begin()*/) //main only-
{
if (i != pats.begin()) // sum distance
length += (vec0-vec).Magnitude();
vec0 = vec;
//LogO(fToStr(length,2,6));
}
#endif
}
a=0;
// normal
Vector3 pos (p[a ][0], p[a ][1], p[a ][2]);
Vector3 posX(p[a+3][0], p[a+3][1], p[a+3][2]); posX-=pos; posX.normalise();
Vector3 posY(p[a+12][0],p[a+12][1],p[a+12][2]); posY-=pos; posY.normalise();
Vector3 norm = posX.crossProduct(posY); norm.normalise();/**/
for (int y=0; y<4; ++y)
for (int x=0; x<4; ++x)
{
Vector3 pos(p[a][0], p[a][1], p[a][2]); a++;
m->position(pos);
m->normal(norm);/**/
m->textureCoord(y/3.f,x/3.f);
if (x<3 && y<3)
{
int a = ii+x+y*4;
m->index(a); m->index(a+1); m->index(a+4);
m->index(a+5); m->index(a+4); m->index(a+1);
}
}
ii += 16;
}
#ifdef VDR_LEN
LogO("VDR TRK: " + pSet->gui.track +" LEN: "+fToStr(length,2,6));
#endif
}
m->end();
AxisAlignedBox aabInf; aabInf.setInfinite();
m->setBoundingBox(aabInf); // always visible
mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(m);
}
ManualObject* CHud::CreateVdrMinimap()
{
asp = float(app->mWindow->getWidth())/float(app->mWindow->getHeight());
// get track sizes
minX=FLT_MAX; maxX=FLT_MIN; minY=FLT_MAX; maxY=FLT_MIN;
const std::list <ROADSTRIP>& roads = app->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)
{
for (int iy=0; iy<4; ++iy)
for (int ix=0; ix<4; ++ix)
{
const MATHVECTOR<float,3>& vec = (*i).GetPatch().GetPoint(ix,iy);
Real x = vec[0], y = vec[2];
if (x < minX) minX = x; if (x > maxX) maxX = x;
if (y < minY) minY = y; if (y > maxY) maxY = y;
}
}
}
float fMapSizeX = maxX - minX, fMapSizeY = maxY - minY; // map size
float size = std::max(fMapSizeX, fMapSizeY);
scX = 1.f / size; scY = 1.f / size;
ManualObject* m = app->mSceneMgr->createManualObject();
m->begin("hud/Minimap", RenderOperation::OT_TRIANGLE_LIST);
int ii = 0;
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)
{
float p[16][3]; int a=0;
for (int y=0; y<4; ++y)
for (int x=0; x<4; ++x)
{
const MATHVECTOR<float,3>& vec = (*i).GetPatch().GetPoint(x,y);
p[a][0] = vec[0]; p[a][1] = vec[2]; p[a][2] = vec[1]; a++;
}
a = 0;
// normal
Vector3 pos (p[a ][2], -p[a ][0], p[a ][1]);
Vector3 posX(p[a+3][2], -p[a+3][0], p[a+3][1]); posX-=pos; posX.normalise();
Vector3 posY(p[a+12][2],-p[a+12][0],p[a+12][1]); posY-=pos; posY.normalise();
Vector3 norm = posX.crossProduct(posY); norm.normalise();/**/
for (int y=0; y<4; ++y)
for (int x=0; x<4; ++x)
{
Vector3 pos( (p[a][0] - minX)*scX*2-1, // pos x,y = -1..1
-(p[a][1] - minY)*scY*2+1, 0); a++;
m->position(pos);
m->normal(norm);/**/
Real c = std::min(1.f, std::max(0.3f, 1.f - 2.4f * powf( fabs(norm.y)
/*norm.absDotProduct(vLi)*/, 0.7f) ));
m->colour(ColourValue(c,c,c,1));
m->textureCoord(x/3.f,y/3.f);
if (x<3 && y<3)
{
int a = ii+x+y*4;
m->index(a+0); m->index(a+1); m->index(a+4);
m->index(a+1); m->index(a+4); m->index(a+5);
}
}
ii += 16;
}
}
m->end();
m->setUseIdentityProjection(true); m->setUseIdentityView(true); // on hud
m->setCastShadows(false);
AxisAlignedBox aab; aab.setInfinite(); m->setBoundingBox(aab); // draw always
m->setRenderingDistance(100000.f);
m->setRenderQueueGroup(RQG_Hud2); m->setVisibilityFlags(RV_Hud);
return m;
}
