OgreMagic Library[** MagicPro Ver 0.5 released **]

Emil_halim · Post by **Emil_halim** » Tue Sep 04, 2012 7:07 pm

Hi all,

here is a simple demo that play movie in the background in black&white ,playing "Backstreet Boys - I Want It That Way " song.

Code: Select all

//****************************************//
//           ************                 //
//      ***MagicPro library***            //
//           ************                 //
//****************************************//

#include "Magic.h"

using namespace Magic;
using namespace OIS;

HLSLProgram  SPrg;
hgeQuad*     quad;

// this function will be called befor drawing ogre 3d stuff
void QueueStarted()
{
	Screen_Use2DView();
	ML_StartShaderPrg(SPrg);
	DB_UpdateAllAnimation();
	ML_StopShaderPrg();
	Gfx_RenderQuad(quad);
	Screen_Stop2DView();
}

int WINAPI WinMain (HINSTANCE  hInst,HINSTANCE  hPrev,LPSTR CmdLine,int CmdShow)
{
  z_init("Ogre3D in Blitz3D Style");
  Graphics3D(800,600,32,false);
  defineQueueStarted(QueueStarted);

  z_setAmbientLight(30,30,50);
  Blitz::TEntity* cam = CreateCamera(); 
  CameraClsColor(cam,90,128,255);
  CameraRange(cam,1.0,1000.0);


  z_setMediaDir("media",true);
  Blitz::TEntity* ogrehead = LoadMesh("ogrehead.mesh");
  PositionEntity(ogrehead,0.0,0.0,-150.0));
    
  Blitz::TEntity* light = CreateLight();
  PositionEntity(light,-200,200,50);
  LightColor(light,255,200,150);
  
  DB_LoadAnimation(1, "I Want It That Way.flv");
  DB_PlayAnimationToScreen(1,0,0,800,600); 
  
  SPrg = ML_CreateHLSLPrg();
  ML_EditPixelPrg(SPrg);
  ML_AddToPrg("sampler2D tex0;                                          ");
  ML_AddToPrg("float4   main(  float2 TexCoord : TEXCOORD0) : COLOR0    ");
  ML_AddToPrg("{                                                        ");
  ML_AddToPrg("       float4 col = tex2D( tex0, TexCoord );             ");
  ML_AddToPrg("       float  gry = col.r*0.299+col.g*0.587+col.b*0.184; ");
  ML_AddToPrg("       return float4(gry,gry,gry,col.a);                 ");
  ML_AddToPrg("}                                                        ");
  ML_CompilePixelPrg(SPrg,"main");


  quad = make_hgeQuad(100,50,250,250);
  Set_hgeImage(quad,1);
  Set_hgeBlend(quad,BLEND_DEFAULT);


  while(!OIS_isKeyDown(KC_ESCAPE))
   { 

      RenderWorld();

   }
  DB_FreeAnimation(1);
  EndGraphics();
}

Post by **jacmoe** » Wed Sep 12, 2012 11:04 pm

Great to see you're back.

Emil_halim · Post by **Emil_halim** » Fri Sep 14, 2012 7:36 am

thanks you very much .

Emil_halim · Post by **Emil_halim** » Sat Sep 15, 2012 6:23 pm

Hi all.

Here is another demo that bring the life to OgreHead Mesh.

simply it initializes the screen size and create a camera , set the media location , load a Ogrehead mesh , get the Ogre/Eyes material then added new texture and playing movie in that texture.

this will make ogre Eyes flashing and bring life to it.

here is a screen shot

here is the code

Code: Select all


//****************************************//
//           *********                    //
//      ***Magic library***               //
//           *********                    //
//****************************************//

#include "Magic.h"

using namespace Magic;
//using namespace Ogre;
using namespace OIS;
using namespace Blitz;

int WINAPI WinMain (HINSTANCE  hInst,HINSTANCE  hPrev,LPSTR CmdLine,int CmdShow)
{
  z_init("Ogre3D in Blitz3D Style");
  Graphics3D(800,600,32,false);

  z_setAmbientLight(30,30,50);
  Blitz::TEntity* cam = CreateCamera(); 
  CameraClsColor(cam,90,128,255);
  CameraRange(cam,1.0,1000.0);

  z_setMediaDir("ZipMedia.zip", true);
  z_setMediaDir("media",true);

  Magic::TEntity* ogrehead = z_loadMesh("ogrehead.mesh");
  z_positionEntity(ogrehead,0.0,0.0,-150.0);
  
  TMaterial mat = z_getMaterialByName(ogrehead,"Ogre/Eyes");
  z_materialDiffuse(mat,1.0f,1.0f,1.0f,1.0);

  DB_LoadAnimation(1, "I Want It That Way.flv");
  DB_SetAnimationVolume(1,90);

  TTexture text = O_Image_Make ( 10, 512, 512);
  TTextureUnit textUnit = mat->getTechnique(0)->getPass(0)->createTextureUnitState();
  textUnit->setTextureCoordSet(0);
  z_TextureUnitsetTexture(textUnit,text);

  DB_PlayAnimationToImage(10,1,0,0,512,512);

  Blitz::TEntity* light = CreateLight();
  PositionEntity(light,-200,200,50);
  LightColor(light,255,200,150);


  while(!OIS_isKeyDown(KC_ESCAPE))
   {
     
	  if(OIS_isKeyDown(KC_LEFT))  MoveEntity(cam,-0.1f,0, 0.0f);
	  if(OIS_isKeyDown(KC_RIGHT)) MoveEntity(cam, 0.1f,0, 0.0f);
	  if(OIS_isKeyDown(KC_UP))    MoveEntity(cam, 0.0f,0,-0.1f);
	  if(OIS_isKeyDown(KC_DOWN))  MoveEntity(cam, 0.0f,0, 0.1f); 

          DB_UpdateAllAnimation();

          RenderWorld();

   }

  EndGraphics();
}

Emil_halim · Post by **Emil_halim** » Sun Jul 19, 2015 10:30 am

Hi everyome,

I came back with my new project , which collects Ogre , Irrlicht , DarkBasic Pro, indieLib , HGE and ofcaurse my magic library.

still using Ogre ver 1.9 , Irrlicht 1.8 .

if every thing is oaky i will post the SDK tomorrow .

here is a demo that plaies 9 defirent movies on the background at the same time , render Ogre Head mesh , render Alien.X and pelican.x meshs and thire effects with darkbasic stuff , i have devided the screen into 9 zones whche holdes the movies inside them so that when you move the mouse over a certaine zone it will play the souned of that movie and plays others silent sound.

here is the screen shot

here is the code

Code: Select all

//****************************************//
//           ************                 //
//      ***MagicPro library***            //
//           ************                 //
//****************************************//

#include "MagicPro.h"



int WINAPI WinMain (HINSTANCE  hInst,HINSTANCE  hPrev,LPSTR CmdLine,int CmdShow)
{
	
	AppTitle("MagicPro Test Example");
    setConfigFiles("","","MagicPro.log");
	Graphics3D(800,600);

	
	AddMediaDir("../../media/materials/programs");
	AddMediaDir("../../media/materials/scripts");
	AddMediaDir("../../media/materials/textures");
	AddMediaDir("../../media/models");
	AddMediaDir("../../media/MagicMedia");
	AddMediaDir("../../media/MagicMedia/movie");
	AddMediaDir("../../media/DarkBasic");
	AddMediaDir("../../media/DarkBasic/metal");
	PB_Parse3DScripts();

	hgeSystem_SetStateBool(CLEAR_BUF_BY_OGRE, false);

	BBsetAmbientLight(30.0F, 30.0F, 50.0F);

	BBentity* cam =  BBCreateCamera(NULL);
	BBCameraRange(cam, 0.1f, 5000.0f);
	BBPositionEntity(cam, 0,0,220);
	camera_lookat((CameraHandle)cam->Handle,0,0,-300);

	BBCameraClsColor(cam,0.0f,0.0f,0.0f);

	BBentity* mesh = BBLoadMesh("ogrehead.mesh");

	BBentity* light = BBCreateLight(2);
	BBPositionEntity(light, 20,80,50);

	hgeSystem_SetStateBool(MOVIE_WITH_SOUND, false);

	DB_LoadAnimation(1,"Sandra - Infinite Kiss ( 2012 ).mpg");
	DB_PlayAnimation(1);
	DB_SetAnimationVolume(1, 100);

	DB_LoadAnimation(2,"I Want It That Way.flv");
	DB_PlayAnimation(2);
	//DB_SetAnimationVolume(2, 0);

	DB_LoadAnimation(3,"TellHim.flv");
	DB_PlayAnimation(3);
	//DB_SetAnimationVolume(3, 0);

	DB_LoadAnimation(4,"Don't Cry.flv");
	DB_PlayAnimation(4);
	//DB_SetAnimationVolume(4, 0);

	DB_LoadAnimation(5,"Angel of Darkness.flv");
	DB_PlayAnimation(5);
	//DB_SetAnimationVolume(5, 0);

	DB_LoadAnimation(6,"Hiroshima.flv");
	DB_PlayAnimation(6);
	//DB_SetAnimationVolume(6, 0);

	DB_LoadAnimation(7,"My Heart Will Go On.flv");
	DB_PlayAnimation(7);
	//DB_SetAnimationVolume(7, 0);

	DB_LoadAnimation(8,"Become 1.flv");
	DB_PlayAnimation(8);
	//DB_SetAnimationVolume(8, 0);

	DB_LoadAnimation(9,"bchert_khir.mp4");
	DB_PlayAnimation(9);
	//DB_SetAnimationVolume(9, 0);

	ML_CreateRectZone(0,0,200,200,1);
	ML_CreateRectZone(200,0,400,200,2);
	ML_CreateRectZone(400,0,600,200,3);
	ML_CreateRectZone(600,0,800,200,4);

	SetMipmapNum ( 0 );
	Load ( "Smal_Logo.png", 100 );
	//Image_load(100,"Smal_Logo.png");
	image_SetColorKeyFromPoint(100,2,2);
	hgeSprite*  spr = make_mlSprite(100);
	
	 DBP_Sprite ( 5, 0, 0, 100 ); //create and draw the sprite at 0,0

	 DBP_Backdrop_Off();
	 DBP_make_object_Box (1 , 100.0f , 100.0f, 100.0f);
	 DBP_texture_object ( 1, 100 );
	 DBP_position_object (1 , 0 , -90.0f , 100.0f );

	 
	 DBP_load_object ( "alien/Alien.X" , 2 );
	 DBP_scale_object(2, 20.0f, 20.0f ,20.0f);    // Darkbasic scale x = 100 --> ogre scale x = 1.0 , x = 50.0 --> x = 0.5
	 DBP_Load_Effect ( "metal.fx" ,1,1 );
	
  	 DBP_set_limb_effect ( 2, 1, 1);
	 DBP_set_limb_effect ( 2, 8, 1);
	 DBP_position_object (2 , 0 , 0.0f , 130.0f );  

	 DBP_load_object ( "pelican.x" , 6 );  
	 DBP_set_effect_on ( 6,"metal.fx",1  );
	
	 DBP_move_camera ( 25.0f  );

	int movieID;
	while(!OIS_isKeyDown(KC_ESCAPE) && !OIS_mouseDown(MBLeft))
    {
       DoEvents();

	   static ScrnZone* oldzone =  ML_GetMouseZone();
	   ScrnZone* zone =  ML_GetMouseZone();
	   if(zone) movieID = ML_GetZoneData(zone);
	   if(oldzone != zone)
	    { 
	       DB_SetAnimationVolume(movieID, 100);
		   oldzone = zone;
	    }

	   Screen_Use2DView();
	   DB_PlayAnimationToScreen(1,0,0,200,200);
	   DB_PlayAnimationToScreen(2,200,0,400,200);
	   DB_PlayAnimationToScreen(3,400,0,600,200);
	   DB_PlayAnimationToScreen(4,600,0,800,200);
	   DB_PlayAnimationToScreen(5,0,200,200,400);
	   DB_PlayAnimationToScreen(6,200,200,400,400);
	   DB_PlayAnimationToScreen(7,400,200,600,400);
	   DB_PlayAnimationToScreen(8,600,200,800,400);
	   DB_PlayAnimationToScreen(9,0,400,800,600);
       Screen_Stop2DView();
      
	   RenderWorld();
	  
	   static float rot = 0.0f;
	   rot += 1.0f;

	   DBP_rotate_object (1 , rot , rot , 0 );

	   DBP_Paste_Sprite(5,600,200);

	   DBP_Paste_Image ( 100, 20, 300 );

	   DBP_DarkRender();
	   
	   Screen_Use2DView();
	   
	   System_UseBlitzMode();
	   Bltz_SetScale(0.5f,0.5f);
	   hgeSprite_Render(spr,OIS_mouseX(),OIS_mouseY());
	   System_StopBlitzMode();

	   Screen_Stop2DView();

	   DBP_rotate_object ( 6 , rot +0.1f,rot +0.2f,rot +0.3f ); 
	   

	   Sync();
    }

  
  EndGraphics();

}

enjoy with MagicPro library.

Post by **Kojack** » Sun Jul 19, 2015 11:05 am

Cool!

Emil_halim · Post by **Emil_halim** » Mon Jul 20, 2015 2:26 pm

thank you Kojack ,

here is another Demo that using StoonMagic of Ogre , Irrlichet Tech_demo , ReflectiveSkies of DrakBasic , collision demo of IndieLib and sandra movie , in one demo.

ofcourse each demo will render to a corsepoinding texture , then render that texter as sprites.

here is a screen shot.

here is the code.

irrdemo.h file
=============

Code: Select all

//****************************************//
//           ************                 //
//      ***MagicPro library***            //
//           ************                 //
//****************************************//


class CDemo : public irr::IEventReceiver
{
public:

	CDemo();
	~CDemo();
	void Run();
	virtual bool OnEvent(const irr::SEvent& event);
private:

	void createLoadingScreen();
	void loadSceneData();
	void switchToNextScene();
	void shoot();
	void createParticleImpacts();
		
	irr::IrrlichtDevice *device;
	irr::video::IVideoDriver* driver;
	irr::scene::ISceneManager* smgr;
	irr::gui::IGUIEnvironment* guienv;

	irr::gui::IGUIInOutFader* inOutFader;

	struct SParticleImpact
	{
		irr::u32 when;
		irr::core::vector3df pos;
		irr::core::vector3df outVector;
	};

	int currentScene;
	irr::video::SColor backColor;

	irr::scene::IQ3LevelMesh* quakeLevelMesh;
	irr::scene::ISceneNode* quakeLevelNode;
	irr::scene::ISceneNode* skyboxNode;
	irr::scene::IAnimatedMeshSceneNode* model1;
	irr::scene::IAnimatedMeshSceneNode* model2;
	irr::scene::IParticleSystemSceneNode* campFire;

	irr::scene::IMetaTriangleSelector* metaSelector;
	irr::scene::ITriangleSelector* mapSelector;

	irr::s32 sceneStartTime;
	irr::s32 timeForThisScene;

	irr::core::array<SParticleImpact> Impacts;

	irr::u32 Number;
    irr::core::stringc FilenameTemplate;
};

irrdemo.cpp file
================

Code: Select all

//****************************************//
//           ************                 //
//      ***MagicPro library***            //
//           ************                 //
//****************************************//

#include "MagicPro.h"

#include "irrdemo.h"



CDemo::CDemo( ) :  currentScene(-2), backColor(0),  quakeLevelMesh(0), quakeLevelNode(0), 
 skyboxNode(0), model1(0), model2(0), campFire(0), metaSelector(0), 
 mapSelector(0), sceneStartTime(0), timeForThisScene(0)
{
	device = GetIrrlichtDevice();

	//device->getFileSystem()->addFileArchive("irrlicht.dat");
	//device->getFileSystem()->addFileArchive("map-20kdm2.pk3");
	AddMediaDir("../../media/irr_media/irrlicht.dat");
	AddMediaDir("../../media/irr_media/map-20kdm2.pk3");
	
	driver = device->getVideoDriver();
	smgr = device->getSceneManager();
	guienv = device->getGUIEnvironment();

	FilenameTemplate.replace ( '/', '_' );
    FilenameTemplate.replace ( '\\', '_' );

	device->setEventReceiver( this );
}

CDemo::~CDemo()
{
	if (mapSelector)
		mapSelector->drop();

	if (metaSelector)
		metaSelector->drop();
}

void CDemo::Run()
{
	// set ambient light
	smgr->setAmbientLight ( irr::video::SColorf ( 0xFFc0c0c0 ) );
	wchar_t tmp[255];
	// draw everything
	irr::s32 now = 0;
	irr::s32 lastfps = 0;
	// load next scene if necessary
	now = device->getTimer()->getTime();
	if (now - sceneStartTime > timeForThisScene && timeForThisScene!=-1)
	    switchToNextScene();
	createParticleImpacts();
	smgr->drawAll();
	guienv->drawAll();
	// write statistics
	const irr::s32 nowfps = driver->getFPS();
	swprintf(tmp, 255, L"%ls fps:%3d triangles:%0.3f mio/s",
						driver->getName(), driver->getFPS(),
						driver->getPrimitiveCountDrawn(1) * (1.f / 1000000.f));							
}

bool CDemo::OnEvent(const irr::SEvent& event)
{
	if (!device)
		return false;
	if (event.KeyInput.Key == irr::KEY_F9)
    {
        irr::video::IImage* image = device->getVideoDriver()->createScreenShot();
        if (image)
        {
             irr::c8 buf[256];
             snprintf(buf, 256, "%s_shot%04d.jpg",FilenameTemplate.c_str(),++Number);
             device->getVideoDriver()->writeImageToFile(image, buf, 85 );
             image->drop();
        }
    }
	else
	if (event.EventType == irr::EET_KEY_INPUT_EVENT &&
		event.KeyInput.Key == irr::KEY_ESCAPE &&
		event.KeyInput.PressedDown == false)
	{
		// user wants to quit.
		if (currentScene < 3)
			timeForThisScene = 0;
		else
			device->closeDevice();
	}
	else
	if (((event.EventType == irr::EET_KEY_INPUT_EVENT &&
		event.KeyInput.Key == irr::KEY_SPACE &&
		event.KeyInput.PressedDown == false) ||
		(event.EventType == irr::EET_MOUSE_INPUT_EVENT &&
		 event.MouseInput.Event == irr::EMIE_LMOUSE_LEFT_UP)) &&
		currentScene == 3)
	{
		// shoot
		shoot();
	}
	else
	if (device->getSceneManager()->getActiveCamera())
	{
		device->getSceneManager()->getActiveCamera()->OnEvent(event);
		return true;
	}

	return false;
}


void CDemo::switchToNextScene()
{
	currentScene++;
	if (currentScene > 3)
		currentScene = 1;

	irr::scene::ISceneManager* sm = device->getSceneManager();
	irr::scene::ISceneNodeAnimator* sa = 0;
	irr::scene::ICameraSceneNode* camera = 0;

	camera = sm->getActiveCamera();
	if (camera)
	{
		sm->setActiveCamera(0);
		camera->remove();
		camera = 0;
	}

	switch(currentScene)
	{
	case -1: // loading screen
		timeForThisScene = 0;
		createLoadingScreen();
		break;

	case 0: // load scene
		timeForThisScene = 0;
		loadSceneData();
		break;

	case 1: // panorama camera
		{
			currentScene += 1;
			//camera = sm->addCameraSceneNode(0, core::vector3df(0,0,0), core::vector3df(-586,708,52));
			//camera->setTarget(core::vector3df(0,400,0));

			irr::core::array<irr::core::vector3df> points;

			points.push_back(irr::core::vector3df(-931.473755f, 138.300003f, 987.279114f)); // -49873
			points.push_back(irr::core::vector3df(-847.902222f, 136.757553f, 915.792725f)); // -50559
			points.push_back(irr::core::vector3df(-748.680420f, 152.254501f, 826.418945f)); // -51964
			points.push_back(irr::core::vector3df(-708.428406f, 213.569580f, 784.466675f)); // -53251
			points.push_back(irr::core::vector3df(-686.217651f, 288.141174f, 762.965576f)); // -54015
			points.push_back(irr::core::vector3df(-679.685059f, 365.095612f, 756.551453f)); // -54733
			points.push_back(irr::core::vector3df(-671.317871f, 447.360107f, 749.394592f)); // -55588
			points.push_back(irr::core::vector3df(-669.468445f, 583.335632f, 747.711853f)); // -56178
			points.push_back(irr::core::vector3df(-667.611267f, 727.313232f, 746.018250f)); // -56757
			points.push_back(irr::core::vector3df(-665.853210f, 862.791931f, 744.436096f)); // -57859
			points.push_back(irr::core::vector3df(-642.649597f, 1026.047607f, 724.259827f)); // -59705
			points.push_back(irr::core::vector3df(-517.793884f, 838.396790f, 490.326050f)); // -60983
			points.push_back(irr::core::vector3df(-474.387299f, 715.691467f, 344.639984f)); // -61629
			points.push_back(irr::core::vector3df(-444.600250f, 601.155701f, 180.938095f)); // -62319
			points.push_back(irr::core::vector3df(-414.808899f, 479.691406f, 4.866660f)); // -63048
			points.push_back(irr::core::vector3df(-410.418945f, 429.642242f, -134.332687f)); // -63757
			points.push_back(irr::core::vector3df(-399.837585f, 411.498383f, -349.350983f)); // -64418
			points.push_back(irr::core::vector3df(-390.756653f, 403.970093f, -524.454407f)); // -65005
			points.push_back(irr::core::vector3df(-334.864227f, 350.065491f, -732.397400f)); // -65701
			points.push_back(irr::core::vector3df(-195.253387f, 349.577209f, -812.475891f)); // -66335
			points.push_back(irr::core::vector3df(16.255573f, 363.743134f, -833.800415f)); // -67170
			points.push_back(irr::core::vector3df(234.940964f, 352.957825f, -820.150696f)); // -67939
			points.push_back(irr::core::vector3df(436.797668f, 349.236450f, -816.914185f)); // -68596
			points.push_back(irr::core::vector3df(575.236206f, 356.244812f, -719.788513f)); // -69166
			points.push_back(irr::core::vector3df(594.131042f, 387.173828f, -609.675598f)); // -69744
			points.push_back(irr::core::vector3df(617.615234f, 412.002899f, -326.174072f)); // -70640
			points.push_back(irr::core::vector3df(606.456848f, 403.221954f, -104.179291f)); // -71390
			points.push_back(irr::core::vector3df(610.958252f, 407.037750f, 117.209778f)); // -72085
			points.push_back(irr::core::vector3df(597.956909f, 395.167877f, 345.942200f)); // -72817
			points.push_back(irr::core::vector3df(587.383118f, 391.444519f, 566.098633f)); // -73477
			points.push_back(irr::core::vector3df(559.572449f, 371.991333f, 777.689453f)); // -74124
			points.push_back(irr::core::vector3df(423.753204f, 329.990051f, 925.859741f)); // -74941
			points.push_back(irr::core::vector3df(247.520050f, 252.818954f, 935.311829f)); // -75651
			points.push_back(irr::core::vector3df(114.756012f, 199.799759f, 805.014160f));
			points.push_back(irr::core::vector3df(96.783348f, 181.639481f, 648.188110f));
			points.push_back(irr::core::vector3df(97.865623f, 138.905975f, 484.812561f));
			points.push_back(irr::core::vector3df(99.612457f, 102.463669f, 347.603210f));
			points.push_back(irr::core::vector3df(99.612457f, 102.463669f, 347.603210f));
			points.push_back(irr::core::vector3df(99.612457f, 102.463669f, 347.603210f));

			timeForThisScene = (points.size()-3)* 1000;

			camera = sm->addCameraSceneNode(0, points[0], irr::core::vector3df(0 ,400,0));
			//camera->setTarget(core::vector3df(0,400,0));

			sa = sm->createFollowSplineAnimator(device->getTimer()->getTime(),points);
			camera->addAnimator(sa);
			sa->drop();

			model1->setVisible(false);
			model2->setVisible(false);
			campFire->setVisible(false);
			inOutFader->fadeIn(7000);
		}
		break;

	case 2:	// down fly anim camera
		camera = sm->addCameraSceneNode(0, irr::core::vector3df(100,40,-80), irr::core::vector3df(844,670,-885));
		sa = sm->createFlyStraightAnimator(irr::core::vector3df(94, 1002, 127),irr::core::vector3df(108, 15, -60), 10000, true);
		camera->addAnimator(sa);
		timeForThisScene = 9900;
		model1->setVisible(true);
		model2->setVisible(false);
		campFire->setVisible(false);
		sa->drop();
		break;

	case 3: // interactive, go around
		{
			model1->setVisible(true);
			model2->setVisible(true);
			campFire->setVisible(true);
			timeForThisScene = -1;

			irr::SKeyMap keyMap[9];
			keyMap[0].Action = irr::EKA_MOVE_FORWARD;
			keyMap[0].KeyCode = irr::KEY_UP;
			keyMap[1].Action = irr::EKA_MOVE_FORWARD;
			keyMap[1].KeyCode = irr::KEY_KEY_W;

			keyMap[2].Action = irr::EKA_MOVE_BACKWARD;
			keyMap[2].KeyCode = irr::KEY_DOWN;
			keyMap[3].Action = irr::EKA_MOVE_BACKWARD;
			keyMap[3].KeyCode = irr::KEY_KEY_S;

			keyMap[4].Action = irr::EKA_STRAFE_LEFT;
			keyMap[4].KeyCode = irr::KEY_LEFT;
			keyMap[5].Action = irr::EKA_STRAFE_LEFT;
			keyMap[5].KeyCode = irr::KEY_KEY_A;

			keyMap[6].Action = irr::EKA_STRAFE_RIGHT;
			keyMap[6].KeyCode = irr::KEY_RIGHT;
			keyMap[7].Action = irr::EKA_STRAFE_RIGHT;
			keyMap[7].KeyCode = irr::KEY_KEY_D;

			keyMap[8].Action = irr::EKA_JUMP_UP;
			keyMap[8].KeyCode = irr::KEY_KEY_J;

			camera = sm->addCameraSceneNodeFPS(0, 100.0f, .4f, -1, keyMap, 9, false, 3.f);
			camera->setPosition(irr::core::vector3df(108,140,-140));camera->setFarValue(5000.0f);

			irr::scene::ISceneNodeAnimatorCollisionResponse* collider =
				sm->createCollisionResponseAnimator(metaSelector, camera, irr::core::vector3df(25,50,25),
				irr::core::vector3df(0, quakeLevelMesh ? -10.f : 0.0f,0),irr::core::vector3df(0,45,0), 0.005f);

			camera->addAnimator(collider);
			collider->drop();
		}
		break;
	}

	sceneStartTime = device->getTimer()->getTime();
}


void CDemo::loadSceneData()
{
	// load quake level

	irr::video::IVideoDriver* driver = device->getVideoDriver();
	irr::scene::ISceneManager* sm = device->getSceneManager();

	// Quake3 Shader controls Z-Writing
	sm->getParameters()->setAttribute(irr::scene::ALLOW_ZWRITE_ON_TRANSPARENT, true);

	quakeLevelMesh = (irr::scene::IQ3LevelMesh*) sm->getMesh("20kdm2.bsp");

	if (quakeLevelMesh)
	{
		irr::u32 i;

		//move all quake level meshes (non-realtime)
		irr::core::matrix4 m;
		m.setTranslation(irr::core::vector3df(-1300,-70,-1249));

		for ( i = 0; i != irr::scene::quake3::E_Q3_MESH_SIZE; ++i )
			sm->getMeshManipulator()->transform(quakeLevelMesh->getMesh(i), m);

		quakeLevelNode = sm->addOctreeSceneNode(
				quakeLevelMesh->getMesh( irr::scene::quake3::E_Q3_MESH_GEOMETRY));
		if (quakeLevelNode)
		{
			//quakeLevelNode->setPosition(core::vector3df(-1300,-70,-1249));
			quakeLevelNode->setVisible(true);

			// create map triangle selector
			mapSelector = sm->createOctreeTriangleSelector(quakeLevelMesh->getMesh(0),
				quakeLevelNode, 128);

			// if not using shader and no gamma it's better to use more lighting, because
			// quake3 level are usually dark
			quakeLevelNode->setMaterialType ( irr::video::EMT_LIGHTMAP_M4 );

			// set additive blending if wanted
			quakeLevelNode->setMaterialType(irr::video::EMT_LIGHTMAP_ADD);
		}

		// the additional mesh can be quite huge and is unoptimized
		irr::scene::IMesh * additional_mesh = quakeLevelMesh->getMesh ( irr::scene::quake3::E_Q3_MESH_ITEMS );

		for ( i = 0; i!= additional_mesh->getMeshBufferCount (); ++i )
		{
			irr::scene::IMeshBuffer *meshBuffer = additional_mesh->getMeshBuffer ( i );
			const irr::video::SMaterial &material = meshBuffer->getMaterial();

			//! The ShaderIndex is stored in the material parameter
			irr::s32 shaderIndex = (irr::s32) material.MaterialTypeParam2;

			// the meshbuffer can be rendered without additional support, or it has no shader
			const irr::scene::quake3::IShader *shader = quakeLevelMesh->getShader ( shaderIndex );
			if ( 0 == shader )
			{
				continue;
			}
			// Now add the MeshBuffer(s) with the current Shader to the Manager
			sm->addQuake3SceneNode ( meshBuffer, shader );
		}
	}

	// load sydney model and create 2 instances

	irr::scene::IAnimatedMesh* mesh = 0;
	mesh = sm->getMesh("sydney.md2");
	if (mesh)
	{
		model1 = sm->addAnimatedMeshSceneNode(mesh);
		if (model1)
		{
			model1->setMaterialTexture(0, driver->getTexture("spheremap.jpg"));
			model1->setPosition(irr::core::vector3df(100,40,-80));
			model1->setScale(irr::core::vector3df(2,2,2));
			model1->setMD2Animation(irr::scene::EMAT_STAND);
			model1->setMaterialFlag(irr::video::EMF_LIGHTING, false);
			model1->setMaterialFlag(irr::video::EMF_NORMALIZE_NORMALS, true);
			model1->setMaterialType(irr::video::EMT_SPHERE_MAP);
			model1->addShadowVolumeSceneNode();
		}

		model2 = sm->addAnimatedMeshSceneNode(mesh);
		if (model2)
		{
			model2->setPosition(irr::core::vector3df(180,15,-60));
			model2->setScale(irr::core::vector3df(2,2,2));
			model2->setMD2Animation(irr::scene::EMAT_RUN);
			model2->setMaterialTexture(0, device->getVideoDriver()->getTexture("sydney.bmp"));
			model2->setMaterialFlag(irr::video::EMF_LIGHTING, true);
			model2->setMaterialFlag(irr::video::EMF_NORMALIZE_NORMALS, true);
			model2->addShadowVolumeSceneNode();
		}
	}

	irr::scene::ISceneNodeAnimator* anim = 0;

	// create sky box
	driver->setTextureCreationFlag(irr::video::ETCF_CREATE_MIP_MAPS, false);
	skyboxNode = sm->addSkyBoxSceneNode(
		driver->getTexture("irrlicht2_up.jpg"),
		driver->getTexture("irrlicht2_dn.jpg"),
		driver->getTexture("irrlicht2_lf.jpg"),
		driver->getTexture("irrlicht2_rt.jpg"),
		driver->getTexture("irrlicht2_ft.jpg"),
		driver->getTexture("irrlicht2_bk.jpg"));
	driver->setTextureCreationFlag(irr::video::ETCF_CREATE_MIP_MAPS, true);

	// create walk-between-portals animation

	irr::core::vector3df waypoint[2];
	waypoint[0].set(-150,40,100);
	waypoint[1].set(350,40,100);

	if (model2)
	{
		anim = device->getSceneManager()->createFlyStraightAnimator(
			waypoint[0], waypoint[1], 2000, true);
		model2->addAnimator(anim);
		anim->drop();
	}

	// create animation for portals;

	irr::core::array<irr::video::ITexture*> textures;
	for (irr::s32 g=1; g<8; ++g)
	{
		irr::core::stringc tmp("portal");
		tmp += g;
		tmp += ".bmp";
		irr::video::ITexture* t = driver->getTexture( tmp );
		textures.push_back(t);
	}

	anim = sm->createTextureAnimator(textures, 100);

	// create portals

	irr::scene::IBillboardSceneNode* bill = 0;

	for (int r=0; r<2; ++r)
	{
		bill = sm->addBillboardSceneNode(0, irr::core::dimension2d<irr::f32>(100,100),
			waypoint[r]+ irr::core::vector3df(0,20,0));
		bill->setMaterialFlag(irr::video::EMF_LIGHTING, false);
		bill->setMaterialTexture(0, driver->getTexture("portal1.bmp"));
		bill->setMaterialType(irr::video::EMT_TRANSPARENT_ADD_COLOR);
		bill->addAnimator(anim);
	}

	anim->drop();

	// create cirlce flying dynamic light with transparent billboard attached

	irr::scene::ILightSceneNode* light = 0;

	light = sm->addLightSceneNode(0,irr::core::vector3df(0,0,0),irr::video::SColorf(1.0f, 1.0f, 1.f, 1.0f), 500.f);

	anim = sm->createFlyCircleAnimator(irr::core::vector3df(100,150,80), 80.0f, 0.0005f);

	light->addAnimator(anim);
	anim->drop();

	bill = device->getSceneManager()->addBillboardSceneNode(light,irr::core::dimension2d<irr::f32>(40,40));
	bill->setMaterialFlag(irr::video::EMF_LIGHTING, false);
	bill->setMaterialTexture(0, driver->getTexture("particlewhite.bmp"));
	bill->setMaterialType(irr::video::EMT_TRANSPARENT_ADD_COLOR);

	// create meta triangle selector with all triangles selectors in it.
	metaSelector = sm->createMetaTriangleSelector();
	metaSelector->addTriangleSelector(mapSelector);

	// create camp fire

	campFire = sm->addParticleSystemSceneNode(false);
	campFire->setPosition(irr::core::vector3df(100,120,600));
	campFire->setScale(irr::core::vector3df(2,2,2));

	irr::scene::IParticleEmitter* em = campFire->createBoxEmitter(irr::core::aabbox3d<irr::f32>(-7,0,-7,7,1,7),
		irr::core::vector3df(0.0f,0.06f,0.0f),80,100,irr::video::SColor(1,255,255,255),irr::video::SColor(1,255,255,255), 800,2000);

	em->setMinStartSize(irr::core::dimension2d<irr::f32>(20.0f, 10.0f));
	em->setMaxStartSize(irr::core::dimension2d<irr::f32>(20.0f, 10.0f));
	campFire->setEmitter(em);
	em->drop();

	irr::scene::IParticleAffector* paf = campFire->createFadeOutParticleAffector();
	campFire->addAffector(paf);
	paf->drop();

	campFire->setMaterialFlag(irr::video::EMF_LIGHTING, false);
	campFire->setMaterialFlag(irr::video::EMF_ZWRITE_ENABLE, false);
	campFire->setMaterialTexture(0, driver->getTexture("fireball.bmp"));
	campFire->setMaterialType(irr::video::EMT_TRANSPARENT_ADD_COLOR);
}


void CDemo::createLoadingScreen()
{
	irr::core::dimension2d<irr::u32> size = device->getVideoDriver()->getScreenSize();

	device->getCursorControl()->setVisible(false);

	// setup loading screen

	backColor.set(255,90,90,156);

	// create in fader

	inOutFader = device->getGUIEnvironment()->addInOutFader();
	inOutFader->setColor(backColor,	irr::video::SColor ( 0, 230, 230, 230 ));
		
}


void CDemo::shoot()
{
	irr::scene::ISceneManager* sm = device->getSceneManager();
	irr::scene::ICameraSceneNode* camera = sm->getActiveCamera();

	if (!camera || !mapSelector)
		return;

	SParticleImpact imp;
	imp.when = 0;

	// get line of camera

	irr::core::vector3df start = camera->getPosition();
	irr::core::vector3df end = (camera->getTarget() - start);
	end.normalize();
	start += end*8.0f;
	end = start + (end * camera->getFarValue());

	irr::core::triangle3df triangle;

	irr::core::line3d<irr::f32> line(start, end);

	// get intersection point with map
	irr::scene::ISceneNode* hitNode;
	if (sm->getSceneCollisionManager()->getCollisionPoint(
		line, mapSelector, end, triangle, hitNode))
	{
		// collides with wall
		irr::core::vector3df out = triangle.getNormal();
		out.setLength(0.03f);

		imp.when = 1;
		imp.outVector = out;
		imp.pos = end;
	}
	else
	{
		// doesnt collide with wall
		irr::core::vector3df start = camera->getPosition();
		irr::core::vector3df end = (camera->getTarget() - start);
		end.normalize();
		start += end*8.0f;
		end = start + (end * camera->getFarValue());
	}

	// create fire ball
	irr::scene::ISceneNode* node = 0;
	node = sm->addBillboardSceneNode(0,	irr::core::dimension2d<irr::f32>(25,25), start);

	node->setMaterialFlag(irr::video::EMF_LIGHTING, false);
	node->setMaterialTexture(0, device->getVideoDriver()->getTexture("fireball.bmp"));
	node->setMaterialType(irr::video::EMT_TRANSPARENT_ADD_COLOR);

	irr::f32 length = (irr::f32)(end - start).getLength();
	const irr::f32 speed = 0.6f;
	irr::u32 time = (irr::u32)(length / speed);

	irr::scene::ISceneNodeAnimator* anim = 0;

	// set flight line

	anim = sm->createFlyStraightAnimator(start, end, time);
	node->addAnimator(anim);
	anim->drop();

	anim = sm->createDeleteAnimator(time);
	node->addAnimator(anim);
	anim->drop();

	if (imp.when)
	{
		// create impact note
		imp.when = device->getTimer()->getTime() + (time - 100);
		Impacts.push_back(imp);
	}
}


void CDemo::createParticleImpacts()
{
	irr::u32 now = device->getTimer()->getTime();
	irr::scene::ISceneManager* sm = device->getSceneManager();

	for (irr::s32 i=0; i<(irr::s32)Impacts.size(); ++i)
		if (now > Impacts[i].when)
		{
			// create smoke particle system
			irr::scene::IParticleSystemSceneNode* pas = 0;

			pas = sm->addParticleSystemSceneNode(false, 0, -1, Impacts[i].pos);

			pas->setParticleSize(irr::core::dimension2d<irr::f32>(10.0f, 10.0f));

			irr::scene::IParticleEmitter* em = pas->createBoxEmitter(
				irr::core::aabbox3d<irr::f32>(-5,-5,-5,5,5,5),
				Impacts[i].outVector, 20,40, irr::video::SColor(50,255,255,255),irr::video::SColor(50,255,255,255),
				1200,1600, 20);

			pas->setEmitter(em);
			em->drop();

			irr::scene::IParticleAffector* paf = campFire->createFadeOutParticleAffector();
			pas->addAffector(paf);
			paf->drop();

			pas->setMaterialFlag(irr::video::EMF_LIGHTING, false);
			pas->setMaterialFlag(irr::video::EMF_ZWRITE_ENABLE, false);
			pas->setMaterialTexture(0, device->getVideoDriver()->getTexture("smoke.bmp"));
			pas->setMaterialType(irr::video::EMT_TRANSPARENT_ADD_COLOR);

			irr::scene::ISceneNodeAnimator* anim = sm->createDeleteAnimator(2000);
			pas->addAnimator(anim);
			anim->drop();
			
			// delete entry
			Impacts.erase(i);
			i--;
		}
}

MagicPro_Tech_Demo.cpp file
============================

Code: Select all

//****************************************//
//           ************                 //
//      ***MagicPro library***            //
//           ************                 //
//****************************************//

#include "MagicPro.h"

#include "irrdemo.h"

Ogre::AnimationState* mAnimState;



int WINAPI WinMain (HINSTANCE  hInst,HINSTANCE  hPrev,LPSTR CmdLine,int CmdShow)
{
	
	AppTitle("MagicPro Test Example");
    setConfigFiles("","","MagicPro.log");
	int Width = DBP_GetDesktopWidth();
	int Height = DBP_GetDesktopHeight();	
	Graphics3D(Width,Height);

{ // start of Ogre stuff	================================================================================		
	char* group = "StoneMagic";
	Ogre::ResourceGroupManager &res = Ogre::ResourceGroupManager::getSingleton();
    res.createResourceGroup(group);
	AddMediaDir("media/StoneMagic",group);
	AddMediaDir("media/StoneMagic/fonts",group);
	AddMediaDir("media/StoneMagic/materials/programs",group);
	AddMediaDir("media/StoneMagic/materials/textures",group);
	AddMediaDir("media/StoneMagic/materials/scripts",group);
	AddMediaDir("media/StoneMagic/particle",group);
	AddMediaDir("media/StoneMagic/packs/models.zip",group); 
	AddMediaDir("../../media/irr_media",group);
	AddMediaDir("../../media/MagicMedia/movie",group);
	AddMediaDir("media/resources",group);
	AddMediaDir("media/resources/animations",group);
	PB_Parse3DScript(group);
	
	hgeSystem_SetStateBool(CLEAR_BUF_BY_OGRE, false);
	
	
	    Ogre::SceneManager* mSceneMgr = GetOgreSceneManager();
		// Set ambient light
		mSceneMgr->setAmbientLight(Ogre::ColourValue(0.5f, 0.5f, 0.5f));

		// Create a light
		Ogre::Light* l = mSceneMgr->createLight("MainLight");

		l->setPosition(20,80,50);
		
		//------------------------------------------
		Ogre::Entity *ground = mSceneMgr->createEntity( "ground", "Plane01.mesh" );
		Ogre::Entity *s1 = mSceneMgr->createEntity( "s1", "s1.mesh" );
		Ogre::Entity *s2 = mSceneMgr->createEntity( "s2", "s2.mesh" );
		Ogre::Entity *s3 = mSceneMgr->createEntity( "s3", "s3.mesh" );
		Ogre::Entity *s4 = mSceneMgr->createEntity( "s4", "s4.mesh" );
		Ogre::Entity *s5 = mSceneMgr->createEntity( "s5", "s5.mesh" );
		Ogre::Entity *s6 = mSceneMgr->createEntity( "s6", "s6.mesh" );
		Ogre::Entity *s7 = mSceneMgr->createEntity( "s7", "s7.mesh" );
		Ogre::Entity *s8 = mSceneMgr->createEntity( "s8", "s8.mesh" );
		Ogre::Entity *s9 = mSceneMgr->createEntity( "s9", "s9.mesh" );
		Ogre::Entity *s10 = mSceneMgr->createEntity( "s10", "s10.mesh" );
		Ogre::Entity *s11 = mSceneMgr->createEntity( "s11", "s11.mesh" );
		Ogre::Entity *s12 = mSceneMgr->createEntity( "s12", "s12.mesh" );
		Ogre::Entity *s13 = mSceneMgr->createEntity( "s13", "s13.mesh" );
		Ogre::Entity *s14 = mSceneMgr->createEntity( "s14", "s14.mesh" );
		Ogre::Entity *s15 = mSceneMgr->createEntity( "s15", "s15.mesh" );

		mSceneMgr->getRootSceneNode()->attachObject(ground);
		mSceneMgr->getRootSceneNode()->attachObject(s1);
		mSceneMgr->getRootSceneNode()->attachObject(s2);
		mSceneMgr->getRootSceneNode()->attachObject(s3);
		mSceneMgr->getRootSceneNode()->attachObject(s4);
		mSceneMgr->getRootSceneNode()->attachObject(s5);
		mSceneMgr->getRootSceneNode()->attachObject(s6);
		mSceneMgr->getRootSceneNode()->attachObject(s7);
		mSceneMgr->getRootSceneNode()->attachObject(s8);
		mSceneMgr->getRootSceneNode()->attachObject(s9);
		mSceneMgr->getRootSceneNode()->attachObject(s10);
		mSceneMgr->getRootSceneNode()->attachObject(s11);
		mSceneMgr->getRootSceneNode()->attachObject(s12);
		mSceneMgr->getRootSceneNode()->attachObject(s13);
		mSceneMgr->getRootSceneNode()->attachObject(s14);
		mSceneMgr->getRootSceneNode()->attachObject(s15);

		Ogre::Entity *cast1 = mSceneMgr->createEntity( "cast1", "cast1.mesh" );
		Ogre::SceneNode* cast1_node=mSceneMgr->getRootSceneNode()->createChildSceneNode();
		cast1_node->attachObject(cast1);
		
		Ogre::Entity *pilon = mSceneMgr->createEntity( "pilon", "pilon.mesh" );
		Ogre::SceneNode* pilon_node=mSceneMgr->getRootSceneNode()->createChildSceneNode();
		pilon_node->attachObject(pilon);

		
		Ogre::ParticleSystem* pSys2 = mSceneMgr->createParticleSystem("fountain1","PEExamples/stoneh2");
		mSceneMgr->getRootSceneNode()->attachObject(pSys2);


		Ogre::ParticleSystem* pSys3 = mSceneMgr->createParticleSystem("fountain2", "PEExamples/stoneh2_small");
		Ogre::ParticleSystem* pSys4 = mSceneMgr->createParticleSystem("fountain3", "PEExamples/stoneh2_small");
		Ogre::ParticleSystem* pSys5 = mSceneMgr->createParticleSystem("fountain4", "PEExamples/stoneh2_small");
		Ogre::SceneNode* spout_node1=mSceneMgr->getRootSceneNode()->createChildSceneNode();
		Ogre::SceneNode* spout_node2=mSceneMgr->getRootSceneNode()->createChildSceneNode();
		Ogre::SceneNode* spout_node3=mSceneMgr->getRootSceneNode()->createChildSceneNode();

		spout_node1->attachObject(pSys3);
		spout_node2->attachObject(pSys4);
		spout_node3->attachObject(pSys5);

		Ogre::Real max2ogre=0.025f;
		Ogre::Vector3 triSpoutPos1=Ogre::Vector3(-0.084f/max2ogre,0.354f/max2ogre,-7.047f/max2ogre);
		Ogre::Vector3 triSpoutPos2=Ogre::Vector3(5.872f/max2ogre,0.354f/max2ogre,3.461f/max2ogre);
		Ogre::Vector3 triSpoutPos3=Ogre::Vector3(-5.787f/max2ogre,0.354f/max2ogre,3.351f/max2ogre);

		spout_node1->setPosition(triSpoutPos1);
		spout_node2->setPosition(triSpoutPos2);
		spout_node3->setPosition(triSpoutPos3);

		Ogre::Entity *cast3 = mSceneMgr->createEntity( "cast3", "cast1.mesh" );
		Ogre::SceneNode* cast3_node=mSceneMgr->getRootSceneNode()->createChildSceneNode();
		cast3_node->attachObject(cast3);
		cast3_node->setScale(5,1,5);
		cast3_node->setPosition(0,100,0);
		cast3->setMaterialName("cast3");

		Ogre::Entity *cast4 = mSceneMgr->createEntity( "cast4", "cast1.mesh" );
		Ogre::SceneNode* cast4_node=mSceneMgr->getRootSceneNode()->createChildSceneNode();
		cast4_node->attachObject(cast4);
		cast4_node->setScale(2,1,2);
		cast4_node->setPosition(0,200,0);
		cast4->setMaterialName("cast4");

		Ogre::Entity *castTri1 = mSceneMgr->createEntity( "castTri1", "cast1.mesh" );
		Ogre::SceneNode* castTriNode1=mSceneMgr->getRootSceneNode()->createChildSceneNode();
		castTriNode1->attachObject(castTri1);
		castTriNode1->setScale(0.5f,0.1f,0.5f);
		castTriNode1->setPosition(triSpoutPos1-Ogre::Vector3(0,-10,0));
		castTri1->setMaterialName("castTri");

		Ogre::Entity *castSun2 = mSceneMgr->createEntity( "castSun2", "cast1.mesh" );
		Ogre::SceneNode* castSunNode2=mSceneMgr->getRootSceneNode()->createChildSceneNode();
		castSunNode2->attachObject(castSun2);
		castSunNode2->setScale(1.5f,0.1f,1.5f);
		castSunNode2->setPosition(0,10,0);
		castSun2->setMaterialName("castsun1");

		Ogre::SceneNode* castSunNode[20];
		for (int sc=1;sc<20;sc++) {

			Ogre::Entity *castSun1 = mSceneMgr->createEntity( "castSun1"+Ogre::StringConverter::toString(sc), "cast1.mesh" );
			castSunNode[sc]=mSceneMgr->getRootSceneNode()->createChildSceneNode();
			castSunNode[sc]->attachObject(castSun1);
			castSunNode[sc]->setScale(2.5f-sc*0.05f,0.1f,2.5f-sc*0.05f);
			castSunNode[sc]->setPosition(0,40.0f+sc*10.0f,0);
			castSunNode[sc]->yaw(Ogre::Radian(0.5f));
			castSunNode[sc]->pitch(Ogre::Radian(float(rand()%5)));
			castSunNode[sc]->roll(Ogre::Radian(float(rand()%5)));
			castSun1->setMaterialName("castsun");
		};

		Ogre::Entity *castTri2 = mSceneMgr->createEntity( "castTri2", "cast1.mesh" );
		Ogre::SceneNode* castTriNode2=mSceneMgr->getRootSceneNode()->createChildSceneNode();
		castTriNode2->attachObject(castTri2);
		castTriNode2->setScale(0.5f,0.1f,0.5f);
		castTriNode2->setPosition(triSpoutPos2-Ogre::Vector3(0,-10.0f,0));
		castTriNode2->yaw(Ogre::Radian(-90.0f));
		castTri2->setMaterialName("castTri");

		Ogre::Entity *castTri3 = mSceneMgr->createEntity( "castTri3", "cast1.mesh" );
		Ogre::SceneNode* castTriNode3=mSceneMgr->getRootSceneNode()->createChildSceneNode();
		castTriNode3->attachObject(castTri3);
		castTriNode3->setScale(0.5f,0.1f,0.5f);
		castTriNode3->setPosition(triSpoutPos3-Ogre::Vector3(0,-10,0));
		castTriNode3->yaw(Ogre::Radian(90.0f));
		castTri3->setMaterialName("castTri");


		Ogre::Entity *gorizont = mSceneMgr->createEntity( "gorizont", "gorizont.mesh" );
		mSceneMgr->getRootSceneNode()->attachObject(gorizont);
		Ogre::Entity *barier = mSceneMgr->createEntity( "barier", "barier.mesh" );
		mSceneMgr->getRootSceneNode()->attachObject(barier);

		//-----------------------------------------
		Ogre::SceneNode* lookNode= mSceneMgr->getRootSceneNode()->createChildSceneNode();
		lookNode->setPosition(0,200,0);

		 // Create the camera
        Ogre::Camera* mCamera = mSceneMgr->createCamera("PlayerCam");

        // Position it at 500 in Z direction
        mCamera->setPosition(Ogre::Vector3(0,0,500));
        // Look back along -Z
        mCamera->lookAt(Ogre::Vector3(0,0,-300));
        mCamera->setNearClipDistance(5);
		// Create one viewport, entire window
        Ogre::Viewport* vp = GetOgreRenderWindow()->addViewport(mCamera);
        vp->setBackgroundColour(Ogre::ColourValue(0,0,0));

        // Alter the camera aspect ratio to match the viewport
        mCamera->setAspectRatio(Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight()));
		  
		Ogre::SceneNode* camNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
		camNode->attachObject(mCamera);
		mCamera->setPosition(0,0,0);

		camNode->setPosition(-244.852f,392.682f,-357.77f);
		camNode->setOrientation(Ogre::Quaternion(0.345054f,-0.0821347f,0.909552f,0.216516f));

		camNode->needUpdate();

		// set up spline animation of node
		Ogre::Animation* anim = mSceneMgr->createAnimation("CameraTrack",319.382f-28.307f);// 319.382-28.5128
		// Spline it for nice curves
		anim->setInterpolationMode(Ogre::Animation::IM_SPLINE);

		//anim->setInterpolationMode(Animation::IM_LINEAR);
		// Create a track to animate the camera's node
		Ogre::AnimationTrack* track = anim->createNodeTrack(0, camNode);
		// Setup keyframes
		Ogre::TransformKeyFrame* key;
		key = (Ogre::TransformKeyFrame*)track->createKeyFrame(0); // startposition

		Ogre::Real animDelay=1;
		Ogre::Real timOffset=-28.8307f*animDelay;

		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*28.8307f+timOffset);
		key->setTranslate(Ogre::Vector3(-244.852f,392.682f,-357.77f));
		key->setRotation(Ogre::Quaternion(0.345054f,-0.0821347f,0.909552f,0.216516f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*35.2817f+timOffset);
		key->setTranslate(Ogre::Vector3(-393.737f,294.394f,-113.343f));
		key->setRotation(Ogre::Quaternion(-0.306394f,0.0508652f,0.937698f,0.155653f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*40.6439f+timOffset);
		key->setTranslate(Ogre::Vector3(-422.293f,349.852f,173.018f));
		key->setRotation(Ogre::Quaternion(-0.800221f,0.201077f,0.547927f,0.137671f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*49.6474f+timOffset);
		key->setTranslate(Ogre::Vector3(-79.646f,349.852f,560.048f));
		key->setRotation(Ogre::Quaternion(-0.896801f,0.294858f,0.313268f,0.102994f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*58.5187f+timOffset);
		key->setTranslate(Ogre::Vector3(501.429f,267.73f,432.065f));
		key->setRotation(Ogre::Quaternion(-0.993273f,0.115458f,-0.000865597f,-0.000100481f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*67.743f+timOffset);
		key->setTranslate(Ogre::Vector3(640.836f,323.694f,-73.3012f));
		key->setRotation(Ogre::Quaternion(-0.605509f,0.0523376f,-0.79111f,-0.0683883f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*82.8461f+timOffset);
		key->setTranslate(Ogre::Vector3(169.581f,523.395f,-738.473f));
		key->setRotation(Ogre::Quaternion(-0.153773f,0.0488329f,-0.940583f,-0.298618f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*94.9738f+timOffset);
		key->setTranslate(Ogre::Vector3(-544.202f,335.46f,-620.324f));
		key->setRotation(Ogre::Quaternion(-0.0808456f,0.0166631f,-0.976055f,-0.200973f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*114.848f+timOffset);
		key->setTranslate(Ogre::Vector3(-1279.63f,1060.58f,186.159f));
		key->setRotation(Ogre::Quaternion(0.734783f,-0.290591f,-0.569856f,-0.22537f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*129.583f+timOffset);
		key->setTranslate(Ogre::Vector3(-892.411f,1131.63f,999.012f));
		key->setRotation(Ogre::Quaternion(0.837642f,-0.232815f,-0.47594f,-0.132303f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*141.035f+timOffset);
		key->setTranslate(Ogre::Vector3(-404.345f,716.693f,1474.86f));
		key->setRotation(Ogre::Quaternion(0.905332f,-0.191741f,-0.370559f,-0.0785072f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*154.269f+timOffset);
		key->setTranslate(Ogre::Vector3(528.32f,321.039f,1093.36f));
		key->setRotation(Ogre::Quaternion(0.949058f,-0.24763f,0.188184f,0.0490821f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*167.148f+timOffset);
		key->setTranslate(Ogre::Vector3(245.522f,66.4289f,417.204f));
		key->setRotation(Ogre::Quaternion(0.969895f,-0.00327889f,0.243174f,0.000821591f));

		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*180.0f+timOffset);
		key->setTranslate(Ogre::Vector3(74.5456f,161.762f,229.612f));
		key->setRotation(Ogre::Quaternion(0.919624f,-0.37099f,0.119602f,0.048247f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*200.0f+timOffset);
		key->setTranslate(Ogre::Vector3(99.7407f,953.843f,310.485f));
		key->setRotation(Ogre::Quaternion(0.815697f,-0.560923f,0.116455f,0.0800779f));

		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*213.003f+timOffset);
		key->setTranslate(Ogre::Vector3(740.743f,158.305f,165.596f));
		key->setRotation(Ogre::Quaternion(0.461686f,-0.0305725f,0.884463f,0.0582964f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*231.324f+timOffset);
		key->setTranslate(Ogre::Vector3(1889.01f,281.073f,89.9274f));
		key->setRotation(Ogre::Quaternion(0.723468f,0.00313488f,0.690157f,-0.00313797f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*249.487f+timOffset);
		key->setTranslate(Ogre::Vector3(2872.93f,118.85f,-472.164f));
		key->setRotation(Ogre::Quaternion(0.657661f,0.0386955f,0.750839f,-0.0443189f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*264.965f+timOffset);
		key->setTranslate(Ogre::Vector3(2613.98f,169.808f,-1362.87f));
		key->setRotation(Ogre::Quaternion(0.515329f,0.0279485f,0.855113f,-0.0465596f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*278.284f+timOffset);
		key->setTranslate(Ogre::Vector3(2000.71f,209.627f,-1909.93f));
		key->setRotation(Ogre::Quaternion(0.39415f,0.0271869f,0.916301f,-0.0634344f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*292.262f+timOffset);
		key->setTranslate(Ogre::Vector3(844.269f,282.555f,-1766.07f));
		key->setRotation(Ogre::Quaternion(0.227154f,0.00503583f,0.973453f,-0.0220159f));
		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*308.494f+timOffset);
		key->setTranslate(Ogre::Vector3(34.4144f,291.87f,-1023.65f));
		key->setRotation(Ogre::Quaternion(0.0827656f,-0.00208207f,0.996139f,0.023802f));

		key = (Ogre::TransformKeyFrame*) track->createKeyFrame(animDelay*319.382f+timOffset);
		key->setTranslate(Ogre::Vector3(-244.852f,392.682f,-357.77f));
		key->setRotation(Ogre::Quaternion(0.345054f,-0.0821347f,0.909552f,0.216516f));



		// Create a new animation state to track this
		mAnimState = mSceneMgr->createAnimationState("CameraTrack");
		mAnimState->setEnabled(true);

	
} //End of Ogre stuff	================================================================================	



{ // start of DarkBasic stuff	================================================================================
	char* group = "DarkBasic";
	AddMediaDir("../../media/DarkBasic",group);
	AddMediaDir("../../media/DarkBasic/ReflectiveSkies",group);
	AddMediaDir("../../media/DarkBasic/ReflectiveSkies/skies",group);
	PB_Parse3DScript(group);

	DBP_Backdrop_Off();
	 //rem Create skybox
     for(int o=2; o <= 7; o++)
	  {
          DBP_make_object_plain( o,101.0f,101.0f );  DBP_set_object( o,1,1,1,2,0,0,0 );
		  if( o==2 ){ DBP_position_object ( o,-50.0f,0.0f,0.0f ); DBP_yrotate_object( o,270.0f );  }
		  if( o==3 ){ DBP_position_object ( o, 50.0f,0.0f,0.0f ); DBP_yrotate_object( o,90.0f  );  }
		  if( o==4 ){ DBP_position_object ( o,0.0f,-50.0f,0.0f ); DBP_xrotate_object( o,90.0f );   }
		  if( o==5 ){ DBP_position_object ( o,0.0f, 50.0f,0.0f ); DBP_xrotate_object( o,270.0f );  }
		  if( o==6 ){ DBP_position_object ( o,0.0f,0.0f, 50.0f ); DBP_yrotate_object( o,0.0f );    }
		  if( o==7 ){ DBP_position_object ( o,0.0f,0.0f,-50.0f ); DBP_yrotate_object( o,180.0f );  }
	  }

	 Image_Load (  "ice/neg_x.png",1 );
     Image_Load (  "ice/pos_x.png",2 );
     Image_Load (  "ice/neg_y.png",3 );
     Image_Load (  "ice/pos_y.png",4 );
     Image_Load (  "ice/neg_z.png",5 );
     Image_Load (  "ice/pos_z.png",6 );
     for(int o=2; o<= 7; o++)
		   DBP_texture_object ( o, o-1 );
 
	// DBP_load_object ( "alien/Alien.X" , 1 );   
	// DBP_scale_object(1, 10.0f, 10.0f , 10.0f);
	// DBP_position_object ( 1 ,0.0f,-10.0f,0.0f );
	 DBP_set_effect_on ( 1,"model/metal.fx",1  );
   	 DBP_scale_object(1, 25.0f, 25.0f , 25.0f);

} //End of DarkBasic stuff	================================================================================	

    int OgreID = 300;
    Image_MakeRenderTarget ( OgreID , 600 , 400 );
    hgeSprite*  OgreSpr = make_mlSprite(OgreID);
    
	CDemo* irr_demo = new CDemo;
    int IrrID = 400;
    Image_MakeRenderTarget ( IrrID , 600 , 400 );
    hgeSprite*  IrrSpr = make_mlSprite(IrrID);

	int DarkID = 500;
    Image_MakeRenderTarget ( DarkID , 600 , 400 );
    hgeSprite*  DarkSpr = make_mlSprite(DarkID);

	int IndieID = 600;
    Image_MakeRenderTarget ( IndieID , 600 , 400 );
    hgeSprite*  IndieSpr = make_mlSprite(IndieID);

	// IndieLib stuff
	//{
		// Loading Background
	    IND_Surface mSurfaceBack;
	    GetIndSurfaceManager()->Add (&mSurfaceBack, "twist.jpg", IND_OPAQUE, IND_32);
	
		// Loading Rocket
	    IND_Surface mSurfaceRocket;
	    GetIndSurfaceManager()->Add (&mSurfaceRocket, "rocket.png", IND_ALPHA, IND_32);

		// Loading Beetleship
	    IND_Surface mSurfaceBeetle;
	    GetIndSurfaceManager()->Add (&mSurfaceBeetle, "beetleship.png", IND_ALPHA, IND_32);

		// Sword Master animation, we apply a color key of (0, 255, 0)
     	IND_Animation mSwordMasterAnimation;
	    GetIndAnimationManager()->AddToSurface (&mSwordMasterAnimation, "sword_master.xml", IND_ALPHA, IND_32, 0, 255, 0);
		
	
		// Font
	    IND_Font mFontSmall;
	    GetIndFontManager()->Add(&mFontSmall, "font_small.png", "font_small.xml", IND_ALPHA, IND_32);


		// Creating 2d entity for the background
	    IND_Entity2d mBack;			
	    GetIndEntity2dManager()->Add (&mBack);					// Entity adding
	    mBack.SetSurface (&mSurfaceBack);						// Set the surface into the entity
		// Background
	    mBack.SetHotSpot (0.5f, 0.5f);
	    mBack.SetPosition (400, 300, 1);
	    mBack.SetScale (1.7f, 1.7f);

		// Creating 2d entity for the Rocket
	    IND_Entity2d mRocket;					
	    GetIndEntity2dManager()->Add (&mRocket);					// Entity adding
	    mRocket.SetSurface (&mSurfaceRocket);					// Set the surface into the entity
		// Rocket
	    mRocket.SetHotSpot (0.5f, 0.5f);
	    mRocket.SetPosition (200, 400, 2);
	    mRocket.SetBoundingAreas ("rocket_collisions.xml");
		
		// Creating 2d entity for the Beetleship
	    IND_Entity2d mBeetle;					
	    GetIndEntity2dManager()->Add (&mBeetle);					// Entity adding
	    mBeetle.SetSurface (&mSurfaceBeetle);					// Set the surface into the entity
		// Beetle
	    mBeetle.SetHotSpot (0.5f, 0.5f);
	    mBeetle.SetMirrorX (1);
		mBeetle.SetPosition (600, 450, 3);
	    mBeetle.SetBoundingTriangle ("beetle_head", 160, 105, 160, 170, 190, 135);
	    mBeetle.SetBoundingCircle ("beetle_boy_head", 85, 52, 55);
	
		// Creating 2d entity for the Sword Master animation
	    IND_Entity2d mSwordMaster;
	    GetIndEntity2dManager()->Add (&mSwordMaster);				// Entity adding
		mSwordMaster.SetAnimation (&mSwordMasterAnimation);		// Set the animation into the entity
	
		// Sword Master Animation
    	mSwordMaster.SetHotSpot (0.5f, 0.5f);
	    mSwordMaster.SetPosition (400, 220, 4);

		// Text small white
  	    IND_Entity2d mTextSmallWhite;					
	    GetIndEntity2dManager()->Add(&mTextSmallWhite);				// Entity adding
		mTextSmallWhite.SetFont(&mFontSmall);					// Set the font into the entity

		// Text
		mTextSmallWhite.SetLineSpacing(18);
	    mTextSmallWhite.SetCharSpacing(-7);
	    mTextSmallWhite.SetPosition(400, 30, 10);
	    mTextSmallWhite.SetAlign(IND_CENTER);

		IND_Camera2d mCamera2d( 800/ 2, 600 / 2);
	//}

	    float	mAngle = 0;
	    float	mScale = 1.0f;
	    int		mSpeedRotation = 5;
	    int		mSpeedScaling = 1;
	    float	mDelta;
 
	
	// movie stuff
	DB_LoadAnimation(1,"Sandra - Infinite Kiss ( 2012 ).mpg");
	DB_PlayAnimation(1);
	DB_SetAnimationVolume(1, 100);


   while(!OIS_isKeyDown(KC_ESCAPE) && !OIS_mouseDown(MBLeft))
    {
       DoEvents();
	   
	   mAnimState->addTime(Timer_GetDelta());

	   ML_StartRenderingTo( OgreID );
	   GetDX9Device()->Clear ( 0, NULL, D3DCLEAR_TARGET |D3DCLEAR_STENCIL | D3DCLEAR_ZBUFFER , D3DCOLOR_ARGB (255, 0, 0, 0 ), 1.0f, 0 );
	   RenderWorld();
	   ML_StartRenderingTo( IrrID  ); 
	   DBP_Cls();
	   irr_demo->Run();
	   ML_StartRenderingTo( DarkID ); 
	   GetDX9Device()->Clear ( 0, NULL, D3DCLEAR_TARGET |D3DCLEAR_STENCIL | D3DCLEAR_ZBUFFER , D3DCOLOR_ARGB (255, 0, 0, 0 ), 1.0f, 0 );
	   float cama = Timer_GetTime();
	   DBP_position_camera (cosf(cama)*45.0f,0.0f,sinf(cama)*45.0f);
	   DBP_point_camera(0,0.0f,0.0f,0.0f);
	   DBP_DarkRender();

	   ML_StartRenderingTo( IndieID );
	   GetDX9Device()->Clear ( 0, NULL, D3DCLEAR_TARGET |D3DCLEAR_STENCIL | D3DCLEAR_ZBUFFER , D3DCOLOR_ARGB (255, 0, 0, 0 ), 1.0f, 0 );
	   // IndieLib stuff
	   mDelta =  Timer_GetDelta();

	   if (OIS_isKeyDown(KC_RIGHT)){
			mScale += mSpeedScaling * mDelta;
		}
	   if (OIS_isKeyDown(KC_LEFT)){
			mScale -= mSpeedScaling * mDelta;
		}
	   if (mScale < 0){
			mScale = 0;
		}
	   mAngle += mSpeedRotation * mDelta;

	   mBack.SetAngleXYZ (0, 0, -mAngle);

       mRocket.SetAngleXYZ (0, 0, mAngle);
	   mRocket.SetScale (mScale, mScale);	

	   mBeetle.SetPosition (OIS_mouseX(),OIS_mouseY(), 3);

	   mTextSmallWhite.SetText("No collision between the groups we are checking");
	   if (GetIndEntity2dManager()->IsCollision(&mRocket, "engines", &mBeetle, "beetle_boy_head")){
			mTextSmallWhite.SetText("Collision between rocket boy head and engines");
		}	

		if (GetIndEntity2dManager()->IsCollision(&mRocket, "rocket_head", &mBeetle, "beetle_head")){ 
			mTextSmallWhite.SetText("Collision between rokect head and beetle head");
		}	
		
		if (GetIndEntity2dManager()->IsCollision(&mRocket, "rocket_boy_head", &mBeetle, "beetle_boy_head")){ 
			mTextSmallWhite.SetText("Collision between rocket boy head and beetle boy head");	
		}

		if (GetIndEntity2dManager()->IsCollision(&mBeetle, "beetle_boy_head", &mSwordMaster, "sword")){ 
			mTextSmallWhite.SetText("Collision between beetle boy head and the sword");
		}

	   IND_SetViewPort2d(0, 0, 800, 600);
	   IND_SetCamera2d(&mCamera2d);
  	   GetIndEntity2dManager()->RenderEntities2d();
       GetIndEntity2dManager()->RenderCollisionAreas (255, 0, 0, 255);  

	   // start render to orignal screen
	   ML_StartRenderingTo( ); 
	   GetDX9Device()->Clear ( 0, NULL, D3DCLEAR_TARGET |D3DCLEAR_STENCIL | D3DCLEAR_ZBUFFER , D3DCOLOR_ARGB (255, 200, 200, 200 ), 1.0f, 0 );

	   static float k = 800.0f; 
	   k  -=  Timer_GetTime()*0.08f;
	   if(k < -1810.0f) k=800.0f;
	   Screen_Use2DView();
	   DB_PlayAnimationToScreen(1,1000,10,1400,200);
	   hgeSprite_RenderStretch(IndieSpr,1000, 300, 1400,500);
	   System_UseBlitzMode();
	   Bltz_SetScale(0.5f,0.5f);
	   hgeSprite_Render(OgreSpr,OIS_mouseX(),OIS_mouseY());
	   hgeSprite_Render(IrrSpr ,OIS_mouseX(),OIS_mouseY()+300.0f);
	   hgeSprite_Render(DarkSpr,OIS_mouseX(),OIS_mouseY()+600.0f);   
	   DBP_Paste_Image ( DarkID, 350, 400+k );
	   DBP_Paste_Image ( OgreID, 350, 805+k );
	   DBP_Paste_Image ( IrrID , 350, 1210+k );
	   
	   System_StopBlitzMode();
	   
	   Screen_Stop2DView();

	   Sync();
    }
    
  EndGraphics();

}

now i will try to devid my project into smaller pices , it is very huge , so that i can upload it.

Enjoy Coding with MagicPro library.

Emil_halim · Post by **Emil_halim** » Mon Jul 20, 2015 3:50 pm

Oh , does any one here know a free host sever , so i can uplade my project ,

thanks

NotCamelCase · Post by **NotCamelCase** » Mon Jul 20, 2015 7:30 pm

Emil_halim wrote:Oh , does any one here know a free host sever , so i can uplade my project ,

thanks

In case you're using GitHub and unaware of it, there is GitHub pages providing basic web intro for the projects. I don't know much to what extent you can customize it for your liking though.

https://pages.github.com/

Emil_halim · Post by **Emil_halim** » Tue Jul 21, 2015 12:04 am

Hi NotCamelCase,

thank you for your post , but i think that GitHub is for open source project .

i uesd the same old hosting site for the new MagicPro library , here is the link .

http://bcxdx.spoilerspace.com/Ogre/MagicPro_Ver_0.5.rar

Enjoy coding with MagicPro library.

Ogre Forums

OgreMagic Library[ MagicPro Ver 0.5 released ]

Re: OgreMagic Library[ Ver 1.50 released - irrlicht integrat

Re: OgreMagic Library[ Ver 1.50 released - irrlicht integrat

Re: OgreMagic Library[ Ver 1.50 released - irrlicht integrat

Re: OgreMagic Library[ Ver 1.50 released - irrlicht integrat

Re: OgreMagic Library[ Ver 1.50 released - irrlicht integrat

Re: OgreMagic Library[ Ver 1.50 released - irrlicht integrat

Re: OgreMagic Library[ Ver 1.50 released - irrlicht integrat

Re: OgreMagic Library[ Ver 1.50 released - irrlicht integrat

Re: OgreMagic Library[ Ver 1.50 released - irrlicht integrat

Re: OgreMagic Library[ Ver 1.50 released - irrlicht integrat