int main()
{
//创建设备,颜色深度16,
IrrlichtDevice *device = createDevice(EDT_OPENGL, dimension2d<u32>(640, 480), 16,
false/*不全屏*/, false/*关闭stencil buffer*/, false/*不与视频同步*/, 0);
if (!device)
return 1;
device->setWindowCaption(L"不停变化的背景色");
IVideoDriver* driver = device->getVideoDriver();
f32 bg_r = 255.0f;
f32 bg_g = 255.0f;
f32 bg_b = 255.0f;
bool fadeOut = true;
int lastFPS = -1;
u32 then = device->getTimer()->getTime();
const f32 fadeRate = 0.1f;
while(device->run())
{
const u32 now = device->getTimer()->getTime();
const f32 frameDeltaTime = (f32)(now - then);
then = now;
if (bg_r <= 0.0f) fadeOut = false;
else if (bg_r >= 255.0f) fadeOut = true;
if (fadeOut)
{
bg_r-= fadeRate * frameDeltaTime;
bg_g-= fadeRate * frameDeltaTime;
bg_b-= fadeRate * frameDeltaTime;
}
else
{
bg_r+= fadeRate * frameDeltaTime;
bg_g+= fadeRate * frameDeltaTime;
bg_b+= fadeRate * frameDeltaTime;
}
driver->beginScene(true, true, SColor(255, (u32)bg_r, (u32)bg_g, (u32)bg_b));
driver->endScene();
}
device->drop();
return 0;
}
// this test draws lines of different lengths and compares
// them with pixel placement
// grey pixels denote start and end of the white drawn lines
// black pixels only make those grey points better visible
// yellow and magenta lines should start and end next toa black pixel,
// yellow one right to the last black pixel down, magenta below the last
// black pixel to the right
// white lines are always double drawn, lines back and forth.
static bool drawLine(E_DRIVER_TYPE driverType)
{
IrrlichtDevice *device = createDevice( driverType, dimension2d<u32>(160, 120), 32);
if (!device)
return true; // Treat a failure to create a driver as benign; this saves a lot of #ifdefs
IVideoDriver* driver = device->getVideoDriver();
stabilizeScreenBackground(driver);
logTestString("Testing driver %ls\n", driver->getName());
device->getSceneManager()->addCameraSceneNode();
driver->beginScene(video::ECBF_COLOR | video::ECBF_DEPTH, SColor(255,100,101,140));
// horizontal lines
for (u32 i=0; i<20; ++i)
{
driver->draw2DLine(core::vector2di(10,10+3*i), core::vector2di(10+2*i,10+3*i));
// mark start point
driver->drawPixel(9,10+3*i+1, video::SColor(0xff000000));
driver->drawPixel(10,10+3*i+1, video::SColor(0xff888888));
driver->drawPixel(11,10+3*i+1, video::SColor(0xff000000));
// mark end point
driver->drawPixel(9+2*i,10+3*i+1, video::SColor(0xff000000));
driver->drawPixel(10+2*i,10+3*i+1, video::SColor(0xff888888));
driver->drawPixel(11+2*i,10+3*i+1, video::SColor(0xff000000));
driver->draw2DLine(core::vector2di(10+2*i,10+3*i+2), core::vector2di(10,10+3*i+2));
}
// vertical lines
for (u32 i=0; i<20; ++i)
{
driver->draw2DLine(core::vector2di(11+3*i,10), core::vector2di(11+3*i,10+2*i));
// mark start point
driver->drawPixel(11+3*i+1,9, video::SColor(0xff000000));
driver->drawPixel(11+3*i+1,10, video::SColor(0xff888888));
driver->drawPixel(11+3*i+1,11, video::SColor(0xff000000));
// mark end point
driver->drawPixel(11+3*i+1,9+2*i, video::SColor(0xff000000));
driver->drawPixel(11+3*i+1,10+2*i, video::SColor(0xff888888));
driver->drawPixel(11+3*i+1,11+2*i, video::SColor(0xff000000));
driver->draw2DLine(core::vector2di(11+3*i+2,10+2*i), core::vector2di(11+3*i+2, 10));
}
// diagonal lines
driver->draw2DLine(core::vector2di(14,14),core::vector2di(50,68), video::SColor(0xffffff00));
driver->draw2DLine(core::vector2di(15,14),core::vector2di(69,50), video::SColor(0xffff00ff));
driver->endScene();
bool result = takeScreenshotAndCompareAgainstReference(driver, "-drawLine.png");
device->closeDevice();
device->run();
device->drop();
return result;
}
/*
That's it. The Scene node is done. Now we simply have to start
the engine, create the scene node and a camera, and look at the result.
*/
int main()
{
// create engine and camera
IrrlichtDevice *device =
createDevice(video::EDT_OPENGL, core::dimension2d<s32>(640, 480), 16, false);
device->setWindowCaption(L"Custom Scene Node - Irrlicht Engine Demo");
video::IVideoDriver* driver = device->getVideoDriver();
scene::ISceneManager* smgr = device->getSceneManager();
smgr->addCameraSceneNode(0, core::vector3df(0,-40,0), core::vector3df(0,0,0));
/*
Create our scene node. Note that it is dropped (->drop()) instantly after
we create it. This is possible because the scene manager now takes
care of it. This is not nessecary, it would also be possible to drop it
at the end of the program.
*/
CSampleSceneNode *myNode =
new CSampleSceneNode(smgr->getRootSceneNode(), smgr, 666);
myNode->drop();
/*
To animate something in this boring scene consisting only of one tetraeder,
and to show, that you now can use your scene node like any other scene
node in the engine, we add an animator to the scene node, which rotates
the node a little bit.
*/
scene::ISceneNodeAnimator* anim =
smgr->createRotationAnimator(core::vector3df(0.8f, 0, 0.8f));
myNode->addAnimator(anim);
anim->drop();
/*
Now draw everything and finish.
*/
while(device->run())
{
driver->beginScene(true, true, video::SColor(0,100,100,100));
smgr->drawAll();
driver->endScene();
}
device->drop();
return 0;
}
int main( ) {
// Boring stuff: set up the scene, object & camera as usual
IrrlichtDevice* device = createDevice( DRIVER, dimension2d<s32>( 640, 480 ), 16, false, false, false, 0 );
IVideoDriver* driver = device->getVideoDriver( );
ISceneManager* smgr = device->getSceneManager( );
IGUIEnvironment* guienv = device->getGUIEnvironment( );
device->getFileSystem( )->changeWorkingDirectoryTo( MEDIA_DIRECTORY );
guienv->addStaticText( L"Lens Flare", rect<s32>( 10, 10, 260, 22 ), true );
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( smgr->getMesh( "sydney.md2" ) );
node->setMaterialFlag( EMF_LIGHTING, false );
node->setMD2Animation( scene::EMAT_STAND );
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
IAnimatedMeshSceneNode* node2 = smgr->addAnimatedMeshSceneNode( smgr->getMesh( "sydney.md2" ) );
node2->setMaterialFlag( EMF_LIGHTING, false );
node2->setMD2Animation( scene::EMAT_STAND );
node2->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
node2->setPosition( vector3df( 20.0f, 0.0f, 0.0f ) );
ICameraSceneNode* cam = smgr->addCameraSceneNode( 0, vector3df( 40.0f, 30.0f, -40.0f ), vector3df( 0.0f, 5.0f, 0.0f ) );
ISceneNode* sun = smgr->addSphereSceneNode( 50.0f, 16 );
sun->setPosition( vector3df( 0.0f, 50.0f, 1000.0f ) );
sun->setMaterialFlag( EMF_LIGHTING, false );
sun->setMaterialTexture( 0, driver->getTexture("sun.png") );
// Interesting stuff
// As before, we make a renderer
IPostProc* ppRenderer = new CRendererPostProc( smgr, dimension2di( 1024, 512 ), true, true, SColor( 255u, 100u, 101u, 140u ) );
// Now make a flare effect:
// (render from, output size, sun scene node)
// can also use a vector instead of a scene node - when using a scene node the position will follow node automatically
CLensFlarePostProc* ppFlare1 = new CLensFlarePostProc( ppRenderer, dimension2di( 1024, 512 ), driver->getTexture("flare.png"), sun, 50.0f );
CLensFlarePostProc* ppFlare2 = new CLensFlarePostProc( ppFlare1, dimension2di( 1024, 512 ), driver->getTexture("flare.png"), vector3df( -2000.0f, 50.0f, 1000.0f ) );
ppFlare2->setQuality( PPQ_CRUDE ); // Setting the quality to crude avoids pixel checking, which is slow (expecially when more than one lens flare), so if you use >1 flare, set most of them to crude.
// These variables aren't important - they are just for showing the FPS
wchar_t tmp[255]; u8 t = 0u;
while( device->run( ) ) {
cam->setPosition( vector3df( -(device->getCursorControl( )->getPosition( ).X - 320.0f) * 0.1f, (device->getCursorControl( )->getPosition( ).Y - 240.0f) * 0.2f, -70.0f ) );
driver->beginScene( false, driver->getDriverType( ) == video::EDT_DIRECT3D9 );
ppFlare2->render( NULL );
guienv->drawAll( );
driver->endScene( );
// Show the current FPS
if( ++ t == 30u ) { t = 0u; swprintf(tmp, 255, L"%ls fps:%3d", driver->getName(), driver->getFPS() ); device->setWindowCaption( tmp ); }
}
delete ppFlare1;
delete ppFlare2;
delete ppRenderer;
// Back to boring stuff
device->drop();
return 0;
}
extern "C" IRRLICHT_API IrrlichtDevice* IRRCALLCONV createDeviceEx(const SIrrlichtCreationParameters& params)
{
IrrlichtDevice* dev = 0;
#ifdef _IRR_COMPILE_WITH_WINDOWS_DEVICE_
if (params.DeviceType == EIDT_WIN32 || (!dev && params.DeviceType == EIDT_BEST))
dev = new CIrrDeviceWin32(params);
#endif
#ifdef _IRR_COMPILE_WITH_OSX_DEVICE_
if (params.DeviceType == EIDT_OSX || (!dev && params.DeviceType == EIDT_BEST))
dev = new CIrrDeviceMacOSX(params);
#endif
#ifdef _IRR_COMPILE_WITH_X11_DEVICE_
if (params.DeviceType == EIDT_X11 || (!dev && params.DeviceType == EIDT_BEST))
dev = new CIrrDeviceLinux(params);
#endif
#ifdef _IRR_COMPILE_WITH_IOS_DEVICE_
if (params.DeviceType == EIDT_IOS || (!dev && params.DeviceType == EIDT_BEST))
dev = new CIrrDeviceiOS(params);
#endif
#ifdef _IRR_COMPILE_WITH_ANDROID_DEVICE_
if (params.DeviceType == EIDT_ANDROID || (!dev && params.DeviceType == EIDT_BEST))
dev = new CIrrDeviceAndroid(params);
#endif
#ifdef _IRR_COMPILE_WITH_SDL_DEVICE_
if (params.DeviceType == EIDT_SDL || (!dev && params.DeviceType == EIDT_BEST))
dev = new CIrrDeviceSDL(params);
#endif
#ifdef _IRR_COMPILE_WITH_FB_DEVICE_
if (params.DeviceType == EIDT_FRAMEBUFFER || (!dev && params.DeviceType == EIDT_BEST))
dev = new CIrrDeviceFB(params);
#endif
#ifdef _IRR_COMPILE_WITH_CONSOLE_DEVICE_
if (params.DeviceType == EIDT_CONSOLE || (!dev && params.DeviceType == EIDT_BEST))
dev = new CIrrDeviceConsole(params);
#endif
if (dev && !dev->getVideoDriver() && params.DriverType != video::EDT_NULL)
{
dev->closeDevice(); // destroy window
dev->run(); // consume quit message
dev->drop();
dev = 0;
}
return dev;
}
static bool shadows(video::E_DRIVER_TYPE driverType)
{
IrrlichtDevice *device = createDevice (driverType, core::dimension2d<u32>(160,120), 16, false, true);
if (!device)
return true; // No error if device does not exist
stabilizeScreenBackground(device->getVideoDriver());
scene::ICameraSceneNode* cam = device->getSceneManager()->addCameraSceneNodeFPS();
cam->setPosition(core::vector3df(-15,55,10));
cam->setTarget(core::vector3df(-5,-5,-15));
device->getSceneManager()->setAmbientLight(video::SColorf(.5f,.5f,.5f));
scene::IMeshSceneNode* cube = device->getSceneManager()->addCubeSceneNode(100, 0, -1, core::vector3df(0,50,0));
cube->setScale(core::vector3df(-1,-1,-1));
scene::IAnimatedMeshSceneNode* node = device->getSceneManager()->addAnimatedMeshSceneNode(device->getSceneManager()->getMesh("../media/ninja.b3d"), 0, -1, core::vector3df(0,2,0), core::vector3df(),core::vector3df(5,5,5));
node->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
node->addShadowVolumeSceneNode();
node->setAnimationSpeed(0.f);
scene::ILightSceneNode* light = device->getSceneManager()->addLightSceneNode(0, core::vector3df(10,10,10));
light->setLightType(video::ELT_POINT);
light->setRadius(500.f);
light->getLightData().DiffuseColor.set(0,1,1);
device->getVideoDriver()->beginScene (true, true, 0);
device->getSceneManager()->drawAll();
device->getVideoDriver()->endScene();
bool result = takeScreenshotAndCompareAgainstReference(device->getVideoDriver(), "-stencilShadow.png", 99.91f);
node->remove();
cube->remove();
// test self-shadowing
node = device->getSceneManager()->addAnimatedMeshSceneNode(device->getSceneManager()->getMesh("../media/dwarf.x"));
node->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
node->addShadowVolumeSceneNode();
node->setAnimationSpeed(0.f);
cam->setPosition(core::vector3df(0,55,-30));
cam->setTarget(core::vector3df(60,45,150));
device->getVideoDriver()->beginScene (true, true, 0);
device->getSceneManager()->drawAll();
device->getVideoDriver()->endScene();
result = takeScreenshotAndCompareAgainstReference(device->getVideoDriver(), "-stencilSelfShadow.png", 99.41f);
device->closeDevice();
device->run();
device->drop();
return result;
}
int main()
{
//Start up the engine (OpenGL)
IrrlichtDevice *device = createDevice(video::EDT_OPENGL, core::dimension2d<s32>(640,480));
//Grab pointers to the driver and scenemanager
video::IVideoDriver* driver = device->getVideoDriver();
scene::ISceneManager* smgr = device->getSceneManager();
device->setWindowCaption(L"Random Direction Affector Demo");
//Setup the particle system scene node
scene::IParticleSystemSceneNode* ps = smgr->addParticleSystemSceneNode();
scene::IParticleEmitter* eaf = ps->createBoxEmitter(core::aabbox3df(-100,-1,-100,100,1,100),core::vector3df(0,-0.03,0),50,100,video::SColor(0,0,0,0),video::SColor(0,0,0,0),5000,5000);
ps->setEmitter(eaf);
eaf->drop();
//Add the Random Direction Affector
scene::IParticleAffector* aff = new scene::CRandomDirectionAffector(0.03,250);
ps->addAffector(aff);
aff->drop();
//Disable Lighting
ps->setMaterialFlag(video::EMF_LIGHTING,false);
// add a static camera
smgr->addCameraSceneNode(0,core::vector3df(0,0,-300),core::vector3df(0,0,0));
int lastFPS = -1;
// draw everything (should be self explanitory, otherwise check out the hello world tutorial)
while(device->run())
{
driver->beginScene(true, true, video::SColor(255,64,64,64));
smgr->drawAll();
driver->endScene();
int fps = driver->getFPS();
if (lastFPS != fps)
{
core::stringw str = L"Scale Affector Demo [";
str += driver->getName();
str += "] FPS:";
str += fps;
device->setWindowCaption(str.c_str());
lastFPS = fps;
}
}
// delete device
device->drop();
return 0;
}
// ----------------------------------------------------------------------------
bool Editor::init()
{
m_maps_path = NULL;
m_music_loc = NULL;
m_indicator = NULL;
m_valid_data_dir = false;
m_exe_loc = "";
m_toolbar = NULL;
m_toolbox = NULL;
m_rcs = NULL;
m_tex_sel = NULL;
m_indicator = NULL;
m_viewport = NULL;
m_rcs = NULL;
m_font = NULL;
m_new_dialog_wndw = NULL;
m_screen_size = dimension2du(10, 10);
IrrlichtDevice *nulldevice = createDevice(video::EDT_NULL);
m_screen_size = nulldevice->getVideoModeList()->getDesktopResolution();
readConfigFile(nulldevice->getFileSystem());
nulldevice->drop();
m_device = createDevice(EDT_OPENGL, m_screen_size, 16, false, false, true);
if (!m_device) return false;
m_device->setResizable(true);
m_device->setWindowCaption(L"SuperTuxKart Track Editor Beta v0.03");
if (m_screen_size.Width < 20 || m_screen_size.Height < 20)
m_device->maximizeWindow();
m_video_driver = m_device->getVideoDriver();
m_scene_manager = m_device->getSceneManager();
m_gui_env = m_device->getGUIEnvironment();
m_screen_size = m_video_driver->getScreenSize();
m_def_wd = m_device->getFileSystem()->getWorkingDirectory();
// lights
m_scene_manager->setAmbientLight(SColorf(0.3f, 0.3f, 0.3f, 1.0f));
ILightSceneNode* l = m_scene_manager->addLightSceneNode(0, vector3df(0, 1, 0),
SColorf(1.0f, 1.0f, 1.0f), 500, -1);
l->setLightType(ELT_DIRECTIONAL);
l->setPosition(vector3df(0,
1, 0));
m_device->setEventReceiver(this);
if (!isValidDataLoc()) dataDirLocDlg();
return true;
} // init
/** Verify that two skinned animated mesh scene nodes can use different frames of the skinned mesh */
bool b3dAnimation(void)
{
// Use EDT_BURNINGSVIDEO since it is not dependent on (e.g.) OpenGL driver versions.
IrrlichtDevice *device = createDevice( EDT_BURNINGSVIDEO, dimension2d<s32>(160, 120), 32);
assert(device);
if (!device)
return false;
IVideoDriver* driver = device->getVideoDriver();
ISceneManager * smgr = device->getSceneManager();
IAnimatedMesh* mesh = smgr->getMesh("../media/ninja.b3d");
IAnimatedMeshSceneNode* node1;
IAnimatedMeshSceneNode* node2;
assert(mesh);
bool result = false;
if(mesh)
{
node1 = smgr->addAnimatedMeshSceneNode(mesh);
assert(node1);
if(node1)
{
node1->setPosition(vector3df(-3, -3, 10));
node1->setMaterialFlag(EMF_LIGHTING, false);
node1->setAnimationSpeed(0.f);
}
node2 = smgr->addAnimatedMeshSceneNode(mesh);
assert(node2);
if(node2)
{
node2->setPosition(vector3df(3, -3, 10));
node2->setMaterialFlag(EMF_LIGHTING, false);
node2->setAnimationSpeed(0.f);
node2->setCurrentFrame(62.f);
}
(void)smgr->addCameraSceneNode();
// Just jump to the last frame since that's all we're interested in.
device->run();
driver->beginScene(true, true, SColor(255, 255, 255, 0));
smgr->drawAll();
driver->endScene();
result = takeScreenshotAndCompareAgainstReference(driver, "-b3dAnimation.png");
}
device->drop();
return result;
}
bool ClientLauncher::print_video_modes()
{
IrrlichtDevice *nulldevice;
bool vsync = g_settings->getBool("vsync");
u16 fsaa = g_settings->getU16("fsaa");
MyEventReceiver* receiver = new MyEventReceiver();
SIrrlichtCreationParameters params = SIrrlichtCreationParameters();
params.DriverType = video::EDT_NULL;
params.WindowSize = core::dimension2d<u32>(640, 480);
params.Bits = 24;
params.AntiAlias = fsaa;
params.Fullscreen = false;
params.Stencilbuffer = false;
params.Vsync = vsync;
params.EventReceiver = receiver;
params.HighPrecisionFPU = g_settings->getBool("high_precision_fpu");
nulldevice = createDeviceEx(params);
if (nulldevice == NULL) {
delete receiver;
return false;
}
dstream << _("Available video modes (WxHxD):") << std::endl;
video::IVideoModeList *videomode_list = nulldevice->getVideoModeList();
if (videomode_list != NULL) {
s32 videomode_count = videomode_list->getVideoModeCount();
core::dimension2d<u32> videomode_res;
s32 videomode_depth;
for (s32 i = 0; i < videomode_count; ++i) {
videomode_res = videomode_list->getVideoModeResolution(i);
videomode_depth = videomode_list->getVideoModeDepth(i);
dstream << videomode_res.Width << "x" << videomode_res.Height
<< "x" << videomode_depth << std::endl;
}
dstream << _("Active video mode (WxHxD):") << std::endl;
videomode_res = videomode_list->getDesktopResolution();
videomode_depth = videomode_list->getDesktopDepth();
dstream << videomode_res.Width << "x" << videomode_res.Height
<< "x" << videomode_depth << std::endl;
}
nulldevice->drop();
delete receiver;
return videomode_list != NULL;
}
// this test draws alternating white and black borders with
// increasing thickness. Intended use of this test is to ensure
// the corect pixel alignment within the render window.
static bool pixelAccuracy(E_DRIVER_TYPE driverType)
{
IrrlichtDevice *device = createDevice( driverType, dimension2d<u32>(160, 120), 32);
if (!device)
return true; // Treat a failure to create a driver as benign; this saves a lot of #ifdefs
IVideoDriver* driver = device->getVideoDriver();
stabilizeScreenBackground(driver);
logTestString("Testing driver %ls\n", driver->getName());
device->getSceneManager()->addCameraSceneNode();
driver->beginScene(video::ECBF_COLOR | video::ECBF_DEPTH, SColor(255,100,101,140));
u32 start=0;
for (u32 count=1; count<10; ++count)
{
for (u32 j=0; j<count; ++j)
{
for (u32 x=0; x<100-start; ++x)
{
driver->drawPixel(start+x, start, (count%2==1)?0xffffffff:0xff000000);
}
++start;
}
}
start=0;
for (u32 count=1; count<10; ++count)
{
for (u32 j=0; j<count; ++j)
{
for (u32 x=0; x<100-start; ++x)
{
driver->drawPixel(start, start+x, (count%2==1)?0xffffffff:0xff000000);
}
++start;
}
}
for (u32 x=0; x<100; ++x)
{
driver->drawPixel(x, x, 0xffff0000);
}
driver->endScene();
bool result = takeScreenshotAndCompareAgainstReference(driver, "-pixelAccuracy.png");
device->closeDevice();
device->run();
device->drop();
return result;
}
int main( ) {
// Boring stuff: set up the scene, object & camera as usual
IrrlichtDevice* device = createDevice( DRIVER, dimension2d<s32>( 640, 480 ), 16, false, false, false, 0 );
IVideoDriver* driver = device->getVideoDriver( );
ISceneManager* smgr = device->getSceneManager( );
IGUIEnvironment* guienv = device->getGUIEnvironment( );
device->getFileSystem( )->changeWorkingDirectoryTo( MEDIA_DIRECTORY );
guienv->addStaticText( L"Multiple Renders", rect<s32>( 10, 10, 260, 22 ), true );
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( smgr->getMesh( "sydney.md2" ) );
node->setMaterialFlag( EMF_LIGHTING, false );
node->setMD2Animation( scene::EMAT_STAND );
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
smgr->addCameraSceneNode( 0, vector3df( 40.0f, 30.0f, -40.0f ), vector3df( 0.0f, 5.0f, 0.0f ) );
// Interesting stuff
// This time, we make 2 renderers for the same scene
IPostProc* ppRenderer1 = new CRendererPostProc( smgr, dimension2di( 1024, 512 ), true, true, SColor( 255u, 100u, 101u, 140u ) );
IPostProc* ppRenderer2 = new CRendererPostProc( smgr, dimension2di( 1024, 512 ), true, true, SColor( 255u, 100u, 101u, 140u ) );
CEffectPostProc* ppBlur = new CEffectPostProc( ppRenderer2, dimension2di( 1024, 512 ), PP_BLUR, 0.005f );
CEffectPostProc* ppOverlay = new CEffectPostProc( ppRenderer1, dimension2di( 1024, 512 ), PP_OVERLAY, 1.0f );
ppOverlay->setInput( 1, ppBlur );
// These variables aren't important - they are just for showing the FPS
wchar_t tmp[255]; u8 t = 0u;
while( device->run( ) ) {
driver->beginScene( false, driver->getDriverType( ) == video::EDT_DIRECT3D9 );
// Because we want to have each scene render differently, we need to render them manually between changes:
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
ppRenderer1->preRender( ); // Note: preRender not render, and no NULL
node->setMaterialTexture( 0, driver->getTexture("fireball.bmp") );
// We could call ppRender2->preRender() here, but it isn't necessary since the overlay will do that for us anyway
ppOverlay->render( NULL );
guienv->drawAll( );
driver->endScene( );
// Show the current FPS
if( ++ t == 30u ) { t = 0u; swprintf(tmp, 255, L"%ls fps:%3d", driver->getName(), driver->getFPS() ); device->setWindowCaption( tmp ); }
}
delete ppOverlay;
delete ppBlur;
delete ppRenderer1;
delete ppRenderer2;
// Back to boring stuff
device->drop();
return 0;
}
int main( ) {
// Boring stuff: set up the scene, object & camera as usual
IrrlichtDevice* device = createDevice( DRIVER, dimension2d<s32>( 640, 480 ), 16, false, false, false, 0 );
IVideoDriver* driver = device->getVideoDriver( );
ISceneManager* smgr = device->getSceneManager( );
IGUIEnvironment* guienv = device->getGUIEnvironment( );
device->getFileSystem( )->changeWorkingDirectoryTo( MEDIA_DIRECTORY );
guienv->addStaticText( L"Custom Effect (Old Monitor)", rect<s32>( 10, 10, 260, 22 ), true );
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( smgr->getMesh( "sydney.md2" ) );
node->setMaterialFlag( EMF_LIGHTING, false );
node->setMD2Animation( scene::EMAT_STAND );
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
smgr->addCameraSceneNode( 0, vector3df( 40.0f, 30.0f, -40.0f ), vector3df( 0.0f, 5.0f, 0.0f ) );
// Interesting stuff
IPostProc* ppRenderer = new CRendererPostProc( smgr, dimension2di( 1024, 512 ), true, true, SColor( 255u, 100u, 101u, 140u ) );
CEffectPostProc* ppMine = new CEffectPostProc( ppRenderer, dimension2di( 1024, 512 ), GL_OLDMONITOR, DX_OLDMONITOR, EPST_PS_1_2, EPST_PS_2_0, EMT_SOLID, PPF_FROMCODE, 1.0f );
// Notes:
// EPST_PS_1_2 shows the minimum version required to run your shader - usually EPST_PS_1_1 for simple things
// EMT_SOLID can be changed to EMT_TRANSPARENT_ALPHA_CHANNEL, EMT_TRANSPARENT_ALPHA_CHANNEL_REF, etc. If this is done, the first texture is copied to the screen, then the second drawn on top using your shader. This is much faster than using 2 dynamic textures in one shader (not sure why) so use it when you can if you have 2 inputs
// 1.0f is where your parameters go
// Remember to use setTimer if your effect uses the time variable:
ppMine->setTimer( device->getTimer( ) );
// I hate this next line, but it needs to be set correctly to prevent MAJOR slowdown in Irrlicht when running in Direct3D mode.
// (if not called, your shader will have all parameters set to 0. If called with values too high, your app will slow significantly)
// Note: this is ONLY needed with custom shaders
ppMine->setRequiredVariables( 1, true, true ); // (number of input parameters, uses time?, uses randNum?)
// These variables aren't important - they are just for showing the FPS
wchar_t tmp[255]; u8 t = 0u;
while( device->run( ) ) {
// The monitor effect needs to know how strong it should be
ppMine->setParameters( min_( 1.0f, device->getTimer( )->getTime( ) * 0.0002f ) );
driver->beginScene( false, driver->getDriverType( ) == video::EDT_DIRECT3D9 );
ppMine->render( NULL );
guienv->drawAll( );
driver->endScene( );
// Show the current FPS
if( ++ t == 30u ) { t = 0u; swprintf(tmp, 255, L"%ls fps:%3d", driver->getName(), driver->getFPS() ); device->setWindowCaption( tmp ); }
}
delete ppMine;
delete ppRenderer;
// Back to boring stuff
device->drop();
return 0;
}
int main( ) {
// Boring stuff: set up the scene, object & camera as usual
IrrlichtDevice* device = createDevice( DRIVER, dimension2d<s32>( 640, 480 ), 16, false, false, false, 0 );
IVideoDriver* driver = device->getVideoDriver( );
ISceneManager* smgr = device->getSceneManager( );
IGUIEnvironment* guienv = device->getGUIEnvironment( );
device->getFileSystem( )->changeWorkingDirectoryTo( MEDIA_DIRECTORY );
guienv->addStaticText( L"Mixing Scenes", rect<s32>( 10, 10, 260, 22 ), true );
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( smgr->getMesh( "sydney.md2" ) );
node->setMaterialFlag( EMF_LIGHTING, false );
node->setMD2Animation( scene::EMAT_STAND );
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
smgr->addCameraSceneNode( 0, vector3df( 40.0f, 30.0f, -40.0f ), vector3df( 0.0f, 5.0f, 0.0f ) );
// Set up the second scene, object & camera - this time, use a different texture and camera angle to show some change
ISceneManager* smgr2 = smgr->createNewSceneManager( false );
ISceneNode* rootnode2 = smgr2->getRootSceneNode( );
IAnimatedMeshSceneNode* node2 = smgr2->addAnimatedMeshSceneNode( smgr2->getMesh( "sydney.md2" ), rootnode2 );
node2->setMaterialFlag( EMF_LIGHTING, false );
node2->setMD2Animation( scene::EMAT_STAND );
node2->setMaterialTexture( 0, driver->getTexture("fireball.bmp") );
smgr2->addCameraSceneNode( 0, vector3df( 40.0f, 30.0f, -40.0f ), vector3df( 10.0f, 5.0f, 0.0f ) );
// Interesting stuff (see previous example for full details)
IPostProc* ppRenderer1 = new CRendererPostProc( smgr, dimension2di( 1024, 512 ), true, true, SColor( 255u, 100u, 101u, 140u ) );
IPostProc* ppRenderer2 = new CRendererPostProc( smgr2, dimension2di( 1024, 512 ), true, true, SColor( 255u, 0u, 0u, 0u ) );
// PP_OVERLAY takes a multiplication parameter - setting this to 1.0 does a simple add, 2.0 doubles the second texture's luminosity, etc.
CEffectPostProc* ppOverlay = new CEffectPostProc( ppRenderer1, dimension2di( 1024, 512 ), PP_OVERLAY, 2.0f );
// The constructor can only take 1 input, but PP_OVERLAY needs 2, so set the other one now;
ppOverlay->setInput( 1, ppRenderer2 );
// These variables aren't important - they are just for showing the FPS
wchar_t tmp[255]; u8 t = 0u;
while( device->run( ) ) {
driver->beginScene( false, driver->getDriverType( ) == video::EDT_DIRECT3D9 );
// We only need to tell the final node to render - it will automatically render both scenes
ppOverlay->render( NULL );
guienv->drawAll( );
driver->endScene( );
// Show the current FPS
if( ++ t == 30u ) { t = 0u; swprintf(tmp, 255, L"%ls fps:%3d", driver->getName(), driver->getFPS() ); device->setWindowCaption( tmp ); }
}
delete ppRenderer1;
delete ppRenderer2;
delete ppOverlay;
// Back to boring stuff
device->drop();
return 0;
}
/** Tests for XML handling */
bool testXML(void)
{
IrrlichtDevice *device = createDevice(video::EDT_NULL, dimension2du(400, 200));
bool result = true;
result &= simple_xml(device->getFileSystem());
result &= cdata(device->getFileSystem());
result &= attributeValues(device->getFileSystem());
device->drop();
return result;
}
int main( ) {
// Boring stuff: set up the scene, object & camera as usual
IrrlichtDevice* device = createDevice( DRIVER, dimension2d<s32>( 640, 480 ), 16, false, false, false, 0 );
IVideoDriver* driver = device->getVideoDriver( );
ISceneManager* smgr = device->getSceneManager( );
IGUIEnvironment* guienv = device->getGUIEnvironment( );
device->getFileSystem( )->changeWorkingDirectoryTo( MEDIA_DIRECTORY );
guienv->addStaticText( L"Transitions", rect<s32>( 10, 10, 260, 22 ), true );
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( smgr->getMesh( "sydney.md2" ) );
node->setMaterialFlag( EMF_LIGHTING, false );
node->setMD2Animation( scene::EMAT_STAND );
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
smgr->addCameraSceneNode( 0, vector3df( 40.0f, 30.0f, -40.0f ), vector3df( 0.0f, 5.0f, 0.0f ) );
// Set up the second scene, object & camera - this time, use a different texture and camera angle to show some change
ISceneManager* smgr2 = smgr->createNewSceneManager( false );
ISceneNode* rootnode2 = smgr2->getRootSceneNode( );
IAnimatedMeshSceneNode* node2 = smgr2->addAnimatedMeshSceneNode( smgr2->getMesh( "sydney.md2" ), rootnode2 );
node2->setMaterialFlag( EMF_LIGHTING, false );
node2->setMD2Animation( scene::EMAT_STAND );
node2->setMaterialTexture( 0, driver->getTexture("fireball.bmp") );
smgr2->addCameraSceneNode( 0, vector3df( 40.0f, 30.0f, -40.0f ), vector3df( 10.0f, 5.0f, 0.0f ) );
// Interesting stuff
IPostProc* ppRenderer1 = new CRendererPostProc( smgr, dimension2di( 1024, 512 ), true, true, SColor( 255u, 100u, 101u, 140u ) );
IPostProc* ppRenderer2 = new CRendererPostProc( smgr2, dimension2di( 1024, 512 ), true, true, SColor( 255u, 0u, 0u, 0u ) );
CTransitionPostProc* ppTransition = new CTransitionPostProc( ppRenderer1, ppRenderer2, dimension2di( 1024, 512 ), driver->getTexture("terrain-heightmap.bmp") );
// ppTransition->setQuality( PPQ_CRUDE );
// These variables aren't important - they are just for showing the FPS
wchar_t tmp[255]; u8 t = 0u;
while( device->run( ) ) {
ppTransition->setBlend( sinf( device->getTimer( )->getTime( ) * 0.0005f - 2.0f ) * 2.0f + 0.5f );
driver->beginScene( false, driver->getDriverType( ) == video::EDT_DIRECT3D9 );
ppTransition->render( NULL );
guienv->drawAll( );
driver->endScene( );
// Show the current FPS
if( ++ t == 30u ) { t = 0u; swprintf(tmp, 255, L"%ls fps:%3d", driver->getName(), driver->getFPS() ); device->setWindowCaption( tmp ); }
}
delete ppTransition;
delete ppRenderer1;
delete ppRenderer2;
// Back to boring stuff
device->drop();
return 0;
}
void init_irrlicht(bool32 fullscreen)
{
irrlicht->device = 0;
irrlicht->driver = 0;
irrlicht->smgr = 0;
irrlicht->hud = 0;
irrlicht->stencil_buffer = false;
if (fullscreen)
{
// create a NULL device to detect screen resolution
IrrlichtDevice *nulldevice = createDevice(EDT_NULL);
dimension2d<u32> deskres = nulldevice->getVideoModeList()->getDesktopResolution();
nulldevice->drop();
irrlicht->device = createDevice( EDT_OPENGL, deskres, 32, true, irrlicht->stencil_buffer, true );
}
else
{
//device = createDevice( EDT_OPENGL, dimension2d<u32>(1280, 720), 32, false, stencil_buffer, false);
irrlicht->device = createDevice( EDT_OPENGL, dimension2d<u32>(SCREEN_WIDTH, SCREEN_HEIGHT), 32, false, irrlicht->stencil_buffer, false);
}
if (!irrlicht->device)
{
std::cout << "ERROR: Failed to create Irrlicht device." << std::endl;
return;
}
irrlicht->device->setWindowCaption(L"Secret");
irrlicht->driver = irrlicht->device->getVideoDriver();
if (!irrlicht->driver)
{
std::cout << "ERROR: Failed to create Irrlicht driver." << std::endl;
return;
}
irrlicht->smgr = irrlicht->device->getSceneManager();
if (!irrlicht->smgr)
{
std::cout << "ERROR: Failed to create Irrlicht smgr." << std::endl;
return;
}
irrlicht->hud = irrlicht->smgr->createNewSceneManager();
if (!irrlicht->hud)
{
std::cout << "ERROR: Failed to create Irrlicht hud." << std::endl;
return;
}
irrlicht->colmgr = irrlicht->smgr->getSceneCollisionManager();
}
int main( ) {
// Boring stuff: set up the scene, object & camera as usual
IrrlichtDevice* device = createDevice( DRIVER, dimension2d<s32>( 640, 480 ), 16, false, false, false, 0 );
IVideoDriver* driver = device->getVideoDriver( );
ISceneManager* smgr = device->getSceneManager( );
IGUIEnvironment* guienv = device->getGUIEnvironment( );
device->getFileSystem( )->changeWorkingDirectoryTo( MEDIA_DIRECTORY );
guienv->addStaticText( L"Single Effect", rect<s32>( 10, 10, 260, 22 ), true );
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( smgr->getMesh( "sydney.md2" ) );
node->setMaterialFlag( EMF_LIGHTING, false );
node->setMD2Animation( scene::EMAT_STAND );
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
smgr->addCameraSceneNode( 0, vector3df( 40.0f, 30.0f, -40.0f ), vector3df( 0.0f, 5.0f, 0.0f ) );
// Interesting stuff
// We make 2 objects - a scene renderer, and a blur. both render to textures with size 1024x512 (always use powers of 2)
// When setting up the renderer, the parameters are:
// SceneManager to render, size of output, clearBackBuffer?, clearZBuffer?, background colour
IPostProc* ppRenderer = new CRendererPostProc( smgr, dimension2di( 1024, 512 ), true, true, SColor( 255u, 100u, 101u, 140u ) );
// When setting up the effect, the parameters are:
// Input, size of output, effect ID (see CEffectPostProc.h for full list), effect parameters (in this case, blur size)
CEffectPostProc* ppBlur = new CEffectPostProc( ppRenderer, dimension2di( 1024, 512 ), PP_BLUR, 0.01f );
// Change to a better quality - not all shaders will respect these, but they can be used to hint the rendering standard required.
ppBlur->setQuality( PPQ_GOOD );
// Options (worst to best): PPQ_CRUDE, PPQ_FAST, PPQ_DEFAULT, PPQ_GOOD, PPQ_BEST
// You can also call setOverallQuality( PPQ_WHATEVER ) to change the quality of all effects which are in the chain.
// These variables aren't important - they are just for showing the FPS
wchar_t tmp[255]; u8 t = 0u;
while( device->run( ) ) {
// What's happened to beginScene? well we want to use beginScene( false, false ) for speed, but this makes Irrlicht complain (wrongly) when using Direct3D9, so use ( false, true ) in that case.
driver->beginScene( false, driver->getDriverType( ) == video::EDT_DIRECT3D9 );
// The rendering is as normal, except smgr->drawAll(); is replaced with this line:
ppBlur->render( NULL ); // NULL = render to screen. Can also take a texture to render to, or no parameter (renders to an internal texture)
guienv->drawAll( );
driver->endScene( );
// Show the current FPS
if( ++ t == 30u ) { t = 0u; swprintf(tmp, 255, L"%ls fps:%3d", driver->getName(), driver->getFPS() ); device->setWindowCaption( tmp ); }
}
delete ppBlur;
delete ppRenderer;
// Back to boring stuff
device->drop();
return 0;
}
int main( ) {
// Boring stuff: set up the scene, object & camera as usual
IrrlichtDevice* device = createDevice( DRIVER, dimension2d<s32>( 640, 480 ), 16, false, false, false, 0 );
IVideoDriver* driver = device->getVideoDriver( );
ISceneManager* smgr = device->getSceneManager( );
IGUIEnvironment* guienv = device->getGUIEnvironment( );
device->getFileSystem( )->changeWorkingDirectoryTo( MEDIA_DIRECTORY );
guienv->addStaticText( L"Splitscreen", rect<s32>( 10, 10, 260, 22 ), true );
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( smgr->getMesh( "sydney.md2" ) );
node->setMaterialFlag( EMF_LIGHTING, false );
node->setMD2Animation( scene::EMAT_STAND );
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
smgr->addCameraSceneNode( 0, vector3df( 40.0f, 30.0f, -40.0f ), vector3df( 0.0f, 5.0f, 0.0f ) );
// Set up the second scene, object & camera - this time, use a different texture and camera angle to show some change
ISceneManager* smgr2 = smgr->createNewSceneManager( false );
ISceneNode* rootnode2 = smgr2->getRootSceneNode( );
IAnimatedMeshSceneNode* node2 = smgr2->addAnimatedMeshSceneNode( smgr2->getMesh( "sydney.md2" ), rootnode2 );
node2->setMaterialFlag( EMF_LIGHTING, false );
node2->setMD2Animation( scene::EMAT_STAND );
node2->setMaterialTexture( 0, driver->getTexture("fireball.bmp") );
smgr2->addCameraSceneNode( 0, vector3df( 40.0f, 30.0f, -40.0f ), vector3df( 10.0f, 5.0f, 0.0f ) );
// Interesting stuff
IPostProc* ppRenderer1 = new CRendererPostProc( smgr, dimension2di( 1024, 512 ), true, true, SColor( 255u, 100u, 101u, 140u ) );
IPostProc* ppRenderer2 = new CRendererPostProc( smgr2, dimension2di( 1024, 512 ), true, true, SColor( 255u, 0u, 0u, 0u ) );
// Splitscreen objects can be given up to 4 views. The rects at the end are optional - if not given, an arrangement will be created to fit the given number of views
CSplitPostProc* ppSplit = new CSplitPostProc( ppRenderer1, ppRenderer2, dimension2di( 1024, 512 ), rect<f32>( -0.5f, -1.0f, 0.5f, 0.0f ), rect<f32>( -0.7f, 0.0f, 0.3f, 1.0f ) );
ppSplit->setVoidColor( SColor( 255u, 128u, 128u, 128u ) ); // Change the colour shown where there are no views. Call setVoidColor() to use no color (slightly faster, but should only be used if the views entirely cover the screen)
// These variables aren't important - they are just for showing the FPS
wchar_t tmp[255]; u8 t = 0u;
while( device->run( ) ) {
driver->beginScene( false, driver->getDriverType( ) == video::EDT_DIRECT3D9 );
ppSplit->render( NULL );
guienv->drawAll( );
driver->endScene( );
// Show the current FPS
if( ++ t == 30u ) { t = 0u; swprintf(tmp, 255, L"%ls fps:%3d", driver->getName(), driver->getFPS() ); device->setWindowCaption( tmp ); }
}
delete ppRenderer1;
delete ppSplit;
delete ppRenderer2;
// Back to boring stuff
device->drop();
return 0;
}
static bool loadScene(void)
{
IrrlichtDevice *device = createDevice(video::EDT_BURNINGSVIDEO,
core::dimension2du(160,120), 32);
if (!device)
return false;
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
// load scene from example, with correct relative path
device->getFileSystem()->changeWorkingDirectoryTo("results");
smgr->loadScene("../../media/example.irr");
smgr->addCameraSceneNode(0, core::vector3df(0,0,-50));
device->getFileSystem()->changeWorkingDirectoryTo("..");
bool result = false;
device->run();
device->getTimer()->setTime(666); // scene has animations and current scene seems to be saved at that time ... really - best result with just that number :-)
if (driver->beginScene(true, true, video::SColor(0, 80, 80, 80)))
{
smgr->drawAll();
driver->endScene();
// we need to be very sloppy, because the animators will produce a different
// start depending on the actual loading time. 97% seems to be safe, as removing
// an object produces values around 95%
result = takeScreenshotAndCompareAgainstReference(driver, "-loadScene.png", 97.4f);
if (!result)
logTestString("Rendering the loaded scene failed.\n");
}
ISceneNode* node = smgr->getSceneNodeFromId(128);
if (!node)
result=false;
else if (result) // only check if scene was correctly loaded
{
result &= (node->getChildren().size()==0);
if (!result)
logTestString("Node has an illegal child node.\n");
device->getSceneManager()->loadScene("results/scene2.irr", 0, node);
result &= (node->getChildren().size()!=0);
if (!result)
logTestString("Loading second scene as child failed.\n");
}
device->closeDevice();
device->run();
device->drop();
return result;
}
int main(void)
{
IrrlichtDevice *device = createDevice(video::EDT_OPENGL);
video::IVideoDriver *driver = device->getVideoDriver();
while(device->run())
{
driver->beginScene(true, true, video::SColor(0,255,255,255));
driver->endScene();
}
device->drop();
return 0;
}
/** Test the behaviour of makeColorKeyTexture() using both 16 bit (software)
and 32 bit (Burning) textures, with the new behaviour and the legacy
behaviour. */
static bool doTestWith(E_DRIVER_TYPE driverType,
bool zeroTexels)
{
IrrlichtDevice *device = createDevice( driverType,
dimension2d<u32>(160, 120), 32);
if (!device)
return false;
IVideoDriver* driver = device->getVideoDriver();
ISceneManager * smgr = device->getSceneManager();
// Draw a cube background so that we can check that the keying is working.
ISceneNode * cube = smgr->addCubeSceneNode(50.f, 0, -1, vector3df(0, 0, 60));
cube->setMaterialTexture(0, driver->getTexture("../media/wall.bmp"));
cube->setMaterialFlag(video::EMF_LIGHTING, false);
ITexture * Texture = device->getVideoDriver()->getTexture("../media/portal2.bmp");
device->getVideoDriver()->makeColorKeyTexture(Texture,
position2d<s32>(64,64),
zeroTexels);
device->getVideoDriver()->makeColorKeyTexture(Texture,
position2d<s32>(64,64),
zeroTexels);
(void)smgr->addCameraSceneNode();
driver->beginScene(video::ECBF_COLOR | video::ECBF_DEPTH, SColor(255,100,101,140));
smgr->drawAll();
driver->draw2DImage(Texture,
position2di(40, 40),
rect<s32>(0, 0, Texture->getSize().Width, Texture->getSize().Height),
0,
SColor(255,255,255,255),
true);
driver->endScene();
char screenshotName[256];
(void)snprintf_irr(screenshotName, 256, "-makeColorKeyTexture-%s.png",
zeroTexels? "old" : "new");
bool result = takeScreenshotAndCompareAgainstReference(driver, screenshotName);
device->closeDevice();
device->run();
device->drop();
return result;
}
int main()
{
IrrlichtDevice *device =
createDevice( video::EDT_BURNINGSVIDEO, dimension2d<u32>(640, 480), 16,
false, false, false, 0);
if (!device) return 1;
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
IGUIEnvironment* guienv = device->getGUIEnvironment();
// Add Light to the Scene
ILightSceneNode *light = smgr->addLightSceneNode( 0, vector3df() );
light->getLightData().AmbientColor = SColorf( 0.2f, 0.2f, 0.2f );
light->getLightData().SpecularColor = SColorf( 1.0f, 1.0f, 1.0f );
light->getLightData().DiffuseColor = SColorf( 0.8f, 0.8f, 0.8f );
light->setLightType( ELT_DIRECTIONAL );
light->setRotation( vector3df( 45.0f, 45.0f, 0.0f ));
smgr->setAmbientLight( SColorf( 0.2f, 0.2f, 0.2f ));
// scene::IMeshSceneNode* node = smgr->addCubeSceneNode(20);
// if (node){
// node->setMaterialFlag(EMF_LIGHTING, false);
// smgr->getMeshManipulator()->setVertexColors(node->getMesh(),SColor(250,250,0,0));
// node->setPosition(core::vector3df(0,0,0) );
// node->setVisible(false);
// }
smgr->addCameraSceneNode(0, vector3df(0,0,-50), vector3df(0,0,0));
while(device->run())
{
core::aabbox3df box;
box.MinEdge.set(vector3df(-100,-100,-100));
box.MaxEdge.set(vector3df(100,100,100));
driver->beginScene(true, true, SColor(250, 100, 150, 150));
smgr->drawAll();
guienv->drawAll();
criaGizmosBicos(driver);
// criaRegiaAnalise(box, driver);
driver->endScene();
}
device->drop();
return 0;
}
int main(int argc, char* argv[]) {
// Create a basic device with EDT_SOFTWARE drivers this is simply
// supposed to show off node_packet transmission not anything graphical.
IrrlichtDevice *device = createDevice(video::EDT_SOFTWARE,
core::dimension2d<u32>(640, 480));
// Set up video driver.
video::IVideoDriver* driver = device->getVideoDriver();
// Set up scene manager.
scene::ISceneManager* smgr = device->getSceneManager();
// Initialize the camera
scene::ICameraSceneNode* camera = smgr->addCameraSceneNodeFPS();
// Create the network manager
net::NetworkManager netmgr = net::NetworkManager::master("255.255.255.255", 4444);
// Create the camera packet
net::CameraPacket cameraPacket(camera);
// Run the main game loop.
while (device->run()) {
// If the window is active then render
if (device->isWindowActive()) {
// Start the scene
driver->beginScene(true, true, video::SColor(255,200, 200, 200));
// Draw everything in the scene
smgr->drawAll();
// Serialise the camera packet data.
net::NetworkType data = cameraPacket.serialize();
// Send the camera packet data.
netmgr.sendData(data);
// End the scene
driver->endScene();
// If the window is not active then yield the device till it is active.
} else {
device->yield();
}
}
device->drop();
return EXIT_SUCCESS;
}
/** Tests the offset capability of the fly circle animator */
bool flyCircleAnimator(void)
{
IrrlichtDevice *device = createDevice(video::EDT_BURNINGSVIDEO,
core::dimension2du(160,120), 32);
if (!device)
return false;
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
const f32 offsetDegrees[] = { 0.f, 45.f, 135.f, 270.f };
for(u32 i = 0; i < sizeof(offsetDegrees) / sizeof(offsetDegrees[0]); ++i)
{
IBillboardSceneNode * node = smgr->addBillboardSceneNode();
// Have the animator rotate around the Z axis plane, rather than the default Y axis
ISceneNodeAnimator * animator = smgr->createFlyCircleAnimator(
vector3df(0, 0, 0), 30.f, 0.001f,
vector3df(0, 0, 1), (offsetDegrees[i] / 360.f));
if(!node || !animator)
return false;
node->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR );
node->setMaterialTexture(0, driver->getTexture("../media/particle.bmp"));
node->setMaterialFlag(video::EMF_LIGHTING, false);
node->addAnimator(animator);
animator->drop();
}
(void)smgr->addCameraSceneNode(0, vector3df(0, 0, -50), vector3df(0, 0, 0));
bool result = false;
// Don't do device->run() since I need the time to remain at 0.
if (driver->beginScene(true, true, video::SColor(0, 80, 80, 80)))
{
smgr->drawAll();
driver->endScene();
result = takeScreenshotAndCompareAgainstReference(driver, "-flyCircleAnimator.png", 100);
}
device->closeDevice();
device->run();
device->drop();
return result;
}
int example_helloworld()
{
// create device
IrrlichtDevice *device = startup();
if (device == 0)
return 1; // could not create selected driver.
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
IGUIEnvironment* guienv = device->getGUIEnvironment();
IAnimatedMesh* mesh = smgr->getMesh("../../media/sydney.md2");
if (!mesh)
{
device->drop();
return 1;
}
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh );
/*
To let the mesh look a little bit nicer, we change its material. We
disable lighting because we do not have a dynamic light in here, and
the mesh would be totally black otherwise. Then we set the frame loop,
such that the predefined STAND animation is used. And last, we apply a
texture to the mesh. Without it the mesh would be drawn using only a
color.
*/
if (node)
{
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMD2Animation(scene::EMAT_STAND);
node->setMaterialTexture( 0, driver->getTexture("../../media/sydney.bmp") );
}
/*
To look at the mesh, we place a camera into 3d space at the position
(0, 30, -40). The camera looks from there to (0,5,0), which is
approximately the place where our md2 model is.
*/
smgr->addCameraSceneNode(0, vector3df(0,30,-40), vector3df(0,5,0));
EventReceiver_basic receiver(device);
device->setEventReceiver(&receiver);
return run ( device );
}
//! Tests the basic functionality of the software device.
bool softwareDevice(void)
{
IrrlichtDevice *device = createDevice(video::EDT_SOFTWARE, dimension2d<u32>(160, 120), 32);
if (!device)
return false;
video::IVideoDriver* driver = device->getVideoDriver();
ISceneManager * smgr = device->getSceneManager();
// Test a particular rotation that highlighted a clipping issue from matrix::transformPlane()
video::S3DVertex vertices[3];
vertices[0] = video::S3DVertex(10,0,-10, 1,0,0,
video::SColor(255,255,0,255), 1, 1);
vertices[1] = video::S3DVertex(0,20,0, 0,1,1,
video::SColor(255,255,255,0), 1, 0);
vertices[2] = video::S3DVertex(-10,0,-10, 0,0,1,
video::SColor(255,0,255,0), 0, 0);
video::SMaterial material;
material.Lighting = false;
material.Wireframe = false;
const u16 indices[] = { 1,0,2, };
matrix4 transform(matrix4::EM4CONST_IDENTITY);
vector3df rotations(290, 0, 290); // <-- This rotation used to clip the triangle incorrectly
transform.setRotationDegrees(rotations);
(void)smgr->addCameraSceneNode(0, core::vector3df(0,0,-40), core::vector3df(0,0,0));
driver->beginScene(video::ECBF_COLOR | video::ECBF_DEPTH, video::SColor(255,255,255,0));
smgr->drawAll();
driver->setMaterial(material);
driver->setTransform(video::ETS_WORLD, transform);
driver->drawIndexedTriangleList(&vertices[0], 3, &indices[0], 1);
driver->endScene();
bool result = takeScreenshotAndCompareAgainstReference(driver, "-softwareDevice-rotatedClip.png");
device->closeDevice();
device->run();
device->drop();
return result;
}
/** The result should be as follows: We have three times the same image, a billboard with a cube and the text in front.
They are replicated three times, one centered in the screen without viewport, one in the upper left (qurter screen) and
one on the right (half screen). The latter is stretched due to the changed aspect ratio.
The two viewport scenes get the texture drawn over the center as well, using draw2dimage. This should mark the proper
image position with the top left corner of the texture.
Finally, each scene has a checkbox drawn at the left side, vertically centered. This will show whether GUI elements adhere
to viewports as well. */
static bool viewPortText(E_DRIVER_TYPE driverType)
{
IrrlichtDevice *device = createDevice( driverType, dimension2d<u32>(160, 120), 32);
if (!device)
return true; // Treat a failure to create a driver as benign; this saves a lot of #ifdefs
IVideoDriver* driver = device->getVideoDriver();
ISceneManager * smgr = device->getSceneManager();
IGUIEnvironment* env = smgr->getGUIEnvironment();
stabilizeScreenBackground(driver);
env->addCheckBox(true, core::recti(10,60,28,82));
logTestString("Testing driver %ls\n", driver->getName());
IBillboardSceneNode * bnode = smgr->addBillboardSceneNode(0,dimension2d<f32>(32,32),core::vector3df(0,0,10));
bnode->setMaterialFlag(video::EMF_LIGHTING, false);
bnode->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
bnode->setMaterialTexture(0, driver->getTexture("../media/fire.bmp"));
smgr->addTextSceneNode(device->getGUIEnvironment()->getBuiltInFont(), L"TEST", video::SColor(255,255,255,255), 0);
smgr->addCubeSceneNode();
smgr->addCameraSceneNode(0, vector3df(0,30,-40), vector3df(0,5,0));
driver->beginScene(video::ECBF_COLOR | video::ECBF_DEPTH, SColor(255,100,101,140));
smgr->drawAll();
env->drawAll();
driver->setViewPort(rect<s32>(0,0,160/2,120/2));
smgr->drawAll();
env->drawAll();
driver->draw2DImage(driver->getTexture("../media/fire.bmp"), core::vector2di(160/2,120/2));
driver->setViewPort(rect<s32>(160/2,0,160,120));
smgr->drawAll();
env->drawAll();
driver->draw2DImage(driver->getTexture("../media/fire.bmp"), core::vector2di(160/2,120/2));
driver->endScene();
bool result = takeScreenshotAndCompareAgainstReference(driver, "-viewPortText.png", 98.71f);
device->closeDevice();
device->run();
device->drop();
return result;
}
/** At the moment, this just verifies that the last frame of the animation produces the expected bitmap. */
bool md2Animation(void)
{
// Use EDT_BURNINGSVIDEO since it is not dependent on (e.g.) OpenGL driver versions.
IrrlichtDevice *device = createDevice( EDT_BURNINGSVIDEO, dimension2d<u32>(160, 120), 32);
assert(device);
if (!device)
return false;
IVideoDriver* driver = device->getVideoDriver();
ISceneManager * smgr = device->getSceneManager();
IAnimatedMesh* mesh = smgr->getMesh("../media/sydney.md2");
IAnimatedMeshSceneNode* node;
assert(mesh);
if(mesh)
{
node = smgr->addAnimatedMeshSceneNode(mesh);
assert(node);
if(node)
{
node->setPosition(vector3df(20, 0, 30));
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMaterialTexture(0, driver->getTexture("../media/sydney.bmp"));
node->setLoopMode(false);
(void)smgr->addCameraSceneNode();
// Just jump to the last frame since that's all we're interested in.
node->setMD2Animation(EMAT_DEATH_FALLBACK);
node->setCurrentFrame((f32)(node->getEndFrame()));
device->run();
driver->beginScene(true, true, SColor(255, 255, 255, 0));
smgr->drawAll();
driver->endScene();
}
}
bool result = takeScreenshotAndCompareAgainstReference(driver, "-md2Animation.png");
device->drop();
return result;
}
int main( ) {
// Boring stuff: set up the scene, object & camera as usual
IrrlichtDevice* device = createDevice( DRIVER, dimension2d<s32>( 640, 480 ), 16, false, false, false, 0 );
IVideoDriver* driver = device->getVideoDriver( );
ISceneManager* smgr = device->getSceneManager( );
IGUIEnvironment* guienv = device->getGUIEnvironment( );
device->getFileSystem( )->changeWorkingDirectoryTo( MEDIA_DIRECTORY );
guienv->addStaticText( L"Combined Effects", rect<s32>( 10, 10, 260, 22 ), true );
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( smgr->getMesh( "sydney.md2" ) );
node->setMaterialFlag( EMF_LIGHTING, false );
node->setMD2Animation( scene::EMAT_STAND );
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
smgr->addCameraSceneNode( 0, vector3df( 40.0f, 30.0f, -40.0f ), vector3df( 0.0f, 5.0f, 0.0f ) );
// Interesting stuff (see previous example for full details)
IPostProc* ppRenderer = new CRendererPostProc( smgr, dimension2di( 1024, 512 ), true, true, SColor( 255u, 100u, 101u, 140u ) );
CEffectPostProc* ppInvert = new CEffectPostProc( ppRenderer, dimension2di( 1024, 512 ), PP_INVERT );
// The second effect is made exactly the same way, but takes ppInvert as the input instead of ppRenderer
CEffectPostProc* ppBlur = new CEffectPostProc( ppInvert, dimension2di( 1024, 512 ), PP_BLUR, 0.01f );
// delete ppInvert;
// These variables aren't important - they are just for showing the FPS
wchar_t tmp[255]; u8 t = 0u;
while( device->run( ) ) {
driver->beginScene( false, driver->getDriverType( ) == video::EDT_DIRECT3D9 );
ppBlur->render( NULL );
guienv->drawAll( );
driver->endScene( );
// Show the current FPS
if( ++ t == 30u ) { t = 0u; swprintf(tmp, 255, L"%ls fps:%3d", driver->getName(), driver->getFPS() ); device->setWindowCaption( tmp ); }
}
// The effects can be deleted in any order
delete ppBlur;
delete ppInvert;
delete ppRenderer;
// Back to boring stuff
device->drop();
return 0;
}
