//-------------------------------------------------------------------------------------------
void MagickWidget::loadMesh(Ogre::MeshPtr pMesh)
{
QString directory(OgitorsRoot::getSingletonPtr()->GetProjectOptions()->ProjectDir.c_str());
if(directory.isEmpty())
directory = "./";
QDir(directory).mkpath("entitycache");
Ogre::TexturePtr texture = Ogre::TextureManager::getSingleton().createManual( "MeshMagickTex",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D,
512, 512, 0, Ogre::PF_R8G8B8A8 , Ogre::TU_RENDERTARGET );
Ogre::RenderTexture *rttTex = texture->getBuffer()->getRenderTarget();
Ogre::SceneManager *mSceneMgr = Ogre::Root::getSingletonPtr()->createSceneManager("OctreeSceneManager", "MeshMagickTexMgr");
Ogre::Light *dirl = mSceneMgr->createLight("DisplayLight");
dirl->setDirection(-1,-1,-1);
dirl->setDiffuseColour(1,1,1);
dirl->setType(Ogre::Light::LT_DIRECTIONAL);
Ogre::Camera* RTTCam = mSceneMgr->createCamera("MeshMagickCam");
RTTCam->setNearClipDistance(0.01F);
RTTCam->setFarClipDistance(0);
RTTCam->setAspectRatio(1);
RTTCam->setFOVy(Ogre::Degree(90));
RTTCam->setPosition(0,0,1);
RTTCam->lookAt(0,0,0);
Ogre::Viewport *v = rttTex->addViewport( RTTCam );
v->setClearEveryFrame( true );
v->setBackgroundColour(Ogre::ColourValue(0,0,0));
Ogre::Entity *mEntity;
mEntity = mSceneMgr->createEntity("scbDisplay", pMesh->getName());
mSceneMgr->getRootSceneNode()->attachObject(mEntity);
Ogre::Vector3 vSize = mEntity->getBoundingBox().getHalfSize();
Ogre::Vector3 vCenter = mEntity->getBoundingBox().getCenter();
vSize += Ogre::Vector3(vSize.z, vSize.z, vSize.z);
float maxsize = std::max(std::max(vSize.x,vSize.y),vSize.z);
vSize = Ogre::Vector3(0, 0, maxsize * 1.15f) + vCenter;
RTTCam->setPosition(vSize.x,vSize.y,vSize.z);
RTTCam->lookAt(vCenter.x,vCenter.y,vCenter.z);
rttTex->update();
Ogre::String imagefile = OgitorsUtils::QualifyPath(directory.toStdString() + "/entitycache/meshmagick.png");
rttTex->writeContentsToFile(imagefile);
mEntity->detachFromParent();
mSceneMgr->destroyEntity(mEntity);
rttTex->removeAllViewports();
Ogre::Root::getSingletonPtr()->destroySceneManager(mSceneMgr);
mDisplayWidget->setImage(QString(imagefile.c_str()));
}
void CSceneEditorView::OnEditsceneAddentity()
{
CEntityCreatorDlg EntityCreatorDlg;
if (IDOK == EntityCreatorDlg.DoModal())
{
HTREEITEM Selected = m_SceneManagerDlg->m_SceneTree.GetSelectedItem();
m_SceneManagerDlg->m_SceneTree.InsertItem(EntityCreatorDlg.m_EntityName, Selected);
Ogre::String SceneNodeName = m_SceneManagerDlg->m_SceneTree.GetItemText(Selected);
Ogre::Entity *Entity = m_SceneManager->createEntity(Ogre::String(EntityCreatorDlg.m_EntityName), Ogre::String(EntityCreatorDlg.m_MeshName));
Ogre::SceneNode *SceneNode = m_SceneManager->getSceneNode(SceneNodeName);
SceneNode->attachObject(Entity);
Ogre::AxisAlignedBox Box = Entity->getBoundingBox();
Ogre::Vector3 Center = Box.getCenter();
m_Camera->lookAt(Center);
m_SceneManagerDlg->m_SceneTree.Expand(Selected, TVE_EXPAND);
if (m_Root != NULL)
{
m_Root->renderOneFrame();
}
}
}
void VLogicModel::_updateBoundingBox()
{
if (VNULL == mFullBoundingBox)
{
mFullBoundingBox = new Ogre::AxisAlignedBox();
}
mFullBoundingBox->setNull();
for (VEntityMap::iterator itr = mEntities.begin(); itr != mEntities.end(); ++itr)
{
Ogre::Entity *entity = itr->second.mEntity;
if (entity != VNULL)
{
mFullBoundingBox->merge(entity->getBoundingBox());
}
}
VAttachedModelOriginSceneNodes::const_iterator itr = mAttachedModelOriginSceneNodes.begin();
while (itr != mAttachedModelOriginSceneNodes.end())
{
if (itr->first)
{
mFullBoundingBox->merge(itr->first->_getFullBoundingBox());
}
++itr;
}
}
void InputGeometry::_calculateExtents()
{
Ogre::Entity* ent = _sourceMeshes[0];
Ogre::AxisAlignedBox sourceMeshBB = ent->getBoundingBox();
Ogre::Matrix4 transform;
transform = _referenceNode->_getFullTransform().inverse() * ent->getParentSceneNode()->_getFullTransform();
sourceMeshBB.transform(transform);
Ogre::Vector3 min = sourceMeshBB.getMinimum();
Ogre::Vector3 max = sourceMeshBB.getMaximum();
for(auto itr = _sourceMeshes.begin(); itr != _sourceMeshes.end(); ++itr)
{
Ogre::Entity* tmpEnt = *itr;
transform = _referenceNode->_getFullTransform().inverse() * tmpEnt->getParentSceneNode()->_getFullTransform();
sourceMeshBB = ent->getBoundingBox();
sourceMeshBB.transform(transform);
Ogre::Vector3 min2 = sourceMeshBB.getMinimum();
if(min2.x < min.x)
min.x = min2.x;
if(min2.y < min.y)
min.y = min2.y;
if(min2.z < min.z)
min.z = min2.z;
Ogre::Vector3 max2 = sourceMeshBB.getMaximum();
if(max2.x > max.x)
max.x = max2.x;
if(max2.y > max.y)
max.y = max2.y;
if(max2.z > max.z)
max.z = max2.z;
}
if(!_boundMin)
{
_boundMin = new float[3];
}
if(!_boundMax)
{
_boundMax = new float[3];
}
Utility::vector3_toFloatPtr(min,_boundMin);
Utility::vector3_toFloatPtr(max,_boundMax);
}
/* -----------------------------------------------------------------------
| build bullet box shape
|
| : default create 125 (5x5x5) dynamic object
----------------------------------------------------------------------- */
bool
buildBoxShapeArray(Ogre::SceneManager* sceneMgr, btDynamicsWorld* dynamicsWorld, btAlignedObjectArray<btCollisionShape*>& collisionShapes,
const btVector3& array_size, btScalar scale)
{
btTransform startTransform;
startTransform.setIdentity();
btScalar mass(1.f);
btVector3 localInertia(0,0,0);
btBoxShape* colShape = new btBoxShape(btVector3(scale, scale, scale));
btAssert(colShape);
colShape->calculateLocalInertia(mass,localInertia);
collisionShapes.push_back(colShape);
float start_x = - array_size.getX()/2;
float start_y = array_size.getY();
float start_z = - array_size.getZ()/2;
int index = 0;
for (int k=0;k<array_size.getY();k++)
{
for (int i=0;i<array_size.getX();i++)
{
for(int j=0;j<array_size.getZ();j++)
{
startTransform.setOrigin(scale * btVector3(
btScalar(2.0*i + start_x),
btScalar(20+2.0*k + start_y),
btScalar(2.0*j + start_z)));
//using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
btDefaultMotionState* myMotionState = new btDefaultMotionState(startTransform);
btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,myMotionState,colShape,localInertia);
btRigidBody* body = new btRigidBody(rbInfo);
body->setContactProcessingThreshold(BT_LARGE_FLOAT);
if (sceneMgr)
{
Ogre::Entity* ent = sceneMgr->createEntity("ent_" + Ogre::StringConverter::toString(index++),"Barrel.mesh");
Ogre::SceneNode* node = sceneMgr->getRootSceneNode()->createChildSceneNode("node_box_" + Ogre::StringConverter::toString(index++));
node->attachObject(ent);
node->setPosition(startTransform.getOrigin().getX(), startTransform.getOrigin().getY(), startTransform.getOrigin().getZ());
const Ogre::AxisAlignedBox& aabb = ent->getBoundingBox();
const Ogre::Vector3& boxScale = (aabb.getMaximum() - aabb.getMinimum())/2.0f;
node->scale(scale/boxScale.x, scale/boxScale.y, scale/boxScale.z);
body->setUserPointer((void*)node);
}
dynamicsWorld->addRigidBody(body);
}
}
}
return true;
}
Monster* MonsterFactory::createInstance(SceneManager* sceneMgr, Maze* maze, MonsterManager* monsterMgr)
{
Ogre::SceneNode* monsterNode = sceneMgr->getRootSceneNode()->createChildSceneNode();
Ogre::Entity* entity = sceneMgr->createEntity(mParams["mesh"]);
//entity->setCastShadows(true);
monsterNode->attachObject(entity);
Monster* mon;
mon = new Monster(monsterNode, entity, maze, monsterMgr);
if (mParams.find("radius") != mParams.end())
mon->setRadius((float)atof(mParams["radius"].c_str()));
if (mParams.find("blood") != mParams.end())
{
mon->setBlood((float)atof(mParams["blood"].c_str()));
mon->setMaxBlood(mon->getBlood());
}
if (mParams.find("speed") != mParams.end())
mon->setSpeed((float)atof(mParams["speed"].c_str()));
if (mParams.find("spell") != mParams.end())
mon->setType((mParams["spell"].c_str()));
if (mParams.find("scale") != mParams.end())
{
float scale = (float)atof(mParams["scale"].c_str());
mon->setScale(scale, scale, scale);
}
//mon->setScale(2, 2, 2);
// 创建怪物头顶血条
BillboardSet* healthHUD = sceneMgr->createBillboardSet();
healthHUD->setMaterialName("Glass/Billboard");
healthHUD->setDefaultWidth(100);
healthHUD->setDefaultHeight(14);
SceneNode* hudNode = monsterNode->createChildSceneNode();
hudNode->attachObject(healthHUD);
/*Billboard* b2 = healthHUD->createBillboard(0, entity->getBoundingBox().getSize().y, 0);
b2->setColour(ColourValue::Black);*/
Billboard* b = healthHUD->createBillboard(0, entity->getBoundingBox().getSize().y, 0);
//b->setColour(ColourValue(0, 0.75f, 0));
//b->setDimensions(96, 12);
mon->setHealthHUD(healthHUD);
// 测试粒子by kid
Ogre::ParticleSystem* ps = sceneMgr->createParticleSystem(monsterNode->getName() + "frozen", "Glass/MonsterFrozen");
monsterNode->attachObject(ps);
ps->setVisible(false);
ps = sceneMgr->createParticleSystem(monsterNode->getName() + "burn", "Glass/MonsterBurn");
monsterNode->attachObject(ps);
ps->setVisible(false);
return mon;
}
int Create_Static_Object::create(Ogre::SceneManager *mainSceneMgr) {
if (meshName.empty() ) {
std::cout << "Whoops, what do you think you're doing? You didn't give a mesh name!" << std::endl;
return 0;
}
if (meshFile.empty() ) {
std::cout << "Well what did you expect? There's no mesh file to load!" << std::endl;
return 0;
}
Ogre::SceneNode *nodeStaticObject = mainSceneMgr->getRootSceneNode()->createChildSceneNode(meshName, location, rotation);
Ogre::Entity *entityStaticObject = mainSceneMgr->createEntity(meshName, meshFile);
if (!materialName.empty() ){
entityStaticObject->setMaterialName(materialName);
}
entityStaticObject->setCastShadows(shadow);
nodeStaticObject->attachObject(entityStaticObject);
nodeStaticObject->showBoundingBox(showBBox);
nodeStaticObject->scale(scale);
//Create the ground shape.
BtOgre::StaticMeshToShapeConverter ogreBulletShapeConverter(entityStaticObject);
if (bulletCollision == "sphere"){
shapeStaticObject = ogreBulletShapeConverter.createSphere();
} else if (bulletCollision == "box"){
shapeStaticObject = ogreBulletShapeConverter.createBox();
offsetLocation = entityStaticObject->getBoundingBox().getHalfSize();
location.y = location.y - offsetLocation.y;
} else if (bulletCollision == "trimesh"){
shapeStaticObject = ogreBulletShapeConverter.createTrimesh();
} else if (bulletCollision == "cylinder"){
shapeStaticObject = ogreBulletShapeConverter.createCylinder();
} else if (bulletCollision == "convex"){
shapeStaticObject = ogreBulletShapeConverter.createConvex();
}else{
return 0;
}
shapeStaticObject->setLocalScaling(BtOgre::Convert::toBullet(nodeStaticObject->getScale() ) );
//Create MotionState (no need for BtOgre here, you can use it if you want to though).
stateStaticObject = new btDefaultMotionState(btTransform( BtOgre::Convert::toBullet(rotation), BtOgre::Convert::toBullet(location) ) );
//Create the Body.
bodyStaticObject = new btRigidBody(0, stateStaticObject, shapeStaticObject, btVector3(0,0,0));
Globals::phyWorld->addRigidBody(bodyStaticObject);
return 1;
}
//-------------------------------------------------------
void Ground::LoadFromHeightMap(std::shared_ptr<Ogre::Image> hmap, Ogre::SceneNode* parentNode)
{
mImage = hmap;
Ogre::Box box = Ogre::Box(0, 0, mImage->getWidth(), mImage->getHeight());
mRootNode = parentNode->createChildSceneNode();
mGlobalBoundingBox.setNull();
Ogre::Material* groundMaterial = CreateGroundMaterialTextured("Material/" + CLASS_NAME + "/Textured", mImage.get());
static const float VERTEX_STEP = 1.0f;
static const float HEIGHT_STEP = 8.0f;
float offsetX = GROUND_SIZE * VERTEX_STEP / 2.0f;
float offsetY = GROUND_SIZE * VERTEX_STEP / 2.0f;
size_t width = mImage->getWidth();
size_t height = mImage->getHeight();
float texStep = 1.0f / REGIONS_NUMBER;
size_t texRegionWidth = static_cast<size_t>(std::ceil(static_cast<float>(width) / REGIONS_NUMBER));
size_t texRegionHeight = static_cast<size_t>(std::ceil(static_cast<float>(height) / REGIONS_NUMBER));
for (size_t y = 0; y < REGIONS_NUMBER; ++y)
{
size_t top = y * texRegionHeight;
for (size_t x = 0; x < REGIONS_NUMBER; ++x)
{
size_t left = x * texRegionWidth;
Ogre::Box roi = Ogre::Box(left, height - std::min(top + texRegionHeight + 1, height), std::min(left + texRegionWidth + 1, width), height - top);
Ogre::MeshPtr mesh = CreateRegion(y * REGIONS_NUMBER + x, groundMaterial->getName(), roi,
Ogre::Vector3(x * VERTEX_STEP * REGION_SIZE - offsetX, y * VERTEX_STEP * REGION_SIZE - offsetY, 0.0f),
Ogre::Vector3(VERTEX_STEP, VERTEX_STEP, HEIGHT_STEP),
Ogre::Vector2(x * texStep, 1.0f - (y + 1) * texStep));
Ogre::Entity* entity = mSceneManager->createEntity(mesh);
auto node = mRootNode->createChildSceneNode();
node->attachObject(entity);
node->showBoundingBox(true);
mGlobalBoundingBox.merge(entity->getBoundingBox());
mEntities.push_back(entity);
}
}
}
Ogre::SceneNode* createBox(Ogre::SceneManager* sceneMgr, Ogre::String name)
{
// create an ordinary Ogre mesh with texture
Ogre::Entity* boxEnt = sceneMgr->createEntity(name , "cube.mesh");
// we need the bounding box of the cube.mesh to set the size of the Bullet box
Ogre::AxisAlignedBox boxBb = boxEnt->getBoundingBox();
//Ogre::Vector3 size = boxBb.getSize();
boxEnt->setMaterialName("Examples/BumpyMetal");
// create the node
Ogre::SceneNode* boxNode = sceneMgr->getRootSceneNode()->createChildSceneNode();
boxNode->attachObject( boxEnt );
return boxNode;
}
void OgreColladaContentImporter::sceneNodeCreated(Ogre::SceneNode* pNode, FCDSceneNode* pFColladaSceneNode)
{
NxOgre::ActorParams actorParams;
NxOgre::ShapeParams shapeParams;
Ogre::Vector3 boxSize;
Ogre::Vector3 scale;
Ogre::Entity *pEntity;
std::list<Ogre::Entity*> entityList;
std::list<Ogre::Entity*>::iterator entityListIter;
NxVec3 row;
pEntity = NULL;
Ogre::SceneNode::ObjectIterator iter = pNode->getAttachedObjectIterator();
while (iter.hasMoreElements())
{
pEntity = dynamic_cast<Ogre::Entity*>(iter.getNext());
if (pEntity != NULL)
{
entityList.push_back(pEntity);
}
}
shapeParams.setToDefault();
//scale = pNode->_getDerivedScale();
//shapeParams.mMeshScale = NxVec3(scale.x, scale.y, scale.z);
for (entityListIter = entityList.begin(); entityListIter != entityList.end(); ++entityListIter)
{
pEntity = *entityListIter;
boxSize = pEntity->getBoundingBox().getSize();
pNode->detachObject(pEntity);
actorParams.setToDefault();
actorParams.mMass = 0.0f;
actorParams.mBodyFlags |= NX_BF_KINEMATIC;
GameObjectFactory::getSingleton().makeBody(pEntity->getName(), pNode, pEntity, scene
,new NxOgre::CubeShape(boxSize.x, boxSize.y, boxSize.z, shapeParams), actorParams);
}
sceneNodes.push_back(pNode);
}
void Player::setupNodes (Ogre::SceneManager* sceneManager)
{
// Create the nodes
mPlayerNode = sceneManager->getRootSceneNode()->createChildSceneNode("PlayerNode");
mPlayerCameraNode = mPlayerNode->createChildSceneNode("PlayerCameraNode");
mCharacterNode = mPlayerNode->createChildSceneNode("PlayerCharacterNode");
mTargettingPathNode = mPlayerNode->createChildSceneNode("PlayerPathNode");
mTargettingEndNode = sceneManager->getRootSceneNode()->createChildSceneNode("TargettingEndNode");
mTargettingPathNode->setVisible(false);
mPlayerCameraNode->setPosition(0, 100, 200);
// Add the entities
// Add player
Ogre::Entity* playerEntity = sceneManager->createEntity("PlayerCharacter", "potato.mesh");
Ogre::AxisAlignedBox bb = playerEntity->getBoundingBox();
mPlayerHeight = (bb.getMaximum().y - bb.getMinimum().y) * 0.1f * 0.5f;
mCharacterNode->attachObject(playerEntity);
mCharacterNode->setScale(0.1f, 0.1f, 0.1f);
mCharacterNode->setPosition(0, 0, 0);
// Add target marker
mTargettingEndNode = sceneManager->getRootSceneNode()->createChildSceneNode("TargetNode");
Ogre::Entity* targetEntity = sceneManager->createEntity("TargetEntity", "sphere.mesh");
mTargettingEndNode->attachObject(targetEntity);
targetEntity = sceneManager->createEntity("TargetEntity2", "column.mesh");
mTargettingEndNode->attachObject(targetEntity);
mTargettingEndNode->setScale(0.1f, 0.1f, 0.1f);
mTargettingEndNode->setPosition(0, 0, 0);
// Billboard set
/*mTargettingEndBBS = sceneManager->createBillboardSet("TargetBillboardSet", 2);
sceneManager->getRootSceneNode()->attachObject(mTargettingEndBBS);
mTargettingEndBBS->setMaterialName("Examples/Flare");
mTargettingEndBBS->setVisible(true);
mTargettingEndBBS->createBillboard(0, 300, 0, Ogre::ColourValue(0.5f, 0.6f, 1.0f));
mTargettingEndBBS->setDefaultDimensions(100, 100);
mTargettingEndBBS->setBillboardType(Ogre::BBT_ORIENTED_COMMON);
mTargettingEndBBS->setCommonUpVector(Ogre::Vector3(0, 1, 0));*/
}
bool TutorialApplication::mouseReleased(const OIS::MouseEvent &arg, OIS::MouseButtonID id)
{
if (m_mode == TrollMode) {
const Vector3 p = m_cursorNode->getPosition();
m_ogres.push_back(p);
Ogre::Entity *troll = m_SceneMgr->createEntity("ogrehead.mesh");
Vector3 bounds = troll->getBoundingBox().getSize();
Real dim = std::max({bounds.x, bounds.y, bounds.z});
Real scale = GRID_SPACING / dim;
bounds = bounds * scale * 0.5f;
Ogre::SceneNode *node = m_SceneMgr->getRootSceneNode()->createChildSceneNode();
node->setPosition(p.x + bounds.x, p.y + bounds.y, p.z + bounds.z);
// node->showBoundingBox(true);
node->scale(scale, scale, scale);
node->attachObject(troll);
}
return BaseApplication::mouseReleased(arg, id);
}
void MapManager::AddObstacle(MapArea* area, Objects* input)
{
if(input->mLoaded)
return;
char areaString[30];
sprintf(areaString, "map_area_%d", area->getIndex());
//get the area node from map node.
Ogre::SceneNode* areaNode = (Ogre::SceneNode*)mMapNode->getChild(Ogre::String(areaString));
char cubeString[30];
sprintf(cubeString, "cube_%d", input->index);
Ogre::Entity* cubeEntity = mSceneMgr->createEntity(Ogre::String(cubeString),"cube.mesh");
cubeEntity->setMaterialName("Cube");
//cubeEntity->getMesh()->setAutoBuildEdgeLists(true);
//cubeEntity->getMesh()->buildEdgeList();
cubeEntity->setCastShadows(false);
//create a node for the cube
Ogre::SceneNode* cubeNode = areaNode->createChildSceneNode(Ogre::String(cubeString));
//attach the cube to the node
cubeNode->attachObject(cubeEntity);
//move the cube to it's position
cubeNode->setPosition(input->mPosition);
//cube entity actual size = 100 by 100 by 100
Ogre::Vector3 scale;
scale.x = Ogre::Real(0.01f)*input->sizeWidth;
scale.y = 0.1f;
scale.z = Ogre::Real(0.01f)*input->sizeHeight;
cubeNode->setScale(scale);
input->mLoaded = true;
Ogre::Vector3 size = cubeEntity->getBoundingBox().getSize();
size /= 2.f;
size *= 0.96f;
//size rescale. refer to prac07 for full calculation
size.x *= Ogre::Real(0.01f)*input->sizeWidth;
size.y *= Ogre::Real(0.1f);
size.z *= Ogre::Real(0.01f)*input->sizeHeight;
OgreBulletCollisions::BoxCollisionShape *sceneBoxShape = new OgreBulletCollisions::BoxCollisionShape(size);
OgreBulletDynamics::RigidBody *boxBody = new OgreBulletDynamics::RigidBody("BoxRigid" + Ogre::StringConverter::toString(input->index),
PhysicManager::getSingletonPtr()->getPhysicWorld(),
PhysicManager::COL_OBSTACLE,
PhysicManager::mObstacleCollideWith);
boxBody->setStaticShape(cubeNode, sceneBoxShape,
1.f,
1.f,
input->mPosition,
Ogre::Quaternion(0,0,0,1));
mRigidBodyList.push_back(boxBody);
mNumEntitiesInstanced++;
}
void CResourceManagementView::EngineSetup(void)
{
CEngine* Engine = ((CResourceManagementApp*)AfxGetApp())->m_Engine;
Ogre::Root *Root = Engine->GetRoot();
Ogre::SceneManager *SceneManager = NULL;
SceneManager = Root->createSceneManager(Ogre::ST_GENERIC, "ResourceManagement");
//
// 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("Resource Management");
if (RenderWindow == NULL)
{
try
{
m_RenderWindow = Root->createRenderWindow("Resource Management", 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);
}
}
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));
m_Camera->lookAt(0.0, 0.0, 0.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, 1.0f, 0.8f));
}
// Alter the camera aspect ratio to match the viewport
m_Camera->setAspectRatio(Ogre::Real(rect.Width()) / Ogre::Real(rect.Height()));
Ogre::StringVector Groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
Ogre::Entity *MobiusEntity = Engine->m_StlFileManager->createEntity("Mobius", "1_4.stl");
Ogre::SceneNode *MobiusNode = SceneManager->getRootSceneNode()->createChildSceneNode();
MobiusNode->attachObject(MobiusEntity);
Ogre::AxisAlignedBox MobiusBox = MobiusEntity->getBoundingBox();
Ogre::Vector3 MobiusCenter = MobiusBox.getCenter();
m_Camera->lookAt(MobiusCenter);
Ogre::Real Radius = MobiusEntity->getBoundingRadius();
m_Camera->setPosition(300, 100, 200);
m_Camera->setPolygonMode(Ogre::PM_WIREFRAME);
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
#else
int main (int argc, char *argv[]) {
#endif
Ogre::Root *ogre;
Ogre::RenderWindow *window;
Ogre::SceneManager *sceneMgr;
Ogre::SceneManager *guiSceneMgr;
Ogre::Camera *camera;
Ogre::Camera *guiCamera;
// fire up an Ogre rendering window. Clearing the first two (of three) params will let us
// specify plugins and resources in code instead of via text file
ogre = new Ogre::Root("", "");
#if defined(_DEBUG)
ogre->loadPlugin("RenderSystem_GL_d");
#else
ogre->loadPlugin("RenderSystem_GL");
#endif
Ogre::RenderSystemList *renderSystems = NULL;
Ogre::RenderSystemList::iterator r_it;
renderSystems = ogre->getAvailableRenderers();
r_it = renderSystems->begin();
ogre->setRenderSystem(*r_it);
ogre->initialise(false);
// load common plugins
#if defined(_DEBUG)
//ogre->loadPlugin("Plugin_CgProgramManager_d");
ogre->loadPlugin("Plugin_OctreeSceneManager_d");
#else
//ogre->loadPlugin("Plugin_CgProgramManager");
ogre->loadPlugin("Plugin_OctreeSceneManager");
#endif
// load the basic resource location(s)
Ogre::ResourceGroupManager::getSingleton().addResourceLocation("resource", "FileSystem", "General");
Ogre::ResourceGroupManager::getSingleton().addResourceLocation("resource/gui.zip", "Zip", "GUI");
Ogre::ResourceGroupManager::getSingleton().addResourceLocation("meshes", "FileSystem", "Meshes");
#if defined(WIN32)
Ogre::ResourceGroupManager::getSingleton().addResourceLocation("c:\\windows\\fonts", "FileSystem", "GUI");
#endif
Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("General");
Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("GUI");
Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("Meshes");
// setup main window; hardcode some defaults for the sake of presentation
Ogre::NameValuePairList opts;
opts["resolution"] = "1024x768";
opts["fullscreen"] = "false";
opts["vsync"] = "false";
// create a rendering window with the title "CDK"
window = ogre->createRenderWindow("Bouwgame Client v0.1", 1024, 768, false, &opts);
// since this is basically a CEGUI app, we can use the ST_GENERIC scene manager for now; in a later article
// we'll see how to change this
sceneMgr = ogre->createSceneManager(Ogre::ST_GENERIC);
guiSceneMgr = ogre->createSceneManager(Ogre::ST_GENERIC);
guiCamera = guiSceneMgr->createCamera("GUICamera");
guiCamera->setNearClipDistance(5);
camera = sceneMgr->createCamera("camera");
camera->setNearClipDistance(5);
Ogre::Viewport* vp = window->addViewport(guiCamera);
vp->setBackgroundColour(Ogre::ColourValue(0.2f,0.2f,0.8f));
/* ambient light */
sceneMgr->setAmbientLight(Ogre::ColourValue(0.8, 0.8, 0.8));
sceneMgr->setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_ADDITIVE);
/* meshes */
Ogre::Entity* ent = sceneMgr->createEntity( "BouwPlaatsEntity", "world.mesh" );
Ogre::SceneNode* node = sceneMgr->getRootSceneNode()->createChildSceneNode("BouwNode", Ogre::Vector3(0, 0, 0));
node->attachObject(ent);
//node->setScale(Ogre::Vector3(0.7,0.7,0.7));
ent = sceneMgr->createEntity("plaats", "bouwplaats_step_00.mesh");
Ogre::Vector3 size = ent->getBoundingBox().getSize();
Ogre::LogManager::getSingletonPtr()->getDefaultLog()->logMessage(Ogre::String("Bouwplaats size: ") + Ogre::StringConverter::toString(size));
size = ent->getBoundingBox().getMaximum();
Ogre::LogManager::getSingletonPtr()->getDefaultLog()->logMessage(Ogre::String("Bouwplaats max: ") + Ogre::StringConverter::toString(size));
size = ent->getBoundingBox().getMinimum();
Ogre::LogManager::getSingletonPtr()->getDefaultLog()->logMessage(Ogre::String("Bouwplaats min: ") + Ogre::StringConverter::toString(size));
Ogre::Entity* ent1 = sceneMgr->createEntity( "KeetEntity", "keet.mesh" );
Ogre::SceneNode* scenenode = sceneMgr->getRootSceneNode()->createChildSceneNode("KeetNode", Ogre::Vector3(0, 0, 0));
scenenode->attachObject(ent1);
Ogre::Entity* ent2 = sceneMgr->createEntity( "HekjeEntity", "hekje.mesh" );
Ogre::SceneNode* scenenode2 = sceneMgr->getRootSceneNode()->createChildSceneNode("HekjeNode", Ogre::Vector3(0, -100, 0));
scenenode2->attachObject(ent2);
scenenode2->setScale(Ogre::Vector3(400,0,100));
// most examples get the viewport size to calculate this; for now, we'll just
// set it to 4:3 the easy way
camera->setAspectRatio((Ogre::Real)1.333333);
camera->setPosition(Ogre::Vector3(40,100,10));
guiCamera->setPosition(0, 0, 300);
guiCamera->lookAt(node->getPosition());
// this next bit is for the sake of the input handler
unsigned long hWnd;
window->getCustomAttribute("WINDOW", &hWnd);
// set up the input handlers
Simulation *sim = new Simulation();
InputHandler *handler = new InputHandler(sim, hWnd, camera);
DataManager *dataManager = new DataManager();
GameAI* gameAI = new GameAI(dataManager);
//Create Network
Network * net = new Network(dataManager);
//net->start();
sim->requestStateChange(GUI);
gui = new GuiManager();
// networkshit
while(!net->isConnected())
{
Sleep(1000);
}
net->Send(GETGROUPS, "", "", NULL);
net->Send(LOGIN, "gast", "gast", 1);
gui->setSimulation(sim);
gui->init("", ogre, guiSceneMgr, window);
gui->activate("main");
handler->setWindowExtents(1024,768);
SimulationState cState;
Ogre::WindowEventUtilities::addWindowEventListener(window, handler);
DWORD tFrameStart = 0x0; //in miliseconds
signed long tFrameX = 0x0;
float tDelta2 = 0.0f; //in seconds
float m_fps = 60.0f;
tFrameStart = GetTickCount();
float tDelta;
//testAI->calculateNextPath(40,10);
while ((cState = sim->getCurrentState()) != SHUTDOWN) {
tFrameX = GetTickCount() - tFrameStart;
tDelta2 = (float)tFrameX / 1000.0f;
if (tDelta2 > 3600) // tDelta > 1 hour
tDelta2 = 1.0f / m_fps; //< System tick count has highly likely overflowed, so get approximation
tFrameStart = GetTickCount();
m_fps = (int)(1.0f / tDelta2);
tDelta = tDelta2;
handler->capture();
handler->update(tDelta);
gui->update(tDelta);
//if (sim->getCurrentState() == SIMULATION || sim->getCurrentState() == SIMULATION_MOUSELOOK)
// testAI->update(tDelta);
// run the message pump (Eihort)
Ogre::WindowEventUtilities::messagePump();
ogre->renderOneFrame();
if (sim->getCurrentState() != cState) {
handler->StateSwitched(cState, sim->getCurrentState());
switch (sim->getCurrentState()) {
case GUI:
window->getViewport(0)->setCamera(guiCamera);
break;
case SIMULATION:
window->getViewport(0)->setCamera(camera);
break;
}
}
}
// clean up after ourselves
//delete testAI;
delete sim;
delete ogre;
delete handler;
delete gameAI;
delete dataManager;
return 0;
}
void CTerrainWalkingView::EngineSetup(void)
{
Ogre::Root *Root = ((CTerrainWalkingApp*)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("Walking");
if (RenderWindow == NULL)
{
try
{
m_RenderWindow = Root->createRenderWindow("Walking", 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(10);
m_Camera->setFarClipDistance(10000);
m_Camera->setCastShadows(false);
m_Camera->setUseRenderingDistance(true);
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 *TopographyNode = SceneManager->getRootSceneNode()->createChildSceneNode("Topography");
Ogre::Entity *TopographyEntity = SceneManager->createEntity("Topography", "Topography.mesh");
TopographyNode->attachObject(TopographyEntity);
Ogre::AxisAlignedBox TopographyBox = TopographyEntity->getBoundingBox();
Ogre::Vector3 Minimum = TopographyBox.getMinimum();
Ogre::Vector3 Center = TopographyBox.getCenter();
Ogre::SceneNode *RobotNode = SceneManager->getRootSceneNode()->createChildSceneNode("Robot");
Ogre::Entity *RobotEntity = SceneManager->createEntity("Robot", "robot.mesh");
RobotNode->attachObject(RobotEntity);
RobotEntity->getParentNode()->scale(10,10,10);
Ogre::AxisAlignedBox RobotBox = RobotEntity->getBoundingBox();
RobotNode->setPosition(Ogre::Vector3(Minimum[0], Minimum[1] + RobotBox.getSize()[1], Minimum[2]));
m_Camera->setPosition(Ogre::Vector3(Minimum[0], Minimum[1] + 5000, Minimum[2]));
m_Camera->lookAt(Center);
m_Camera->setPolygonMode(Ogre::PolygonMode::PM_WIREFRAME);
m_Animation = RobotEntity->getAnimationState("Walk");
m_Animation->setEnabled(true);
m_CollisionTools = new MOC::CollisionTools(SceneManager);
Root->renderOneFrame();
}
void Objects::insertMesh (const MWWorld::Ptr& ptr, const std::string& mesh)
{
Ogre::SceneNode* insert = ptr.getRefData().getBaseNode();
assert(insert);
NifOgre::NIFLoader::load(mesh);
Ogre::Entity *ent = mRenderer.getScene()->createEntity(mesh);
Ogre::Vector3 extents = ent->getBoundingBox().getSize();
extents *= insert->getScale();
float size = std::max(std::max(extents.x, extents.y), extents.z);
bool small = (size < Settings::Manager::getInt("small object size", "Viewing distance")) && Settings::Manager::getBool("limit small object distance", "Objects");
// do not fade out doors. that will cause holes and look stupid
if (ptr.getTypeName().find("Door") != std::string::npos)
small = false;
if (mBounds.find(ptr.getCell()) == mBounds.end())
mBounds[ptr.getCell()] = Ogre::AxisAlignedBox::BOX_NULL;
Ogre::AxisAlignedBox bounds = ent->getBoundingBox();
bounds = Ogre::AxisAlignedBox(
insert->_getDerivedPosition() + bounds.getMinimum(),
insert->_getDerivedPosition() + bounds.getMaximum()
);
bounds.scale(insert->getScale());
mBounds[ptr.getCell()].merge(bounds);
bool transparent = false;
for (unsigned int i=0; i<ent->getNumSubEntities(); ++i)
{
Ogre::MaterialPtr mat = ent->getSubEntity(i)->getMaterial();
Ogre::Material::TechniqueIterator techIt = mat->getTechniqueIterator();
while (techIt.hasMoreElements())
{
Ogre::Technique* tech = techIt.getNext();
Ogre::Technique::PassIterator passIt = tech->getPassIterator();
while (passIt.hasMoreElements())
{
Ogre::Pass* pass = passIt.getNext();
if (pass->getDepthWriteEnabled() == false)
transparent = true;
}
}
}
if(!mIsStatic || !Settings::Manager::getBool("use static geometry", "Objects") || transparent)
{
insert->attachObject(ent);
ent->setRenderingDistance(small ? Settings::Manager::getInt("small object distance", "Viewing distance") : 0);
ent->setVisibilityFlags(mIsStatic ? (small ? RV_StaticsSmall : RV_Statics) : RV_Misc);
ent->setRenderQueueGroup(transparent ? RQG_Alpha : RQG_Main);
}
else
{
Ogre::StaticGeometry* sg = 0;
if (small)
{
if( mStaticGeometrySmall.find(ptr.getCell()) == mStaticGeometrySmall.end())
{
uniqueID = uniqueID +1;
sg = mRenderer.getScene()->createStaticGeometry( "sg" + Ogre::StringConverter::toString(uniqueID));
mStaticGeometrySmall[ptr.getCell()] = sg;
sg->setRenderingDistance(Settings::Manager::getInt("small object distance", "Viewing distance"));
}
else
sg = mStaticGeometrySmall[ptr.getCell()];
}
else
{
if( mStaticGeometry.find(ptr.getCell()) == mStaticGeometry.end())
{
uniqueID = uniqueID +1;
sg = mRenderer.getScene()->createStaticGeometry( "sg" + Ogre::StringConverter::toString(uniqueID));
mStaticGeometry[ptr.getCell()] = sg;
}
else
sg = mStaticGeometry[ptr.getCell()];
}
// This specifies the size of a single batch region.
// If it is set too high:
// - there will be problems choosing the correct lights
// - the culling will be more inefficient
// If it is set too low:
// - there will be too many batches.
sg->setRegionDimensions(Ogre::Vector3(2500,2500,2500));
sg->addEntity(ent,insert->_getDerivedPosition(),insert->_getDerivedOrientation(),insert->_getDerivedScale());
sg->setVisibilityFlags(small ? RV_StaticsSmall : RV_Statics);
sg->setCastShadows(true);
sg->setRenderQueueGroup(transparent ? RQG_Alpha : RQG_Main);
mRenderer.getScene()->destroyEntity(ent);
}
}
Ogre::Vector3 Cube::getEntityCenter(Ogre::Entity& _entity)
{
Ogre::AxisAlignedBox boundingBox = _entity.getBoundingBox();
Ogre::Vector3 point = ( boundingBox.getMaximum() - boundingBox.getMinimum() ) /2;
return point;
}
int initOgreAR(aruco::CameraParameters camParams, unsigned char* buffer, std::string resourcePath)
{
/// INIT OGRE FUNCTIONS
#ifdef _WIN32
root = new Ogre::Root(resourcePath + "plugins_win.cfg", resourcePath + "ogre_win.cfg");
#elif __x86_64__ || __ppc64__
root = new Ogre::Root(resourcePath + "plugins_x64.cfg", resourcePath + "ogre.cfg");
#else
root = new Ogre::Root(resourcePath + "plugins.cfg", resourcePath + "ogre.cfg");
#endif
if (!root->showConfigDialog()) return -1;
Ogre::SceneManager* smgr = root->createSceneManager(Ogre::ST_GENERIC);
/// CREATE WINDOW, CAMERA AND VIEWPORT
Ogre::RenderWindow* window = root->initialise(true);
Ogre::Camera *camera;
Ogre::SceneNode* cameraNode;
camera = smgr->createCamera("camera");
camera->setNearClipDistance(0.01f);
camera->setFarClipDistance(10.0f);
camera->setProjectionType(Ogre::PT_ORTHOGRAPHIC);
camera->setPosition(0, 0, 0);
camera->lookAt(0, 0, 1);
double pMatrix[16];
camParams.OgreGetProjectionMatrix(camParams.CamSize,camParams.CamSize, pMatrix, 0.05,10, false);
Ogre::Matrix4 PM(pMatrix[0], pMatrix[1], pMatrix[2] , pMatrix[3],
pMatrix[4], pMatrix[5], pMatrix[6] , pMatrix[7],
pMatrix[8], pMatrix[9], pMatrix[10], pMatrix[11],
pMatrix[12], pMatrix[13], pMatrix[14], pMatrix[15]);
camera->setCustomProjectionMatrix(true, PM);
camera->setCustomViewMatrix(true, Ogre::Matrix4::IDENTITY);
window->addViewport(camera);
cameraNode = smgr->getRootSceneNode()->createChildSceneNode("cameraNode");
cameraNode->attachObject(camera);
/// CREATE BACKGROUND FROM CAMERA IMAGE
int width = camParams.CamSize.width;
int height = camParams.CamSize.height;
// create background camera image
mPixelBox = Ogre::PixelBox(width, height, 1, Ogre::PF_R8G8B8, buffer);
// Create Texture
mTexture = Ogre::TextureManager::getSingleton().createManual("CameraTexture",Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
Ogre::TEX_TYPE_2D,width,height,0,Ogre::PF_R8G8B8,Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
//Create Camera Material
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().create("CameraMaterial", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
Ogre::Technique *technique = material->createTechnique();
technique->createPass();
material->getTechnique(0)->getPass(0)->setLightingEnabled(false);
material->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
material->getTechnique(0)->getPass(0)->createTextureUnitState("CameraTexture");
Ogre::Rectangle2D* rect = new Ogre::Rectangle2D(true);
rect->setCorners(-1.0, 1.0, 1.0, -1.0);
rect->setMaterial("CameraMaterial");
// Render the background before everything else
rect->setRenderQueueGroup(Ogre::RENDER_QUEUE_BACKGROUND);
// Hacky, but we need to set the bounding box to something big, use infinite AAB to always stay visible
Ogre::AxisAlignedBox aabInf;
aabInf.setInfinite();
rect->setBoundingBox(aabInf);
// Attach background to the scene
Ogre::SceneNode* node = smgr->getRootSceneNode()->createChildSceneNode("Background");
node->attachObject(rect);
/// CREATE SIMPLE OGRE SCENE
// add sinbad.mesh
Ogre::ResourceGroupManager::getSingleton().addResourceLocation(resourcePath + "Sinbad.zip", "Zip", "Popular");
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
for(int i=0; i<MAX_MARKERS; i++) {
Ogre::String entityName = "Marker_" + Ogre::StringConverter::toString(i);
Ogre::Entity* ogreEntity = smgr->createEntity(entityName, "Sinbad.mesh");
Ogre::Real offset = ogreEntity->getBoundingBox().getHalfSize().y;
ogreNode[i] = smgr->getRootSceneNode()->createChildSceneNode();
// add entity to a child node to correct position (this way, entity axis is on feet of sinbad)
Ogre::SceneNode *ogreNodeChild = ogreNode[i]->createChildSceneNode();
ogreNodeChild->attachObject(ogreEntity);
// Sinbad is placed along Y axis, we need to rotate to put it along Z axis so it stands up over the marker
// first rotate along X axis, then add offset in Z dir so it is over the marker and not in the middle of it
ogreNodeChild->rotate(Ogre::Vector3(1,0,0), Ogre::Radian(Ogre::Degree(90)));
ogreNodeChild->translate(0,0,offset,Ogre::Node::TS_PARENT);
// mesh is too big, rescale!
const float scale = 0.006675f;
ogreNode[i]->setScale(scale, scale, scale);
// Init animation
ogreEntity->getSkeleton()->setBlendMode(Ogre::ANIMBLEND_CUMULATIVE);
if(i==0)
{
baseAnim[i] = ogreEntity->getAnimationState("HandsClosed");
topAnim[i] = ogreEntity->getAnimationState("HandsRelaxed");
}
else if(i==1)
{
baseAnim[i] = ogreEntity->getAnimationState("Dance");
topAnim[i] = ogreEntity->getAnimationState("Dance");
}
else if(i==2)
{
baseAnim[i] = ogreEntity->getAnimationState("RunBase");
topAnim[i] = ogreEntity->getAnimationState("RunTop");
}
else
{
baseAnim[i] = ogreEntity->getAnimationState("IdleBase");
topAnim[i] = ogreEntity->getAnimationState("IdleTop");
}
baseAnim[i]->setLoop(true);
topAnim[i]->setLoop(true);
baseAnim[i]->setEnabled(true);
topAnim[i]->setEnabled(true);
}
/// KEYBOARD INPUT READING
size_t windowHnd = 0;
window->getCustomAttribute("WINDOW", &windowHnd);
im = OIS::InputManager::createInputSystem(windowHnd);
keyboard = static_cast<OIS::Keyboard*>(im->createInputObject(OIS::OISKeyboard, true));
return 1;
}
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 ZoneListWidget::_createImages(ImageMap& retlist)
{
retlist.clear();
Ogre::TexturePtr texture = Ogre::TextureManager::getSingleton().createManual( "EntityTex",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D,
256, 256, 0, Ogre::PF_A8R8G8B8 , Ogre::TU_RENDERTARGET );
Ogre::RenderTexture *rttTex = texture->getBuffer()->getRenderTarget();
Ogre::SceneManager *mSceneMgr = Ogre::Root::getSingletonPtr()->createSceneManager("OctreeSceneManager", "EntityTexMgr");
Ogre::Light *dirl = mSceneMgr->createLight("DisplayLight");
dirl->setDirection(-1,-1,-1);
dirl->setDiffuseColour(1,1,1);
dirl->setType(Ogre::Light::LT_DIRECTIONAL);
Ogre::Camera* RTTCam = mSceneMgr->createCamera("EntityCam");
RTTCam->setNearClipDistance(0.01F);
RTTCam->setFarClipDistance(0);
RTTCam->setAspectRatio(1);
RTTCam->setFOVy(Ogre::Degree(90));
RTTCam->setPosition(0,0,1);
RTTCam->lookAt(0,0,0);
Ogre::Viewport *v = rttTex->addViewport( RTTCam );
v->setClearEveryFrame( true );
v->setBackgroundColour(Ogre::ColourValue(0,0,0,0));
ModularZoneFactory* factory = dynamic_cast<ModularZoneFactory*>(OgitorsRoot::getSingletonPtr()->GetEditorObjectFactory("Modular Zone Object"));
if(!factory)return;
factory->loadZoneTemplates();
ZoneInfoMap zoneTemplates = factory->getZoneTemplateMap();
Ogre::Entity *mEntity;
unsigned char dataptr[300 * 300 * 6];
unsigned char *dataptr2;
Ogre::PixelBox pb(256,256,1,Ogre::PF_A8R8G8B8, dataptr);
EntityMap entities;
ZoneInfoMap::iterator zi;
for(zi=zoneTemplates.begin();zi!=zoneTemplates.end();++zi)
{
Ogre::String addstr = (*zi).second.mMesh;
if(entities.find((*zi).first) == entities.end())
entities.insert(EntityMap::value_type((*zi).first,addstr));
}
EntityMap::const_iterator ite = entities.begin();
while(ite != entities.end())
{
Ogre::String addstr = ite->second;
mEntity = mSceneMgr->createEntity("MZP_Preview", addstr);
mSceneMgr->getRootSceneNode()->attachObject(mEntity);
//TODO: It would be nice to retrieve a Preview Camera Position from
//the .zone file
//TODO: also render portal outlines clearly so that the user can see
//how the zone is laid out
Ogre::Vector3 vSize = mEntity->getBoundingBox().getCorner(Ogre::AxisAlignedBox::NEAR_RIGHT_TOP);//.getHalfSize();//============
Ogre::Vector3 vCenter = mEntity->getBoundingBox().getCenter();
//FIXME ------ NICE PREVIEWS NEEDED - bigger
vSize += Ogre::Vector3(vSize.z, vSize.z, vSize.z);
float maxsize = std::max(std::max(vSize.x,vSize.y),vSize.z);
//vSize = Ogre::Vector3(0, 0, maxsize * 1.1f) + vCenter;
vSize = Ogre::Vector3(maxsize * 0.5f, vSize.y, maxsize * 0.5f) + vCenter;
//vSize.x +=vSize.x/2;//Maybe test to see which is larger x/2 or z/2 and use that?
//vSize.z +=vSize.x/2;
//RTTCam->setProjectionType(Ogre::PT_ORTHOGRAPHIC);
RTTCam->setPosition(vSize.x,vSize.y,vSize.z);
RTTCam->lookAt(vCenter.x,vCenter.y,vCenter.z);
rttTex->update();
rttTex->copyContentsToMemory(pb, Ogre::RenderTarget::FB_FRONT);
dataptr2 = new unsigned char[96 * 96 * 4];
Ogre::PixelBox pb2(96,96,1,Ogre::PF_A8R8G8B8, dataptr2);
Ogre::Image::scale(pb,pb2);
addstr.erase(addstr.length() - 5, 5);
retlist.insert(ImageMap::value_type((*ite).first, dataptr2));
mEntity->detachFromParent();
mSceneMgr->destroyEntity(mEntity);
ite++;
}
rttTex->removeAllViewports();
Ogre::Root::getSingletonPtr()->destroySceneManager(mSceneMgr);
Ogre::TextureManager::getSingletonPtr()->unload(texture->getName());
Ogre::TextureManager::getSingletonPtr()->remove(texture->getName());
}
void COrbitViewView::EngineSetup(void)
{
Ogre::Root *Root = ((COrbitViewApp*)AfxGetApp())->m_Engine->GetRoot();
m_SceneManager = Root->createSceneManager(Ogre::ST_GENERIC, "OrbitViewt");
//
// 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);
try
{
m_RenderWindow = Root->createRenderWindow("OrbitViewt", 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 = m_SceneManager->createCamera("Camera");
m_Camera->setNearClipDistance(0.5);
m_Camera->setFarClipDistance(5000);
m_Camera->setCastShadows(false);
m_Camera->setUseRenderingDistance(true);
Ogre::SceneNode *CameraNode = NULL;
CameraNode = m_SceneManager->getRootSceneNode()->createChildSceneNode("CameraNode", Ogre::Vector3::ZERO);
CameraNode->attachObject(m_Camera);
Ogre::Viewport* Viewport = NULL;
if (0 == m_RenderWindow->getNumViewports())
{
Viewport = m_RenderWindow->addViewport(m_Camera);
Viewport->setBackgroundColour(Ogre::ColourValue(0.8f, 1.0f, 0.8f));
}
// Alter the camera aspect ratio to match the viewport
m_Camera->setAspectRatio(Ogre::Real(rect.Width()) / Ogre::Real(rect.Height()));
Ogre::Entity *RobotEntity = m_SceneManager->createEntity("Robot", "robot.mesh");
Ogre::SceneNode *RobotNode = m_SceneManager->getRootSceneNode()->createChildSceneNode("Robot");
RobotNode->attachObject(RobotEntity);
Ogre::AxisAlignedBox Box = RobotEntity->getBoundingBox();
Ogre::Vector3 Center = Box.getCenter();
m_Camera->setPosition(Ogre::Vector3(Center[0], Center[1], Center[2] + 500.0));
m_Camera->lookAt(Center);
Root->renderOneFrame();
}
void CTerrainWalkingView::OnTimer(UINT_PTR nIDEvent)
{
Ogre::Quaternion Quaternion;
CEngine *Engine = ((CTerrainWalkingApp*)AfxGetApp())->m_Engine;
Ogre::Root *Root = Engine->GetRoot();
Ogre::SceneNode *RobotNode = Root->getSceneManager("Walking")->getSceneNode("Robot");
Ogre::Entity *RobotEntity = Root->getSceneManager("Walking")->getEntity("Robot");
Ogre::AxisAlignedBox RobotBox = RobotEntity->getBoundingBox();
Ogre::Entity *TopographyEntity = Root->getSceneManager("Walking")->getEntity("Topography");
Ogre::AxisAlignedBox TopographyBox = TopographyEntity->getBoundingBox();
Ogre::Vector3 Start = TopographyBox.getMinimum();
Ogre::Vector3 Finish = TopographyBox.getMaximum();
double x = Start[0] + (Finish[0] - Start[0]) * m_RelativeDistance;
double y = Start[1] + (Finish[1] - Start[1]) * m_RelativeDistance;
double z = Start[2] + (Finish[2] - Start[2]) * m_RelativeDistance;
Ogre::Vector3 Elevation(x, y, z);
Ogre::Vector3 CameraMove;
switch (nIDEvent)
{
case 1:
m_Animation->addTime(0.01);
m_RelativeDistance += 0.01;
if (m_CollisionTools->collidesWithEntity(Elevation, Ogre::Vector3(x,y - 1,z), Ogre::Vector3(x,y + 1,z), 100.0f, 0.0f, 4294967295))
{
x = Elevation[0];
y = Elevation[1] + RobotBox.getSize()[1];
z = Elevation[2];
}
RobotNode->setPosition(x, y, z);
m_Camera->lookAt(x, y, z);
if (m_RelativeDistance > 1.0)
KillTimer(1);
break;
case 2:
CameraMove[0] = -100;
CameraMove[1] = 0;
CameraMove[2] = 0;
m_Camera->moveRelative(CameraMove);
break;
case 3:
CameraMove[0] = 0;
CameraMove[1] = 100;
CameraMove[2] = 0;
m_Camera->moveRelative(CameraMove);
break;
case 4:
CameraMove[0] = 100;
CameraMove[1] = 0;
CameraMove[2] = 0;
m_Camera->moveRelative(CameraMove);
break;
case 5:
CameraMove[0] = 0;
CameraMove[1] = -100;
CameraMove[2] = 0;
m_Camera->moveRelative(CameraMove);
break;
}
Root->renderOneFrame();
CView::OnTimer(nIDEvent);
}
//-------------------------------------------------------------------------------------
void TutorialApplication::createScene(void)
{
// Set the scene's ambient light
mSceneMgr->setAmbientLight(Ogre::ColourValue(0.5f, 0.5f, 0.5f));
// Create an Entity
Ogre::Entity* ogreHead = mSceneMgr->createEntity("Head", "templeTest111.mesh");
b= ogreHead->getBoundingBox();
Ogre::Vector3 t= b.getCenter();
Ogre::Vector3 dim = b.getSize();
// Create a SceneNode and attach the Entity to it
Ogre::SceneNode* headNode1 = mSceneMgr->getRootSceneNode()->createChildSceneNode("HeadNode1");
Ogre::SceneNode* headNode2 = headNode1->createChildSceneNode("HeadNode2",Ogre::Vector3(-1*t.x,-1*t.y,-1*t.z));
headNode2->attachObject(ogreHead);
//headNode1->scale(0.15,0.15,0.15);
//Create a Light and set its position
Ogre::Light* light = mSceneMgr->createLight("MainLight");
light->setPosition(0.0f, 10000.0f, 0.0f);
//create skybox.
mSceneMgr->setSkyDome(true, "Examples/CloudySky", 5, 8);
//create arrow
/*
Ogre::Entity* arrow = mSceneMgr->createEntity("arrow", "arrow.mesh");
Ogre::SceneNode* arrowNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("arrowNode");
arrowNode->attachObject(arrow);
arrowNode->translate(4000,4000,0);
arrowNode->scale(50,1,100);
*/
// Assuming scene_mgr is your SceneManager.
Ogre::ManualObject * circle = mSceneMgr->createManualObject("circle");
float const radius = 7;
float const accuracy = 35;
circle->begin("BaseWhiteNoLighting", Ogre::RenderOperation::OT_LINE_STRIP);
unsigned point_index = 0;
for(float theta = 0; theta <= 2 * Ogre::Math::PI; theta += Ogre::Math::PI / accuracy) {
circle->position(radius * cos(theta), 0, radius * sin(theta));
circle->index(point_index++);
}
circle->index(0);// Rejoins the last point to the first.
circle->end();
circleNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("circleNode");
circleNode->attachObject(circle);
circleNode->scale(100,1,100);
//circleNode->translate(4000,-4000,0);
mCamera->setOrthoWindow(dim.x,dim.z);
mWindow->resize(500+700,500*dim.z/dim.x);
winsize.x = 500;
winsize.y = mWindow->getHeight();
mCamera->setAspectRatio(dim.x/dim.z);
mCamera2->setAspectRatio(700.0/mWindow->getHeight());
mCamera2->setPosition(4000,(-dim.y/2)+1000,0);
mCamera2->lookAt(4000,(-dim.y/2)+1000,-1);
}
void Animation::addExtraLight(Ogre::SceneManager *sceneMgr, NifOgre::ObjectScenePtr objlist, const ESM::Light *light)
{
const MWWorld::Fallback *fallback = MWBase::Environment::get().getWorld()->getFallback();
const int clr = light->mData.mColor;
Ogre::ColourValue color(((clr >> 0) & 0xFF) / 255.0f,
((clr >> 8) & 0xFF) / 255.0f,
((clr >> 16) & 0xFF) / 255.0f);
const float radius = float(light->mData.mRadius);
if((light->mData.mFlags&ESM::Light::Negative))
color *= -1;
objlist->mLights.push_back(sceneMgr->createLight());
Ogre::Light *olight = objlist->mLights.back();
olight->setDiffuseColour(color);
Ogre::ControllerValueRealPtr src(Ogre::ControllerManager::getSingleton().getFrameTimeSource());
Ogre::ControllerValueRealPtr dest(OGRE_NEW OEngine::Render::LightValue(olight, color));
Ogre::ControllerFunctionRealPtr func(OGRE_NEW OEngine::Render::LightFunction(
(light->mData.mFlags&ESM::Light::Flicker) ? OEngine::Render::LT_Flicker :
(light->mData.mFlags&ESM::Light::FlickerSlow) ? OEngine::Render::LT_FlickerSlow :
(light->mData.mFlags&ESM::Light::Pulse) ? OEngine::Render::LT_Pulse :
(light->mData.mFlags&ESM::Light::PulseSlow) ? OEngine::Render::LT_PulseSlow :
OEngine::Render::LT_Normal
));
objlist->mControllers.push_back(Ogre::Controller<Ogre::Real>(src, dest, func));
bool interior = !(mPtr.isInCell() && mPtr.getCell()->getCell()->isExterior());
bool quadratic = fallback->getFallbackBool("LightAttenuation_OutQuadInLin") ?
!interior : fallback->getFallbackBool("LightAttenuation_UseQuadratic");
// with the standard 1 / (c + d*l + d*d*q) equation the attenuation factor never becomes zero,
// so we ignore lights if their attenuation falls below this factor.
const float threshold = 0.03;
if (!quadratic)
{
float r = radius * fallback->getFallbackFloat("LightAttenuation_LinearRadiusMult");
float attenuation = fallback->getFallbackFloat("LightAttenuation_LinearValue") / r;
float activationRange = 1.0f / (threshold * attenuation);
olight->setAttenuation(activationRange, 0, attenuation, 0);
}
else
{
float r = radius * fallback->getFallbackFloat("LightAttenuation_QuadraticRadiusMult");
float attenuation = fallback->getFallbackFloat("LightAttenuation_QuadraticValue") / std::pow(r, 2);
float activationRange = std::sqrt(1.0f / (threshold * attenuation));
olight->setAttenuation(activationRange, 0, 0, attenuation);
}
// If there's an AttachLight bone, attach the light to that, otherwise put it in the center,
if(objlist->mSkelBase && objlist->mSkelBase->getSkeleton()->hasBone("AttachLight"))
objlist->mSkelBase->attachObjectToBone("AttachLight", olight);
else
{
Ogre::AxisAlignedBox bounds = Ogre::AxisAlignedBox::BOX_NULL;
for(size_t i = 0;i < objlist->mEntities.size();i++)
{
Ogre::Entity *ent = objlist->mEntities[i];
bounds.merge(ent->getBoundingBox());
}
Ogre::SceneNode *node = bounds.isFinite() ? mInsert->createChildSceneNode(bounds.getCenter())
: mInsert->createChildSceneNode();
node->attachObject(olight);
}
}