void
TestScene5::runOgre()
{
// initialize framework & open window
Ogre::Root* root = new Ogre::Root();
root->restoreConfig();
root->initialise(false);
auto window = root->createRenderWindow("Ogre RenderWindow", 800, 600, false);
auto sceneMgr = root->createSceneManager(Ogre::ST_GENERIC);
// adjust camera
auto cam1 = sceneMgr->createCamera("cam1");
auto camNode1 = sceneMgr->getRootSceneNode()->createChildSceneNode("camnode1");
cam1->setNearClipDistance(5);
camNode1->attachObject(cam1);
camNode1->setPosition(100, 100, 100);
camNode1->lookAt(Ogre::Vector3(-1, -1, -1), Ogre::Node::TS_LOCAL);
window->addViewport(cam1);
// load & integrate model
root->addResourceLocation("./resources/Ogre", "FileSystem");
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
auto model = sceneMgr->createEntity("model", "alexandria.mesh");
auto modelNode = sceneMgr->getRootSceneNode()->createChildSceneNode();
modelNode->attachObject(model);
// position model
modelNode->setPosition(-100, -100, -100);
// loop
runOgreLoop(root);
}
//-----------------------------------------------------------------------
// Update all the zone info for a given node. This function
// makes sure the home zone of the node is correct, and references
// to any zones it is visiting are added and a reference to the
// node is added to the visitor lists of any zone it is visiting.
//
void PCZSceneManager::_updatePCZSceneNode( PCZSceneNode * pczsn )
{
// Skip if root Zone has been destroyed (shutdown conditions)
if (!mDefaultZone)
return;
// Skip if the node is the sceneroot node
if (pczsn == getRootSceneNode())
return;
// clear all references to visiting zones
pczsn->clearNodeFromVisitedZones();
// Find the current home zone of the node associated with the pczsn entry.
_updateHomeZone( pczsn, false );
/* The following function does the following:
* 1) Check all portals in the home zone - if the node is touching the portal
* then add the node to the connected zone as a visitor
* 2) Recurse into visited zones in case the node spans several zones
*/
// (recursively) check each portal of home zone to see if the node is touching
if (pczsn->getHomeZone() &&
pczsn->allowedToVisit() == true)
{
pczsn->getHomeZone()->_checkNodeAgainstPortals(pczsn, 0);
}
// update zone-specific data for the node for any zones that require it
pczsn->updateZoneData();
}
Box::Box( PhysicsScene* scene, const Vector3& size, const Vector3& position, const Quaternion& orientation ): Primitive( scene )
{
PxPhysics& physics = mScene->getScene()->getPhysics();
PxTransform transform;
transform.p = Math::ogreVec3ToPx( position );
transform.q = Math::ogreQtToPx( orientation );
PxBoxGeometry geometry;
geometry.halfExtents = Math::ogreVec3ToPx( size / 2.0f );
mActor = PxCreateStatic( physics, transform, geometry, *scene->getDefaultMaterial() );
if ( !mActor )
ENGINE_EXCEPT( "Could not create physics box actor" );
mScene->getScene()->addActor( *mActor );
mMesh = Procedural::BoxGenerator().setSize( size ).realizeMesh();
auto scm = Locator::getGraphics().getScene();
mNode = scm->getRootSceneNode()->createChildSceneNode();
mItem = Locator::getGraphics().getScene()->createItem( mMesh );
mItem->setQueryFlags( SceneQueryFlag_World );
mItem->setDatablock( "Developer/Floor" );
mItem->setCastShadows( true );
mNode->attachObject( mItem );
mNode->setPosition( position );
mNode->setOrientation( orientation );
}
//-------------------------------------------------------------------------
void TerrainSceneManager::setupTerrainPages(void)
{
//create a root terrain node.
if (!mTerrainRoot)
mTerrainRoot = getRootSceneNode() -> createChildSceneNode( "Terrain" );
//setup the page array.
unsigned short pageSlots = 1 + (mBufferedPageMargin * 2);
unsigned short i, j;
for (i = 0; i < pageSlots; ++i)
{
mTerrainPages.push_back(TerrainPageRow());
for (j = 0; j < pageSlots; ++j)
{
mTerrainPages[i].push_back(0);
}
}
// If we're not paging, load immediate for convenience
if ( mActivePageSource && !mPagingEnabled )
mActivePageSource->requestPage(0,0);
}
void fakeHaskell()
{
DemoApp* da = initDemo();
Ogre::SceneManager* sm = getSceneManager();
Ogre::SceneNode* rnode = getRootSceneNode(sm);
/* OgreFramework::getSingletonPtr()->m_pSceneMgr->setSkyBox(true, "Examples/SpaceSkyBox");
m_pCubeEntity = OgreFramework::getSingletonPtr()->m_pSceneMgr->createEntity("Cube", "ogrehead.mesh");
m_pCubeNode = OgreFramework::getSingletonPtr()->m_pSceneMgr->getRootSceneNode()->createChildSceneNode("CubeNode");
m_pCubeNode->attachObject(m_pCubeEntity);
m_pCube2E = OgreFramework::getSingletonPtr()->m_pSceneMgr->createEntity("Steve", Ogre::SceneManager::PT_CUBE);
m_pCube2N = OgreFramework::getSingletonPtr()->m_pSceneMgr->getRootSceneNode()->createChildSceneNode("SteveN");
m_pCube2N->attachObject(m_pCube2E);*/
setSkybox(sm, true, "Examples/SpaceSkyBox");
Ogre::Entity* cubeEntity = createEntity(sm, "Cube", "ogrehead.mesh");
Ogre::SceneNode* cubeNode = createChildSceneNode(rnode, "CubeNode");
attachObject(cubeNode, cubeEntity);
finishSetupAndRun(da);
}
void SingleplayerGame::createScene(std::vector<std::string> partyNames){
auto scnMgr = mRenderer->mSceneManager;
auto root = scnMgr->getRootSceneNode();
Ogre::Camera* camera = mRenderer->mCamera;
mRoomRoot = root->createChildSceneNode();
scnMgr->setSkyBox(true, "Examples/MorningSkyBox", 5000, true);
// Set ambient light
scnMgr->setAmbientLight(Ogre::ColourValue(0.3, 0.3, 0.3));
scnMgr->setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_ADDITIVE);
// Create a light
mMainLight = scnMgr->createLight(BaseGame::mainLightName);
mMainLight->setPosition(0, 500, 0);
mMainLight->setType(Ogre::Light::LT_POINT);
mMainLight->setDiffuseColour(.5, .5, .5);
// Create ground plane
ground = new Plane(scnMgr, mRoomRoot);
// Add test objects
Player* p = new Player(scnMgr, mRoomRoot,
mPlayerBank->getPlayerInfo(partyNames[0]),
Ogre::Vector3(500, 0, 200), mSoundBank);
myParty.push_back(p);
Player* p2 = new Player(scnMgr, mRoomRoot,
mPlayerBank->getPlayerInfo(partyNames[1]),
Ogre::Vector3(500, 0, 0), mSoundBank);
myParty.push_back(p2);
Player* p3 = new Player(scnMgr, mRoomRoot,
mPlayerBank->getPlayerInfo(partyNames[2]),
Ogre::Vector3(500, 0, -200), mSoundBank);
myParty.push_back(p3);
Player* p4 = new Player(scnMgr, mRoomRoot,
mPlayerBank->getPlayerInfo("Mecha-Scoot"),
Ogre::Vector3(-500, 0, 200), mSoundBank);
enemyParty.push_back(p4);
Player* p5 = new Player(scnMgr, mRoomRoot,
mPlayerBank->getPlayerInfo("SSJVirginia"),
Ogre::Vector3(-500, 0, 0), mSoundBank);
enemyParty.push_back(p5);
Player* p6 = new Player(scnMgr, mRoomRoot,
mPlayerBank->getPlayerInfo("Metal Scoot"),
Ogre::Vector3(-500, 0, -200), mSoundBank);
enemyParty.push_back(p6);
// Set Camera Position
cameraInitialPosition = Ogre::Vector3(1100, 250, 700);
cameraInitialLookAt = Ogre::Vector3(0, 0, 0);
camera->setPosition(cameraInitialPosition);
camera->lookAt(cameraInitialLookAt);
}
void SceneManager::renderScene(Viewport* vp, Camera* cam) {
assert(mRenderer != NULL);
mRenderer->clearRenderQueues();
// Find visible scene objects and insert them into the render queues.
getRootSceneNode()->findVisibleObjects(cam);
assert(mRenderer != NULL);
mRenderer->render(vp, cam);
}
void
TestScene12::runOgre()
{
// initialize framework & open window
Ogre::Root* root = new Ogre::Root();
root->restoreConfig();
root->initialise(false);
auto window = root->createRenderWindow("Ogre RenderWindow", 800, 600, false);
auto sceneMgr = root->createSceneManager(Ogre::ST_GENERIC);
// adjust camera
auto cam1 = sceneMgr->createCamera("cam1");
auto camNode1 = sceneMgr->getRootSceneNode()->createChildSceneNode("camnode1");
cam1->setNearClipDistance(5);
camNode1->attachObject(cam1);
camNode1->setPosition(Ogre::Vector3(100, 100, 100));
camNode1->lookAt(Ogre::Vector3(-1, -1, -1), Ogre::Node::TS_LOCAL);
window->addViewport(cam1);
// load & integrate model
root->addResourceLocation("./resources/Ogre", "FileSystem");
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
Mesh_Cube M(1);
M.createMesh("cube");
Ogre::SceneNode* groups[ROWS];
std::list<Ogre::SceneNode*> nodes;
for (int i = 0; i < ROWS; i++)
{
groups[i] = sceneMgr->getRootSceneNode()->createChildSceneNode();
nodes.push_back(groups[i]);
}
for (int i = 0; i < ROWS * COLS; i++)
{
auto node = groups[i % ROWS]->createChildSceneNode();
node->attachObject(sceneMgr->createEntity(std::string("model") + boost::lexical_cast<std::string>(i), "cube"));
node->setPosition(
camNode1->getOrientation() * -Ogre::Vector3::UNIT_X * LEFT(i)
+ camNode1->getOrientation() * Ogre::Vector3::UNIT_Y * UP(i)
);
}
root->addFrameListener(new MoveObjectTask_Ogre12(nodes));
// loop
runOgreLoop(root);
}
PhysicDebugGraphicObject::PhysicDebugGraphicObject(ISystemScene& pSystemScene, UObject& entity,
const Schema::SystemComponent& component)
: ISystemObject(&pSystemScene, &entity, component) {
auto sceneManager = GetSystemScene<GraphicScene>()->getSceneManager();
lines_ = sceneManager->createManualObject();
lines_->begin("BaseWhiteNoLighting", Ogre::RenderOperation::OT_LINE_LIST);
lines_->position(Ogre::Vector3::ZERO);
lines_->position(Ogre::Vector3::ZERO);
lines_->end();
sceneManager->getRootSceneNode()->attachObject(lines_);
}
//-----------------------------------------------------------------------
void PCZSceneManager::clearScene(void)
{
destroyAllStaticGeometry();
destroyAllMovableObjects();
// Clear root node of all children
getRootSceneNode()->removeAllChildren();
getRootSceneNode()->detachAllObjects();
// Delete all SceneNodes, except root that is
for (SceneNodeList::iterator i = mSceneNodes.begin();
i != mSceneNodes.end(); ++i)
{
OGRE_DELETE i->second;
}
mSceneNodes.clear();
mAutoTrackingSceneNodes.clear();
// delete all the zones
for (ZoneMap::iterator j = mZones.begin();
j != mZones.end(); ++j)
{
OGRE_DELETE j->second;
}
mZones.clear();
mDefaultZone = 0;
// Clear animations
destroyAllAnimations();
// Remove sky nodes since they've been deleted
mSkyBoxNode = mSkyPlaneNode = mSkyDomeNode = 0;
mSkyBoxEnabled = mSkyPlaneEnabled = mSkyDomeEnabled = false;
// Clear render queue, empty completely
if (mRenderQueue)
mRenderQueue->clear(true);
// re-initialize
init(mDefaultZoneTypeName, mDefaultZoneFileName);
}
void SceneManager::clearSceneNodes() {
getRootSceneNode()->removeAllChildren();
for (SceneNodeMap::iterator iter = mSceneNodes.begin();
iter != mSceneNodes.end(); ++iter) {
delete iter->second;
}
mSceneNodes.clear();
if (mSceneGraph.root) {
delete mSceneGraph.root;
mSceneGraph.root = NULL;
}
}
SceneNode* SceneManager::getSceneNode(const string& name) {
// Early termination for camera node.
SceneNode* node = getCameraNode(name);
if (node) {
return node;
}
SceneNodeIterator iter(getRootSceneNode());
while(iter.hasNext()) {
SceneNode& node = *iter;
const string& nodeName = node.getName();
const NodeID& nodeID = node.getID();
if (nodeName == node.createName(nodeID, name)) {
return iter.current();
}
iter.advance();
}
return NULL;
}
void
TestScene3::runOgre()
{
// initialize framework & open window
Ogre::Root* root = new Ogre::Root();
root->restoreConfig();
root->initialise(false);
auto window = root->createRenderWindow("Ogre RenderWindow", 800, 600, false);
auto sceneMgr = root->createSceneManager(Ogre::ST_GENERIC);
// adjust camera
auto cam1 = sceneMgr->createCamera("cam1");
auto camNode1 = sceneMgr->getRootSceneNode()->createChildSceneNode("camnode1");
cam1->setNearClipDistance(5);
camNode1->attachObject(cam1);
camNode1->setPosition(100, 100, 100);
camNode1->lookAt(Ogre::Vector3(-1, -1, -1), Ogre::Node::TS_LOCAL);
window->addViewport(cam1);
// loop
runOgreLoop(root);
}
Plane::Plane( PhysicsScene* scene, const Ogre::Plane& plane,
const Real width, const Real height, const Vector3& position, const Real u, const Real v ):
Primitive( scene )
{
PxPhysics& physics = mScene->getScene()->getPhysics();
mActor = PxCreatePlane( physics,
PxPlane( Glacier::Math::ogreVec3ToPx( plane.normal ), plane.d ),
*mScene->getDefaultMaterial() );
if ( !mActor )
ENGINE_EXCEPT( "Could not create physics plane actor" );
mScene->getScene()->addActor( *mActor );
Ogre::v1::MeshPtr planeMeshV1 = Ogre::v1::MeshManager::getSingleton().createPlane(
"",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
plane, width, height,
1, 1, true, 1, u, v, Ogre::Vector3::UNIT_Z,
Ogre::v1::HardwareBuffer::HBU_STATIC,
Ogre::v1::HardwareBuffer::HBU_STATIC );
mMesh = Ogre::MeshManager::getSingleton().createManual( "", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );
mMesh->importV1( planeMeshV1.get(), true, true, true );
// mMesh = Procedural::PlaneGenerator().setEnableNormals( true ).setSize( Vector2( width, height ) ).setNormal( plane.normal ).setNumSegX( 8 ).setNumSegY( 8 ).setUTile( u ).setVTile( v ).realizeMesh();
auto scm = Locator::getGraphics().getScene();
mNode = scm->getRootSceneNode()->createChildSceneNode();
mItem = scm->createItem( mMesh );
mItem->setQueryFlags( SceneQueryFlag_World );
mItem->setDatablock( "GameTextures/TileLargeHexagon" );
mItem->setCastShadows( false );
mNode->attachObject( mItem );
mNode->setPosition( position );
mNode->setOrientation( Quaternion::IDENTITY );
}
bool PlaneNodeProcessor::processNode(DOMElement *nodeElem, bool loadGameObjects)
{
if (!hasNodeName(nodeElem, "plane"))
{
return false;
}
Ogre::String entName = getAttributeValueAsStdString(nodeElem, "name");
LOG_DEBUG(Logger::RULES,
"Processing plane node "
+ entName);
if(entName=="")
{
entName = getRandomName("Plane");
}
Quaternion orientation(Quaternion::IDENTITY);
Vector3 position(Vector3::ZERO);
Vector2 scale(1,1);
DOMElement* oriElem = getChildNamed(nodeElem, "rotation");
if (oriElem != NULL)
{
orientation = processQuaternion(oriElem);
}
else
{
LOG_WARNING(Logger::RULES, "No orientation given for plane, used Identity");
}
DOMElement* posElem = getChildNamed(nodeElem, "position");
if (posElem != NULL)
{
position = processVector3(posElem);
}
else
{
LOG_WARNING(Logger::RULES, "No position given for plane, used (0,0,0)");
}
DOMElement* scaleElem = getChildNamed(nodeElem, "scale");
if (posElem != NULL)
{
scale = processVector2(scaleElem);
}
else
{
LOG_WARNING(Logger::RULES, "No scale given for plane, used (0,0)");
}
while(!MeshManager::getSingleton().getByName(entName).isNull())
{
entName = getRandomName("Plane");
}
SceneNode* node = getRootSceneNode()->createChildSceneNode(entName + "Node", position, orientation);
MovablePlane* plane = new MovablePlane(entName + "Plane");
plane->d = 0;
plane->normal = Vector3::UNIT_Y;
MeshManager::getSingleton().createPlane(entName + "Mesh", "custom", *plane, scale.x, scale.y, 10, 10, true, 1, 1, 1, Vector3::UNIT_Z);
Entity* ent = CoreSubsystem::getSingleton().getWorld()->getSceneManager()->createEntity(entName, entName + "Mesh");
LOG_DEBUG(Logger::RULES, " Loaded plane "+entName);
node->attachObject(ent);
node->attachObject(plane);
//node->scale(scale.x,1,scale.y);
createCollision(ent, getChildNamed(nodeElem, "physicsproxy"));
DOMElement* materialElem = getChildNamed(nodeElem, "material");
if(materialElem)
{
if(getChildNamed(nodeElem, "renderToTexture"))
{
Ogre::String matName = getAttributeValueAsStdString(materialElem, "name");
MaterialPtr material = static_cast<MaterialPtr>(MaterialManager::getSingleton().getByName(matName))->clone(matName + entName);
createRenderToTextures(ent, plane, material, getChildNamed(nodeElem, "renderToTexture"));
ent->setMaterialName(matName + entName);
}
else
ent->setMaterialName(getAttributeValueAsStdString(materialElem, "name"));
}
else
{
LOG_WARNING(Logger::RULES, "No material given for plane "+entName);
}
return true;
}
void PCZSceneManager::init( const String &defaultZoneTypeName,
const String &filename)
{
// delete ALL portals
Portal * p;
PortalList::iterator i = mPortals.begin();
for (i = mPortals.begin(); i != mPortals.end(); i++)
{
p = *i;
OGRE_DELETE p;
}
mPortals.clear();
// delete all the zones
for (ZoneMap::iterator j = mZones.begin();
j != mZones.end(); ++j)
{
OGRE_DELETE j->second;
}
mZones.clear();
mFrameCount = 0;
mDefaultZoneTypeName = defaultZoneTypeName;
mDefaultZoneFileName = filename;
// create a new default zone
mZoneFactoryManager = PCZoneFactoryManager::getSingletonPtr();
mDefaultZone = createZoneFromFile(mDefaultZoneTypeName, "Default_Zone", (PCZSceneNode*)getRootSceneNode(), mDefaultZoneFileName);
}
void MainApplication::createScene(void)
{
// Application global configuration
GlobalConfiguration::setup("../data/xml/hot_config.xml", m_sceneManager, m_trayManager) ;
// Creates the instance of collision detector
new Triggers::SweepAndPrune ;
//new Triggers::BasicCollisionDetector ;
GlobalConfiguration::setCurrentMap("map01") ;
creerChemin("map01");
// create your scene here :)
::std::cout<<"Creating scene..."<<::std::flush ;
// 0- Sets the camera style
//m_cameraManager->setStyle(OgreBites::CS_ORBIT) ; //OgreBites::CS_MANUAL) ;
// 1- Sets the shadows (shadow volumes)
// ------------------------------------
m_sceneManager->setShadowTechnique(Ogre::SHADOWTYPE_NONE) ; // No shadows
//m_sceneManager->setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_MODULATIVE) ; ////Ogre::SHADOWTYPE_STENCIL_ADDITIVE) ;//
//////m_sceneManager->setShadowDirectionalLightExtrusionDistance(10000000) ;
//m_sceneManager->setShadowIndexBufferSize(500000) ;
//m_sceneManager->setShadowColour(::Ogre::ColourValue(.3,.3,.3)) ;
//////m_sceneManager->setShowDebugShadows(true) ;
m_camera->setFarClipDistance(Ogre::Real(3000)) ;
m_camera->setNearClipDistance(Ogre::Real(0.01)) ;
// 2- Sets fog
// -----------
m_sceneManager->setFog(Ogre::FOG_LINEAR, Ogre::ColourValue(Ogre::Real(0.0), Ogre::Real(0.0), Ogre::Real(0.0)), Ogre::Real(0.03), Ogre::Real(2000.0), Ogre::Real(3000.0)) ;
// 3- Adds lights
Ogre::Light * light = m_sceneManager->createLight("light1siga") ;
light->setType(Ogre::Light::LT_DIRECTIONAL) ;
Ogre::Vector3 direction(-10.0, -10.0, -1.0) ;
direction.normalise() ;
light->setDirection(direction) ;
light->setDiffuseColour(0.5,0.5,0.5) ;
light->setSpecularColour(0.5, 0.5, 0.5) ;
m_sceneManager->setAmbientLight(::Ogre::ColourValue(0.5,0.5,0.5)) ;
m_sceneManager->getRootSceneNode()->attachObject(light) ;
// Gets the root scene node
Ogre::SceneNode * rootSceneNode = getRootSceneNode() ;
// Setups the picking
//m_picking = new PickingBoundingBox(m_sceneManager, m_camera, OIS::MB_Left) ;
m_picking = new PickingSelectionBuffer(m_window, m_sceneManager, m_camera, OIS::MB_Left) ;
// Setups the camera control system
m_cameraManager = new RTSCameraManager(m_sceneManager, m_camera, &m_keyboardState) ;
//TEST de DIJKSTRA
/*Math::Vector2<Config::Real> my_position(0,0);
Math::Vector2<Config::Real> target_position(10,15);
std::vector<Math::Vector2<Config::Real>> chemin;
if(GlobalConfiguration::getCurrentMap()->isValid(target_position))
{
calc_chemin(GlobalConfiguration::getCurrentMap(),my_position,target_position,chemin);
}
else{std::cout << "position non valide" <<std::endl;}
std::cout << "/////////////////////////////////////////////////////////////////" << std::endl;
std::cout << "Chemin : " << std::endl;
for(int i=0;i<chemin.size();i++)
{
std::cout << chemin[i] << std::endl;
}
std::cout << "/////////////////////////////////////////////////////////////////" << std::endl;*/
}
void OverhangTerrainSceneManager::initialise()
{
_pRoot = getRootSceneNode() -> createChildSceneNode( "Terrain" );
}
// Update scene graph.
void SceneManager::updateScene(const float secondsPassed) {
getRootSceneNode()->update(secondsPassed);
}
