void GameState::createScene()
{
OgreFramework::getSingletonPtr()->m_pLog->logMessage("Creating Game Scene...");
OgreFramework::getSingletonPtr()->m_pViewport->setShadowsEnabled(true);
DotSceneLoader* dsl = new DotSceneLoader();
dsl->parseDotScene("Level1.xml", "General", m_pSceneMgr, m_pSceneMgr->getRootSceneNode());
delete dsl;
m_pCamera = m_pSceneMgr->getCamera("HeroCam");
OgreFramework::getSingletonPtr()->m_pViewport->setCamera(m_pCamera);
m_pHero = new dsgame::HeroUnit(m_pSceneMgr->getEntity("HeroEntity"),m_pSceneMgr->getSceneNode("HeroNode"));
m_pHero->getEntity()->setQueryFlags(HERO_MASK);
m_pOgre = new dsgame::npc::NormalOgreUnit(m_pSceneMgr->getEntity("Ogre1"),m_pSceneMgr->getSceneNode("OgreNode1"));
OgreFramework::getSingletonPtr()->m_pLog->logMessage("Game Scene Created...");
adjustObjectsMasks("Muro", 105, OBSTACLE_MASK);
adjustObjectsMasks("Door", 3, DOOR_MASK);
adjustObjectsMasks("Bau", 7, OBSTACLE_MASK);
adjustObjectsMasks("Ogre", 1, ENEMY_MASK);
m_pSceneMgr->getEntity("Chao")->setQueryFlags(GROUND_MASK);
}
void TankWarWorld::loadScene(){
SceneNode *wor = mSceneManager->getRootSceneNode()->createChildSceneNode();
DotSceneLoader* mLoader = new DotSceneLoader();
mLoader->parseDotScene("111.scene", "General", mSceneManager, mSceneManager->getRootSceneNode());
geometryList.push_back(mSceneManager->getEntity("Cone001")); //add to list
geometryList.push_back(mSceneManager->getEntity("Pyramid001")); //add to list
geometryList.push_back(mSceneManager->getEntity("Pyramid002")); //add to list
// Load more files if needed.
delete mLoader;
}
void PhysicsMain::loadPhysicsLevel(const std::string& levelName)
{
log("[Loading] Setting up Physics world and loading shapes from .scene file");
createWorld(levelName);
// creates collision meshes out of static objects
// get the scene manager
SceneManager* sceneMgr = LKernel::getG<SceneManager>();
// parse our .scene file
// No standard way to check if a file exists without opening it.
std::ifstream fileExistsCheck(Settings::WorldFileLocation + levelName + ".scene");
if (fileExistsCheck)
{
fileExistsCheck.close();
DotSceneLoader dsl;
dsl.parseDotScene(levelName + ".scene", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
sceneMgr, sceneMgr->getRootSceneNode());
// then go through each of the static objects and turn them into trimeshes.
for (const std::string& s : dsl.staticObjects)
{
// apparently triangle meshes only screw up if you turn on debug drawing for them. No I don't know why the f**k that should matter.
Entity* dslEnt = sceneMgr->getEntity(s);
SceneNode* dslNode = sceneMgr->getSceneNode(s);
btCollisionShape* shape;
std::string bulletFilePath = dslNode->getName() + ".bullet";
shape = LKernel::getG<CollisionShapeManager>()->getShapeFromFile(bulletFilePath, dslEnt, dslNode);
// then do the rest as usual
btRigidBody::btRigidBodyConstructionInfo info{ 0, new btDefaultMotionState(), shape };
auto body = new btRigidBody(info);
body->setCollisionFlags(btCollisionObject::CF_STATIC_OBJECT | btCollisionObject::CF_DISABLE_VISUALIZE_OBJECT);
body->setUserPointer(new CollisionObjectDataHolder(body, PonykartCollisionGroups::Road, dslNode->getName()));
world->addRigidBody(body, (short)PonykartCollisionGroups::Road, (short)PonykartCollidesWithGroups::Road);
}
}
// make a ground plane for us
createGroundPlane(-15);
// run some events
if (postCreateWorld.size())
for (auto& fun : postCreateWorld)
fun(world);
}
Entity Factory::createTank(entityx::ptr<entityx::EntityManager> entityMgr, std::string prefix,Ogre::Real velocity,Ogre::Real angularVelocity ,Ogre::Vector3 overHating,int health,bool ai)
{
DotSceneLoader loader;
Ogre::SceneManager* sceneMgr = RenderManager::getPtr()->getSceneManager();
loader.parseDotScene("tank.scene", "General", sceneMgr, 0, prefix);
Ogre::SceneNode* ctl = sceneMgr->getSceneNode(prefix + "TankControl");
Ogre::SceneNode* body = sceneMgr->getSceneNode(prefix + "TankBody");
Ogre::SceneNode* turret = sceneMgr->getSceneNode(prefix + "TankTurret");
Ogre::SceneNode* cannon = sceneMgr->getSceneNode(prefix +"TankCannon");
Entity tankEmptyControl = entityMgr->create();
Entity tankTurret = entityMgr->create();
Entity tankBody = entityMgr->create();
Entity tankCannon = entityMgr->create();
tankEmptyControl.assign<Position>(ctl->getPosition());
tankEmptyControl.assign<Orientation>(ctl->getOrientation());
tankEmptyControl.assign<Velocity>(0, 0, velocity);
tankEmptyControl.assign<AngularVelocity>(0, angularVelocity, 0);
tankEmptyControl.assign<Renderable>(ctl);
tankEmptyControl.assign<OverHeating>(overHating.x,overHating.y,overHating.z);
tankEmptyControl.assign<Destroyable>(health,health);
tankEmptyControl.assign<Collidable>();
tankEmptyControl.assign<Name>(prefix);
if(ai){
tankEmptyControl.assign<AI>();
Ogre::Entity *model = static_cast<Ogre::Entity*>(body->getAttachedObject(0));
model->getSubEntity(1)->setMaterialName("Red");
model = static_cast<Ogre::Entity*>(turret->getAttachedObject(0));
model->getSubEntity(1)->setMaterialName("Red");
model = static_cast<Ogre::Entity*>(cannon->getAttachedObject(0));
model->getSubEntity(1)->setMaterialName("Red");
}
ptr<Children> child = tankEmptyControl.assign<Children>();
child->children["body"] = tankBody;
child->children["turret"] = tankTurret;
//child->children.push_back(tankBody);
//child->children.push_back(tankTurret);
tankTurret.assign<Position>(turret->getPosition());
tankTurret.assign<Orientation>(turret->getOrientation());
tankTurret.assign<Renderable>(turret);
child = tankTurret.assign<Children>();
child->children["cannon"] = tankCannon;
tankBody.assign<Position>(body->getPosition());
tankBody.assign<Orientation>(body->getOrientation());
tankBody.assign<Renderable>(body);
tankCannon.assign<Position>(cannon->getPosition());
tankCannon.assign<Renderable>(cannon);
tankCannon.assign<Orientation>(cannon->getOrientation());
ctl->scale(.35, .55, .35);
return tankEmptyControl;
}
Level::Level()
{
//nv = new NavMesher();
//nv->Build();
//mTileMesh = new Sample_TileMesh;
//this->handleSettings();
if (!Sample_TileMesh::handleBuild()) {
return;
}
//DotScene Loading code
DotSceneLoader* pDotSceneLoader = new DotSceneLoader();
pDotSceneLoader->parseDotScene("city.scene", "General", GSYS->GetSceneMgr(), GSYS->GetSceneMgr()->getRootSceneNode());
delete pDotSceneLoader;
LodStrategyManager::getSingleton().setDefaultStrategy(PixelCountLodStrategy::getSingletonPtr());
// End .scene loading code
const dtNavMesh *nav = m_navMesh;
int ntiles = 0;
for (int i = 0; i < nav->getMaxTiles(); i++)
{
const dtMeshTile* tile = nav->getTile(i);
if (!tile->header) continue;
ntiles++;
}
printf("tile count: %d\n", ntiles);
//handleRender();
//mTileMesh->handleRender();
//this->DrawDebug(); // Overwrites handleRender(), old code
String name = "Level";
node = GSYS->GetSceneMgr()->getSceneNode(getFilePath());
ent = GSYS->GetSceneMgr()->getEntity(getFilePath());
//node = GSYS->GetSceneMgr()->getRootSceneNode()->createChildSceneNode();
//node->attachObject(ent);
//node->setScale(.7,.7,.7); // for Iogre exporter - C4D - exported with "scale up by a factor of 1"
//node->setScale(0,0,0); // for Iogre exporter - C4D - exported with "scale down by a factor of 1"
//physics data
//TODO : Get a simplified version for large vertex meshes and use that for collision data
/*
TemplateUtils::getMeshInformationNx(ent->getMesh().get(),
m_nverts,
m_tris,
m_verts,
m_ntris,
m_trinorms,
m_materials,
m_bmin,
m_bmax,
node->getPosition(),
node->getOrientation(),
node->getScale());
*/
// Quick check for valid mesh data
if (INPT->getMesh()->getVerts().size() > 0) {
// Convert Tris to Nx friendly array (PxU32* )
std::vector<size_t>::const_iterator myIter = INPT->getMesh()->getTris().begin();
std::vector<PxU32> fsFaces;
for (myIter; myIter != INPT->getMesh()->getTris().end(); ++myIter) {
fsFaces.push_back(*myIter);
}
// Convert verts (points) to Nx friendly array (PxVec3*)
std::vector<float>::const_iterator myVertsIter = INPT->getMesh()->getVerts().begin();
std::vector<PxVec3> fsVerts;
PxVec3 tempVec3;
int vertsIndex = 0;
for (size_t i = 0; i < INPT->getMesh()->getVerts().size() / 3; i++) {
tempVec3.x = INPT->getMesh()->getVerts()[vertsIndex];
tempVec3.y = INPT->getMesh()->getVerts()[vertsIndex + 1];
tempVec3.z = INPT->getMesh()->getVerts()[vertsIndex + 2];
vertsIndex += 3;
fsVerts.push_back(tempVec3);
}
/*
NxTriangleMeshDesc fsDesc;
fsDesc.numVertices = (PxU32)INPT->getMesh()->getVertCount();
fsDesc.numTriangles = (PxU32)INPT->getMesh()->getTriCount();
fsDesc.pointStrideBytes = sizeof(PxVec3);
fsDesc.triangleStrideBytes = 3*sizeof(PxU32);
fsDesc.points = &fsVerts[0]; // PxVec3*[] array
fsDesc.triangles = &fsFaces[0]; // PxU32*[] array
fsDesc.flags = 0;
fsDesc.materialIndexStride = sizeof(PxMaterialIndex);
if (INPT->getMesh()->getMaterials().size() > 0)
fsDesc.materialIndices = &INPT->getMesh()->getMaterials()[0];
NxTriangleMeshShapeDesc fsShapeDesc;
NxInitCooking();
{
MemoryWriteBuffer buf;
buf.data = NULL;
bool status = NxCookTriangleMesh(fsDesc, buf);
if (status == true )
fsShapeDesc.meshData = PHY->getSDK()->createTriangleMesh(MemoryReadBuffer(buf.data));
}
if (fsShapeDesc.meshData)
{
PxActorDesc actorDesc;
NxBodyDesc bodyDesc;
actorDesc.shapes.pushBack(&fsShapeDesc);
actorDesc.body = NULL;
actorDesc.globalPose.t = TemplateUtils::toNX(Vector3(0,0,0));
actorDesc.name = "Hangar";
if (actorDesc.isValid())
{
actor = PHY->getScene()->createActor(actorDesc);
actor->userData = NULL;
PHY->SetActorCollisionGroup(actor, GROUP_COLLIDABLE_NON_PUSHABLE);
}
else
{
throw Ogre::Exception(Ogre::Exception::ERR_INTERNAL_ERROR, "Actor Create Error #6", __FUNCTION__);
}
}
*/
//add box items
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 8; j++)
{
//BoxItem* it = new BoxItem(i*8+j, "cube", Vector3(-10+i*5,0.6,-16+j*4), Vector3(0.01,0.01,0.01), 10);
//items.push_back(it);
}
}
}
}
void DivBoxLevel::makeElementBoxes(
const QWebElement &document,
Ogre::Real scale,
std::vector<QString> tags,
Ogre::String meshName,
Ogre::SceneManager * sceneManager) {
DotSceneLoader* pDotSceneLoader = new DotSceneLoader();
pDotSceneLoader->parseDotScene("papercraft_man_line_running.scene",
"General", sceneManager, sceneManager->getRootSceneNode());
delete pDotSceneLoader;
Animation::Instance().animationStates.clear();
Animation::Instance().init(sceneManager, "arm_left");
Animation::Instance().init(sceneManager, "arm_right");
Animation::Instance().init(sceneManager, "chest");
Animation::Instance().init(sceneManager, "leg_left");
Animation::Instance().init(sceneManager, "leg_right");
Animation::Instance().init(sceneManager, "pants");
QWebElementCollection elements;
foreach(QString tag, tags)
elements.append(document.findAll(tag));
Ogre::Vector3 position = Ogre::Vector3(0.0, 1000.0, 0.0);
int elementCount = 0;
foreach(QWebElement element, elements) {
if (fits(&element, 10, 4096)) {
Ogre::String textureName =
"PageTex" + element.tagName().toStdString()
+ Ogre::StringConverter::toString(elementCount);
Box box;
box.width = element.geometry().width()*scale;
box.height = element.geometry().height()*scale;
box.sceneNode = sceneManager->createSceneNode(textureName);
element.setStyleProperty("background-color", "white");
Ogre::Entity* cube = sceneManager->createEntity(meshName);
makeOgreImage(&element, textureName);
Ogre::MaterialPtr material =
makeMaterial("PageMat" + Ogre::StringConverter::toString(position),
textureName, 1.3);
cube->getSubEntity(1)->setMaterial(material);
box.sceneNode->attachObject(cube);
box.sceneNode->setScale(box.width, box.height, box.width);
if (box.width > 50)
bigBoxes.push_back(box);
else if (box.width > 5)
smallBoxes.push_back(box);
elementCount++;
}
}
int smallBoxIndex = 0;
for (int i = 0; i < bigBoxes.size(); i++) {
CollisionActor* actor = simulation->terrainFactory->createActor()
->addPoint(bigBoxes[i].width, bigBoxes[i].height)
->addPoint(-bigBoxes[i].width, -bigBoxes[i].height)
->createCollisionShape(CollisionShape2::DEF_AABB);
if (i == 0) {
// FIRST PLANE-----------------------
actor->teleport(100.0, 100.0);
characterSceneNode = simulation->characterFactory->createActor()
->addPoint(4.0, 30.0)
->addPoint(-4.0, -10.0)
->createCollisionShape(CollisionShape2::DEF_CONVEX)
->teleport(100.0, bigBoxes[i].height * 2 + 200.0)
->sceneNode;
Ogre::SceneNode* sn = sceneManager->getSceneNode("Armature");
sceneManager->getRootSceneNode()->removeChild(sn);
characterSceneNode->addChild(sn);
sn->scale(0.4, 0.4, 0.4);
sn->translate(0, 10, 0);
sn->setOrientation(
Ogre::Quaternion(Ogre::Degree(90.0), Ogre::Vector3::UNIT_Y));
} else {
// FURTHER PLANES--------------------
float lX = bigBoxes[i - 1].sceneNode->_getDerivedPosition().x;
float lY = bigBoxes[i - 1].sceneNode->_getDerivedPosition().y;
float lW = bigBoxes[i - 1].width;
float lH = bigBoxes[i - 1].height;
float cX = bigBoxes[i].sceneNode->_getDerivedPosition().x;
float cY = bigBoxes[i].sceneNode->_getDerivedPosition().y;
float cW = bigBoxes[i].width;
float cH = bigBoxes[i].height;
if (cH - lH > 50.0 && smallBoxes.size() - 1 - smallBoxIndex > 1) {
// current is mutch higher then last
actor->teleport(lX + lW + cW, 100.0);
float sX = smallBoxes[smallBoxIndex].sceneNode->_getDerivedPosition().x;
float sY = smallBoxes[smallBoxIndex].sceneNode->_getDerivedPosition().y;
float sW = smallBoxes[smallBoxIndex].width;
float sH = smallBoxes[smallBoxIndex].height;
CollisionActor* hoverplane = simulation->hoverplaneFactory
->createActor()
->addPoint(sW, sH)
->addPoint(-sW, -sH)
->createCollisionShape(CollisionShape2::DEF_AABB);
static_cast<Hoverplane*>(hoverplane)
->setSpeed(0.2 + static_cast<float>
(static_cast<int>(lX * cX * cW) % 5) * 0.1)
->setPath(lX + lW - sW - 100.0, lY + lH - sH + 10.0,
lX + lW - sW - 100.0, lY + lH - sH + cH - lH);
hoverplane->sceneNode->addChild(smallBoxes[smallBoxIndex].sceneNode);
smallBoxIndex++;
} else {
if (lH - cH > 50.0 && smallBoxes.size() - 1 - smallBoxIndex > 1) {
actor->teleport(lX + lW + cW, 100.0);
float sX = smallBoxes[smallBoxIndex].sceneNode->
_getDerivedPosition().x;
float sY = smallBoxes[smallBoxIndex].sceneNode->
_getDerivedPosition().y;
float sW = smallBoxes[smallBoxIndex].width;
float sH = smallBoxes[smallBoxIndex].height;
CollisionActor* hoverplane = simulation->hoverplaneFactory
->createActor()
->addPoint(sW, sH)
->addPoint(-sW, -sH)
->createCollisionShape(CollisionShape2::DEF_AABB);
static_cast<Hoverplane*>(hoverplane)
->setSpeed(0.2 + static_cast<float>
(static_cast<int>(lX * cX * cW) % 5) * 0.1)
->setPath(cX, cY + cH + sH + 10.0,
cX, cY + cH + sH + lH);
hoverplane->sceneNode->addChild(smallBoxes[smallBoxIndex].sceneNode);
smallBoxIndex++;
} else {
if (i%3 == 2 && smallBoxes.size() - 1 - smallBoxIndex > 3) {
actor->teleport(lX + lW + cW +
smallBoxes[smallBoxIndex].sceneNode
->_getDerivedPosition().x +
smallBoxes[smallBoxIndex+1].sceneNode
->_getDerivedPosition().x +
smallBoxes[smallBoxIndex+2].sceneNode
->_getDerivedPosition().x
+ 400.0,
100.0);
{
float sX = smallBoxes[smallBoxIndex].sceneNode->
_getDerivedPosition().x;
float sY = smallBoxes[smallBoxIndex].sceneNode->
_getDerivedPosition().y;
float sW = smallBoxes[smallBoxIndex].width;
float sH = smallBoxes[smallBoxIndex].height;
CollisionActor* hoverplane = simulation->hoverplaneFactory
->createActor()
->addPoint(sW, sH)
->addPoint(-sW, -sH)
->createCollisionShape(CollisionShape2::DEF_AABB);
static_cast<Hoverplane*>(hoverplane)
->setSpeed(0.1 + static_cast<float>
(static_cast<int>(lX * cX * sW) % 5) * 0.1)
->setPath(lX + lW + 100.0, lY + lH - sH,
lX + lW + 100.0, lY + lH + cH + 200.0);
hoverplane->sceneNode
->addChild(smallBoxes[smallBoxIndex].sceneNode);
}
{
float sX = smallBoxes[smallBoxIndex+1].sceneNode->
_getDerivedPosition().x;
float sY = smallBoxes[smallBoxIndex+1].sceneNode->
_getDerivedPosition().y;
float sW = smallBoxes[smallBoxIndex+1].width;
float sH = smallBoxes[smallBoxIndex+1].height;
CollisionActor* hoverplane = simulation->hoverplaneFactory
->createActor()
->addPoint(sW, sH)
->addPoint(-sW, -sH)
->createCollisionShape(CollisionShape2::DEF_AABB);
static_cast<Hoverplane*>(hoverplane)
->setSpeed(0.2 + static_cast<float>
(static_cast<int>(lX * cX * sW) % 5) * 0.1)
->setPath(lX + lW + 200.0, lY + lH - sH,
lX + lW + 200.0, lY + lH + cH + 200.0);
hoverplane->sceneNode
->addChild(smallBoxes[smallBoxIndex+1].sceneNode);
}
{
float sX = smallBoxes[smallBoxIndex+2].sceneNode->
_getDerivedPosition().x;
float sY = smallBoxes[smallBoxIndex+2].sceneNode->
_getDerivedPosition().y;
float sW = smallBoxes[smallBoxIndex+2].width;
float sH = smallBoxes[smallBoxIndex+2].height;
CollisionActor* hoverplane = simulation->hoverplaneFactory
->createActor()
->addPoint(sW, sH)
->addPoint(-sW, -sH)
->createCollisionShape(CollisionShape2::DEF_AABB);
static_cast<Hoverplane*>(hoverplane)
->setSpeed(0.15 + static_cast<float>
(static_cast<int>(lX * cX * sW) % 5) * 0.1)
->setPath(lX + lW + 300.0, lY + lH - sH,
lX + lW + 300.0, lY + lH + cH + 200.0);
hoverplane->sceneNode
->addChild(smallBoxes[smallBoxIndex+2].sceneNode);
}
smallBoxIndex += 3;
} else {
actor->teleport(lX + lW + cW + 100.0, 100.0);
}
}
}
}
actor->sceneNode->addChild(bigBoxes[i].sceneNode);
qDebug() << "dooors" << doors.size() << "\n\n";
if ((i == (bigBoxes.size()-1) / 2 || i == bigBoxes.size()-1)
&& this->doors.size() >= 1) {
CollisionActor* door;
if (i == (bigBoxes.size()-1) / 2) {
door = this->doors[0];
qDebug() << "dooors0\n\n\n\n\n";
} else {
door = this->doors[0];
qDebug() << "dooors1\n\n\n\n\n";
}
door
->addPoint(0.0, 0.0)
->addPoint(40., 60.)
->createCollisionShape(CollisionShape2::DEF_AABB)
->teleport(
bigBoxes[i].sceneNode->_getDerivedPosition().x,
bigBoxes[i].sceneNode->_getDerivedPosition().y
+ bigBoxes[i].height);
Ogre::Entity* doorEntity = sceneManager->createEntity("door.mesh");
door->sceneNode->attachObject(doorEntity);
door->sceneNode->setScale(20, 30, 20);
door->sceneNode->setOrientation(
Ogre::Quaternion(Ogre::Degree(180.0), Ogre::Vector3::UNIT_Y));
}
}
}
