void COgreManager::BuildTangentOfMesh( const STRING& meshname )
{
MeshPtr mesh = MeshManager::getSingleton().load(meshname, ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME);
unsigned short src, dest;
if (!mesh->suggestTangentVectorBuildParams(VES_TANGENT, src, dest))
mesh->buildTangentVectors(VES_TANGENT, src, dest);
}
void SplineRoad::AddMesh(MeshPtr mesh, String sMesh, const AxisAlignedBox& aabox,
Entity** pEnt, SceneNode** pNode, String sEnd)
{
mesh->_setBounds(aabox);
mesh->_setBoundingSphereRadius((aabox.getMaximum()-aabox.getMinimum()).length()/2.0);
mesh->load();
unsigned short src, dest;
if (!mesh->suggestTangentVectorBuildParams(VES_TANGENT, src, dest))
mesh->buildTangentVectors(VES_TANGENT, src, dest);
*pEnt = mSceneMgr->createEntity("rd.ent"+sEnd, sMesh);
*pNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("rd.node"+sEnd);
(*pNode)->attachObject(*pEnt);
(*pEnt)->setVisible(false); (*pEnt)->setCastShadows(false);
(*pEnt)->setVisibilityFlags(RV_Road);
}
void MeshWithoutIndexDataTests::testBuildTangentVectors()
{
String fileName = "testBuildTangentVectors.mesh";
createMeshWithMaterial(fileName);
MeshPtr mesh = mMeshMgr->getByName(fileName);
try
{
// make sure correct exception is thrown
mesh->buildTangentVectors();
CPPUNIT_FAIL("Expected InvalidParametersException!");
}
catch (const InvalidParametersException&)
{
// ok
}
mMeshMgr->remove( fileName );
}
/// create Fluid areas . . . . . . .
//----------------------------------------------------------------------------------------------------------------------
void CScene::CreateFluids()
{
vFlNd.clear(); vFlEnt.clear(); vFlSMesh.clear();
#ifdef SR_EDITOR
app->UpdFluidBox();
#endif
if (!mWaterRTT->mNdFluidsRoot)
mWaterRTT->mNdFluidsRoot = app->mSceneMgr->getRootSceneNode()->createChildSceneNode("FluidsRootNode");
for (int i=0; i < sc->fluids.size(); i++)
{
FluidBox& fb = sc->fluids[i];
// plane
Plane p; p.normal = Vector3::UNIT_Y; p.d = 0;
String smesh = "WaterMesh"+toStr(i);
MeshPtr mesh = MeshManager::getSingleton().createPlane( smesh, rgDef,
p, fb.size.x,fb.size.z, 6,6, true, 1, fb.tile.x*fb.size.x,fb.tile.y*fb.size.z, Vector3::UNIT_Z);
Entity* efl = app->mSceneMgr->createEntity("WaterPlane"+toStr(i), "WaterMesh"+toStr(i));
unsigned short src,dest;
if (!mesh->suggestTangentVectorBuildParams(VES_TANGENT, src,dest))
mesh->buildTangentVectors(VES_TANGENT, src,dest);
String sMtr = fb.id == -1 ? "" : data->fluids->fls[fb.id].material; //"Water"+toStr(1+fb.type)
MaterialPtr mtr = MaterialManager::getSingleton().getByName(sMtr); //temp
efl->setMaterial(mtr); efl->setCastShadows(false);
efl->setRenderQueueGroup(RQG_Fluid); efl->setVisibilityFlags(RV_Terrain);
SceneNode* nfl = mWaterRTT->mNdFluidsRoot->createChildSceneNode(
fb.pos/*, Quaternion(Degree(fb.rot.x),Vector3::UNIT_Y)*/);
nfl->attachObject(efl);
vFlSMesh.push_back(smesh); vFlEnt.push_back(efl); vFlNd.push_back(nfl);
#ifndef SR_EDITOR // game
CreateBltFluids();
#endif
}
}
int DecalManager::addTerrainDecal(Ogre::Vector3 position, Ogre::Vector2 size, Ogre::Vector2 numSeg, Ogre::Real rotation, Ogre::String materialname, Ogre::String normalname)
{
#if 0
Ogre::ManualObject *mo = gEnv->ogreSceneManager->createManualObject();
String oname = mo->getName();
SceneNode *mo_node = terrain_decals_snode->createChildSceneNode();
mo->begin(materialname, Ogre::RenderOperation::OT_TRIANGLE_LIST);
AxisAlignedBox *aab=new AxisAlignedBox();
float uTile = 1, vTile = 1;
Vector3 normal = Vector3(0,1,0); // UP
int offset = 0;
float ground_dist = 0.001f;
Ogre::Vector3 vX = normal.perpendicular();
Ogre::Vector3 vY = normal.crossProduct(vX);
Ogre::Vector3 delta1 = size.x / numSeg.x * vX;
Ogre::Vector3 delta2 = size.y / numSeg.y * vY;
// build one corner of the square
Ogre::Vector3 orig = -0.5*size.x*vX - 0.5*size.y*vY;
for (int i1 = 0; i1<=numSeg.x; i1++)
for (int i2 = 0; i2<=numSeg.y; i2++)
{
Vector3 pos = orig+i1*delta1+i2*delta2 + position;
pos.y = hfinder->getHeightAt(pos.x, pos.z) + ground_dist;
mo->position(pos);
aab->merge(pos);
mo->textureCoord(i1/(Ogre::Real)numSeg.x*uTile, i2/(Ogre::Real)numSeg.y*vTile);
mo->normal(normal);
}
bool reverse = false;
if (delta1.crossProduct(delta2).dotProduct(normal)>0)
reverse= true;
for (int n1 = 0; n1<numSeg.x; n1++)
{
for (int n2 = 0; n2<numSeg.y; n2++)
{
if (reverse)
{
mo->index(offset+0);
mo->index(offset+(numSeg.y+1));
mo->index(offset+1);
mo->index(offset+1);
mo->index(offset+(numSeg.y+1));
mo->index(offset+(numSeg.y+1)+1);
}
else
{
mo->index(offset+0);
mo->index(offset+1);
mo->index(offset+(numSeg.y+1));
mo->index(offset+1);
mo->index(offset+(numSeg.y+1)+1);
mo->index(offset+(numSeg.y+1));
}
offset++;
}
offset++;
}
offset+=numSeg.y+1;
mo->end();
mo->setBoundingBox(*aab);
// some optimizations
mo->setCastShadows(false);
mo->setDynamic(false);
delete(aab);
MeshPtr mesh = mo->convertToMesh(oname+"_mesh");
// build edgelist
mesh->buildEdgeList();
// remove the manualobject again, since we dont need it anymore
gEnv->ogreSceneManager->destroyManualObject(mo);
unsigned short src, dest;
if (!mesh->suggestTangentVectorBuildParams(VES_TANGENT, src, dest))
{
mesh->buildTangentVectors(VES_TANGENT, src, dest);
}
Entity *ent = gEnv->ogreSceneManager->createEntity(oname+"_ent", oname+"_mesh");
mo_node->attachObject(ent);
mo_node->setVisible(true);
//mo_node->showBoundingBox(true);
mo_node->setPosition(Vector3::ZERO); //(position.x, 0, position.z));
// RTSS
//Ogre::RTShader::ShaderGenerator::getSingleton().createShaderBasedTechnique(materialname, Ogre::MaterialManager::DEFAULT_SCHEME_NAME, Ogre::RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME);
//Ogre::RTShader::ShaderGenerator::getSingleton().invalidateMaterial(RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME, materialname);
RTSSgenerateShadersForMaterial(materialname, normalname);
#endif
return 0;
}
int DecalManager::addTerrainSplineDecal(Ogre::SimpleSpline *spline, float width, Ogre::Vector2 numSeg, Ogre::Vector2 uvSeg, Ogre::String materialname, float ground_offset, Ogre::String export_fn, bool debug)
{
#if 0
Ogre::ManualObject *mo = gEnv->ogreSceneManager->createManualObject();
String oname = mo->getName();
SceneNode *mo_node = terrain_decals_snode->createChildSceneNode();
mo->begin(materialname, Ogre::RenderOperation::OT_TRIANGLE_LIST);
AxisAlignedBox *aab=new AxisAlignedBox();
int offset = 0;
// how width is the road?
float delta_width = width / numSeg.x;
float steps_len = 1.0f / numSeg.x;
for (int l = 0; l<=numSeg.x; l++)
{
// get current position on that spline
Vector3 pos_cur = spline->interpolate(steps_len * (float)l);
Vector3 pos_next = spline->interpolate(steps_len * (float)(l + 1));
Ogre::Vector3 direction = (pos_next - pos_cur);
if (l == numSeg.x)
{
// last segment uses previous position
pos_next = spline->interpolate(steps_len * (float)(l - 1));
direction = (pos_cur - pos_next);
}
for (int w = 0; w<=numSeg.y; w++)
{
// build vector for the width
Vector3 wn = direction.normalisedCopy().crossProduct(Vector3::UNIT_Y);
// calculate the offset, spline in the middle
Vector3 offset = (-0.5 * wn * width) + (w/numSeg.y) * wn * width;
// push everything together
Ogre::Vector3 pos = pos_cur + offset;
// get ground height there
pos.y = hfinder->getHeightAt(pos.x, pos.z) + ground_offset;
// add the position to the mesh
mo->position(pos);
aab->merge(pos);
mo->textureCoord(l/(Ogre::Real)numSeg.x*uvSeg.x, w/(Ogre::Real)numSeg.y*uvSeg.y);
mo->normal(Vector3::UNIT_Y);
}
}
bool reverse = false;
for (int n1 = 0; n1<numSeg.x; n1++)
{
for (int n2 = 0; n2<numSeg.y; n2++)
{
if (reverse)
{
mo->index(offset+0);
mo->index(offset+(numSeg.y+1));
mo->index(offset+1);
mo->index(offset+1);
mo->index(offset+(numSeg.y+1));
mo->index(offset+(numSeg.y+1)+1);
}
else
{
mo->index(offset+0);
mo->index(offset+1);
mo->index(offset+(numSeg.y+1));
mo->index(offset+1);
mo->index(offset+(numSeg.y+1)+1);
mo->index(offset+(numSeg.y+1));
}
offset++;
}
offset++;
}
offset+=numSeg.y+1;
mo->end();
mo->setBoundingBox(*aab);
// some optimizations
mo->setCastShadows(false);
mo->setDynamic(false);
delete(aab);
MeshPtr mesh = mo->convertToMesh(oname+"_mesh");
// build edgelist
mesh->buildEdgeList();
// remove the manualobject again, since we dont need it anymore
gEnv->ogreSceneManager->destroyManualObject(mo);
unsigned short src, dest;
if (!mesh->suggestTangentVectorBuildParams(VES_TANGENT, src, dest))
{
mesh->buildTangentVectors(VES_TANGENT, src, dest);
}
Entity *ent = gEnv->ogreSceneManager->createEntity(oname+"_ent", oname+"_mesh");
mo_node->attachObject(ent);
mo_node->setVisible(true);
//mo_node->showBoundingBox(true);
mo_node->setPosition(Vector3::ZERO); //(position.x, 0, position.z));
if (!export_fn.empty())
{
MeshSerializer *ms = new MeshSerializer();
ms->exportMesh(mesh.get(), export_fn);
LOG("spline mesh exported as " + export_fn);
delete(ms);
}
// TBD: RTSS
//Ogre::RTShader::ShaderGenerator::getSingleton().createShaderBasedTechnique(materialname, Ogre::MaterialManager::DEFAULT_SCHEME_NAME, Ogre::RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME);
//Ogre::RTShader::ShaderGenerator::getSingleton().invalidateMaterial(RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME, materialname);
RTSSgenerateShadersForMaterial(materialname, "");
#endif
return 0;
}
// Just override the mandatory create scene method
void createScene(void)
{
RenderSystem *rs = Root::getSingleton().getRenderSystem();
const RenderSystemCapabilities* caps = rs->getCapabilities();
if (!caps->hasCapability(RSC_VERTEX_PROGRAM) || !(caps->hasCapability(RSC_FRAGMENT_PROGRAM)))
{
OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "Your card does not support vertex and fragment programs, so cannot "
"run this demo. Sorry!",
"DeferredShading::createScene");
}
if (caps->getNumMultiRenderTargets()<2)
{
OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "Your card does not support at least two simultaneous render targets, so cannot "
"run this demo. Sorry!",
"DeferredShading::createScene");
}
// Prepare athene mesh for normalmapping
MeshPtr pAthene = MeshManager::getSingleton().load("athene.mesh",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
unsigned short src, dest;
if (!pAthene->suggestTangentVectorBuildParams(VES_TANGENT, src, dest))
pAthene->buildTangentVectors(VES_TANGENT, src, dest);
// Prepare knot mesh for normal mapping
pAthene = MeshManager::getSingleton().load("knot.mesh",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
if (!pAthene->suggestTangentVectorBuildParams(VES_TANGENT, src, dest))
pAthene->buildTangentVectors(VES_TANGENT, src, dest);
// Set ambient light
mSceneMgr->setAmbientLight(ColourValue(0.2, 0.2, 0.15));
// Skybox
mSceneMgr->setSkyBox(true, "DeferredDemo/SkyBox");
// Create "root" node
SceneNode* rootNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
Entity* athena = mSceneMgr->createEntity("Athena", "athene.mesh");
athena->setMaterialName("DeferredDemo/DeferredAthena");
SceneNode *aNode = rootNode->createChildSceneNode();
aNode->attachObject( athena );
aNode->setPosition(-100, 40, 100);
// Create a prefab plane
mPlane = new MovablePlane("ReflectPlane");
mPlane->d = 0;
mPlane->normal = Vector3::UNIT_Y;
MeshManager::getSingleton().createCurvedPlane("ReflectionPlane",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
*mPlane,
2000, 2000, -1000,
20, 20,
true, 1, 10, 10, Vector3::UNIT_Z);
mPlaneEnt = mSceneMgr->createEntity( "Plane", "ReflectionPlane" );
mPlaneNode = rootNode->createChildSceneNode();
mPlaneNode->attachObject(mPlaneEnt);
mPlaneNode->translate(-5, -30, 0);
//mPlaneNode->roll(Degree(5));
mPlaneEnt->setMaterialName("DeferredDemo/Ground");
// Create an entity from a model (will be loaded automatically)
Entity* knotEnt = mSceneMgr->createEntity("Knot", "knot.mesh");
knotEnt->setMaterialName("DeferredDemo/RockWall");
knotEnt->setMeshLodBias(0.25f);
// Create an entity from a model (will be loaded automatically)
Entity* ogreHead = mSceneMgr->createEntity("Head", "ogrehead.mesh");
ogreHead->getSubEntity(0)->setMaterialName("DeferredDemo/Ogre/Eyes");// eyes
ogreHead->getSubEntity(1)->setMaterialName("DeferredDemo/Ogre/Skin");
ogreHead->getSubEntity(2)->setMaterialName("DeferredDemo/Ogre/EarRing"); // earrings
ogreHead->getSubEntity(3)->setMaterialName("DeferredDemo/Ogre/Tusks"); // tusks
rootNode->createChildSceneNode( "Head" )->attachObject( ogreHead );
// Add a whole bunch of extra entities to fill the scene a bit
Entity *cloneEnt;
int N=4;
for (int n = 0; n < N; ++n)
{
float theta = 2.0f*Math::PI*(float)n/(float)N;
// Create a new node under the root
SceneNode* node = mSceneMgr->createSceneNode();
// Random translate
Vector3 nodePos;
nodePos.x = Math::SymmetricRandom() * 40.0 + Math::Sin(theta) * 500.0;
nodePos.y = Math::SymmetricRandom() * 20.0 - 40.0;
nodePos.z = Math::SymmetricRandom() * 40.0 + Math::Cos(theta) * 500.0;
node->setPosition(nodePos);
Quaternion orientation(Math::SymmetricRandom(),Math::SymmetricRandom(),Math::SymmetricRandom(),Math::SymmetricRandom());
orientation.normalise();
node->setOrientation(orientation);
rootNode->addChild(node);
// Clone knot
char cloneName[12];
sprintf(cloneName, "Knot%d", n);
cloneEnt = knotEnt->clone(cloneName);
// Attach to new node
node->attachObject(cloneEnt);
}
mCamera->setPosition(-50, 100, 500);
mCamera->lookAt(0,0,0);
// show overlay
Overlay* overlay = OverlayManager::getSingleton().getByName("Example/ShadowsOverlay");
overlay->show();
mSystem = new DeferredShadingSystem(mWindow->getViewport(0), mSceneMgr, mCamera);
// Create main, moving light
MLight* l1 = mSystem->createMLight();//"MainLight");
l1->setDiffuseColour(0.75f, 0.7f, 0.8f);
l1->setSpecularColour(0.85f, 0.9f, 1.0f);
SceneNode *lightNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
lightNode->attachObject(l1);
// Create a track for the light
Animation* anim = mSceneMgr->createAnimation("LightTrack", 16);
// Spline it for nice curves
anim->setInterpolationMode(Animation::IM_SPLINE);
// Create a track to animate the camera's node
NodeAnimationTrack* track = anim->createNodeTrack(0, lightNode);
// Setup keyframes
TransformKeyFrame* key = track->createNodeKeyFrame(0); // A start position
key->setTranslate(Vector3(300,300,-300));
key = track->createNodeKeyFrame(4);//B
key->setTranslate(Vector3(300,300,300));
key = track->createNodeKeyFrame(8);//C
key->setTranslate(Vector3(-300,300,300));
key = track->createNodeKeyFrame(12);//D
key->setTranslate(Vector3(-300,300,-300));
key = track->createNodeKeyFrame(16);//D
key->setTranslate(Vector3(300,300,-300));
// Create a new animation state to track this
SharedData::getSingleton().mAnimState = mSceneMgr->createAnimationState("LightTrack");
SharedData::getSingleton().mAnimState->setEnabled(true);
// Create some happy little lights
createSampleLights();
// safely setup application's (not postfilter!) shared data
SharedData::getSingleton().iCamera = mCamera;
SharedData::getSingleton().iRoot = mRoot;
SharedData::getSingleton().iWindow = mWindow;
SharedData::getSingleton().iActivate = true;
SharedData::getSingleton().iGlobalActivate = true;
SharedData::getSingleton().iSystem = mSystem;
SharedData::getSingleton().iMainLight = l1;
}
void OgreSample18App::createScene()
{
mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_ADDITIVE);
mCurrentShadowTechnique = SHADOWTYPE_STENCIL_ADDITIVE;
// Set ambient light off
mSceneMgr->setAmbientLight(ColourValue(0.0, 0.0, 0.0));
// Fixed light, dim
mSunLight = mSceneMgr->createLight("SunLight");
mSunLight->setType(Light::LT_SPOTLIGHT);
mSunLight->setPosition(1500,1750,1300);
mSunLight->setSpotlightRange(Degree(30), Degree(50));
Ogre::Vector3 dir;
dir = -mSunLight->getPosition();
dir.normalise();
mSunLight->setDirection(dir);
mSunLight->setDiffuseColour(0.35, 0.35, 0.38);
mSunLight->setSpecularColour(0.9, 0.9, 1);
// Point light, movable, reddish
mLight = mSceneMgr->createLight("Light2");
mLight->setDiffuseColour(mMinLightColour);
mLight->setSpecularColour(1, 1, 1);
mLight->setAttenuation(8000,1,0.0005,0);
// Create light node
mLightNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(
"MovingLightNode");
mLightNode->attachObject(mLight);
// create billboard set
BillboardSet* bbs = mSceneMgr->createBillboardSet("lightbbs", 1);
bbs->setMaterialName("Examples/Flare");
Billboard* bb = bbs->createBillboard(0,0,0,mMinLightColour);
// attach
mLightNode->attachObject(bbs);
ControllerFunctionRealPtr func = ControllerFunctionRealPtr(new WaveformControllerFunction(Ogre::WFT_SINE,0.75f,0.5f));
ControllerManager& contMgr = ControllerManager::getSingleton();
ControllerValueRealPtr val = ControllerValueRealPtr(new LightWibbler(mLight,bb,mMinLightColour,mMaxLightColour,mMinFlareSize,mMaxFlareSize));
mController = contMgr.createController(contMgr.getFrameTimeSource(),val,func);
mLightNode->setPosition(Vector3(300,1750,-700));
Animation* anim = mSceneMgr->createAnimation("LightTrack", 20);
// Spline it for nice curves
anim->setInterpolationMode(Animation::IM_SPLINE);
// Create a track to animate the camera's node
NodeAnimationTrack* track = anim->createNodeTrack(0, mLightNode);
// Setup keyframes
TransformKeyFrame* key = track->createNodeKeyFrame(0); // A startposition
key->setTranslate(Vector3(300,750,-700));
key = track->createNodeKeyFrame(2);//B
key->setTranslate(Vector3(150,800,-250));
key = track->createNodeKeyFrame(4);//C
key->setTranslate(Vector3(-150,850,-100));
key = track->createNodeKeyFrame(6);//D
key->setTranslate(Vector3(-400,700,-200));
key = track->createNodeKeyFrame(8);//E
key->setTranslate(Vector3(-200,700,-400));
key = track->createNodeKeyFrame(10);//F
key->setTranslate(Vector3(-100,850,-200));
key = track->createNodeKeyFrame(12);//G
key->setTranslate(Vector3(-100,575,180));
key = track->createNodeKeyFrame(14);//H
key->setTranslate(Vector3(0,750,300));
key = track->createNodeKeyFrame(16);//I
key->setTranslate(Vector3(100,850,100));
key = track->createNodeKeyFrame(18);//J
key->setTranslate(Vector3(250,800,0));
key = track->createNodeKeyFrame(20);//K == A
key->setTranslate(Vector3(300,750,-700));
// Create a new animation state to track this
mAnimState = mSceneMgr->createAnimationState("LightTrack");
mAnimState->setEnabled(true);
mLightNode->setAutoTracking(true,mSceneMgr->getRootSceneNode());
MeshPtr pAthene = MeshManager::getSingleton().load("athene.mesh",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
unsigned short src, dest;
if (!pAthene->suggestTangentVectorBuildParams(VES_TANGENT, src, dest))
{
pAthene->buildTangentVectors(VES_TANGENT, src, dest);
}
SceneNode* node;
node = mSceneMgr->getRootSceneNode()->createChildSceneNode();
mAthene = mSceneMgr->createEntity( "athene", "athene.mesh" );
mAthene->setMaterialName(BASIC_ATHENE_MATERIAL);
node->attachObject( mAthene );
node->yaw(Degree(90));
Entity* pEnt;
// Columns
for (int x = -2; x <= 2; ++x)
{
for (int z = -2; z <= 2; ++z)
{
if (x != 0 || z != 0)
{
StringUtil::StrStreamType str;
str << "col" << x << "_" << z;
node = mSceneMgr->getRootSceneNode()->createChildSceneNode();
pEnt = mSceneMgr->createEntity( str.str(), "column.mesh" );
pEnt->setMaterialName(BASIC_ROCKWALL_MATERIAL);
pColumns.push_back(pEnt);
node->attachObject( pEnt );
node->translate(x*300,0, z*300);
}
}
}
// Skybox
mSceneMgr->setSkyBox(true, "Examples/StormySkyBox");
// Floor plane (use POSM plane def)
mPlane = new MovablePlane("*mPlane");
mPlane->normal = Vector3::UNIT_Y;
mPlane->d = 107;
MeshManager::getSingleton().createPlane("Myplane",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, *mPlane,
1500,1500,50,50,true,1,5,5,Vector3::UNIT_Z);
pPlaneEnt = mSceneMgr->createEntity( "plane", "Myplane" );
pPlaneEnt->setMaterialName(BASIC_ROCKWALL_MATERIAL);
pPlaneEnt->setCastShadows(false);
mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(pPlaneEnt);
if (mRoot->getRenderSystem()->getCapabilities()->hasCapability(RSC_HWRENDER_TO_TEXTURE))
{
mSceneMgr->setShadowTextureSettings(1024,2);
}
else
{
mSceneMgr->setShadowTextureSettings(512,2);
}
mSceneMgr->setShadowColour(ColourValue(0.5f,0.5f,0.5f));
//handles;
resetMaterials();
materialChanged(0);
configureLights(ShadowTechnique::SHADOWTYPE_STENCIL_MODULATIVE);
}
//-----------------------------------------------------------------------
void Shadows::createTestScene(bool useOgreMaterials)
{
Ogre::String planeMatName, knotMatName;
if(useOgreMaterials)
{
planeMatName = "PSSM/Plane";
knotMatName = "PSSM/Knot";
}
else
{
planeMatName = "PSSMPlane";
knotMatName = "PSSMKnot";
}
// temp
planeMatName = "ESM/Plane";
knotMatName = "ESM/Knot";
SceneManager* sceneMgr = getSceneManager();
/*
sceneMgr->setAmbientLight(ColourValue(0.3, 0.3, 0.3));
Light* l = sceneMgr->createLight("Spot");
l->setType(Light::LT_SPOTLIGHT);
Vector3 dir(0.3, -1, 0.2);
dir.normalise();
l->setDirection(dir);
l->setDiffuseColour(ColourValue(1.0, 1.0, 0.0, 1));
l->setPosition(0, 25.0, 2.0);
l->setSpotlightRange((Radian) 0.104, (Radian) 1.40, 1);
l->setAttenuation(50, 1.0, 0.009, 0.0032);
*/
// Create a basic plane to have something in the scene to look at
Plane plane;
plane.normal = Vector3::UNIT_Y;
plane.d = 100;
MeshPtr msh = MeshManager::getSingleton().createPlane("Myplane",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane,
4500,4500,100,100,true,1,40,40,Vector3::UNIT_Z);
msh->buildTangentVectors(VES_TANGENT);
Entity* pPlaneEnt;
pPlaneEnt = sceneMgr->createEntity( "plane", "Myplane" );
pPlaneEnt->setMaterialName(planeMatName);
sceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(pPlaneEnt);
Entity* ent = sceneMgr->createEntity("knot", "knot.mesh");
ent->setMaterialName(knotMatName);
createRandomEntityClones(ent, 20, Vector3(-100,0,-100), Vector3(100,0,100));
SceneNode* node = sceneMgr->getRootSceneNode()->createChildSceneNode();
node->attachObject(ent);
//node->setPosition(Vector3(0, 0, 0));
for(int i=0; i<sceneMgr->getRootSceneNode()->numChildren(); i++)
{
Node* node = sceneMgr->getRootSceneNode()->getChild(i);
node->setScale(0.05f, 0.05f, 0.05f);
}
}
void TunnelSlice::connect(TunnelSlice* next)
{
float wallLength1 = getWallLength();
float wallLength2 = next->getWallLength();
int tempID = intermediateMeshID;
entireIntermediate = parentNode->createChildSceneNode("intermediateSegmentNode" + Util::toStringInt(intermediateMeshID));
std::string meshName = "intermediateMesh" + Util::toStringInt(intermediateMeshID);
ManualObject* manual = parentNode->getCreator()->createManualObject(meshName);
Quaternion q1 = getQuaternion();
Quaternion q2 = next->getQuaternion();
Vector3 start = center + getForward() * (depth / 2);
Vector3 end = next->center - next->getForward() * (next->depth / 2);
Vector3 move;
Vector3 p1;
Vector3 p2;
Vector3 p3;
Vector3 p4;
Vector3 bl = Vector3(Ogre::Math::POS_INFINITY, Ogre::Math::POS_INFINITY, Ogre::Math::POS_INFINITY);
Vector3 tr = Vector3(Ogre::Math::NEG_INFINITY, Ogre::Math::NEG_INFINITY, Ogre::Math::NEG_INFINITY);
move = Vector3(-wallLength1 * (0.5 + Math::Cos(Ogre::Radian(Math::PI) / 4)), wallLength1 / 2, 0);
move = q1 * move;
p1 = start + move;
move = Vector3(-wallLength2 * (0.5 + Math::Cos(Ogre::Radian(Math::PI) / 4)), wallLength2 / 2, 0);
move = q2 * move;
p2 = end + move;
move = Vector3(-wallLength2 / 2, wallLength2 * (0.5 + Math::Sin(Ogre::Radian(Math::PI) / 4)), 0);
move = q2 * move;
p3 = end + move;
move = Vector3(-wallLength1 / 2, wallLength1 * (0.5 + Math::Sin(Ogre::Radian(Math::PI) / 4)), 0);
move = q1 * move;
p4 = start + move;
if (sidesUsed[NORTHWEST])
setIntermediateWall(entireIntermediate, NORTHWEST, manual, p1, p2, p3, p4, bl, tr);
p1 = p4;
p2 = p3;
move = Vector3(wallLength2 / 2, wallLength2 * (0.5 + Math::Sin(Ogre::Radian(Math::PI) / 4)), 0);
move = q2 * move;
p3 = end + move;
move = Vector3(wallLength1 / 2, wallLength1 * (0.5 + Math::Sin(Ogre::Radian(Math::PI) / 4)), 0);
move = q1 * move;
p4 = start + move;
if (sidesUsed[NORTH])
setIntermediateWall(entireIntermediate, NORTH, manual, p1, p2, p3, p4, bl, tr);
p1 = p4;
p2 = p3;
move = Vector3(wallLength2 * (0.5 + Math::Cos(Ogre::Radian(Math::PI) / 4)), wallLength2 / 2, 0);
move = q2 * move;
p3 = end + move;
move = Vector3(wallLength1 * (0.5 + Math::Cos(Ogre::Radian(Math::PI) / 4)), wallLength1 / 2, 0);
move = q1 * move;
p4 = start + move;
if (sidesUsed[NORTHEAST])
setIntermediateWall(entireIntermediate, NORTHEAST, manual, p1, p2, p3, p4, bl, tr);
p1 = p4;
p2 = p3;
move = Vector3(wallLength2 * (0.5 + Math::Cos(Ogre::Radian(Math::PI) / 4)), -wallLength2 / 2, 0);
move = q2 * move;
p3 = end + move;
move = Vector3(wallLength1 * (0.5 + Math::Cos(Ogre::Radian(Math::PI) / 4)), -wallLength1 / 2, 0);
move = q1 * move;
p4 = start + move;
if (sidesUsed[EAST])
setIntermediateWall(entireIntermediate, EAST, manual, p1, p2, p3, p4, bl, tr);
p1 = p4;
p2 = p3;
move = Vector3(wallLength2 / 2, -wallLength2 * (0.5 + Math::Sin(Ogre::Radian(Math::PI) / 4)), 0);
move = q2 * move;
p3 = end + move;
move = Vector3(wallLength1 / 2, -wallLength1 * (0.5 + Math::Sin(Ogre::Radian(Math::PI) / 4)), 0);
move = q1 * move;
p4 = start + move;
if (sidesUsed[SOUTHEAST])
setIntermediateWall(entireIntermediate, SOUTHEAST, manual, p1, p2, p3, p4, bl, tr);
p1 = p4;
p2 = p3;
move = Vector3(-wallLength2 / 2, -wallLength2 * (0.5 + Math::Sin(Ogre::Radian(Math::PI) / 4)), 0);
move = q2 * move;
p3 = end + move;
move = Vector3(-wallLength1 / 2, -wallLength1 * (0.5 + Math::Sin(Ogre::Radian(Math::PI) / 4)), 0);
move = q1 * move;
p4 = start + move;
if (sidesUsed[SOUTH])
setIntermediateWall(entireIntermediate, SOUTH, manual, p1, p2, p3, p4, bl, tr);
p1 = p4;
p2 = p3;
move = Vector3(-wallLength2 * (0.5 + Math::Cos(Ogre::Radian(Math::PI) / 4)), -wallLength2 / 2, 0);
move = q2 * move;
p3 = end + move;
move = Vector3(-wallLength1 * (0.5 + Math::Cos(Ogre::Radian(Math::PI) / 4)), -wallLength1 / 2, 0);
move = q1 * move;
p4 = start + move;
if (sidesUsed[SOUTHWEST])
setIntermediateWall(entireIntermediate, SOUTHWEST, manual, p1, p2, p3, p4, bl, tr);
p1 = p4;
p2 = p3;
move = Vector3(-wallLength1 * (0.5 + Math::Cos(Ogre::Radian(Math::PI) / 4)), wallLength1 / 2, 0);
move = q2 * move;
p3 = end + move;
move = Vector3(-wallLength2 * (0.5 + Math::Cos(Ogre::Radian(Math::PI) / 4)), wallLength2 / 2, 0);
move = q1 * move;
p4 = start + move;
if (sidesUsed[WEST])
setIntermediateWall(entireIntermediate, WEST, manual, p1, p2, p3, p4, bl, tr);
MeshPtr mesh = manual->convertToMesh(meshName);
mesh->_setBounds( AxisAlignedBox( bl, tr ), true );
float l = (tr - bl).length() / 2;
mesh->_setBoundingSphereRadius(l);
unsigned short src, dest;
if (!mesh->suggestTangentVectorBuildParams(VES_TANGENT, src, dest))
{
mesh->buildTangentVectors(VES_TANGENT, src, dest);
}
Entity* intermediateSegmentEntity = entireIntermediate->getCreator()->createEntity("intermediateSegmentEntity" + Util::toStringInt(intermediateMeshID), meshName);
//intermediateSegmentEntity->setMaterialName(getMaterialName());
for (int i = 0; i < intermediateSegmentEntity->getNumSubEntities(); ++i)
intermediateSegmentEntity->getSubEntity(i)->setMaterialName(getMaterialName());
entireIntermediate->attachObject(intermediateSegmentEntity);
meshes.push_back(mesh);
intermediateMeshID++;
parentNode->getCreator()->destroyManualObject(manual);
}