void CActorCondition::load(IReader &input_packet)
{
inherited::load (input_packet);
load_data (m_fAlcohol, input_packet);
load_data (m_condition_flags, input_packet);
load_data (m_fSatiety, input_packet);
load_data (m_curr_medicine_influence.fHealth, input_packet);
load_data (m_curr_medicine_influence.fPower, input_packet);
load_data (m_curr_medicine_influence.fSatiety, input_packet);
load_data (m_curr_medicine_influence.fRadiation, input_packet);
load_data (m_curr_medicine_influence.fWoundsHeal, input_packet);
load_data (m_curr_medicine_influence.fMaxPowerUp, input_packet);
load_data (m_curr_medicine_influence.fAlcohol, input_packet);
load_data (m_curr_medicine_influence.fTimeTotal, input_packet);
load_data (m_curr_medicine_influence.fTimeCurrent, input_packet);
u8 cntr = input_packet.r_u8();
for(; cntr>0; cntr--)
{
SBooster B;
B.m_type = (EBoostParams)input_packet.r_u8();
B.fBoostValue = input_packet.r_float();
B.fBoostTime = input_packet.r_float();
m_booster_influences[B.m_type] = B;
BoostParameters(B);
}
}
void CBone::LoadData(IReader& F)
{
R_ASSERT(F.find_chunk(BONE_CHUNK_DEF));
F.r_stringZ (name); xr_strlwr(name);
R_ASSERT(F.find_chunk(BONE_CHUNK_MATERIAL));
F.r_stringZ (game_mtl);
R_ASSERT(F.find_chunk(BONE_CHUNK_SHAPE));
F.r (&shape,sizeof(SBoneShape));
if (F.find_chunk(BONE_CHUNK_FLAGS))
IK_data.ik_flags.assign(F.r_u32());
R_ASSERT(F.find_chunk(BONE_CHUNK_IK_JOINT));
IK_data.type = (EJointType)F.r_u32();
F.r (IK_data.limits,sizeof(SJointLimit)*3);
IK_data.spring_factor = F.r_float();
IK_data.damping_factor = F.r_float();
if (F.find_chunk(BONE_CHUNK_IK_JOINT_BREAK)){
IK_data.break_force = F.r_float();
IK_data.break_torque= F.r_float();
}
if (F.find_chunk(BONE_CHUNK_IK_JOINT_FRICTION)){
IK_data.friction = F.r_float();
}
if (F.find_chunk(BONE_CHUNK_MASS)){
mass = F.r_float();
F.r_fvector3(center_of_mass);
}
}
bool EDetail::Load(IReader& F)
{
// check version
R_ASSERT (F.find_chunk(DETOBJ_CHUNK_VERSION));
u32 version = F.r_u32();
if (version!=DETOBJ_VERSION){
ELog.Msg(mtError,"EDetail: unsupported version.");
return false;
}
// references
string256 buf;
R_ASSERT (F.find_chunk(DETOBJ_CHUNK_REFERENCE));
F.r_stringZ (buf,sizeof(buf));
// scale
R_ASSERT (F.find_chunk(DETOBJ_CHUNK_SCALE_LIMITS));
m_fMinScale = F.r_float(); if (fis_zero(m_fMinScale)) m_fMinScale = 0.1f;
m_fMaxScale = F.r_float(); if (m_fMaxScale<m_fMinScale) m_fMaxScale = m_fMinScale;
// density factor
if (F.find_chunk(DETOBJ_CHUNK_DENSITY_FACTOR))
m_fDensityFactor= F.r_float();
if (F.find_chunk(DETOBJ_CHUNK_FLAGS))
m_Flags.assign (F.r_u32());
// update object
return Update(buf);
}
void SHeliBodyState::load(IReader &input_packet)
{
type = (EHeliBodyState)input_packet.r_s16();
b_looking_at_point = !!input_packet.r_u8();
currBodyHPB.x = input_packet.r_float();
currBodyHPB.y = input_packet.r_float();
currBodyHPB.z = input_packet.r_float();
}
bool ESceneAIMapTool::LoadStream(IReader& F)
{
inherited::LoadStream (F);
u16 version = 0;
R_ASSERT(F.r_chunk(AIMAP_CHUNK_VERSION,&version));
if( version!=AIMAP_VERSION ){
ELog.DlgMsg( mtError, "AIMap: Unsupported version.");
return false;
}
R_ASSERT(F.find_chunk(AIMAP_CHUNK_FLAGS));
F.r (&m_Flags,sizeof(m_Flags));
R_ASSERT(F.find_chunk(AIMAP_CHUNK_BOX));
F.r (&m_AIBBox,sizeof(m_AIBBox));
R_ASSERT(F.find_chunk(AIMAP_CHUNK_PARAMS));
F.r (&m_Params,sizeof(m_Params));
R_ASSERT(F.find_chunk(AIMAP_CHUNK_NODES));
m_Nodes.resize (F.r_u32());
for (AINodeIt it=m_Nodes.begin(); it!=m_Nodes.end(); it++){
*it = xr_new<SAINode>();
(*it)->LoadStream (F,this);
}
DenumerateNodes ();
if (F.find_chunk(AIMAP_CHUNK_INTERNAL_DATA)){
m_VisRadius = F.r_float();
m_BrushSize = F.r_u32();
}
if (F.find_chunk(AIMAP_CHUNK_INTERNAL_DATA2)){
m_SmoothHeight = F.r_float();
}
// snap objects
if (F.find_chunk(AIMAP_CHUNK_SNAP_OBJECTS)){
shared_str buf;
int cnt = F.r_u32();
if (cnt){
for (int i=0; i<cnt; i++){
F.r_stringZ (buf);
CCustomObject* O = Scene->FindObjectByName(buf.c_str(),OBJCLASS_SCENEOBJECT);
if (!O) ELog.Msg(mtError,"AIMap: Can't find snap object '%s'.",buf.c_str());
else m_SnapObjects.push_back(O);
}
}
}
hash_FillFromNodes ();
return true;
}
//------------------------------------------------------------------------------
// I/O part
//------------------------------------------------------------------------------
BOOL CPGDef::Load(IReader& F)
{
R_ASSERT (F.find_chunk(PGD_CHUNK_VERSION));
u16 version = F.r_u16();
if (version!=PGD_VERSION){
Log ("!Unsupported PG version. Load failed.");
return FALSE;
}
R_ASSERT (F.find_chunk(PGD_CHUNK_NAME));
F.r_stringZ (m_Name);
F.r_chunk (PGD_CHUNK_FLAGS,&m_Flags);
if (F.find_chunk(PGD_CHUNK_EFFECTS)){
m_Effects.resize(F.r_u32());
for (EffectIt it=m_Effects.begin(); it!=m_Effects.end(); it++){
*it = xr_new<SEffect>();
F.r_stringZ ((*it)->m_EffectName);
F.r_stringZ ((*it)->m_OnPlayChildName);
F.r_stringZ ((*it)->m_OnBirthChildName);
F.r_stringZ ((*it)->m_OnDeadChildName);
(*it)->m_Time0 = F.r_float();
(*it)->m_Time1 = F.r_float();
(*it)->m_Flags.assign (F.r_u32());
}
}else{ //.??? убрать через некоторое время
R_ASSERT (F.find_chunk(PGD_CHUNK_EFFECTS2));
m_Effects.resize(F.r_u32());
for (EffectIt it=m_Effects.begin(); it!=m_Effects.end(); it++){
*it = xr_new<SEffect>();
F.r_stringZ ((*it)->m_EffectName);
F.r_stringZ ((*it)->m_OnPlayChildName);
(*it)->m_Time0 = F.r_float();
(*it)->m_Time1 = F.r_float();
(*it)->m_Flags.assign (F.r_u32());
}
}
if (F.find_chunk(PGD_CHUNK_TIME_LIMIT)){
m_fTimeLimit= F.r_float();
}
#ifdef _EDITOR
if (F.find_chunk(PGD_CHUNK_OWNER)){
F.r_stringZ (m_OwnerName);
F.r_stringZ (m_ModifName);
F.r (&m_CreateTime,sizeof(m_CreateTime));
F.r (&m_ModifTime,sizeof(m_ModifTime));
}
#endif
return TRUE;
}
// postprocess color LOAD method implementation
void CPostProcessColor::load (IReader &pReader)
{
m_fBase = pReader.r_float ();
m_Red.Load_2 (pReader);
m_Green.Load_2 (pReader);
m_Blue.Load_2 (pReader);
}
void TClipMaker::LoadClips()
{
bool bRes=true;
if (EFS.GetOpenName("$clips$",m_ClipFName)){
Clear ();
IReader* F = FS.r_open(m_ClipFName.c_str()); VERIFY(F);
m_ClipFName = EFS.ExcludeBasePath(m_ClipFName.c_str(),FS.get_path("$clips$")->m_Path);
if (F->find_chunk(CHUNK_ZOOM)){
m_Zoom = F->r_float();
}
IReader* C = F->open_chunk(CHUNK_CLIPS);
if(C){
IReader* M = C->open_chunk(0);
for (int count=1; M; count++) {
CUIClip* clip = xr_new<CUIClip>(this,count);
if (!clip->Load(*M)){
ELog.Msg(mtError,"Unsupported clip version. Load failed.");
xr_delete(clip);
bRes = false;
}
M->close();
if (!bRes) break;
clips.push_back(clip);
M = C->open_chunk(count);
}
C->close ();
UpdateClips ();
}
FS.r_close(F);
}
}
bool CGlow::Load(IReader& F)
{
u32 version = 0;
R_ASSERT(F.r_chunk(GLOW_CHUNK_VERSION,&version));
if((version!=0x0011)&&(version!=GLOW_VERSION)){
ELog.DlgMsg( mtError, "CGlow: Unsupported version.");
return false;
}
CCustomObject::Load(F);
if (F.find_chunk(GLOW_CHUNK_SHADER)){
F.r_stringZ (m_ShaderName);
}
R_ASSERT(F.find_chunk(GLOW_CHUNK_TEXTURE));
F.r_stringZ (m_TexName);
R_ASSERT(F.find_chunk(GLOW_CHUNK_PARAMS));
m_fRadius = F.r_float();
if (version==0x0011){
F.r_fvector3 (FPosition);
UpdateTransform();
}
if (F.find_chunk(GLOW_CHUNK_FLAGS))
m_Flags.assign (F.r_u16());
return true;
}
bool CClip::Load(IReader& F)
{
R_ASSERT (F.find_chunk(EOBJ_CLIP_VERSION_CHUNK));
u16 ver = F.r_u16();
if (ver!=EOBJ_CLIP_VERSION) return false;
R_ASSERT(F.find_chunk(EOBJ_CLIP_DATA_CHUNK));
F.r_stringZ (name);
for (int k=0; k<4; k++){
F.r_stringZ (cycles[k].name);
cycles[k].slot = F.r_u16();
}
F.r_stringZ (fx.name);
fx.slot = F.r_u16();
fx_power = F.r_float();
length = F.r_float();
return true;
}
bool CCustomMotion::Load(IReader& F)
{
F.r_stringZ (name);
iFrameStart = F.r_u32();
iFrameEnd = F.r_u32();
fFPS = F.r_float();
return true;
}
void SHeliEnemy::load(IReader &input_packet)
{
type = (EHeliHuntState)input_packet.r_s16();
input_packet.r_fvector3 (destEnemyPos);
destEnemyID = input_packet.r_u32();
fire_trail_length_des = input_packet.r_float();
bUseFireTrail = !!input_packet.r_u8();
}
void CBone::Load_0(IReader& F)
{
F.r_stringZ (name); xr_strlwr(name);
F.r_stringZ (parent_name); xr_strlwr(parent_name);
F.r_stringZ (wmap);
F.r_fvector3 (rest_offset);
F.r_fvector3 (rest_rotate);
rest_length = F.r_float();
std::swap (rest_rotate.x,rest_rotate.y);
Reset ();
}
void STextureParams::Load(IReader& F)
{
R_ASSERT(F.find_chunk(THM_CHUNK_TEXTUREPARAM));
F.r (&fmt,sizeof(ETFormat));
flags.assign(F.r_u32());
border_color= F.r_u32();
fade_color = F.r_u32();
fade_amount = F.r_u32();
mip_filter = F.r_u32();
width = F.r_u32();
height = F.r_u32();
if (F.find_chunk(THM_CHUNK_TEXTURE_TYPE)){
type = (ETType)F.r_u32();
}
if (F.find_chunk(THM_CHUNK_DETAIL_EXT)){
F.r_stringZ(detail_name);
detail_scale = F.r_float();
}
if (F.find_chunk(THM_CHUNK_MATERIAL)){
material = (ETMaterial)F.r_u32 ();
material_weight = F.r_float ();
}
if (F.find_chunk(THM_CHUNK_BUMP)){
bump_virtual_height = F.r_float ();
bump_mode = (ETBumpMode)F.r_u32 ();
if (bump_mode<STextureParams::tbmNone){
bump_mode = STextureParams::tbmNone; //.. временно (до полного убирания Autogen)
}
F.r_stringZ (bump_name);
}
if (F.find_chunk(THM_CHUNK_EXT_NORMALMAP))
F.r_stringZ (ext_normal_map_name);
if (F.find_chunk(THM_CHUNK_FADE_DELAY))
fade_delay = F.r_u8();
}
void CLAItem::Load(IReader& F)
{
R_ASSERT(F.find_chunk(CHUNK_ITEM_COMMON));
F.r_stringZ (cName);
fFPS = F.r_float();
iFrameCount = F.r_u32();
int key_cnt,key;
R_ASSERT(F.find_chunk(CHUNK_ITEM_KEYS));
key_cnt = F.r_u32();
for (int i=0; i<key_cnt; i++){
key = F.r_u32 ();
Keys[key] = F.r_u32();
}
}
void CHelicopter::load(IReader &input_packet)
{
m_movement.load (input_packet);
m_body.load (input_packet);
m_enemy.load (input_packet);
input_packet.r_fvector3 (XFORM().c);
m_barrel_dir_tolerance = input_packet.r_float();
UseFireTrail (m_enemy.bUseFireTrail);//force reloar disp params
load_data (m_use_rocket_on_attack, input_packet);
load_data (m_use_mgun_on_attack, input_packet);
load_data (m_min_rocket_dist, input_packet);
load_data (m_max_rocket_dist, input_packet);
load_data (m_min_mgun_dist, input_packet);
load_data (m_max_mgun_dist, input_packet);
load_data (m_time_between_rocket_attack, input_packet);
load_data (m_syncronize_rocket, input_packet);
}
void CInventoryItem::load(IReader &packet)
{
m_ItemCurrPlace.value = packet.r_u16();
m_fCondition = packet.r_float();
//-- load_data( m_upgrades, packet );
//-- install_loaded_upgrades();
u8 tmp = packet.r_u8();
if (!tmp)
return;
if (!object().PPhysicsShell()) {
object().setup_physic_shell ();
object().PPhysicsShell()->Disable();
}
object().PHLoadState(packet);
object().PPhysicsShell()->Disable();
}
void CInventoryItem::load(IReader &packet)
{
m_eItemPlace = (EItemPlace)packet.r_u8();
m_fCondition = packet.r_float();
SetSlot (packet.r_u8());
if (GetSlot() == 255)
SetSlot (NO_ACTIVE_SLOT);
u8 tmp = packet.r_u8();
if (!tmp)
return;
if (!object().PPhysicsShell()) {
object().setup_physic_shell ();
object().PPhysicsShell()->Disable();
}
object().PHLoadState(packet);
object().PPhysicsShell()->Disable();
}
void CBone::Load_1(IReader& F)
{
R_ASSERT(F.find_chunk(BONE_CHUNK_VERSION));
u16 ver = F.r_u16();
if ((ver!=0x0001)&&(ver!=BONE_VERSION))
return;
R_ASSERT(F.find_chunk(BONE_CHUNK_DEF));
F.r_stringZ (name); xr_strlwr(name);
F.r_stringZ (parent_name); xr_strlwr(parent_name);
F.r_stringZ (wmap);
R_ASSERT(F.find_chunk(BONE_CHUNK_BIND_POSE));
F.r_fvector3 (rest_offset);
F.r_fvector3 (rest_rotate);
rest_length = F.r_float();
if (ver==0x0001)
std::swap (rest_rotate.x,rest_rotate.y);
LoadData (F);
}
void CHitMemoryManager::load (IReader &packet)
{
if (!m_object->g_Alive())
return;
typedef CClientSpawnManager::CALLBACK_TYPE CALLBACK_TYPE;
CALLBACK_TYPE callback;
callback.bind (&m_object->memory(),&CMemoryManager::on_requested_spawn);
int count = packet.r_u8();
for (int i=0; i<count; ++i) {
CDelayedHitObject delayed_object;
delayed_object.m_object_id = packet.r_u16();
CHitObject &object = delayed_object.m_hit_object;
object.m_object = smart_cast<CEntityAlive*>(Level().Objects.net_Find(delayed_object.m_object_id));
// object params
object.m_object_params.m_level_vertex_id = packet.r_u32();
packet.r_fvector3 (object.m_object_params.m_position);
#ifdef USE_ORIENTATION
packet.r_float (object.m_object_params.m_orientation.yaw);
packet.r_float (object.m_object_params.m_orientation.pitch);
packet.r_float (object.m_object_params.m_orientation.roll);
#endif
// self params
object.m_self_params.m_level_vertex_id = packet.r_u32();
packet.r_fvector3 (object.m_self_params.m_position);
#ifdef USE_ORIENTATION
packet.r_float (object.m_self_params.m_orientation.yaw);
packet.r_float (object.m_self_params.m_orientation.pitch);
packet.r_float (object.m_self_params.m_orientation.roll);
#endif
#ifdef USE_LEVEL_TIME
VERIFY (Device.dwTimeGlobal >= object.m_level_time);
object.m_level_time = packet.r_u32();
object.m_level_time += Device.dwTimeGlobal;
#endif // USE_LEVEL_TIME
#ifdef USE_LAST_LEVEL_TIME
VERIFY (Device.dwTimeGlobal >= object.m_last_level_time);
object.m_last_level_time = packet.r_u32();
object.m_last_level_time += Device.dwTimeGlobal;
#endif // USE_LAST_LEVEL_TIME
#ifdef USE_FIRST_LEVEL_TIME
VERIFY (Device.dwTimeGlobal >= (*I).m_first_level_time);
object.m_first_level_time = packet.r_u32();
object.m_first_level_time += Device.dwTimeGlobal;
#endif // USE_FIRST_LEVEL_TIME
packet.r_fvector3 (object.m_direction);
object.m_bone_index = packet.r_u16();
object.m_amount = packet.r_float();
if (object.m_object) {
add (object);
continue;
}
m_delayed_objects.push_back (delayed_object);
const CClientSpawnManager::CSpawnCallback *spawn_callback = Level().client_spawn_manager().callback(delayed_object.m_object_id,m_object->ID());
if (!spawn_callback || !spawn_callback->m_object_callback)
if(!g_dedicated_server)
Level().client_spawn_manager().add (delayed_object.m_object_id,m_object->ID(),callback);
#ifdef DEBUG
else {
if (spawn_callback && spawn_callback->m_object_callback) {
VERIFY (spawn_callback->m_object_callback == callback);
}
}
#endif // DEBUG
}
}
bool CLight::Load(IReader& F)
{
u32 version = 0;
string1024 buf;
R_ASSERT(F.r_chunk(LIGHT_CHUNK_VERSION,&version));
if((version!=0x0010)&&(version!=LIGHT_VERSION)){
ELog.DlgMsg( mtError, "CLight: Unsupported version.");
return false;
}
CCustomObject::Load(F);
if (F.find_chunk(LIGHT_CHUNK_PARAMS)){
m_Type = (ELight::EType)F.r_u32();
F.r_fcolor (m_Color);
m_Brightness = F.r_float();
m_Range = F.r_float();
m_Attenuation0 = F.r_float();
m_Attenuation1 = F.r_float();
m_Attenuation2 = F.r_float();
m_Cone = F.r_float();
m_VirtualSize = F.r_float();
}else{
R_ASSERT(F.find_chunk(LIGHT_CHUNK_D3D_PARAMS));
Flight d3d;
F.r (&d3d,sizeof(d3d));
m_Type = (ELight::EType)d3d.type;
m_Color.set (d3d.diffuse);
PPosition = d3d.position;
m_Range = d3d.range;
m_Attenuation0 = d3d.attenuation0;
m_Attenuation1 = d3d.attenuation1;
m_Attenuation2 = d3d.attenuation2;
m_Cone = d3d.phi;
R_ASSERT(F.r_chunk(LIGHT_CHUNK_BRIGHTNESS,&m_Brightness));
}
R_ASSERT(F.r_chunk(LIGHT_CHUNK_USE_IN_D3D,&m_UseInD3D));
if(version==0x0010){
if (F.find_chunk(LIGHT_CHUNK_ROTATE)){
F.r_fvector3(FRotation);
}else{
FRotation.set(0,0,0);
}
}
if (F.find_chunk(LIGHT_CHUNK_FLAG)) F.r(&m_Flags.flags,sizeof(m_Flags));
if (F.find_chunk(LIGHT_CHUNK_LCONTROL)) F.r(&m_LControl,sizeof(m_LControl));
if (D3DLIGHT_DIRECTIONAL==m_Type){
ESceneLightTools* lt = dynamic_cast<ESceneLightTools*>(ParentTools); VERIFY(lt);
lt->m_SunShadowDir.set(FRotation.x,FRotation.y);
ELog.DlgMsg( mtError, "CLight: Can't load sun.");
return false;
}
if (F.find_chunk(LIGHT_CHUNK_ANIMREF)){
F.r_stringZ(buf,sizeof(buf));
m_pAnimRef = LALib.FindItem(buf);
if (!m_pAnimRef) ELog.Msg(mtError, "Can't find light animation: %s",buf);
}
if (F.find_chunk(LIGHT_CHUNK_FALLOFF_TEXTURE)){
F.r_stringZ(m_FalloffTex);
}
if (F.find_chunk(LIGHT_CHUNK_FUZZY_DATA)){
m_FuzzyData = xr_new<SFuzzyData>();
m_FuzzyData->Load(F);
m_Flags.set(ELight::flPointFuzzy,TRUE);
}else{
m_Flags.set(ELight::flPointFuzzy,FALSE);
}
UpdateTransform ();
return true;
}
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);
}
bool CSMotion::Load(IReader& F)
{
CCustomMotion::Load(F);
u16 vers = F.r_u16();
if (vers==0x0004){
m_BoneOrPart= u16(F.r_u32()&0xffff);
m_Flags.set (esmFX,F.r_u8());
m_Flags.set (esmStopAtEnd,F.r_u8());
fSpeed = F.r_float();
fAccrue = F.r_float();
fFalloff = F.r_float();
fPower = F.r_float();
bone_mots.resize(F.r_u32());
string64 temp_buf;
for(BoneMotionIt bm_it=bone_mots.begin(); bm_it!=bone_mots.end(); bm_it++){
bm_it->SetName (itoa(int(bm_it-bone_mots.begin()),temp_buf,10));
bm_it->m_Flags.assign((u8)F.r_u32());
for (int ch=0; ch<ctMaxChannel; ch++){
bm_it->envs[ch] = xr_new<CEnvelope> ();
bm_it->envs[ch]->Load_1(F);
}
}
}else{
if (vers==0x0005){
m_Flags.assign ((u8)F.r_u32());
m_BoneOrPart= u16(F.r_u32()&0xffff);
fSpeed = F.r_float();
fAccrue = F.r_float();
fFalloff = F.r_float();
fPower = F.r_float();
bone_mots.resize(F.r_u32());
string64 buf;
for(BoneMotionIt bm_it=bone_mots.begin(); bm_it!=bone_mots.end(); bm_it++){
F.r_stringZ (buf,sizeof(buf));
bm_it->SetName (buf);
bm_it->m_Flags.assign((u8)F.r_u32());
for (int ch=0; ch<ctMaxChannel; ch++){
bm_it->envs[ch] = xr_new<CEnvelope> ();
bm_it->envs[ch]->Load_1(F);
}
}
}else{
if (vers!=EOBJ_SMOTION_VERSION) return false;
m_Flags.assign (F.r_u8());
m_BoneOrPart= F.r_u16();
fSpeed = F.r_float();
fAccrue = F.r_float();
fFalloff = F.r_float();
fPower = F.r_float();
bone_mots.resize(F.r_u16());
string64 buf;
for(BoneMotionIt bm_it=bone_mots.begin(); bm_it!=bone_mots.end(); bm_it++){
F.r_stringZ (buf,sizeof(buf));
bm_it->SetName (buf);
bm_it->m_Flags.assign(F.r_u8());
for (int ch=0; ch<ctMaxChannel; ch++){
bm_it->envs[ch] = xr_new<CEnvelope> ();
bm_it->envs[ch]->Load_2(F);
}
}
}
}
for(BoneMotionIt bm_it=bone_mots.begin(); bm_it!=bone_mots.end(); bm_it++)
xr_strlwr (bm_it->name);
return true;
}
bool EDetailManager::LoadStream(IReader& F)
{
inherited::LoadStream (F);
string256 buf;
R_ASSERT (F.find_chunk(DETMGR_CHUNK_VERSION));
u32 version = F.r_u32();
if (version!=DETMGR_VERSION){
ELog.Msg(mtError,"EDetailManager: unsupported version.");
return false;
}
if (F.find_chunk(DETMGR_CHUNK_FLAGS)) m_Flags.assign(F.r_u32());
// header
R_ASSERT (F.r_chunk(DETMGR_CHUNK_HEADER,&dtH));
// slots
R_ASSERT (F.find_chunk(DETMGR_CHUNK_SLOTS));
int slot_cnt = F.r_u32();
if (slot_cnt)dtSlots= xr_alloc<DetailSlot>(slot_cnt);
m_Selected.resize (slot_cnt);
F.r (dtSlots,slot_cnt*sizeof(DetailSlot));
// objects
if (!LoadColorIndices(F)){
ELog.DlgMsg (mtError,"EDetailManager: Some objects removed. Reinitialize objects.",buf);
InvalidateSlots ();
}
// internal
// bbox
R_ASSERT (F.r_chunk(DETMGR_CHUNK_BBOX,&m_BBox));
// snap objects
if (F.find_chunk(DETMGR_CHUNK_SNAP_OBJECTS)){
int snap_cnt = F.r_u32();
if (snap_cnt){
for (int i=0; i<snap_cnt; i++){
F.r_stringZ (buf,sizeof(buf));
CCustomObject* O = Scene->FindObjectByName(buf,OBJCLASS_SCENEOBJECT);
if (!O) ELog.Msg(mtError,"EDetailManager: Can't find snap object '%s'.",buf);
else m_SnapObjects.push_back(O);
}
}
}
if (F.find_chunk(DETMGR_CHUNK_DENSITY))
ps_r__Detail_density= F.r_float();
// base texture
if(F.find_chunk(DETMGR_CHUNK_BASE_TEXTURE)){
F.r_stringZ (buf,sizeof(buf));
if (m_Base.LoadImage(buf)){
m_Base.CreateShader();
m_RTFlags.set(flRTGenerateBaseMesh,TRUE);
}else{
ELog.Msg(mtError,"EDetailManager: Can't find base texture '%s'.",buf);
ClearSlots();
ClearBase();
}
}
InvalidateCache ();
return true;
}
void CKinematics::Load(const char* N, IReader *data, u32 dwFlags)
{
//Msg ("skeleton: %s",N);
inherited::Load (N, data, dwFlags);
pUserData = NULL;
m_lod = NULL;
// loading lods
IReader* LD = data->open_chunk(OGF_S_LODS);
if (LD)
{
string_path short_name;
strcpy_s (short_name,sizeof(short_name),N);
if (strext(short_name)) *strext(short_name)=0;
// From stream
{
string_path lod_name;
LD->r_string (lod_name, sizeof(lod_name));
//. strconcat (sizeof(name_load),name_load, short_name, ":lod:", lod_name.c_str());
m_lod = ::Render->model_CreateChild(lod_name, NULL);
VERIFY3(m_lod,"Cant create LOD model for", N);
//. VERIFY2 (m_lod->Type==MT_HIERRARHY || m_lod->Type==MT_PROGRESSIVE || m_lod->Type==MT_NORMAL,lod_name.c_str());
/*
strconcat (name_load, short_name, ":lod:1");
m_lod = ::Render->model_CreateChild(name_load,LD);
VERIFY (m_lod->Type==MT_SKELETON_GEOMDEF_PM || m_lod->Type==MT_SKELETON_GEOMDEF_ST);
*/
}
LD->close ();
}
#ifndef _EDITOR
// User data
IReader* UD = data->open_chunk(OGF_S_USERDATA);
pUserData = UD?xr_new<CInifile>(UD,FS.get_path("$game_config$")->m_Path):0;
if (UD) UD->close();
#endif
// Globals
bone_map_N = xr_new<accel> ();
bone_map_P = xr_new<accel> ();
bones = xr_new<vecBones> ();
bone_instances = NULL;
// Load bones
#pragma todo("container is created in stack!")
xr_vector<shared_str> L_parents;
R_ASSERT (data->find_chunk(OGF_S_BONE_NAMES));
visimask.zero ();
int dwCount = data->r_u32();
// Msg ("!!! %d bones",dwCount);
// if (dwCount >= 64) Msg ("!!! More than 64 bones is a crazy thing! (%d), %s",dwCount,N);
VERIFY3 (dwCount < 64, "More than 64 bones is a crazy thing!",N);
for (; dwCount; dwCount--) {
string256 buf;
// Bone
u16 ID = u16(bones->size());
data->r_stringZ (buf,sizeof(buf)); strlwr(buf);
CBoneData* pBone = CreateBoneData(ID);
pBone->name = shared_str(buf);
pBone->child_faces.resize (children.size());
bones->push_back (pBone);
bone_map_N->push_back (mk_pair(pBone->name,ID));
bone_map_P->push_back (mk_pair(pBone->name,ID));
// It's parent
data->r_stringZ (buf,sizeof(buf)); strlwr(buf);
L_parents.push_back (buf);
data->r (&pBone->obb,sizeof(Fobb));
visimask.set (u64(1)<<ID,TRUE);
}
std::sort (bone_map_N->begin(),bone_map_N->end(),pred_sort_N);
std::sort (bone_map_P->begin(),bone_map_P->end(),pred_sort_P);
// Attach bones to their parents
iRoot = BI_NONE;
for (u32 i=0; i<bones->size(); i++) {
shared_str P = L_parents[i];
CBoneData* B = (*bones)[i];
if (!P||!P[0]) {
// no parent - this is root bone
R_ASSERT (BI_NONE==iRoot);
iRoot = u16(i);
B->SetParentID(BI_NONE);
continue;
} else {
u16 ID = LL_BoneID(P);
R_ASSERT (ID!=BI_NONE);
(*bones)[ID]->children.push_back(B);
B->SetParentID(ID);
}
}
R_ASSERT (BI_NONE != iRoot);
// Free parents
L_parents.clear();
// IK data
IReader* IKD = data->open_chunk(OGF_S_IKDATA);
if (IKD){
for (u32 i=0; i<bones->size(); i++) {
CBoneData* B = (*bones)[i];
u16 vers = (u16)IKD->r_u32();
IKD->r_stringZ (B->game_mtl_name);
IKD->r (&B->shape,sizeof(SBoneShape));
B->IK_data.Import(*IKD,vers);
Fvector vXYZ,vT;
IKD->r_fvector3 (vXYZ);
IKD->r_fvector3 (vT);
B->bind_transform.setXYZi(vXYZ);
B->bind_transform.translate_over(vT);
B->mass = IKD->r_float();
IKD->r_fvector3 (B->center_of_mass);
}
// calculate model to bone converting matrix
(*bones)[LL_GetBoneRoot()]->CalculateM2B(Fidentity);
IKD->close();
}
// after load process
{
for (u16 child_idx=0; child_idx<(u16)children.size(); child_idx++)
LL_GetChild(child_idx)->AfterLoad (this,child_idx);
}
// unique bone faces
{
for (u32 bone_idx=0; bone_idx<bones->size(); bone_idx++) {
CBoneData* B = (*bones)[bone_idx];
for (u32 child_idx=0; child_idx<children.size(); child_idx++){
CBoneData::FacesVec faces = B->child_faces[child_idx];
std::sort (faces.begin(),faces.end());
CBoneData::FacesVecIt new_end = std::unique(faces.begin(),faces.end());
faces.erase (new_end,faces.end());
B->child_faces[child_idx].clear_and_free();
B->child_faces[child_idx] = faces;
}
}
}
// reset update_callback
Update_Callback = NULL;
// reset update frame
wm_frame = u32(-1);
LL_Validate ();
}
bool ESoundSource::Load(IReader& F)
{
u32 version = 0;
if(F.r_chunk(SOUND_CHUNK_VERSION,&version)){
if(version!=SOUND_SOURCE_VERSION){
ELog.Msg( mtError, "ESoundSource: Unsupported version.");
return false;
}
}else return false;
inherited::Load (F);
R_ASSERT(F.find_chunk(SOUND_CHUNK_TYPE));
m_Type = ESoundType(F.r_u32());
R_ASSERT(F.find_chunk(SOUND_CHUNK_SOURCE_NAME));
F.r_stringZ (m_WAVName);
if (F.find_chunk(SOUND_CHUNK_SOURCE_PARAMS3)){
m_Params.base_volume = 1.f;
F.r_fvector3 (m_Params.position);
m_Params.volume = F.r_float();
m_Params.freq = F.r_float();
m_Params.min_distance = F.r_float();
m_Params.max_distance = F.r_float();
m_Params.max_ai_distance= F.r_float();
}else if (F.find_chunk(SOUND_CHUNK_SOURCE_PARAMS2)){
m_Params.base_volume = 1.f;
F.r_fvector3 (m_Params.position);
m_Params.volume = F.r_float();
m_Params.freq = F.r_float();
m_Params.min_distance = F.r_float();
m_Params.max_distance = F.r_float();
m_Params.max_ai_distance= F.r_float();
}else{
if (!F.find_chunk(SOUND_CHUNK_SOURCE_PARAMS)){
ELog.DlgMsg( mtError, "ESoundSource: Can't load Sound Source '%s'. Unsupported version.",*m_WAVName);
return false;
}
m_Params.base_volume = 1.f;
F.r_fvector3 (m_Params.position);
m_Params.volume = F.r_float();
m_Params.freq = F.r_float();
m_Params.min_distance = F.r_float();
m_Params.max_distance = F.r_float();
m_Params.max_ai_distance= m_Params.max_distance;
}
if(F.find_chunk(SOUND_CHUNK_SOURCE_FLAGS))
F.r (&m_Flags,sizeof(m_Flags));
if(F.find_chunk(SOUND_CHUNK_GAME_PARAMS)){
F.r_fvector2 (m_RandomPause);
F.r_fvector2 (m_ActiveTime);
F.r_fvector2 (m_PlayTime);
}
ResetSource ();
switch (m_Type){
case stStaticSource:
if (m_Flags.is(flPlaying)) Play();
if (m_Flags.is(flSimulating)) Simulate();
break;
default: THROW;
}
return true;
}
void SGameMtl::Load(IReader& fs)
{
R_ASSERT(fs.find_chunk(GAMEMTL_CHUNK_MAIN));
ID = fs.r_u32();
fs.r_stringZ (m_Name);
if (fs.find_chunk(GAMEMTL_CHUNK_DESC)){
fs.r_stringZ (m_Desc);
}
R_ASSERT(fs.find_chunk(GAMEMTL_CHUNK_FLAGS));
Flags.assign (fs.r_u32());
R_ASSERT(fs.find_chunk(GAMEMTL_CHUNK_PHYSICS));
fPHFriction = fs.r_float();
fPHDamping = fs.r_float();
fPHSpring = fs.r_float();
fPHBounceStartVelocity = fs.r_float();
fPHBouncing = fs.r_float();
R_ASSERT(fs.find_chunk(GAMEMTL_CHUNK_FACTORS));
fShootFactor = fs.r_float();
fBounceDamageFactor = fs.r_float();
fVisTransparencyFactor = fs.r_float();
fSndOcclusionFactor = fs.r_float();
if(fs.find_chunk(GAMEMTL_CHUNK_FLOTATION))
fFlotationFactor = fs.r_float();
if(fs.find_chunk(GAMEMTL_CHUNK_INJURIOUS))
fInjuriousSpeed = fs.r_float();
}
