modelloadermdx.cpp

骨骼动画....把魔兽模型解出的代码..

			DataStream.WriteDWord(0);
		}
	}
	else
	{
		if(ParticleEmitter2.Data().Tail)
		{
			DataStream.WriteDWord(1);
		}
		else
		{
			DataStream.WriteDWord(0); //What value if neither???
		}
	}

	DataStream.WriteFloat(ParticleEmitter2.Data().TailLength);
	DataStream.WriteFloat(ParticleEmitter2.Data().Time);

	DataStream.WriteFloat(ParticleEmitter2.Data().SegmentColor1.z);
	DataStream.WriteFloat(ParticleEmitter2.Data().SegmentColor1.y);
	DataStream.WriteFloat(ParticleEmitter2.Data().SegmentColor1.x);

	DataStream.WriteFloat(ParticleEmitter2.Data().SegmentColor2.z);
	DataStream.WriteFloat(ParticleEmitter2.Data().SegmentColor2.y);
	DataStream.WriteFloat(ParticleEmitter2.Data().SegmentColor2.x);

	DataStream.WriteFloat(ParticleEmitter2.Data().SegmentColor3.z);
	DataStream.WriteFloat(ParticleEmitter2.Data().SegmentColor3.y);
	DataStream.WriteFloat(ParticleEmitter2.Data().SegmentColor3.x);

	DataStream.WriteByte(static_cast<BYTE>(ParticleEmitter2.Data().Alpha.x));
	DataStream.WriteByte(static_cast<BYTE>(ParticleEmitter2.Data().Alpha.y));
	DataStream.WriteByte(static_cast<BYTE>(ParticleEmitter2.Data().Alpha.z));

	DataStream.WriteFloat(ParticleEmitter2.Data().ParticleScaling.x);
	DataStream.WriteFloat(ParticleEmitter2.Data().ParticleScaling.y);
	DataStream.WriteFloat(ParticleEmitter2.Data().ParticleScaling.z);

	DataStream.WriteDWord(static_cast<DWORD>(ParticleEmitter2.Data().HeadLifeSpan.x));
	DataStream.WriteDWord(static_cast<DWORD>(ParticleEmitter2.Data().HeadLifeSpan.y));
	DataStream.WriteDWord(static_cast<DWORD>(ParticleEmitter2.Data().HeadLifeSpan.z));

	DataStream.WriteDWord(static_cast<DWORD>(ParticleEmitter2.Data().HeadDecay.x));
	DataStream.WriteDWord(static_cast<DWORD>(ParticleEmitter2.Data().HeadDecay.y));
	DataStream.WriteDWord(static_cast<DWORD>(ParticleEmitter2.Data().HeadDecay.z));

	DataStream.WriteDWord(static_cast<DWORD>(ParticleEmitter2.Data().TailLifeSpan.x));
	DataStream.WriteDWord(static_cast<DWORD>(ParticleEmitter2.Data().TailLifeSpan.y));
	DataStream.WriteDWord(static_cast<DWORD>(ParticleEmitter2.Data().TailLifeSpan.z));

	DataStream.WriteDWord(static_cast<DWORD>(ParticleEmitter2.Data().TailDecay.x));
	DataStream.WriteDWord(static_cast<DWORD>(ParticleEmitter2.Data().TailDecay.y));
	DataStream.WriteDWord(static_cast<DWORD>(ParticleEmitter2.Data().TailDecay.z));

	DataStream.WriteDWord((ParticleEmitter2.Data().TextureId == INVALID_INDEX) ? 0xFFFFFFFF : ParticleEmitter2.Data().TextureId);
	DataStream.WriteDWord(ParticleEmitter2.Data().Squirt ? 1 : 0);
	DataStream.WriteDWord(ParticleEmitter2.Data().PriorityPlane);
	DataStream.WriteDWord(ParticleEmitter2.Data().ReplaceableId);

	if(ParticleEmitter2.Data().Visibility.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KP2V'));
		if(!ParticleEmitter2.Data().Visibility.Save(DataStream)) return FALSE;
	}

	if(ParticleEmitter2.Data().EmissionRate.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KP2E'));
		if(!ParticleEmitter2.Data().EmissionRate.Save(DataStream)) return FALSE;
	}

	if(ParticleEmitter2.Data().Width.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KP2W'));
		if(!ParticleEmitter2.Data().Width.Save(DataStream)) return FALSE;
	}

	if(ParticleEmitter2.Data().Length.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KP2N'));
		if(!ParticleEmitter2.Data().Length.Save(DataStream)) return FALSE;
	}

	if(ParticleEmitter2.Data().Speed.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KP2S'));
		if(!ParticleEmitter2.Data().Speed.Save(DataStream)) return FALSE;
	}

	if(ParticleEmitter2.Data().Latitude.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KP2L'));
		if(!ParticleEmitter2.Data().Latitude.Save(DataStream)) return FALSE;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves the model ribbon emitters
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveRibbonEmitters(MODEL& Model, DATA_OUT_STREAM& DataStream)
{
	INT i;
	INT TotalSize = 0;

	if(Model.Data().RibbonEmitterContainer.GetSize() <= 0) return TRUE;

	for(i = 0; i < Model.Data().RibbonEmitterContainer.GetTotalSize(); i++)
	{
		if(Model.Data().RibbonEmitterContainer.ValidIndex(i))
		{
			TotalSize += Model.Data().RibbonEmitterContainer[i]->GetSize();
		}
	}

	DataStream.WriteDWord(ReverseDWord('RIBB'));
	DataStream.WriteDWord(TotalSize);

	for(i = 0; i < Model.Data().RibbonEmitterContainer.GetTotalSize(); i++)
	{
		if(Model.Data().RibbonEmitterContainer.ValidIndex(i))
		{
			if(!SaveRibbonEmitter(*(Model.Data().RibbonEmitterContainer[i]), DataStream)) return FALSE;
		}
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model ribbon emitter
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveRibbonEmitter(MODEL_RIBBON_EMITTER& RibbonEmitter, DATA_OUT_STREAM& DataStream)
{
	DataStream.WriteDWord(RibbonEmitter.GetSize());

	if(!SaveBaseData(RibbonEmitter.BaseData(), DataStream, NODE_FLAG_RIBBON_EMITTER)) return FALSE;

	DataStream.WriteFloat(RibbonEmitter.Data().HeightAbove.GetScalar());
	DataStream.WriteFloat(RibbonEmitter.Data().HeightBelow.GetScalar());
	DataStream.WriteFloat(RibbonEmitter.Data().Alpha.GetScalar());

	DataStream.WriteFloat(RibbonEmitter.Data().Color.GetVector3().z);
	DataStream.WriteFloat(RibbonEmitter.Data().Color.GetVector3().y);
	DataStream.WriteFloat(RibbonEmitter.Data().Color.GetVector3().x);

	DataStream.WriteFloat(RibbonEmitter.Data().LifeSpan);

	DataStream.WriteDWord(0); //What's this? (Always 0?)

	DataStream.WriteDWord(static_cast<DWORD>(RibbonEmitter.Data().EmissionRate));
	DataStream.WriteDWord(RibbonEmitter.Data().Rows);
	DataStream.WriteDWord(RibbonEmitter.Data().Columns);
	DataStream.WriteDWord((RibbonEmitter.Data().MaterialId == INVALID_INDEX) ? 0xFFFFFFFF : RibbonEmitter.Data().MaterialId);
	DataStream.WriteFloat(RibbonEmitter.Data().Gravity);

	if(RibbonEmitter.Data().Visibility.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KRVS'));
		if(!RibbonEmitter.Data().Visibility.Save(DataStream)) return FALSE;
	}

	if(RibbonEmitter.Data().HeightAbove.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KRHA'));
		if(!RibbonEmitter.Data().HeightAbove.Save(DataStream)) return FALSE;
	}

	if(RibbonEmitter.Data().HeightBelow.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KRHB'));
		if(!RibbonEmitter.Data().HeightBelow.Save(DataStream)) return FALSE;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves the model event objects
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveEventObjects(MODEL& Model, DATA_OUT_STREAM& DataStream)
{
	INT i;
	INT TotalSize = 0;

	if(Model.Data().EventObjectContainer.GetSize() <= 0) return TRUE;

	for(i = 0; i < Model.Data().EventObjectContainer.GetTotalSize(); i++)
	{
		if(Model.Data().EventObjectContainer.ValidIndex(i))
		{
			TotalSize += Model.Data().EventObjectContainer[i]->GetSize();
		}
	}

	DataStream.WriteDWord(ReverseDWord('EVTS'));
	DataStream.WriteDWord(TotalSize);

	for(i = 0; i < Model.Data().EventObjectContainer.GetTotalSize(); i++)
	{
		if(Model.Data().EventObjectContainer.ValidIndex(i))
		{
			if(!SaveEventObject(*(Model.Data().EventObjectContainer[i]), DataStream)) return FALSE;
		}
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model event object
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveEventObject(MODEL_EVENT_OBJECT& EventObject, DATA_OUT_STREAM& DataStream)
{
	std::list<INT>::iterator i;

	if(!SaveBaseData(EventObject.BaseData(), DataStream, NODE_FLAG_EVENT_OBJECT)) return FALSE;

	DataStream.WriteDWord(ReverseDWord('KEVT'));

	DataStream.WriteDWord(static_cast<DWORD>(EventObject.Data().EventTrack.size()));
	DataStream.WriteDWord((EventObject.Data().GlobalSequenceId == INVALID_INDEX) ? 0xFFFFFFFF : EventObject.Data().GlobalSequenceId);

	i = EventObject.Data().EventTrack.begin();
	while(i != EventObject.Data().EventTrack.end())
	{
		DataStream.WriteDWord(*i);
		i++;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves the model cameras
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveCameras(MODEL& Model, DATA_OUT_STREAM& DataStream)
{
	INT i;
	INT TotalSize = 0;

	if(Model.Data().CameraContainer.GetSize() <= 0) return TRUE;

	for(i = 0; i < Model.Data().CameraContainer.GetTotalSize(); i++)
	{
		if(Model.Data().CameraContainer.ValidIndex(i))
		{
			TotalSize += Model.Data().CameraContainer[i]->GetSize();
		}
	}

	DataStream.WriteDWord(ReverseDWord('CAMS'));
	DataStream.WriteDWord(TotalSize);

	for(i = 0; i < Model.Data().CameraContainer.GetTotalSize(); i++)
	{
		if(Model.Data().CameraContainer.ValidIndex(i))
		{
			if(!SaveCamera(*(Model.Data().CameraContainer[i]), DataStream)) return FALSE;
		}
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model camera
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveCamera(MODEL_CAMERA& Camera, DATA_OUT_STREAM& DataStream)
{
	DataStream.WriteDWord(Camera.GetSize());

	DataStream.WriteString(Camera.Data().Name, MODEL_NAME_CAMERA_SIZE);

	DataStream.WriteFloat(Camera.Data().Source.x);
	DataStream.WriteFloat(Camera.Data().Source.y);
	DataStream.WriteFloat(Camera.Data().Source.z);

	DataStream.WriteFloat(Camera.Data().FieldOfView);
	DataStream.WriteFloat(Camera.Data().FarDistance);
	DataStream.WriteFloat(Camera.Data().NearDistance);

	DataStream.WriteFloat(Camera.Data().Target.x);
	DataStream.WriteFloat(Camera.Data().Target.y);
	DataStream.WriteFloat(Camera.Data().Target.z);

	if(Camera.Data().SourceTranslation.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KCTR'));
		if(!Camera.Data().SourceTranslation.Save(DataStream)) return FALSE;
	}

	if(Camera.Data().TargetTranslation.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KTTR'));
		if(!Camera.Data().TargetTranslation.Save(DataStream)) return FALSE;
	}

	if(Camera.Data().Rotation.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KCRL'));
		if(!Camera.Data().Rotation.Save(DataStream)) return FALSE;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves the model collision shapes
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveCollisionShapes(MODEL& Model, DATA_OUT_STREAM& DataStream)
{
	INT i;
	INT TotalSize = 0;

	if(Model.Data().CollisionShapeContainer.GetSize() <= 0) return TRUE;

	for(i = 0; i < Model.Data().CollisionShapeContainer.GetTotalSize(); i++)
	{
		if(Model.Data().CollisionShapeContainer.ValidIndex(i))
		{
			TotalSize += Model.Data().CollisionShapeContainer[i]->GetSize();
		}
	}

	DataStream.WriteDWord(ReverseDWord('CLID'));
	DataStream.WriteDWord(TotalSize);

	for(i = 0; i < Model.Data().CollisionShapeContainer.GetTotalSize(); i++)
	{
		if(Model.Data().CollisionShapeContainer.ValidIndex(i))
		{
			if(!SaveCollisionShape(*(Model.Data().CollisionShapeContainer[i]), DataStream)) return FALSE;
		}
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model collision shape
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveCollisionShape(MODEL_COLLISION_SHAPE& CollisionShape, DATA_OUT_STREAM& DataStream)
{
	std::list<D3DXVECTOR3>::iterator i;

	if(!SaveBaseData(CollisionShape.BaseData(), DataStream, NODE_FLAG_COLLISION_SHAPE)) return FALSE;

	switch(CollisionShape.Data().Type)
	{
		case COLLISION_SHAPE_TYPE_BOX:
		{
			if(CollisionShape.Data().VertexList.size() != 2)
			{
				Error.SetMessage("Collision shape boxes needs exactly 2 vertices!");
				return FALSE;
			}

			DataStream.WriteDWord(0);
			break;
		}

		case COLLISION_SHAPE_TYPE_SPHERE:
		{
			if(CollisionShape.Data().VertexList.size() != 1)
			{
				Error.SetMessage("Collision shape spheres needs exactly 1 vertex!");
				return FALSE;
			}

			DataStream.WriteDWord(2);
			break;
		}

		default:
		{
			Error.SetMessage("Unknown collision shape type!");
			return FALSE;
		}
	}

	i = CollisionShape.Data().VertexList.begin();
	while(i != CollisionShape.Data().VertexList.end())
	{
		DataStream.WriteFloat(i->x);
		DataStream.WriteFloat(i->y);
		DataStream.WriteFloat(i->z);

		i++;
	}

	if(CollisionShape.Data().Type == COLLISION_SHAPE_TYPE_SPHERE)
	{
		DataStream.WriteFloat(CollisionShape.Data().BoundsRadius);
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Loads the model version
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::LoadVersion(MODEL& Model, DATA_IN_STREAM& DataStream, INT Size)
{
	Model.Data().Info.Version = DataStream.ReadDWord();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Loads the model info
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::LoadModel(MODEL& Model, DATA_IN_STREAM& DataStream, INT Size)
{
	CHAR Buffer[MODEL_NAME_SIZE + 1];

	Buffer[MODEL_NAME_SIZE] = '\0';

	if(!DataStream.Read(Buffer, MODEL_NAME_SIZE)) return FALSE;
	Model.Data().Info.Name = Buffer;

	DataStream.ReadDWord(); //What is this? (always 0?)