SceneObject* PhysicsSim::loadSceneObject(stringw mesh_file, stringw texture_file)
{
IAnimatedMesh *mesh = smgr->getMesh(mediaDirectory + mesh_file);
IAnimatedMeshSceneNode* Node = smgr->addAnimatedMeshSceneNode(mesh, smgr->getRootSceneNode());
stringw tex_file = texture_file;
if(tex_file == L"")
{
tex_file = mesh_file;
if(tex_file.find(".dae") > -1)
tex_file.remove(".dae");
if(tex_file.find(".3ds") > -1)
tex_file.remove(".3ds");
tex_file.append(".jpg");
}
tex_file = mediaDirectory + tex_file;
if(smgr->getFileSystem()->existFile(tex_file))
Node->setMaterialTexture(0, driver->getTexture(tex_file));
Node->setMaterialFlag(EMF_LIGHTING, true);
Node->setMaterialFlag(EMF_TEXTURE_WRAP, false);
Node->setMaterialFlag(EMF_BACK_FACE_CULLING, true);
Node->addShadowVolumeSceneNode(0,-1,false);
Node->getMaterial(0).AmbientColor.set(255,255,255,255);
updateObjects();
return Node;
}
void CScene::UpdateScene(vector<vector3df> otherClientPosition, ICameraSceneNode* camera)
{
ISceneManager* smgr=device->getSceneManager();
IVideoDriver* driver=device->getVideoDriver();
// 测试用
IAnimatedMesh* personMeshTest=smgr->getMesh("../../media/sydney.md2");
IAnimatedMeshSceneNode* personNode = smgr->addAnimatedMeshSceneNode( personMeshTest );
if (!personMeshTest)
{
device->drop();
return ;
}
if (personNode)
{
personNode->setScale(vector3df(0.4f,0.4f,0.4f));
personNode->setPosition(vector3df(0.0f,10.0f,0.0f));
personNode->setMaterialTexture( 0, driver->getTexture("../../media/sydney.bmp") );
personNode->setMaterialFlag(EMF_LIGHTING, false);
personNode->getMaterial(0).Shininess=28.0f;
personNode->getMaterial(0).NormalizeNormals=true;
personNode->setMD2Animation ( scene::EMAT_STAND );
}
personMeshTest->setMaterialFlag(EMF_LIGHTING,false);
// 显示其他客户端
for (int i=0;i!=otherClientPosition.size();i++)
{
IAnimatedMesh* personMesh=smgr->getMesh("../../media/sydney.md2");
IAnimatedMeshSceneNode* personNode = smgr->addAnimatedMeshSceneNode( personMesh );
if (!personMesh)
{
device->drop();
return ;
}
if (personNode && personNode->getPosition()!=camera->getPosition())
{
// personNode->setPosition(vector3df(10,20,0));
// personNode->setScale(vector3df(0.5,0.5,0.5));
personNode->setPosition(otherClientPosition[i]);
personNode->setMaterialTexture( 0, driver->getTexture("../../media/sydney.bmp") );
personNode->setMaterialFlag(EMF_LIGHTING, false);
personNode->getMaterial(0).Shininess=28.0f;
personNode->getMaterial(0).NormalizeNormals=true;
personNode->setMD2Animation ( scene::EMAT_STAND );
}
personMesh->setMaterialFlag(EMF_LIGHTING,false);
}
}
int main()
{
IrrlichtDevice *device =
createDevice( video::EDT_OPENGL, dimension2d<u32>(800, 600));
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
smgr->addCameraSceneNode(0, vector3df(0,10,-10), vector3df(0,5,0));
IAnimatedMesh* mesh = smgr->getMesh("ninja.b3d");
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode(mesh);
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMaterialTexture( 0, driver->getTexture("nskinrd.jpg") );
node->setRotation(vector3df(0,180,0)); // let ninja be in front to us
node->setJointMode(EJUOR_CONTROL); // tell irrlicht that you want to control joint positions
IBoneSceneNode* bone = node->getJointNode("Joint10"); // create IBoneSceneNode and select the desired bone
while(device->run()) {
bone->setRotation(bone->getRotation() + vector3df(1,0,0)); // rotate bone
driver->beginScene();
smgr->drawAll();
driver->endScene();
}
device->drop();
return 0;
}
void TestLevel::init() {
IAnimatedMesh* mesh = smgr->getMesh("img/sydney.md2");
IAnimatedMeshSceneNode * tmpnode = smgr->addAnimatedMeshSceneNode(mesh);
if (tmpnode) {
tmpnode->setMaterialFlag(EMF_LIGHTING, false);
tmpnode->setMD2Animation(scene::EMAT_STAND);
tmpnode->setMaterialTexture(0, driver->getTexture("img/sydney.bmp"));
}
tmpnode->setPosition(vector3df(-222,0,0));
vector3df wsp(0,5,-10);
ship = new TestPlayerShip(TestPlayerShip::createTestPlayerShipNode(context));
ship->attachNewCamera(new StaticCamera(context,ship));
// ship.attachCamera(cam);
this->node = new NonPlayerShip(tmpnode);
testPlanet = Planet::createTestPlanet(context);
}
bool testTransparentVertexAlphaMore(E_DRIVER_TYPE driverType)
{
IrrlichtDevice *device = createDevice(driverType, dimension2d<u32>(160, 120));
if (!device)
return true;
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
if (driver->getColorFormat() != video::ECF_A8R8G8B8)
{
device->closeDevice();
device->run();
device->drop();
return true;
}
logTestString("Testing driver %ls\n", driver->getName());
IAnimatedMesh* mesh = smgr->getMesh("../media/sydney.md2");
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh );
IMeshSceneNode* cube = smgr->addCubeSceneNode(10.0f,0,-1,vector3df(-5,3,-15));
if (node)
{
node->setMaterialFlag(EMF_LIGHTING, false);
node->setFrameLoop(0, 310);
node->setMaterialTexture( 0, driver->getTexture("../media/sydney.bmp") );
}
if (cube)
{
cube->getMaterial(0).MaterialType = EMT_TRANSPARENT_VERTEX_ALPHA;
cube->setMaterialTexture(0, driver->getTexture("../media/wall.bmp"));
cube->setMaterialFlag(EMF_LIGHTING, false);
smgr->getMeshManipulator()->setVertexColorAlpha(cube->getMesh(),128);
}
// second cube without texture
cube = smgr->addCubeSceneNode(10.0f,0,-1,vector3df(5,3,-15));
if (cube)
{
cube->getMaterial(0).MaterialType = EMT_TRANSPARENT_VERTEX_ALPHA;
cube->setMaterialFlag(EMF_LIGHTING, false);
smgr->getMeshManipulator()->setVertexColorAlpha(cube->getMesh(),128);
}
smgr->addCameraSceneNode(0, vector3df(0,30,-40), vector3df(0,5,0));
driver->beginScene(true, true, SColor(0,200,200,200));
smgr->drawAll();
driver->endScene();
bool result = takeScreenshotAndCompareAgainstReference(driver, "-transparentVertexAlphaChannelMore.png", 99.18f);
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"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;
}
IAnimatedMeshSceneNode* getModel(ISceneManager* smgr, IVideoDriver* drv) {
//load mesh
IAnimatedMesh* mesh = smgr->getMesh("../model/box.obj");
//set mesh to new node
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode(mesh);
//if node is created, add some texture on it
if(node) {
node->setMaterialFlag(EMF_LIGHTING, false);
//node->setMaterialTexture(0,drv->getTexture("../model/kuva2.bmp"));
//node->setMaterialType( EMT_SOLID );
node->setMaterialFlag(EMF_BACK_FACE_CULLING, false);
node->setMaterialFlag(EMF_FRONT_FACE_CULLING, false);
std::cout << "node ok\n";
}
return node;
}
static ISceneNode* addNinja(ISceneManager* smgr, core::vector3df pos)
{
IAnimatedMeshSceneNode* ninja = smgr->addAnimatedMeshSceneNode(
smgr->getMesh("Assets/model/ninja/ninja.b3d"));
ninja->setFrameLoop(182, 204);
ninja->setMaterialFlag(video::EMF_LIGHTING, false);
ninja->setAnimationSpeed(12);
ninja->setPosition(pos);
return ninja;
}
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"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;
}
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"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;
}
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;
}
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()
{
IrrlichtDevice *device =
createDevice( video::EDT_SOFTWARE, dimension2d<u32>(640, 480), 16,
false, false, false, 0);
if (!device)
return 1;
device->setWindowCaption(L"Have a go here: Chapter 3");
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
IAnimatedMesh* mesh = smgr->getMesh("/home/fuyajun/Documents/irrlicht-1.7.2/media/sydney.md2");
if (!mesh)
{
device->drop();
return 1;
}
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh );
MyAnimationEndCallback animEndCallback;
//连续动画
if (node)
{
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMD2Animation(scene::EMAT_STAND);
node->setMaterialTexture( 0, driver->getTexture("/home/fuyajun/Documents/irrlicht-1.7.2/media/sydney.bmp") );
node->setLoopMode(false);
node->setAnimationEndCallback(&animEndCallback);
}
smgr->addCameraSceneNode(0, vector3df(0,30,-40), vector3df(0,5,0));
while(device->run())
{
driver->beginScene(true, true, SColor(255,100,101,140));
smgr->drawAll();
driver->endScene();
}
device->drop();
return 0;
}
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 );
}
bool PlayerObject::initWithLevel(int level)
{
// IMesh* mesh = _assets->getMesh(PLAYER, MESH, 0);
// if (!mesh)
// return false;
//
// IMeshSceneNode* node = _smgr->addMeshSceneNode(mesh);
// _node = node;
// if (node)
// {
// node->setMaterialFlag(EMF_LIGHTING, true);
//// node->setMaterialFlag(EMF_FOG_ENABLE, true);
// node->setMaterialTexture(0, _assets->getTexture(PLAYER, TEXTURE, 0));
//// for (int i = 0; i < 9; i++)//TODO : comment faire pour ne pas mettre le nombre de textures en dur
//// {
//// node->setMaterialTexture(0, _ressources->getTexture(PLAYER, TEXTURE, 0));
//// }
//
// this->scaleOnCase();
// this->updateNodePosition();
// return true;
// }
_level = level;
IAnimatedMesh* mesh = static_cast<IAnimatedMesh*>(_assets->getMesh(PLAYER, MESH, _level));
if (!mesh)
return false;
IAnimatedMeshSceneNode* node = _smgr->addAnimatedMeshSceneNode(mesh, getParentNode(), NODE_ID_PLAYER);
_node = node;
if (node)
{
node->setMaterialFlag(EMF_LIGHTING, false);
// node->setMaterialFlag(EMF_FOG_ENABLE, true);
startNewAnim(EMAT_STAND, REPEAT);
startNewAnim(EMAT_SALUTE, ONCE);
// node->setMD2Animation(EMAT_STAND);
this->scaleOnCase();
this->updateNodePosition();
node->setMaterialTexture(0, _assets->getTexture(PLAYER, TEXTURE, _level));
return true;
}
return false;
}
int main()
{
eventReceiver receiver;
IrrlichtDevice *device = createDevice( video::EDT_OPENGL, dimension2d<u32>(1366, 768), 16,true, false, false,&receiver);
device->setWindowCaption(L"(WhizGeek || Mclightning).com");
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
scene::ICameraSceneNode* kam= smgr->addCameraSceneNode(NULL,vector3df(0,0,200),vector3df(0,0,0));
//kam->setPosition(vector3df(0,0,200));
ISceneNode* kutu=smgr->addCubeSceneNode(50,0,2,vector3df(50,0,0));
ISceneNode* kutu2=smgr->addCubeSceneNode(50,0,2,vector3df(-50,0,0));
ITexture *duvar=driver->getTexture("wall.jpg");
kutu->setMaterialTexture(0,duvar);
kutu->setMaterialFlag(video::EMF_LIGHTING, false);
kutu2->setMaterialTexture(0,duvar);
kutu2->setMaterialFlag(video::EMF_LIGHTING, false);
IAnimatedMesh* mesh = smgr->getMesh("sydney.md2");
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh );
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMD2Animation(scene::EMAT_STAND);
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
node->setRotation(vector3df(0,270,0));
irFinder ir("test",true,230,255);
CvPoint in;
while(device->run())
{
if(receiver.IsKeyDown(KEY_ESCAPE))
{
device->drop();
return 0;
}
driver->beginScene(true, true, SColor(255,0,0,255));
in=ir.yenile();
//node->setPosition(vector3df(30*in.x/320,30*(240-in.y)/240,0));
kam->setPosition(vector3df(in.x-160,(240-in.y),200));
smgr->drawAll();
driver->endScene();
}
device->drop();
}
/** 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()
{
IrrlichtDevice *device =
createDevice( video::EDT_OPENGL, dimension2d<u32>(640, 480), 16,
false, false, false, 0);
if (!device)
cout<<"error";
else
{
device->setWindowCaption(L"Hello World! - Irrlicht Engine Demo");
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
IGUIEnvironment* guienv = device->getGUIEnvironment();
guienv->addStaticText(L"Hello World! This is the Irrlicht Software renderer!",
rect<s32>(10,10,260,22), true);
IAnimatedMesh* mesh = smgr->getMesh("sydney.md2");
if (!mesh)
{
device->drop();
return 1;
}
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh );
if (node)
{
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMD2Animation(scene::EMAT_STAND);
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
}
smgr->addCameraSceneNode(0, vector3df(0,30,-40), vector3df(0,5,0));
while(device->run())
{
driver->beginScene(true, true, SColor(255,100,101,140));
smgr->drawAll();
guienv->drawAll();
driver->endScene();
}
device->drop();
}
cout<<"hello world2";
}
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;
}
void AnnyFactory::produce(int x,int y,int z){
std::string sydneyMesh = "monkey.obj";
std::string sydneyMaterial = "unwrappedPainted.png";//"monkey.bmp";
IAnimatedMesh* mesh = sceneManager->getMesh((RESOURCES+sydneyMesh).c_str());
if (!mesh)
{
exit(1);
}
IAnimatedMeshSceneNode* node = sceneManager->addAnimatedMeshSceneNode( mesh );
const wchar_t* name = L"Monkey head";
objectList->addObject(name);
if (node)
{
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMD2Animation(scene::EMAT_RUN);
node->setMaterialTexture( 0, driver->getTexture((RESOURCES+sydneyMaterial).c_str()) );
node->setName(name);
node->setPosition(core::vector3df(x,y,z));
node->setScale(core::vector3df(10,10,10));
node->setRotation(core::vector3df(0,200,0));
}
}
void CRaycastTankExample::createTank(const stringw file, const stringw collFile, const vector3df &pos, const f32 mass)
{
IAnimatedMeshSceneNode *Node = device->getSceneManager()->addAnimatedMeshSceneNode(
device->getSceneManager()->getMesh(file.c_str()));
Node->setPosition(pos);
//Node->setRotation(vector3df(-40,90,0));
Node->setMaterialFlag(video::EMF_LIGHTING, true);
//Node->setScale(vector3df(2,2,4));
IGImpactMeshShape *shape = new IGImpactMeshShape(Node, device->getSceneManager()->getMesh(collFile.c_str()), mass);
tank = world->addRigidBody(shape);
// When using a raycast vehicle, we don't want this rigid body to deactivate.
tank->setActivationState(EAS_DISABLE_DEACTIVATION);
// Set some damping on the rigid body because the raycast vehicles tend to bounce a lot without a lot of tweaking.
// (cheap fix for the example only)
tank->setDamping(0.4, 0.4);
// We create our vehicle, passing our newly created rigid body as a parameter.
vehicle = world->addRaycastVehicle(tank);
// Set up our wheel construction info. These values can be changed for each wheel,
// and the values that you want to keep will stay the same, that way
// all parameters for each wheel can stay the same for what needs to remain equal,
// such as directions and suspension rest length.
SWheelInfoConstructionInfo wheel;
wheel.chassisConnectionPointCS = vector3df(0.0,-0.88,4.0);
wheel.wheelDirectionCS = vector3df(0.0,-0.1,0.0);
wheel.wheelAxleCS = vector3df(-0.5,0.0,0.0);
wheel.suspensionRestLength = 0.6;
wheel.wheelRadius = 8.0;
wheel.isFrontWheel = true;
// The bones are in the center of the mesh on the X axis, so we just set the width ourselves.
// Do the left row of wheels.
for(u32 i=0; i < Node->getJointCount(); i++)
{
// The bones that we need in this mesh are all named "RoadWheels" with a numerical suffix.
// So we do a quick check to make sure that no unwanted bones get through as wheels.
if(Node->getJointNode(i)->getName()[0] == 'R')
{
wheel.chassisConnectionPointCS = vector3df(-4, Node->getJointNode(i)->getPosition().Y,Node->getJointNode(i)->getPosition().Z);
vehicle->addWheel(wheel);
}
}
wheel.wheelAxleCS = vector3df(0.5,0.0,0.0);
// Do the right row of wheels.
for(u32 i=0; i < Node->getJointCount(); i++)
{
if(Node->getJointNode(i)->getName()[0] == 'R')
{
wheel.chassisConnectionPointCS = vector3df(4, Node->getJointNode(i)->getPosition().Y,Node->getJointNode(i)->getPosition().Z);
vehicle->addWheel(wheel);
}
}
for (u32 i=0;i<vehicle->getNumWheels();i++)
{
SWheelInfo &info = vehicle->getWheelInfo(i);
info.suspensionStiffness = 0.08f;
info.wheelDampingRelaxation = 20.0f;
info.wheelDampingCompression = 20.0f;
info.frictionSlip = 1000;
info.rollInfluence = 0.1f;
// We call updateWheel, which takes SWheelInfo as the first parameter,
// and the ID of the wheel to apply that info to. This must
// be called after any changes in order for the changes to actually take effect.
vehicle->updateWheelInfo(i);
}
}
/*
This is the main method. We can now use main() on every platform.
*/
int main()
{
/*
The most important function of the engine is the createDevice()
function. The IrrlichtDevice is created by it, which is the root
object for doing anything with the engine. createDevice() has 7
parameters:
- deviceType: Type of the device. This can currently be the Null-device,
one of the two software renderers, D3D9, or OpenGL. In this
example we use EDT_SOFTWARE, but to try out, you might want to
change it to EDT_BURNINGSVIDEO, EDT_NULL, EDT_DIRECT3D9, or EDT_OPENGL.
- windowSize: Size of the Window or screen in FullScreenMode to be
created. In this example we use 640x480.
- bits: Amount of color bits per pixel. This should be 16 or 32. The
parameter is often ignored when running in windowed mode.
- fullscreen: Specifies if we want the device to run in fullscreen mode
or not.
- stencilbuffer: Specifies if we want to use the stencil buffer (for
drawing shadows).
- vsync: Specifies if we want to have vsync enabled, this is only useful
in fullscreen mode.
- eventReceiver: An object to receive events. We do not want to use this
parameter here, and set it to 0.
Always check the return value to cope with unsupported drivers,
dimensions, etc.
*/
IrrlichtDevice *device =
createDevice( video::EDT_OGLES1, dimension2d<u32>(640, 480), 16,
false, false, false, 0);
if (!device)
return 1;
/*
Set the caption of the window to some nice text. Note that there is an
'L' in front of the string. The Irrlicht Engine uses wide character
strings when displaying text.
*/
device->setWindowCaption(L"Hello World! - Irrlicht Engine Demo");
/*
Get a pointer to the VideoDriver, the SceneManager and the graphical
user interface environment, so that we do not always have to write
device->getVideoDriver(), device->getSceneManager(), or
device->getGUIEnvironment().
*/
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
IGUIEnvironment* guienv = device->getGUIEnvironment();
/*
We add a hello world label to the window, using the GUI environment.
The text is placed at the position (10,10) as top left corner and
(260,22) as lower right corner.
*/
guienv->addStaticText(L"Hello World! This is the Irrlicht Software renderer!",
rect<s32>(10,10,260,22), true);
/*
Get a media path dedicated for your platform.
*/
const io::path mediaPath = getExampleMediaPath();
/*
To show something interesting, we load a Quake 2 model and display it.
We only have to get the Mesh from the Scene Manager with getMesh() and add
a SceneNode to display the mesh with addAnimatedMeshSceneNode(). We
check the return value of getMesh() to become aware of loading problems
and other errors.
Instead of writing the filename sydney.md2, it would also be possible
to load a Maya object file (.obj), a complete Quake3 map (.bsp) or any
other supported file format. By the way, that cool Quake 2 model
called sydney was modelled by Brian Collins.
*/
IAnimatedMesh* mesh = smgr->getMesh(mediaPath + "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(mediaPath + "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));
/*
Ok, now we have set up the scene, lets draw everything: We run the
device in a while() loop, until the device does not want to run any
more. This would be when the user closes the window or presses ALT+F4
(or whatever keycode closes a window).
*/
while(device->run())
{
/*
Anything can be drawn between a beginScene() and an endScene()
call. The beginScene() call clears the screen with a color and
the depth buffer, if desired. Then we let the Scene Manager and
the GUI Environment draw their content. With the endScene()
call everything is presented on the screen.
*/
driver->beginScene(ECBF_COLOR | ECBF_DEPTH, SColor(255,100,101,140));
smgr->drawAll();
guienv->drawAll();
driver->endScene();
}
/*
After we are done with the render loop, we have to delete the Irrlicht
Device created before with createDevice(). In the Irrlicht Engine, you
have to delete all objects you created with a method or function which
starts with 'create'. The object is simply deleted by calling ->drop().
See the documentation at irr::IReferenceCounted::drop() for more
information.
*/
device->drop();
return 0;
}
/*
This is the main method. We can use void main() on every platform.
On Windows platforms, we could also use the WinMain method
if we would want to get rid of the console window, which pops up when
starting a program with main(), but to keep this example simple,
we use main().
*/
int main(int argc, char** argv)
{
/*
The most important function of the engine is the 'createDevice'
function. The Irrlicht Device can be created with it, which is the
root object for doing everything with the engine.
createDevice() has 7 paramters:
deviceType: Type of the device. This can currently be the Null-device,
the Software device, DirectX8, DirectX9, or OpenGL. In this example we use
EDT_SOFTWARE, but to try out, you might want to change it to
EDT_NULL, EDT_DIRECTX8 , EDT_DIRECTX9, or EDT_OPENGL.
windowSize: Size of the Window or FullscreenMode to be created. In this
example we use 640x480.
bits: Amount of bits per pixel when in fullscreen mode. This should
be 16 or 32. This parameter is ignored when running in windowed mode.
fullscreen: Specifies if we want the device to run in fullscreen mode
or not.
stencilbuffer: Specifies if we want to use the stencil buffer for drawing shadows.
vsync: Specifies if we want to have vsync enabled, this is only useful in fullscreen
mode.
eventReceiver: An object to receive events. We do not want to use this
parameter here, and set it to 0.
*/
IrrlichtDevice *device =
createDevice(EDT_SOFTWARE, dimension2d<s32>(640, 480), 16,
false, false, false, 0);
/*
Set the caption of the window to some nice text. Note that there is
a 'L' in front of the string. The Irrlicht Engine uses wide character
strings when displaying text.
*/
device->setWindowCaption(L"Hello World! - Irrlicht Engine Demo");
/*
Get a pointer to the video driver, the SceneManager and the
graphical user interface environment, so that
we do not always have to write device->getVideoDriver(),
device->getSceneManager() and device->getGUIEnvironment().
*/
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
IGUIEnvironment* guienv = device->getGUIEnvironment();
/*
We add a hello world label to the window, using the GUI environment.
*/
guienv->addStaticText(L"Hello World! This is the Irrlicht Software renderer!",
rect<int>(10,10,200,22), true);
/*
To display something interesting, we load a Quake 2 model
and display it. We only have to get the Mesh from the Scene
Manager (getMesh()) and add a SceneNode to display the mesh.
(addAnimatedMeshSceneNode()). Instead of writing the filename
sydney.md2, it would also be possible to load a Maya object file
(.obj), a complete Quake3 map (.bsp) or a Milshape file (.ms3d).
By the way, that cool Quake 2 model called sydney was modelled
by Brian Collins.
*/
IAnimatedMesh* mesh = smgr->getMesh("../../media/sydney.md2");
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh );
/*
To let the mesh look a little bit nicer, we change its material a
little bit: We disable lighting because we do not have a dynamic light
in here, and the mesh would be totally black. Then we set the frame
loop, so that the animation is looped between the frames 0 and 310.
And at 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->setFrameLoop(0, 310);
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).
*/
smgr->addCameraSceneNode(0, vector3df(0,30,-40), vector3df(0,5,0));
/*
Ok, now we have set up the scene, lets draw everything:
We run the device in a while() loop, until the device does not
want to run any more. This would be when the user closed the window
or pressed ALT+F4 in windows.
*/
while(device->run())
{
/*
Anything can be drawn between a beginScene() and an endScene()
call. The beginScene clears the screen with a color and also the
depth buffer if wanted. Then we let the Scene Manager and the
GUI Environment draw their content. With the endScene() call
everything is presented on the screen.
*/
driver->beginScene(true, true, SColor(0,200,200,200));
smgr->drawAll();
guienv->drawAll();
driver->endScene();
}
/*
After we are finished, we have to delete the Irrlicht Device
created before with createDevice(). In the Irrlicht Engine,
you will have to delete all objects you created with a method or
function which starts with 'create'. The object is simply deleted
by calling ->drop().
See the documentation at
http://irrlicht.sourceforge.net//docu/classirr_1_1IUnknown.html#a3
for more information.
*/
device->drop();
return 0;
}
int main( ) {
// Boring stuff: set up the scene, object & camera as usual
// To make things more interesting, we add many Sydneys and a textured floor this time
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"Depth of Field", rect<s32>( 10, 10, 260, 22 ), true );
IAnimatedMesh* mesh = smgr->getMesh("sydney.md2");
// Create the required material. This is a simple shader which draws the texture with no lights.
// Use GL_PLAIN1 / DX_PLANE1 or GL_PLAIN2 / DX_PLANE2 to support 1 or 2 basic point-lights
u32 matid;
IGPUProgrammingServices* gpu = driver->getGPUProgrammingServices( );
switch( driver->getDriverType( ) ) {
case EDT_OPENGL:
matid = gpu->addHighLevelShaderMaterial( GL_V_MAT, "main", EVST_VS_1_1, GL_PLAIN, "main", EPST_PS_1_1, new CTexturesShaderCallback( ), EMT_SOLID, 1 );
break;
case EDT_DIRECT3D8:
case EDT_DIRECT3D9:
default:
matid = gpu->addHighLevelShaderMaterial( DX_V_MAT, "main", EVST_VS_1_1, DX_PLAIN, "main", EPST_PS_2_0, new CTexturesShaderCallback( ), EMT_SOLID, 0 );
}
for( u8 x = 0u; x != 2u; ++ x )
for( u8 i = 0u; i != 5u; ++ i ) {
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh );
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMD2Animation(scene::EMAT_STAND);
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
node->setMaterialType( (E_MATERIAL_TYPE) matid );
node->setPosition( vector3df( -x * 20.0f, 0.0f, i * 40.0f ) );
}
ISceneNode* node2 = smgr->addMeshSceneNode( smgr->addHillPlaneMesh( "", dimension2df( 200.0f, 200.0f ), dimension2d<u32>( 10, 10 ), NULL, 0.0f, dimension2df( 0.0f, 0.0f ), dimension2df( 100.0f, 100.0f ) ) );
node2->setMaterialFlag(EMF_LIGHTING, false);
node2->setMaterialTexture( 0, driver->getTexture("terrain-heightmap.bmp") );
node2->setMaterialType( (E_MATERIAL_TYPE) matid );
node2->setPosition( vector3df( 0.0f, -22.0f, 0.0f ) );
ICameraSceneNode* cam = smgr->addCameraSceneNode( 0, vector3df( 40.0f, 60.0f, -40.0f ), vector3df( 0.0f, 5.0f, 50.0f ) );
IPostProc* ppRenderer = new CRendererPostProc( smgr, dimension2di( 1024, 512 ), true, true, SColor( 255u, 100u, 101u, 140u ) );
CEffectPostProc* ppBlurDOF = new CEffectPostProc( ppRenderer, dimension2di( 1024, 512 ), PP_BLURDOF );
// We could set parameters on creation, but no need since we will animate it anyway.
// Parameters are: near blur, near focus, far focus, far blur, blur level
// You can also use PP_BLURDOFNEAR or PP_BLURDOFFAR to have only near or far blurring
// These variables aren't important - they are just for showing the FPS
wchar_t tmp[255]; u8 t = 0u;
while( device->run( ) ) {
// Change the camera angle
cam->setTarget( vector3df( -(device->getCursorControl( )->getPosition( ).X - 320.0f) * 0.1f, (device->getCursorControl( )->getPosition( ).Y - 240.0f) * 0.2f, 0.0f ) );
// Animate the depth of field:
f32 p = sinf( device->getTimer( )->getTime( ) * 0.0005f ) * 0.5f - 0.2f;
ppBlurDOF->setParameters( p * 100.0f + 80.0f, p * 100.0f + 110.0f, p * 100.0f + 160.0f, p * 100.0f + 240.0f, 0.01f );
driver->beginScene( false, driver->getDriverType( ) == video::EDT_DIRECT3D9 );
ppBlurDOF->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 ppBlurDOF;
delete ppRenderer;
// Back to boring stuff
device->drop();
return 0;
}
int main( ) {
// Boring stuff: set up the scene, object & camera as usual
// To make things more interesting, we add many Sydneys and a textured floor this time
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"Heat Haze (with Depth dependence)", rect<s32>( 10, 10, 260, 22 ), true );
IAnimatedMesh* mesh = smgr->getMesh("sydney.md2");
ISceneManager* smgr2 = smgr->createNewSceneManager( false );
ISceneNode* rootnode2 = smgr2->getRootSceneNode( );
IGPUProgrammingServices* gpu = driver->getGPUProgrammingServices( );
u32 matid, matid2;
switch( driver->getDriverType( ) ) {
case EDT_OPENGL:
matid = gpu->addHighLevelShaderMaterial( GL_V_MAT, "main", EVST_VS_1_1, GL_PLAIN, "main", EPST_PS_1_1, new CTexturesShaderCallback( ), EMT_SOLID, 1 );
matid2 = gpu->addHighLevelShaderMaterial( GL_V_MAT, "main", EVST_VS_1_1, GL_HEATSOURCE, "main", EPST_PS_1_1, new CTexturesShaderCallback( ), EMT_TRANSPARENT_ALPHA_CHANNEL, 1 );
break;
case EDT_DIRECT3D8:
case EDT_DIRECT3D9:
default:
matid = gpu->addHighLevelShaderMaterial( DX_V_MAT, "main", EVST_VS_1_1, DX_PLAIN, "main", EPST_PS_2_0, new CTexturesShaderCallback( ), EMT_SOLID, 0 );
matid2 = gpu->addHighLevelShaderMaterial( DX_V_MAT, "main", EVST_VS_1_1, DX_HEATSOURCE, "main", EPST_PS_2_0, new CTexturesShaderCallback( ), EMT_TRANSPARENT_ALPHA_CHANNEL, 0 );
}
for( u8 x = 0u; x != 2u; ++ x )
for( u8 i = 0u; i != 5u; ++ i ) {
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh );
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMD2Animation(scene::EMAT_STAND);
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
node->setMaterialType( (E_MATERIAL_TYPE) matid );
node->setPosition( vector3df( -x * 20.0f, 0.0f, i * 40.0f ) );
ISceneNode* node2 = smgr2->addBillboardSceneNode( rootnode2, dimension2df( 30.0f, 80.0f ), vector3df( -x * 20.0f, 30.0f, i * 40.0f ) );
node2->setMaterialFlag(EMF_LIGHTING, false);
node2->setMaterialType( EMT_TRANSPARENT_ADD_COLOR );
node2->setMaterialTexture( 0, driver->getTexture("fireball.bmp") );
node2->setMaterialType( (E_MATERIAL_TYPE) matid2 );
}
ISceneNode* nodeF = smgr->addMeshSceneNode( smgr->addHillPlaneMesh( "", dimension2df( 200.0f, 200.0f ), dimension2d<u32>( 10, 10 ), NULL, 0.0f, dimension2df( 0.0f, 0.0f ), dimension2df( 100.0f, 100.0f ) ) );
nodeF->setMaterialFlag(EMF_LIGHTING, false);
nodeF->setMaterialTexture( 0, driver->getTexture("terrain-heightmap.bmp") );
nodeF->setPosition( vector3df( 0.0f, -22.0f, 0.0f ) );
nodeF->setMaterialType( (E_MATERIAL_TYPE) matid );
ICameraSceneNode* cam1 = smgr->addCameraSceneNode( 0, vector3df( 40.0f, 60.0f, -40.0f ), vector3df( 0.0f, 5.0f, 50.0f ) );
ICameraSceneNode* cam2 = smgr2->addCameraSceneNode( rootnode2, vector3df( 40.0f, 60.0f, -40.0f ), vector3df( 0.0f, 5.0f, 50.0f ) );
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 ) );
CEffectPostProc* ppHaze = new CEffectPostProc( ppRenderer1, dimension2di( 1024, 512 ), PP_HAZEDEPTH );
ppHaze->setInput( 1, ppRenderer2 );
ppHaze->setTimer( device->getTimer( ) );
// These variables aren't important - they are just for showing the FPS
wchar_t tmp[255]; u8 t = 0u;
while( device->run( ) ) {
cam1->setPosition( vector3df( 40.0f, 60.0f - (device->getCursorControl( )->getPosition( ).Y - 240.0f) * 0.1f, -40.0f ) );
cam1->setTarget( vector3df( -(device->getCursorControl( )->getPosition( ).X - 320.0f) * 0.1f, (device->getCursorControl( )->getPosition( ).Y - 240.0f) * 0.2f, 50.0f ) );
cam2->setPosition( cam1->getPosition( ) );
cam2->setTarget( cam1->getTarget( ) );
cam2->setUpVector( cam1->getUpVector( ) );
driver->beginScene( false, driver->getDriverType( ) == video::EDT_DIRECT3D9 );
ppHaze->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 ppHaze;
delete ppRenderer1;
delete ppRenderer2;
// Back to boring stuff
device->drop();
return 0;
}
void
CProcTitle::Init()
{
// Get scean manager.
m_pSceneMgr = m_pDevice->getSceneManager();
if (!m_pSceneMgr)
{
return;
}
// Get gui environment
m_pGuiEnv = m_pDevice->getGUIEnvironment();
if (!m_pGuiEnv)
{
return;
}
m_pGuiEnv->addStaticText(L"ProcTitle", rect<int>(10,10,200,22), true);
//-----------------------------------------------------
//
// set event receiver
//
//-----------------------------------------------------
m_pEvtReceiver = new CProcLoginEventReceiver(this);
m_pDevice->setEventReceiver(m_pEvtReceiver);
//-----------------------------------------------------
//
// create light
//
//-----------------------------------------------------
m_pSceneMgr->addLightSceneNode(0,
core::vector3df(100,100,-100),
video::SColorf(1.0f, 1.0f, 1.0f, 1.0f),
1200.0f);
//-----------------------------------------------------
//
// object
//
//-----------------------------------------------------
// load water
{
/*scene::IAnimatedMesh* mesh;
scene::ISceneNode* node;
mesh = m_pSceneMgr->addHillPlaneMesh("myHill",
core::dimension2d<f32>(20,20),
core::dimension2d<u32>(40,40), 0, 0,
core::dimension2d<f32>(0,0),
core::dimension2d<f32>(10,10));
node = m_pSceneMgr->addWaterSurfaceSceneNode(mesh->getMesh(0), 3.0f, 300.0f, 30.0f);
node->setPosition(core::vector3df(0,0,0));
node->setMaterialTexture(0, m_pDriver->getTexture("media/stones.jpg"));
node->setMaterialTexture(1, m_pDriver->getTexture("media/water.jpg"));
node->setMaterialType(video::EMT_REFLECTION_2_LAYER);*/
}
// load sydney
{
IAnimatedMesh* pMesh;
IAnimatedMeshSceneNode* pNode;
// load mesh, mesh's ref count will be 1
pMesh = m_pSceneMgr->getMesh("media/sydney.md2");
// add node, mesh's ref count will be 2
pNode = m_pSceneMgr->addAnimatedMeshSceneNode(pMesh);
// load material
if (pNode)
{
pNode->setMaterialFlag(EMF_LIGHTING, false);
pNode->setFrameLoop(0, 310);
ITexture* pTexture = m_pDriver->getTexture("media/sydney.bmp");
pNode->setMaterialTexture(0, pTexture);
}
// create agent
m_pAgent = new CPlayer(this, pMesh, pNode, NULL, m_pSceneMgr);
}
// load dwarf
{
/*IAnimatedMesh* pMesh;
IAnimatedMeshSceneNode* pNode;
pMesh = m_pSceneMgr->getMesh("media/dwarf.x");
pNode = m_pSceneMgr->addAnimatedMeshSceneNode(pMesh);
pNode->setPosition(core::vector3df(30,0,0));
pNode->setScale(core::vector3df(0.5f,0.5f,0.5f));
pNode->setAnimationSpeed(15);
pNode->setName("dwarf");
pNode->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true); */
}
//-----------------------------------------------------
//
// camera
//
//-----------------------------------------------------
m_pSceneMgr->addCameraSceneNode(0, vector3df(0,30,-100), vector3df(0,0,0));
//m_pSceneMgr->addCameraSceneNodeFPS();
}
void dns_cache_prune(DnsCache *c) {
usec_t t = 0;
assert(c);
/* Remove all entries that are past their TTL */
for (;;) {
_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
DnsCacheItem *i;
i = prioq_peek(c->by_expiry);
if (!i)
break;
if (t <= 0)
t = now(CLOCK_BOOTTIME);
if (i->until > t)
break;
/* Take an extra reference to the key so that it
* doesn't go away in the middle of the remove call */
key = dns_resource_key_ref(i->key);
dns_cache_remove(c, key);
}
}
static int dns_cache_item_prioq_compare_func(const void *a, const void *b) {
const DnsCacheItem *x = a, *y = b;
if (x->until < y->until)
return -1;
if (x->until > y->until)
return 1;
return 0;
}
static int dns_cache_init(DnsCache *c) {
int r;
assert(c);
r = prioq_ensure_allocated(&c->by_expiry, dns_cache_item_prioq_compare_func);
if (r < 0)
return r;
r = hashmap_ensure_allocated(&c->by_key, &dns_resource_key_hash_ops);
if (r < 0)
return r;
return r;
}
static int dns_cache_link_item(DnsCache *c, DnsCacheItem *i) {
DnsCacheItem *first;
int r;
assert(c);
assert(i);
r = prioq_put(c->by_expiry, i, &i->prioq_idx);
if (r < 0)
return r;
first = hashmap_get(c->by_key, i->key);
if (first) {
LIST_PREPEND(by_key, first, i);
assert_se(hashmap_replace(c->by_key, first->key, first) >= 0);
} else {
r = hashmap_put(c->by_key, i->key, i);
if (r < 0) {
prioq_remove(c->by_expiry, i, &i->prioq_idx);
return r;
}
}
return 0;
}
static DnsCacheItem* dns_cache_get(DnsCache *c, DnsResourceRecord *rr) {
DnsCacheItem *i;
assert(c);
assert(rr);
LIST_FOREACH(by_key, i, hashmap_get(c->by_key, rr->key))
if (i->rr && dns_resource_record_equal(i->rr, rr) > 0)
return i;
return NULL;
}
static void dns_cache_item_update_positive(DnsCache *c, DnsCacheItem *i, DnsResourceRecord *rr, usec_t timestamp) {
assert(c);
assert(i);
assert(rr);
i->type = DNS_CACHE_POSITIVE;
if (!i->by_key_prev) {
/* We are the first item in the list, we need to
* update the key used in the hashmap */
assert_se(hashmap_replace(c->by_key, rr->key, i) >= 0);
}
dns_resource_record_ref(rr);
dns_resource_record_unref(i->rr);
i->rr = rr;
dns_resource_key_unref(i->key);
i->key = dns_resource_key_ref(rr->key);
i->until = timestamp + MIN(rr->ttl * USEC_PER_SEC, CACHE_TTL_MAX_USEC);
prioq_reshuffle(c->by_expiry, i, &i->prioq_idx);
}
static int dns_cache_put_positive(
DnsCache *c,
DnsResourceRecord *rr,
usec_t timestamp,
int owner_family,
const union in_addr_union *owner_address) {
_cleanup_(dns_cache_item_freep) DnsCacheItem *i = NULL;
DnsCacheItem *existing;
int r;
assert(c);
assert(rr);
assert(owner_address);
/* New TTL is 0? Delete the entry... */
if (rr->ttl <= 0) {
dns_cache_remove(c, rr->key);
return 0;
}
if (rr->key->class == DNS_CLASS_ANY)
return 0;
if (rr->key->type == DNS_TYPE_ANY)
return 0;
/* Entry exists already? Update TTL and timestamp */
existing = dns_cache_get(c, rr);
if (existing) {
dns_cache_item_update_positive(c, existing, rr, timestamp);
return 0;
}
/* Otherwise, add the new RR */
r = dns_cache_init(c);
if (r < 0)
return r;
dns_cache_make_space(c, 1);
i = new0(DnsCacheItem, 1);
if (!i)
return -ENOMEM;
i->type = DNS_CACHE_POSITIVE;
i->key = dns_resource_key_ref(rr->key);
i->rr = dns_resource_record_ref(rr);
i->until = timestamp + MIN(i->rr->ttl * USEC_PER_SEC, CACHE_TTL_MAX_USEC);
i->prioq_idx = PRIOQ_IDX_NULL;
i->owner_family = owner_family;
i->owner_address = *owner_address;
r = dns_cache_link_item(c, i);
if (r < 0)
return r;
i = NULL;
return 0;
}
static int dns_cache_put_negative(
DnsCache *c,
DnsResourceKey *key,
int rcode,
usec_t timestamp,
uint32_t soa_ttl,
int owner_family,
const union in_addr_union *owner_address) {
_cleanup_(dns_cache_item_freep) DnsCacheItem *i = NULL;
int r;
assert(c);
assert(key);
assert(owner_address);
dns_cache_remove(c, key);
if (key->class == DNS_CLASS_ANY)
return 0;
if (key->type == DNS_TYPE_ANY)
return 0;
if (soa_ttl <= 0)
return 0;
if (!IN_SET(rcode, DNS_RCODE_SUCCESS, DNS_RCODE_NXDOMAIN))
return 0;
r = dns_cache_init(c);
if (r < 0)
return r;
dns_cache_make_space(c, 1);
i = new0(DnsCacheItem, 1);
if (!i)
return -ENOMEM;
i->type = rcode == DNS_RCODE_SUCCESS ? DNS_CACHE_NODATA : DNS_CACHE_NXDOMAIN;
i->key = dns_resource_key_ref(key);
i->until = timestamp + MIN(soa_ttl * USEC_PER_SEC, CACHE_TTL_MAX_USEC);
i->prioq_idx = PRIOQ_IDX_NULL;
i->owner_family = owner_family;
i->owner_address = *owner_address;
r = dns_cache_link_item(c, i);
if (r < 0)
return r;
i = NULL;
return 0;
}
int dns_cache_put(
DnsCache *c,
DnsQuestion *q,
int rcode,
DnsAnswer *answer,
unsigned max_rrs,
usec_t timestamp,
int owner_family,
const union in_addr_union *owner_address) {
unsigned i;
int r;
assert(c);
assert(q);
int main( ) {
// Boring stuff: set up the scene, object & camera as usual
// To make things more interesting, we add many Sydneys and a textured floor this time
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"Sandbox", rect<s32>( 10, 10, 260, 22 ), true );
IAnimatedMesh* mesh = smgr->getMesh("sydney.md2");
IGPUProgrammingServices* gpu = driver->getGPUProgrammingServices( );
u32 matid;
switch( driver->getDriverType( ) ) {
case EDT_OPENGL:
matid = gpu->addHighLevelShaderMaterial( GL_V_MAT, "main", EVST_VS_1_1, GL_PLAIN, "main", EPST_PS_1_1, new CTexturesShaderCallback( ), EMT_SOLID, 1 );
break;
case EDT_DIRECT3D8:
case EDT_DIRECT3D9:
default:
matid = gpu->addHighLevelShaderMaterial( DX_V_MAT, "main", EVST_VS_1_1, DX_PLAIN, "main", EPST_PS_2_0, new CTexturesShaderCallback( ), EMT_SOLID, 0 );
}
for( u8 x = 0u; x != 2u; ++ x )
for( u8 i = 0u; i != 5u; ++ i ) {
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh );
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMD2Animation(scene::EMAT_STAND);
node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );
node->setMaterialType( (E_MATERIAL_TYPE) matid );
node->setPosition( vector3df( -x * 20.0f, 0.0f, i * 40.0f ) );
}
ISceneNode* nodeF = smgr->addTerrainSceneNode( "terrain-heightmap.bmp" );
nodeF->setMaterialFlag(EMF_LIGHTING, false);
nodeF->setMaterialTexture( 0, driver->getTexture("terrain-heightmap.bmp") );
nodeF->setPosition( vector3df( -512.0f, -50.0f, -512.0f ) );
nodeF->setScale( vector3df( 4.0f, 0.2f, 4.0f ) );
nodeF->setMaterialType( (E_MATERIAL_TYPE) matid );
ICameraSceneNode* cam1 = smgr->addCameraSceneNode( 0, vector3df( 0.0f, 0.0f, -40.0f ), vector3df( 0.0f, 5.0f, 50.0f ) );
IPostProc* ppRenderer1 = new CRendererPostProc( smgr, dimension2di( 1024, 512 ), true, true, SColor( 255, 130u, 180u, 230u ) );
CWaterPostProc* ppWater = new CWaterPostProc( ppRenderer1, dimension2di( 1024, 512 ), -22.0f );
ppWater->setTimer( device->getTimer( ) );
wchar_t tmp[255];
u8 t = 0u;
while( device->run( ) ) {
// cam1->setPosition( vector3df( 40.0f, 60.0f - (device->getCursorControl( )->getPosition( ).Y - 240.0f) * 0.1f, -40.0f ) );
cam1->setPosition( vector3df( (device->getCursorControl( )->getPosition( ).X - 320.0f) * 0.1f, (device->getCursorControl( )->getPosition( ).Y - 240.0f) * 0.1f, -40.0f ) );
// cam1->setTarget( vector3df( (device->getCursorControl( )->getPosition( ).X - 320.0f) * 0.1f, (device->getCursorControl( )->getPosition( ).Y - 240.0f) * 0.1f, 0.0f ) );
// cam1->setTarget( cam1->getPosition( ) + vector3df( 0.0f, 0.0f, 10.0f ) );
// cam1->setTarget( vector3df( -(device->getCursorControl( )->getPosition( ).X - 320.0f) * 0.1f, (device->getCursorControl( )->getPosition( ).Y - 240.0f) * 0.2f, 50.0f ) );
driver->beginScene( false, driver->getDriverType( ) == video::EDT_DIRECT3D9 );
ppWater->render( NULL );
guienv->drawAll( );
driver->endScene( );
if( ++ t == 30u ) {
t = 0u;
swprintf(tmp, 255, L"%ls fps:%3d", driver->getName(), driver->getFPS() );
device->setWindowCaption( tmp );
}
}
delete ppWater;
delete ppRenderer1;
// Back to boring stuff
device->drop();
return 0;
}