void global_slots_data:: Load ( )
{
// Load .details
// copy
//if()
IReader* R = FS.r_open ( "$level$", "build.details" );
R->r_chunk ( 0, &dtH );
R->seek ( 0 );
u32 check_sum = crc32( R-> pointer(), R->length());
recalculation_data.load( check_sum );
if( !recalculation_data.recalculating() )
{
IWriter* W = FS.w_open ( "$level$", "level.details" );
W->w ( R->pointer(), R->length() );
FS.w_close ( W );
}
FS.r_close ( R );
// re-open
string_path N;
FS.update_path ( N, "$level$", "level.details" );
dtFS = xr_new<CVirtualFileRW> ( N );
R_ASSERT ( dtH.version()==DETAIL_VERSION );
dtFS->find_chunk ( 2 );
dtS = (DetailSlot*)dtFS->pointer();
}
bool CALifeStorageManager::load (LPCSTR save_name_no_check)
{
LPCSTR game_saves_path = FS.get_path("$game_saves$")->m_Path;
string_path save_name;
strncpy_s (save_name, sizeof(save_name), save_name_no_check, sizeof(save_name)-5-xr_strlen(SAVE_EXTENSION)-xr_strlen(game_saves_path));
CTimer timer;
timer.Start ();
string_path save;
xr_strcpy (save,m_save_name);
if (!save_name) {
if (!xr_strlen(m_save_name))
R_ASSERT2 (false,"There is no file name specified!");
}
else
{
strconcat (sizeof(m_save_name), m_save_name, save_name, SAVE_EXTENSION);
}
string_path file_name;
FS.update_path (file_name,"$game_saves$",m_save_name);
xr_strcpy (g_last_saved_game, save_name);
xr_strcpy (g_bug_report_file, file_name);
IReader *stream;
stream = FS.r_open(file_name);
if (!stream) {
Msg ("* Cannot find saved game %s",file_name);
xr_strcpy (m_save_name,save);
return (false);
}
CHECK_OR_EXIT (CSavedGameWrapper::valid_saved_game(*stream),make_string("%s\nSaved game version mismatch or saved game is corrupted",file_name));
/*
string512 temp;
strconcat (sizeof(temp),temp,CStringTable().translate("st_loading_saved_game").c_str()," \"",save_name,SAVE_EXTENSION,"\"");
g_pGamePersistent->LoadTitle(temp);
*/
g_pGamePersistent->LoadTitle();
unload ();
reload (m_section);
u32 source_count = stream->r_u32();
void *source_data = xr_malloc(source_count);
rtc_decompress (source_data,source_count,stream->pointer(),stream->length() - 3*sizeof(u32));
FS.r_close (stream);
load (source_data, source_count, file_name);
xr_free (source_data);
groups().on_after_game_load ();
VERIFY (graph().actor());
Msg ("* Game %s is successfully loaded from file '%s' (%.3fs)",save_name, file_name,timer.GetElapsed_sec());
return (true);
}
void CGameGraphBuilder::load_graph_points (const float &start, const float &amount)
{
Progress (start);
Msg ("Loading graph points");
string_path spawn_file_name;
strconcat (sizeof(spawn_file_name),spawn_file_name,*m_level_name,"level.spawn");
IReader *reader = FS.r_open(spawn_file_name);
u32 id;
NET_Packet net_packet;
for (
IReader *chunk = reader->open_chunk_iterator(id);
chunk;
chunk = reader->open_chunk_iterator(id,chunk)
)
{
net_packet.B.count = chunk->length();
chunk->r (net_packet.B.data,net_packet.B.count);
load_graph_point (net_packet);
}
FS.r_close (reader);
Msg ("%d graph points loaded",graph().vertices().size());
Progress (start + amount);
}
void ppmd_initialize ()
{
if (trained_model)
trained_model->rewind ();
static bool initialized = false;
if (initialized)
return;
string_path file_name;
FS.update_path (file_name,"$game_config$","mp\\!PPMd.mdl");
if (FS.exist(file_name)) {
IReader *reader = FS.r_open(file_name);
R_ASSERT (reader);
u32 buffer_size = reader->length();
u8 *buffer = (u8*)xr_malloc(buffer_size);
reader->r (buffer,buffer_size);
FS.r_close (reader);
trained_model = new stream(buffer,buffer_size);
}
initialized = true;
if (StartSubAllocator(suballocator_size))
return;
exit (-1);
}
BOOL testEqual (LPCSTR path, IReader* base)
{
IReader* test = FS.r_open (path);
if (test->length() != base->length())
{
return FALSE;
}
return 0==memcmp(test->pointer(),base->pointer(),base->length());
}
void transfer(const char *name, xr_vector<T> &dest, IReader& F, u32 chunk)
{
IReader* O = F.open_chunk(chunk);
u32 count = O?(O->length()/sizeof(T)):0;
clMsg ("* %16s: %d",name,count);
if (count)
{
dest.reserve(count);
dest.insert (dest.begin(), (T*)O->pointer(), (T*)O->pointer() + count);
}
if (O) O->close ();
}
bool xrCompressor::testEqual(LPCSTR path, IReader* base)
{
bool res = false;
IReader* test = FS.r_open (path);
if(test->length() == base->length())
{
if( 0==memcmp(test->pointer(),base->pointer(),base->length()) )
res = TRUE;
}
FS.r_close (test);
return res;
}
bool CSavedGameWrapper::valid_saved_game (IReader &stream)
{
if (stream.length() < 8)
return (false);
if (stream.r_u32() != u32(-1))
return (false);
if (stream.r_u32() < 0x0002)
return (false);
return (true);
}
u32 CParticleManager::LoadActions(int alist_id, IReader& R)
{
// Execute the specified action list.
ParticleActions* pa = GetActionListPtr(alist_id);
pa->clear ();
if (R.length()){
u32 cnt = R.r_u32();
for (u32 k=0; k<cnt; k++){
ParticleAction* act = CreateAction ((PActionEnum)R.r_u32());
act->Load (R);
pa->append (act);
}
}
return pa->size();
}
CDemoPlay::CDemoPlay(const char *name, float ms, u32 cycles, float life_time) : CEffectorCam(cefDemo,life_time/*,FALSE*/)
{
Msg ("*** Playing demo: %s",name);
Console->Execute ("hud_weapon 0");
if( g_bBenchmark || g_SASH.IsRunning() )
Console->Execute ("hud_draw 0");
fSpeed = ms;
dwCyclesLeft = cycles?cycles:1;
m_pMotion = 0;
m_MParam = 0;
string_path nm, fn;
xr_strcpy (nm,sizeof(nm),name);
LPSTR extp =strext(nm);
if (extp)
xr_strcpy ( nm, sizeof( nm ) - ( extp - nm ), ".anm");
if ( FS.exist(fn,"$level$",nm) || FS.exist(fn,"$game_anims$",nm) )
{
m_pMotion = xr_new<COMotion> ();
m_pMotion->LoadMotion (fn);
m_MParam = xr_new<SAnimParams> ();
m_MParam->Set (m_pMotion);
m_MParam->Play ();
}else{
if (!FS.exist(name)) {
g_pGameLevel->Cameras().RemoveCamEffector (cefDemo);
return ;
}
IReader* fs = FS.r_open (name);
u32 sz = fs->length();
if (sz%sizeof(Fmatrix) != 0) {
FS.r_close (fs);
g_pGameLevel->Cameras().RemoveCamEffector (cefDemo);
return ;
}
seq.resize (sz/sizeof(Fmatrix));
m_count = seq.size();
CopyMemory (&*seq.begin(),fs->pointer(),sz);
FS.r_close (fs);
Log ("~ Total key-frames: ",m_count);
}
stat_started = FALSE;
Device.PreCache (50, true, false);
}
CSavedGameWrapper::CSavedGameWrapper (LPCSTR saved_game_name)
{
string_path file_name;
saved_game_full_name (saved_game_name,file_name);
R_ASSERT3 (FS.exist(file_name),"There is no saved game ",file_name);
IReader *stream = FS.r_open(file_name);
if (!valid_saved_game(*stream)) {
FS.r_close (stream);
CALifeTimeManager time_manager(alife_section);
m_game_time = time_manager.game_time();
m_actor_health = 1.f;
m_level_id = ai().game_graph().header().levels().begin()->first;
return;
}
u32 source_count = stream->r_u32();
void *source_data = xr_malloc(source_count);
rtc_decompress (source_data,source_count,stream->pointer(),stream->length() - 3*sizeof(u32));
FS.r_close (stream);
IReader reader(source_data,source_count);
{
CALifeTimeManager time_manager(alife_section);
time_manager.load (reader);
m_game_time = time_manager.game_time();
}
{
R_ASSERT2 (reader.find_chunk(OBJECT_CHUNK_DATA),"Can't find chunk OBJECT_CHUNK_DATA!");
u32 count = reader.r_u32();
VERIFY (count > 0);
CSE_ALifeDynamicObject *object = CALifeObjectRegistry::get_object(reader);
VERIFY (object->ID == 0);
CSE_ALifeCreatureActor *actor = smart_cast<CSE_ALifeCreatureActor*>(object);
VERIFY (actor);
m_actor_health = actor->g_Health();
m_level_id = ai().game_graph().vertex(object->m_tGraphID)->level_id();
F_entity_Destroy (object);
}
xr_free (source_data);
}
bool operator ()(char* o){
//compare file names
int eq = xr_strcmp(m_full_name,o);
if(0!=eq)
return false;
if( !m_flags.test(eDontCheckFileSize) ){
//compare file size
const CLocatorAPI::file* f = m_fs_old->exist("$target_folder$",o);
u32 file_size = f->size_real;
if ( (f->vfs==0xffffffff) && (file_size != m_file_size) )
return false;
};
//compare file crc
if( !m_crc32 && !m_flags.test(eDontCheckCRC) ){
IReader* r = m_fs_new->r_open ("$target_folder$",m_full_name);
m_crc32 = crc32 (r->pointer(),r->length());
m_fs_new->r_close(r);
};
if( !m_flags.test(eDontCheckCRC) ){
IReader* r_ = m_fs_old->r_open("$target_folder$",o);
u32 crc32_ = crc32 (r_->pointer(),r_->length());
m_fs_old->r_close(r_);
if(m_crc32!=crc32_)
return false;
}
if( !m_flags.test(eDontCheckBinary) ){
//compare files binary content
IReader* f1 = m_fs_new->r_open ("$target_folder$",m_full_name);
IReader* f2 = m_fs_old->r_open ("$target_folder$",o);
int res = memcmp(f1->pointer(),f2->pointer(),f1->length());
m_fs_new->r_close(f1);
m_fs_old->r_close(f2);
if(0!=res)
return false;
}
return true;
}
HRESULT __stdcall Open (D3DXINCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes)
{
string_path pname;
strconcat (sizeof(pname),pname,::Render->getShaderPath(),pFileName);
IReader* R = FS.r_open ("$game_shaders$",pname);
if (0==R) {
// possibly in shared directory or somewhere else - open directly
R = FS.r_open ("$game_shaders$",pFileName);
if (0==R) return E_FAIL;
}
// duplicate and zero-terminate
u32 size = R->length();
u8* data = xr_alloc<u8> (size + 1);
CopyMemory (data,R->pointer(),size);
data[size] = 0;
FS.r_close (R);
*ppData = data;
*pBytes = size;
return D3D_OK;
}
//--------------------------------------------------------------------------------------------------------------
SPS* CResourceManager::_CreatePS (LPCSTR name)
{
LPSTR N = LPSTR(name);
map_PS::iterator I = m_ps.find (N);
if (I!=m_ps.end()) return I->second;
else
{
SPS* _ps = xr_new<SPS> ();
_ps->dwFlags |= xr_resource_flagged::RF_REGISTERED;
m_ps.insert (mk_pair(_ps->set_name(name),_ps));
if (0==stricmp(name,"null")) {
_ps->ps = NULL;
return _ps;
}
// Open file
includer Includer;
string_path cname;
strconcat (sizeof(cname), cname,::Render->getShaderPath(),name,".ps");
FS.update_path (cname, "$game_shaders$", cname);
// duplicate and zero-terminate
IReader* R = FS.r_open(cname);
R_ASSERT2 (R,cname);
u32 size = R->length();
char* data = xr_alloc<char>(size + 1);
CopyMemory (data,R->pointer(),size);
data[size] = 0;
FS.r_close (R);
// Select target
LPCSTR c_target = "ps_2_0";
LPCSTR c_entry = "main";
if (strstr(data,"main_ps_1_1")) { c_target = "ps_1_1"; c_entry = "main_ps_1_1"; }
if (strstr(data,"main_ps_1_2")) { c_target = "ps_1_2"; c_entry = "main_ps_1_2"; }
if (strstr(data,"main_ps_1_3")) { c_target = "ps_1_3"; c_entry = "main_ps_1_3"; }
if (strstr(data,"main_ps_1_4")) { c_target = "ps_1_4"; c_entry = "main_ps_1_4"; }
if (strstr(data,"main_ps_2_0")) { c_target = "ps_2_0"; c_entry = "main_ps_2_0"; }
// Compile
LPD3DXBUFFER pShaderBuf = NULL;
LPD3DXBUFFER pErrorBuf = NULL;
LPD3DXSHADER_CONSTANTTABLE pConstants = NULL;
HRESULT _hr = S_OK;
_hr = ::Render->shader_compile (name,data,size, NULL, &Includer, c_entry, c_target, D3DXSHADER_DEBUG | D3DXSHADER_PACKMATRIX_ROWMAJOR /*| D3DXSHADER_PREFER_FLOW_CONTROL*/, &pShaderBuf, &pErrorBuf, NULL);
//_hr = D3DXCompileShader (text,text_size, NULL, &Includer, c_entry, c_target, D3DXSHADER_DEBUG | D3DXSHADER_PACKMATRIX_ROWMAJOR, &pShaderBuf, &pErrorBuf, NULL);
xr_free (data);
LPCSTR last_error = "";
if (SUCCEEDED(_hr))
{
if (pShaderBuf)
{
_hr = HW.pDevice->CreatePixelShader ((DWORD*)pShaderBuf->GetBufferPointer(), &_ps->ps);
if (SUCCEEDED(_hr)) {
LPCVOID data = NULL;
_hr = D3DXFindShaderComment ((DWORD*)pShaderBuf->GetBufferPointer(),MAKEFOURCC('C','T','A','B'),&data,NULL);
if (SUCCEEDED(_hr) && data)
{
pConstants = LPD3DXSHADER_CONSTANTTABLE(data);
_ps->constants.parse (pConstants,0x1);
}
else
_hr = E_FAIL;
}
}
else
_hr = E_FAIL;
}else
{
if (pErrorBuf)
last_error = (LPCSTR)pErrorBuf->GetBufferPointer();
}
// Real Wolf.10.12.2014
string1024 buff;
if (FAILED(_hr))
{
if (xr_strlen(last_error))
sprintf_s(buff, 1023, "ќшибка компил¤ции шейдера %s: %s ", name, last_error);
else
sprintf_s(buff, 1023, "ќшибка компил¤ции шейдера %s. ¬озможна ошибка в скрипте, или\n видеокарта не поддерживает пиксельные шейдеры 1.1", name);
Msg(buff);
}
pConstants = NULL;
_RELEASE(pShaderBuf);
_RELEASE(pErrorBuf);
CHECK_OR_EXIT (
!FAILED(_hr),
make_string(buff)
);
return _ps;
}
}
ID3DBaseTexture* CRender::texture_load(LPCSTR fRName, u32& ret_msize)
{
ID3DTexture2D* pTexture2D = NULL;
IDirect3DCubeTexture9* pTextureCUBE = NULL;
string_path fn;
u32 dwWidth,dwHeight;
u32 img_size = 0;
int img_loaded_lod = 0;
D3DFORMAT fmt;
u32 mip_cnt=u32(-1);
// validation
R_ASSERT (fRName);
R_ASSERT (fRName[0]);
// make file name
string_path fname;
xr_strcpy(fname,fRName); //. andy if (strext(fname)) *strext(fname)=0;
fix_texture_name (fname);
IReader* S = NULL;
//if (FS.exist(fn,"$game_textures$",fname, ".dds") && strstr(fname,"_bump")) goto _BUMP;
if (!FS.exist(fn,"$game_textures$", fname, ".dds") && strstr(fname,"_bump")) goto _BUMP_from_base;
if (FS.exist(fn,"$level$", fname, ".dds")) goto _DDS;
if (FS.exist(fn,"$game_saves$", fname, ".dds")) goto _DDS;
if (FS.exist(fn,"$game_textures$", fname, ".dds")) goto _DDS;
#ifdef _EDITOR
ELog.Msg(mtError,"Can't find texture '%s'",fname);
return 0;
#else
Msg("! Can't find texture '%s'",fname);
R_ASSERT(FS.exist(fn,"$game_textures$", "ed\\ed_not_existing_texture",".dds"));
goto _DDS;
// Debug.fatal(DEBUG_INFO,"Can't find texture '%s'",fname);
#endif
_DDS:
{
// Load and get header
D3DXIMAGE_INFO IMG;
S = FS.r_open (fn);
#ifdef DEBUG
Msg ("* Loaded: %s[%d]b",fn,S->length());
#endif // DEBUG
img_size = S->length ();
R_ASSERT (S);
HRESULT const result = D3DXGetImageInfoFromFileInMemory (S->pointer(),S->length(),&IMG);
if ( FAILED(result) ) {
Msg ("! Can't get image info for texture '%s'",fn);
FS.r_close (S);
string_path temp;
R_ASSERT ( FS.exist( temp, "$game_textures$", "ed\\ed_not_existing_texture", ".dds" ) );
R_ASSERT ( xr_strcmp(temp,fn) );
xr_strcpy ( fn, temp );
goto _DDS;
}
if (IMG.ResourceType == D3DRTYPE_CUBETEXTURE) goto _DDS_CUBE;
else goto _DDS_2D;
_DDS_CUBE:
{
HRESULT const result =
D3DXCreateCubeTextureFromFileInMemoryEx(
HW.pDevice,
S->pointer(),S->length(),
D3DX_DEFAULT,
IMG.MipLevels,0,
IMG.Format,
D3DPOOL_MANAGED,
D3DX_DEFAULT,
D3DX_DEFAULT,
0,&IMG,0,
&pTextureCUBE
);
FS.r_close (S);
if ( FAILED(result) ) {
Msg ("! Can't load texture '%s'",fn);
string_path temp;
R_ASSERT ( FS.exist( temp, "$game_textures$", "ed\\ed_not_existing_texture", ".dds" ) );
R_ASSERT ( xr_strcmp(temp,fn) );
xr_strcpy ( fn, temp );
goto _DDS;
}
// OK
dwWidth = IMG.Width;
dwHeight = IMG.Height;
fmt = IMG.Format;
ret_msize = calc_texture_size(img_loaded_lod, mip_cnt, img_size);
mip_cnt = pTextureCUBE->GetLevelCount();
return pTextureCUBE;
}
_DDS_2D:
{
strlwr (fn);
// Load SYS-MEM-surface, bound to device restrictions
ID3DTexture2D* T_sysmem;
HRESULT const result =
D3DXCreateTextureFromFileInMemoryEx(
HW.pDevice,S->pointer(),S->length(),
D3DX_DEFAULT,D3DX_DEFAULT,
IMG.MipLevels,0,
IMG.Format,
D3DPOOL_SYSTEMMEM,
D3DX_DEFAULT,
D3DX_DEFAULT,
0,&IMG,0,
&T_sysmem
);
FS.r_close (S);
if ( FAILED(result) ) {
Msg ("! Can't load texture '%s'",fn);
string_path temp;
R_ASSERT ( FS.exist( temp, "$game_textures$", "ed\\ed_not_existing_texture", ".dds" ) );
strlwr (temp);
R_ASSERT ( xr_strcmp(temp,fn) );
xr_strcpy ( fn, temp );
goto _DDS;
}
img_loaded_lod = get_texture_load_lod(fn);
pTexture2D = TW_LoadTextureFromTexture(T_sysmem,IMG.Format, img_loaded_lod, dwWidth, dwHeight);
mip_cnt = pTexture2D->GetLevelCount();
_RELEASE (T_sysmem);
// OK
fmt = IMG.Format;
ret_msize = calc_texture_size(img_loaded_lod, mip_cnt, img_size);
return pTexture2D;
}
}
/*
_BUMP:
{
// Load SYS-MEM-surface, bound to device restrictions
D3DXIMAGE_INFO IMG;
IReader* S = FS.r_open (fn);
msize = S->length ();
ID3DTexture2D* T_height_gloss;
R_CHK(D3DXCreateTextureFromFileInMemoryEx(
HW.pDevice, S->pointer(),S->length(),
D3DX_DEFAULT,D3DX_DEFAULT, D3DX_DEFAULT,0,D3DFMT_A8R8G8B8,
D3DPOOL_SYSTEMMEM, D3DX_DEFAULT,D3DX_DEFAULT,
0,&IMG,0,&T_height_gloss ));
FS.r_close (S);
//TW_Save (T_height_gloss,fname,"debug-0","original");
// Create HW-surface, compute normal map
ID3DTexture2D* T_normal_1 = 0;
R_CHK(D3DXCreateTexture (HW.pDevice,IMG.Width,IMG.Height,D3DX_DEFAULT,0,D3DFMT_A8R8G8B8,D3DPOOL_SYSTEMMEM,&T_normal_1));
R_CHK(D3DXComputeNormalMap (T_normal_1,T_height_gloss,0,0,D3DX_CHANNEL_RED,_BUMPHEIGH));
//TW_Save (T_normal_1,fname,"debug-1","normal");
// Transfer gloss-map
TW_Iterate_1OP (T_normal_1,T_height_gloss,it_gloss_rev);
//TW_Save (T_normal_1,fname,"debug-2","normal-G");
// Compress
fmt = D3DFMT_DXT5;
ID3DTexture2D* T_normal_1C = TW_LoadTextureFromTexture(T_normal_1,fmt,psTextureLOD,dwWidth,dwHeight);
//TW_Save (T_normal_1C,fname,"debug-3","normal-G-C");
#if RENDER==R_R2
// Decompress (back)
fmt = D3DFMT_A8R8G8B8;
ID3DTexture2D* T_normal_1U = TW_LoadTextureFromTexture(T_normal_1C,fmt,0,dwWidth,dwHeight);
// TW_Save (T_normal_1U,fname,"debug-4","normal-G-CU");
// Calculate difference
ID3DTexture2D* T_normal_1D = 0;
R_CHK(D3DXCreateTexture(HW.pDevice,dwWidth,dwHeight,T_normal_1U->GetLevelCount(),0,D3DFMT_A8R8G8B8,D3DPOOL_SYSTEMMEM,&T_normal_1D));
TW_Iterate_2OP (T_normal_1D,T_normal_1,T_normal_1U,it_difference);
// TW_Save (T_normal_1D,fname,"debug-5","normal-G-diff");
// Reverse channels back + transfer heightmap
TW_Iterate_1OP (T_normal_1D,T_height_gloss,it_height_rev);
// TW_Save (T_normal_1D,fname,"debug-6","normal-G-diff-H");
// Compress
fmt = D3DFMT_DXT5;
ID3DTexture2D* T_normal_2C = TW_LoadTextureFromTexture(T_normal_1D,fmt,0,dwWidth,dwHeight);
// TW_Save (T_normal_2C,fname,"debug-7","normal-G-diff-H-C");
_RELEASE (T_normal_1U );
_RELEASE (T_normal_1D );
//
string256 fnameB;
strconcat (fnameB,"$user$",fname,"X");
ref_texture t_temp = dxRenderDeviceRender::Instance().Resources->_CreateTexture (fnameB);
t_temp->surface_set (T_normal_2C );
_RELEASE (T_normal_2C ); // texture should keep reference to it by itself
#endif
// release and return
// T_normal_1C - normal.gloss, reversed
// T_normal_2C - 2*error.height, non-reversed
_RELEASE (T_height_gloss );
_RELEASE (T_normal_1 );
return T_normal_1C;
}
*/
_BUMP_from_base:
{
Msg ("! auto-generated bump map: %s",fname);
//////////////////
#ifndef _EDITOR
if (strstr(fname,"_bump#"))
{
R_ASSERT2 (FS.exist(fn,"$game_textures$", "ed\\ed_dummy_bump#", ".dds"), "ed_dummy_bump#");
S = FS.r_open (fn);
R_ASSERT2 (S, fn);
img_size = S->length ();
goto _DDS_2D;
}
if (strstr(fname,"_bump"))
{
R_ASSERT2 (FS.exist(fn,"$game_textures$", "ed\\ed_dummy_bump", ".dds"),"ed_dummy_bump");
S = FS.r_open (fn);
R_ASSERT2 (S, fn);
img_size = S->length ();
goto _DDS_2D;
}
#endif
//////////////////
*strstr (fname,"_bump") = 0;
R_ASSERT2 (FS.exist(fn,"$game_textures$", fname, ".dds"),fname);
// Load SYS-MEM-surface, bound to device restrictions
D3DXIMAGE_INFO IMG;
S = FS.r_open (fn);
img_size = S->length ();
ID3DTexture2D* T_base;
R_CHK2(D3DXCreateTextureFromFileInMemoryEx(
HW.pDevice, S->pointer(),S->length(),
D3DX_DEFAULT,D3DX_DEFAULT, D3DX_DEFAULT,0,D3DFMT_A8R8G8B8,
D3DPOOL_SYSTEMMEM, D3DX_DEFAULT,D3DX_DEFAULT,
0,&IMG,0,&T_base ), fn);
FS.r_close (S);
// Create HW-surface
ID3DTexture2D* T_normal_1 = 0;
R_CHK(D3DXCreateTexture (HW.pDevice,IMG.Width,IMG.Height,D3DX_DEFAULT,0,D3DFMT_A8R8G8B8,D3DPOOL_SYSTEMMEM, &T_normal_1));
R_CHK(D3DXComputeNormalMap (T_normal_1,T_base,0,D3DX_NORMALMAP_COMPUTE_OCCLUSION,D3DX_CHANNEL_LUMINANCE,_BUMPHEIGH));
// Transfer gloss-map
TW_Iterate_1OP (T_normal_1,T_base,it_gloss_rev_base);
// Compress
fmt = D3DFMT_DXT5;
img_loaded_lod = get_texture_load_lod(fn);
ID3DTexture2D* T_normal_1C = TW_LoadTextureFromTexture(T_normal_1, fmt, img_loaded_lod, dwWidth, dwHeight);
mip_cnt = T_normal_1C->GetLevelCount();
#if RENDER==R_R2
// Decompress (back)
fmt = D3DFMT_A8R8G8B8;
ID3DTexture2D* T_normal_1U = TW_LoadTextureFromTexture(T_normal_1C,fmt,0,dwWidth,dwHeight);
// Calculate difference
ID3DTexture2D* T_normal_1D = 0;
R_CHK(D3DXCreateTexture(HW.pDevice,dwWidth,dwHeight,T_normal_1U->GetLevelCount(),0,D3DFMT_A8R8G8B8,D3DPOOL_SYSTEMMEM,&T_normal_1D));
TW_Iterate_2OP (T_normal_1D,T_normal_1,T_normal_1U,it_difference);
// Reverse channels back + transfer heightmap
TW_Iterate_1OP (T_normal_1D,T_base,it_height_rev_base);
// Compress
fmt = D3DFMT_DXT5;
ID3DTexture2D* T_normal_2C = TW_LoadTextureFromTexture(T_normal_1D,fmt,0,dwWidth,dwHeight);
_RELEASE (T_normal_1U );
_RELEASE (T_normal_1D );
//
string256 fnameB;
strconcat (sizeof(fnameB),fnameB,"$user$",fname,"_bumpX");
ref_texture t_temp = dxRenderDeviceRender::Instance().Resources->_CreateTexture (fnameB);
t_temp->surface_set (T_normal_2C );
_RELEASE (T_normal_2C ); // texture should keep reference to it by itself
#endif
// T_normal_1C - normal.gloss, reversed
// T_normal_2C - 2*error.height, non-reversed
_RELEASE (T_base);
_RELEASE (T_normal_1);
ret_msize = calc_texture_size(img_loaded_lod, mip_cnt, img_size);
return T_normal_1C;
}
}
void xrServer::SLS_Default ()
{
if (game->custom_sls_default()) {
game->sls_default ();
return;
}
#ifdef USE_DESIGNER_KEY
bool _designer = !!strstr(Core.Params,"-designer");
CSE_ALifeCreatureActor *_actor = 0;
#endif
string256 fn_spawn;
if (FS.exist(fn_spawn, "$level$", "level.spawn")) {
IReader* SP = FS.r_open(fn_spawn);
NET_Packet P;
u32 S_id;
for (IReader *S = SP->open_chunk_iterator(S_id); S; S = SP->open_chunk_iterator(S_id,S)) {
P.B.count = S->length();
S->r (P.B.data,P.B.count);
u16 ID;
P.r_begin (ID);
R_ASSERT (M_SPAWN==ID);
ClientID clientID;clientID.set(0);
#ifdef USE_DESIGNER_KEY
CSE_Abstract *entity =
#endif
Process_spawn(P,clientID);
#ifdef USE_DESIGNER_KEY
if (_designer) {
CSE_ALifeCreatureActor *actor = smart_cast<CSE_ALifeCreatureActor*>(entity);
if (actor)
_actor = actor;
}
#endif
}
FS.r_close (SP);
}
#ifdef USE_DESIGNER_KEY
if (!_designer)
return;
if (_actor)
return;
_actor = smart_cast<CSE_ALifeCreatureActor*>(entity_Create("actor"));
_actor->o_Position = Fvector().set(0.f,0.f,0.f);
_actor->set_name_replace("designer");
_actor->s_flags.flags |= M_SPAWN_OBJECT_ASPLAYER;
NET_Packet packet;
packet.w_begin (M_SPAWN);
_actor->Spawn_Write (packet,TRUE);
u16 id;
packet.r_begin (id);
R_ASSERT (id == M_SPAWN);
ClientID clientID;
clientID.set (0);
Process_spawn (packet,clientID);
#endif
}
//--------------------------------------------------------------------------------------------------------------
SVS* CResourceManager::_CreateVS (LPCSTR _name)
{
string_path name;
strcpy_s (name,_name);
if (0 == ::Render->m_skinning) strcat(name,"_0");
if (1 == ::Render->m_skinning) strcat(name,"_1");
if (2 == ::Render->m_skinning) strcat(name,"_2");
LPSTR N = LPSTR (name);
map_VS::iterator I = m_vs.find (N);
if (I!=m_vs.end()) return I->second;
else
{
SVS* _vs = xr_new<SVS> ();
_vs->dwFlags |= xr_resource_flagged::RF_REGISTERED;
m_vs.insert (mk_pair(_vs->set_name(name),_vs));
if (0==stricmp(_name,"null")) {
_vs->vs = NULL;
return _vs;
}
includer Includer;
LPD3DXBUFFER pShaderBuf = NULL;
LPD3DXBUFFER pErrorBuf = NULL;
LPD3DXSHADER_CONSTANTTABLE pConstants = NULL;
HRESULT _hr = S_OK;
string_path cname;
strconcat (sizeof(cname),cname,::Render->getShaderPath(),_name,".vs");
FS.update_path (cname, "$game_shaders$", cname);
// LPCSTR target = NULL;
IReader* fs = FS.r_open(cname);
R_ASSERT3 (fs, "shader file doesnt exist", cname);
// Select target
LPCSTR c_target = "vs_2_0";
LPCSTR c_entry = "main";
/*if (HW.Caps.geometry.dwVersion>=CAP_VERSION(3,0)) target="vs_3_0";
else*/ if (HW.Caps.geometry_major>=2) c_target="vs_2_0";
else c_target="vs_1_1";
LPSTR pfs = xr_alloc<char>(fs->length() + 1);
strncpy (pfs, (LPCSTR)fs->pointer(), fs->length());
pfs [fs->length()] = 0;
if (strstr(pfs, "main_vs_1_1")) { c_target = "vs_1_1"; c_entry = "main_vs_1_1"; }
if (strstr(pfs, "main_vs_2_0")) { c_target = "vs_2_0"; c_entry = "main_vs_2_0"; }
xr_free(pfs);
// vertex
R_ASSERT2 (fs,cname);
_hr = ::Render->shader_compile(name,LPCSTR(fs->pointer()),fs->length(), NULL, &Includer, c_entry, c_target, D3DXSHADER_DEBUG | D3DXSHADER_PACKMATRIX_ROWMAJOR /*| D3DXSHADER_PREFER_FLOW_CONTROL*/, &pShaderBuf, &pErrorBuf, NULL);
// _hr = D3DXCompileShader (LPCSTR(fs->pointer()),fs->length(), NULL, &Includer, "main", target, D3DXSHADER_DEBUG | D3DXSHADER_PACKMATRIX_ROWMAJOR, &pShaderBuf, &pErrorBuf, NULL);
FS.r_close (fs);
if (SUCCEEDED(_hr))
{
if (pShaderBuf)
{
_hr = HW.pDevice->CreateVertexShader ((DWORD*)pShaderBuf->GetBufferPointer(), &_vs->vs);
if (SUCCEEDED(_hr)) {
LPCVOID data = NULL;
_hr = D3DXFindShaderComment ((DWORD*)pShaderBuf->GetBufferPointer(),MAKEFOURCC('C','T','A','B'),&data,NULL);
if (SUCCEEDED(_hr) && data)
{
pConstants = LPD3DXSHADER_CONSTANTTABLE(data);
_vs->constants.parse (pConstants,0x2);
} else _hr = E_FAIL;
}
}
else _hr = E_FAIL;
} else {
VERIFY (pErrorBuf);
Log ("! error: ",(LPCSTR)pErrorBuf->GetBufferPointer());
}
_RELEASE (pShaderBuf);
_RELEASE (pErrorBuf);
pConstants = NULL;
R_CHK (_hr);
return _vs;
}
}
void xrCompressor::CompressOne(LPCSTR path)
{
filesTOTAL ++;
if (testSKIP(path))
{
filesSKIP ++;
printf (" - a SKIP");
Msg ("%-80s - SKIP",path);
return;
}
string_path fn;
strconcat (sizeof(fn), fn, target_name.c_str(), "\\", path);
if (::GetFileAttributes(fn)==u32(-1))
{
filesSKIP ++;
printf (" - CAN'T OPEN");
Msg ("%-80s - CAN'T OPEN",path);
return;
}
IReader* src = FS.r_open (fn);
if (0==src)
{
filesSKIP ++;
printf (" - CAN'T OPEN");
Msg ("%-80s - CAN'T OPEN",path);
return;
}
bytesSRC += src->length ();
u32 c_crc32 = crc32 (src->pointer(),src->length());
u32 c_ptr = 0;
u32 c_size_real = 0;
u32 c_size_compressed = 0;
u32 a_tests = 0;
ALIAS* A = testALIAS (src,c_crc32,a_tests);
printf ("%3da ",a_tests);
if(A)
{
filesALIAS ++;
printf ("ALIAS");
Msg ("%-80s - ALIAS (%s)",path,A->path);
// Alias found
c_ptr = A->c_ptr;
c_size_real = A->c_size_real;
c_size_compressed = A->c_size_compressed;
} else
{
if (testVFS(path))
{
filesVFS ++;
// Write into BaseFS
c_ptr = fs_pack_writer->tell ();
c_size_real = src->length();
c_size_compressed = src->length();
fs_pack_writer->w (src->pointer(),c_size_real);
printf ("VFS");
Msg ("%-80s - VFS",path);
} else
{ //if(testVFS(path))
// Compress into BaseFS
c_ptr = fs_pack_writer->tell();
c_size_real = src->length();
if (0!=c_size_real)
{
u32 c_size_max = rtc_csize (src->length());
u8* c_data = xr_alloc<u8> (c_size_max);
t_compress.Begin ();
c_size_compressed = c_size_max;
if (bFast)
{
R_ASSERT(LZO_E_OK == lzo1x_1_compress ((u8*)src->pointer(),c_size_real,c_data,&c_size_compressed,c_heap));
}else
{
R_ASSERT(LZO_E_OK == lzo1x_999_compress ((u8*)src->pointer(),c_size_real,c_data,&c_size_compressed,c_heap));
}
t_compress.End ();
if ((c_size_compressed+16) >= c_size_real)
{
// Failed to compress - revert to VFS
filesVFS ++;
c_size_compressed = c_size_real;
fs_pack_writer->w (src->pointer(),c_size_real);
printf ("VFS (R)");
Msg ("%-80s - VFS (R)",path);
} else
{
// Compressed OK - optimize
if (!bFast)
{
u8* c_out = xr_alloc<u8> (c_size_real);
u32 c_orig = c_size_real;
R_ASSERT (LZO_E_OK == lzo1x_optimize (c_data,c_size_compressed,c_out,&c_orig, NULL));
R_ASSERT (c_orig == c_size_real );
xr_free (c_out);
}//bFast
fs_pack_writer->w (c_data,c_size_compressed);
printf ("%3.1f%%", 100.f*float(c_size_compressed)/float(src->length()));
Msg ("%-80s - OK (%3.1f%%)",path,100.f*float(c_size_compressed)/float(src->length()));
}
// cleanup
xr_free (c_data);
}else
{ //0!=c_size_real
filesVFS ++;
c_size_compressed = c_size_real;
printf ("VFS (R)");
Msg ("%-80s - EMPTY FILE",path);
}
}//test VFS
} //(A)
// Write description
write_file_header (path,c_crc32,c_ptr,c_size_real,c_size_compressed);
if (0==A)
{
// Register for future aliasing
ALIAS R;
R.path = xr_strdup (fn);
R.crc = c_crc32;
R.c_ptr = c_ptr;
R.c_size_real = c_size_real;
R.c_size_compressed = c_size_compressed;
aliases.insert (mk_pair(R.c_size_real,R));
}
FS.r_close (src);
}
void CSoundRender_Source::LoadWave (LPCSTR pName)
{
pname = pName;
// Load file into memory and parse WAV-format
OggVorbis_File ovf;
ov_callbacks ovc = {ov_read_func,ov_seek_func,ov_close_func,ov_tell_func};
IReader* wave = FS.r_open (pname.c_str());
R_ASSERT3 (wave&&wave->length(),"Can't open wave file:",pname.c_str());
ov_open_callbacks (wave,&ovf,NULL,0,ovc);
vorbis_info* ovi = ov_info(&ovf,-1);
// verify
R_ASSERT3 (ovi,"Invalid source info:",pName);
R_ASSERT3 (ovi->channels==1,"Invalid source num channels:",pName);
R_ASSERT3 (ovi->rate==44100,"Invalid source rate:",pName);
WAVEFORMATEX wfxdest = SoundRender->wfm;
wfxdest.nChannels = u16(ovi->channels);
wfxdest.nBlockAlign = wfxdest.nChannels * wfxdest.wBitsPerSample / 8;
wfxdest.nAvgBytesPerSec = wfxdest.nSamplesPerSec * wfxdest.nBlockAlign;
s64 pcm_total = ov_pcm_total(&ovf,-1);
if (psSoundFreq==sf_22K) pcm_total/=2;
dwBytesTotal = u32(pcm_total*wfxdest.nBlockAlign);
dwBytesPerMS = wfxdest.nAvgBytesPerSec/1000;
// dwBytesPerSec = wfxdest.nAvgBytesPerSec;
dwTimeTotal = u32 ( sdef_source_footer + u64( (u64(dwBytesTotal)*u64(1000))/u64(wfxdest.nAvgBytesPerSec) ) );
vorbis_comment* ovm = ov_comment(&ovf,-1);
if (ovm->comments){
IReader F (ovm->user_comments[0],ovm->comment_lengths[0]);
u32 vers = F.r_u32 ();
if (vers==0x0001){
m_fMinDist = F.r_float ();
m_fMaxDist = F.r_float ();
m_fBaseVolume = 1.f;
m_uGameType = F.r_u32 ();
m_fMaxAIDist = m_fMaxDist;
}else if (vers==0x0002){
m_fMinDist = F.r_float ();
m_fMaxDist = F.r_float ();
m_fBaseVolume = F.r_float ();
m_uGameType = F.r_u32 ();
m_fMaxAIDist = m_fMaxDist;
}else if (vers==OGG_COMMENT_VERSION){
m_fMinDist = F.r_float ();
m_fMaxDist = F.r_float ();
m_fBaseVolume = F.r_float ();
m_uGameType = F.r_u32 ();
m_fMaxAIDist = F.r_float ();
}else{
Log ("! Invalid ogg-comment version, file: ",pName);
}
}else{
Log ("! Missing ogg-comment, file: ",pName);
}
R_ASSERT3((m_fMaxAIDist>=0.1f)&&(m_fMaxDist>=0.1f),"Invalid max distance.",pName);
ov_clear (&ovf);
FS.r_close (wave);
}
////////////////////////////////////////////////////////////////////////////
// CSE_Abstract
////////////////////////////////////////////////////////////////////////////
CSE_Abstract::CSE_Abstract (LPCSTR caSection)
{
m_editor_flags.zero ();
RespawnTime = 0;
net_Ready = FALSE;
ID = 0xffff;
ID_Parent = 0xffff;
ID_Phantom = 0xffff;
owner = 0;
s_gameid = 0;
s_RP = 0xFE; // Use supplied coords
s_flags.assign (0);
s_name = caSection;
s_name_replace = 0; //xr_strdup("");
o_Angle.set (0.f,0.f,0.f);
o_Position.set (0.f,0.f,0.f);
m_bALifeControl = false;
m_wVersion = 0;
m_script_version = 0;
m_tClassID = TEXT2CLSID(pSettings->r_string(caSection,"class"));
// m_spawn_probability = 1.f;
m_spawn_flags.zero ();
m_spawn_flags.set (flSpawnEnabled ,TRUE);
m_spawn_flags.set (flSpawnOnSurgeOnly ,TRUE);
m_spawn_flags.set (flSpawnSingleItemOnly ,TRUE);
m_spawn_flags.set (flSpawnIfDestroyedOnly ,TRUE);
m_spawn_flags.set (flSpawnInfiniteCount ,TRUE);
// m_max_spawn_count = 1;
// m_spawn_control = "";
// m_spawn_count = 0;
// m_last_spawn_time = 0;
// m_next_spawn_time = 0;
// m_min_spawn_interval = 0;
// m_max_spawn_interval = 0;
m_ini_file = 0;
if (pSettings->line_exist(caSection,"custom_data")) {
string_path file_name;
FS.update_path (file_name,"$game_config$",pSettings->r_string(caSection,"custom_data"));
if (!FS.exist(file_name)) {
Msg ("! cannot open config file %s",file_name);
}
else {
IReader *reader = FS.r_open(file_name);
VERIFY (reader);
{
int size = reader->length()*sizeof(char);
LPSTR temp = (LPSTR)_alloca(size + 1);
CopyMemory (temp,reader->pointer(),size);
temp[size] = 0;
m_ini_string = temp;
}
FS.r_close (reader);
}
}
#ifndef AI_COMPILER
m_script_clsid = object_factory().script_clsid(m_tClassID);
#endif
client_data.clear ();
}
void global_claculation_data::xrLoad()
{
string_path N;
FS.update_path ( N, "$game_data$", "shaders_xrlc.xr" );
g_shaders_xrlc = new Shader_xrLC_LIB();
g_shaders_xrlc->Load ( N );
// Load CFORM
{
FS.update_path (N,"$level$","build.cform");
IReader* fs = FS.r_open("$level$","build.cform");
R_ASSERT (fs->find_chunk(0));
hdrCFORM H;
fs->r (&H,sizeof(hdrCFORM));
R_ASSERT (CFORM_CURRENT_VERSION==H.version);
Fvector* verts = (Fvector*)fs->pointer();
CDB::TRI* tris = (CDB::TRI*)(verts+H.vertcount);
RCAST_Model.build ( verts, H.vertcount, tris, H.facecount );
Msg("* Level CFORM: %dK",RCAST_Model.memory()/1024);
g_rc_faces.resize (H.facecount);
R_ASSERT(fs->find_chunk(1));
fs->r (&*g_rc_faces.begin(),g_rc_faces.size()*sizeof(b_rc_face));
LevelBB.set (H.aabb);
}
{
slots_data.Load( );
}
// Lights
{
IReader* fs = FS.r_open("$level$","build.lights");
IReader* F; u32 cnt; R_Light* L;
// rgb
F = fs->open_chunk (0);
cnt = F->length()/sizeof(R_Light);
L = (R_Light*)F->pointer();
g_lights.rgb.assign (L,L+cnt);
F->close ();
// hemi
F = fs->open_chunk (1);
cnt = F->length()/sizeof(R_Light);
L = (R_Light*)F->pointer();
g_lights.hemi.assign(L,L+cnt);
F->close ();
// sun
F = fs->open_chunk (2);
cnt = F->length()/sizeof(R_Light);
L = (R_Light*)F->pointer();
g_lights.sun.assign (L,L+cnt);
F->close ();
FS.r_close (fs);
}
// Load level data
{
IReader* fs = FS.r_open ("$level$","build.prj");
IReader* F;
// Version
u32 version;
fs->r_chunk (EB_Version,&version);
R_ASSERT(XRCL_CURRENT_VERSION==version);
// Header
fs->r_chunk (EB_Parameters,&g_params);
// Load level data
transfer("materials", g_materials, *fs, EB_Materials);
transfer("shaders_xrlc",g_shader_compile, *fs, EB_Shaders_Compile);
post_process_materials( *g_shaders_xrlc, g_shader_compile, g_materials );
// process textures
#ifdef DEBUG
xr_vector<b_texture> dbg_textures;
#endif
Status ("Processing textures...");
{
Surface_Init ();
F = fs->open_chunk (EB_Textures);
u32 tex_count = F->length()/sizeof(b_texture);
for (u32 t=0; t<tex_count; t++)
{
Progress (float(t)/float(tex_count));
b_texture TEX;
F->r (&TEX,sizeof(TEX));
#ifdef DEBUG
dbg_textures.push_back( TEX );
#endif
b_BuildTexture BT;
CopyMemory (&BT,&TEX,sizeof(TEX));
// load thumbnail
LPSTR N = BT.name;
if (strchr(N,'.')) *(strchr(N,'.')) = 0;
strlwr (N);
if (0==xr_strcmp(N,"level_lods")) {
// HACK for merged lod textures
BT.dwWidth = 1024;
BT.dwHeight = 1024;
BT.bHasAlpha= TRUE;
BT.pSurface = 0;
} else {
strcat (N,".thm");
IReader* THM = FS.r_open("$game_textures$",N);
R_ASSERT2 (THM, N);
// version
u32 version = 0;
R_ASSERT (THM->r_chunk(THM_CHUNK_VERSION,&version));
// if( version!=THM_CURRENT_VERSION ) FATAL ("Unsupported version of THM file.");
// analyze thumbnail information
R_ASSERT(THM->find_chunk(THM_CHUNK_TEXTUREPARAM));
THM->r (&BT.THM.fmt,sizeof(STextureParams::ETFormat));
BT.THM.flags.assign (THM->r_u32());
BT.THM.border_color = THM->r_u32();
BT.THM.fade_color = THM->r_u32();
BT.THM.fade_amount = THM->r_u32();
BT.THM.mip_filter = THM->r_u32();
BT.THM.width = THM->r_u32();
BT.THM.height = THM->r_u32();
BOOL bLOD=FALSE;
if (N[0]=='l' && N[1]=='o' && N[2]=='d' && N[3]=='\\') bLOD = TRUE;
// load surface if it has an alpha channel or has "implicit lighting" flag
BT.dwWidth = BT.THM.width;
BT.dwHeight = BT.THM.height;
BT.bHasAlpha = BT.THM.HasAlphaChannel();
BT.pSurface = 0;
if (!bLOD)
{
if (BT.bHasAlpha || BT.THM.flags.test(STextureParams::flImplicitLighted))
{
clMsg ("- loading: %s",N);
u32 w=0, h=0;
BT.pSurface = Surface_Load(N,w,h);
R_ASSERT2 (BT.pSurface,"Can't load surface");
if ((w != BT.dwWidth) || (h != BT.dwHeight))
Msg ("! THM doesn't correspond to the texture: %dx%d -> %dx%d", BT.dwWidth, BT.dwHeight, w, h);
BT.Vflip ();
} else {
// Free surface memory
}
}
}
// save all the stuff we've created
g_textures.push_back (BT);
}
}
}
}
void xrLoad(LPCSTR name, bool draft_mode)
{
FS.get_path ("$level$")->_set ((LPSTR)name);
string256 N;
if (!draft_mode) {
// shaders
string_path N;
FS.update_path (N,"$game_data$","shaders_xrlc.xr");
g_shaders_xrlc = xr_new<Shader_xrLC_LIB> ();
g_shaders_xrlc->Load (N);
// Load CFORM
{
strconcat (sizeof(N),N,name,"build.cform");
IReader* fs = FS.r_open(N);
R_ASSERT (fs->find_chunk(0));
hdrCFORM H;
fs->r (&H,sizeof(hdrCFORM));
R_ASSERT (CFORM_CURRENT_VERSION==H.version);
Fvector* verts = (Fvector*)fs->pointer();
CDB::TRI* tris = (CDB::TRI*)(verts+H.vertcount);
Level.build ( verts, H.vertcount, tris, H.facecount );
Level.syncronize ();
Msg("* Level CFORM: %dK",Level.memory()/1024);
g_rc_faces.resize (H.facecount);
R_ASSERT(fs->find_chunk(1));
fs->r (&*g_rc_faces.begin(),g_rc_faces.size()*sizeof(b_rc_face));
LevelBB.set (H.aabb);
FS.r_close (fs);
}
// Load level data
{
strconcat (sizeof(N),N,name,"build.prj");
IReader* fs = FS.r_open (N);
IReader* F;
// Version
u32 version;
fs->r_chunk (EB_Version,&version);
R_ASSERT (XRCL_CURRENT_VERSION >= 17);
R_ASSERT (XRCL_CURRENT_VERSION <= 18);
// Header
b_params Params;
fs->r_chunk (EB_Parameters,&Params);
// Load level data
transfer("materials", g_materials, *fs, EB_Materials);
transfer("shaders_xrlc",g_shader_compile, *fs, EB_Shaders_Compile);
// process textures
Status ("Processing textures...");
{
Surface_Init ();
F = fs->open_chunk (EB_Textures);
u32 tex_count = F->length()/sizeof(b_texture);
for (u32 t=0; t<tex_count; t++)
{
Progress (float(t)/float(tex_count));
b_texture TEX;
F->r (&TEX,sizeof(TEX));
b_BuildTexture BT;
CopyMemory (&BT,&TEX,sizeof(TEX));
// load thumbnail
string128 &N = BT.name;
LPSTR extension = strext(N);
if (extension)
*extension = 0;
xr_strlwr (N);
if (0==xr_strcmp(N,"level_lods")) {
// HACK for merged lod textures
BT.dwWidth = 1024;
BT.dwHeight = 1024;
BT.bHasAlpha= TRUE;
BT.pSurface = 0;
} else {
xr_strcat (N,".thm");
IReader* THM = FS.r_open("$game_textures$",N);
// if (!THM) continue;
R_ASSERT2 (THM, N);
// version
u32 version = 0;
R_ASSERT (THM->r_chunk(THM_CHUNK_VERSION,&version));
// if( version!=THM_CURRENT_VERSION ) FATAL ("Unsupported version of THM file.");
// analyze thumbnail information
R_ASSERT(THM->find_chunk(THM_CHUNK_TEXTUREPARAM));
THM->r (&BT.THM.fmt,sizeof(STextureParams::ETFormat));
BT.THM.flags.assign (THM->r_u32());
BT.THM.border_color = THM->r_u32();
BT.THM.fade_color = THM->r_u32();
BT.THM.fade_amount = THM->r_u32();
BT.THM.mip_filter = THM->r_u32();
BT.THM.width = THM->r_u32();
BT.THM.height = THM->r_u32();
BOOL bLOD=FALSE;
if (N[0]=='l' && N[1]=='o' && N[2]=='d' && N[3]=='\\') bLOD = TRUE;
// load surface if it has an alpha channel or has "implicit lighting" flag
BT.dwWidth = BT.THM.width;
BT.dwHeight = BT.THM.height;
BT.bHasAlpha = BT.THM.HasAlphaChannel();
BT.pSurface = 0;
if (!bLOD)
{
if (BT.bHasAlpha || BT.THM.flags.test(STextureParams::flImplicitLighted))
{
clMsg ("- loading: %s",N);
u32 w=0, h=0;
BT.pSurface = Surface_Load(N,w,h);
R_ASSERT2 (BT.pSurface,"Can't load surface");
if ((w != BT.dwWidth) || (h != BT.dwHeight))
Msg ("! THM doesn't correspond to the texture: %dx%d -> %dx%d", BT.dwWidth, BT.dwHeight, w, h);
BT.Vflip ();
} else {
// Free surface memory
}
}
}
// save all the stuff we've created
g_textures.push_back (BT);
}
}
}
}
// // Load emitters
// {
// strconcat (N,name,"level.game");
// IReader *F = FS.r_open(N);
// IReader *O = 0;
// if (0!=(O = F->open_chunk (AIPOINT_CHUNK))) {
// for (int id=0; O->find_chunk(id); id++) {
// Emitters.push_back(Fvector());
// O->r_fvector3 (Emitters.back());
// }
// O->close();
// }
// }
//
// Load lights
{
strconcat (sizeof(N),N,name,"build.prj");
IReader* F = FS.r_open(N);
R_ASSERT2 (F,"There is no file 'build.prj'!");
IReader &fs= *F;
// Version
u32 version;
fs.r_chunk (EB_Version,&version);
R_ASSERT (XRCL_CURRENT_VERSION >= 17);
R_ASSERT (XRCL_CURRENT_VERSION <= 18);
// Header
b_params Params;
fs.r_chunk (EB_Parameters,&Params);
// Lights (Static)
{
F = fs.open_chunk(EB_Light_static);
b_light_static temp;
u32 cnt = F->length()/sizeof(temp);
for (u32 i=0; i<cnt; i++)
{
R_Light RL;
F->r (&temp,sizeof(temp));
Flight& L = temp.data;
if (_abs(L.range) > 10000.f) {
Msg ("! BAD light range : %f",L.range);
L.range = L.range > 0.f ? 10000.f : -10000.f;
}
// type
if (L.type == D3DLIGHT_DIRECTIONAL) RL.type = LT_DIRECT;
else RL.type = LT_POINT;
// generic properties
RL.position.set (L.position);
RL.direction.normalize_safe (L.direction);
RL.range = L.range*1.1f;
RL.range2 = RL.range*RL.range;
RL.attenuation0 = L.attenuation0;
RL.attenuation1 = L.attenuation1;
RL.attenuation2 = L.attenuation2;
RL.amount = L.diffuse.magnitude_rgb ();
RL.tri[0].set (0,0,0);
RL.tri[1].set (0,0,0);
RL.tri[2].set (0,0,0);
// place into layer
if (0==temp.controller_ID) g_lights.push_back (RL);
}
F->close ();
}
}
// Init params
// g_params.Init ();
// Load initial map from the Level Editor
{
string_path file_name;
strconcat (sizeof(file_name),file_name,name,"build.aimap");
IReader *F = FS.r_open(file_name);
R_ASSERT2 (F, file_name);
R_ASSERT (F->open_chunk(E_AIMAP_CHUNK_VERSION));
R_ASSERT (F->r_u16() == E_AIMAP_VERSION);
R_ASSERT (F->open_chunk(E_AIMAP_CHUNK_BOX));
F->r (&LevelBB,sizeof(LevelBB));
R_ASSERT (F->open_chunk(E_AIMAP_CHUNK_PARAMS));
F->r (&g_params,sizeof(g_params));
R_ASSERT (F->open_chunk(E_AIMAP_CHUNK_NODES));
u32 N = F->r_u32();
R_ASSERT2 (N < ((u32(1) << u32(MAX_NODE_BIT_COUNT)) - 2),"Too many nodes!");
g_nodes.resize (N);
hdrNODES H;
H.version = XRAI_CURRENT_VERSION;
H.count = N+1;
H.size = g_params.fPatchSize;
H.size_y = 1.f;
H.aabb = LevelBB;
typedef BYTE NodeLink[3];
for (u32 i=0; i<N; i++) {
NodeLink id;
u16 pl;
SNodePositionOld _np;
NodePosition np;
for (int j=0; j<4; ++j) {
F->r (&id,3);
g_nodes[i].n[j] = (*LPDWORD(&id)) & 0x00ffffff;
}
pl = F->r_u16();
pvDecompress (g_nodes[i].Plane.n,pl);
F->r (&_np,sizeof(_np));
CNodePositionConverter(_np,H,np);
g_nodes[i].Pos = vertex_position(np,LevelBB,g_params);
g_nodes[i].Plane.build(g_nodes[i].Pos,g_nodes[i].Plane.n);
}
F->close ();
if (!strstr(Core.Params,"-keep_temp_files"))
DeleteFile (file_name);
}
}
HRESULT CRender::shader_compile (
LPCSTR name,
DWORD const* pSrcData,
UINT SrcDataLen,
LPCSTR pFunctionName,
LPCSTR pTarget,
DWORD Flags,
void*& result
)
{
D3DXMACRO defines [128];
int def_it = 0;
char sh_name[MAX_PATH] = "";
u32 len = 0;
// options
if (o.forceskinw) {
defines[def_it].Name = "SKIN_COLOR";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(o.forceskinw); ++len;
if (m_skinning<0) {
defines[def_it].Name = "SKIN_NONE";
defines[def_it].Definition = "1";
def_it ++;
sh_name[len]='1'; ++len;
}
else {
sh_name[len]='0'; ++len;
}
if (0==m_skinning) {
defines[def_it].Name = "SKIN_0";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(0==m_skinning); ++len;
if (1==m_skinning) {
defines[def_it].Name = "SKIN_1";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(1==m_skinning); ++len;
if (2==m_skinning) {
defines[def_it].Name = "SKIN_2";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(2==m_skinning); ++len;
if (3==m_skinning) {
defines[def_it].Name = "SKIN_3";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(3==m_skinning); ++len;
if (4==m_skinning) {
defines[def_it].Name = "SKIN_4";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(4==m_skinning); ++len;
// finish
defines[def_it].Name = 0;
defines[def_it].Definition = 0;
def_it ++;
R_ASSERT (def_it<128);
HRESULT _result = E_FAIL;
string_path folder_name, folder;
xr_strcpy ( folder, "r1\\objects\\r1\\" );
xr_strcat ( folder, name );
xr_strcat ( folder, "." );
char extension[3];
strncpy_s ( extension, pTarget, 2 );
xr_strcat ( folder, extension );
FS.update_path ( folder_name, "$game_shaders$", folder );
xr_strcat ( folder_name, "\\" );
m_file_set.clear( );
FS.file_list ( m_file_set, folder_name, FS_ListFiles | FS_RootOnly, "*");
string_path temp_file_name, file_name;
if ( !match_shader_id(name, sh_name, m_file_set, temp_file_name) ) {
string_path file;
xr_strcpy ( file, "shaders_cache\\r1\\" );
xr_strcat ( file, name );
xr_strcat ( file, "." );
xr_strcat ( file, extension );
xr_strcat ( file, "\\" );
xr_strcat ( file, sh_name );
FS.update_path ( file_name, "$app_data_root$", file);
}
else {
xr_strcpy ( file_name, folder_name );
xr_strcat ( file_name, temp_file_name );
}
if (FS.exist(file_name))
{
IReader* file = FS.r_open(file_name);
if (file->length()>4)
{
u32 crc = 0;
crc = file->r_u32();
boost::crc_32_type processor;
processor.process_block ( file->pointer(), ((char*)file->pointer()) + file->elapsed() );
u32 const real_crc = processor.checksum( );
if ( real_crc == crc ) {
_result = create_shader(pTarget, (DWORD*)file->pointer(), file->elapsed(), file_name, result, o.disasm);
}
}
file->close();
}
if (FAILED(_result))
{
includer Includer;
LPD3DXBUFFER pShaderBuf = NULL;
LPD3DXBUFFER pErrorBuf = NULL;
LPD3DXCONSTANTTABLE pConstants = NULL;
LPD3DXINCLUDE pInclude = (LPD3DXINCLUDE)&Includer;
_result = D3DXCompileShader((LPCSTR)pSrcData,SrcDataLen,defines,pInclude,pFunctionName,pTarget,Flags|D3DXSHADER_USE_LEGACY_D3DX9_31_DLL,&pShaderBuf,&pErrorBuf,&pConstants);
if (SUCCEEDED(_result)) {
IWriter* file = FS.w_open(file_name);
boost::crc_32_type processor;
processor.process_block ( pShaderBuf->GetBufferPointer(), ((char*)pShaderBuf->GetBufferPointer()) + pShaderBuf->GetBufferSize() );
u32 const crc = processor.checksum( );
file->w_u32 (crc);
file->w ( pShaderBuf->GetBufferPointer(), (u32)pShaderBuf->GetBufferSize());
FS.w_close (file);
_result = create_shader(pTarget, (DWORD*)pShaderBuf->GetBufferPointer(), pShaderBuf->GetBufferSize(), file_name, result, o.disasm);
}
else {
Log ("! ", file_name);
if ( pErrorBuf )
Log ("! error: ",(LPCSTR)pErrorBuf->GetBufferPointer());
else
Msg ("Can't compile shader hr=0x%08x", _result);
}
}
return _result;
}
CLevelGameGraph (
LPCSTR graph_file_name,
LPCSTR raw_cross_table_file_name,
CGameGraph::SLevel *tLevel,
LPCSTR S,
u32 dwOffset,
u32 dwLevelID,
CInifile *Ini
)
{
m_tLevel = *tLevel;
m_dwOffset = dwOffset;
m_tpLevelPoints.clear ();
FILE_NAME caFileName;
// loading graph
strcpy_s (caFileName,graph_file_name);
m_tpGraph = new CGameGraph(caFileName);
strcpy_s (caFileName,raw_cross_table_file_name);
CGameLevelCrossTable *l_tpCrossTable = new CGameLevelCrossTable(caFileName);
CLevelGraph *l_tpAI_Map = new CLevelGraph(S);
VERIFY2 (l_tpCrossTable->header().level_guid() == l_tpAI_Map->header().guid(), "cross table doesn't correspond to the AI-map, rebuild graph!");
VERIFY2 (l_tpCrossTable->header().game_guid() == m_tpGraph->header().guid(), "cross table doesn't correspond to the graph, rebuild graph!");
VERIFY2 (m_tpGraph->header().level(GameGraph::_LEVEL_ID(0)).guid() == l_tpAI_Map->header().guid(), "cross table doesn't correspond to the AI-map, rebuild graph!");
VERIFY (l_tpAI_Map->header().vertex_count() == l_tpCrossTable->header().level_vertex_count());
VERIFY (m_tpGraph->header().vertex_count() == l_tpCrossTable->header().game_vertex_count());
tLevel->m_guid = l_tpAI_Map->header().guid();
{
for (GameGraph::_GRAPH_ID i=0, n = m_tpGraph->header().vertex_count(); i<n; ++i)
if ((!l_tpAI_Map->valid_vertex_id(m_tpGraph->vertex(i)->level_vertex_id()) ||
(l_tpCrossTable->vertex(m_tpGraph->vertex(i)->level_vertex_id()).game_vertex_id() != i) ||
!l_tpAI_Map->inside(m_tpGraph->vertex(i)->level_vertex_id(),m_tpGraph->vertex(i)->level_point()))) {
Msg ("! Graph doesn't correspond to the cross table");
R_ASSERT2 (false,"Graph doesn't correspond to the cross table");
}
}
m_tpVertices.resize (m_tpGraph->header().vertex_count());
GRAPH_VERTEX_IT B = m_tpVertices.begin();
GRAPH_VERTEX_IT I = B;
GRAPH_VERTEX_IT E = m_tpVertices.end();
for ( ; I != E; I++) {
(*I).tLocalPoint = m_tpGraph->vertex(int(I - B))->level_point();
(*I).tGlobalPoint.add (m_tpGraph->vertex(int(I - B))->game_point(),m_tLevel.offset());
(*I).tLevelID = dwLevelID;
(*I).tNodeID = m_tpGraph->vertex(int(I - B))->level_vertex_id();
Memory.mem_copy ((*I).tVertexTypes,m_tpGraph->vertex(int(I - B))->vertex_type(),GameGraph::LOCATION_TYPE_COUNT*sizeof(GameGraph::_LOCATION_ID));
(*I).tNeighbourCount = m_tpGraph->vertex(int(I - B))->edge_count();
CGameGraph::const_iterator b,i,e;
m_tpGraph->begin (int(I - B),i,e);
(*I).tpaEdges = (CGameGraph::CEdge*)xr_malloc((*I).tNeighbourCount*sizeof(CGameGraph::CEdge));
b = i;
for ( ; i != e; ++i) {
GameGraph::CEdge &edge = (*I).tpaEdges[i - b];
edge = *i;
VERIFY ((edge.vertex_id() + dwOffset) < (u32(1) << (8*sizeof(GameGraph::_GRAPH_ID))));
edge.m_vertex_id = (GameGraph::_GRAPH_ID)(edge.m_vertex_id + dwOffset);
}
(*I).dwPointOffset = 0;
vfGenerateDeathPoints (int(I - B),l_tpCrossTable,l_tpAI_Map,(*I).tDeathPointCount);
}
xr_delete (l_tpCrossTable);
xr_delete (l_tpAI_Map);
// updating cross-table
{
strcpy_s (caFileName,raw_cross_table_file_name);
CGameLevelCrossTable *tpCrossTable = new CGameLevelCrossTable(caFileName);
xr_vector<CGameLevelCrossTable::CCell> tCrossTableUpdate;
tCrossTableUpdate.resize(tpCrossTable->header().level_vertex_count());
for (int i=0; i<(int)tpCrossTable->header().level_vertex_count(); i++) {
tCrossTableUpdate[i] = tpCrossTable->vertex(i);
VERIFY (u32(tCrossTableUpdate[i].tGraphIndex) < tpCrossTable->header().game_vertex_count());
tCrossTableUpdate[i].tGraphIndex = tCrossTableUpdate[i].tGraphIndex + (GameGraph::_GRAPH_ID)dwOffset;
}
CGameLevelCrossTable::CHeader tCrossTableHeader;
tCrossTableHeader.dwVersion = XRAI_CURRENT_VERSION;
tCrossTableHeader.dwNodeCount = tpCrossTable->m_tCrossTableHeader.dwNodeCount;
tCrossTableHeader.dwGraphPointCount = tpCrossTable->m_tCrossTableHeader.dwGraphPointCount;
tCrossTableHeader.m_level_guid = tpCrossTable->m_tCrossTableHeader.m_level_guid;
tCrossTableHeader.m_game_guid = tGraphHeader.m_guid;
xr_delete (tpCrossTable);
m_cross_table.w(&tCrossTableHeader,sizeof(tCrossTableHeader));
for (int i=0; i<(int)tCrossTableHeader.dwNodeCount; i++)
m_cross_table.w(&(tCrossTableUpdate[i]),sizeof(tCrossTableUpdate[i]));
}
// fill vertex map
{
string_path fName;
strconcat (sizeof(fName),fName,S,"level.spawn");
IReader *F = FS.r_open(fName);
u32 id;
IReader *O = F->open_chunk_iterator(id);
for (int i=0; O; O = F->open_chunk_iterator(id,O)) {
NET_Packet P;
P.B.count = O->length();
O->r (P.B.data,P.B.count);
u16 ID;
P.r_begin (ID);
R_ASSERT (M_SPAWN==ID);
P.r_stringZ (fName);
CSE_Abstract *E = F_entity_Create(fName);
R_ASSERT3 (E,"Can't create entity.",fName);
// E->Spawn_Read (P);
CSE_ALifeGraphPoint *tpGraphPoint = smart_cast<CSE_ALifeGraphPoint*>(E);
if (tpGraphPoint) {
E->Spawn_Read (P);
Fvector tVector;
tVector = tpGraphPoint->o_Position;
GameGraph::_GRAPH_ID tGraphID = GameGraph::_GRAPH_ID(-1);
float fMinDistance = 1000000.f;
{
GRAPH_VERTEX_IT B = m_tpVertices.begin();
GRAPH_VERTEX_IT I = B;
GRAPH_VERTEX_IT E = m_tpVertices.end();
for ( ; I != E; I++) {
float fDistance = (*I).tLocalPoint.distance_to(tVector);
if (fDistance < fMinDistance) {
fMinDistance = fDistance;
tGraphID = GameGraph::_GRAPH_ID(I - B);
if (fMinDistance < EPS_L)
break;
}
}
}
if (fMinDistance < EPS_L) {
SConnectionVertex T;
LPSTR S;
S = xr_strdup(tpGraphPoint->name_replace());
T.caConnectName = xr_strdup(*tpGraphPoint->m_caConnectionPointName);
T.dwLevelID = dwfGetIDByLevelName(Ini,*tpGraphPoint->m_caConnectionLevelName);
// T.tGraphID = (GameGraph::_GRAPH_ID)i;
// T.tOldGraphID = tGraphID;
T.tOldGraphID = (GameGraph::_GRAPH_ID)i;
T.tGraphID = tGraphID;
bool ok = true;
VERTEX_MAP::const_iterator II = m_tVertexMap.begin();
VERTEX_MAP::const_iterator EE = m_tVertexMap.end();
for ( ; II != EE; ++II)
if (T.tOldGraphID == (*II).second.tOldGraphID) {
ok = false;
Msg ("Graph point %s is removed,because it has the same position as some another graph point",E->name_replace());
break;
}
if (ok) {
m_tVertexMap.insert (mk_pair(S,T));
i++;
}
}
}
F_entity_Destroy (E);
}
if (i != m_tpGraph->header().vertex_count())
Msg ("Graph for the level %s doesn't correspond to the graph points from Level Editor! (%d : %d)",*m_tLevel.name(),i,m_tpGraph->header().vertex_count());
VERTEX_MAP::const_iterator I = m_tVertexMap.begin();
VERTEX_MAP::const_iterator E = m_tVertexMap.end();
for ( ; I != E; ++I) {
R_ASSERT3 (!xr_strlen((*I).second.caConnectName) || ((*I).second.tGraphID < m_tpVertices.size()),"Rebuild graph for the level",*m_tLevel.name());
}
// VERIFY3 (i == m_tpGraph->header().vertex_count(), "Rebuild graph for the level ",m_tLevel.name());
O->close ();
FS.r_close (F);
}
};
int ProcessDifference()
{
LPCSTR params = GetCommandLine();
Flags32 _flags;
_flags.zero();
if(strstr(params,"-diff /?")){
printf("HELP:\n");
printf("xrCompress.exe -diff <new_data> <old_data> -out <diff_resulf> [options]\n");
printf("<new_data>, <old_data> and <diff_resulf> values must be a folder name\n");
printf("[options] are set of:\n");
printf("-nofileage do not perform file age checking\n");
printf("-crc do not perform crc32 checking\n");
printf("-nobinary do not perform binary content checking\n");
printf("-nosize do not perform file size checking\n");
return 3;
}
CLocatorAPI* FS_new = NULL;
CLocatorAPI* FS_old = NULL;
xr_vector<char*>* file_list_old = NULL;
xr_vector<char*>* folder_list_old = NULL;
xr_vector<char*>* file_list_new = NULL;
xr_vector<char*>* folder_list_new = NULL;
sscanf (strstr(params,"-diff ")+6,"%[^ ] ",new_folder);
sscanf (strstr(params,"-diff ")+6+xr_strlen(new_folder)+1,"%[^ ] ",old_folder);
sscanf (strstr(params,"-out ")+5,"%[^ ] ",target_folder);
if(strstr(params,"-nofileage")){
_flags.set(file_comparer::eDontCheckFileAge, TRUE);
};
if(strstr(params,"-nocrc")){
_flags.set(file_comparer::eDontCheckCRC, TRUE);
};
if(strstr(params,"-nobinary")){
_flags.set(file_comparer::eDontCheckBinary, TRUE);
};
if(strstr(params,"-nosize")){
_flags.set(file_comparer::eDontCheckFileSize, TRUE);
};
FS_new = xr_new<CLocatorAPI> ();
FS_new->_initialize(CLocatorAPI::flTargetFolderOnly,new_folder);
file_list_new = FS_new->file_list_open ("$target_folder$",FS_ListFiles);
folder_list_new = FS_new->file_list_open ("$target_folder$",FS_ListFolders);
FS_old = xr_new<CLocatorAPI> ();
FS_old->_initialize(CLocatorAPI::flTargetFolderOnly,old_folder);
file_list_old = FS_old->file_list_open ("$target_folder$",FS_ListFiles);
folder_list_old = FS_old->file_list_open ("$target_folder$",FS_ListFolders);
xr_vector<LPCSTR> target_file_list;
target_file_list.reserve(file_list_new->size());
for(u32 i=0; i<file_list_new->size();++i){
file_comparer fc(file_list_new->at(i),FS_new, FS_old,_flags);
xr_vector<char*>::iterator it = std::find_if(file_list_old->begin(),file_list_old->end(),fc);
if(it != file_list_old->end()){
printf("skip file %s\n",file_list_new->at(i));
}else
target_file_list.push_back(file_list_new->at(i));
}
string_path out_path;
for(u32 i=0; i<target_file_list.size();++i){
LPCSTR fn = target_file_list[i];
strconcat(out_path,target_folder,"\\",fn);
VerifyPath(out_path);
IReader* r = FS_new->r_open("$target_folder$",fn);
IWriter* w = FS_old->w_open(out_path);
w->w(r->pointer(),r->length());
FS_new->r_close(r);
FS_old->w_close(w);
}
FS_new->file_list_close(file_list_new);
FS_new->file_list_close(folder_list_new);
FS_old->file_list_close(file_list_old);
FS_old->file_list_close(folder_list_old);
xr_delete(FS_new);
xr_delete(FS_old);
return 0;
}
/*
ID3DTexture2D* TW_LoadTextureFromTexture
(
ID3DTexture2D* t_from,
D3DFORMAT& t_dest_fmt,
int levels_2_skip,
u32& w,
u32& h
)
{
// Calculate levels & dimensions
ID3DTexture2D* t_dest = NULL;
D3DSURFACE_DESC t_from_desc0 ;
R_CHK (t_from->GetLevelDesc (0,&t_from_desc0));
int levels_exist = t_from->GetLevelCount();
int top_width = t_from_desc0.Width;
int top_height = t_from_desc0.Height;
Reduce (top_width,top_height,levels_exist,levels_2_skip);
// Create HW-surface
if (D3DX_DEFAULT==t_dest_fmt) t_dest_fmt = t_from_desc0.Format;
R_CHK (D3DXCreateTexture(
HW.pDevice,
top_width,top_height,
levels_exist,0,t_dest_fmt,
D3DPOOL_MANAGED,&t_dest
));
// Copy surfaces & destroy temporary
ID3DTexture2D* T_src= t_from;
ID3DTexture2D* T_dst= t_dest;
int L_src = T_src->GetLevelCount ()-1;
int L_dst = T_dst->GetLevelCount ()-1;
for (; L_dst>=0; L_src--,L_dst--)
{
// Get surfaces
IDirect3DSurface9 *S_src, *S_dst;
R_CHK (T_src->GetSurfaceLevel (L_src,&S_src));
R_CHK (T_dst->GetSurfaceLevel (L_dst,&S_dst));
// Copy
R_CHK (D3DXLoadSurfaceFromSurface(S_dst,NULL,NULL,S_src,NULL,NULL,D3DX_FILTER_NONE,0));
// Release surfaces
_RELEASE (S_src);
_RELEASE (S_dst);
}
// OK
w = top_width;
h = top_height;
return t_dest;
}
template <class _It>
IC void TW_Iterate_1OP
(
ID3DTexture2D* t_dst,
ID3DTexture2D* t_src,
const _It pred
)
{
DWORD mips = t_dst->GetLevelCount();
R_ASSERT (mips == t_src->GetLevelCount());
for (DWORD i = 0; i < mips; i++) {
D3DLOCKED_RECT Rsrc,Rdst;
D3DSURFACE_DESC desc,descS;
t_dst->GetLevelDesc (i, &desc);
t_src->GetLevelDesc (i, &descS);
VERIFY (desc.Format==descS.Format);
VERIFY (desc.Format==D3DFMT_A8R8G8B8);
t_src->LockRect (i,&Rsrc,0,0);
t_dst->LockRect (i,&Rdst,0,0);
for (u32 y = 0; y < desc.Height; y++) {
for (u32 x = 0; x < desc.Width; x++) {
DWORD& pSrc = *(((DWORD*)((BYTE*)Rsrc.pBits + (y * Rsrc.Pitch)))+x);
DWORD& pDst = *(((DWORD*)((BYTE*)Rdst.pBits + (y * Rdst.Pitch)))+x);
pDst = pred(pDst,pSrc);
}
}
t_dst->UnlockRect (i);
t_src->UnlockRect (i);
}
}
template <class _It>
IC void TW_Iterate_2OP
(
ID3DTexture2D* t_dst,
ID3DTexture2D* t_src0,
ID3DTexture2D* t_src1,
const _It pred
)
{
DWORD mips = t_dst->GetLevelCount();
R_ASSERT (mips == t_src0->GetLevelCount());
R_ASSERT (mips == t_src1->GetLevelCount());
for (DWORD i = 0; i < mips; i++) {
D3DLOCKED_RECT Rsrc0,Rsrc1,Rdst;
D3DSURFACE_DESC desc,descS0,descS1;
t_dst->GetLevelDesc (i, &desc);
t_src0->GetLevelDesc (i, &descS0);
t_src1->GetLevelDesc (i, &descS1);
VERIFY (desc.Format==descS0.Format);
VERIFY (desc.Format==descS1.Format);
VERIFY (desc.Format==D3DFMT_A8R8G8B8);
t_src0->LockRect (i,&Rsrc0, 0,0);
t_src1->LockRect (i,&Rsrc1, 0,0);
t_dst->LockRect (i,&Rdst, 0,0);
for (u32 y = 0; y < desc.Height; y++) {
for (u32 x = 0; x < desc.Width; x++) {
DWORD& pSrc0 = *(((DWORD*)((BYTE*)Rsrc0.pBits + (y * Rsrc0.Pitch)))+x);
DWORD& pSrc1 = *(((DWORD*)((BYTE*)Rsrc1.pBits + (y * Rsrc1.Pitch)))+x);
DWORD& pDst = *(((DWORD*)((BYTE*)Rdst.pBits + (y * Rdst.Pitch)))+x);
pDst = pred(pDst,pSrc0,pSrc1);
}
}
t_dst->UnlockRect (i);
t_src0->UnlockRect (i);
t_src1->UnlockRect (i);
}
}
IC u32 it_gloss_rev (u32 d, u32 s) { return color_rgba (
color_get_A(s), // gloss
color_get_B(d),
color_get_G(d),
color_get_R(d) );
}
IC u32 it_gloss_rev_base(u32 d, u32 s) {
u32 occ = color_get_A(d)/3;
u32 def = 8;
u32 gloss = (occ*1+def*3)/4;
return color_rgba (
gloss, // gloss
color_get_B(d),
color_get_G(d),
color_get_R(d)
);
}
IC u32 it_difference (u32 d, u32 orig, u32 ucomp) { return color_rgba(
128+(int(color_get_R(orig))-int(color_get_R(ucomp)))*2, // R-error
128+(int(color_get_G(orig))-int(color_get_G(ucomp)))*2, // G-error
128+(int(color_get_B(orig))-int(color_get_B(ucomp)))*2, // B-error
128+(int(color_get_A(orig))-int(color_get_A(ucomp)))*2 ); // A-error
}
IC u32 it_height_rev (u32 d, u32 s) { return color_rgba (
color_get_A(d), // diff x
color_get_B(d), // diff y
color_get_G(d), // diff z
color_get_R(s) ); // height
}
IC u32 it_height_rev_base(u32 d, u32 s) { return color_rgba (
color_get_A(d), // diff x
color_get_B(d), // diff y
color_get_G(d), // diff z
(color_get_R(s)+color_get_G(s)+color_get_B(s))/3 ); // height
}
*/
ID3DBaseTexture* CRender::texture_load(LPCSTR fRName, u32& ret_msize, bool bStaging)
{
// Moved here just to avoid warning
#ifdef USE_DX11
D3DX11_IMAGE_INFO IMG;
#else
D3DX10_IMAGE_INFO IMG;
#endif
ZeroMemory(&IMG, sizeof(IMG));
// Staging control
static bool bAllowStaging = !strstr(Core.Params,"-no_staging");
bStaging &= bAllowStaging;
ID3DBaseTexture* pTexture2D = NULL;
//IDirect3DCubeTexture9* pTextureCUBE = NULL;
string_path fn;
//u32 dwWidth,dwHeight;
u32 img_size = 0;
int img_loaded_lod = 0;
//D3DFORMAT fmt;
u32 mip_cnt=u32(-1);
// validation
R_ASSERT (fRName);
R_ASSERT (fRName[0]);
// make file name
string_path fname;
xr_strcpy(fname,fRName); //. andy if (strext(fname)) *strext(fname)=0;
fix_texture_name (fname);
IReader* S = NULL;
if (!FS.exist(fn,"$game_textures$", fname, ".dds") && strstr(fname,"_bump")) goto _BUMP_from_base;
if (FS.exist(fn,"$level$", fname, ".dds")) goto _DDS;
if (FS.exist(fn,"$game_saves$", fname, ".dds")) goto _DDS;
if (FS.exist(fn,"$game_textures$", fname, ".dds")) goto _DDS;
#ifdef _EDITOR
ELog.Msg(mtError,"Can't find texture '%s'",fname);
return 0;
#else
Msg("! Can't find texture '%s'",fname);
R_ASSERT(FS.exist(fn,"$game_textures$", "ed\\ed_not_existing_texture",".dds"));
goto _DDS;
// Debug.fatal(DEBUG_INFO,"Can't find texture '%s'",fname);
#endif
_DDS:
{
// Load and get header
S = FS.r_open (fn);
#ifdef DEBUG
Msg ("* Loaded: %s[%d]",fn,S->length());
#endif // DEBUG
img_size = S->length ();
R_ASSERT (S);
//R_CHK2 (D3DXGetImageInfoFromFileInMemory (S->pointer(),S->length(),&IMG), fn);
#ifdef USE_DX11
R_CHK2 (D3DX11GetImageInfoFromMemory(S->pointer(),S->length(), 0, &IMG, 0), fn);
#else
R_CHK2 (D3DX10GetImageInfoFromMemory(S->pointer(),S->length(), 0, &IMG, 0), fn);
#endif
//if (IMG.ResourceType == D3DRTYPE_CUBETEXTURE) goto _DDS_CUBE;
if (IMG.MiscFlags & D3D_RESOURCE_MISC_TEXTURECUBE) goto _DDS_CUBE;
else goto _DDS_2D;
_DDS_CUBE:
{
//R_CHK(D3DXCreateCubeTextureFromFileInMemoryEx(
// HW.pDevice,
// S->pointer(),S->length(),
// D3DX_DEFAULT,
// IMG.MipLevels,0,
// IMG.Format,
// D3DPOOL_MANAGED,
// D3DX_DEFAULT,
// D3DX_DEFAULT,
// 0,&IMG,0,
// &pTextureCUBE
// ));
// Inited to default by provided default constructor
#ifdef USE_DX11
D3DX11_IMAGE_LOAD_INFO LoadInfo;
#else
D3DX10_IMAGE_LOAD_INFO LoadInfo;
#endif
//LoadInfo.Usage = D3D_USAGE_IMMUTABLE;
if (bStaging)
{
LoadInfo.Usage = D3D_USAGE_STAGING;
LoadInfo.BindFlags = 0;
LoadInfo.CpuAccessFlags = D3D_CPU_ACCESS_WRITE;
}
else
{
LoadInfo.Usage = D3D_USAGE_DEFAULT;
LoadInfo.BindFlags = D3D_BIND_SHADER_RESOURCE;
}
LoadInfo.pSrcInfo = &IMG;
#ifdef USE_DX11
R_CHK(D3DX11CreateTextureFromMemory(
HW.pDevice,
S->pointer(),S->length(),
&LoadInfo,
0,
&pTexture2D,
0
));
#else
R_CHK(D3DX10CreateTextureFromMemory(
HW.pDevice,
S->pointer(),S->length(),
&LoadInfo,
0,
&pTexture2D,
0
));
#endif
FS.r_close (S);
// OK
mip_cnt = IMG.MipLevels;
ret_msize = calc_texture_size(img_loaded_lod, mip_cnt, img_size);
return pTexture2D;
}
_DDS_2D:
{
// Check for LMAP and compress if needed
strlwr (fn);
// Load SYS-MEM-surface, bound to device restrictions
//ID3DTexture2D* T_sysmem;
//R_CHK2(D3DXCreateTextureFromFileInMemoryEx
// (
// HW.pDevice,S->pointer(),S->length(),
// D3DX_DEFAULT,D3DX_DEFAULT,
// IMG.MipLevels,0,
// IMG.Format,
// D3DPOOL_SYSTEMMEM,
// D3DX_DEFAULT,
// D3DX_DEFAULT,
// 0,&IMG,0,
// &T_sysmem
// ), fn);
img_loaded_lod = get_texture_load_lod(fn);
// Inited to default by provided default constructor
#ifdef USE_DX11
D3DX11_IMAGE_LOAD_INFO LoadInfo;
#else
D3DX10_IMAGE_LOAD_INFO LoadInfo;
#endif
//LoadInfo.FirstMipLevel = img_loaded_lod;
LoadInfo.Width = IMG.Width;
LoadInfo.Height = IMG.Height;
if (img_loaded_lod)
{
Reduce(LoadInfo.Width, LoadInfo.Height, IMG.MipLevels, img_loaded_lod);
}
//LoadInfo.Usage = D3D_USAGE_IMMUTABLE;
if (bStaging)
{
LoadInfo.Usage = D3D_USAGE_STAGING;
LoadInfo.BindFlags = 0;
LoadInfo.CpuAccessFlags = D3D_CPU_ACCESS_WRITE;
}
else
{
LoadInfo.Usage = D3D_USAGE_DEFAULT;
LoadInfo.BindFlags = D3D_BIND_SHADER_RESOURCE;
}
LoadInfo.pSrcInfo = &IMG;
#ifdef USE_DX11
R_CHK2(D3DX11CreateTextureFromMemory
(
HW.pDevice,S->pointer(),S->length(),
&LoadInfo,
0,
&pTexture2D,
0
), fn);
#else
R_CHK2(D3DX10CreateTextureFromMemory
(
HW.pDevice,S->pointer(),S->length(),
&LoadInfo,
0,
&pTexture2D,
0
), fn);
#endif
FS.r_close (S);
mip_cnt = IMG.MipLevels;
// OK
ret_msize = calc_texture_size(img_loaded_lod, mip_cnt, img_size);
return pTexture2D;
}
}
_BUMP_from_base:
{
//Msg ("! auto-generated bump map: %s",fname);
Msg ("! Fallback to default bump map: %s",fname);
//////////////////
if (strstr(fname,"_bump#"))
{
R_ASSERT2 (FS.exist(fn,"$game_textures$", "ed\\ed_dummy_bump#", ".dds"), "ed_dummy_bump#");
S = FS.r_open (fn);
R_ASSERT2 (S, fn);
img_size = S->length ();
goto _DDS_2D;
}
if (strstr(fname,"_bump"))
{
R_ASSERT2 (FS.exist(fn,"$game_textures$", "ed\\ed_dummy_bump", ".dds"),"ed_dummy_bump");
S = FS.r_open (fn);
R_ASSERT2 (S, fn);
img_size = S->length ();
goto _DDS_2D;
}
//////////////////
}
return 0;
}
