// ----------------------------------------------------------------------------
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
//! Constructor
COGLES2MaterialParallaxMapCB::COGLES2MaterialParallaxMapCB() :
FirstUpdate(true), WVPMatrixID(-1), WVMatrixID(-1), EyePositionID(-1), LightPositionID(-1), LightColorID(-1), FactorID(-1), TextureUnit0ID(-1), TextureUnit1ID(-1),
FogEnableID(-1), FogTypeID(-1), FogColorID(-1), FogStartID(-1), FogEndID(-1), FogDensityID(-1), Factor(0.02f), TextureUnit0(0), TextureUnit1(1),
FogEnable(0), FogType(1), FogColor(SColorf(0.f, 0.f, 0.f, 1.f)), FogStart(0.f), FogEnd(0.f), FogDensity(0.f)
{
for (u32 i = 0; i < 2; ++i)
{
LightPosition[i] = core::vector3df(0.f, 0.f, 0.f);
LightColor[i] = SColorf(0.f, 0.f, 0.f, 1.f);
}
}
void PhysicsSim::makeLight(vector3df position, float intensity)
{
ILightSceneNode* lsn = smgr->addLightSceneNode(0, position, video::SColorf(1.f, 1.f, 1.f), 1);
// smgr->setAmbientLight(SColorf(0.2, 0.2, 0.2));
SLight sl = lsn->getLightData();
sl.Attenuation = Vector3D(0, 0.001, 0);
sl.DiffuseColor = SColorf(1, 1, 1);
sl.Direction = Vector3D(0, -1, 0);
sl.AmbientColor = SColorf(0.4, 0.4, 0.4);
lsn->setLightData(sl);
}
void IrrQWidget::buildIrrlichtScene(){
if(idevice != 0){
collMan = iscene->getSceneCollisionManager();
geo = iscene->getGeometryCreator();
ILightSceneNode *light = iscene->addLightSceneNode();
light->setLightType( ELT_DIRECTIONAL );
light->setRotation( vector3df( 45.0f, 45.0f, 0.0f ));
light->getLightData().AmbientColor = SColorf( 0.2f, 0.2f, 0.2f, 1.0f );
light->getLightData().DiffuseColor = SColorf( 0.8f, 0.8f, 0.8f, 1.0f );
camera = iscene->addCameraSceneNodeFPS();
camera->setPosition(vector3df(0,0,-90));
camera->setTarget(vector3df(0,0,0));
}
}
//! Interpolates the color with a f32 value to another color
SColorf SColorf::getInterpolated(const SColorf &other, f32 d) const
{
d = core::StaticMath::clamp(d, 0.f, 1.f);
const f32 inv = 1.0f - d;
return SColorf(other.Red * inv + Red * d,
other.Green * inv + Green * d, other.Blue * inv + Blue * d,
other.Alpha * inv + Alpha * d);
}
void Entity::createLight(E_LIGHT_TYPE typ, f32 r, f32 g, f32 b, f32 a)
{
type = LIGHT_TYPE;
lightNode = Scene->addLightSceneNode(0, vector3df(0,0,0), SColorf(r,g,b,a), 100.0f);
lightNode->setLightType(typ);
lightNode->enableCastShadow();
rx=ry=rz=0;
isVisible = true;
}
//! Returns interpolated color. ( quadratic )
inline SColorf SColorf::getInterpolated_quadratic(const SColorf& c1,
const SColorf& c2, f32 d) const
{
d = core::StaticMath::clamp(d, 0.f, 1.f);
// this*(1-d)*(1-d) + 2 * c1 * (1-d) + c2 * d * d;
const f32 inv = 1.f - d;
const f32 mul0 = inv * inv;
const f32 mul1 = 2.f * d * inv;
const f32 mul2 = d * d;
return SColorf(Red * mul0 + c1.Red * mul1 + c2.Red * mul2,
Green * mul0 + c1.Green * mul1 + c2.Green * mul2,
Green * mul0 + c1.Blue * mul1 + c2.Blue * mul2,
Alpha * mul0 + c1.Alpha * mul1 + c2.Alpha * mul2);
}
void load_map() {
IAnimatedMesh* mesh = smgr->getMesh("resources/nodes/maps/room.3ds");
smgr->getMeshManipulator()->makePlanarTextureMapping(mesh->getMesh(0), 0.008f);
ISceneNode* node = 0;
node = smgr->addAnimatedMeshSceneNode(mesh);
node->setMaterialTexture(0, driver->getTexture("resources/textures/maps/wall.jpg"));
node->getMaterial(0).SpecularColor.set(0,0,0,0);
mesh = smgr->addHillPlaneMesh("myHill",
dimension2d<f32>(20,20),
dimension2d<u32>(40,40),
0,
0,
dimension2d<f32>(0,0),
dimension2d<f32>(10,10)
);
node = smgr->addWaterSurfaceSceneNode(mesh->getMesh(0), 3.0f, 300.0f, 30.0f);
node->setPosition(vector3df(0,7,0));
node->setMaterialTexture(0, driver->getTexture("resources/textures/maps/stones.jpg"));
node->setMaterialTexture(1, driver->getTexture("resources/textures/maps/water.jpg"));
node->setMaterialType(video::EMT_REFLECTION_2_LAYER);
// create light
node = smgr->addLightSceneNode(0, vector3df(0,0,0), SColorf(1.0f, 0.6f, 0.7f, 1.0f), 600.0f);
ISceneNodeAnimator* anim = 0;
anim = smgr->createFlyCircleAnimator (vector3df(0,150,0),250.0f);
node->addAnimator(anim);
anim->drop();
// attach billboard to light
node = smgr->addBillboardSceneNode(node, dimension2d<f32>(50, 50));
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMaterialType(EMT_TRANSPARENT_ADD_COLOR);
node->setMaterialTexture(0, driver->getTexture("resources/textures/particles/particlewhite.bmp"));
}
EngineExhaustNode::EngineExhaustNode(ISceneNode* parent, ISceneManager *mgr, s32 id,
float radius, float psize, bool light):
ISceneNode(parent, mgr, id),
mParticleSize(psize),
mExhaustVelocity(-0.02, 0, 0),
mRadius(radius)
{
// engine light
if(light)
{
scene::ILightSceneNode* light = mgr->addLightSceneNode(this, core::vector3df(0,0,40), SColorf(0.6, 0.4, 0.1), 30);
light->setLightType( video::ELT_POINT );
}
// create particle system to set up affectors, then delete again
/// \todo fix this
auto fire = SceneManager->addParticleSystemSceneNode(false, 0, 0);
//Emitter
mFadeOutAffector = fire->createFadeOutParticleAffector(SColor(0,0,0,0), mParticleLifetime );
mScaleAffector = fire->createScaleParticleAffector(dimension2df(4.0 * psize , 4.0 * psize ));
fire->remove();
// texture loading
mFireTexture = SceneManager->getVideoDriver()->getTexture("gfx/fire.png");
if(mFireTexture)
mFireTexture->grab();
setName("engine");
}
void MyIrrlichtComposition::AddLight()
{
light=smgr->addLightSceneNode(0, vector3df(0,100,0),SColorf(0.8f,0.8f,0.6f));
light->setRadius(300);
}
Application::Application():sock(true){
//int16_t mRCYaw = mRCPitch = mRCRoll = 0;
mRCThrottle = 1250;
mRCPitch = 1500;
mRCYaw = 1500;
mRCRoll = 1500;
mRCThrottle = 2000;
mRCPitch = 1000;
mRCYaw = 1000;
mRCRoll = 1000;
irrDevice = createDevice(video::EDT_OPENGL, dimension2d<u32>(640, 480), 32, false, false, false, this);
irrGUI = irrDevice->getGUIEnvironment();
irrTimer = irrDevice->getTimer();
irrScene = irrDevice->getSceneManager();
irrDriver = irrDevice->getVideoDriver();
irrDevice->getCursorControl()->setVisible(0);
// load a map
irrDevice->getFileSystem()->addFileArchive("map-20kdm2.pk3");
scene::IAnimatedMesh* mesh = irrScene->getMesh("20kdm2.bsp");
scene::ISceneNode* node = 0;
if (mesh)
node = irrScene->addOctreeSceneNode(mesh->getMesh(0), 0, -1, 1024);
if (node)
node->setPosition(core::vector3df(-1300,-144,-1249));
// Initialize bullet
CollisionConfiguration = new btDefaultCollisionConfiguration();
BroadPhase = new btAxisSweep3(btVector3(-1000, -1000, -1000), btVector3(1000, 1000, 1000));
Dispatcher = new btCollisionDispatcher(CollisionConfiguration);
Solver = new btSequentialImpulseConstraintSolver();
World = new btDiscreteDynamicsWorld(Dispatcher, BroadPhase, Solver, CollisionConfiguration);
World->setGravity(btVector3(0, -9.82, 0));
// Add camera
ICameraSceneNode *Camera = irrScene->addCameraSceneNodeFPS(0, 100, 0.01);
//ICameraSceneNode *Camera = irrScene->addCameraSceneNode();
Camera->setPosition(vector3df(0, 0, 0));
Camera->setRotation(vector3df(45, -30, 0));
//Camera->setUpVector(vector3df(0, 0, 1.0));
//Camera->setTarget(vector3df(1, 0, 0));
// Preload textures
irrDriver->getTexture("ice0.jpg");
irrDriver->getTexture("rust0.jpg");
// Create the initial scene
irrScene->addLightSceneNode(0, core::vector3df(2, 5, -2), SColorf(4, 4, 4, 1));
irrScene->addLightSceneNode(0, core::vector3df(2, -5, -2), SColorf(4, 4, 4, 1));
CreateStartScene();
// Main loop
TimeStamp = irrTimer->getTime(), DeltaTime = 0;
Copter *view = new Copter(this);
activeQuad = view;
sock.bind("127.0.0.1", 9002);
}
int main()
{
Input input;
IrrlichtDevice *device = createDevice(video::EDT_DIRECT3D9, dimension2d<u32>(800, 600), 16, false, true, false, &input);
device->setWindowCaption(L"Seas of Gold");
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
IGUIEnvironment* guienv = device->getGUIEnvironment();
E_DRIVER_TYPE driverType = driverChoiceConsole();
EffectHandler *effect = new EffectHandler(device, driver->getScreenSize(), false, true);
E_FILTER_TYPE filterType = (E_FILTER_TYPE)core::clamp<u32>((u32)3 - '1', 0, 4);
MapID currentMap;
int skyR = 30, skyG = 30, skyB = 70;
int timer = 0;
SColor sky = SColor(255, skyR, skyG, skyB);
float plPos_x = 0.0f, plPos_y = 0.0f, plPos_z = 0.0f;
bool updateCam = true;
bool menu1 = false;
int state = Main;
int frameCount = 0;
LoadMap loadMap;
Player player;
Interface playerInterface(driver);
ITriangleSelector* selector = 0;
ISceneNodeAnimator* anim = 0;
Vendor southVendor;
Vendor eastVendor;
Vendor northVendor;
//InitializeVendors(northVendor, southVendor, eastVendor, itemD);
//ItemDatabase* itemD = new ItemDatabase;
ItemDatabase itemD;
itemD.Initialize();
//initialize player's inventory
player.AddGold(1000);
player.getInventory()->addItem(itemD.getItem(bronzeOre), 50);
player.getInventory()->addItem(itemD.getItem(ironOre), 50);
player.getInventory()->addItem(itemD.getItem(goldOre), 50);
//initialize south vendor's inventory
southVendor.getInventory()->addItem(itemD.getItem(bronzeOre), 100);
southVendor.getInventory()->addItem(itemD.getItem(coalOre), 100);
southVendor.getInventory()->addItem(itemD.getItem(supplies), 1000);
//initialize north vendor's inventory
northVendor.getInventory()->addItem(itemD.getItem(obsidianOre), 50);
northVendor.getInventory()->addItem(itemD.getItem(supplies), 1000);
//initialize south vendor's inventory
eastVendor.getInventory()->addItem(itemD.getItem(goldOre), 100);
eastVendor.getInventory()->addItem(itemD.getItem(ironOre), 100);
eastVendor.getInventory()->addItem(itemD.getItem(supplies), 1000);
//Item item(0, "bronzeOre", "Sprites/ore_Bronze.png");
//Item item2 = item;
//Item* item2 = itemD.getItem(3);
//inventory.addItem(&item, 2);
//inventory.addItem(&item, 2);
//inventory.addItem(item2, 2);
//int test = 0;
// Load the map scene
//loadMap.Load(smgr, device, Map_Africa);
//loadMap.Load(smgr, device, Map_India);
//loadMap.Load(smgr, device, selector, plyrNode, anim, Map_England);
IAnimatedMeshSceneNode* plyrNode = player.loadPlayerNode(device, smgr);
//plyrNode->setDebugDataVisible((scene::E_DEBUG_SCENE_TYPE)(plyrNode->isDebugDataVisible() ^ scene::EDS_BBOX));
ICameraSceneNode* camera = smgr->addCameraSceneNode(0, plyrNode->getPosition() + vector3df(0, 2, 2), vector3df(0, 0, 100));
loadMap.Load(smgr, device, selector, plyrNode, anim, driver, Map_Africa);
currentMap = Map_Africa;
//loadMap.setCollisions(smgr, selector, plyrNode, anim);
if (loadMap.CollNode)
{
selector = smgr->createOctreeTriangleSelector(loadMap.CollNode->getMesh(), loadMap.CollNode, 32);
for (int i = 0; i < loadMap.CollNode->getMaterialCount(); i++)
{
loadMap.CollNode->getMaterial(i).NormalizeNormals = true;
}
loadMap.CollNode->setTriangleSelector(selector);
}
if (selector)
{
anim = smgr->createCollisionResponseAnimator(selector, plyrNode, vector3df(0.6f, 0.75f, 0.4f), core::vector3df(0.0f, -0.05f, 0.0f),
core::vector3df(0.0f, -0.725f, 0.0f));
plyrNode->addAnimator(anim);
}
ISceneCollisionManager* collMan = smgr->getSceneCollisionManager();
////////////// The Sun ////////////
ILightSceneNode *sun_node;
SLight sun_data;
ISceneNode *sun_billboard;
float sun_angle = 0;
video::SColorf Diffuse_Night = video::SColorf(0.0f, 0.0f, 0.0f, 1.0f);
video::SColorf Diffuse_Day = video::SColorf(1.0f, 1.0f, 1.0f, 1.0f);
sun_node = smgr->addLightSceneNode();
sun_data.Direction = vector3df(0, 0, 0);
sun_data.Type = video::ELT_DIRECTIONAL;
sun_data.AmbientColor = video::SColorf(0.1f, 0.1f, 0.1f, 1);
sun_data.SpecularColor = video::SColorf(0, 0, 0, 0);
sun_data.DiffuseColor = Diffuse_Day;
sun_data.CastShadows = true;
sun_node->setLightData(sun_data);
sun_node->setPosition(vector3df(0, 0, 0));
sun_node->setRotation(vector3df(0, 0, 0));
sun_billboard = smgr->addBillboardSceneNode(sun_node, core::dimension2d<f32>(60, 60));
if (sun_billboard)
{
sun_billboard->setPosition(vector3df(0, 0, -100));
sun_billboard->setMaterialFlag(video::EMF_LIGHTING, false);
sun_billboard->setMaterialFlag(video::EMF_ZWRITE_ENABLE, false);
sun_billboard->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
sun_billboard->setMaterialTexture(0, driver->getTexture("Assets/particlewhite.bmp"));
}
/////////// End ////////////
//------- candleLight -----//
ILightSceneNode *candleLight = smgr->addLightSceneNode();
SLight candleLight_data;
candleLight_data.Type = video::ELT_POINT;
candleLight_data.DiffuseColor = SColorf(1.0f, 0.546f, 0.016f, 1.0f);
candleLight_data.SpecularColor = video::SColorf(0, 0, 0, 0);
candleLight->setPosition(vector3df(2.43467f, 1.55795f, -3.94657));
candleLight_data.Radius = 1.5f;
candleLight->setLightData(candleLight_data);
//------- end -----//
//// Make the player
//player.AddGold(1000);
//player.SetCurrentPort(eMapDest::South);
//Item* itemCi = new Item("Iron Ore", 1);
//player.getItems()->addItem(itemCi);
//Item* itemCb = new Item("Bronze Ore", 1);
//player.getItems()->addItem(itemCb);
//Vendor vN;
//Item* itemG = new Item("Gold Ore", 1000);
//vN.getItems()->addItem(itemG);
//Vendor vS;
//Item* itemI = new Item("Iron Ore", 1000);
//vS.getItems()->addItem(itemI);
//Vendor vE;
//Item* itemB = new Item("Bronze Ore", 1000);
//vE.getItems()->addItem(itemB);
//Vendor northVendor
//delete &itemD;
int test99 = 0;
// Make the menus
MainMenu mainMenu(device, driver);
MapMenu mapMenu(device, driver);
mapMenu.SetPlayer(&player);
TradeMenu tradeMenu;
tradeMenu.Initialize(device, driver, &player, &southVendor);
//TradeMenu tradeMenu(device, driver);
//tradeMenu.SetPlayer(&player);
//tradeMenu.SetVendor(&vS);
//
CraftingMenu craftMenu(device, driver, &player, itemD);
//craftMenu.SetPlayer(&player);
//////////////////////////////////////////////////////////////////////////
// Initialize timer to compute elapsed time between frames
//////////////////////////////////////////////////////////////////////////
__int64 cntsPerSec = 0;
QueryPerformanceFrequency((LARGE_INTEGER*)&cntsPerSec);
float secsPerCnt = 1.0f / (float)cntsPerSec;
__int64 prevTimeStamp = 0;
QueryPerformanceCounter((LARGE_INTEGER*)&prevTimeStamp);
while (device->run())
{
//for scaling animation by time, not by frame
__int64 currTimeStamp = 0;
QueryPerformanceCounter((LARGE_INTEGER*)&currTimeStamp);
float dt = (currTimeStamp - prevTimeStamp) * secsPerCnt;
sun_node->setRotation(vector3df(sun_angle, 0.0f, 0.0f));
sun_angle += dt;
frameCount += 1;
if ((sun_angle > 0 && sun_angle < 109) || (sun_angle>350))
{
timer++;
if (timer > 10)
{
if (skyR < 100) skyR += 1;
if (skyG < 100) skyG += 1;
if (skyB < 140) skyB += 1;
timer = 0;
}
}
if (sun_angle > 170 && sun_angle < 330)
{
timer++;
if (timer > 10)
{
if (skyR > 0) skyR -= 1;
if (skyG > 0) skyG -= 1;
if (skyB > 40) skyB -= 1;
timer = 0;
}
}
player.updatePlayer(plyrNode, dt, collMan, selector);
playerInterface.update(plyrNode, loadMap, driver, device, input, updateCam, state);
switch (state)
{
case Map:
{
int out = mapMenu.Update(&input, frameCount);
switch (out)
{
case eMapDest::Exit:
{
state = None;
break;
}
case eMapDest::East:
{
state = None;
//Item* itemB = new Item("Bronze Ore", 1000);
//vE.getItems()->addItem(itemB);
tradeMenu.SetVendor(&eastVendor);
loadMap.Load(smgr, device, selector, plyrNode, anim, driver, Map_India);
currentMap = Map_India;
if (loadMap.CollNode)
{
selector = smgr->createOctreeTriangleSelector(loadMap.CollNode->getMesh(), loadMap.CollNode, 32);
for (int i = 0; i < loadMap.CollNode->getMaterialCount(); i++)
{
loadMap.CollNode->getMaterial(i).NormalizeNormals = true;
}
loadMap.CollNode->setTriangleSelector(selector);
}
if (selector)
{
anim = smgr->createCollisionResponseAnimator(selector, plyrNode, vector3df(0.6f, 0.75f, 0.4f), core::vector3df(0.0f, -0.05f, 0.0f),
core::vector3df(0.0f, -0.725f, 0.0f));
plyrNode->addAnimator(anim);
}
collMan = smgr->getSceneCollisionManager();
break;
}
case eMapDest::North:
{
state = None;
//Item *itemG = new Item("Gold Ore", 1000);
//vN.getItems()->addItem(itemG);
//tradeMenu.SetVendor(&vN);
tradeMenu.SetVendor(&northVendor);
loadMap.Load(smgr, device, selector, plyrNode, anim, driver, Map_England);
currentMap = Map_England;
if (loadMap.CollNode)
{
selector = smgr->createOctreeTriangleSelector(loadMap.CollNode->getMesh(), loadMap.CollNode, 32);
for (int i = 0; i < loadMap.CollNode->getMaterialCount(); i++)
{
loadMap.CollNode->getMaterial(i).NormalizeNormals = true;
}
loadMap.CollNode->setTriangleSelector(selector);
}
if (selector)
{
anim = smgr->createCollisionResponseAnimator(selector, plyrNode, vector3df(0.6f, 0.75f, 0.4f), core::vector3df(0.0f, -0.05f, 0.0f),
core::vector3df(0.0f, -0.725f, 0.0f));
plyrNode->addAnimator(anim);
}
collMan = smgr->getSceneCollisionManager();
break;
}
case eMapDest::South:
{
state = None;
//Item *itemI = new Item("Iron Ore", 1000);
//vS.getItems()->addItem(itemI);
//tradeMenu.SetVendor(&vS);
tradeMenu.SetVendor(&southVendor);
loadMap.Load(smgr, device, selector, plyrNode, anim, driver, Map_Africa);
currentMap = Map_Africa;
if (loadMap.CollNode)
{
selector = smgr->createOctreeTriangleSelector(loadMap.CollNode->getMesh(), loadMap.CollNode, 32);
for (int i = 0; i < loadMap.CollNode->getMaterialCount(); i++)
{
loadMap.CollNode->getMaterial(i).NormalizeNormals = true;
}
loadMap.CollNode->setTriangleSelector(selector);
}
if (selector)
{
anim = smgr->createCollisionResponseAnimator(selector, plyrNode, vector3df(0.6f, 0.75f, 0.4f), core::vector3df(0.0f, -0.05f, 0.0f),
core::vector3df(0.0f, -0.725f, 0.0f));
plyrNode->addAnimator(anim);
}
collMan = smgr->getSceneCollisionManager();
break;
}
default:
break;
}
break;
}
case Trade:
{
bool out = false;
out = tradeMenu.Update(&input, frameCount, device, currentMap);
if (out)
state = None;
break;
}
case Main:
{
int out = mainMenu.Update(&input, frameCount);
switch (out)
{
case MSstart:
{
state = None;
break;
}
case MSexit:
{
device->closeDevice();
//return 0;
break;
}
default:
break;
}
break;
}
case Craft:
{
bool out = craftMenu.Update(&input, frameCount, device);
if (out)
state = None;
break;
}
default:
// Do nothing
break;
}
if (updateCam) moveCameraControl(plyrNode, device, camera);
////////////////////////////////////////////////////////
if (sun_angle > 360) sun_angle = 0;
if (sun_angle < 180) sun_data.DiffuseColor = Diffuse_Day; else sun_data.DiffuseColor = Diffuse_Night;
sun_node->setLightData(sun_data);
sky.setRed(skyR);
sky.setGreen(skyG);
sky.setBlue(skyB);
driver->beginScene(true, true, sky);
smgr->drawAll();
playerInterface.render(driver, state);
// Draw the menu
switch (state)
{
case Map:
{
mapMenu.Draw(driver, device);
break;
}
case Trade:
{
tradeMenu.Render(driver, device);
break;
}
case Main:
{
mainMenu.Draw(driver);
break;
}
case Craft:
{
craftMenu.Draw(driver);
break;
}
default:
// Do nothing
break;
}
driver->endScene();
// Update the prev time stamp to current
prevTimeStamp = currTimeStamp;
}
device->drop();
return 0;
}
/* ----------------------------------------------------------------------------
Diffuse color emitted by the light.
*/
void DLL_EXPORT IrrSetLightDiffuseColor( ILightSceneNode *light, float R, float G, float B )
{
light->getLightData().DiffuseColor = SColorf( R, G, B, 0.0f );
}
SColorf ConvertRGBAColorToSColorf(const RGBAColor& color)
{
return SColorf(color.r(), color.g(), color.b(), color.a());
}
void COGLES2MaterialParallaxMapCB::OnSetConstants(IMaterialRendererServices* services, s32 userData)
{
IVideoDriver* driver = services->getVideoDriver();
if (FirstUpdate)
{
WVPMatrixID = services->getVertexShaderConstantID("uWVPMatrix");
WVMatrixID = services->getVertexShaderConstantID("uWVMatrix");
EyePositionID = services->getVertexShaderConstantID("uEyePosition");
LightPositionID = services->getVertexShaderConstantID("uLightPosition");
LightColorID = services->getVertexShaderConstantID("uLightColor");
FactorID = services->getVertexShaderConstantID("uFactor");
TextureUnit0ID = services->getVertexShaderConstantID("uTextureUnit0");
TextureUnit1ID = services->getVertexShaderConstantID("uTextureUnit1");
FogEnableID = services->getVertexShaderConstantID("uFogEnable");
FogTypeID = services->getVertexShaderConstantID("uFogType");
FogColorID = services->getVertexShaderConstantID("uFogColor");
FogStartID = services->getVertexShaderConstantID("uFogStart");
FogEndID = services->getVertexShaderConstantID("uFogEnd");
FogDensityID = services->getVertexShaderConstantID("uFogDensity");
FirstUpdate = false;
}
const core::matrix4 W = driver->getTransform(ETS_WORLD);
const core::matrix4 V = driver->getTransform(ETS_VIEW);
const core::matrix4 P = driver->getTransform(ETS_PROJECTION);
/*core::matrix4 Matrix = P * V * W;
services->setPixelShaderConstant(WVPMatrixID, Matrix.pointer(), 16);
Matrix = V * W;
services->setPixelShaderConstant(WVMatrixID, Matrix.pointer(), 16);
core::vector3df EyePosition(0.0f, 0.0f, 0.0f);
Matrix.makeInverse();
Matrix.transformVect(EyePosition);
services->setPixelShaderConstant(EyePositionID, reinterpret_cast<f32*>(&EyePosition), 3);
Matrix = W;
Matrix.makeInverse();*/
core::matrix4 Matrix_W = W;
core::matrix4 Matrix_V_W = V * W;
core::matrix4 Matrix_P_V_W = P * Matrix_V_W;
core::vector3df EyePosition(0.0f, 0.0f, 0.0f);
services->setPixelShaderConstant(WVPMatrixID, Matrix_P_V_W.pointer(), 16);
services->setPixelShaderConstant(WVMatrixID, Matrix_V_W.pointer(), 16);
Matrix_V_W.makeInverse();
Matrix_V_W.transformVect(EyePosition);
services->setPixelShaderConstant(EyePositionID, reinterpret_cast<f32*>(&EyePosition), 3);
Matrix_W.makeInverse();
const u32 LightCount = driver->getDynamicLightCount();
for (u32 i = 0; i < 2; ++i)
{
SLight CurrentLight;
if (i < LightCount)
CurrentLight = driver->getDynamicLight(i);
else
{
CurrentLight.DiffuseColor.set(0.f, 0.f, 0.f);
CurrentLight.Radius = 1.f;
}
CurrentLight.DiffuseColor.a = 1.f / (CurrentLight.Radius*CurrentLight.Radius);
//Matrix.transformVect(CurrentLight.Position);
Matrix_W.transformVect(CurrentLight.Position);
LightPosition[i] = CurrentLight.Position;
LightColor[i] = CurrentLight.DiffuseColor;
}
services->setPixelShaderConstant(LightPositionID, reinterpret_cast<f32*>(LightPosition), 6);
services->setPixelShaderConstant(LightColorID, reinterpret_cast<f32*>(LightColor), 8);
services->setPixelShaderConstant(FactorID, &Factor, 1);
services->setPixelShaderConstant(TextureUnit0ID, &TextureUnit0, 1);
services->setPixelShaderConstant(TextureUnit1ID, &TextureUnit1, 1);
services->setPixelShaderConstant(FogEnableID, &FogEnable, 1);
if (FogEnable)
{
SColor TempColor(0);
E_FOG_TYPE TempType = EFT_FOG_LINEAR;
bool TempPerFragment = false;
bool TempRange = false;
driver->getFog(TempColor, TempType, FogStart, FogEnd, FogDensity, TempPerFragment, TempRange);
FogType = (s32)TempType;
FogColor = SColorf(TempColor);
services->setPixelShaderConstant(FogTypeID, &FogType, 1);
services->setPixelShaderConstant(FogColorID, reinterpret_cast<f32*>(&FogColor), 4);
services->setPixelShaderConstant(FogStartID, &FogStart, 1);
services->setPixelShaderConstant(FogEndID, &FogEnd, 1);
services->setPixelShaderConstant(FogDensityID, &FogDensity, 1);
}
}
SceneWorld::SceneWorld(PseuGUI *g) : Scene(g)
{
DEBUG(logdebug("SceneWorld: Initializing..."));
debugmode = false;
_freeCameraMove = true;
// store some pointers right now to prevent repeated ptr dereferencing later (speeds up code)
gui = g;
wsession = gui->GetInstance()->GetWSession();
world = wsession->GetWorld();
mapmgr = world->GetMapMgr();
movemgr = world->GetMoveMgr();
mychar = wsession->GetMyChar();
ASSERT(mychar);
_CalcXYMoveVect(mychar->GetO());
old_char_o = mychar->GetO();
if(soundengine)
{
soundengine->stopAllSounds();
}
ILightSceneNode* light = smgr->addLightSceneNode(0, core::vector3df(0,0,0), SColorf(255, 255, 255, 255), 1000.0f);
SLight ldata = light->getLightData();
ldata.AmbientColor = video::SColorf(0.2f,0.2f,0.2f);
ldata.DiffuseColor = video::SColorf(1.0f,1.0f,1.0f);
ldata.Type = video::ELT_DIRECTIONAL;
ldata.Position = core::vector3df(-0.22f,-1,0);
light->setLightData(ldata);
eventrecv = new MyEventReceiver();
device->setEventReceiver(eventrecv);
eventrecv->mouse.wheel = MAX_CAM_DISTANCE;
camera = new MCameraFPS(smgr);
camera->setNearValue(0.1f);
f32 farclip = instance->GetConf()->farclip;
if(farclip < 50)
farclip = TILESIZE;
f32 fov = instance->GetConf()->fov;
if(!iszero(fov))
{
logdetail("Camera: Field of view (FOV) = %.3f",fov);
camera->setFOV(fov);
}
camera->setFarValue(farclip);
debugText = guienv->addStaticText(L"< debug text >",rect<s32>(0,0,driver->getScreenSize().Width,30),true,true,0,-1,true);
envBasicColor = video::SColor(0,100,101,190);
smgr->setShadowColor(); // set shadow to default color
sky = NULL;
selectedNode = oldSelectedNode = NULL;
//sky = smgr->addSkyDomeSceneNode(driver->getTexture("data/misc/sky.jpg"),64,64,1.0f,2.0f);
/* // TODO: for now let irrlicht draw the skybox
sky->grab(); // if the camera clip is set too short, the sky will not be rendered properly.
sky->remove(); // thus we grab the sky node while removing it from rendering.
*/
f32 fogfar = instance->GetConf()->fogfar;
if(fogfar < 30)
fogfar = farclip * 0.7f;
f32 fognear = instance->GetConf()->fognear;
if(fognear < 10)
fognear = fogfar * 0.75f;
logdetail("GUI: Using farclip=%.2f fogfar=%.2f fognear=%.2f", farclip, fogfar, fognear);
driver->setFog(envBasicColor, true, fognear, fogfar, 0.02f);
// setup cursor
cursor->setOSCursorVisible(false);
cursor->addMouseCursorTexture("data/misc/cursor.png", true);
cursor->setVisible(true);
InitTerrain();
UpdateTerrain();
RelocateCameraBehindChar();
DEBUG(logdebug("SceneWorld: Init done!"));
}
void CScene::CreateScene(/*vector<vector3df> otherClientPosition*/)
{
ISceneManager* smgr=device->getSceneManager();
IVideoDriver* driver=device->getVideoDriver();
smgr->setAmbientLight(SColorf(0.0f, 0.0f, 0.0f));
// 天空盒
// ISceneNode* SkyBox=smgr->addSkyBoxSceneNode(driver->getTexture("../../media/irrlicht2_up.jpg"),
// driver->getTexture("../../media/irrlicht2_dn.jpg"),
// driver->getTexture("../../media/irrlicht2_lf.jpg"),
// driver->getTexture("../../media/irrlicht2_rt.jpg"),
// driver->getTexture("../../media/irrlicht2_ft.jpg"),
// driver->getTexture("../../media/irrlicht2_bk.jpg"));
ISceneNode* SkyBox=smgr->addSkyBoxSceneNode(driver->getTexture("../../media/skyBoxTop.jpg"),
driver->getTexture("../../media/skyBoxTop.jpg"),
driver->getTexture("../../media/skyBoxTop.jpg"),
driver->getTexture("../../media/skyBoxTop.jpg"),
driver->getTexture("../../media/skyBoxTop.jpg"),
driver->getTexture("../../media/skyBoxTop.jpg"));
terrain=smgr->addTerrainSceneNode(
"../../media/land.jpg",0,-1,
core::vector3df(-500.0f, 0.0f, -1500.0f), // 节点坐标
core::vector3df(0.f, 0.f, 0.f), // 旋转矩阵
core::vector3df(20.0f, 0.0f, 20.0f), // 缩放矩阵
video::SColor ( 255, 255, 255, 255 ), // 顶点颜色
1, // LOD最大程度
scene::ETPS_17, // 地形块大小
0 // 平滑度
);
terrain->setMaterialFlag(EMF_LIGHTING,false);
terrain->setMaterialTexture(0,driver->getTexture("../../media/terrain-texture.jpg"));
// terrain->setMaterialTexture(1,driver->getTexture("../../media/terrain-texture.jpg"));
terrain->setMaterialType(EMT_DETAIL_MAP);
terrain->scaleTexture(1.0f);
/*
// Building1
building1Mesh=smgr->getMesh("../../media/building1.obj");
building1Node=smgr->addAnimatedMeshSceneNode(building1Mesh);
if (building1Node)
{
building1Node->setPosition(vector3df(0,-10,140));
building1Node->setMaterialTexture(0,driver->getTexture("../../media/wall.bmp"));
building1Node->setMaterialFlag(EMF_LIGHTING,false);
}
// Building2
building2Mesh=smgr->getMesh("../../media/building2.obj");
building2Node=smgr->addAnimatedMeshSceneNode(building2Mesh);
if (building2Node)
{
building2Node->setPosition(vector3df(30,0,0));
building2Node->setMaterialTexture(0,driver->getTexture("../../media/wall.bmp"));
building2Node->setMaterialFlag(EMF_LIGHTING,false);
}
*/
smgr->loadScene("../../media/test.irr");
}
/* ----------------------------------------------------------------------------
set the scene ambient lighting
*/
void DLL_EXPORT IrrSetAmbientLight( float R, float G, float B )
{
smgr->setAmbientLight( SColorf( R, G, B, 0.0f ));
}
void loop_ctr(s4 &game_state)
{
ISceneNode* empty_node = irrlicht->smgr->addEmptySceneNode();
empty_node->setPosition(vector3df(0,0,0));
ICameraSceneNode* camera = irrlicht->smgr->addCameraSceneNode();
camera->setPosition({0,-250,-100});
camera->setUpVector({0,0,-1});
camera->setTarget({0,0,0});
camera->setParent(empty_node);
camera->setFOV(70);
irrlicht->device->getCursorControl()->setVisible(false);
irrlicht->smgr->setAmbientLight(SColorf(1,1,1,1));
irrlicht->hud = irrlicht->smgr->createNewSceneManager(false);
ICameraSceneNode* hud_camera = irrlicht->hud->addCameraSceneNode();
matrix4 ortho;
ortho.buildProjectionMatrixOrthoLH(
irrlicht->driver->getScreenSize().Width/ortho_scale,
irrlicht->driver->getScreenSize().Height/ortho_scale,-1.0,1000.0);
hud_camera->setProjectionMatrix(ortho);
hud_camera->setPosition({0,0,-100});
hud_camera->setTarget({0,0,0});
// temp objects ----------------------------------
blist cmpnt_list, joint_list, tree_list;
b_set(cmpnt_list,memory,sizeof(Component));
b_set(joint_list,memory,sizeof(Joint));
b_set(tree_list,memory,sizeof(CTree));
irr::core::map<ISceneNode*,Component*> node_cmpnt_map;
ISceneNode* ctr_parent = irrlicht->smgr->addEmptySceneNode();
IMesh* cube_mesh = irrlicht->smgr->getGeometryCreator()->createCubeMesh();
auto add_object_to_world = [&] (vec3 pos, vec3 scale, s4 a, s4 r, s4 g, s4 b) -> Component*
{
const f4 floor_position = 10.0f;
Component make_cmpnt;
make_cmpnt.id = CMPNT_ID; CMPNT_ID++;
make_cmpnt.node = irrlicht->smgr->addMeshSceneNode(cube_mesh,ctr_parent);
make_cmpnt.node->setPosition(pos.irr());
make_cmpnt.node->setScale(scale.irr());
make_cmpnt.node->getMaterial(0).AmbientColor.set(a,r,g,b);
make_cmpnt.shadow = irrlicht->smgr->addMeshSceneNode(cube_mesh,0);
make_cmpnt.shadow->setScale({scale.x, scale.y, 0.1f});
make_cmpnt.shadow->setPosition({pos.x, pos.y,floor_position});
make_cmpnt.shadow->getMaterial(0).AmbientColor.set(GREY_BLUE_SHADOW);
for (s4 i = 0; i < MAX_JOINTS; i++)
make_cmpnt.joints[i] = 0;
make_cmpnt.tree = 0;
b_copy(cmpnt_list,&make_cmpnt);
node_cmpnt_map.insert(make_cmpnt.node, (Component*)blast_address(cmpnt_list) );
return (Component*)blast_address(cmpnt_list);
};
auto add_joint = [&] (Component* A, Component* B, vec3 posA, vec3 posB)
{
Joint C;
C.A = A;
C.posA = A->node->getTransformedBoundingBox().getExtent() * A->node->getScale();
C.posA *= (posA * 0.5f);
C.B = B;
C.posB = B->node->getTransformedBoundingBox().getExtent() * B->node->getScale();
C.posB *= (posB * 0.5f);
C.type = Joint::SNAP;
C.is_connected = false;
b_copy(joint_list,&C);
for (s4 i = 0; i < MAX_JOINTS; i++)
{
if (C.A->joints[i] == 0)
{
C.A->joints[i] = (Joint*)blast_address(joint_list);
break;
} else if (i == MAX_JOINTS-1)
{
std::cout << "ERROR: Joint could not be added to C.A." << std::endl;
}
}
for (s4 i = 0; i < MAX_JOINTS; i++)
{
if (C.B->joints[i] == 0)
{
C.B->joints[i] = (Joint*)blast_address(joint_list);
break;
} else if (i == MAX_JOINTS-1)
{
std::cout << "ERROR: Joint could not be added to C.B." << std::endl;
}
}
};
{
Component* A = add_object_to_world(vec3(0,30,-20),vec3(3,3,3),BLUE_LIGHT);
Component* B = add_object_to_world(vec3(0,60,-20),vec3(9,3,2),BLACK);
add_joint(A,B,vec3(0.0f,0.0f,1.0f),vec3(0.0f,0.0f,-1.0f));
Component* C = add_object_to_world(vec3(0,-90,-20),vec3(3,3,3),YELLOW_LIGHT);
Component* D = add_object_to_world(vec3(0,-40,-20),vec3(8,10,4),GREEN_LIGHT);
add_joint(C,D,vec3(0.0f,1.0f,0.0f),vec3(0.0f,-1.0f,0.0f));
add_joint(A,D,vec3(0.0f,0.0f,-1.0f),vec3(0.0f,0.0f,1.0f));
}
// temp objects ----------------------------------
SimpleNodeEditor* sneditor = simple_node_editor_init();
sneditor->root_node = ctr_parent;
f4 target_z_rotation = empty_node->getRotation().Z;
p("---- Game loop start ----");
f4 dt = 0.0f;
const f4 maxDelta = 1.0f/60.0f * 5.0f;
const f4 tick_ms = 0.01666f;
f4 render_dt = 0.0f;
const f4 render_ms = 0.016667f;
u4 time_physics_prev = btclock->getTimeMicroseconds();
while(irrlicht->device->run() && game_state == GAME_STATE_PLAY)
{
const u4 time_physics_curr = btclock->getTimeMicroseconds();
const f4 frameTime = ((f4)(time_physics_curr - time_physics_prev)) / 1000000.0; // todo: is this truncated correctly?
time_physics_prev = time_physics_curr;
f4 capped_dt = frameTime;
if (capped_dt > maxDelta) { capped_dt = maxDelta; }
render_dt += capped_dt;
if ( render_dt >= render_ms )
{
render_dt = 0.0f;
f4 curr_rotation = empty_node->getRotation().Z;
if (curr_rotation != target_z_rotation)
{
weighted_average(curr_rotation,target_z_rotation, 20.0f);
if (curr_rotation >= 360.0f) {
curr_rotation -= 360.0f;
target_z_rotation -= 360.0f;
}
else if (curr_rotation < 0) {
curr_rotation += 360.0f;
target_z_rotation += 360.0f;
}
empty_node->setRotation({0,0,curr_rotation});
}
if (sneditor->selected_node)
{
position2d<s32> screen_coord = irrlicht->colmgr->getScreenCoordinatesFrom3DPosition(sneditor->selected_node->getPosition(), camera);
sneditor->hand_icon->setPosition({(screen_coord.X - (SCREEN_WIDTH/2)) / ortho_scale,
(screen_coord.Y - (SCREEN_HEIGHT/2)) / -ortho_scale,0});
} else {
sneditor->hand_icon->setPosition({(sneditor->cursor->getPosition().X - (SCREEN_WIDTH/2)) / ortho_scale,
(sneditor->cursor->getPosition().Y - (SCREEN_HEIGHT/2)) / -ortho_scale,0});
}
// Render
irrlicht->driver->beginScene(true, true, SColor(GREY_BLUE));
irrlicht->smgr->drawAll();
irrlicht->driver->clearZBuffer();
irrlicht->hud->drawAll();
irrlicht->driver->endScene();
}
dt += capped_dt;
while( dt >= tick_ms )
{
dt -= tick_ms;
receiver->input();
if (receiver->a.state)
target_z_rotation -= 90.0f;
if (receiver->d.state)
target_z_rotation += 90.0f;
simple_node_editor_update(
sneditor, receiver->mouse.left.state, receiver->mouse.left.released, receiver->mouse.right.state,
false, receiver->tab.state, camera, &node_cmpnt_map);
// TODO: Change this to:
// - only test what the user is holding
// - and only if the user is holding the smaller inserting part.
// example: holding a screw in a large box
bloop(joint_list, i)
{
Joint* c = (Joint*)b_get_mem_address(joint_list,i);
if (c->A->tree != sneditor->selected_tree && c->B->tree != sneditor->selected_tree )
{
continue;
}
if (!c->is_connected)
{
vec3 A = c->A->node->getPosition();
vec3 B = c->B->node->getPosition();
A += c->posA;
B += c->posB;
if (A.distance(B) < 13 /* && receiver->spacebar*/)
{
std::cout << "Comparing " << i << std::endl;
c->is_connected = true;
connect_joints(c,sneditor,camera,tree_list);
}
}
}
bloop(tree_list, i)
{
CTree* tree = (CTree*)b_get_mem_address(tree_list,i);
if (tree->translation == vec3(0,0,0))
{
continue;
}
for (s4 k = 0; k < tree->child_list.length;k++)
{
Component* cmpnt = (Component*)b_get_value(tree->child_list,k);
cmpnt->node->setPosition(cmpnt->node->getPosition() + tree->translation.irr());
cmpnt->shadow->setPosition(cmpnt->node->getPosition() * vector3df(1,1,0) + vector3df(0,0,10));
}
tree->translation = vec3(0,0,0);
}
if (receiver->restart.state) { game_state = GAME_STATE_RESET; }
if (receiver->QUIT) { game_state = GAME_STATE_QUIT; }
}
