bool MetaFileSystem::MkDir(const std::string &dirname)
{
std::lock_guard<std::recursive_mutex> guard(lock);
std::string of;
IFileSystem *system;
if (MapFilePath(dirname, of, &system))
{
return system->MkDir(of);
}
else
{
return false;
}
}
bool MetaFileSystem::RenameFile(const std::string &from, const std::string &to)
{
std::string of;
std::string rf;
IFileSystem *system;
if (MapFilePath(from, of, &system) && MapFilePath(to, rf, &system))
{
return system->RenameFile(of, rf);
}
else
{
return false;
}
}
std::vector<PSPFileInfo> MetaFileSystem::GetDirListing(std::string path)
{
std::string of;
IFileSystem *system;
if (MapFilePath(path, of, &system))
{
return system->GetDirListing(of);
}
else
{
std::vector<PSPFileInfo> empty;
return empty;
}
}
bool MetaFileSystem::RmDir(const std::string &dirname)
{
lock_guard guard(lock);
std::string of;
IFileSystem *system;
if (MapFilePath(dirname, of, &system))
{
return system->RmDir(of);
}
else
{
return false;
}
}
PSPFileInfo MetaFileSystem::GetFileInfo(std::string filename)
{
std::string of;
IFileSystem *system;
if (MapFilePath(filename, of, &system))
{
return system->GetFileInfo(of);
}
else
{
PSPFileInfo bogus; // TODO
return bogus;
}
}
bool MetaFileSystem::RemoveFile(const std::string &filename)
{
lock_guard guard(lock);
std::string of;
IFileSystem *system;
if (MapFilePath(filename, of, &system))
{
return system->RemoveFile(of);
}
else
{
return false;
}
}
std::vector<FileInfo> MetaFileSystem::GetDirListing(std::string path)
{
std::lock_guard<std::recursive_mutex> guard(lock);
std::string of;
IFileSystem *system;
if (MapFilePath(path, of, &system))
{
return system->GetDirListing(of);
}
else
{
std::vector<FileInfo> empty;
return empty;
}
}
IFileSystem* CreateFileSystem(const IVolume* _rVolume)
{
IFileSystem* pFileSystem = new CFileSystemGCWii(_rVolume);
if (!pFileSystem)
return nullptr;
if (!pFileSystem->IsValid())
{
delete pFileSystem;
pFileSystem = nullptr;
}
return pFileSystem;
}
FileInfo MetaFileSystem::GetFileInfo(std::string filename)
{
std::lock_guard<std::recursive_mutex> guard(lock);
std::string of;
IFileSystem *system;
if (MapFilePath(filename, of, &system))
{
return system->GetFileInfo(of);
}
else
{
FileInfo bogus; // TODO
return bogus;
}
}
bool
CMNGAnimation::Load(const char* filename, IFileSystem& fs)
{
this->~CMNGAnimation();
// open the file
m_file = fs.Open(filename, IFileSystem::read);
if (m_file == NULL) {
return false;
}
// initialize MNG playback
m_stream = mng_initialize(this, CB_Allocate, CB_Free, NULL);
// set all of the callbacks
mng_setcb_openstream(m_stream, CB_OpenStream);
mng_setcb_closestream(m_stream, CB_CloseStream);
mng_setcb_readdata(m_stream, CB_ReadData);
mng_setcb_processheader(m_stream, CB_ProcessHeader);
mng_setcb_gettickcount(m_stream, CB_GetTickCount);
mng_setcb_getcanvasline(m_stream, CB_GetCanvasLine);
mng_setcb_refresh(m_stream, CB_Refresh);
mng_setcb_settimer(m_stream, CB_SetTimer);
// do some reading
if (mng_read(m_stream) != MNG_NOERROR) {
return false;
}
return true;
}
bool
CConfigFile::Load(const char* filename, IFileSystem& fs)
{
m_sections.erase(m_sections.begin(), m_sections.end());
// open the file
IFile* file = fs.Open(filename, IFileSystem::read);
if (file == NULL) {
return false;
}
std::string current_section = "";
bool eof = false;
while (!eof) {
// read a line
std::string line;
eof = !read_line(file, line);
const char* string = line.c_str();
// parse it
// eliminate whitespace
skip_whitespace(string);
if (string[0] == '[') { // it's a section
string++;
current_section = "";
while (*string != ']') {
current_section += *string++;
}
string++;
} else { // it's a key=value pair
// read key
std::string key;
while (*string != '=' && *string) {
key += *string++;
}
if (*string == 0) {
continue; // skip lines without equals
}
string++; // skip the '='
std::string value;
while (*string) {
value += *string++;
}
// add the item
WriteString(current_section.c_str(), key.c_str(), value.c_str());
}
}
file->Close();
return true;
}
bool
sTileset::Load(const char* filename, IFileSystem& fs)
{
IFile* file = fs.Open(filename, IFileSystem::read);
if (file == NULL)
return false;
bool result = LoadFromFile(file);
file->Close();
return result;
}
void PrintDetailedPlayerClassStats()
{
if ( !tf_DetailedStats.GetInt() )
return;
IFileSystem *pFileSys = filesystem;
FileHandle_t hFile = pFileSys->Open( "class_stats_detailed.txt", "wt", "LOGDIR" );
if ( hFile != FILESYSTEM_INVALID_HANDLE )
{
// Print the header.
for ( int i=TFCLASS_UNDECIDED+1; i < STATS_NUM_GROUPS; i++ )
{
pFileSys->FPrintf( hFile, "%s dist\t%s dmg\t", GetGroupNameFor( i ), GetGroupNameFor( i ) );
}
pFileSys->FPrintf( hFile, "\n" );
// Write out each column.
int iterators[STATS_NUM_GROUPS];
for ( i=TFCLASS_UNDECIDED+1; i < STATS_NUM_GROUPS; i++ )
iterators[i] = g_ClassShotInfos[i].Head();
bool bWroteAnything;
do
{
bWroteAnything = false;
for ( int i=TFCLASS_UNDECIDED+1; i < STATS_NUM_GROUPS; i++ )
{
if ( iterators[i] == g_ClassShotInfos[i].InvalidIndex() )
{
pFileSys->FPrintf( hFile, "\t\t" );
}
else
{
CShotInfo *pInfo = &g_ClassShotInfos[i][iterators[i]];
iterators[i] = g_ClassShotInfos[i].Next( iterators[i] );
pFileSys->FPrintf( hFile, "%.2f\t%d\t", pInfo->m_flDistance, pInfo->m_nDamage );
bWroteAnything = true;
}
}
pFileSys->FPrintf( hFile, "\n" );
} while ( bWroteAnything );
pFileSys->Close( hFile );
}
}
bool
sTileset::Save(const char* filename, IFileSystem& fs) const
{
// open the file
IFile* file = fs.Open(filename, IFileSystem::write);
if (file == NULL)
return false;
bool result = SaveToFile(file);
file->Close();
return result;
}
bool
CConfigFile::Save(const char* filename, IFileSystem& fs) const
{
IFile* file = fs.Open(filename, IFileSystem::write);
if (file == NULL) {
return false;
}
// find the section without a name and write that first
std::map<std::string, Section>::const_iterator i;
for (i = m_sections.begin(); i != m_sections.end(); i++) {
if (i->first == "") {
const Section& s = i->second;
std::map<std::string, std::string>::const_iterator j;
for (j = s.entries.begin(); j != s.entries.end(); j++) {
write_string(file, j->first);
file->Write("=", 1);
write_string(file, j->second);
file->Write("\n", 1);
}
file->Write("\n", 1);
}
}
// write the rest of the sections
for (i = m_sections.begin(); i != m_sections.end(); i++) {
if (i->first != "") {
file->Write("[", 1);
write_string(file, i->first);
file->Write("]\n", 2);
const Section& s = i->second;
std::map<std::string, std::string>::const_iterator j;
for (j = s.entries.begin(); j != s.entries.end(); j++) {
write_string(file, j->first);
file->Write("=", 1);
write_string(file, j->second);
file->Write("\n", 1);
}
file->Write("\n", 1);
}
}
file->Close();
return true;
}
CString WindowManager::LoadJson(IFileSystem& fileSystem, const CString& cszRelativeFilename)
{
std::shared_ptr<Stream::IStream> spStream =
fileSystem.OpenFile(cszRelativeFilename, true);
Stream::TextStreamFilter stream(*spStream,
Stream::ITextStream::textEncodingAnsi,
Stream::ITextStream::lineEndingNative);
CString cszLine, cszText;
while (!stream.AtEndOfStream())
{
stream.ReadLine(cszLine);
cszText += cszLine;
cszText += _T("\r\n");
}
return cszText;
}
void MetaFileSystem::CloseFile(u32 handle)
{
IFileSystem *sys = GetHandleOwner(handle);
if (sys)
sys->CloseFile(handle);
}
// Operations dealing with encrypted space are done here - the volume is swapped to allow this
bool ParsePartitionData(SPartition& _rPartition)
{
bool ParsedOK = true;
// Switch out the main volume temporarily
IVolume *OldVolume = m_Disc;
// Ready some stuff
m_Disc = CreateVolumeFromFilename(m_Filename, _rPartition.GroupNumber, _rPartition.Number);
IFileSystem *FileSystem = CreateFileSystem(m_Disc);
if (!FileSystem)
{
ERROR_LOG(DISCIO, "Failed to create filesystem for group %d partition %u", _rPartition.GroupNumber, _rPartition.Number);
ParsedOK = false;
}
else
{
std::vector<const SFileInfo *> Files;
size_t numFiles = FileSystem->GetFileList(Files);
// Mark things as used which are not in the filesystem
// Header, Header Information, Apploader
ReadFromVolume(0x2440 + 0x14, 4, _rPartition.Header.ApploaderSize);
ReadFromVolume(0x2440 + 0x18, 4, _rPartition.Header.ApploaderTrailerSize);
MarkAsUsedE(_rPartition.Offset
+ _rPartition.Header.DataOffset
, 0
, 0x2440
+ _rPartition.Header.ApploaderSize
+ _rPartition.Header.ApploaderTrailerSize);
// DOL
ReadFromVolume(0x420, 4, _rPartition.Header.DOLOffset);
_rPartition.Header.DOLSize = GetDOLSize(_rPartition.Header.DOLOffset);
MarkAsUsedE(_rPartition.Offset
+ _rPartition.Header.DataOffset
, _rPartition.Header.DOLOffset
, _rPartition.Header.DOLSize);
// FST
ReadFromVolume(0x424, 4, _rPartition.Header.FSTOffset);
ReadFromVolume(0x428, 4, _rPartition.Header.FSTSize);
MarkAsUsedE(_rPartition.Offset
+ _rPartition.Header.DataOffset
, _rPartition.Header.FSTOffset
, _rPartition.Header.FSTSize);
// Go through the filesystem and mark entries as used
for (size_t currentFile = 0; currentFile < numFiles; currentFile++)
{
DEBUG_LOG(DISCIO, "%s", currentFile ? (*Files.at(currentFile)).m_FullPath : "/");
// Just 1byte for directory? - it will end up reserving a cluster this way
if ((*Files.at(currentFile)).m_NameOffset & 0x1000000)
MarkAsUsedE(_rPartition.Offset
+ _rPartition.Header.DataOffset
, (*Files.at(currentFile)).m_Offset, 1);
else
MarkAsUsedE(_rPartition.Offset
+ _rPartition.Header.DataOffset
, (*Files.at(currentFile)).m_Offset, (*Files.at(currentFile)).m_FileSize);
}
}
delete FileSystem;
// Swap back
delete m_Disc;
m_Disc = OldVolume;
return ParsedOK;
}
bool CShaderHLSL::Create(P3D::sShaderDesc &desc)
{
const char *pData;
ULONG fsize;
IFileSystem* pFS = CRenderer::mEngine()->mFilesystem();
wchar path[P3DMAX_PATH];
wsprintf(path, P3DMAX_PATH-1, _W("shaders/%s.rshader"), desc.ShaderFile.Get());
FSFILE *fp = pFS->Load(path, (BYTE *&)pData, fsize, true);
if (!fp)
{
CON(MSG_ERR, _W("Can't open %s.hlsl shader file from data/shaders directory!"), desc.ShaderFile.Get());
return false;
}
ID3DXBuffer *pShaderBlob = NULL;
ID3DXBuffer *pErrors = NULL;
DWORD flags = D3DXSHADER_DEBUG; //D3DXSHADER_OPTIMIZATION_LEVEL3
char profile[128];
switch(desc.ShaderType)
{
case SHADERTYPE_VERTEX_SHADER:
strcpy(profile, D3DXGetVertexShaderProfile(g_pD3ddev));
break;
case SHADERTYPE_PIXEL_SHADER:
strcpy(profile, D3DXGetPixelShaderProfile(g_pD3ddev));
break;
case SHADERTYPE_GEOMETRY_SHADER:
CON(MSG_ERR, _W("DX9 does not support geometry shaders."));
return false;
default:
CON(MSG_ERR, _W("Chader creation failed. No apropriate ShaderType given."));
return false;
}
CIncludeHandler includeHandler;
D3DXMACRO Shader_Macros[] =
{
{ "DX9", NULL },
{ "SM3", NULL },
NULL
};
if(FAILED(D3DXCompileShader(
pData,
fsize,
Shader_Macros,
&includeHandler,
_W2A(desc.EntryFunction.Get()),
profile,
flags,
&pShaderBlob,
&pErrors,
&m_pConstTable
)))
{
if(pErrors) CON(MSG_ERR, _W("%s"), _A2W((char*)pErrors->GetBufferPointer()));
else CON(MSG_ERR, _W("Error description not given"));
CON(MSG_ERR, _W("Shader %s could not be compiled"), desc.ShaderFile.Get());
SAFE_RELEASE(pErrors);
return false;
}
pFS->UnLoad(fp, (BYTE *)pData);
//save to cache
fp = pFS->Open(_W("cache/shaders/hlsl"), _W("wb"));
const char* cs = (const char*)pShaderBlob->GetBufferPointer();
pFS->Write(cs, 1, pShaderBlob->GetBufferSize(), fp);
pFS->Close(fp);
bool shaderCreated = false;
switch(desc.ShaderType)
{
case SHADERTYPE_VERTEX_SHADER:
shaderCreated = SUCCEEDED(g_pD3ddev->CreateVertexShader((const DWORD*)pShaderBlob->GetBufferPointer(), &m_pVS));
break;
case SHADERTYPE_PIXEL_SHADER:
shaderCreated = SUCCEEDED(g_pD3ddev->CreatePixelShader((const DWORD*)pShaderBlob->GetBufferPointer(), &m_pPS));
break;
}
if(!shaderCreated)
{
CON(MSG_ERR, _W("Shader creation error"));
return false;
}
//set constant to their default values
m_pConstTable->SetDefaults(g_pD3ddev);
//create vertex declaration
if(desc.ShaderType == SHADERTYPE_VERTEX_SHADER)
m_pVertDecl = new CVertexDeclaration(CRenderer::cGraphicsManager()->GetVertexDescByID(desc.VertexDescID), pShaderBlob);
SAFE_RELEASE(pShaderBlob);
m_desc = desc;
CON(MSG_INFO, _W("Shader '%s' created"), desc.ShaderFile);
return true;
}
/*
The start of the main function starts like in most other example. We ask the
user for the desired renderer and start it up. This time with the advanced
parameter handling.
*/
int main()
{
// create device with full flexibility over creation parameters
// you can add more parameters if desired, check irr::SIrrlichtCreationParameters
irr::SIrrlichtCreationParameters params;
params.DriverType= video::EDT_DIRECT3D9;
params.WindowSize=core::dimension2d<u32>(1024, 768);
IrrlichtDevice* device = createDeviceEx(params);
if (device == 0)
return 1; // could not create selected driver.
/*
First, we add standard stuff to the scene: A nice irrlicht engine
logo, a small help text, a user controlled camera, and we disable
the mouse cursor.
*/
video::IVideoDriver* driver = device->getVideoDriver();
scene::ISceneManager* smgr = device->getSceneManager();
gui::IGUIEnvironment* env = device->getGUIEnvironment();
IFileSystem* filesys = device->getFileSystem();
driver->setTextureCreationFlag(video::ETCF_ALWAYS_32_BIT, true);
SKeyMap keyMap[4];
keyMap[0].Action = EKA_MOVE_FORWARD;
keyMap[0].KeyCode = KEY_UP;
keyMap[1].Action = EKA_MOVE_BACKWARD;
keyMap[1].KeyCode = KEY_DOWN;
keyMap[2].Action = EKA_STRAFE_LEFT;
keyMap[2].KeyCode = KEY_LEFT;
keyMap[3].Action = EKA_STRAFE_RIGHT;
keyMap[3].KeyCode = KEY_RIGHT;
// add camera
camera = smgr->addCameraSceneNodeFPS(0,100.0f,0.5f, -1, keyMap, 4);
camera->setPosition(core::vector3df(-168, 283, -168));
camera->setTarget(core::vector3df(60,137,83));
camera->setFarValue(42000.0f);
// disable mouse cursor
device->getCursorControl()->setVisible(false);
// create event receiver
MyEventReceiver receiver;
device->setEventReceiver(&receiver);
smgr->setAmbientLight(video::SColorf(0.1,0.1,0.1,1));
ITerrainSceneNode* floorNode = smgr->addTerrainSceneNode(0, 0, -1, vector3df(0, 0, 0), vector3df(0, 0, 0), vector3df(1, 1, 1), SColor(255, 255, 255, 255), 5, ETPS_17, 0, true);
char floor[32 * 32] = {0};
IReadFile* floorfile = filesys->createMemoryReadFile(floor, sizeof(char) * 32 * 32, "m2");
floorNode->loadHeightMapRAW(floorfile);
//floorNode->setMaterialFlag(EMF_LIGHTING, false);
floorNode->setScale(vector3df(100, 1, 100));
floorNode->setPosition(vector3df(-800, 1, -800));
floorNode->getMaterial(0).EmissiveColor.set(255,10,10,10);
//floorNode->setVisible(false);
smgr->addSphereSceneNode(10);
tool = smgr->addSphereSceneNode(TOOL_R);
ISceneNodeAnimator* anim = smgr->createRotationAnimator(core::vector3df(0,1,0));
tool->addAnimator(anim);
tool->setPosition(vector3df(0, 120, 0));
tool->setMaterialFlag(EMF_WIREFRAME, true);
node = smgr->addTerrainSceneNode(0, 0, -1, vector3df(0, 0, 0), vector3df(0, 0, 0), vector3df(1, 1, 1), SColor(255, 255, 255, 255), 0, ETPS_17, 0, true);
for (int i = OFFSET; i < (MATERIAL_SIZE + OFFSET); ++i)
{
for (int j = OFFSET; j < (MATERIAL_SIZE + OFFSET); ++j)
{
material[i * REAL_SIZE + j] = 100;
}
}
file = filesys->createMemoryReadFile(material, sizeof(float) * REAL_SIZE * REAL_SIZE, "m1");
node->loadHeightMapRAW(file, 32, false, true, REAL_SIZE);
node->getMaterial(0).AmbientColor.set(255,0,0,255);
//node->getMaterial(0).Shininess = 20.0f;
//node->setMaterialFlag(EMF_LIGHTING, false);
//node->setMaterialFlag(EMF_WIREFRAME, true);
node->setMaterialFlag(EMF_BACK_FACE_CULLING, false);
node->setPosition(vector3df(-OFFSET, 0, -OFFSET));
smgr->addLightSceneNode( 0, core::vector3df(100,300,100), video::SColorf(0.3f,0.3f,0.3f), 300);
std::list<vector3df> pathList;
pathList.push_back(vector3df(30, 100, 30));
pathList.push_back(vector3df(30, 100, 170));
pathList.push_back(vector3df(170, 100, 170));
pathList.push_back(vector3df(170, 100, 30));
pathList.push_back(vector3df(60, 100, 30));
pathList.push_back(vector3df(60, 100, 140));
pathList.push_back(vector3df(140, 100, 140));
pathList.push_back(vector3df(140, 100, 60));
std::list<vector3df>::iterator pathIter = pathList.begin();
int s = 0;
int lastFPS = -1;
while(device->run())
if (device->isWindowActive())
{
if (pathIter != pathList.end())
{
vector3df endP = *pathIter;
vector3df noewP = tool->getPosition();
vector3df vStep;
if (noewP.X < endP.X)
{
vStep.X = STEP;
}
if (noewP.X > endP.X)
{
vStep.X = -STEP;
}
if (noewP.Y < endP.Y)
{
vStep.Y = STEP;
}
if (noewP.Y > endP.Y)
{
vStep.Y = -STEP;
}
if (noewP.Z < endP.Z)
{
vStep.Z = STEP;
}
if (noewP.Z > endP.Z)
{
vStep.Z = -STEP;
}
tool->setPosition(tool->getPosition() + vStep);
Cut();
if (endP.getDistanceFrom(noewP) <= STEP)
{
++pathIter;
}
}
// IMesh* m = node->getMesh();
// IMeshBuffer* b = m->getMeshBuffer(0);
//
// u32 c1 = m->getMeshBufferCount();
//
// u32 c2 = b->getVertexCount();
//
// void* v = b->getVertices();
//
// for (int i = 0; i < 30; ++i)
// {
// for (int j = 0; j < 30; ++j)
// {
// S3DVertex2TCoords* tmpv = (static_cast<S3DVertex2TCoords*>(v) + (i + s + 10) * 128 + (j + s + 10));
//
// tmpv->Pos.Y = 1000;
// }
// }
//
// s = (s + 1) % 50 + 10;
//
// for (int i = 0; i < 30; ++i)
// {
// for (int j = 0; j < 30; ++j)
// {
// S3DVertex2TCoords* tmpv = (static_cast<S3DVertex2TCoords*>(v) + (i + s + 10) * 128 + (j + s + 10));
//
// tmpv->Pos.Y = 800;
// }
// }
// node->setPosition(node->getPosition());
driver->beginScene(true, true, 0 );
smgr->drawAll();
env->drawAll();
// for (int i = 0; i < 30; ++i)
// {
// for (int j = 0; j < 30; ++j)
// {
// material[(i + s + 10) * 128 + (j + s + 10)] = 1000;
// }
// }
//
// s = (s + 1) % 50 + 10;
//
// for (int i = 0; i < 30; ++i)
// {
// for (int j = 0; j < 30; ++j)
// {
// material[(i + s + 10) * 128 + (j + s + 10)] = 800;
// }
// }
//
// file->read(material, sizeof(float) * 128 * 128);
// file->seek(0);
// node->loadHeightMapRAW(file, 32, false, true, 128);
//
// node->setMaterialFlag(EMF_LIGHTING, false);
// node->setMaterialFlag(EMF_WIREFRAME, true);
// node->setMaterialFlag(EMF_BACK_FACE_CULLING, false);
// node->setMaterialFlag(EMF_FRONT_FACE_CULLING, false);
driver->endScene();
// display frames per second in window title
int fps = driver->getFPS();
if (lastFPS != fps)
{
core::stringw str = L"Terrain Renderer - Irrlicht Engine [";
str += driver->getName();
str += "] FPS:";
str += fps;
// Also print terrain height of current camera position
// We can use camera position because terrain is located at coordinate origin
device->setWindowCaption(str.c_str());
lastFPS = fps;
}
}
device->drop();
return 0;
}
bool
sTileset::Import_TST(const char* filename, IFileSystem& fs)
{
// TST file format created by Christoper B. Matthews for the RPG Toolkit Development System
IFile* file = fs.Open(filename, IFileSystem::read);
if (file == NULL)
return false;
// read header
word version;
word numtiles;
word detail;
file->Read(&version, 2);
file->Read(&numtiles, 2);
file->Read(&detail, 2);
// check header for errors
// only support details 2, 4, 6
if (version != 20 && (detail == 2 || detail == 4 || detail == 6))
{
file->Close();
return false;
}
// allocate new tiles
m_Tiles.clear();
m_Tiles.resize(numtiles);
// read them from file
for (int i = 0; i < m_Tiles.size(); i++)
{
sTile& tile = m_Tiles[i];
switch (detail)
{
case 2: // 16x16, 24-bit color
{
for (int ix = 0; ix < 16; ix++)
for (int iy = 0; iy < 16; iy++)
{
RGB rgb;
file->Read(&rgb, 3);
byte alpha = 255;
if (rgb.red == 0 && rgb.green == 1 && rgb.blue == 2)
alpha = 0;
tile.GetPixels()[iy * 16 + ix].red = rgb.red;
tile.GetPixels()[iy * 16 + ix].green = rgb.green;
tile.GetPixels()[iy * 16 + ix].blue = rgb.blue;
tile.GetPixels()[iy * 16 + ix].alpha = alpha;
}
break;
}
case 4: // 16x16, 8-bit color
case 6: // 16x16, 4-bit color
// these two are effectively the same format
{
for (int ix = 0; ix < 16; ix++)
for (int iy = 0; iy < 16; iy++)
{
byte b;
file->Read(&b, 1);
RGB rgb = dos_palette[b];
byte alpha = 255;
if (b == 255)
alpha = 0;
tile.GetPixels()[iy * 16 + ix].red = rgb.red;
tile.GetPixels()[iy * 16 + ix].green = rgb.green;
tile.GetPixels()[iy * 16 + ix].blue = rgb.blue;
tile.GetPixels()[iy * 16 + ix].alpha = alpha;
}
break;
}
}
}
file->Close();
return true;
}
bool CMeshLoader::Load(const wchar* path, bool ignore_animation_data/*=false*/)
{
if (m_bLoaded)
{
Unload();
m_bLoaded = false;
}
IFileSystem* pFS = CEngine::instance()->mFilesystem();
unsigned int ltim = GetTickCount();
// open file
wchar fspath[P3DMAX_PATH];
wsprintf(fspath, P3DMAX_PATH-1, _W("models/%s.rmesh"), path);
FSFILE* fp = pFS->Open(fspath, _W("rb"));
if (!fp)
{
CON(MSG_ERR, _W("MeshLoader: Can't find mesh file '%s'!"), fspath);
return false;
}
if (fp->nLen<sizeof(sRMHeader))
{
CON(MSG_ERR, _W("MeshLoader: Mesh file '%s' is corrupted!"), fspath);
pFS->Close(fp);
return false;
}
// load and check header
m_rhead = new sRMHeader();
pFS->Read(m_rhead, sizeof(sRMHeader), 1, fp);
if (m_rhead->magic[0]!='R' || m_rhead->magic[1]!='M')
{
CON(MSG_ERR, _W("MeshLoader: File '%s' is not valid RMesh!"), fspath);
pFS->Close(fp);
return false;
}
if (m_rhead->major!=RM_MAJOR)
{
CON(MSG_ERR, _W("MeshLoader: Mesh '%s' is version %d, but engine can load only %d!"), fspath, m_rhead->major, RM_MAJOR);
pFS->Close(fp);
return false;
}
if (m_rhead->minor!=RM_MINOR)
{
CON(MSG_DBG, _W("MeshLoader: Minor version warning. Mesh '%s' is minor version %d, engine can load %d."), fspath, m_rhead->minor, RM_MINOR);
}
m_bLoaded=true;
// LOAD INFO ---------------------------------------------------
m_rinfo = new sRMInfo();
pFS->Seek(fp, m_rhead->contents[RM_FILE_INFO].offset, SEEK_SET);
pFS->Read(m_rinfo, sizeof(sRMInfo), 1, fp);
// LOAD SUBSETS ---------------------------------------------------
m_nSubsets = m_rhead->contents[RM_SUBSETS].length/sizeof(sRMSubset);
m_rsubsets = new sRMSubset[m_nSubsets];
pFS->Seek(fp, m_rhead->contents[RM_SUBSETS].offset, SEEK_SET);
pFS->Read(m_rsubsets, sizeof(sRMSubset), m_nSubsets, fp);
// LOAD VERTICES ---------------------------------------------------
m_nVerts = m_rhead->contents[RM_VERTICES].length/sizeof(sRMVertex);
m_rverts = new sRMVertex[m_nVerts];
pFS->Seek(fp, m_rhead->contents[RM_VERTICES].offset, SEEK_SET);
pFS->Read(m_rverts, sizeof(sRMVertex), m_nVerts, fp);
// LOAD INDICES ---------------------------------------------------
m_nInds = m_rhead->contents[RM_INDICES].length/sizeof(sRMIndex);
m_rinds = new sRMIndex[m_nInds];
pFS->Seek(fp, m_rhead->contents[RM_INDICES].offset, SEEK_SET);
pFS->Read(m_rinds, sizeof(sRMIndex), m_nInds, fp);
// MAKE FACE GROUPS -----------------------------------------------
m_faceGroups = new unsigned int[m_nInds/3];
memset(m_faceGroups, 0, sizeof(unsigned int)*m_nInds/3);
for (unsigned int s=0; s<m_nSubsets; s++)
{
// find faces which belongs to this subset
unsigned int beginFace = m_rsubsets[s].firstindex/3;
unsigned int endFace = (m_rsubsets[s].firstindex+m_rsubsets[s].numindices)/3;
// assign face groups to this subset
for (unsigned int f=beginFace; f<endFace; f++) m_faceGroups[f]=s;
}
// IF THIS FILE HAS ANIMATION AND IT IS LAODED MAKE SURE TO SET m_bAnimated TO TRUE
m_bAnimated = false;
if (!m_rinfo->idontimportanim)
{
// check if file contain animated content
// TODO:
}
// close file
pFS->Close(fp);
ltim = GetTickCount() - ltim;
if (ltim<1000)
CON(MSG_INFO, _W("MeshLoader: Mesh '%s' loaded. Loading took %d miliseconds."), path, ltim);
else
CON(MSG_INFO, _W("MeshLoader: Mesh '%s' loaded. Loading took %d seconds."), path, ltim/1000);
return true;
}
bool
sTileset::Import_VSP(const char* filename, IFileSystem& fs)
{
IFile* file = fs.Open(filename, IFileSystem::read);
if (file == NULL)
return false;
word version;
RGB palette[256];
word numtiles;
file->Read(&version, 2);
file->Read(palette, 3 * 256);
file->Read(&numtiles, 2);
m_Tiles.clear();
m_Tiles.resize(numtiles);
// decode the file
if (version == 2)
{
for (int i = 0; i < numtiles; i++)
{
byte tile[256];
file->Read(tile, 256);
for (int x = 0; x < 16; x++)
for (int y = 0; y < 16; y++)
{
RGBA color;
byte c = tile[y * 16 + x];
if (c == 0)
{
color.red = 0;
color.green = 0;
color.blue = 0;
color.alpha = 0;
}
else
{
color.red = (byte)(palette[c].red * 4);
color.green = (byte)(palette[c].green * 4);
color.blue = (byte)(palette[c].blue * 4);
color.alpha = 255;
}
m_Tiles[i].GetPixels()[y * 16 + x] = color;
}
}
}
else
{
// for that wierd thing aen never told me in the vsp code
dword dw;
file->Read(&dw, 4);
// create a temporary buffer while setting up the decoding stuff...
byte* buffer = (byte*)malloc(numtiles * 256);
int len = numtiles * 256;
int counter = 0;
//start decoding!
while (counter < len)
{
byte c;
file->Read(&c, 1);
// if the c was 255 then it's a compressed value
if (c == 255)
{
byte run, color;
file->Read(&run, 1);
file->Read(&color, 1);
for (int i = 0; i < run; i++)
{
buffer[counter] = color;
counter++;
}
}
else // it's a normal value
{
buffer[counter] = c;
counter++;
}
}
// now, tranfer the decoded stuff into the tiles' data structure
for (int i = 0; i < numtiles; i++)
for (int j = 0; j < 256; j++)
{
if (buffer[i * 256 + j] == 0)
{
m_Tiles[i].GetPixels()[j].red = 0;
m_Tiles[i].GetPixels()[j].green = 0;
m_Tiles[i].GetPixels()[j].blue = 0;
m_Tiles[i].GetPixels()[j].alpha = 0;
}
else
{
m_Tiles[i].GetPixels()[j].red = (palette[buffer[i * 256 + j]].red) * 4;
m_Tiles[i].GetPixels()[j].green = (palette[buffer[i * 256 + j]].green) * 4;
m_Tiles[i].GetPixels()[j].blue = (palette[buffer[i * 256 + j]].blue) * 4;
m_Tiles[i].GetPixels()[j].alpha = 255;
}
}
}
file->Close();
return true;
}
bool CShaderHLSL::Create(P3D::sShaderDesc &desc)
{
const char *pData;
ULONG fsize;
IFileSystem* pFS = CRenderer::mEngine()->mFilesystem();
wchar path[P3DMAX_PATH];
wsprintf(path, P3DMAX_PATH-1, _W("shaders/%s.rshader"), desc.ShaderFile.Get());
FSFILE *fp = pFS->Load(path, (BYTE *&)pData, fsize, true);
if (!fp)
{
CON(MSG_ERR, _W("Can't open %s.hlsl shader file from data/shaders directory!"), desc.ShaderFile.Get());
return false;
}
ID3D10Blob *pShaderBlob = NULL;
ID3D10Blob *pErrors = NULL;
UINT flags = D3D10_SHADER_DEBUG; //D3D10_SHADER_OPTIMIZATION_LEVEL3
char profile[128];
switch(desc.ShaderType)
{
case SHADERTYPE_VERTEX_SHADER:
strcpy(profile, D3D10GetVertexShaderProfile(g_pD3ddev));
break;
case SHADERTYPE_GEOMETRY_SHADER:
strcpy(profile, D3D10GetGeometryShaderProfile(g_pD3ddev));
break;
case SHADERTYPE_PIXEL_SHADER:
strcpy(profile, D3D10GetPixelShaderProfile(g_pD3ddev));
break;
default:
CON(MSG_ERR, _W("Chader creation failed. No apropriate ShaderType given."));
return false;
}
CIncludeHandler includeHandler;
D3D10_SHADER_MACRO Shader_Macros[] =
{
{ "DX10", NULL },
{ "SM4", NULL },
NULL
};
if(!CheckHRResult(D3DX10CompileFromMemory(
pData,
fsize,
NULL,
Shader_Macros,
&includeHandler,
_W2A(desc.EntryFunction.Get()),
profile,
flags,
0,
NULL,
&pShaderBlob,
&pErrors,
NULL
)))
{
if(pErrors) CON(MSG_ERR, _W("%s"), _A2W((char*)pErrors->GetBufferPointer()));
else CON(MSG_ERR, _W("Error description not given"));
CON(MSG_ERR, _W("Shader %s could not be compiled"), desc.ShaderFile.Get());
SAFE_RELEASE(pErrors);
return false;
}
pFS->UnLoad(fp, (BYTE *)pData);
//save to cache
fp = pFS->Open(_W("cache/shaders/hlsl"), _W("wb"));
const char* cs = (const char*)pShaderBlob->GetBufferPointer();
pFS->Write(cs, 1, pShaderBlob->GetBufferSize(), fp);
pFS->Close(fp);
bool shaderCreated = false;
switch(desc.ShaderType)
{
case SHADERTYPE_VERTEX_SHADER:
shaderCreated = CheckHRResult(g_pD3ddev->CreateVertexShader(pShaderBlob->GetBufferPointer(), pShaderBlob->GetBufferSize(), &m_pVS));
break;
case SHADERTYPE_GEOMETRY_SHADER:
shaderCreated = CheckHRResult(g_pD3ddev->CreateGeometryShader(pShaderBlob->GetBufferPointer(), pShaderBlob->GetBufferSize(), &m_pGS));
break;
case SHADERTYPE_PIXEL_SHADER:
shaderCreated = CheckHRResult(g_pD3ddev->CreatePixelShader(pShaderBlob->GetBufferPointer(), pShaderBlob->GetBufferSize(), &m_pPS));
break;
}
if(!shaderCreated)
{
CON(MSG_ERR, _W("Shader creation error"));
return false;
}
//if(!CheckHRResult(D3DReflect((DWORD*)pShaderBlob->GetBufferPointer(), pShaderBlob->GetBufferSize(), __uuidof(ID3D10ShaderReflection), &m_pReflection)))
if(!CheckHRResult(D3D10ReflectShader(pShaderBlob->GetBufferPointer(), pShaderBlob->GetBufferSize(), &m_pReflection)))
{
CON(MSG_ERR, _W("Could not create a Shader reflection"));
return false;
}
//HRESULT D3DReflect(LPCVOID pSrcData, SIZE_T SrcDataSize, REFIID pInterface, void **ppReflector);
D3D10_SHADER_DESC shDesc;
m_pReflection->GetDesc(&shDesc);
m_numResources = shDesc.BoundResources; //not sure about this
if(desc.ShaderType == SHADERTYPE_VERTEX_SHADER)
m_pVertDecl = new CVertexDeclaration(CRenderer::cGraphicsManager()->GetVertexDescByID(desc.VertexDescID), pShaderBlob);
SAFE_RELEASE(pShaderBlob);
m_desc = desc;
CON(MSG_INFO, _W("Shader '%s' created"), desc.ShaderFile);
return true;
}
void PrintPlayerClassStats()
{
IFileSystem *pFileSys = filesystem;
FileHandle_t hFile = pFileSys->Open( "class_stats.txt", "wt", "LOGDIR" );
if ( hFile == FILESYSTEM_INVALID_HANDLE )
return;
pFileSys->FPrintf( hFile, "Class\tPlayer Time (minutes)\tAvg Engagement Dist\t(OLD) Engagement Dist\n" );
for ( int i=TFCLASS_UNDECIDED+1; i < STATS_NUM_GROUPS; i++ )
{
CPlayerClassStats *pStats = &g_PlayerClassStats[i];
// Figure out the average engagement distance across all classes.
int j;
double flAvgEngagementDist = 0;
int nTotalEngagements = 0;
double flTotalEngagementDist = 0;
double flTotalNormalizedEngagementDist = 0;
int nTotalNormalizedEngagements = 0;
for ( j=TFCLASS_UNDECIDED+1; j < STATS_NUM_GROUPS; j++ )
{
CInterClassStats *pInter = &g_PlayerClassStats[i].m_InterClassStats[j];
nTotalEngagements += pInter->m_nEngagements;
flTotalEngagementDist += pInter->m_flTotalEngagementDist;
nTotalNormalizedEngagements += pInter->m_nNormalizedEngagements;
flTotalNormalizedEngagementDist += pInter->m_flTotalNormalizedEngagementDist;
}
flAvgEngagementDist = nTotalEngagements ? ( flTotalEngagementDist / nTotalEngagements ) : 0;
double flAvgNormalizedEngagementDist = nTotalNormalizedEngagements ? (flTotalNormalizedEngagementDist / nTotalNormalizedEngagements) : 0;
pFileSys->FPrintf( hFile, "%s", GetGroupNameFor( i ) );
pFileSys->FPrintf( hFile, "\t%.1f", (pStats->m_flPlayerTime / 60.0f) );
pFileSys->FPrintf( hFile, "\t%d", (int)flAvgNormalizedEngagementDist );
pFileSys->FPrintf( hFile, "\t%d", (int)flAvgEngagementDist );
pFileSys->FPrintf( hFile, "\n" );
}
pFileSys->FPrintf( hFile, "\n" );
pFileSys->FPrintf( hFile, "\n" );
pFileSys->FPrintf( hFile, "Class\tTarget Class\tTotal Damage\tKills\tAvg Engagement Dist\t(OLD) Engagement Dist\n" );
for ( i=TFCLASS_UNDECIDED+1; i < STATS_NUM_GROUPS; i++ )
{
CPlayerClassStats *pStats = &g_PlayerClassStats[i];
// Print the inter-class stats.
for ( int j=TFCLASS_UNDECIDED+1; j < STATS_NUM_GROUPS; j++ )
{
CInterClassStats *pInter = &pStats->m_InterClassStats[j];
pFileSys->FPrintf( hFile, "%s", GetGroupNameFor( i ) );
pFileSys->FPrintf( hFile, "\t%s", GetGroupNameFor( j ) );
pFileSys->FPrintf( hFile, "\t%d", (int)pInter->m_flTotalDamageInflicted );
pFileSys->FPrintf( hFile, "\t%d", pInter->m_nKills );
pFileSys->FPrintf( hFile, "\t%d", (int)(pInter->m_nNormalizedEngagements ? (pInter->m_flTotalNormalizedEngagementDist / pInter->m_nNormalizedEngagements) : 0) );
pFileSys->FPrintf( hFile, "\t%d", (int)(pInter->m_nEngagements ? (pInter->m_flTotalEngagementDist / pInter->m_nEngagements) : 0) );
pFileSys->FPrintf( hFile, "\n" );
}
}
pFileSys->Close( hFile );
}
// ------------------------------------------------
bool CTextureLoader::Load(const wchar* path)
{
IFileSystem *fs = CRenderer::mEngine()->mFilesystem();
Unload();
//memset(&m_info, 0, sizeof(sRTInfo));
// make physical FS path
wchar physPath[512];
wsprintf(physPath, 511, _W("textures/%s.rtex"), path);
for (unsigned int i=0; i<wstrlen(physPath); i++)
if (physPath[i]==',') physPath[i]='/';
FSFILE* fp;
fp = fs->Open(physPath, _W("rb"));
if (!fp)
{
return false;
}
m_dataLen = fp->nLen;
if (m_dataLen < sizeof(sRTHeader))
{
fs->Close(fp);
return false;
}
// read header
sRTHeader head;
fs->Read(&head, 1, sizeof(sRTHeader), fp);
// check header
if (head.magic[0]!='R' || head.magic[1]!='T')
{
CON(MSG_ERR, _W("Texture %s is not valid rtex!"), path);
fs->Close(fp);
return false;
}
// load texture info
fs->Seek(fp, head.contents[RT_FILE_INFO].offset, SEEK_SET);
fs->Read(&m_info, 1, sizeof(sRTInfo), fp);
// load texture data
unsigned long rawDataLen = fp->nLen-head.contents[RT_IMAGE_SUBSET].offset-head.contents[RT_IMAGE_SUBSET].length;
m_data = new BYTE[rawDataLen];
fs->Seek(fp, head.contents[RT_IMAGE_SUBSET].offset+head.contents[RT_IMAGE_SUBSET].length, SEEK_SET);
fs->Read(m_data, 1, rawDataLen, fp);
m_bLoaded=true;
// load all subsets
fs->Seek(fp, head.contents[RT_IMAGE_SUBSET].offset, SEEK_SET);
unsigned int numSubs = head.contents[RT_IMAGE_SUBSET].length / sizeof(sRTImageSubset);
for (unsigned int s = 0; s < numSubs; s++)
{
sImageData* ida = new sImageData();
fs->Read(&ida->subset, 1, sizeof(sRTImageSubset), fp);
ida->size = ida->subset.len;
ida->pData = &m_data[ida->subset.offset];
m_subs.push_back(ida);
}
fs->Close(fp);
int i = 0; // debug
return true;
}
bool
sMap::Save(const char* filename, IFileSystem& fs)
{
// do some preliminary checking...
// the start layer should not have parallax
m_Layers[m_StartLayer].EnableParallax(false);
IFile* file = fs.Open(filename, IFileSystem::write);
if (file == NULL)
return false;
// write the map header
MAP_HEADER header;
memset(&header, 0, sizeof(header));
memcpy(header.signature, ".rmp", 4);
header.version = 1;
header.num_layers = m_Layers.size();
header.num_entities = m_Entities.size();
header.startx = m_StartX;
header.starty = m_StartY;
header.startlayer = m_StartLayer;
header.startdirection = m_StartDirection;
header.num_strings = 9;
file->Write(&header, sizeof(header));
// write the strings
WriteMapString(file, ""); // OBSOLETE
WriteMapString(file, m_MusicFile.c_str());
WriteMapString(file, ""); // OBSOLETE
WriteMapString(file, m_EntryScript.c_str());
WriteMapString(file, m_ExitScript.c_str());
WriteMapString(file, m_EdgeScripts[0].c_str());
WriteMapString(file, m_EdgeScripts[1].c_str());
WriteMapString(file, m_EdgeScripts[2].c_str());
WriteMapString(file, m_EdgeScripts[3].c_str());
// write layers
for (int i = 0; i < m_Layers.size(); i++)
{
const sLayer& layer = m_Layers[i];
const sObstructionMap& obstructions = layer.GetObstructionMap();
// write the header
LAYER_HEADER lh;
memset(&lh, 0, sizeof(lh));
lh.width = m_Layers[i].GetWidth();
lh.height = m_Layers[i].GetHeight();
lh.flags = (m_Layers[i].IsVisible() ? 0 : 1) | (m_Layers[i].HasParallax() ? 2 : 0);
lh.parallax_x = m_Layers[i].GetXParallax();
lh.parallax_y = m_Layers[i].GetYParallax();
lh.scrolling_x = m_Layers[i].GetXScrolling();
lh.scrolling_y = m_Layers[i].GetYScrolling();
lh.num_segments = obstructions.GetNumSegments();
lh.reflective = (m_Layers[i].IsReflective() ? 1 : 0);
file->Write(&lh, sizeof(lh));
// write the layer name
WriteMapString(file, m_Layers[i].GetName());
// write the layer data
for (int iy = 0; iy < m_Layers[i].GetHeight(); iy++)
for (int ix = 0; ix < m_Layers[i].GetWidth(); ix++)
{
word w = m_Layers[i].GetTile(ix, iy);
file->Write(&w, 2);
}
// write the obstruction map
for (int i = 0; i < obstructions.GetNumSegments(); i++) {
const sObstructionMap::Segment& s = obstructions.GetSegment(i);
dword x1 = s.x1;
dword y1 = s.y1;
dword x2 = s.x2;
dword y2 = s.y2;
file->Write(&x1, sizeof(dword));
file->Write(&y1, sizeof(dword));
file->Write(&x2, sizeof(dword));
file->Write(&y2, sizeof(dword));
}
} // end for layer
// write entities
for (int i = 0; i < m_Entities.size(); i++)
{
// write the header
ENTITY_HEADER eh;
memset(&eh, 0, sizeof(eh));
eh.mapx = m_Entities[i]->x;
eh.mapy = m_Entities[i]->y;
eh.layer = m_Entities[i]->layer;
switch (m_Entities[i]->GetEntityType())
{
case sEntity::PERSON: eh.type = 1; break;
case sEntity::TRIGGER: eh.type = 2; break;
}
file->Write(&eh, sizeof(eh));
// write the entity data
switch (m_Entities[i]->GetEntityType())
{
case sEntity::PERSON:
{
sPersonEntity* person = (sPersonEntity*)m_Entities[i];
WriteMapString(file, person->name.c_str());
WriteMapString(file, person->spriteset.c_str());
WriteMapWord(file, 5); // four scripts
// scripts
WriteMapString(file, person->script_create.c_str());
WriteMapString(file, person->script_destroy.c_str());
WriteMapString(file, person->script_activate_touch.c_str());
WriteMapString(file, person->script_activate_talk.c_str());
WriteMapString(file, person->script_generate_commands.c_str());
// reserved
for (int i = 0; i < 16; i++) {
WriteMapByte(file, 0);
}
break;
}
case sEntity::TRIGGER:
{
sTriggerEntity* trigger = (sTriggerEntity*)m_Entities[i];
WriteMapString(file, trigger->script.c_str());
break;
}
} // end switch entity type
} // end for entity
// write the zones
for (int i = 0; i < m_Zones.size(); i++)
{
ZONE_HEADER zh;
memset(&zh, 0, sizeof(zh));
zh.x1 = m_Zones[i].x1;
zh.y1 = m_Zones[i].y1;
zh.x2 = m_Zones[i].x2;
zh.y2 = m_Zones[i].y2;
zh.layer = m_Zones[i].layer;
zh.reactivate_in_num_steps = m_Zones[i].reactivate_in_num_steps;
file->Write(&zh, sizeof(zh));
WriteMapString(file, m_Zones[i].script.c_str());
} // end for zones
// save the tileset
if (!m_Tileset.SaveToFile(file)) {
file->Close();
return false;
}
file->Close();
return true;
}
void ModuleManager::scanModuleDir()
{
if (RootConfig::isSet("ModulesDir") == false)
{
Logger::getInstance() << Logger::Warning << "No modules dir specified. No module will be loaded" << Logger::Flush;
return ;
}
//Retreiving modules in ModulesDir
IFileSystem* fs = new FileSystem(RootConfig::getParamChar("ModulesDir"));
#ifndef _WIN32
std::list<IFile*>* files = fs->getFileList("so");
#else
std::list<IFile*>* files = fs->getFileList("dll");
#endif // !_WIN32
if (files != NULL)
{
//Creating a new modules list
ModuleStuff newStuff;
std::list<RefCounter<zAPI::IModuleInfo*>*>* newList = new std::list<RefCounter<zAPI::IModuleInfo*>*>[zAPI::IModule::NumberOfHooks];
newStuff.list = NULL;
newStuff.hooks = newList;
//duplicating old list, to apply changes from the old one to the new one
if (this->_modules.size() > 0)
{
for (int i = 0; i < zAPI::IModule::NumberOfHooks; ++i)
newList[i] = this->_modules.back().ptr.hooks[i];
}
//flag to see if some changes occured.
bool firstChange = true;
//files list iterators
std::list<IFile*>::iterator it;
std::list<IFile*>::iterator ite = files->end();
//modules instance iterators
std::list<RefCounter<zAPI::IModuleInfo*> >::iterator mIt = this->_moduleInstances.begin();
std::list<RefCounter<zAPI::IModuleInfo*> >::iterator mIte = this->_moduleInstances.end();
//First we look if some modules doesn't exists anymore.
for (; mIt != mIte; ++mIt)
{
for (it = files->begin(); it != ite; ++it)
{
if ((*it)->getFullFileName() == (*mIt).ptr->getFileName())
break;
}
if (it == ite) //module wasn't in dir anymore : unloading
{
if (firstChange)
{
this->_modules.push_back(newStuff);
this->_modules.back().count = 0;
firstChange = false;
}
Logger::getInstance() << Logger::Info << (*mIt).ptr->getFileName() << " is missing from ModulesDir. Unloading module." << Logger::Flush;
this->unload((*mIt).ptr->getFileName());
if ((*mIt).count == 0)
{
mIt = this->_moduleInstances.erase(mIt);
mIte = this->_moduleInstances.end();
}
}
}
//Then we add new modules
it = files->begin();
for (; it != ite; ++it)
{
if (this->isLoaded((*it)->getFullFileName()) == false)
{
if (firstChange)
{
this->_modules.push_back(newStuff);
this->_modules.back().count = 0;
firstChange = false;
}
this->load((*it)->getFullFileName());
}
}
if (firstChange == true)
delete[] newList;
else
this->createModuleStuff();
}
delete fs;
}
//-------------------------------------------------------------------------
// i n i t
//-------------------------------------------------------------------------
int CApplication::init()
{
SIrrlichtCreationParameters cp;
static SKeyMap keyMap[5];
keyMap[0].Action = EKA_MOVE_FORWARD;
keyMap[0].KeyCode = KEY_KEY_W;
keyMap[1].Action = EKA_STRAFE_LEFT;
keyMap[1].KeyCode = KEY_KEY_A;
keyMap[2].Action = EKA_MOVE_BACKWARD;
keyMap[2].KeyCode = KEY_KEY_S;
keyMap[3].Action = EKA_STRAFE_RIGHT;
keyMap[3].KeyCode = KEY_KEY_D;
keyMap[4].Action = EKA_JUMP_UP;
keyMap[4].KeyCode = KEY_SPACE;
int result=0;
stringc msg;
// use null device for early file system access
IrrlichtDevice* m_nullDevice = createDevice(EDT_NULL);
IFileSystem* fileSystem = m_nullDevice->getFileSystem();
m_currentDirectory = fileSystem->getWorkingDirectory();
m_currentDirectory = fileSystem->flattenFilename(m_currentDirectory);
if(m_argv)
{
m_appExecutable = m_argv[0];
}
else
{
m_appExecutable = "irrlicht.exe";
}
stringc appBaseName;
appBaseName = fileSystem->getAbsolutePath(m_appExecutable);
appBaseName = fileSystem->getFileBasename(appBaseName, false);
//
// create log writer
//
m_logName = appBaseName;
m_logName += ".log";
m_logFile = fileSystem->createAndWriteFile(m_logName);
msg = "Created log file: ";
msg += m_logName;
logMessage(msg);
//
// configuration system
//
// locate the data directory - underneath our executable or outside of it.
stringc temp("data/");
if(!fileSystem->existFile(temp))
{
temp = "../data/";
// todo - look for "data.zip"...
}
m_dataRoot = fileSystem->getAbsolutePath(temp);
m_configName = m_dataRoot;
m_configName += "/cfg/";
m_configName += appBaseName;
m_configName += ".xml";
if(!fileSystem->existFile(m_configName))
{
// not in data/cfg or ../data/cfg so look in the working directory.
m_configName = appBaseName;
m_configName += ".xml";
if(!fileSystem->existFile(m_configName))
{
return -1;
}
}
// load the config file
m_config = new CXMLConfig();
if(!m_config->load(m_configName))
{
return -1;
}
// setup the device based on config settings
stringc sdriver = m_config->getString("driver","video","EDT_OPENGL");
cp.DriverType = EDT_OPENGL;
if(sdriver == "EDT_DIRECT3D9")
cp.DriverType = EDT_DIRECT3D9;
cp.WindowSize = m_config->getDimension("resolution","video",dimension2di(800, 600));
cp.Bits = m_config->getInt("colordepth","video",32);
cp.Fullscreen = m_config->getBool("fullscreen","video",false);
cp.Vsync = m_config->getBool("vsync","video",true);
cp.Stencilbuffer = m_config->getBool("stencilbuffer","video",false);
cp.AntiAlias = m_config->getInt("antialias","video",0);
cp.EventReceiver = this;
cp.WindowId = 0;
m_device = createDeviceEx(cp);
if(!m_device)
return -1;
m_fileSystem = m_device->getFileSystem();
m_videoDriver = m_device->getVideoDriver();
m_sceneManager = m_device->getSceneManager();
m_gui = m_device->getGUIEnvironment();
m_device->getCursorControl()->setVisible(m_config->getBool("HWCursorVisible","video",true));
m_device->setWindowCaption(stringw(m_title).c_str());
//
// add configured file systems
//
if(_initFileSystems())
return -1;
//
// set up the default font
//
stringc fontFolder = "fnt/";
stringc defFonts = fontFolder + "defaults.zip";
if(m_fileSystem->existFile(defFonts.c_str()))
{
m_fileSystem->addZipFileArchive(defFonts.c_str());
m_defaultFont = m_gui->getFont("tdeffont.xml");
if(m_defaultFont)
{
m_defaultFont->grab();
m_gui->getSkin()->setFont(m_defaultFont);
}
m_monoFont = m_gui->getFont("monospace.xml");
if(m_monoFont)
{
m_monoFont->grab();
}
}
m_world = m_sceneManager->createMetaTriangleSelector();
// camera setup
f32 rotateSpeed = m_config->getFloat("rotateSpeed","options",100.f);
m_orgMoveSpeed = m_config->getFloat("moveSpeed","options",0.001f);
f32 jumpSpeed = m_config->getFloat("jumpSpeed","options",0.05f);
m_camera = m_sceneManager->addCameraSceneNodeFPS(0, rotateSpeed, m_orgMoveSpeed, -1,keyMap,5,true, jumpSpeed);
vector3df v = m_config->getVector3("campos","options");
m_camera->setPosition(v);
v = m_config->getVector3("camtarget","options");
m_camera->setTarget(v);
bool collisionEnabled = m_config->getBool("collision","options");
if(collisionEnabled)
{
vector3df gravity,ellipsoid;
gravity = m_config->getVector3("gravity","options",vector3df(0,-0.1f,0));
ellipsoid = m_config->getVector3("ellipsoid","options",vector3df(2,5,2));
m_collisionResponse = m_sceneManager->createCollisionResponseAnimator(m_world,m_camera,
ellipsoid, gravity);
m_camera->addAnimator(m_collisionResponse);
}
// debug & help panels setup
m_debugPanel = new gui::CGUITextPanel(m_gui, "debugPanel", rectf(0.25f,0.005f,0.75f,0.05f));
m_debugPanel->addItem("Node: Pos(x,y,z) Hpr(x,y,z) Dir(x,y,z)", EGUIA_CENTER);
m_debugPanel->addItem("Frame: Avg(0.0) Min(0.0) Max(0.0)", EGUIA_CENTER);
m_debugPanel->setVisible(true);
m_helpPanel = new gui::CGUITextPanel(m_gui, "helpPanel", rectf(0.005f,0.005f,0.245f,0.05f));
m_helpPanel->addItem(" wasd - Movement");
m_helpPanel->addItem(" F1 - Toggle Help");
m_helpPanel->addItem(" F2 - Toggle Debug");
createScene();
return result;
}
bool
sMap::Import_VergeMAP(const char* filename, const char* tilesetFilename, IFileSystem& fs)
{
m_MusicFile = "";
m_EntryScript = "";
m_ExitScript = "";
m_Layers.clear();
m_Entities.clear();
IFile* file = fs.Open(filename, IFileSystem::read);
if (file == NULL)
return false;
// check for v1 maps (ver 4) and v2 maps (ver 5)
char signature[6];
file->Read(signature, 6);
file->Seek(0);
bool success = false;
if (signature[0] == 4)
{
V1MAP_HEADER header;
file->Read(&header, sizeof(header));
word* layer_background = new word[header.layer_size_x * header.layer_size_y];
word* layer_foreground = new word[header.layer_size_x * header.layer_size_y];
file->Read(layer_background, header.layer_size_x * header.layer_size_y * sizeof(word));
file->Read(layer_foreground, header.layer_size_x * header.layer_size_y * sizeof(word));
sTileset tileset;
if (strcmp_ci(tilesetFilename + strlen(tilesetFilename) - 4, ".vsp") == 0)
success = tileset.Import_VSP(tilesetFilename, fs);
else
success = tileset.Load(tilesetFilename, fs);
sLayer layer[2];
if (success)
{
// process map and see if the map has tiles that are out of range
int highestTileIndex = 0;
for (int j=0; j<header.layer_size_y; j++)
for (int i=0; i<header.layer_size_x; i++)
if (layer_background[j * header.layer_size_x + i] >= highestTileIndex)
highestTileIndex = layer_background[j * header.layer_size_x + i];
else if (layer_foreground[j * header.layer_size_x + i] >= highestTileIndex)
highestTileIndex = layer_foreground[j * header.layer_size_x + i];
if (highestTileIndex >= tileset.GetNumTiles())
success = false;
// transfer data across into the sMap now...
if (success)
{
layer[0].SetName("Background");
layer[1].SetName("Foreground");
layer[0].Resize(header.layer_size_x, header.layer_size_y);
layer[1].Resize(header.layer_size_x, header.layer_size_y);
for (int j=0; j<header.layer_size_y; j++)
for (int i=0; i<header.layer_size_x; i++)
{
layer[0].SetTile(i,j, layer_background[j * header.layer_size_x + i]);
if (layer_foreground[j * header.layer_size_x + i])
layer[1].SetTile(i,j, layer_foreground[j * header.layer_size_x + i]);
else
layer[1].SetTile(i,j, tileset.GetNumTiles());
}
tileset.AppendTiles(1);
memset(tileset.GetTile(tileset.GetNumTiles() - 1).GetPixels(), 0, 256 * sizeof(RGBA));
m_Tileset = tileset;
AppendLayer(layer[0]);
AppendLayer(layer[1]);
SetMusicFile((char*)header.music_fname);
SetStartX(header.x_start);
SetStartX(header.y_start);
SetStartDirection(4);
// calculate the parallax mode
for (int i=0; i<2; i++)
{
// FIXME (set parallax properly)
// GetLayer(i).SetParallaxX(1, 1);
// GetLayer(i).SetParallaxY(1, 1);
// GetLayer(i).SetScrollingX(1, 1);
// GetLayer(i).SetScrollingX(1, 1);
}
switch(header.parallax_mode)
{
case 0:
SetStartLayer(0);
break;
case 1:
SetStartLayer(1);
break;
case 2:
// FIXME (set parallax properly)
SetStartLayer(1);
// GetLayer(0).SetParallaxX(header.parallax_multiplier, header.parallax_divisor);
// GetLayer(0).SetParallaxY(header.parallax_multiplier, header.parallax_divisor);
break;
case 3:
// FIXME (set parallax properly)
SetStartLayer(0);
// GetLayer(1).SetParallaxX(header.parallax_multiplier, header.parallax_divisor);
// GetLayer(1).SetParallaxY(header.parallax_multiplier, header.parallax_divisor);
break;
}
}
}
// cleanup
delete[] layer_background;
delete[] layer_foreground;
}
else if (strcmp(signature, "MAPù5") == 0)
{
V2MAP_HEADER header;
V2MAP_LAYERINFO LayerInfo[7];
sTileset tileset;
word *mapLayer[7];
int i,j,k;
int highestTileIndex = 0;
file->Read(&header, sizeof(header));
for (i=0; i<header.num_layers; i++)
{
file->Read(LayerInfo + i, sizeof(V2MAP_LAYERINFO));
//bug for v2's map: two bytes are added for no reason
word w;
file->Read(&w, 2);
}
// get info about map and uncompress it
for (i=0; i<header.num_layers; i++)
mapLayer[i] = new word[LayerInfo[i].size_x * LayerInfo[i].size_y];
for (i=0; i<header.num_layers; i++)
{
// god, this is so dumb. It's supposed to be the buffersize, but do I look like I need it?
file->Read(&j, 4);
for (j=0; j<LayerInfo[i].size_x*LayerInfo[i].size_y; j++)
{
word value;
byte run;
file->Read(&value, sizeof(word));
if ((value & 0xFF00) == 0xFF00)
{
run = (byte)value & 0x00FF;
file->Read(&value, sizeof(word));
mapLayer[i][j] = value;
for (k=1; k<run; k++)
{
j++;
mapLayer[i][j] = value;
}
}
else
{
mapLayer[i][j] = value;
}
}
}
if (strcmp_ci(tilesetFilename + strlen(tilesetFilename) - 4, ".vsp") == 0)
success = tileset.Import_VSP(tilesetFilename);
else
success = tileset.Load(tilesetFilename);
// transfer map array into the class
if (success)
{
highestTileIndex = 0;
// check for any tile index larger than the tilset's index
for (i=0; i<header.num_layers; i++)
for (j=0; j<LayerInfo[i].size_x*LayerInfo[i].size_y; j++)
if (mapLayer[i][j] >= highestTileIndex)
highestTileIndex = mapLayer[i][j];
if (highestTileIndex >= tileset.GetNumTiles())
success = false;
if (success)
{
sLayer *layer;
layer = new sLayer[header.num_layers];
for (i=0; i<header.num_layers; i++)
{
char Name[7];
memcpy(Name, "Layer A", 8);
Name[6] += i;
layer[i].SetName(Name);
layer[i].Resize(LayerInfo[i].size_x, LayerInfo[i].size_y);
}
for (i=0; i<header.num_layers; i++)
{
for (j=0; j<LayerInfo[i].size_y; j++)
for (k=0; k<LayerInfo[i].size_x; k++)
layer[i].SetTile(k, j, mapLayer[i][(j * LayerInfo[i].size_x) + k]);
// FIXME: set parallax properly
// layer[i].SetParallaxX(LayerInfo[i].multx, LayerInfo[i].pdivx);
// layer[i].SetParallaxY(LayerInfo[i].multy, LayerInfo[i].pdivy);
// layer[i].SetScrollingX(1,1);
// layer[i].SetScrollingY(1,1);
}
for (i=0; i<(int)strlen((char*)header.renderstring); i++)
switch(header.renderstring[i])
{
case '1': AppendLayer(layer[0]); j = 0; break;
case '2': AppendLayer(layer[1]); j = 1; break;
case '3': AppendLayer(layer[2]); j = 2; break;
case '4': AppendLayer(layer[3]); j = 3; break;
case '5': AppendLayer(layer[4]); j = 4; break;
case '6': AppendLayer(layer[5]); j = 5; break;
case 'E': SetStartLayer(j); break;
}
SetMusicFile((char*)header.music_name);
SetStartX(header.x_start);
SetStartY(header.y_start);
m_Tileset = tileset;
delete[] layer;
}
}
for (i=0; i<header.num_layers; i++)
delete mapLayer[i];
}
file->Close();
return success;
}
