mirror of
https://github.com/minetest/irrlicht.git
synced 2024-11-15 04:03:48 +01:00
20b3d56987
Burnings renderer changes. git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/branches/ogl-es@6116 dfc29bdd-3216-0410-991c-e03cc46cb475
404 lines
12 KiB
C++
404 lines
12 KiB
C++
// This is a Demo of the Irrlicht Engine (c) 2005-2009 by N.Gebhardt.
|
|
// This file is not documented.
|
|
|
|
#include "CMainMenu.h"
|
|
#include "CDemo.h"
|
|
#include "exampleHelper.h"
|
|
|
|
|
|
|
|
CMainMenu::CMainMenu()
|
|
: startButton(0), MenuDevice(0), selected(0), start(false), fullscreen(false),
|
|
#if defined(USE_IRRKLANG) || defined(USE_SDL_MIXER)
|
|
music(true),
|
|
#else
|
|
music(false),
|
|
#endif
|
|
shadows(true), additive(false), transparent(true), vsync(true), aa(true),
|
|
#ifndef _IRR_WINDOWS_
|
|
driverType(video::EDT_OPENGL)
|
|
#else
|
|
driverType(video::EDT_DIRECT3D9)
|
|
#endif
|
|
//driverType(video::EDT_BURNINGSVIDEO)
|
|
{
|
|
}
|
|
|
|
|
|
bool CMainMenu::run()
|
|
{
|
|
video::E_DRIVER_TYPE driverType = video::EDT_OPENGL;
|
|
if (!IrrlichtDevice::isDriverSupported(video::EDT_OPENGL))
|
|
driverType = video::EDT_BURNINGSVIDEO;
|
|
|
|
MenuDevice = createDevice(driverType,
|
|
core::dimension2d<u32>(512, 384), 16, false, false, false, this);
|
|
|
|
const io::path mediaPath = getExampleMediaPath();
|
|
|
|
if (MenuDevice->getFileSystem()->existFile("irrlicht.dat"))
|
|
MenuDevice->getFileSystem()->addFileArchive("irrlicht.dat");
|
|
else
|
|
MenuDevice->getFileSystem()->addFileArchive(mediaPath + "irrlicht.dat");
|
|
|
|
video::IVideoDriver* driver = MenuDevice->getVideoDriver();
|
|
scene::ISceneManager* smgr = MenuDevice->getSceneManager();
|
|
gui::IGUIEnvironment* guienv = MenuDevice->getGUIEnvironment();
|
|
|
|
core::stringw str = "Irrlicht Engine Demo v";
|
|
str += MenuDevice->getVersion();
|
|
MenuDevice->setWindowCaption(str.c_str());
|
|
|
|
// set new Skin
|
|
gui::IGUISkin* newskin = guienv->createSkin(gui::EGST_BURNING_SKIN);
|
|
guienv->setSkin(newskin);
|
|
newskin->drop();
|
|
|
|
// load font
|
|
gui::IGUIFont* font = guienv->getFont(mediaPath + "fonthaettenschweiler.bmp");
|
|
if (font)
|
|
guienv->getSkin()->setFont(font);
|
|
|
|
// add images
|
|
|
|
const s32 leftX = 260;
|
|
|
|
// add tab control
|
|
gui::IGUITabControl* tabctrl = guienv->addTabControl(core::rect<int>(leftX,10,512-10,384-10),
|
|
0, true, true);
|
|
gui::IGUITab* optTab = tabctrl->addTab(L"Demo");
|
|
gui::IGUITab* aboutTab = tabctrl->addTab(L"About");
|
|
|
|
// add list box
|
|
|
|
gui::IGUIListBox* box = guienv->addListBox(core::rect<int>(10,10,220,120), optTab, 1);
|
|
|
|
const wchar_t* const names[] =
|
|
{L"Software Renderer", L"Burning's Video",
|
|
L"Direct3D 8", L"Direct3D 9", L"OpenGL 1.x-4.x",
|
|
L"OpenGL-ES 1.x", L"OpenGL-ES 2.x"};
|
|
for (u32 i=1; i<video::EDT_COUNT; ++i)
|
|
{
|
|
if (IrrlichtDevice::isDriverSupported(video::E_DRIVER_TYPE(i)))
|
|
box->addItem(names[i-1]);
|
|
}
|
|
|
|
switch (driverType )
|
|
{
|
|
case video::EDT_OPENGL: selected = 0; break;
|
|
case video::EDT_DIRECT3D9: selected = 1; break;
|
|
case video::EDT_BURNINGSVIDEO: selected = 2; break;
|
|
case video::EDT_SOFTWARE: selected = 3; break;
|
|
default: break;
|
|
}
|
|
box->setSelected(selected);
|
|
|
|
// add button
|
|
|
|
startButton = guienv->addButton(core::rect<int>(30,295,200,324), optTab, 2, L"Start Demo");
|
|
|
|
// add checkbox
|
|
|
|
const s32 d = 50;
|
|
|
|
guienv->addCheckBox(fullscreen, core::rect<int>(20,85+d,130,110+d),
|
|
optTab, 3, L"Fullscreen");
|
|
guienv->addCheckBox(music, core::rect<int>(135,85+d,245,110+d),
|
|
optTab, 4, L"Music & Sfx");
|
|
guienv->addCheckBox(shadows, core::rect<int>(20,110+d,135,135+d),
|
|
optTab, 5, L"Realtime shadows");
|
|
guienv->addCheckBox(additive, core::rect<int>(20,135+d,230,160+d),
|
|
optTab, 6, L"Old HW compatible blending");
|
|
guienv->addCheckBox(vsync, core::rect<int>(20,160+d,230,185+d),
|
|
optTab, 7, L"Vertical synchronisation");
|
|
guienv->addCheckBox(aa, core::rect<int>(20,185+d,230,210+d),
|
|
optTab, 8, L"Antialiasing");
|
|
|
|
// add about text
|
|
|
|
const wchar_t* text2 = L"This is the tech demo of the Irrlicht engine. To start, "\
|
|
L"select a video driver which works best with your hardware and press 'Start Demo'.\n"\
|
|
L"What you currently see is displayed using the Burning Software Renderer (Thomas Alten).\n"\
|
|
L"The Irrlicht Engine was written by me, Nikolaus Gebhardt. The models, "\
|
|
L"maps and textures were placed at my disposal by B.Collins, M.Cook and J.Marton. The music was created by "\
|
|
L"M.Rohde and is played back by irrKlang.\n"\
|
|
L"For more information, please visit the homepage of the Irrlicht engine:\nhttp://irrlicht.sourceforge.net";
|
|
|
|
guienv->addStaticText(text2, core::rect<int>(10, 10, 230, 320),
|
|
true, true, aboutTab);
|
|
|
|
// add md2 model
|
|
|
|
scene::IAnimatedMesh* mesh = smgr->getMesh(mediaPath + "faerie.md2");
|
|
scene::IAnimatedMeshSceneNode* modelNode = smgr->addAnimatedMeshSceneNode(mesh);
|
|
if (modelNode)
|
|
{
|
|
modelNode->setPosition( core::vector3df(0.f, 0.f, -5.f) );
|
|
modelNode->setMaterialTexture(0, driver->getTexture(mediaPath + "faerie2.bmp"));
|
|
modelNode->setMaterialFlag(video::EMF_LIGHTING, true);
|
|
modelNode->getMaterial(0).Shininess = 50.f;
|
|
modelNode->getMaterial(0).NormalizeNormals = true;
|
|
modelNode->setMD2Animation(scene::EMAT_STAND);
|
|
}
|
|
|
|
// set ambient light (no sun light in the catacombs)
|
|
smgr->setAmbientLight( video::SColorf(0.2f, 0.2f, 0.2f) );
|
|
|
|
scene::ILightSceneNode *light;
|
|
scene::ISceneNodeAnimator* anim;
|
|
scene::ISceneNode* bill;
|
|
|
|
enum eLightParticle
|
|
{
|
|
LIGHT_NONE,
|
|
LIGHT_GLOBAL,
|
|
LIGHT_RED,
|
|
LIGHT_BLUE
|
|
};
|
|
core::vector3df lightDir[2] = {
|
|
core::vector3df(0.f, 0.1f, 0.4f),
|
|
core::vector3df(0.f, 0.1f, -0.4f),
|
|
};
|
|
|
|
struct SLightParticle
|
|
{
|
|
eLightParticle type;
|
|
u32 dir;
|
|
};
|
|
const SLightParticle lightParticle[] =
|
|
{
|
|
//LIGHT_GLOBAL,0,
|
|
{LIGHT_RED,0},
|
|
{LIGHT_BLUE,0},
|
|
{LIGHT_RED,1},
|
|
{LIGHT_BLUE,1},
|
|
{LIGHT_NONE,0}
|
|
};
|
|
|
|
const SLightParticle *l = lightParticle;
|
|
while ( l->type != LIGHT_NONE )
|
|
{
|
|
switch ( l->type )
|
|
{
|
|
case LIGHT_GLOBAL:
|
|
// add illumination from the background
|
|
light = smgr->addLightSceneNode(0, core::vector3df(10.f,40.f,-5.f),
|
|
video::SColorf(0.2f, 0.2f, 0.2f), 90.f);
|
|
break;
|
|
case LIGHT_RED:
|
|
// add light nearly red
|
|
light = smgr->addLightSceneNode(0, core::vector3df(0,1,0),
|
|
video::SColorf(0.8f, 0.f, 0.f, 0.0f), 30.0f);
|
|
// attach red billboard to the light
|
|
bill = smgr->addBillboardSceneNode(light, core::dimension2d<f32>(10, 10));
|
|
if ( bill )
|
|
{
|
|
bill->setMaterialFlag(video::EMF_LIGHTING, false);
|
|
bill->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
|
|
bill->setMaterialFlag(video::EMF_ZWRITE_ENABLE, false);
|
|
bill->setMaterialTexture(0, driver->getTexture(mediaPath + "particlered.bmp"));
|
|
}
|
|
// add fly circle animator to the light
|
|
anim = smgr->createFlyCircleAnimator(core::vector3df(0.f,0.f,-5.f),20.f,
|
|
0.002f, lightDir [l->dir] );
|
|
light->addAnimator(anim);
|
|
anim->drop();
|
|
break;
|
|
case LIGHT_BLUE:
|
|
// add light nearly blue
|
|
light = smgr->addLightSceneNode(0, core::vector3df(0,1,0),
|
|
video::SColorf(0.f, 0.0f, 0.8f, 0.0f), 30.0f);
|
|
// attach blue billboard to the light
|
|
bill = smgr->addBillboardSceneNode(light, core::dimension2d<f32>(10, 10));
|
|
if (bill)
|
|
{
|
|
bill->setMaterialFlag(video::EMF_LIGHTING, false);
|
|
bill->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
|
|
bill->setMaterialFlag(video::EMF_ZWRITE_ENABLE, false);
|
|
bill->setMaterialTexture(0, driver->getTexture(mediaPath + "portal1.bmp"));
|
|
}
|
|
// add fly circle animator to the light
|
|
anim = smgr->createFlyCircleAnimator(core::vector3df(0.f,0.f,-5.f),20.f,
|
|
-0.002f, lightDir [l->dir], 0.5f);
|
|
light->addAnimator(anim);
|
|
anim->drop();
|
|
break;
|
|
case LIGHT_NONE:
|
|
break;
|
|
}
|
|
l += 1;
|
|
}
|
|
|
|
// create a fixed camera
|
|
smgr->addCameraSceneNode(0, core::vector3df(45,0,0), core::vector3df(0,0,10));
|
|
|
|
|
|
// irrlicht logo and background
|
|
// add irrlicht logo
|
|
bool oldMipMapState = driver->getTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS);
|
|
driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false);
|
|
|
|
guienv->addImage(driver->getTexture(mediaPath + "irrlichtlogo3.png"),
|
|
core::position2d<s32>(5,5));
|
|
|
|
video::ITexture* irrlichtBack = driver->getTexture(mediaPath + "demoback.jpg");
|
|
|
|
driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, oldMipMapState);
|
|
|
|
// query original skin color
|
|
getOriginalSkinColor();
|
|
|
|
// set transparency
|
|
setTransparency();
|
|
|
|
// draw all
|
|
|
|
while(MenuDevice->run())
|
|
{
|
|
if (MenuDevice->isWindowActive())
|
|
{
|
|
driver->beginScene(video::ECBF_DEPTH, video::SColor(0,0,0,0));
|
|
|
|
if (irrlichtBack)
|
|
driver->draw2DImage(irrlichtBack,
|
|
core::position2d<int>(0,0));
|
|
|
|
smgr->drawAll();
|
|
guienv->drawAll();
|
|
driver->endScene();
|
|
}
|
|
}
|
|
|
|
MenuDevice->drop();
|
|
|
|
for (u32 i=1; i<video::EDT_COUNT; ++i)
|
|
{
|
|
if (IrrlichtDevice::isDriverSupported(video::E_DRIVER_TYPE(i)))
|
|
{
|
|
if (!selected)
|
|
{
|
|
driverType=video::E_DRIVER_TYPE(i);
|
|
break;
|
|
}
|
|
--selected;
|
|
}
|
|
}
|
|
|
|
return start;
|
|
}
|
|
|
|
|
|
bool CMainMenu::OnEvent(const SEvent& event)
|
|
{
|
|
if (event.EventType == EET_KEY_INPUT_EVENT &&
|
|
event.KeyInput.Key == KEY_F9 &&
|
|
event.KeyInput.PressedDown == false)
|
|
{
|
|
video::IImage* image = MenuDevice->getVideoDriver()->createScreenShot();
|
|
if (image)
|
|
{
|
|
MenuDevice->getVideoDriver()->writeImageToFile(image, "screenshot_main.jpg");
|
|
image->drop();
|
|
}
|
|
}
|
|
else
|
|
if (event.EventType == irr::EET_MOUSE_INPUT_EVENT &&
|
|
event.MouseInput.Event == EMIE_RMOUSE_LEFT_UP )
|
|
{
|
|
core::rect<s32> r(event.MouseInput.X, event.MouseInput.Y, 0, 0);
|
|
gui::IGUIContextMenu* menu = MenuDevice->getGUIEnvironment()->addContextMenu(r, 0, 45);
|
|
menu->addItem(L"transparent menus", 666, transparent == false);
|
|
menu->addItem(L"solid menus", 666, transparent == true);
|
|
menu->addSeparator();
|
|
menu->addItem(L"Cancel");
|
|
}
|
|
else
|
|
if (event.EventType == EET_GUI_EVENT)
|
|
{
|
|
s32 id = event.GUIEvent.Caller->getID();
|
|
switch(id)
|
|
{
|
|
case 45: // context menu
|
|
if (event.GUIEvent.EventType == gui::EGET_MENU_ITEM_SELECTED)
|
|
{
|
|
s32 s = ((gui::IGUIContextMenu*)event.GUIEvent.Caller)->getSelectedItem();
|
|
if (s == 0 || s == 1)
|
|
{
|
|
transparent = !transparent;
|
|
setTransparency();
|
|
}
|
|
}
|
|
break;
|
|
case 1:
|
|
if (event.GUIEvent.EventType == gui::EGET_LISTBOX_CHANGED ||
|
|
event.GUIEvent.EventType == gui::EGET_LISTBOX_SELECTED_AGAIN)
|
|
{
|
|
selected = ((gui::IGUIListBox*)event.GUIEvent.Caller)->getSelected();
|
|
//startButton->setEnabled(selected != 4);
|
|
startButton->setEnabled(true);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (event.GUIEvent.EventType == gui::EGET_BUTTON_CLICKED )
|
|
{
|
|
MenuDevice->closeDevice();
|
|
start = true;
|
|
}
|
|
case 3:
|
|
if (event.GUIEvent.EventType == gui::EGET_CHECKBOX_CHANGED )
|
|
fullscreen = ((gui::IGUICheckBox*)event.GUIEvent.Caller)->isChecked();
|
|
break;
|
|
case 4:
|
|
if (event.GUIEvent.EventType == gui::EGET_CHECKBOX_CHANGED )
|
|
music = ((gui::IGUICheckBox*)event.GUIEvent.Caller)->isChecked();
|
|
break;
|
|
case 5:
|
|
if (event.GUIEvent.EventType == gui::EGET_CHECKBOX_CHANGED )
|
|
shadows = ((gui::IGUICheckBox*)event.GUIEvent.Caller)->isChecked();
|
|
break;
|
|
case 6:
|
|
if (event.GUIEvent.EventType == gui::EGET_CHECKBOX_CHANGED )
|
|
additive = ((gui::IGUICheckBox*)event.GUIEvent.Caller)->isChecked();
|
|
break;
|
|
case 7:
|
|
if (event.GUIEvent.EventType == gui::EGET_CHECKBOX_CHANGED )
|
|
vsync = ((gui::IGUICheckBox*)event.GUIEvent.Caller)->isChecked();
|
|
break;
|
|
case 8:
|
|
if (event.GUIEvent.EventType == gui::EGET_CHECKBOX_CHANGED )
|
|
aa = ((gui::IGUICheckBox*)event.GUIEvent.Caller)->isChecked();
|
|
break;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
void CMainMenu::getOriginalSkinColor()
|
|
{
|
|
irr::gui::IGUISkin * skin = MenuDevice->getGUIEnvironment()->getSkin();
|
|
for (s32 i=0; i<gui::EGDC_COUNT ; ++i)
|
|
{
|
|
SkinColor[i] = skin->getColor( (gui::EGUI_DEFAULT_COLOR)i );
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void CMainMenu::setTransparency()
|
|
{
|
|
irr::gui::IGUISkin * skin = MenuDevice->getGUIEnvironment()->getSkin();
|
|
|
|
for (u32 i=0; i<gui::EGDC_COUNT ; ++i)
|
|
{
|
|
video::SColor col = SkinColor[i];
|
|
|
|
if (false == transparent)
|
|
col.setAlpha(255);
|
|
|
|
skin->setColor((gui::EGUI_DEFAULT_COLOR)i, col);
|
|
}
|
|
}
|
|
|