コード例 #1
0
ファイル: GraphicsEngineImp.cpp プロジェクト: Malow/NDYGFX
AnimatedMesh* GraphicsEngineImp::CreateAnimatedMesh(string filename, D3DXVECTOR3 pos, const char* billboardFilePath, float distanceToSwapToBillboard)
{
	AnimatedMesh* mesh = new AnimatedMesh(pos, filename, billboardFilePath, distanceToSwapToBillboard);

	// If we have it in memory dont put it on the other thread.
	if(!this->useLoadingThread && GetResourceManager()->HasMeshStripsResource(filename.c_str()))
	{
		//Check if loading the animation from file was successful...
		if(mesh->LoadFromFile(filename))
		{
			//...and if so, add it
			this->dx->CreateAnimatedMesh(mesh); 
		}
		else
		{
			//If not, delete the mesh.
			MaloW::Debug("Warning: Deleting animated mesh because of failure.");
			delete mesh;
		}
	}
	else
	{
		LoadMeshEvent* re = new LoadMeshEvent(filename, NULL, mesh, NULL);
		this->PutEvent(re);
	}

	return mesh;
}
コード例 #2
0
ファイル: main.cpp プロジェクト: galek/Asylum_Tutorials
//*************************************************************************************************************
void Render(float alpha, float elapsedtime)
{
	static float time = 0;

	D3DXMATRIX viewproj;

	D3DXMatrixMultiply(&viewproj, &view, &proj);
	D3DXMatrixScaling(&world, 0.1f, 0.1f, 0.1f);

	time += elapsedtime;

	device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0xff6694ed, 1.0f, 0);
	device->SetTransform(D3DTS_WORLD, &world);
	device->SetTransform(D3DTS_VIEW, &view);
	device->SetTransform(D3DTS_PROJECTION, &proj);

	mesh.Update(elapsedtime, &world);

	effect->SetMatrix("matViewProj", &viewproj);

	if( SUCCEEDED(device->BeginScene()) )
	{
		mesh.Draw();
		device->EndScene();
	}
	
	device->Present(NULL, NULL, NULL, NULL);
}
コード例 #3
0
void Scene::Update(float timeElapsed)
{
    TIME_PROFILE("Scene::Update");
    
    uint64 time = SystemTimer::Instance()->AbsoluteMS();
    
    
	updatableSystem->UpdatePreTransform();

    transformSystem->Process();

	updatableSystem->UpdatePostTransform();

	if(RenderManager::Instance()->GetOptions()->IsOptionEnabled(RenderOptions::UPDATE_LODS))
	{
		lodSystem->SetCamera(currentCamera);
		lodSystem->Process();
	}
	

	switchSystem->Process();
    
//	entityManager->Flush();
	int32 size;
	
	size = (int32)animations.size();
	for (int32 animationIndex = 0; animationIndex < size; ++animationIndex)
	{
		SceneNodeAnimationList * anim = animations[animationIndex];
		anim->Update(timeElapsed);
	}
	

	referenceNodeSuffixChanged = false;

	if(RenderManager::Instance()->GetOptions()->IsOptionEnabled(RenderOptions::UPDATE_ANIMATED_MESHES))
	{
		size = (int32)animatedMeshes.size();
		for (int32 animatedMeshIndex = 0; animatedMeshIndex < size; ++animatedMeshIndex)
		{
			AnimatedMesh * mesh = animatedMeshes[animatedMeshIndex];
			mesh->Update(timeElapsed);
		}
	}

	//if(imposterManager)
	//{
	//	imposterManager->Update(timeElapsed);
	//}
    
    updateTime = SystemTimer::Instance()->AbsoluteMS() - time;
}
コード例 #4
0
Scene::~Scene()
{
	for (Vector<AnimatedMesh*>::iterator t = animatedMeshes.begin(); t != animatedMeshes.end(); ++t)
	{
		AnimatedMesh * obj = *t;
		obj->Release();
	}
	animatedMeshes.clear();
	
	for (Vector<Camera*>::iterator t = cameras.begin(); t != cameras.end(); ++t)
	{
		Camera * obj = *t;
		obj->Release();
	}
	cameras.clear();
    
    SafeRelease(currentCamera);
    SafeRelease(clipCamera);
    
    for (Map<String, ProxyNode*>::iterator it = rootNodes.begin(); it != rootNodes.end(); ++it)
    {
        SafeRelease(it->second);
    }
    rootNodes.clear();

    // Children should be removed first because they should unregister themselves in managers
	RemoveAllChildren();
    
	SafeRelease(imposterManager);

    transformSystem = 0;
    renderUpdateSystem = 0;
	lodSystem = 0;
    uint32 size = (uint32)systems.size();
    for (uint32 k = 0; k < size; ++k)
        SafeDelete(systems[k]);
    systems.clear();

	SafeDelete(eventSystem);
	SafeDelete(renderSystem);
}
コード例 #5
0
ファイル: Scene.cpp プロジェクト: galek/dava.framework
Scene::~Scene()
{
    SceneCache::Instance()->RemoveScene(this);
    
	for (Vector<AnimatedMesh*>::iterator t = animatedMeshes.begin(); t != animatedMeshes.end(); ++t)
	{
		AnimatedMesh * obj = *t;
		obj->Release();
	}
	animatedMeshes.clear();
	
	for (Vector<Camera*>::iterator t = cameras.begin(); t != cameras.end(); ++t)
	{
		Camera * obj = *t;
		obj->Release();
	}
	cameras.clear();
    
    SafeRelease(mainCamera);
    SafeRelease(drawCamera);
    
    for (ProxyNodeMap::iterator it = rootNodes.begin(); it != rootNodes.end(); ++it)
    {
        SafeRelease(it->second);
    }
    rootNodes.clear();

    // Children should be removed first because they should unregister themselves in managers
	RemoveAllChildren();
    
	SafeRelease(imposterManager);

    SafeRelease(sceneGlobalMaterial);

    transformSystem = 0;
    renderUpdateSystem = 0;
    lodSystem = 0;
    debugRenderSystem = 0;
    particleEffectSystem = 0;
    updatableSystem = 0;
    lightUpdateSystem = 0;
    switchSystem = 0;
    soundSystem = 0;
    actionSystem = 0;
    skyboxSystem = 0;
    staticOcclusionSystem = 0;
    materialSystem = 0;
    speedTreeUpdateSystem = 0;
    foliageSystem = 0;
    windSystem = 0;
    waveSystem = 0;
    
    uint32 size = (uint32)systems.size();
    for (uint32 k = 0; k < size; ++k)
        SafeDelete(systems[k]);
    systems.clear();

    systemsToProcess.clear();

	SafeDelete(eventSystem);
	SafeDelete(renderSystem);
}
コード例 #6
0
ファイル: main.cpp プロジェクト: Malow/PowerBall
void test()
{
	GraphicsEngine* ge = GetGraphicsEngine();

	// Example of GE useage
	GraphicsEngine* eng = GetGraphicsEngine();
	eng->GetCamera()->setPosition(D3DXVECTOR3(0, 15, -15.6f));
	eng->GetCamera()->LookAt(D3DXVECTOR3(30, 10, 10));
	StaticMesh* testBall = eng->CreateStaticMesh("Media/Ball.obj", D3DXVECTOR3(8, 15, 8));
	StaticMesh* testCylinder = eng->CreateStaticMesh("Media/Cylinder.obj", D3DXVECTOR3(10, 10, 10));
	StaticMesh* bth = eng->CreateStaticMesh("Media/bth.obj", D3DXVECTOR3(5, 20, 15));
	
	AnimatedMesh* flag = eng->CreateAnimatedMesh("Media/FlagRed.ani",  D3DXVECTOR3(8, 15, 8));
	flag->LoopSeamless();

	AnimatedMesh* flagb = eng->CreateAnimatedMesh("Media/FlagBlue.ani",  D3DXVECTOR3(10, 15, 8));
	flagb->LoopSeamless();
	
	StaticMesh* flag1 = eng->CreateStaticMesh("Media/FlagBlue1.obj", D3DXVECTOR3(12, 15, 8));
	StaticMesh* flag2 = eng->CreateStaticMesh("Media/FlagBlue2.obj", D3DXVECTOR3(14, 15, 8));
	StaticMesh* flag3 = eng->CreateStaticMesh("Media/FlagBlue3.obj", D3DXVECTOR3(16, 15, 8));
	StaticMesh* flag4 = eng->CreateStaticMesh("Media/FlagBlue4.obj", D3DXVECTOR3(18, 15, 8));
	StaticMesh* flag5 = eng->CreateStaticMesh("Media/FlagBlue5.obj", D3DXVECTOR3(20, 15, 8));

	StaticMesh* ball1 = eng->CreateStaticMesh("Media/Ball1.obj", D3DXVECTOR3(12, 30, 8));
	StaticMesh* ball2 = eng->CreateStaticMesh("Media/Ball2.obj", D3DXVECTOR3(14, 30, 8));
	StaticMesh* ball3 = eng->CreateStaticMesh("Media/Ball3.obj", D3DXVECTOR3(16, 30, 8));
	StaticMesh* ball4 = eng->CreateStaticMesh("Media/Ball4.obj", D3DXVECTOR3(18, 30, 8));
	
	//StaticMesh* wlmap = eng->CreateStaticMesh("Media/WarlockMap.obj", D3DXVECTOR3(100, 4, 8));
	//StaticMesh* hb = eng->CreateStaticMesh("Media/HardenedBall.obj", D3DXVECTOR3(12, 15, 12));

	bth->Scale(0.1f);
	Light* testLight = eng->CreateLight(D3DXVECTOR3(15, 30, 15));
	testLight->SetLookAt(testBall->GetPosition());
	
	//testBall->SetSpecialColor(RED_COLOR);
	//testCylinder->SetSpecialColor(GREEN_COLOR);
	
	//AnimatedMesh* ani = eng->CreateAnimatedMesh("Media/AniTest.ani", D3DXVECTOR3(12, 16, 12));
	//ani->LoopNormal();
	//ani->LoopSeamless();

	
	SoundEngine* seng = eng->GetSoundEngine();
	SoundEffect* se1 = seng->LoadSoundEffect("Media/Sounds/SoundEffects/ball_vs_ball.mp3", false);
	//SoundEffect* se2 = seng->LoadSoundEffect("Media/Sounds/SoundEffects/ball_vs_wall.mp3", false);
	//SoundSong* ss1 = seng->LoadSong("Media/Sounds/Songs/america_fuck_yeah.mp3", true);
	seng->SetMasterVolume(0.5f);
	//ss1->Play();
	
	
	//eng->LoadingScreen("Media/LoadingScreen/LoadingScreenBG.png", "Media/LoadingScreen/LoadingScreenPB.png");			// going to LoadingScreen to load the above meshes
	//eng->LoadingScreen("Media/LoadingScreen/LoadingScreenBG.png", "Media/LoadingScreen/LoadingScreenPB.png", 0.0f, 1.0f, 1.0f, 1.0f);
	
	eng->LoadingScreen("Media/LoadingScreen/StartScreen.png", "", 0.0f, 1.0f, 1.0f, 1.0f);
	Text* text = eng->CreateText("Lol ", D3DXVECTOR2(500, 500), 1.0f, "Media/Fonts/1");
	
	//Image* testImg = eng->CreateImage(D3DXVECTOR2(50, 50), D3DXVECTOR2(500, 75), "Media/PowerBall.png");
	
	//testLight->SetPosition(testBall->GetPosition() + D3DXVECTOR3(0, 5, 0));
	//testLight->SetLookAt(testLight->GetPosition() - D3DXVECTOR3(0, 5, 0));
	//Light* testLight2 = eng->CreateLight(D3DXVECTOR3(3, 20, 3));
	

	CamRecording* camRec = new CamRecording(2000, true);	// How many milliseconds between each way point
	camRec->Init(eng->GetCamera());
	
	/*camRec->AddCameraWaypoint(D3DXVECTOR3(0, 0, 0), D3DXVECTOR3(8, 16, 8));
	camRec->AddCameraWaypoint(D3DXVECTOR3(0, 30, 0), D3DXVECTOR3(8, 16, 8));
	camRec->AddCameraWaypoint(D3DXVECTOR3(30, 30, 30), D3DXVECTOR3(8, 16, 8));
	camRec->AddCameraWaypoint(D3DXVECTOR3(-20, 20, 30), D3DXVECTOR3(8, 16, 8));
	camRec->AddCameraWaypoint(D3DXVECTOR3(0, 50, 0), D3DXVECTOR3(8, 16, 8));
	camRec->AddCameraWaypoint(D3DXVECTOR3(0, 20, 0), D3DXVECTOR3(8, 16, 8));*/
	//camRec->Load(CIRCLE_AROUND);
	camRec->CircleAround(true, 50, 1000, 0, D3DXVECTOR3(30, 50, 0), D3DXVECTOR3(0,0,30));
	
	bool sw = true;
	float size = 1.0f;

	bool go = true;
		
	while(eng->isRunning() && go)	// Returns true as long as ESC hasnt been pressed, if it's pressed the game engine will shut down itself (to be changed)
	{
		float diff = eng->Update();	// Updates camera etc, does NOT render the frame, another process is doing that, so diff should be very low.

		text->SetText("Distance to Lava: " + MaloW::convertNrToString(eng->GetCamera()->getPosition().y - eng->GetLavaHeightAt(eng->GetCamera()->getPosition().x, eng->GetCamera()->getPosition().z)));

		//testBall->Rotate(D3DXVECTOR3(2*PI, 0, 0) * (diff/1000.0f)); // Divide diff by 1000 to get seconds since diff is in milliseconds.
		testBall->RotateAxis(D3DXVECTOR3(2, 0, 0),  2* PI * (diff/1000.0f)); // Divide diff by 1000 to get seconds since diff is in milliseconds.
		CursorControl cc;

		if(eng->GetKeyListener()->IsPressed('W'))
			eng->GetCamera()->moveForward(diff);
		if(eng->GetKeyListener()->IsPressed(VK_RETURN))	// For keys other than the main-chars you use the VK_ Enums, rightclick on VK_RETURN and "Go to definition" to find the list of all keys
			cc.SetVisibility(true);
		if(eng->GetKeyListener()->IsPressed('A'))
			eng->GetCamera()->moveLeft(diff);
		if(eng->GetKeyListener()->IsPressed('S'))	
			eng->GetCamera()->moveBackward(diff);
		if(eng->GetKeyListener()->IsPressed('D'))	
			eng->GetCamera()->moveRight(diff);

		if(eng->GetKeyListener()->IsPressed(VK_ESCAPE))
			go = false;

		if(eng->GetKeyListener()->IsPressed(VK_BACK))
		{
			if(sw)
			{
				//se1->Play();
				text->DeleteFromEnd(1);
			}
			sw = false;
		}
		else
			sw = true;
		
		if(eng->GetKeyListener()->IsClicked(1))
		{
			size += diff * 0.001f;
			text->SetSize(size);
			//ss1->SetVolume(0.5f);
			text->AppendText("LoL ");
			//ss1->Play();
		}
		//else
			//se1->Play();

		if(eng->GetKeyListener()->IsClicked(2))
		{
			testBall->UseInvisibilityEffect(true);
		}
		else 
			testBall->UseInvisibilityEffect(false);
		
		if(eng->GetKeyListener()->IsPressed('G'))	
		{
			//ani->LoopNormal();
			flag->LoopNormal();
			flagb->LoopNormal();
			eng->GetEngineParameters().FXAAQuality = 4;
			ge->GetEngineParameters().FXAAQuality = 4;
			//camRec->Play();						// Play to start moving the camera along the path
		}
		camRec->Update(diff);					// update needed to move the camera when play is initialized.
	
		if(eng->GetKeyListener()->IsPressed('V'))	
		{
			//ani->NoLooping();
			flag->NoLooping();
			flagb->NoLooping();
		}
		if(eng->GetKeyListener()->IsPressed('B'))	
		{
			//ani->LoopSeamless();
			flag->LoopSeamless();
			flagb->LoopSeamless();
			eng->GetEngineParameters().FXAAQuality = 0;
			//ge->GetEngineParameters().FXAAQuality = 0;
			for(int i = 0; i < 200; i++)
			{
				//se1->Play();
			}
		}
		
	}
	// Delete camera recording
	delete camRec;
}
コード例 #7
0
ファイル: DxManagerRender.cpp プロジェクト: Edaenge/NDYGFX
void DxManager::CalculateCulling()
{
	D3DXMATRIX view = this->camera->GetViewMatrix();
	D3DXMATRIX proj = this->camera->GetProjectionMatrix();

	/*
	float zMinimum = -proj._43 / proj._33;
	float r = this->params.FarClip / (this->params.FarClip - zMinimum);
	proj._33 = r;
	proj._43 = -r * zMinimum;
	*/

	D3DXMATRIX VP;
	D3DXMatrixMultiply(&VP, &view, &proj);


	// Calculate near plane of frustum.
	FrustrumPlanes[0].a = VP._14 + VP._13;
	FrustrumPlanes[0].b = VP._24 + VP._23;
	FrustrumPlanes[0].c = VP._34 + VP._33;
	FrustrumPlanes[0].d = VP._44 + VP._43;
	D3DXPlaneNormalize(&FrustrumPlanes[0], &FrustrumPlanes[0]);

	// Calculate far plane of frustum.
	FrustrumPlanes[1].a = VP._14 - VP._13; 
	FrustrumPlanes[1].b = VP._24 - VP._23;
	FrustrumPlanes[1].c = VP._34 - VP._33;
	FrustrumPlanes[1].d = VP._44 - VP._43;
	D3DXPlaneNormalize(&FrustrumPlanes[1], &FrustrumPlanes[1]);

	// Calculate left plane of frustum.
	FrustrumPlanes[2].a = VP._14 + VP._11; 
	FrustrumPlanes[2].b = VP._24 + VP._21;
	FrustrumPlanes[2].c = VP._34 + VP._31;
	FrustrumPlanes[2].d = VP._44 + VP._41;
	D3DXPlaneNormalize(&FrustrumPlanes[2], &FrustrumPlanes[2]);

	// Calculate right plane of frustum.
	FrustrumPlanes[3].a = VP._14 - VP._11; 
	FrustrumPlanes[3].b = VP._24 - VP._21;
	FrustrumPlanes[3].c = VP._34 - VP._31;
	FrustrumPlanes[3].d = VP._44 - VP._41;
	D3DXPlaneNormalize(&FrustrumPlanes[3], &FrustrumPlanes[3]);

	// Calculate top plane of frustum.
	FrustrumPlanes[4].a = VP._14 - VP._12; 
	FrustrumPlanes[4].b = VP._24 - VP._22;
	FrustrumPlanes[4].c = VP._34 - VP._32;
	FrustrumPlanes[4].d = VP._44 - VP._42;
	D3DXPlaneNormalize(&FrustrumPlanes[4], &FrustrumPlanes[4]);

	// Calculate bottom plane of frustum.
	FrustrumPlanes[5].a = VP._14 + VP._12;
	FrustrumPlanes[5].b = VP._24 + VP._22;
	FrustrumPlanes[5].c = VP._34 + VP._32;
	FrustrumPlanes[5].d = VP._44 + VP._42;
	D3DXPlaneNormalize(&FrustrumPlanes[5], &FrustrumPlanes[5]);
	
	//Terrain
	for(int i = 0; i < this->terrains.size(); i++)
	{
		Terrain* terr = this->terrains.get(i);

		float scale = max(terr->GetScale().x, max(terr->GetScale().y, terr->GetScale().z));
		if(pe.FrustrumVsSphere(this->FrustrumPlanes, terr->GetBoundingSphere(), terr->GetWorldMatrix(), scale))
		{
			terr->SetCulled(false);
		}
		else
		{
			terr->SetCulled(true);
		}
	}

	//Static meshes
	for(int i = 0; i < this->objects.size(); i++)
	{
		StaticMesh* ms = this->objects.get(i);
		MaloW::Array<MeshStrip*>* strips = ms->GetStrips();
		for(int u = 0; u < strips->size(); u++)
		{
			MeshStrip* s = strips->get(u);
			float scale = max(ms->GetScaling().x, max(ms->GetScaling().y, ms->GetScaling().z));
			if(pe.FrustrumVsSphere(this->FrustrumPlanes, s->GetBoundingSphere(), ms->GetWorldMatrix(), scale))
			{
				s->SetCulled(false);
			}
			else
			{
				s->SetCulled(true);
			}
		}
	}

	//Animated meshes
	for(int i = 0; i < this->animations.size(); i++)
	{
		AnimatedMesh* ms = this->animations.get(i);
		MeshStrip* s = ms->GetStrips()->get(0);

		float scale = max(ms->GetScaling().x, max(ms->GetScaling().y, ms->GetScaling().z));
		if(pe.FrustrumVsSphere(this->FrustrumPlanes, s->GetBoundingSphere(), ms->GetWorldMatrix(), scale))
		{
			s->SetCulled(false);
		}
		else
		{
			s->SetCulled(true);
		}
	}
}
コード例 #8
0
void Scenario::loadFromXml(ofxBulletWorldRigid &world){
    ofxXmlSettings ScenarioXml;
    
    if(ScenarioXml.loadFile(PinballChinoManager::projectName+"/scenario.xml")){
        
        ScenarioXml.pushTag("scenario");
        
        int numberOfSavedObjects = ScenarioXml.getNumTags("object");
        
        for(int i = 0; i < numberOfSavedObjects; i++){
            
            ScenarioXml.pushTag("object", i);
            SimpleObject::shapeType Type = (SimpleObject::shapeType)ScenarioXml.getValue("type", 0);
            int objId = ScenarioXml.getValue("id", 0);
            
            
            ofVec3f pos, scale;
			
            pos.x = ScenarioXml.getValue("positionX",0.0, 0);
            pos.y = ScenarioXml.getValue("positionY",0.0, 0);
            pos.z = ScenarioXml.getValue("positionZ",0.0, 0);
            
            scale.x = ScenarioXml.getValue("scaleX",0.0, 0);
            scale.y = ScenarioXml.getValue("scaleY",0.0, 0);
            scale.z = ScenarioXml.getValue("scaleZ",0.0, 0);
			
			ofQuaternion rotation;
            ofVec4f rot;
			
			rot.x = ScenarioXml.getValue("rotationX",0.0,0);
			rot.y = ScenarioXml.getValue("rotationY",0.0,0);
			rot.z = ScenarioXml.getValue("rotationZ",0.0,0);
            rot.w = ScenarioXml.getValue("rotationW",0.0,0);
			rotation.set(rot);
			
            string path;
            path = ScenarioXml.getValue("path","", 0);
            
            //TODO uncomment the line below when the xml is properly configured
            //string strcolor = ScenarioXml.getValue("color", "0xFFFFFF", 0);
			int color = ScenarioXml.getValue("color", 0xFFFFFF, 0);
			
			int pointsCollision = ScenarioXml.getValue("pointsCollision", 0, 0);

			int invisible = 0; // Visible by default event if this value is not implemented in the Xml editor
			invisible = ScenarioXml.getValue("invisible", 0, 0);
			
            switch(Type){
                case SimpleObject::ShapeTypeBall:{
                    Ball *oBall = new Ball(currentMissions);
                    float mass = ScenarioXml.getValue("mass", 0.0);
                    float radius = ScenarioXml.getValue("radius", 0.0);
                    float restitution = ScenarioXml.getValue("restitution", 0.0);
                    float friction = ScenarioXml.getValue("friction", 0.0);
                    oBall->setup(world, pos, mass, radius, restitution, friction);
                    oBall->SetObjectId(objId);
					oBall->setRotation(rotation);
                    oBall->color = color;
					oBall->setVisibility(invisible);
					
                    ScenarioObjects.push_back(oBall);
                }
                break;
                    
                case SimpleObject::ShapeTypeHammer:{
                    Hammer *oHammer = new Hammer(currentMissions);
                    oHammer->setup(world, pos);
                    oHammer->SetObjectId(objId);
					oHammer->setRotation(rotation);
                    oHammer->color = color;
					oHammer->setVisibility(invisible);
                    ScenarioObjects.push_back(oHammer);
					
					oHammer->setupRot();
                }
                break;
                    
                case SimpleObject::ShapeTypeLever:{
                    Lever *oLever = new Lever(currentMissions);
                    int dir = ScenarioXml.getValue("LeverType", 0);
                    oLever->setup(world, pos, path, scale, dir);
                    oLever->SetObjectId(objId);
					oLever->setRotation(rotation);
                    oLever->color = color;
					oLever->setVisibility(invisible);
                    ScenarioObjects.push_back(oLever);

                }
                break;
                    
                case SimpleObject::ShapeTypeObstacle:{
                    Obstacle *oObstable = new Obstacle(currentMissions);
                    //oObstable->setup(world, pos, "3DModels/chino_6.dae");
                    oObstable->setup(world, pos, path, scale);
                    oObstable->SetObjectId(objId);
					oObstable->setRotation(rotation);
                    oObstable->color = color;
					oObstable->setVisibility(invisible);
                    ScenarioObjects.push_back(oObstable);
					oObstable->setPointsCollision(pointsCollision);
					oObstable->setupRot();

                }
                break;
                
                case SimpleObject::ShapeTypeGravity:{
                    Gravity *oGravity = new Gravity(currentMissions);
                    //oObstable->setup(world, pos, "3DModels/chino_6.dae");
                    oGravity->setup(world, pos, path, scale);
                    oGravity->SetObjectId(objId);
					oGravity->setRotation(rotation);
                    oGravity->color = color;
					oGravity->setVisibility(invisible);
                    ScenarioObjects.push_back(oGravity);
					oGravity->setPointsCollision(pointsCollision);
					oGravity->setupRot();
                    
                }
                break;
                   
                case SimpleObject::ShapeTypeTeleporter:{
                    Teleporter *oTeleporter = new Teleporter(currentMissions);
                    //oObstable->setup(world, pos, "3DModels/chino_6.dae");
                    oTeleporter->setup(world, pos, path, scale);
                    oTeleporter->SetObjectId(objId);
					oTeleporter->setRotation(rotation);
                    oTeleporter->color = color;
					oTeleporter->setVisibility(invisible);
                    ScenarioObjects.push_back(oTeleporter);
					oTeleporter->setPointsCollision(pointsCollision);
					oTeleporter->setupRot();
                    
                }
                break;
					
				case SimpleObject::ShapeTypeRamp:{
					Ramp *oRamp = new Ramp(currentMissions);
					//oObstable->setup(world, pos, "3DModels/chino_6.dae");
					oRamp->setup(world, pos, path, scale);
					oRamp->SetObjectId(objId);
					oRamp->setRotation(rotation);
					oRamp->color = color;
					oRamp->setVisibility(invisible);
					ScenarioObjects.push_back(oRamp);
					oRamp->setPointsCollision(pointsCollision);
					oRamp->setupRot();
				}
					break;
					
				case SimpleObject::ShapeTypeObstacleTriShapeMesh:{
					ObstacleTriShapeMesh *oObstacleTriShapeMesh= new ObstacleTriShapeMesh(currentMissions);
					
					oObstacleTriShapeMesh->setup(world, pos, path, scale);
					oObstacleTriShapeMesh->SetObjectId(objId);
					oObstacleTriShapeMesh->setRotation(rotation);
					oObstacleTriShapeMesh->color = color;
					oObstacleTriShapeMesh->setVisibility(invisible);
					ScenarioObjects.push_back(oObstacleTriShapeMesh);
					oObstacleTriShapeMesh->setPointsCollision(pointsCollision);
					oObstacleTriShapeMesh->setupRot();
				}
					break;
					
                case SimpleObject::ShapeTypeAnimatedObject:{
                    AnimatedObject *oAnimatedObject = new AnimatedObject(currentMissions);
                    //oObstable->setup(world, pos, "3DModels/chino_6.dae");
                    oAnimatedObject->setup(world, pos, path, scale);
                    oAnimatedObject->SetObjectId(objId);
					oAnimatedObject->setRotation(rotation);
                    oAnimatedObject->color = color;
					oAnimatedObject->setVisibility(invisible);
                    ScenarioObjects.push_back(oAnimatedObject);
					oAnimatedObject->setPointsCollision(pointsCollision);
					oAnimatedObject->setupRot();
                    
                }
                break;
                
                case SimpleObject::ShapeTypeAnimatedMotionPath:{
                    string pathMotionModel;
                    pathMotionModel = ScenarioXml.getValue("pathMotionModel","", 0);
                    AnimatedMotionPath *oAnimatedMotionPath = new AnimatedMotionPath(currentMissions);
                    oAnimatedMotionPath->setup(world, pos, path, pathMotionModel, scale);
                    oAnimatedMotionPath->SetObjectId(objId);
					oAnimatedMotionPath->setRotation(rotation);
                    oAnimatedMotionPath->color = color;
					oAnimatedMotionPath->setVisibility(invisible);
                    ScenarioObjects.push_back(oAnimatedMotionPath);
					oAnimatedMotionPath->setPointsCollision(pointsCollision);
					oAnimatedMotionPath->setupRot();
                    
                }
                break;
                    
                case SimpleObject::ShapeTypeAnimatedMesh:{
                    AnimatedMesh *oAnimatedMesh = new AnimatedMesh(currentMissions);
                    //oObstable->setup(world, pos, "3DModels/chino_6.dae");
                    oAnimatedMesh->setup(world, pos, path, scale);
                    oAnimatedMesh->SetObjectId(objId);
					oAnimatedMesh->setRotation(rotation);
                    oAnimatedMesh->color = color;
					oAnimatedMesh->setVisibility(invisible);
                    ScenarioObjects.push_back(oAnimatedMesh);
					oAnimatedMesh->setPointsCollision(pointsCollision);
					oAnimatedMesh->setupRot();
                    
                }
                break;
                case SimpleObject::ShapeTypeGeneratedMesh:{
                    GeneratedMesh *oGeneratedMesh = new GeneratedMesh(currentMissions);
                    //oObstable->setup(world, pos, "3DModels/chino_6.dae");
                    oGeneratedMesh->setup(world, pos, path, scale);
                    oGeneratedMesh->SetObjectId(objId);
					oGeneratedMesh->setRotation(rotation);
                    oGeneratedMesh->color = color;
					oGeneratedMesh->setVisibility(invisible);
                    ScenarioObjects.push_back(oGeneratedMesh);
					oGeneratedMesh->setPointsCollision(pointsCollision);
					oGeneratedMesh->setupRot();
                    
                }
                break;
                    
                case SimpleObject::ShapeTypeBounds:{
                    Bounds *oBounds = new Bounds(currentMissions);
                    oBounds->setup(world, pos, path, scale);
                    oBounds->SetObjectId(objId);
					oBounds->setRotation(rotation);
                    oBounds->color = color;
					oBounds->setVisibility(invisible);
                    ScenarioObjects.push_back(oBounds);
					
					oBounds->setupRot();
                }
                break;

            }
            ScenarioXml.popTag();
        }
        
        ScenarioXml.popTag(); //pop position
    }
    
    else{
        
        ofLogError("Scenario file did not load!");
        
    }
    
}
コード例 #9
0
ファイル: main.cpp プロジェクト: galek/Asylum_Tutorials
HRESULT InitScene()
{
	HRESULT hr;
	LPD3DXBUFFER errors = NULL;

	SetWindowText(hwnd, TITLE);

	hr = D3DXCreateEffectFromFileA(device, "../media/shaders/skinning.fx", NULL, NULL, D3DXSHADER_DEBUG, NULL, &effect, &errors);
	
	if( FAILED(hr) )
	{
		if( errors )
		{
			char* str = (char*)errors->GetBufferPointer();
			std::cout << str << "\n\n";

			errors->Release();
		}

		MYERROR("Could not create effect");
		return hr;
	}

	// load animated model
	mesh.Effect = effect;
	mesh.Method = SM_Shader;
	mesh.Path = "../media/meshes/dwarf/";
	
	if( FAILED(hr = mesh.Load(device, "../media/meshes/dwarf/dwarf.X")) )
	{
		MYERROR("Could not load dwarf");
		return hr;
	}

	// all the possible skins are contained in this file => turn off some
	mesh.SetAnimation(6);
	mesh.EnableFrame("LOD0_attachment_weapon3", false);
	mesh.EnableFrame("LOD0_attachment_weapon2", false);
	mesh.EnableFrame("LOD0_attachment_shield3", false);
	mesh.EnableFrame("LOD0_attachment_shield2", false);
	mesh.EnableFrame("LOD0_attachment_head2", false);
	mesh.EnableFrame("LOD0_attachment_head1", false);
	mesh.EnableFrame("LOD0_attachment_torso2", false);
	mesh.EnableFrame("LOD0_attachment_torso3", false);
	mesh.EnableFrame("LOD0_attachment_legs2", false);
	mesh.EnableFrame("LOD0_attachment_legs3", false);
	mesh.EnableFrame("LOD0_attachment_Lpads1", false);
	mesh.EnableFrame("LOD0_attachment_Lpads2", false);
	mesh.EnableFrame("Rshoulder", false);
	
	D3DXVECTOR3 eye(0.5f, 1.0f, -1.5f);
	D3DXVECTOR3 look(0, 0.7f, 0);
	D3DXVECTOR3 up(0, 1, 0);

	D3DXMatrixPerspectiveFovLH(&proj, D3DX_PI / 3, (float)screenwidth / (float)screenheight, 0.1f, 100);
	D3DXMatrixLookAtLH(&view, &eye, &look, &up);
	D3DXMatrixIdentity(&world);

	std::cout << "Press Space to cycle animations\n";

	return S_OK;
}
コード例 #10
0
ファイル: main.cpp プロジェクト: galek/Asylum_Tutorials
//*************************************************************************************************************
void KeyPress(WPARAM wparam)
{
	if( wparam == VK_SPACE )
		mesh.NextAnimation();
}