/*
Most of the hard work is done. We only need to create the Irrlicht Engine
device and all the buttons, menus and toolbars. We start up the engine as
usual, using createDevice(). To make our application catch events, we set our
eventreceiver as parameter. As you can see, there is also a call to
IrrlichtDevice::setResizeable(). This makes the render window resizeable, which
is quite useful for a mesh viewer.
*/
int main(int argc, char* argv[])
{
// ask user for driver
video::E_DRIVER_TYPE driverType=driverChoiceConsole();
if (driverType==video::EDT_COUNT)
return 1;
// create device and exit if creation failed
MyEventReceiver receiver;
Device = createDevice(driverType, core::dimension2d<u32>(800, 600),
16, false, false, false, &receiver);
if (Device == 0)
return 1; // could not create selected driver.
Device->setResizable(true);
Device->setWindowCaption(L"Irrlicht Engine - Loading...");
video::IVideoDriver* driver = Device->getVideoDriver();
IGUIEnvironment* env = Device->getGUIEnvironment();
scene::ISceneManager* smgr = Device->getSceneManager();
smgr->getParameters()->setAttribute(scene::COLLADA_CREATE_SCENE_INSTANCES, true);
driver->setTextureCreationFlag(video::ETCF_ALWAYS_32_BIT, true);
smgr->addLightSceneNode(0, core::vector3df(200,200,200),
video::SColorf(1.0f,1.0f,1.0f),2000);
smgr->setAmbientLight(video::SColorf(0.3f,0.3f,0.3f));
// add our media directory as "search path"
Device->getFileSystem()->addFileArchive("../../media/");
/*
The next step is to read the configuration file. It is stored in the xml
format and looks a little bit like this:
@verbatim
<?xml version="1.0"?>
<config>
<startUpModel file="some filename" />
<messageText caption="Irrlicht Engine Mesh Viewer">
Hello!
</messageText>
</config>
@endverbatim
We need the data stored in there to be written into the global variables
StartUpModelFile, MessageText and Caption. This is now done using the
Irrlicht Engine integrated XML parser:
*/
// read configuration from xml file
io::IXMLReader* xml = Device->getFileSystem()->createXMLReader( L"config.xml");
while(xml && xml->read())
{
switch(xml->getNodeType())
{
case io::EXN_TEXT:
// in this xml file, the only text which occurs is the
// messageText
MessageText = xml->getNodeData();
break;
case io::EXN_ELEMENT:
{
if (core::stringw("startUpModel") == xml->getNodeName())
StartUpModelFile = xml->getAttributeValue(L"file");
else
if (core::stringw("messageText") == xml->getNodeName())
Caption = xml->getAttributeValue(L"caption");
}
break;
default:
break;
}
}
if (xml)
xml->drop(); // don't forget to delete the xml reader
if (argc > 1)
StartUpModelFile = argv[1];
/*
That wasn't difficult. Now we'll set a nicer font and create the Menu.
It is possible to create submenus for every menu item. The call
menu->addItem(L"File", -1, true, true); for example adds a new menu
Item with the name "File" and the id -1. The following parameter says
that the menu item should be enabled, and the last one says, that there
should be a submenu. The submenu can now be accessed with
menu->getSubMenu(0), because the "File" entry is the menu item with
index 0.
*/
// set a nicer font
IGUISkin* skin = env->getSkin();
IGUIFont* font = env->getFont("fonthaettenschweiler.bmp");
if (font)
skin->setFont(font);
// create menu
gui::IGUIContextMenu* menu = env->addMenu();
menu->addItem(L"File", -1, true, true);
menu->addItem(L"View", -1, true, true);
menu->addItem(L"Camera", -1, true, true);
menu->addItem(L"Help", -1, true, true);
gui::IGUIContextMenu* submenu;
submenu = menu->getSubMenu(0);
submenu->addItem(L"Open Model File & Texture...", GUI_ID_OPEN_MODEL);
submenu->addItem(L"Set Model Archive...", GUI_ID_SET_MODEL_ARCHIVE);
submenu->addItem(L"Load as Octree", GUI_ID_LOAD_AS_OCTREE);
submenu->addSeparator();
submenu->addItem(L"Quit", GUI_ID_QUIT);
submenu = menu->getSubMenu(1);
submenu->addItem(L"sky box visible", GUI_ID_SKY_BOX_VISIBLE, true, false, true);
submenu->addItem(L"toggle model debug information", GUI_ID_TOGGLE_DEBUG_INFO, true, true);
submenu->addItem(L"model material", -1, true, true );
submenu = submenu->getSubMenu(1);
submenu->addItem(L"Off", GUI_ID_DEBUG_OFF);
submenu->addItem(L"Bounding Box", GUI_ID_DEBUG_BOUNDING_BOX);
submenu->addItem(L"Normals", GUI_ID_DEBUG_NORMALS);
submenu->addItem(L"Skeleton", GUI_ID_DEBUG_SKELETON);
submenu->addItem(L"Wire overlay", GUI_ID_DEBUG_WIRE_OVERLAY);
submenu->addItem(L"Half-Transparent", GUI_ID_DEBUG_HALF_TRANSPARENT);
submenu->addItem(L"Buffers bounding boxes", GUI_ID_DEBUG_BUFFERS_BOUNDING_BOXES);
submenu->addItem(L"All", GUI_ID_DEBUG_ALL);
submenu = menu->getSubMenu(1)->getSubMenu(2);
submenu->addItem(L"Solid", GUI_ID_MODEL_MATERIAL_SOLID);
submenu->addItem(L"Transparent", GUI_ID_MODEL_MATERIAL_TRANSPARENT);
submenu->addItem(L"Reflection", GUI_ID_MODEL_MATERIAL_REFLECTION);
submenu = menu->getSubMenu(2);
submenu->addItem(L"Maya Style", GUI_ID_CAMERA_MAYA);
submenu->addItem(L"First Person", GUI_ID_CAMERA_FIRST_PERSON);
submenu = menu->getSubMenu(3);
submenu->addItem(L"About", GUI_ID_ABOUT);
/*
Below the menu we want a toolbar, onto which we can place colored
buttons and important looking stuff like a senseless combobox.
*/
// create toolbar
gui::IGUIToolBar* bar = env->addToolBar();
video::ITexture* image = driver->getTexture("open.png");
bar->addButton(GUI_ID_BUTTON_OPEN_MODEL, 0, L"Open a model",image, 0, false, true);
image = driver->getTexture("tools.png");
bar->addButton(GUI_ID_BUTTON_SHOW_TOOLBOX, 0, L"Open Toolset",image, 0, false, true);
image = driver->getTexture("zip.png");
bar->addButton(GUI_ID_BUTTON_SELECT_ARCHIVE, 0, L"Set Model Archive",image, 0, false, true);
image = driver->getTexture("help.png");
bar->addButton(GUI_ID_BUTTON_SHOW_ABOUT, 0, L"Open Help", image, 0, false, true);
// create a combobox for texture filters
gui::IGUIComboBox* box = env->addComboBox(core::rect<s32>(250,4,350,23), bar, GUI_ID_TEXTUREFILTER);
box->addItem(L"No filtering");
box->addItem(L"Bilinear");
box->addItem(L"Trilinear");
box->addItem(L"Anisotropic");
box->addItem(L"Isotropic");
/*
To make the editor look a little bit better, we disable transparent gui
elements, and add an Irrlicht Engine logo. In addition, a text showing
the current frames per second value is created and the window caption is
changed.
*/
// disable alpha
for (s32 i=0; i<gui::EGDC_COUNT ; ++i)
{
video::SColor col = env->getSkin()->getColor((gui::EGUI_DEFAULT_COLOR)i);
col.setAlpha(255);
env->getSkin()->setColor((gui::EGUI_DEFAULT_COLOR)i, col);
}
// add a tabcontrol
createToolBox();
// create fps text
IGUIStaticText* fpstext = env->addStaticText(L"",
core::rect<s32>(400,4,570,23), true, false, bar);
IGUIStaticText* postext = env->addStaticText(L"",
core::rect<s32>(10,50,470,80),false, false, 0, GUI_ID_POSITION_TEXT);
postext->setVisible(false);
// set window caption
Caption += " - [";
Caption += driver->getName();
Caption += "]";
Device->setWindowCaption(Caption.c_str());
/*
That's nearly the whole application. We simply show the about message
box at start up, and load the first model. To make everything look
better, a skybox is created and a user controled camera, to make the
application a little bit more interactive. Finally, everything is drawn
in a standard drawing loop.
*/
// show about message box and load default model
if (argc==1)
showAboutText();
loadModel(StartUpModelFile.c_str());
// add skybox
SkyBox = smgr->addSkyBoxSceneNode(
driver->getTexture("irrlicht2_up.jpg"),
driver->getTexture("irrlicht2_dn.jpg"),
driver->getTexture("irrlicht2_lf.jpg"),
driver->getTexture("irrlicht2_rt.jpg"),
driver->getTexture("irrlicht2_ft.jpg"),
driver->getTexture("irrlicht2_bk.jpg"));
// add a camera scene node
Camera[0] = smgr->addCameraSceneNodeMaya();
Camera[0]->setFarValue(20000.f);
// Maya cameras reposition themselves relative to their target, so target the location
// where the mesh scene node is placed.
Camera[0]->setTarget(core::vector3df(0,30,0));
Camera[1] = smgr->addCameraSceneNodeFPS();
Camera[1]->setFarValue(20000.f);
Camera[1]->setPosition(core::vector3df(0,0,-70));
Camera[1]->setTarget(core::vector3df(0,30,0));
setActiveCamera(Camera[0]);
// load the irrlicht engine logo
IGUIImage *img =
env->addImage(driver->getTexture("irrlichtlogo2.png"),
core::position2d<s32>(10, driver->getScreenSize().Height - 128));
// lock the logo's edges to the bottom left corner of the screen
img->setAlignment(EGUIA_UPPERLEFT, EGUIA_UPPERLEFT,
EGUIA_LOWERRIGHT, EGUIA_LOWERRIGHT);
// remember state so we notice when the window does lose the focus
bool hasFocus = Device->isWindowFocused();
// draw everything
while(Device->run() && driver)
{
// Catch focus changes (workaround until Irrlicht has events for this)
bool focused = Device->isWindowFocused();
if ( hasFocus && !focused )
onKillFocus();
hasFocus = focused;
if (Device->isWindowActive())
{
driver->beginScene(true, true, video::SColor(150,50,50,50));
smgr->drawAll();
env->drawAll();
driver->endScene();
// update information about current frame-rate
core::stringw str(L"FPS: ");
str.append(core::stringw(driver->getFPS()));
str += L" Tris: ";
str.append(core::stringw(driver->getPrimitiveCountDrawn()));
fpstext->setText(str.c_str());
// update information about the active camera
scene::ICameraSceneNode* cam = Device->getSceneManager()->getActiveCamera();
str = L"Pos: ";
str.append(core::stringw(cam->getPosition().X));
str += L" ";
str.append(core::stringw(cam->getPosition().Y));
str += L" ";
str.append(core::stringw(cam->getPosition().Z));
str += L" Tgt: ";
str.append(core::stringw(cam->getTarget().X));
str += L" ";
str.append(core::stringw(cam->getTarget().Y));
str += L" ";
str.append(core::stringw(cam->getTarget().Z));
postext->setText(str.c_str());
// update the tool dialog
updateToolBox();
}
else
Device->yield();
}
Device->drop();
return 0;
}
core::stringc CFileSystem::getAbsolutePath(const core::stringc& filename) const
{
c8 *p=0;
#ifdef _IRR_WINDOWS_API_
#if !defined ( _WIN32_WCE )
c8 fpath[_MAX_PATH];
p = _fullpath( fpath, filename.c_str(), _MAX_PATH);
#endif
#elif (defined(_IRR_POSIX_API_) || defined(_IRR_OSX_PLATFORM_))
c8 fpath[4096];
fpath[0]=0;
p = realpath(filename.c_str(), fpath);
if (!p)
{
// content in fpath is undefined at this point
if ('0'==fpath[0]) // seems like fpath wasn't altered
{
// at least remove a ./ prefix
if ('.'==filename[0] && '/'==filename[1])
return filename.subString(2, filename.size()-2);
else
return filename;
}
else
return core::stringc(fpath);
}
#endif
return core::stringc(p);
}
bool CSTLMeshWriter::writeMeshASCII(io::IWriteFile* file, scene::IMesh* mesh, s32 flags)
{
// write STL MESH header
file->write("solid ",6);
const core::stringc name(SceneManager->getMeshCache()->getMeshFilename(mesh));
file->write(name.c_str(),name.size());
file->write("\n\n",2);
// write mesh buffers
for (u32 i=0; i<mesh->getMeshBufferCount(); ++i)
{
IMeshBuffer* buffer = mesh->getMeshBuffer(i);
if (buffer)
{
const u16 indexCount = buffer->getIndexCount();
switch(buffer->getVertexType())
{
case video::EVT_STANDARD:
{
video::S3DVertex* vtx = (video::S3DVertex*)buffer->getVertices();
for (u32 j=0; j<indexCount; j+=3)
writeFace(file,
vtx[buffer->getIndices()[j]].Pos,
vtx[buffer->getIndices()[j+1]].Pos,
vtx[buffer->getIndices()[j+2]].Pos);
}
break;
case video::EVT_2TCOORDS:
{
video::S3DVertex2TCoords* vtx = (video::S3DVertex2TCoords*)buffer->getVertices();
for (u32 j=0; j<indexCount; j+=3)
writeFace(file,
vtx[buffer->getIndices()[j]].Pos,
vtx[buffer->getIndices()[j+1]].Pos,
vtx[buffer->getIndices()[j+2]].Pos);
}
break;
case video::EVT_TANGENTS:
{
video::S3DVertexTangents* vtx = (video::S3DVertexTangents*)buffer->getVertices();
for (u32 j=0; j<indexCount; j+=3)
writeFace(file,
vtx[buffer->getIndices()[j]].Pos,
vtx[buffer->getIndices()[j+1]].Pos,
vtx[buffer->getIndices()[j+2]].Pos);
}
break;
}
file->write("\n",1);
}
}
file->write("endsolid ",9);
file->write(name.c_str(),name.size());
return true;
}
bool CSTLMeshWriter::writeMeshASCII(io::IWriteFile* file, scene::IMesh* mesh, s32 flags)
{
// write STL MESH header
file->write("solid ",6);
const core::stringc name(SceneManager->getMeshCache()->getMeshName(mesh));
file->write(name.c_str(),name.size());
file->write("\n\n",2);
// write mesh buffers
for (u32 i=0; i<mesh->getMeshBufferCount(); ++i)
{
IMeshBuffer* buffer = mesh->getMeshBuffer(i);
if (buffer)
{
const u32 indexCount = buffer->getIndexCount();
for (u32 j=0; j<indexCount; j+=3)
{
writeFace(file,
buffer->getPosition(buffer->getIndices()[j]),
buffer->getPosition(buffer->getIndices()[j+1]),
buffer->getPosition(buffer->getIndices()[j+2]));
}
file->write("\n",1);
}
}
file->write("endsolid ",9);
file->write(name.c_str(),name.size());
return true;
}
const c8* CTextSceneNode::getSceneCorePropertiesXMLString()
{
core::stringc str;
static core::stringc xmlstr;
xmlstr = "";
if (getMaterialsCount() == 1)
{
const c8* mat_xml = SCENE_MANAGER.getMaterialXMLText(getMaterial(0));
xmlstr.append(mat_xml);
}
str.sprintf(
"<Font filename=\"%s\" size=\"%d/\" />\n",
m_Font->getFileName(), m_Font->getSize()
);
xmlstr.append(str);
str.sprintf(
"<Text value=\"%s\" />\n",
core::stringc(getText()).c_str()
);
xmlstr.append(str);
img::SColor c = getTextColor();
str.sprintf(
"<TextColor value=\"%d,%d,%d,%d\" />\n",
c.getRed(), c.getGreen(), c.getBlue(), c.getAlpha()
);
xmlstr.append(str);
return xmlstr.c_str();
}
//! deletes the path from a filename
void CPakReader::deletePathFromFilename(core::stringc& filename)
{
// delete path from filename
const c8* p = filename.c_str() + filename.size();
// search for path separator or beginning
while (*p!='/' && *p!='\\' && p!=filename.c_str())
--p;
if (p != filename.c_str())
{
++p;
filename = p;
}
}
bool CSTLMeshWriter::writeMeshBinary(io::IWriteFile* file, scene::IMesh* mesh, s32 flags)
{
// write STL MESH header
file->write("binary ",7);
const core::stringc name(SceneManager->getMeshCache()->getMeshName(mesh));
const s32 sizeleft = 73-name.size(); // 80 byte header
if (sizeleft<0)
file->write(name.c_str(),73);
else
{
char* buf = new char[80];
memset(buf, 0, 80);
file->write(name.c_str(),name.size());
file->write(buf,sizeleft);
delete [] buf;
}
u32 facenum = 0;
for (u32 j=0; j<mesh->getMeshBufferCount(); ++j)
facenum += mesh->getMeshBuffer(j)->getIndexCount()/3;
file->write(&facenum,4);
// write mesh buffers
for (u32 i=0; i<mesh->getMeshBufferCount(); ++i)
{
IMeshBuffer* buffer = mesh->getMeshBuffer(i);
if (buffer)
{
const u32 indexCount = buffer->getIndexCount();
const u16 attributes = 0;
for (u32 j=0; j<indexCount; j+=3)
{
const core::vector3df& v1 = buffer->getPosition(buffer->getIndices()[j]);
const core::vector3df& v2 = buffer->getPosition(buffer->getIndices()[j+1]);
const core::vector3df& v3 = buffer->getPosition(buffer->getIndices()[j+2]);
const core::plane3df tmpplane(v1,v2,v3);
file->write(&tmpplane.Normal, 12);
file->write(&v1, 12);
file->write(&v2, 12);
file->write(&v3, 12);
file->write(&attributes, 2);
}
}
}
return true;
}
CShaderMaterial::CShaderMaterial(IrrlichtDevice* device, const core::stringc& name,
io::path vsFile, core::stringc vsEntry, video::E_VERTEX_SHADER_TYPE vsType,
io::path psFile, core::stringc psEntry, video::E_PIXEL_SHADER_TYPE psType,
video::E_MATERIAL_TYPE baseMaterial) : Device(device), Name(name), PixelShaderFlags(0), VertexShaderFlags(0)
{
s32 userdata = 0;
io::path vsPath;
io::path psPath;
// log action
core::stringc msg = core::stringc("compiling material ") + name;
Device->getLogger()->log(msg.c_str(), ELL_INFORMATION);
// create destination path for (driver specific) shader files
if(Device->getVideoDriver()->getDriverType() == video::EDT_OPENGL)
{
vsPath = core::stringc("./shaders/glsl/") + vsFile;
psPath = core::stringc("./shaders/glsl/") + psFile;
userdata = 1;
}
if(Device->getVideoDriver()->getDriverType() == video::EDT_DIRECT3D9)
{
vsPath=core::stringc("./shaders/hlsl/") + vsFile;
psPath=core::stringc("./shaders/hlsl/") + psFile;
userdata = 0;
}
// create shader material
video::IGPUProgrammingServices* gpu = Device->getVideoDriver()->getGPUProgrammingServices();
s32 matID = gpu->addHighLevelShaderMaterialFromFiles(
vsPath, vsEntry.c_str(), vsType,
psPath, psEntry.c_str(), psType,
this, baseMaterial, userdata);
// set material type
Material.MaterialType = (video::E_MATERIAL_TYPE)matID;
// set the default texturenames and texture wrap
// these are overridden by the effect.xml configuration
for (u32 i=0; i<video::MATERIAL_MAX_TEXTURES; ++i)
{
TextureName[i] = core::stringc("texture") + core::stringc(i);
Material.TextureLayer[i].TextureWrapU = video::ETC_REPEAT;
Material.TextureLayer[i].TextureWrapV = video::ETC_REPEAT;
}
}
s32 PlayerManager::getStatAsInteger(const core::stringw& key) const
{
const core::stringc s = getStat(key);
if (s.empty())
return 0;
return core::strtol10(s.c_str());
}
//! deletes the path from a filename
void CPakReader::deletePathFromFilename(core::stringc& filename)
{
// delete path from filename
const c8* p = filename.c_str() + filename.size();
// suche ein slash oder den anfang.
while (*p!='/' && *p!='\\' && p!=filename.c_str())
--p;
core::stringc newName;
if (p != filename.c_str())
{
++p;
filename = p;
}
}
Address::Address(core::stringc addr, core::stringc port)
: resRoot(0), resActive(0)
{
Startup();
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_protocol = SOCK_STREAM;
int error = 0;
error = getaddrinfo(addr.c_str(), port.c_str() , &hints, &resRoot);
if(error)
{
printf("getaddrinfo failed... %s %s %s\n", addr.c_str(), port.c_str(), gai_strerror(error));
freeaddrinfo(resRoot);
resRoot = resActive = 0;
return;
}
};
/**
* Check if we already have a config object for gamepad 'irr_id' as reported by
* irrLicht, If no, create one. Returns true if new configuration was created,
* otherwise false.
*/
bool DeviceManager::getConfigForGamepad(const int irr_id,
const core::stringc& name,
GamepadConfig **config)
{
bool found = false;
bool configCreated = false;
// Find appropriate configuration
for(unsigned int n=0; n < m_gamepad_configs.size(); n++)
{
if(m_gamepad_configs[n].getName() == name.c_str())
{
*config = m_gamepad_configs.get(n);
found = true;
}
}
// If we can't find an appropriate configuration then create one.
if (!found)
{
if(irr_id < (int)(m_irrlicht_gamepads.size()))
{
*config = new GamepadConfig( name.c_str(),
m_irrlicht_gamepads[irr_id].Axes,
m_irrlicht_gamepads[irr_id].Buttons );
}
#ifdef ENABLE_WIIUSE
else // Wiimotes have a higher ID and do not refer to m_irrlicht_gamepads
{
// The Wiimote manager will set number of buttons and axis
*config = new GamepadConfig(name.c_str());
}
#endif
// Add new config to list
m_gamepad_configs.push_back(*config);
configCreated = true;
}
return configCreated;
}
core::stringc CFileSystem::getAbsolutePath(const core::stringc& filename) const
{
c8 *p=0;
core::stringc ret;
#ifdef _IRR_WINDOWS_API_
c8 fpath[_MAX_PATH];
p = _fullpath( fpath, filename.c_str(), _MAX_PATH);
ret = p;
#elif (defined(_IRR_POSIX_API_) || defined(MACOSX))
c8 fpath[4096];
p = realpath(filename.c_str(), fpath);
ret = p;
#endif
return ret;
}
bool CGUISkinSystem::populateTreeView(gui::IGUITreeView *control,const core::stringc& skinname) {
bool ret = false;
io::path oldpath = fs->getWorkingDirectory();
fs->changeWorkingDirectoryTo(skinsPath);
registry = new CXMLRegistry(fs);
if(!registry->loadFile(SKINSYSTEM_SKINFILE,skinname.c_str())) {
return ret;
}
ret = registry->populateTreeView(control);
delete registry;
registry = NULL;
fs->changeWorkingDirectoryTo(oldpath);
return ret;
}
//! sets the caption of the window
void CIrrDeviceWin32::setWindowCaption(const wchar_t* text)
{
DWORD dwResult;
if (IsNonNTWindows)
{
const core::stringc s = text;
SendMessageTimeout(HWnd, WM_SETTEXT, 0,
reinterpret_cast<LPARAM>(s.c_str()),
SMTO_ABORTIFHUNG, 2000, &dwResult);
}
else
SendMessageTimeoutW(HWnd, WM_SETTEXT, 0,
reinterpret_cast<LPARAM>(text),
SMTO_ABORTIFHUNG, 2000, &dwResult);
}
//!
const c8* CTestSceneNode::getSceneCorePropertiesXMLString()
{
static core::stringc xmlstr;
xmlstr = "";
if (getMaterialsCount() == 1)
{
const c8* mat_xml = SCENE_MANAGER.getMaterialXMLText(getMaterial(0));
xmlstr.append(mat_xml);
}
xmlstr.sprintf("<GeomPrimitive type=\"%s\" />\n",
GeomPrimitiveTypeStr[m_GeomPrimitiveType]);
return xmlstr.c_str();
}
void Translation::loadTextData(const core::stringc& fullPath)
{
//cout << "Translation file loaded : " << fullPath.c_str() << endl;
wifstream textFile(fullPath.c_str(), ios::in);
if (textFile) {
//cout << "Processing translation file..." << endl;
wchar_t currentChar;
bool inTextIdentifier = true;
bool inTextValue = false;
core::stringc identifier = "";
core::stringw value = L"";
while (textFile.get(currentChar)) {
if (currentChar == '\n' || currentChar == '\r') {
// Nouvelle traduction
if (identifier != "") {
//cout << "Added translation (" << identifier.c_str() << ") = (" << value.c_str() << ")" << endl;
textData[identifier] = value;
}
identifier = "";
value = L"";
inTextValue = false;
inTextIdentifier = true;
} else {
if (inTextValue) {
value.append(currentChar);
}
if (inTextIdentifier) {
if (currentChar == '=') {
// Passage de l'identifiant a la valeur
inTextIdentifier = false;
inTextValue = true;
} else {
identifier.append(currentChar);
}
}
}
}
textFile.close();
}
}
core::stringc CHashMD5::quickHash(core::stringc str)
{
hash_start();
hash_append((u8*)str.c_str(), str.size());
u8 digest[16];
hash_finish(digest, 16);
c8 retstr[33];
memset(retstr, 0, 33);
c8* temp = retstr;
for(int i = 0; i < 16; i++)
{
if((digest[i] & 0xff) > 0xf){
sprintf(temp, "%x", (digest[i] & 0xff));
}else{
sprintf(temp, "0%x", (digest[i] & 0xff));
}
temp += 2;
}
core::stringc ret(retstr);
return ret;
};
void World::SetSkyBox(const core::stringc &top, const core::stringc &bottom, const core::stringc &left,
const core::stringc &right, const core::stringc &front, const core::stringc &back)
{
scene::ISceneManager *smgr = engine->GetIrrlichtDevice()->getSceneManager();
video::IVideoDriver *driver = engine->GetIrrlichtDevice()->getVideoDriver();
if (skyBoxNode)
skyBoxNode->remove();
skyBoxNode = smgr->addSkyBoxSceneNode(
driver->getTexture( top.c_str() ),
driver->getTexture( bottom.c_str() ),
driver->getTexture( left.c_str() ),
driver->getTexture( right.c_str() ),
driver->getTexture( front.c_str() ),
driver->getTexture( back.c_str() )
);
SetSkyBoxShader(skyBoxShader);
}
bool CSTLMeshWriter::writeMeshBinary(io::IWriteFile* file, scene::IMesh* mesh, s32 flags)
{
// write STL MESH header
file->write("binary ",7);
const core::stringc name(SceneManager->getMeshCache()->getMeshFilename(mesh));
const s32 sizeleft = 73-name.size(); // 80 byte header
if (sizeleft<0)
file->write(name.c_str(),73);
else
{
char* buf = new char[80];
memset(buf, 0, 80);
file->write(name.c_str(),name.size());
file->write(buf,sizeleft);
delete [] buf;
}
u32 facenum = 0;
for (u32 j=0; j<mesh->getMeshBufferCount(); ++j)
facenum += mesh->getMeshBuffer(j)->getIndexCount()/3;
file->write(&facenum,4);
// write mesh buffers
for (u32 i=0; i<mesh->getMeshBufferCount(); ++i)
{
IMeshBuffer* buffer = mesh->getMeshBuffer(i);
if (buffer)
{
const u16 indexCount = buffer->getIndexCount();
switch(buffer->getVertexType())
{
case video::EVT_STANDARD:
{
video::S3DVertex* vtx = (video::S3DVertex*)buffer->getVertices();
const u16 attributes = 0;
for (u32 j=0; j<indexCount; j+=3)
{
file->write(&core::plane3df(vtx[buffer->getIndices()[j]].Pos,vtx[buffer->getIndices()[j+1]].Pos,vtx[buffer->getIndices()[j+2]].Pos).Normal, 12);
file->write(&vtx[buffer->getIndices()[j]].Pos, 12);
file->write(&vtx[buffer->getIndices()[j+1]].Pos, 12);
file->write(&vtx[buffer->getIndices()[j+2]].Pos, 12);
file->write(&attributes, 2);
}
}
break;
case video::EVT_2TCOORDS:
{
video::S3DVertex2TCoords* vtx = (video::S3DVertex2TCoords*)buffer->getVertices();
const u16 attributes = 0;
for (u32 j=0; j<indexCount; j+=3)
{
file->write(&core::plane3df(vtx[buffer->getIndices()[j]].Pos,vtx[buffer->getIndices()[j+1]].Pos,vtx[buffer->getIndices()[j+2]].Pos).Normal, 12);
file->write(&vtx[buffer->getIndices()[j]].Pos, 12);
file->write(&vtx[buffer->getIndices()[j+1]].Pos, 12);
file->write(&vtx[buffer->getIndices()[j+2]].Pos, 12);
file->write(&attributes, 2);
}
}
break;
case video::EVT_TANGENTS:
{
video::S3DVertexTangents* vtx = (video::S3DVertexTangents*)buffer->getVertices();
const u16 attributes = 0;
for (u32 j=0; j<indexCount; j+=3)
{
file->write(&core::plane3df(vtx[buffer->getIndices()[j]].Pos,vtx[buffer->getIndices()[j+1]].Pos,vtx[buffer->getIndices()[j+2]].Pos).Normal, 12);
file->write(&vtx[buffer->getIndices()[j]].Pos, 12);
file->write(&vtx[buffer->getIndices()[j+1]].Pos, 12);
file->write(&vtx[buffer->getIndices()[j+2]].Pos, 12);
file->write(&attributes, 2);
}
}
break;
}
}
}
return true;
}
void GameMapDescription::Load(core::stringc fn)
{
GameLog("Map description %s loading started...", fn.c_str());
io::IXMLReader *xml = Game.FS->createXMLReader(fn.c_str());
for (int i=0; i < GAMEMAPDESCRIPTION_MAXDESCCOUNT; i++)
{
Items[i].keycount = 0;
for (int k=0; k < GAMEMAPDESCRIPTION_MAXKEYCOUNT; k++) Items[i].key[k] = "";
Items[i].title = "";
Items[i].desc = "";
}
ItemsCount = 0;
while( xml && xml->read() )
{
core::stringc node = xml->getNodeName();
if (node == L"item")
{
switch (xml->getNodeType())
{
case io::EXN_ELEMENT_END:
ItemsCount++;
break;
case io::EXN_ELEMENT:
Items[ItemsCount].keycount = 0;
while(xml && xml->read())
{
core::stringc node2 = xml->getNodeName();
if (xml->getNodeType() == io::EXN_ELEMENT_END &&
node == L"item")
{
break;
}
if (xml->getNodeType() == io::EXN_TEXT)
{
Items[ItemsCount].desc = xml->getNodeData();
}
if (node2 == L"title")
{
Items[ItemsCount].title =
xml->getAttributeValue(L"value");
}
if (node2 == L"key")
{
Items[ItemsCount].key[Items[ItemsCount].keycount++] =
xml->getAttributeValue(L"value");
}
assert( Items[ItemsCount].keycount < GAMEMAPDESCRIPTION_MAXKEYCOUNT );
}
break;
}
}
}
xml->drop();
GameLog("Map description loaded.");
}
//! writes a mesh
bool COBJMeshWriter::writeMesh(io::IWriteFile* file, scene::IMesh* mesh, s32 flags)
{
if (!file)
return false;
os::Printer::log("Writing mesh", file->getFileName());
// write OBJ MESH header
const core::stringc name(FileSystem->getFileBasename(SceneManager->getMeshCache()->getMeshName(mesh), false)+".mtl");
file->write("# exported by Irrlicht\n",23);
file->write("mtllib ",7);
file->write(name.c_str(),name.size());
file->write("\n\n",2);
// write mesh buffers
core::array<video::SMaterial*> mat;
u32 allVertexCount=1; // count vertices over the whole file
for (u32 i=0; i<mesh->getMeshBufferCount(); ++i)
{
core::stringc num(i+1);
IMeshBuffer* buffer = mesh->getMeshBuffer(i);
if (buffer && buffer->getVertexCount())
{
file->write("g grp", 5);
file->write(num.c_str(), num.size());
file->write("\n",1);
u32 j;
const u32 vertexCount = buffer->getVertexCount();
for (j=0; j<vertexCount; ++j)
{
file->write("v ",2);
getVectorAsStringLine(buffer->getPosition(j), num);
file->write(num.c_str(), num.size());
}
for (j=0; j<vertexCount; ++j)
{
file->write("vt ",3);
getVectorAsStringLine(buffer->getTCoords(j), num);
file->write(num.c_str(), num.size());
}
for (j=0; j<vertexCount; ++j)
{
file->write("vn ",3);
getVectorAsStringLine(buffer->getNormal(j), num);
file->write(num.c_str(), num.size());
}
file->write("usemtl mat",10);
num = "";
for (j=0; j<mat.size(); ++j)
{
if (*mat[j]==buffer->getMaterial())
{
num = core::stringc(j);
break;
}
}
if (num == "")
{
num = core::stringc(mat.size());
mat.push_back(&buffer->getMaterial());
}
file->write(num.c_str(), num.size());
file->write("\n",1);
const u32 indexCount = buffer->getIndexCount();
for (j=0; j<indexCount; j+=3)
{
file->write("f ",2);
num = core::stringc(buffer->getIndices()[j+2]+allVertexCount);
file->write(num.c_str(), num.size());
file->write("/",1);
file->write(num.c_str(), num.size());
file->write("/",1);
file->write(num.c_str(), num.size());
file->write(" ",1);
num = core::stringc(buffer->getIndices()[j+1]+allVertexCount);
file->write(num.c_str(), num.size());
file->write("/",1);
file->write(num.c_str(), num.size());
file->write("/",1);
file->write(num.c_str(), num.size());
file->write(" ",1);
num = core::stringc(buffer->getIndices()[j+0]+allVertexCount);
file->write(num.c_str(), num.size());
file->write("/",1);
file->write(num.c_str(), num.size());
file->write("/",1);
file->write(num.c_str(), num.size());
file->write(" ",1);
file->write("\n",1);
}
file->write("\n",1);
allVertexCount += vertexCount;
}
}
if (mat.size() == 0)
return true;
file = FileSystem->createAndWriteFile( name );
if (file)
{
os::Printer::log("Writing material", file->getFileName());
file->write("# exported by Irrlicht\n\n",24);
for (u32 i=0; i<mat.size(); ++i)
{
core::stringc num(i);
file->write("newmtl mat",10);
file->write(num.c_str(),num.size());
file->write("\n",1);
getColorAsStringLine(mat[i]->AmbientColor, "Ka", num);
file->write(num.c_str(),num.size());
getColorAsStringLine(mat[i]->DiffuseColor, "Kd", num);
file->write(num.c_str(),num.size());
getColorAsStringLine(mat[i]->SpecularColor, "Ks", num);
file->write(num.c_str(),num.size());
getColorAsStringLine(mat[i]->EmissiveColor, "Ke", num);
file->write(num.c_str(),num.size());
num = core::stringc(mat[i]->Shininess/0.128f);
file->write("Ns ", 3);
file->write(num.c_str(),num.size());
file->write("\n", 1);
if (mat[i]->getTexture(0))
{
file->write("map_Kd ", 7);
file->write(mat[i]->getTexture(0)->getName().getPath().c_str(), mat[i]->getTexture(0)->getName().getPath().size());
file->write("\n",1);
}
file->write("\n",1);
}
file->drop();
}
return true;
}
CUnzipReadFile ( const core::stringc &realName, const c8 * hashName )
: CReadFile( realName.c_str ())
{
CallFileName = hashName;
}
//! PreProcesses a shader using Irrlicht's built-in shader preprocessor.
core::stringc CShaderPreprocessor::ppShaderFF(core::stringc shaderProgram)
{
return ppShader(getFileContent(shaderProgram.c_str()).c_str());
}
