/*
* Create a fake Plane for Drag and Drop
*/
void MyFrameListener::createBackGround() {
Ogre::SceneManager* mSceneMgr = Ogre::Root::getSingleton().
getSceneManager("mainSM");
Ogre::Plane *mPlane = new Ogre::Plane(Ogre::Vector3::UNIT_Z, -2);
Ogre::MeshManager::getSingleton().createPlane("backPlane",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
*mPlane,800, 800, 20, 20, true, 1, 5, 5
, Ogre::Vector3::UNIT_Y);
Ogre::Entity* plane = mSceneMgr->createEntity("backPlane");
plane->setQueryFlags(PLANE_DRAG_DROP);
plane->setMaterialName("sheet");
Ogre::Root::getSingleton().
getSceneManager("mainSM")->getRootSceneNode()->
attachObject(plane);
}
EntityWorldPickListenerVisualizer::EntityWorldPickListenerVisualizer(EntityWorldPickListener& pickListener, Ogre::SceneManager& sceneManager) :
mEntity(0), mDebugNode(0)
{
mDebugNode = sceneManager.getRootSceneNode()->createChildSceneNode();
try {
mEntity = sceneManager.createEntity("pickerDebugObject", "common/primitives/model/sphere.mesh");
//start out with a normal material
mEntity->setMaterialName("BasePointMarkerMaterial");
mEntity->setRenderingDistance(300);
mEntity->setQueryFlags(MousePicker::CM_NONPICKABLE);
mDebugNode->attachObject(mEntity);
} catch (const std::exception& ex) {
S_LOG_WARNING("Error when creating picking visualizer." << ex);
}
pickListener.EventPickedEntity.connect(sigc::mem_fun(*this, &EntityWorldPickListenerVisualizer::picker_EventPickedEntity));
}
OgreWheel* OgreWheel::createOgreWheel(Ogre::SceneNode* parNode, Ogre::Vector3 pos)
{
if (parNode)
{
OgreWheel* wheel = new OgreWheel();
wheel->mParNode = parNode;
wheel->mNode = wheel->mParNode->createChildSceneNode("Wheel" + Ogre::StringConverter::toString(++mWheelCount));
Ogre::SceneManager* smgr = wheel->mParNode->getCreator();
Ogre::Entity* eBody = smgr->createEntity("eBodyWheel" + Ogre::StringConverter::toString(mWheelCount), OGRE_WHEEL_FILE);
wheel->mNode->attachObject(eBody);
wheel->mNode->setPosition(pos/0.0006);
return wheel;
}
return NULL;
}
//-----------------------------------------------------------------------
void SceneDecoratorExtern::createEntity(void)
{
if (!mEntity)
{
Ogre::SceneManager* sceneManager = mParentTechnique->getParentSystem()->getSceneManager();
if (sceneManager)
{
std::stringstream ss;
ss << this;
mEntityName = mMeshName + ss.str();
mEntity = sceneManager->createEntity(mEntityName, mMeshName);
if (mMaterialNameSet)
{
mEntity->setMaterialName(mMaterialName);
}
}
}
}
CollisionModel3D *EditorFrameHandler::GetCollisionModel(const char *modelname)
{
CollisionModel3D *hashres=NULL, *CollisionModel = NULL;
bool bres = CollisionModels.Find(modelname, &hashres);
if (!bres)
{
CollisionModel = newCollisionModel3D(false);
size_t vertex_count,index_count;
Ogre::Vector3* vertices;
unsigned long* indices;
Ogre::SceneManager *SceneMgr = CommonDeclarations::GetSceneManager();
Ogre::Entity *entity = SceneMgr->createEntity("tmpcollis", modelname);
Collidable::getMeshInformation(entity->getMesh().getPointer(),vertex_count,vertices,index_count,indices,Ogre::Vector3(0,0,0),Ogre::Quaternion::IDENTITY,Ogre::Vector3(1,1,1));
SceneMgr->destroyEntity(entity);
size_t index;
int numTris = (int)index_count / 3;
CollisionModel->setTriangleNumber(numTris);
for (unsigned i=0;i<index_count;i+=3)
{
index = indices[i];
CollisionModel->addTriangle(vertices[indices[i+0]].x,vertices[indices[i+0]].y,vertices[indices[i+0]].z,
vertices[indices[i+1]].x,vertices[indices[i+1]].y,vertices[indices[i+1]].z,
vertices[indices[i+2]].x,vertices[indices[i+2]].y,vertices[indices[i+2]].z);
}
CollisionModel->finalize();
delete[] vertices;
delete[] indices;
CollisionModels.Insert(modelname,CollisionModel);
} else
{
CollisionModel = hashres;
}
return CollisionModel;
}
CObject::CObject(const std::string &id, CWorldEntity *pParent, CMap *pMap, EObjectTypes eObjectType, Ogre::SceneNode *pSceneNode)
: CWorldEntity(id, pParent, pMap),
m_ObjectTypeData(OBJECT_TYPE_ID_MAP.toData(eObjectType)) {
setType(eObjectType);
if (pSceneNode) {
m_pSceneNode = pSceneNode;
}
else {
m_pSceneNode = pParent->getSceneNode()->createChildSceneNode(id);
}
Ogre::SceneManager *pSceneManager = m_pSceneNode->getCreator();
Ogre::Entity *pEntity(nullptr);
// create entity
if (m_ObjectTypeData.bPermanetStatic) {
m_pMap->addStaticEntity(m_ObjectTypeData.sMeshName + ".mesh", m_pSceneNode->getPosition(), m_pSceneNode->getOrientation());
setCurAndMaxHP(HP_INFINITY);
}
else {
pEntity = pSceneManager->createEntity(id + "ent", m_ObjectTypeData.sMeshName + ".mesh", "World");
pEntity->setMaterialName(m_ObjectTypeData.sMaterialName);
m_pSceneNode->attachObject(pEntity);
pEntity->setCastShadows(false);
}
createPhysics();
switch (m_uiType) {
case OBJECT_GREEN_RUPEE:
case OBJECT_BLUE_RUPEE:
case OBJECT_RED_RUPEE:
makePickable();
break;
default:
break;
}
}
void GraphicsImpl::updatePositions()
{
{
boost::mutex::scoped_lock lock(modifyNodesMutex);
while (!nodesToAdd.empty()) {
addNode(nodesToAdd.back());
nodesToAdd.pop_back();
}
while (!nodesToRemove.empty()) {
removeNode(nodesToRemove.back());
nodesToRemove.pop_back();
}
while (!terrainToCreate.empty()) {
Terrain terrain = terrainToCreate.back();
Ogre::Entity* ent;
Ogre::SceneNode* node;
Dout << "Creating terrain with specification: " + terrain.specification;
ent = sceneMgr->createEntity(ObjectRegistry::Instance().getNameForID(terrain.node.ID) + boost::lexical_cast<std::string>(terrain.node.ID), terrain.specification);
node = sceneMgr->getRootSceneNode()->createChildSceneNode();
node->attachObject(ent);
node->setPosition(terrain.node.pos);
ent->setMaterialName("Simple/BeachStones");
node->setOrientation(terrain.node.orient);
node->setScale(terrain.scale);
nodes[terrain.node.ID] = node;
terrainToCreate.pop_back();
}
}
if (!frontWorld->nodes.empty()) {
for (std::vector< OgreNewt::Node* >::iterator iter = frontWorld->nodes.begin(); iter != frontWorld->nodes.end(); ++iter) {
nodes[(*iter)->ID]->setOrientation((*iter)->orient);
nodes[(*iter)->ID]->setPosition((*iter)->pos);
}
}
}
void FvXMLAnimationModelSerializerImpl::ReadEntity(
FvXMLSectionPtr spSection, Ogre::SceneNode* pkNode, FvAnimationModel* pkDest )
{
Ogre::SceneManager *pkSceneManager = Ogre::Root::getSingleton().
_getCurrentSceneManager();
FV_ASSERT(pkSceneManager);
FvString kMeshIdentifier = spSection->ReadString("identifier");
FvString kMeshFile = spSection->ReadString("mesh");
Ogre::Entity *pkEntity = pkSceneManager->createEntity(
pkNode->getName() + "_" + kMeshIdentifier,kMeshFile);
FV_ASSERT(pkEntity);
pkEntity->setCastShadows(pkDest->m_bCastShadows);
pkNode->attachObject(pkEntity);
pkDest->m_akNodes[pkDest->m_u32CurrentLodLevel].m_kEntityList.push_back(pkEntity);
pkEntity->setRenderQueueGroup(RENDER_QUEUE_MAX);
AnimationStateSet *pkAnimations = pkEntity->getAllAnimationStates();
if(pkAnimations)
{
AnimationStateIterator kIt = pkAnimations->getAnimationStateIterator();
while (kIt.hasMoreElements())
{
AnimationState *pkAnim= kIt.getNext();
if(pkDest->GetAnimation(pkAnim->getAnimationName()) == NULL)
pkDest->m_kModelAnimations.insert(std::make_pair(pkAnim->getAnimationName(),pkAnim));
}
}
std::vector<FvXMLSectionPtr> kSubentities;
spSection->OpenSections("subentities/subentity",kSubentities);
std::vector<FvXMLSectionPtr>::iterator kSubIt = kSubentities.begin();
for(; kSubIt != kSubentities.end(); ++kSubIt)
{
int iIndex = (*kSubIt)->ReadInt("index",-1);
FvString kMaterialName = (*kSubIt)->ReadString("materialName");
Ogre::SubEntity *pkSubEntity = pkEntity->getSubEntity(iIndex);
if(pkSubEntity && !kMaterialName.empty())
pkSubEntity->setMaterialName(kMaterialName);
}
}
//!
//! Create new scene.
//! \return True if the scene was successfully created, otherwise False.
//!
bool Model2SceneNode::createEntity(QString name, QString fileName)
{
// destroy the entity through its scene manager
Ogre::SceneManager *sceneManager = OgreManager::getSceneManager();
// create a new OGRE entity for each vertex
m_entity = sceneManager->createEntity(name.toStdString(), fileName.toStdString());
if (m_entity) {
// set cumulative blend mode instead of Ogre::ANIMBLEND_AVERAGE which is default
if (m_entity->hasSkeleton()) {
Ogre::Skeleton *skeleton = m_entity->getSkeleton();
skeleton->setBlendMode(Ogre::ANIMBLEND_CUMULATIVE);
}
}
// create a container for the entity
m_entityContainer = new OgreContainer(m_entity);
m_entity->setUserAny(Ogre::Any(m_entityContainer));
return true;
}
//-----------------------------------------------------------------------
void MeshParticleVisualData::modifyMesh(const String &meshName)
{
// destroy old entity
assert(mEntity);
Ogre::SceneNode* parent = mEntity->getParentSceneNode();
assert(parent);
Ogre::SceneManager* creator = parent->getCreator();
assert(creator);
parent->detachObject(mEntity->getName());
creator->destroyMovableObject(mEntity);
mEntity = NULL;
// create new entity
mEntity = creator->createEntity( mSceneNode->getName(), meshName );
assert (mEntity);
mSceneNode->attachObject(mEntity);
}
Entity Factory::createBlock(entityx::ptr<entityx::EntityManager> entityMgr, int x, int y, int z, std::string material)
{
Entity block = entityMgr->create();
Ogre::SceneManager* sceneMgr = RenderManager::getPtr()->getSceneManager();
Ogre::Entity* wall = sceneMgr->createEntity("Cube.mesh");
wall->setMaterialName(material);
Ogre::SceneNode* wallNode = sceneMgr->getRootSceneNode()->createChildSceneNode();
wallNode->attachObject(wall);
block.assign<Position>(x,y,z);
wallNode->setPosition(x,y,z);
block.assign<Orientation>(wallNode->getOrientation());
block.assign<Renderable>(wallNode);
block.assign<Name>("Block");
if(material == "Wall"){
block.assign<Destroyable>(200);
}
return block;
}
entityx::Entity Factory::createProjectile(entityx::ptr<EntityManager> where, Ogre::Vector3 pos, Ogre::Quaternion ori, Ogre::Real velocity, std::string materialName)
{
Ogre::Entity *projMesh;
Ogre::SceneManager *sceneMgr = RenderManager::getPtr()->getSceneManager();
projMesh = sceneMgr->createEntity("ProjectileMesh.mesh");
projMesh->setMaterialName(materialName);
Entity proj = where->create();
Ogre::SceneNode *projNode = sceneMgr->getRootSceneNode()->createChildSceneNode();
projNode->attachObject(projMesh);
Ogre::Light *light = sceneMgr->createLight();
if(materialName == "RedLaser")
light->setDiffuseColour(Ogre::ColourValue(.8, .2, .2));
else
light->setDiffuseColour(Ogre::ColourValue(.2, .2, .8));
light->setType(Ogre::Light::LT_POINT);
projNode->attachObject(light);
projNode->setPosition(pos);
projNode->setOrientation(ori);
//projNode->translate(0, 0, -2, Ogre::SceneNode::TS_LOCAL);
proj.assign<Position>(projNode->getPosition());
proj.assign<Orientation>(ori);
proj.assign<Velocity>(0, 0, velocity);
proj.component<Velocity>()->direction.z = -1;
proj.assign<Renderable>(projNode);
proj.assign<AngularVelocity>(0, 0, 10);
proj.assign<Name>("proiettile");
proj.assign<LightComponent>(light);
return proj;
}
void SoundEditAction::_onEnd(const Point& pt, bool canceled)
{
if (!canceled)
{
Ogre::Vector3 normal;
if (mSceneManipulator->getTerrainIntersects(pt, mCreatePos, &normal, true) && mSoundMovingEntity && mSoundNode)
{
// Permanent it to final scene
mSceneManipulator->_fireUIChanged(static_cast<void*>(&mCreatePos), UIC_SOUNDEDIT);
Ogre::SceneManager* sceneManager = mSceneManipulator->getSceneManager();
Ogre::Entity* entity = sceneManager->createEntity("SoundEntity" + Ogre::StringConverter::toString(mNextNameIndex++), "axes.mesh");
mSoundNode->createChildSceneNode()->attachObject(entity);
entity->getParentSceneNode()->setPosition(mCreatePos);
entity->getParentSceneNode()->setScale(10,10,10);
mSoundEntities.push_back(entity);
}
}
}
LagomPlayerBase::LagomPlayerBase(GameState* state) :
LagomUnitImp<LagomPlayerBase>(*state,Vector3(0.0f, getIntFactory().GroundOffset, 0.0f)),
_selectedActorFactory(_actorFactories.end()),
_constructionObject(nullptr),
_hoverConstructing(false),
_draggingConstruction(false),
_buildCooldown(0.0f),
_buildCooldownMax(1.0f),
_factoryHighlightRemaining(0.0f)
{
Ogre::SceneManager* manager = state->GetSceneManager();
_sceneNode = manager->createSceneNode(getIntFactory().Name);
_mainEntity = manager->createEntity(getIntFactory().Name,getIntFactory().Mesh);
_mainEntity->setMaterialName(getIntFactory().Material);
_materialInstance = _mainEntity->getSubEntity(0);
_sceneNode->attachObject(_mainEntity);
_sceneNode->setPosition(_location);
_sceneNode->setScale(GetFactory()->MeshScale);
_btCollisionShape = new (alignedMalloc<btCylinderShape>()) btCylinderShape(btVector3(getIntFactory().CollisionRange,getIntFactory().GroundOffset,getIntFactory().CollisionRange));
_btDefaultMotionState = new (alignedMalloc<btDefaultMotionState>())
btDefaultMotionState(btTransform(btQuaternion(0,0,0,1),btVector3(0.0f,getIntFactory().GroundOffset,0.0f)));
btScalar mass = 0.0f;
btVector3 fallInertia(0,0,0);
_btCollisionShape->calculateLocalInertia(mass,fallInertia);
btRigidBody::btRigidBodyConstructionInfo rigidBodyCI(mass,_btDefaultMotionState,_btCollisionShape,fallInertia);
_btRigidBody = new (alignedMalloc<btRigidBody>()) btRigidBody(rigidBodyCI);
assert((int)_btRigidBody % 16 == 0);
_btRigidBody->setActivationState(DISABLE_DEACTIVATION);
_health = getIntFactory().Health;
RestrictConstruction();
RegisterInput();
}
void PlayerObject::createObject(Ogre::SceneManager &sceneMgr, Ogre::Camera *camera) {
objectNode = sceneMgr.getRootSceneNode()->createChildSceneNode("PlayerNode");
objectEntity = sceneMgr.createEntity("Player", "ninja.mesh");
objectEntity->setCastShadows(true);
objectNode->scale(0.025f, 0.025f, 0.025f);
objectNode->attachObject(objectEntity);
objectNode->setPosition(position);
mDirection = Ogre::Vector3::ZERO;
mWalkSpeed = 6.0f;
mAnimationState = objectEntity->getAnimationState("Idle2");
mAnimationState->setLoop(true);
mAnimationState->setEnabled(true);
this->camera = camera;
dying = false;
dead = false;
attacking = false;
updateGraveyard = true;
walkTo = position;
lastHealthTick = 0.0f;
} // createObject
void SoundEditAction::_createSoundEntity(int gridX, int gridZ)
{
if (!mFirstInit)
_createIndicatorInstance();
WX::TerrainData* terrainData = mSceneManipulator->getTerrainData();
std::pair<Real, Real> worldPos = terrainData->gridToWorld(gridX, gridZ);
Real worldHeight = terrainData->getHeightAt(worldPos.first, worldPos.second);
Ogre::SceneManager* sceneManager = mSceneManipulator->getSceneManager();
Ogre::Entity* entity = sceneManager->createEntity("SoundEntity" + Ogre::StringConverter::toString(mNextNameIndex++), "axes.mesh");
mSoundNode->createChildSceneNode()->attachObject(entity);
entity->getParentSceneNode()->setPosition(worldPos.first, worldHeight, worldPos.second);
entity->getParentSceneNode()->setVisible(mShowSoundEntity);
entity->getParentSceneNode()->setScale(10,10,10);
mSoundEntities.push_back(entity);
}
/**
* @brief Ctor.
* @param entity The entity which the marker is attached to.
* @param sceneManager A scene manager used to create nodes and entities.
* @param terrainManager Provides height data.
* @param point The location which will be marked.
*/
EntityPointMarker(Eris::Entity& entity, Ogre::SceneManager& sceneManager, const IHeightProvider& heightProvider, const WFMath::Point<3>& point) :
mEntity(entity), mMarkerEntity(0), mMarkerNode(0), mMarkerDirectionIndicator(0), mHeightProvider(heightProvider), mPoint(point)
{
mMarkerNode = sceneManager.getRootSceneNode()->createChildSceneNode();
try {
mMarkerEntity = sceneManager.createEntity("3d_objects/primitives/models/sphere.mesh");
//start out with a normal material
mMarkerEntity->setMaterialName("/global/authoring/point");
//The material is made to ignore depth checks, so if we put it in a later queue we're
//making sure that the marker is drawn on top of everything else, making it easier to interact with.
mMarkerEntity->setRenderQueueGroup(Ogre::RENDER_QUEUE_9);
mMarkerEntity->setRenderingDistance(300);
mMarkerEntity->setQueryFlags(MousePicker::CM_NONPICKABLE);
mMarkerNode->attachObject(mMarkerEntity);
} catch (const std::exception& ex) {
S_LOG_WARNING("Error when creating marker node." << ex);
return;
}
mMarkerNode->setVisible(true);
mMarkerDirectionIndicator = new ShapeVisual(*sceneManager.getRootSceneNode(), false);
mEntity.Moved.connect(sigc::mem_fun(*this, &EntityPointMarker::entityMoved));
}
bool GameNeedleComponent::load(Ogre::SceneNode * node)
{
using namespace Ogre;
Ogre::SceneManager * sm = Orz::OgreGraphicsManager::getSingleton().getSceneManager();
Ogre::Entity * needle = sm->createEntity("needle", "poniter.mesh");
node->createChildSceneNode(Ogre::Vector3(0, 0 , 0))->attachObject(needle);
_semi.reset(new SubEntityMaterialInstance(needle->getSubEntity(1)));
//needle->getSubEntity(1)->getMaterial()->addListener;
CGameFlowerInterface * flower = _flowerComp->queryInterface<CGameFlowerInterface>();
/*Ogre::SceneNode * sn = node->createChildSceneNode(Ogre::Vector3(310, 180, 0));
Light* light;
light = sm->createLight();
light->setType(Ogre::Light::LT_POINT);
light->setAttenuation(80, 1, 0, 0);
light->setDiffuseColour(Ogre::ColourValue::White);
sn->attachObject(light);*/
//sn->attachObject(sm->createEntity("ogrehe", "ogrehead.mesh"));
flower->load(node);
return true;
}
void EC_Water::CreateOgreWaterObject()
{
boost::shared_ptr<OgreRenderer::Renderer> renderer = framework_->GetServiceManager()->GetService
<OgreRenderer::Renderer>(Foundation::Service::ST_Renderer).lock();
if (renderer)
{
Ogre::SceneManager *sceneMgr = renderer->GetSceneManager();
assert(sceneMgr);
if (!scene_node_)
{
const char water_mesh[] = "WaterMesh";
Ogre::MeshPtr mesh = Ogre::MeshManager::getSingleton().createPlane(water_mesh, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
Ogre::Plane(Ogre::Vector3::UNIT_Z, 0), 5000, 5000, 10, 10, true, 1, 1, 1, Ogre::Vector3::UNIT_X);
entity_ = sceneMgr->createEntity("WaterEntity", water_mesh);
entity_->setMaterialName("Ocean");
entity_->setCastShadows(false);
scene_node_ = sceneMgr->getRootSceneNode()->createChildSceneNode("WaterNode");
scene_node_->attachObject(entity_);
}
}
}
// funcion donde se coloca lo que se desea desplegar.
void createScene(){
_sceneManager->setAmbientLight(Ogre::ColourValue(0.2,0.2,0.2));
_sceneManager->setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_ADDITIVE);
// LUZ
Ogre::Light* LuzPuntual01 = _sceneManager->createLight("Luz01");
LuzPuntual01->setType(Ogre::Light::LT_DIRECTIONAL);
LuzPuntual01->setDiffuseColour(1.0,1.0,1.0);
LuzPuntual01->setDirection(Ogre::Vector3( 1, -1, -1 ));
Ogre::Light* LuzPuntual02 = _sceneManager->createLight("Luz02");
LuzPuntual02->setType(Ogre::Light::LT_DIRECTIONAL);
LuzPuntual02->setDiffuseColour(1.0,1.0,1.0);
LuzPuntual02->setDirection(Ogre::Vector3( -1, -1, -1 ));
//Chasis Carro
_nodeChasisCarro = _sceneManager->createSceneNode("ChasisCarro");
_sceneManager->getRootSceneNode()->addChild(_nodeChasisCarro);
Ogre::Entity* _entChasisCarro = _sceneManager->createEntity("ChasisCarro", "chasisCarro.mesh");
_nodeChasisCarro->attachObject(_entChasisCarro);
/* Ruedas Izquierdas */
_nodeRuedaSimple0 = _sceneManager->createSceneNode("RuedaSimple0");
_sceneManager->getRootSceneNode()->addChild(_nodeRuedaSimple0);
// _nodeRuedaSimple00 = _nodeRuedaSimple0->createChildSceneNode("RuedaSimple00");
// _sceneManager->getRootSceneNode()->addChild(_nodeRuedaSimple00);
Ogre::Entity* _entRuedaSimple0 = _sceneManager->createEntity("RuedaSimple0", "RuedaDetallada.mesh");
_nodeRuedaSimple0->attachObject(_entRuedaSimple0);
// _nodeRuedaSimple00->attachObject(_entRuedaSimple0);
_nodeRuedaSimple0->translate(9,3,5);
_nodeRuedaSimple2 = _sceneManager->createSceneNode("RuedaSimple2");
_sceneManager->getRootSceneNode()->addChild(_nodeRuedaSimple2);
// _nodeRuedaSimple22 = _nodeRuedaSimple2->createChildSceneNode("RuedaSimple22");
// _sceneManager->getRootSceneNode()->addChild(_nodeRuedaSimple22);
Ogre::Entity* _entRuedaSimple2 = _sceneManager->createEntity("RuedaSimple2", "RuedaDetallada.mesh");
_nodeRuedaSimple2->attachObject(_entRuedaSimple2);
// _nodeRuedaSimple22->attachObject(_entRuedaSimple2);
_nodeRuedaSimple2->translate(9,3,-5);
/* Ruedas Derechas */
_nodeRuedaSimple1 = _sceneManager->createSceneNode("RuedaSimple1");
_sceneManager->getRootSceneNode()->addChild(_nodeRuedaSimple1);
// _nodeRuedaSimple11 = _nodeRuedaSimple1->createChildSceneNode("RuedaSimple11");
// _sceneManager->getRootSceneNode()->addChild(_nodeRuedaSimple11);
Ogre::Entity* _entRuedaSimple1 = _sceneManager->createEntity("RuedaSimple1", "RuedaDetallada.mesh");
_nodeRuedaSimple1->attachObject(_entRuedaSimple1);
// _nodeRuedaSimple11->attachObject(_entRuedaSimple1);
_nodeRuedaSimple1->translate(-7,3,5);
_nodeRuedaSimple3 = _sceneManager->createSceneNode("RuedaSimple3");
_sceneManager->getRootSceneNode()->addChild(_nodeRuedaSimple3);
// _nodeRuedaSimple33 = _nodeRuedaSimple3->createChildSceneNode("RuedaSimple33");
//_sceneManager->getRootSceneNode()->addChild(_nodeRuedaSimple33);
Ogre::Entity* _entRuedaSimple3 = _sceneManager->createEntity("RuedaSimple3", "RuedaDetallada.mesh");
_nodeRuedaSimple3->attachObject(_entRuedaSimple3);
//_nodeRuedaSimple33->attachObject(_entRuedaSimple3);
_nodeRuedaSimple3->translate(-7,3,-5);
/* ALA DERECHA INFERIOR
Se crea el nodo padre de la nave llamado eje */
eje = _sceneManager->getRootSceneNode()->createChildSceneNode("eje");
padreDI = eje->createChildSceneNode("padreDI");
Ogre::ManualObject* alad = _sceneManager->createManualObject("alad");
alad->begin("BaseWhiteNoLighting", Ogre::RenderOperation::OT_TRIANGLE_FAN);
alad->colour(Ogre::ColourValue(0.0, 0.5, 0.0, 0.0));
alad->position(4.0, -0.5, 0.0);
alad->position(15.0, -0.5, 0.0);
alad->position(15.0, 0.0, 0.0);
alad->position(5.0, 0.0, 0.0);
alad->index(0);
alad->index(1);
alad->index(2);
alad->index(3);
alad->index(0);
alad->end();
padreDI->attachObject(alad);
Ogre::ManualObject* alad2 = _sceneManager->createManualObject("alad2");
alad2->begin("BaseWhiteNoLighting", Ogre::RenderOperation::OT_TRIANGLE_FAN);
alad2->colour(Ogre::ColourValue(0.0, 0.6, 0.0, 0.0));
alad2->position(5.0, 0.0, 0.0);
alad2->position(15.0, 0.0, 0.0);
alad2->position(14.0, 0.0, -3.0);
alad2->position(5.0, 0.0, -4.0);
alad2->index(0);
alad2->index(1);
alad2->index(2);
alad2->index(3);
alad2->index(0);
alad2->end();
padreDI->attachObject(alad2);
/* ALA DERECHA SUPERIOR */
padreDS = eje->createChildSceneNode("padreDS");
Ogre::ManualObject* aladS = _sceneManager->createManualObject("aladS");
aladS->begin("BaseWhiteNoLighting", Ogre::RenderOperation::OT_TRIANGLE_FAN);
aladS->colour(Ogre::ColourValue(0.0, 0.5, 0.0, 0.0));
aladS->position(4.0, 0.0, 0.0);
aladS->position(15.0, 0.0, 0.0);
aladS->position(15.0, 0.5, 0.0);
aladS->position(5.0, 0.5, 0.0);
aladS->index(0);
aladS->index(1);
aladS->index(2);
aladS->index(3);
aladS->index(0);
aladS->end();
padreDS->attachObject(aladS);
Ogre::ManualObject* aladS2 = _sceneManager->createManualObject("aladS2");
aladS2->begin("BaseWhiteNoLighting", Ogre::RenderOperation::OT_TRIANGLE_FAN);
aladS2->colour(Ogre::ColourValue(0.0, 0.6, 0.0, 0.0));
aladS2->position(5.0, 0.5, 0.0);
aladS2->position(15.0, 0.5, 0.0);
aladS2->position(14.0, 0.5, -3.0);
aladS2->position(5.0, 0.5, -3.0);
aladS2->index(0);
aladS2->index(1);
aladS2->index(2);
aladS2->index(3);
aladS2->index(0);
aladS2->end();
padreDS->attachObject(aladS2);
/* ALA IZQUIERDA INFERIOR */
padreII = eje->createChildSceneNode("padreII");
Ogre::ManualObject* aladI = _sceneManager->createManualObject("aladI");
aladI->begin("BaseWhiteNoLighting", Ogre::RenderOperation::OT_TRIANGLE_FAN);
aladI->colour(Ogre::ColourValue(0.0, 0.5, 0.0, 0.0));
aladI->position(-15.0, -0.5, 0.0);
aladI->position(5.0, -0.5, 0.0);
aladI->position(-5.0, 0.0, 0.0);
aladI->position(-15.0, 0.0, 0.0);
aladI->index(0);
aladI->index(1);
aladI->index(2);
aladI->index(3);
aladI->index(0);
aladI->end();
padreII->attachObject(aladI);
Ogre::ManualObject* aladI2 = _sceneManager->createManualObject("aladI2");
aladI2->begin("BaseWhiteNoLighting", Ogre::RenderOperation::OT_TRIANGLE_FAN);
aladI2->colour(Ogre::ColourValue(0.0, 0.6, 0.0, 0.0));
aladI2->position(-15.0, 0.0, 0.0);
aladI2->position(-5.0, 0.0, 0.0);
aladI2->position(-5.0, 0.0, -4.0);
aladI2->position(-14.0, 0.0, -3.0);
aladI2->index(0);
aladI2->index(1);
aladI2->index(2);
aladI2->index(3);
aladI2->index(0);
aladI2->end();
padreII->attachObject(aladI2);
/* ALA IZQUIERDA SUPERIOR */
padreIS = eje->createChildSceneNode("padreIS");
Ogre::ManualObject* aladIS = _sceneManager->createManualObject("aladIS");
aladIS->begin("BaseWhiteNoLighting", Ogre::RenderOperation::OT_TRIANGLE_FAN);
aladIS->colour(Ogre::ColourValue(0.0, 0.5, 0.0, 0.0));
aladIS->position(-15.0, 0.0, 0.0);
aladIS->position(5.0, 0.0, 0.0);
aladIS->position(-5.0, 0.5, 0.0);
aladIS->position(-15.0, 0.5, 0.0);
aladIS->index(0);
aladIS->index(1);
aladIS->index(2);
aladIS->index(3);
aladIS->index(0);
aladIS->end();
padreIS->attachObject(aladIS);
Ogre::ManualObject* aladIS2 = _sceneManager->createManualObject("aladIS2");
aladIS2->begin("BaseWhiteNoLighting", Ogre::RenderOperation::OT_TRIANGLE_FAN);
aladIS2->colour(Ogre::ColourValue(0.0, 0.6, 0.0, 0.0));
aladIS2->position(-15.0, 0.5, 0.0);
aladIS2->position(-5.0, 0.5, 0.0);
aladIS2->position(-5.0, 0.5, -3.0);
aladIS2->position(-14.0, 0.5, -2.0);
aladIS2->index(0);
aladIS2->index(1);
aladIS2->index(2);
aladIS2->index(3);
aladIS2->index(0);
aladIS2->end();
padreIS->attachObject(aladIS2);
/* Rotaciones de las alas */
eje->scale(2.5,2.5,2.5);
eje->translate(0,5,0);
eje->yaw(Ogre::Degree(180));
/* Trasladar las alas */
padreIS->translate(4,0,0);
padreDS->translate(-4,0,0);
padreDI->translate(-4,0,0);
padreII->translate(4,0,0);
eje->scale(0.1,0.1,0.1);
//BordePista
Ogre::SceneNode* _nodeBPista = _sceneManager->createSceneNode("BordePista");
_sceneManager->getRootSceneNode()->addChild(_nodeBPista);
Ogre::Entity* _entBPista = _sceneManager->createEntity("BordePista", "bordePista02.mesh");
_nodeBPista->attachObject(_entBPista);
_entBPista->setMaterialName("Examples/pared");
//PisoObstaculo
Ogre::SceneNode* _nodePObstaculo = _sceneManager->createSceneNode("PistaObstaculo");
_sceneManager->getRootSceneNode()->addChild(_nodePObstaculo);
Ogre::Entity* _entPObstaculo = _sceneManager->createEntity("PistaObstaculo", "pisoObstaculo02.mesh");
_nodePObstaculo->attachObject(_entPObstaculo);
//PisoNOObstaculo
Ogre::SceneNode* _nodePNObstaculo = _sceneManager->createSceneNode("PistaNoObstaculo");
_sceneManager->getRootSceneNode()->addChild(_nodePNObstaculo);
Ogre::Entity* _entPNOObstaculo = _sceneManager->createEntity("PistaNoObstaculo", "pisoNoObstaculo02.mesh");
_nodePNObstaculo->attachObject(_entPNOObstaculo);
_entPNOObstaculo->setMaterialName("Examples/piso");
//PosterInicioFinal
Ogre::SceneNode* _nodePoster = _sceneManager->createSceneNode("PosterInicioFinal");
_sceneManager->getRootSceneNode()->addChild(_nodePoster);
Ogre::Entity* _entPoster = _sceneManager->createEntity("PosterInicioFinal", "posterInicioFinal02.mesh");
_nodePoster->attachObject(_entPoster);
//BanderaInicial
Ogre::SceneNode* _nodeBInicial = _sceneManager->createSceneNode("BanderaInicial");
_sceneManager->getRootSceneNode()->addChild(_nodeBInicial);
Ogre::Entity* _entBanderaI = _sceneManager->createEntity("BanderaInicial", "banderaInicial02.mesh");
_nodeBInicial->attachObject(_entBanderaI);
//BanderaFinal
Ogre::SceneNode* _nodeBFinal = _sceneManager->createSceneNode("BanderaFinal");
_sceneManager->getRootSceneNode()->addChild(_nodeBFinal);
Ogre::Entity* _entBanderaF = _sceneManager->createEntity("BanderaFinal", "banderaFinal.mesh");
_nodeBFinal->attachObject(_entBanderaF);
_sceneManager->setSkyDome(true,"Examples/cielo",5,8);
}
void CSceletalAnimationView::EngineSetup(void)
{
Ogre::Root *Root = ((CSceletalAnimationApp*)AfxGetApp())->m_Engine->GetRoot();
Ogre::SceneManager *SceneManager = NULL;
SceneManager = Root->createSceneManager(Ogre::ST_GENERIC, "Animation");
//
// Create a render window
// This window should be the current ChildView window using the externalWindowHandle
// value pair option.
//
Ogre::NameValuePairList parms;
parms["externalWindowHandle"] = Ogre::StringConverter::toString((long)m_hWnd);
parms["vsync"] = "true";
CRect rect;
GetClientRect(&rect);
Ogre::RenderTarget *RenderWindow = Root->getRenderTarget("Mouse Input");
if (RenderWindow == NULL)
{
try
{
m_RenderWindow = Root->createRenderWindow("Mouse Input", rect.Width(), rect.Height(), false, &parms);
}
catch(...)
{
MessageBox("Cannot initialize\nCheck that graphic-card driver is up-to-date", "Initialize Render System", MB_OK | MB_ICONSTOP);
exit(EXIT_SUCCESS);
}
}
// Load resources
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
// Create the camera
m_Camera = SceneManager->createCamera("Camera");
m_Camera->setNearClipDistance(0.5);
m_Camera->setFarClipDistance(5000);
m_Camera->setCastShadows(false);
m_Camera->setUseRenderingDistance(true);
m_Camera->setPosition(Ogre::Vector3(5.0, 5.0, 10.0));
Ogre::SceneNode *CameraNode = NULL;
CameraNode = SceneManager->getRootSceneNode()->createChildSceneNode("CameraNode");
Ogre::Viewport* Viewport = NULL;
if (0 == m_RenderWindow->getNumViewports())
{
Viewport = m_RenderWindow->addViewport(m_Camera);
Viewport->setBackgroundColour(Ogre::ColourValue(0.8f, 0.8f, 0.8f));
}
// Alter the camera aspect ratio to match the viewport
m_Camera->setAspectRatio(Ogre::Real(rect.Width()) / Ogre::Real(rect.Height()));
m_Camera->lookAt(Ogre::Vector3(0.5, 0.5, 0.5));
m_Camera->setPolygonMode(Ogre::PolygonMode::PM_WIREFRAME);
Ogre::ManualObject* ManualObject = NULL;
ManualObject = SceneManager->createManualObject("Animation");
ManualObject->setDynamic(false);
ManualObject->begin("BaseWhiteNoLighting", Ogre::RenderOperation::OT_TRIANGLE_LIST);
//face 1
ManualObject->position(0, 0, 0);//0
ManualObject->position(1, 0, 0);//1
ManualObject->position(1, 1, 0);//2
ManualObject->triangle(0, 1, 2);//3
ManualObject->position(0, 0, 0);//4
ManualObject->position(1, 1, 0);//5
ManualObject->position(0, 1, 0);//6
ManualObject->triangle(3, 4, 5);//7
//face 2
ManualObject->position(0, 0, 1);//8
ManualObject->position(1, 0, 1);//9
ManualObject->position(1, 1, 1);//10
ManualObject->triangle(6, 7, 8);//11
ManualObject->position(0, 0, 1);//12
ManualObject->position(1, 1, 1);//13
ManualObject->position(0, 1, 1);//14
ManualObject->triangle(9, 10, 11);//15
//face 3
ManualObject->position(0, 0, 0);//16
ManualObject->position(1, 0, 0);//17
ManualObject->position(1, 0, 1);//18
ManualObject->triangle(12, 13, 14);//19
ManualObject->position(0, 0, 0);
ManualObject->position(1, 0, 1);
ManualObject->position(0, 1, 1);
ManualObject->triangle(15, 16, 17);
//face 4
ManualObject->position(1, 0, 0);
ManualObject->position(1, 1, 0);
ManualObject->position(1, 1, 1);
ManualObject->triangle(18, 19, 20);
ManualObject->position(1, 0, 0);
ManualObject->position(1, 1, 1);
ManualObject->position(1, 0, 1);
ManualObject->triangle(21, 22, 23);
//face 5
ManualObject->position(0, 1, 0);
ManualObject->position(1, 1, 0);
ManualObject->position(0, 1, 1);
ManualObject->triangle(24, 25, 26);
ManualObject->position(1, 1, 0);
ManualObject->position(1, 1, 1);
ManualObject->position(0, 1, 1);
ManualObject->triangle(27, 28, 29);
//face 6
ManualObject->position(0, 0, 0);
ManualObject->position(0, 1, 1);
ManualObject->position(0, 0, 1);
ManualObject->triangle(30, 31, 32);
ManualObject->position(0, 0, 0);
ManualObject->position(0, 1, 0);
ManualObject->position(0, 1, 1);
ManualObject->triangle(33, 34, 35);
ManualObject->end();
Ogre::MeshPtr MeshPtr = ManualObject->convertToMesh("Animation");
Ogre::SubMesh* sub = MeshPtr->getSubMesh(0);
Ogre::SkeletonPtr Skeleton = Ogre::SkeletonManager::getSingleton().create("Skeleton", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
MeshPtr.getPointer()->_notifySkeleton(Skeleton);
Ogre::Bone *Root1 = NULL;
Ogre::Bone *Child1 = NULL;
Ogre::Bone *Child2 = NULL;
Root1 = Skeleton.getPointer()->createBone("Root");
Root1->setPosition(Ogre::Vector3(0.0, 0.0, 0.0));
Root1->setOrientation(Ogre::Quaternion::IDENTITY);
Child1 = Root1->createChild(1);
Child1->setPosition(Ogre::Vector3(4.0, 0.0, 0.0));
Child1->setOrientation(Ogre::Quaternion::IDENTITY);
Child2 = Root1->createChild(2);
Child2->setPosition(Ogre::Vector3(5.0, 0.0, 0.0));
Child2->setOrientation(Ogre::Quaternion::IDENTITY);
Ogre::VertexBoneAssignment Assignment;
Assignment.boneIndex = 0;
Assignment.vertexIndex = 0;
Assignment.weight = 1.0;
Skeleton->setBindingPose();
sub->addBoneAssignment(Assignment);
Assignment.vertexIndex = 1;
sub->addBoneAssignment(Assignment);
Assignment.vertexIndex = 2;
sub->addBoneAssignment(Assignment);
Ogre::Animation *Animation = MeshPtr->createAnimation("HandAnimation", 100.0);
Ogre::NodeAnimationTrack *Track = Animation->createNodeTrack(0, Root1);
Ogre::TransformKeyFrame *KeyFrame = NULL;
for (float FrameTime = 0.0; FrameTime < 100.0; FrameTime += 0.1)
{
KeyFrame = Track->createNodeKeyFrame(FrameTime);
KeyFrame->setTranslate(Ogre::Vector3(10.0, 0.0, 0.0));
}
Root1->setManuallyControlled(true);
Child1->setManuallyControlled(true);
Child2->setManuallyControlled(true);
MeshPtr->load();
MeshPtr.getPointer()->_notifySkeleton(Skeleton);
// Ogre::SkeletonSerializer skeletonSerializer;
// skeletonSerializer.exportSkeleton(Skeleton.get(), "C:\\Users\\Ilya\\Documents\\Visual Studio 2010\\Projects\\Recipes\\media\\models\\testskeleton.skeleton");
// Ogre::MeshSerializer ser;
// ser.exportMesh(MeshPtr.get(), "C:\\Users\\Ilya\\Documents\\Visual Studio 2010\\Projects\\Recipes\\media\\models\\testskeleton.mesh");
Ogre::Entity *Entity = SceneManager->createEntity("Animation", "Animation"/*"testskeleton.mesh"*/);
Ogre::SceneNode *SceneNode = SceneManager->getRootSceneNode()->createChildSceneNode();
SceneNode->attachObject(Entity);
Entity->setDisplaySkeleton(true);
m_AnimationState = Entity->getAnimationState("HandAnimation");
m_AnimationState->setEnabled(true);
m_AnimationState->setLoop(true);
m_Camera->setPolygonMode(Ogre::PolygonMode::PM_WIREFRAME);
Root->renderOneFrame();
}
bool EC_Mesh::SetMeshWithSkeleton(const std::string& mesh_name, const std::string& skeleton_name, bool clone)
{
if (!ViewEnabled())
return false;
OgreWorldPtr world = world_.lock();
Ogre::SkeletonPtr skel = Ogre::SkeletonManager::getSingleton().getByName(AssetAPI::SanitateAssetRef(skeleton_name));
if (skel.isNull())
{
LogError("EC_Mesh::SetMeshWithSkeleton: Could not set skeleton " + skeleton_name + " to mesh " + mesh_name + ": not found");
return false;
}
RemoveMesh();
Ogre::SceneManager* sceneMgr = world->OgreSceneManager();
Ogre::Mesh* mesh = PrepareMesh(mesh_name, clone);
if (!mesh)
return false;
try
{
mesh->_notifySkeleton(skel);
// LogDebug("Set skeleton " + skeleton_name + " to mesh " + mesh_name);
}
catch(Ogre::Exception& e)
{
LogError("EC_Mesh::SetMeshWithSkeleton: Could not set skeleton " + skeleton_name + " to mesh " + mesh_name + ": " + std::string(e.what()));
return false;
}
try
{
entity_ = sceneMgr->createEntity(world->GetUniqueObjectName("EC_Mesh_entwithskel"), mesh->getName());
if (!entity_)
{
LogError("EC_Mesh::SetMeshWithSkeleton: Could not set mesh " + mesh_name);
return false;
}
entity_->setRenderingDistance(drawDistance.Get());
entity_->setCastShadows(castShadows.Get());
entity_->setUserAny(Ogre::Any(static_cast<IComponent *>(this)));
// Set UserAny also on subentities
for(uint i = 0; i < entity_->getNumSubEntities(); ++i)
entity_->getSubEntity(i)->setUserAny(entity_->getUserAny());
if (entity_->hasSkeleton())
{
Ogre::SkeletonInstance* skel = entity_->getSkeleton();
// Enable cumulative mode on skeletal animations
if (skel)
skel->setBlendMode(Ogre::ANIMBLEND_CUMULATIVE);
}
}
catch(Ogre::Exception& e)
{
LogError("EC_Mesh::SetMeshWithSkeleton: Could not set mesh " + mesh_name + ": " + std::string(e.what()));
return false;
}
AttachEntity();
emit MeshChanged();
return true;
}
bool EC_Mesh::SetAttachmentMesh(uint index, const std::string& mesh_name, const std::string& attach_point, bool share_skeleton)
{
if (!ViewEnabled())
return false;
OgreWorldPtr world = world_.lock();
if (!entity_)
{
LogError("EC_Mesh::SetAttachmentMesh: No mesh entity created yet, can not create attachments!");
return false;
}
Ogre::SceneManager* sceneMgr = world->OgreSceneManager();
size_t oldsize = attachment_entities_.size();
size_t newsize = index + 1;
if (oldsize < newsize)
{
attachment_entities_.resize(newsize);
attachment_nodes_.resize(newsize);
for(uint i = oldsize; i < newsize; ++i)
{
attachment_entities_[i] = 0;
attachment_nodes_[i] = 0;
}
}
RemoveAttachmentMesh(index);
Ogre::Mesh* mesh = PrepareMesh(mesh_name, false);
if (!mesh)
return false;
if (share_skeleton)
{
// If sharing a skeleton, force the attachment mesh to use the same skeleton
// This is theoretically quite a scary operation, for there is possibility for things to go wrong
Ogre::SkeletonPtr entity_skel = entity_->getMesh()->getSkeleton();
if (entity_skel.isNull())
{
LogError("EC_Mesh::SetAttachmentMesh: Cannot share skeleton for attachment, not found");
return false;
}
try
{
mesh->_notifySkeleton(entity_skel);
}
catch(const Ogre::Exception &/*e*/)
{
LogError("EC_Mesh::SetAttachmentMesh: Could not set shared skeleton for attachment");
return false;
}
}
try
{
QString entityName = QString("EC_Mesh_attach") + QString::number(index);
attachment_entities_[index] = sceneMgr->createEntity(world->GetUniqueObjectName(entityName.toStdString()), mesh->getName());
if (!attachment_entities_[index])
{
LogError("EC_Mesh::SetAttachmentMesh: Could not set attachment mesh " + mesh_name);
return false;
}
attachment_entities_[index]->setRenderingDistance(drawDistance.Get());
attachment_entities_[index]->setCastShadows(castShadows.Get());
attachment_entities_[index]->setUserAny(entity_->getUserAny());
// Set UserAny also on subentities
for(uint i = 0; i < attachment_entities_[index]->getNumSubEntities(); ++i)
attachment_entities_[index]->getSubEntity(i)->setUserAny(entity_->getUserAny());
Ogre::Bone* attach_bone = 0;
if (!attach_point.empty())
{
Ogre::Skeleton* skel = entity_->getSkeleton();
if (skel && skel->hasBone(attach_point))
attach_bone = skel->getBone(attach_point);
}
if (attach_bone)
{
Ogre::TagPoint* tag = entity_->attachObjectToBone(attach_point, attachment_entities_[index]);
attachment_nodes_[index] = tag;
}
else
{
QString nodeName = QString("EC_Mesh_attachment_") + QString::number(index);
Ogre::SceneNode* node = sceneMgr->createSceneNode(world->GetUniqueObjectName(nodeName.toStdString()));
node->attachObject(attachment_entities_[index]);
adjustment_node_->addChild(node);
attachment_nodes_[index] = node;
}
if (share_skeleton && entity_->hasSkeleton() && attachment_entities_[index]->hasSkeleton())
{
attachment_entities_[index]->shareSkeletonInstanceWith(entity_);
}
}
catch(Ogre::Exception& e)
{
LogError("EC_Mesh::SetAttachmentMesh: Could not set attachment mesh " + mesh_name + ": " + std::string(e.what()));
return false;
}
return true;
}
CFootballPlayer::CFootballPlayer(CSimulationManager *simulationManager, const CPfTeamPlayers *teamPlayer, int number, CTeam *team, bool sideLeft)
:CMovingEntity()
{
m_simulationManager = simulationManager;
Ogre::SceneManager *scnMgr = Ogre::Root::getSingletonPtr()->getSceneManager(SIMULATION_SCENE_MANAGER_NODE_NAME);
m_teamPlayer = new CPfTeamPlayers(*teamPlayer);
m_stateMachine = new CStateMachine<CFootballPlayer>(this);
Ogre::String id;
char charId[20];
m_centerOfMassOffset.setOrigin(btVector3(0,-0.9,0));
m_sideLeft = sideLeft;
m_team = team;
m_number = number; //TODO
m_lastKickBallCycle = -1;
//m_direction.normalize();
sprintf(charId,"%s%d", team->getName().c_str(), m_number);
id = charId;
m_entity = scnMgr->createEntity("Player"+id, "Human.mesh");
if(sideLeft) {
if(m_number == 1) {
m_entity->setMaterialName("goalie_red");
} else {
m_entity->setMaterialName("player_red");
}
} else {
if(m_number == 1) {
m_entity->setMaterialName("goalie_yellow");
} else {
m_entity->setMaterialName("player_yellow");
}
}
btVector3 *initialPos = team->getPlayerStrategicPosition(m_number)->getInitialPosition();
btVector3 pos(initialPos->x(), initialPos->y(), initialPos->z());
if(!m_sideLeft) {
pos.setX(-pos.x());
pos.setZ(-pos.z());
}
m_node = scnMgr->getRootSceneNode()->createChildSceneNode("PlayerNode"+id, Ogre::Vector3(pos.x(), pos.y(), pos.z()));
m_node->attachObject(m_entity);
m_shape = new btCylinderShape(btVector3(btScalar(0.5),btScalar(0.9),btScalar(0.5)));
btScalar mass(70.0);
//rigidbody is dynamic if and only if mass is non zero, otherwise static
bool isDynamic = (mass != 0.f);
btVector3 localInertia(0,0,0);
if (isDynamic)
m_shape->calculateLocalInertia(mass,localInertia);
btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,this,m_shape,localInertia);
m_body = new btRigidBody(rbInfo);
m_body->setAngularFactor(btScalar(0));
m_body->setActivationState(DISABLE_DEACTIVATION);
m_steeringBehavior = new CSteeringBehaviors(this);
//Draw Circle
Ogre::ManualObject * circle = scnMgr->createManualObject("circle_name"+id);
float const radius = 1.5,
thickness = 0.7, // Of course this must be less than the radius value.
accuracy = 5,
height = 0.01;
Ogre::MaterialPtr matptr;
Ogre::Pass* pass;
if(sideLeft) {
matptr = Ogre::MaterialManager::getSingleton().createOrRetrieve("Red"+id, "General").first;
matptr->setReceiveShadows(true);
pass = matptr->getTechnique(0)->getPass(0);
Ogre::ColourValue colour = Ogre::ColourValue::Red;
pass->setDiffuse(colour);
pass->setAmbient(colour);
pass->setSpecular(colour);
pass->setSelfIllumination(colour);
//pass->setEmissive(ColourValue(0,0,0,colour.a));
pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
pass->setDepthWriteEnabled(false);
} else {
matptr = Ogre::MaterialManager::getSingleton().createOrRetrieve("Blue"+id, "General").first;
matptr->setReceiveShadows(true);
pass = matptr->getTechnique(0)->getPass(0);
Ogre::ColourValue colour = Ogre::ColourValue::Blue;
pass->setDiffuse(colour);
pass->setAmbient(colour);
pass->setSpecular(colour);
pass->setSelfIllumination(colour);
//pass->setEmissive(ColourValue(0,0,0,colour.a));
pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
pass->setDepthWriteEnabled(false);
}
circle->begin(matptr->getName(), Ogre::RenderOperation::OT_TRIANGLE_LIST);
unsigned point_index = 0;
for(float theta = 0; theta <= 2 * Ogre::Math::PI; theta += Ogre::Math::PI / (radius * accuracy)) {
circle->position(radius * cos(theta),
height,
radius * sin(theta));
circle->position(radius * cos(theta - Ogre::Math::PI / (radius * accuracy)),
height,
radius * sin(theta - Ogre::Math::PI / (radius * accuracy)));
circle->position((radius - thickness) * cos(theta - Ogre::Math::PI / (radius * accuracy)),
height,
(radius - thickness) * sin(theta - Ogre::Math::PI / (radius * accuracy)));
circle->position((radius - thickness) * cos(theta),
height,
(radius - thickness) * sin(theta));
// Join the 4 vertices created above to form a quad.
circle->quad(point_index, point_index + 1, point_index + 2, point_index + 3);
point_index += 4;
}
circle->end();
m_ringNode = m_node->createChildSceneNode();
m_ringNode->attachObject(circle);
}
bool EC_Mesh::SetMesh(QString meshResourceName, bool clone)
{
if (!ViewEnabled())
return false;
OgreWorldPtr world = world_.lock();
std::string mesh_name = meshResourceName.trimmed().toStdString();
RemoveMesh();
// If placeable is not set yet, set it manually by searching it from the parent entity
if (!placeable_)
{
Entity* entity = ParentEntity();
if (entity)
{
ComponentPtr placeable = entity->GetComponent(EC_Placeable::TypeNameStatic());
if (placeable)
placeable_ = placeable;
}
}
Ogre::SceneManager* sceneMgr = world->OgreSceneManager();
Ogre::Mesh* mesh = PrepareMesh(mesh_name, clone);
if (!mesh)
return false;
try
{
entity_ = sceneMgr->createEntity(world->GetUniqueObjectName("EC_Mesh_entity"), mesh->getName());
if (!entity_)
{
LogError("EC_Mesh::SetMesh: Could not set mesh " + mesh_name);
return false;
}
entity_->setRenderingDistance(drawDistance.Get());
entity_->setCastShadows(castShadows.Get());
entity_->setUserAny(Ogre::Any(static_cast<IComponent *>(this)));
// Set UserAny also on subentities
for(uint i = 0; i < entity_->getNumSubEntities(); ++i)
entity_->getSubEntity(i)->setUserAny(entity_->getUserAny());
if (entity_->hasSkeleton())
{
Ogre::SkeletonInstance* skel = entity_->getSkeleton();
// Enable cumulative mode on skeletal animations
if (skel)
skel->setBlendMode(Ogre::ANIMBLEND_CUMULATIVE);
}
// Make sure adjustment node is uptodate
Transform newTransform = nodeTransformation.Get();
adjustment_node_->setPosition(newTransform.pos);
adjustment_node_->setOrientation(newTransform.Orientation());
// Prevent Ogre exception from zero scale
adjustment_node_->setScale(Max(newTransform.scale, float3::FromScalar(0.0000001f)));
// Force a re-apply of all materials to this new mesh.
ApplyMaterial();
}
catch(Ogre::Exception& e)
{
LogError("EC_Mesh::SetMesh: Could not set mesh " + mesh_name + ": " + std::string(e.what()));
return false;
}
AttachEntity();
emit MeshChanged();
return true;
}
void MaterialEditorFrame::OnFileOpen(wxCommandEvent& event)
{
wxFileDialog * openDialog = new wxFileDialog(this, wxT("Choose a file to open"), wxEmptyString, wxEmptyString,
wxT("All Ogre Files (*.material;*.mesh;*.program;*.cg;*.vert;*.frag)|*.material;*.mesh;*.program;*.cg;*.vert;*.frag|Material Files (*.material)|*.material|Mesh Files (*.mesh)|*.mesh|Program Files (*.program)|*.program|Cg Files (*.cg)|*.cg|GLSL Files(*.vert; *.frag)|*.vert;*.frag|All Files (*.*)|*.*"));
if(openDialog->ShowModal() == wxID_OK)
{
wxString path = openDialog->GetPath();
if(path.EndsWith(wxT(".material")) || path.EndsWith(wxT(".program")))
{
MaterialScriptEditor* editor = new MaterialScriptEditor(EditorManager::getSingletonPtr()->getEditorNotebook());
editor->loadFile(path);
int index = (int)path.find_last_of('\\');
if(index == -1) index = (int)path.find_last_of('/');
editor->setName((index != -1) ? path.substr(index + 1, path.Length()) : path);
EditorManager::getSingletonPtr()->openEditor(editor);
}
else if(path.EndsWith(wxT(".cg")))
{
CgEditor* editor = new CgEditor(EditorManager::getSingletonPtr()->getEditorNotebook());
editor->loadFile(path);
int index = (int)path.find_last_of('\\');
if(index == -1) index = (int)path.find_last_of('/');
editor->setName((index != -1) ? path.substr(index + 1, path.Length()) : path);
EditorManager::getSingletonPtr()->openEditor(editor);
}
else if(path.EndsWith(wxT(".mesh")))
{
Ogre::SceneManager *sceneMgr = wxOgre::getSingleton().getSceneManager();
Ogre::Camera *camera = wxOgre::getSingleton().getCamera();
if(mEntity)
{
sceneMgr->getRootSceneNode()->detachObject(mEntity);
sceneMgr->destroyEntity(mEntity);
mEntity = 0;
}
static int meshNumber = 0;
Ogre::String meshName = Ogre::String("Mesh") + Ogre::StringConverter::toString(meshNumber++);
int index = (int)path.find_last_of('\\');
if(index == -1) index = (int)path.find_last_of('/');
wxString mesh = (index != -1) ? path.substr(index + 1, path.Length()) : path;
mEntity = sceneMgr->createEntity(meshName, mesh.GetData());
sceneMgr->getRootSceneNode()->attachObject(mEntity);
Ogre::AxisAlignedBox box = mEntity->getBoundingBox();
Ogre::Vector3 minPoint = box.getMinimum();
Ogre::Vector3 maxPoint = box.getMaximum();
Ogre::Vector3 size = box.getSize();
wxOgre::getSingleton().setZoomScale(max(size.x, max(size.y, size.z)));
wxOgre::getSingleton().resetCamera();
Ogre::Vector3 camPos;
camPos.x = minPoint.x + (size.x / 2.0);
camPos.y = minPoint.y + (size.y / 2.0);
Ogre::Real width = max(size.x, size.y);
camPos.z = (width / tan(camera->getFOVy().valueRadians())) + size.z / 2;
wxOgre::getSingleton().getCamera()->setPosition(camPos);
wxOgre::getSingleton().getCamera()->lookAt(0,0,0);
wxOgre::getSingleton().getLight()->setPosition(maxPoint * 2);
}
}
}
void CUsingControllersView::EngineSetup(void)
{
Ogre::Root *Root = ((CUsingControllersApp*)AfxGetApp())->m_Engine->GetRoot();
Ogre::SceneManager *SceneManager = NULL;
SceneManager = Root->createSceneManager(Ogre::ST_GENERIC, "Walking");
//
// Create a render window
// This window should be the current ChildView window using the externalWindowHandle
// value pair option.
//
Ogre::NameValuePairList parms;
parms["externalWindowHandle"] = Ogre::StringConverter::toString((long)m_hWnd);
parms["vsync"] = "true";
CRect rect;
GetClientRect(&rect);
Ogre::RenderTarget *RenderWindow = Root->getRenderTarget("Mouse Input");
if (RenderWindow == NULL)
{
try
{
m_RenderWindow = Root->createRenderWindow("Mouse Input", rect.Width(), rect.Height(), false, &parms);
}
catch(...)
{
MessageBox("Cannot initialize\nCheck that graphic-card driver is up-to-date", "Initialize Render System", MB_OK | MB_ICONSTOP);
exit(EXIT_SUCCESS);
}
}
// Load resources
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
// Create the camera
m_Camera = SceneManager->createCamera("Camera");
m_Camera->setNearClipDistance(0.5);
m_Camera->setFarClipDistance(5000);
m_Camera->setCastShadows(false);
m_Camera->setUseRenderingDistance(true);
m_Camera->setPosition(Ogre::Vector3(0.0, 0.0, 1000.0));
Ogre::SceneNode *CameraNode = NULL;
CameraNode = SceneManager->getRootSceneNode()->createChildSceneNode("CameraNode");
Ogre::Viewport* Viewport = NULL;
if (0 == m_RenderWindow->getNumViewports())
{
Viewport = m_RenderWindow->addViewport(m_Camera);
Viewport->setBackgroundColour(Ogre::ColourValue(0.8f, 0.8f, 0.8f));
}
// Alter the camera aspect ratio to match the viewport
m_Camera->setAspectRatio(Ogre::Real(rect.Width()) / Ogre::Real(rect.Height()));
Ogre::SceneNode *SphereNode = SceneManager->getRootSceneNode()->createChildSceneNode("Sphere", Ogre::Vector3(0,0,0));
Ogre::Entity *SphereEntity = SceneManager->createEntity("Sphere", "sphere.mesh");
SphereEntity->setMaterialName("Wall/Screen");
SphereNode->attachObject(SphereEntity);
SphereEntity->getParentNode()->scale(0.2,0.2,0.2);
m_Camera->lookAt(Ogre::Vector3(0.0, 0.0, 0.0));
#undef new
Ogre::ControllerFunctionRealPtr func(OGRE_NEW Ogre::WaveformControllerFunction(Ogre::WFT_SINE, 0.0, 1.0));
Ogre::ControllerValueRealPtr dest(OGRE_NEW SphereScale(SphereNode, 1.0));
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
Ogre::ControllerManager& ControllerManager = Ogre::ControllerManager::getSingleton();
m_SphereController = ControllerManager.createController(ControllerManager.getFrameTimeSource(), dest, func);
Root->renderOneFrame();
}
int main() {
Ogre::Root* root = new Ogre::Root();
root->addResourceLocation("/home/soulmerge/projects/Diplomarbeit/Prototype/resources/Ogre/", "FileSystem");
if (!root->restoreConfig() && !root->showConfigDialog()) {
throw 1;
}
root->initialise(false);
Ogre::SceneManager* sceneMgr = root->createSceneManager(Ogre::ST_GENERIC);
sceneMgr->setAmbientLight(Ogre::ColourValue::White * 10);
Ogre::RenderWindow* window = root->createRenderWindow("Ogre RenderWindow", 800, 600, false, NULL);
Ogre::Camera* cam1 = sceneMgr->createCamera("cam1");
Ogre::Camera* cam2 = sceneMgr->createCamera("cam2");
Ogre::Camera* cam3 = sceneMgr->createCamera("cam3");
Ogre::Camera* cam4 = sceneMgr->createCamera("cam4");
Ogre::Viewport* vp1 = window->addViewport(cam1, 1, 0 , 0 , 0.5, 0.5);
Ogre::Viewport* vp2 = window->addViewport(cam2, 2, 0.5, 0 , 0.5, 0.5);
Ogre::Viewport* vp3 = window->addViewport(cam3, 3, 0 , 0.5, 0.5, 0.5);
Ogre::Viewport* vp4 = window->addViewport(cam4, 4, 0.5, 0.5, 0.5, 0.5);
vp1->setBackgroundColour(Ogre::ColourValue(1, 1, 1));
vp2->setBackgroundColour(Ogre::ColourValue(1, 1, 1) * 0.95);
vp3->setBackgroundColour(Ogre::ColourValue(1, 1, 1) * 0.95);
vp4->setBackgroundColour(Ogre::ColourValue(1, 1, 1));
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
Ogre::Entity* model = sceneMgr->createEntity("model", "alexandria.mesh");
Ogre::SceneNode* modelNode1 = sceneMgr->getRootSceneNode()->createChildSceneNode("modelnode1");
modelNode1->attachObject(model);
cam1->setNearClipDistance(5);
cam2->setNearClipDistance(5);
cam3->setNearClipDistance(5);
cam4->setNearClipDistance(5);
/*
cam1->setPolygonMode(Ogre::PM_WIREFRAME);
cam2->setPolygonMode(Ogre::PM_WIREFRAME);
cam3->setPolygonMode(Ogre::PM_WIREFRAME);
cam4->setPolygonMode(Ogre::PM_WIREFRAME);
*/
Ogre::SceneNode* camNode1 = sceneMgr->getRootSceneNode()->createChildSceneNode("camnode1");
Ogre::SceneNode* camNode2 = sceneMgr->getRootSceneNode()->createChildSceneNode("camnode2");
Ogre::SceneNode* camNode3 = sceneMgr->getRootSceneNode()->createChildSceneNode("camnode3");
Ogre::SceneNode* camNode4 = sceneMgr->getRootSceneNode()->createChildSceneNode("camnode4");
camNode1->attachObject(cam1);
camNode2->attachObject(cam2);
camNode3->attachObject(cam3);
camNode4->attachObject(cam4);
Ogre::Quaternion q;
q.FromAngleAxis(Ogre::Degree(90), Ogre::Vector3::UNIT_Y);
camNode1->lookAt(Ogre::Vector3(-1, -1, -1), Ogre::Node::TS_LOCAL);
camNode2->setOrientation(q * camNode1->getOrientation());
camNode3->setOrientation(q * camNode2->getOrientation());
camNode4->setOrientation(q * camNode3->getOrientation());
camNode1->setPosition(100, 100, 100);
camNode2->setPosition(100, 100, -100);
camNode3->setPosition(-100, 100, -100);
camNode4->setPosition(-100, 100, 100);
while(true) {
Ogre::WindowEventUtilities::messagePump();
if (window->isClosed()) {
return 0;
}
if (!root->renderOneFrame()) {
return 0;
}
}
return 0;
}
void CSaveSceneView::EngineSetup(void)
{
Ogre::Root *Root = ((CSaveSceneApp*)AfxGetApp())->m_Engine->GetRoot();
Ogre::SceneManager *SceneManager = NULL;
SceneManager = Root->createSceneManager(Ogre::ST_GENERIC, "SaveScene");
//
// Create a render window
// This window should be the current ChildView window using the externalWindowHandle
// value pair option.
//
Ogre::NameValuePairList parms;
parms["externalWindowHandle"] = Ogre::StringConverter::toString((long)m_hWnd);
parms["vsync"] = "true";
CRect rect;
GetClientRect(&rect);
Ogre::RenderTarget *RenderWindow = Root->getRenderTarget("SaveScene");
if (RenderWindow == NULL)
{
try
{
m_RenderWindow = Root->createRenderWindow("SaveScene", rect.Width(), rect.Height(), false, &parms);
}
catch(...)
{
MessageBox("Cannot initialize\nCheck that graphic-card driver is up-to-date", "Initialize Render System", MB_OK | MB_ICONSTOP);
exit(EXIT_SUCCESS);
}
}
// Load resources
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
// Create the camera
m_Camera = SceneManager->createCamera("Camera");
m_Camera->setNearClipDistance(0.5);
m_Camera->setFarClipDistance(5000);
m_Camera->setCastShadows(false);
m_Camera->setUseRenderingDistance(true);
m_Camera->setPosition(Ogre::Vector3(200.0, 50.0, 100.0));
Ogre::SceneNode *CameraNode = NULL;
CameraNode = SceneManager->getRootSceneNode()->createChildSceneNode("CameraNode");
CameraNode->attachObject(m_Camera);
Ogre::Viewport* Viewport = NULL;
if (0 == m_RenderWindow->getNumViewports())
{
Viewport = m_RenderWindow->addViewport(m_Camera);
Viewport->setBackgroundColour(Ogre::ColourValue(0.0f, 0.0f, 0.0f));
}
// Alter the camera aspect ratio to match the viewport
m_Camera->setAspectRatio(Ogre::Real(rect.Width()) / Ogre::Real(rect.Height()));
Ogre::Entity *RobotEntity = SceneManager->createEntity("Robot", "robot.mesh");
Ogre::SceneNode *RobotNode = SceneManager->getRootSceneNode()->createChildSceneNode();
RobotNode->attachObject(RobotEntity);
Ogre::AxisAlignedBox Box = RobotEntity->getBoundingBox();
Ogre::Vector3 Center = Box.getCenter();
m_Camera->lookAt(Center);
int rc;
xmlDocPtr doc;
// Create a new Xmlm_XmlWriter for DOM, with no compression.
m_XmlWriter = xmlNewTextWriterDoc(&doc, 0);
// Start the document with the xml default for the version,
// encoding ISO 8859-1 and the default for the standalone
// declaration.
xmlTextWriterStartDocument(m_XmlWriter, NULL, MY_ENCODING, NULL);
SceneExplore(SceneManager);
xmlTextWriterEndDocument(m_XmlWriter);
xmlFreeTextWriter(m_XmlWriter);
xmlSaveFileEnc("1.scene", doc, MY_ENCODING);
xmlFreeDoc(doc);
}
void test()
{
Ogre::Root* pOgre = new Ogre::Root("", "");
pOgre->loadPlugin(RENDER_SYSTEM);
pOgre->setRenderSystem(pOgre->getAvailableRenderers().front());
pOgre->initialise(false);
Ogre::NameValuePairList lArgs;
//lArgs["externalWindowHandle"] = bk::format("%d", (bk::uint)l_window.get_handle()).astr;
Ogre::RenderWindow* pWindow = pOgre->createRenderWindow("Heart|Dockyard", 1024, 768, false, &lArgs);
Ogre::SceneManager* pSceneManager = pOgre->createSceneManager(Ogre::ST_GENERIC,"SceneManager");
pSceneManager->setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_ADDITIVE);
pSceneManager->setShadowCameraSetup(Ogre::ShadowCameraSetupPtr(new Ogre::FocusedShadowCameraSetup()));
pSceneManager->setAmbientLight(Ogre::ColourValue(0.1f, 0.1f, 0.1f));
Ogre::Camera* pCamera = pSceneManager->createCamera("Camera");
pCamera->setFixedYawAxis(true, Ogre::Vector3::UNIT_Z);
pCamera->setPosition(Ogre::Vector3(0.0f, 50.0f, 20.0f));
pCamera->lookAt(Ogre::Vector3(0.0f, 0.0f, 0.0f));
pCamera->setNearClipDistance(0.1f);
pCamera->setFarClipDistance(100.0f);
Ogre::Viewport* pViewport = pWindow->addViewport(pCamera);
pViewport->setBackgroundColour(Ogre::ColourValue(0.0f, 0.0f, 0.0f));
pCamera->setAspectRatio(Ogre::Real(pViewport->getActualWidth()) / Ogre::Real(pViewport->getActualHeight()));
Ogre::ResourceGroupManager::getSingleton().addResourceLocation("../data/dockyard.zip", "Zip", "Dockyard", true);
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
Ogre::MeshManager::getSingleton().createPlane("GroundPlane", "Dockyard", Ogre::Plane(0.0f, 0.0f, 1.0f, 0.0f), 100.0f, 100.0f, 100, 100, true, 1, 3.0f, 3.0f);
Ogre::Entity* pGroundEntity = pSceneManager->createEntity("GroundPlane");
pGroundEntity->setMaterialName("Examples/Rockwall");
pGroundEntity->setCastShadows(false);
pGroundEntity->getSubEntity(0)->getMaterial()->setShadingMode(Ogre::SO_PHONG);
Ogre::SceneNode* pGroundNode = pSceneManager->getRootSceneNode()->createChildSceneNode();
pGroundNode->attachObject(pGroundEntity);
Ogre::Entity* pCubeEntity = pSceneManager->createEntity("Cube", Ogre::SceneManager::PT_CUBE);
pCubeEntity->setMaterialName("Examples/10PointBlock");
pCubeEntity->setCastShadows(true);
Ogre::SceneNode* pCubeNode = pSceneManager->getRootSceneNode()->createChildSceneNode();
pCubeNode->attachObject(pCubeEntity);
pCubeNode->setPosition(0.0f, 0.0f, 5.f);
pCubeNode->setScale(0.1f, 0.1f, 0.1f);
Ogre::ColourValue lColour1(1.0f, 1.0f, 1.0f);
Ogre::ColourValue lColour2(1.0f, 1.0f, 1.0f);
Ogre::ColourValue lColour3(1.0f, 1.0f, 1.0f);
Ogre::Light* pLight1 = pSceneManager->createLight();
pLight1->setType(Ogre::Light::LT_SPOTLIGHT);
pLight1->setPosition(30.0f, 30.0f, 30.0f);
pLight1->setDirection(-1.0f, -1.0f, -1.0f);
pLight1->setSpotlightRange(Ogre::Degree(30), Ogre::Degree(50));
pLight1->setDiffuseColour(lColour1 * 0.5f);
Ogre::Light* pLight2 = pSceneManager->createLight();
pLight2->setType(Ogre::Light::LT_SPOTLIGHT);
pLight2->setPosition(-30.0f, 30.0f, 30.0f);
pLight2->setDirection(1.0f, -1.0f, -1.0f);
pLight2->setSpotlightRange(Ogre::Degree(30), Ogre::Degree(50));
pLight2->setDiffuseColour(lColour2 * 0.5f);
Ogre::Light* pLight3 = pSceneManager->createLight();
pLight3->setType(Ogre::Light::LT_SPOTLIGHT);
pLight3->setPosition(30.0f, -30.0f, 30.0f);
pLight3->setDirection(-1.0f, 1.0f, -1.0f);
pLight3->setSpotlightRange(Ogre::Degree(30), Ogre::Degree(50));
pLight3->setDiffuseColour(lColour3 * 0.5f);
Ogre::Overlay* pMenuOverlay = Ogre::OverlayManager::getSingleton().create("Menu");
Ogre::OverlayElement* pMenu = Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", "Menu");
pMenu->setMetricsMode(Ogre::GMM_PIXELS);
pMenu->setWidth(200);
pMenu->setHeight(200);
pMenu->setTop(30);
pMenu->setLeft(30);
pMenu->setMaterialName("Examples/BumpyMetal");
if (pMenu->isContainer()) pMenuOverlay->add2D(static_cast<Ogre::OverlayContainer*>(pMenu));
pMenuOverlay->show();
pOgre->startRendering();
}
