Esempio n. 1
0
void PDomain::Save(IWriter& F)
{
	F.w_u32		(type);
	F.w_fvector3(v[0]);
	F.w_fvector3(v[1]);
	F.w_fvector3(v[2]);
}
Esempio n. 2
0
void	base_Vertex::		write	(IWriter	&w )const
{
	 w.w_fvector3( P );
	 w.w_fvector3( N );
	 w_pod( w, C );		
	 w.w_s32( handle );
}
Esempio n. 3
0
void ESoundSource::Save(IWriter& F)
{
	inherited::Save	(F);

	F.open_chunk	(SOUND_CHUNK_VERSION);
	F.w_u16			(SOUND_SOURCE_VERSION);
	F.close_chunk	();

    F.w_chunk		(SOUND_CHUNK_TYPE,&m_Type,sizeof(m_Type));

    F.open_chunk	(SOUND_CHUNK_SOURCE_NAME);
    F.w_stringZ		(m_WAVName);
    F.close_chunk	();

    F.w_chunk		(SOUND_CHUNK_SOURCE_FLAGS,&m_Flags,sizeof(m_Flags));
    
    F.open_chunk	(SOUND_CHUNK_SOURCE_PARAMS3);
    F.w_fvector3	(m_Params.position);
    F.w_float		(m_Params.volume);
    F.w_float		(m_Params.freq);
    F.w_float		(m_Params.min_distance);
    F.w_float		(m_Params.max_distance);
    F.w_float		(m_Params.max_ai_distance);
    F.close_chunk	();

    F.open_chunk	(SOUND_CHUNK_GAME_PARAMS);
    F.w_fvector2	(m_RandomPause);
    F.w_fvector2	(m_ActiveTime);
    F.w_fvector2	(m_PlayTime);
    F.close_chunk	();
}
Esempio n. 4
0
void _face::write( IWriter &w ) const
{
	base_Face::write( w );
	w.w_fvector2( tc[0] );
	w.w_fvector2( tc[1] );
	w.w_fvector2( tc[2] );
	w.w_fvector3( N );
	w.w_u32( sm_group );
}
Esempio n. 5
0
void ESceneObjectTools::Save(IWriter& F)
{
	inherited::Save(F);

	F.w_chunk		(CHUNK_VERSION,(u16*)&OBJECT_TOOLS_VERSION,sizeof(OBJECT_TOOLS_VERSION));

	F.open_chunk	(CHUNK_FLAGS);
    F.w_u32			(m_Flags.get());
	F.close_chunk	();

    F.open_chunk	(CHUNK_APPEND_RANDOM);
    F.w_fvector3	(m_AppendRandomMinScale);
    F.w_fvector3	(m_AppendRandomMaxScale);
    F.w_fvector3	(m_AppendRandomMinRotation);
    F.w_fvector3	(m_AppendRandomMaxRotation);
    F.w_u32			(m_AppendRandomObjects.size());
    if (m_AppendRandomObjects.size()){
    	for (RStringVecIt it=m_AppendRandomObjects.begin(); it!=m_AppendRandomObjects.end(); it++)
            F.w_stringZ(*it);
    }
    F.close_chunk	();
}
Esempio n. 6
0
void CBone::Save(IWriter& F)
{
	F.open_chunk	(BONE_CHUNK_VERSION);
    F.w_u16			(BONE_VERSION);
    F.close_chunk	();
    
	F.open_chunk	(BONE_CHUNK_DEF);
	F.w_stringZ		(name);
	F.w_stringZ		(parent_name);
	F.w_stringZ		(wmap);
    F.close_chunk	();

	F.open_chunk	(BONE_CHUNK_BIND_POSE);
	F.w_fvector3	(rest_offset);
	F.w_fvector3	(rest_rotate);
	F.w_float		(rest_length);
    F.close_chunk	();

    SaveData		(F);
}
Esempio n. 7
0
void CBone::SaveData(IWriter& F)
{
	F.open_chunk	(BONE_CHUNK_DEF);
	F.w_stringZ		(name);	
    F.close_chunk	();

	F.open_chunk	(BONE_CHUNK_MATERIAL);
    F.w_stringZ		(game_mtl);
    F.close_chunk	();

	F.open_chunk	(BONE_CHUNK_SHAPE);
    F.w				(&shape,sizeof(SBoneShape));
    F.close_chunk	();
    
    F.open_chunk	(BONE_CHUNK_FLAGS);
    F.w_u32			(IK_data.ik_flags.get());
    F.close_chunk	();

	F.open_chunk	(BONE_CHUNK_IK_JOINT);
	F.w_u32			(IK_data.type);
    F.w				(IK_data.limits,sizeof(SJointLimit)*3);
    F.w_float		(IK_data.spring_factor);
    F.w_float		(IK_data.damping_factor);
    F.close_chunk	();

    F.open_chunk	(BONE_CHUNK_IK_JOINT_BREAK);
    F.w_float		(IK_data.break_force);
    F.w_float		(IK_data.break_torque);
    F.close_chunk	();

    F.open_chunk	(BONE_CHUNK_IK_JOINT_FRICTION);
    F.w_float		(IK_data.friction);
    F.close_chunk	();

    F.open_chunk	(BONE_CHUNK_MASS);
    F.w_float		(mass);
	F.w_fvector3	(center_of_mass);
    F.close_chunk	();
}
Esempio n. 8
0
void EScene::Save(LPCSTR map_name, bool bUndo, bool bForceSaveAll)
{
	R_ASSERT		(bUndo);
	VERIFY			(map_name);

    CTimer 			T;
    T.Start			();
    xr_string 		full_name;
	full_name		= map_name;
    
    xr_string 		part_prefix;

    bool bSaveMain	= true;
    
	IWriter* F			= 0;

    if (bSaveMain)
    {
	    F				= FS.w_open(full_name.c_str()); R_ASSERT(F);
        
        F->open_chunk	(CHUNK_VERSION);
        F->w_u32		(CURRENT_FILE_VERSION);
        F->close_chunk	();

        F->open_chunk	(CHUNK_LEVELOP);
        m_LevelOp.Save	(*F);
        F->close_chunk	();

        F->open_chunk	(CHUNK_TOOLS_GUID);
        F->w			(&m_GUID,sizeof(m_GUID));
        F->close_chunk	();

        F->open_chunk	(CHUNK_LEVEL_TAG);
        F->w_stringZ	(m_OwnerName);
        F->w			(&m_CreateTime,sizeof(m_CreateTime));
        F->close_chunk	();
    
		F->open_chunk	(CHUNK_CAMERA);
        F->w_fvector3	(EDevice.m_Camera.GetHPB());
        F->w_fvector3	(EDevice.m_Camera.GetPosition());
        F->close_chunk	();

        F->open_chunk		(CHUNK_SNAPOBJECTS);
        F->w_u32			(m_ESO_SnapObjects.size());

        for(ObjectIt _F=m_ESO_SnapObjects.begin();_F!=m_ESO_SnapObjects.end();++_F)
            F->w_stringZ	((*_F)->Name);

        F->close_chunk		();
    }

    m_SaveCache.clear		();

    SceneToolsMapPairIt _I = m_SceneTools.begin();
    SceneToolsMapPairIt _E = m_SceneTools.end();

    for (; _I!=_E; ++_I)
    {
        if (	(_I->first!=OBJCLASS_DUMMY) && 
        		_I->second 					&& 
                _I->second->IsEnabled()		&&
                _I->second->IsEditable() 	&&
                (_I->second->IsChanged()||bForceSaveAll)	)
        {

            if (_I->second->IsEnabled()&&_I->second->IsEditable())
            {
            	if (_I->second->IsNeedSave())
                {
                    _I->second->SaveStream	(m_SaveCache);
                    F->open_chunk			(CHUNK_TOOLS_DATA+_I->first);
                    F->w					(m_SaveCache.pointer(),m_SaveCache.size());
                    F->close_chunk			();
                }
            }
			m_SaveCache.clear	();
        }
    }
        
    // save data
    if (bSaveMain)		FS.w_close(F);
}
Esempio n. 9
0
void CPEDef::Save(IWriter& F)
{
	F.open_chunk	(PED_CHUNK_VERSION);
	F.w_u16			(PED_VERSION);
	F.close_chunk	();

	F.open_chunk	(PED_CHUNK_NAME);
	F.w_stringZ		(m_Name);
	F.close_chunk	();

	F.open_chunk	(PED_CHUNK_EFFECTDATA);
	F.w_u32			(m_MaxParticles);
	F.close_chunk	();

	F.open_chunk	(PED_CHUNK_ACTIONLIST);
	F.w				(m_Actions.pointer(),m_Actions.size());
	F.close_chunk	();

	F.w_chunk		(PED_CHUNK_FLAGS,&m_Flags,sizeof(m_Flags));

	if (m_Flags.is(dfSprite))
	{
		F.open_chunk	(PED_CHUNK_SPRITE);
		F.w_stringZ		(m_ShaderName);
		F.w_stringZ		(m_TextureName);
		F.close_chunk	();
	}

	if (m_Flags.is(dfFramed))
	{
		F.open_chunk	(PED_CHUNK_FRAME);
		F.w				(&m_Frame,sizeof(SFrame));
		F.close_chunk	();
	}

	if (m_Flags.is(dfTimeLimit))
	{
		F.open_chunk	(PED_CHUNK_TIMELIMIT);
		F.w_float		(m_fTimeLimit);
		F.close_chunk	();
	}

	if (m_Flags.is(dfCollision))
	{
		F.open_chunk	(PED_CHUNK_COLLISION);
		F.w_float		(m_fCollideOneMinusFriction);	
		F.w_float		(m_fCollideResilience);
		F.w_float		(m_fCollideSqrCutoff);
		F.close_chunk	();
	}

	if (m_Flags.is(dfVelocityScale))
	{
		F.open_chunk	(PED_CHUNK_VEL_SCALE);
		F.w_fvector3	(m_VelocityScale);
		F.close_chunk	();
	}

	if (m_Flags.is(dfAlignToPath))
	{
		F.open_chunk	(PED_CHUNK_ALIGN_TO_PATH);
		F.w_fvector3	(m_APDefaultRotation);
		F.close_chunk	();
	}
#ifdef _EDITOR
	F.open_chunk	(PED_CHUNK_EDATA);
    F.w_u32			(m_EActionList.size());
    for (EPAVecIt it=m_EActionList.begin(); it!=m_EActionList.end(); it++){
        F.w_u32		((*it)->type);
    	(*it)->Save	(F);
    }
	F.close_chunk	();
#endif
}
Esempio n. 10
0
void CEditableObject::Save(IWriter& F)
{
	F.open_chunk	(EOBJ_CHUNK_VERSION);
	F.w_u16			(EOBJ_CURRENT_VERSION);
	F.close_chunk	();

	F.open_chunk	(EOBJ_CHUNK_CLASSSCRIPT);
	F.w_stringZ		(m_ClassScript);
	F.close_chunk	();

	F.open_chunk	(EOBJ_CHUNK_LODS);
	F.w_stringZ		(m_LODs);
	F.close_chunk	();

    F.w_chunk		(EOBJ_CHUNK_FLAGS,&m_Flags.flags,sizeof(m_Flags.flags));

//    Log("1: ",F.tell());
    // meshes
    F.open_chunk	(EOBJ_CHUNK_EDITMESHES);
    int count = 0;
    for(EditMeshIt m = m_Meshes.begin();m!=m_Meshes.end();m++){
        F.open_chunk(count); count++;
        (*m)->SaveMesh(F);
        F.close_chunk();
    }
    F.close_chunk	();
//    Log("2: ",F.tell());
    // surfaces
    F.open_chunk	(EOBJ_CHUNK_SURFACES3);
    F.w_u32		(m_Surfaces.size());
    for (SurfaceIt sf_it=m_Surfaces.begin(); sf_it!=m_Surfaces.end(); sf_it++){
        F.w_stringZ	((*sf_it)->_Name			());
        F.w_stringZ	((*sf_it)->_ShaderName		());
        F.w_stringZ	((*sf_it)->_ShaderXRLCName	());
        F.w_stringZ	((*sf_it)->_GameMtlName		());
		F.w_stringZ	((*sf_it)->_Texture			());
		F.w_stringZ	((*sf_it)->_VMap			());
        F.w_u32	((*sf_it)->m_Flags.get		());
        F.w_u32	((*sf_it)->_FVF				());
        F.w_u32	(1);
    }
    F.close_chunk	();
//    Log("3: ",F.tell());

    // bones
    if (!m_Bones.empty()){
	    F.open_chunk	(EOBJ_CHUNK_BONES2);
	    for (BoneIt b_it=m_Bones.begin(); b_it!=m_Bones.end(); b_it++){
        	F.open_chunk	(b_it-m_Bones.begin());
        	(*b_it)->Save	(F);
	    	F.close_chunk	();
        }
    	F.close_chunk	();
    }
//    Log("4: ",F.tell());

    // skeleton motions
    if (!m_SMotions.empty()){
        F.open_chunk	(EOBJ_CHUNK_SMOTIONS);
        F.w_u32			(m_SMotions.size());
        for (SMotionIt s_it=m_SMotions.begin(); s_it!=m_SMotions.end(); s_it++) (*s_it)->Save(F);
        F.close_chunk	();
    }
    // skeleton motions refs
    if (m_SMotionRefs.size()){
        F.open_chunk	(EOBJ_CHUNK_SMOTIONS2);
        F.w_stringZ		(m_SMotionRefs);
        F.close_chunk	();
    }
//    Log("5: ",F.tell());

    // bone parts
    if (!m_BoneParts.empty()){
        F.open_chunk	(EOBJ_CHUNK_BONEPARTS2);
        F.w_u32			(m_BoneParts.size());
        for (BPIt bp_it=m_BoneParts.begin(); bp_it!=m_BoneParts.end(); bp_it++){
            F.w_stringZ	(bp_it->alias);
            F.w_u32		(bp_it->bones.size());
            for (RStringVecIt s_it=bp_it->bones.begin(); s_it!=bp_it->bones.end(); s_it++)
	            F.w_stringZ(s_it->c_str());
        }
        F.close_chunk	();
    }
//    Log("6: ",F.tell());

    if (IsDynamic()){
		F.open_chunk	(EOBJ_CHUNK_ACTORTRANSFORM);
        F.w_fvector3		(a_vPosition);
        F.w_fvector3		(a_vRotate);
		F.close_chunk	();
    }
//    Log("7: ",F.tell());

    F.open_chunk		(EOBJ_CHUNK_DESC);
    F.w_stringZ			(m_CreateName.c_str());
    F.w					(&m_CreateTime,sizeof(m_CreateTime));
    F.w_stringZ			(m_ModifName.c_str());
    F.w					(&m_ModifTime,sizeof(m_ModifTime));
    F.close_chunk		();

    // set modif desc
	SetVersionToCurrent	(FALSE, TRUE);

	bOnModified		= false;
}