modelloadermdl.cpp

来自「骨骼动画....把魔兽模型解出的代码..」· C++ 代码 · 共 2,345 行 · 第 1/5 页

	if(Geoset.Data().Extent.Max != D3DXVECTOR3(0.0f, 0.0f, 0.0f))
	{
		TokenStream.WriteTab();
		TokenStream.WriteWord("MaximumExtent ");
		TokenStream.WriteVector3(Geoset.Data().Extent.Max);
		TokenStream.WriteLine(",");
	}

	if(Geoset.Data().Extent.Radius > 0.0f)
	{
		TokenStream.WriteTab();
		TokenStream.WriteWord("BoundsRadius ");
		TokenStream.WriteFloat(Geoset.Data().Extent.Radius);
		TokenStream.WriteLine(",");
	}

	for(i = 0; i < Geoset.Data().ExtentContainer.GetTotalSize(); i++)
	{
		if(Geoset.Data().ExtentContainer.ValidIndex(i))
		{
			TokenStream.WriteTab();
			TokenStream.WriteLine("Anim {");

			TokenStream.WriteTab(2);
			TokenStream.WriteWord("MinimumExtent ");
			TokenStream.WriteVector3(Geoset.Data().ExtentContainer[i]->Min);
			TokenStream.WriteLine(",");

			TokenStream.WriteTab(2);
			TokenStream.WriteWord("MaximumExtent ");
			TokenStream.WriteVector3(Geoset.Data().ExtentContainer[i]->Max);
			TokenStream.WriteLine(",");

			if(Geoset.Data().ExtentContainer[i]->Radius > 0.0f)
			{
				TokenStream.WriteTab(2);
				TokenStream.WriteWord("BoundsRadius ");
				TokenStream.WriteFloat(Geoset.Data().ExtentContainer[i]->Radius);
				TokenStream.WriteLine(",");
			}

			TokenStream.WriteTab();
			TokenStream.WriteLine("}");
		}
	}

	if(Geoset.Data().MaterialId != INVALID_INDEX)
	{
		TokenStream.WriteTab();
		TokenStream.WriteWord("MaterialID ");
		TokenStream.WriteInt(Geoset.Data().MaterialId);
		TokenStream.WriteLine(",");
	}
	
	if(Geoset.Data().SelectionGroup != INVALID_INDEX)
	{
		TokenStream.WriteTab();
		TokenStream.WriteWord("SelectionGroup ");
		TokenStream.WriteInt(Geoset.Data().SelectionGroup);
		TokenStream.WriteLine(",");
	}

	if(Geoset.Data().Unselectable)
	{
		TokenStream.WriteTab();
		TokenStream.WriteLine("Unselectable,");
	}

	TokenStream.WriteLine("}");

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves the model geoset animations
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDL::SaveGeosetAnimations(MODEL& Model, TOKEN_OUT_STREAM& TokenStream)
{
	INT i;

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

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

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model geoset animation
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDL::SaveGeosetAnimation(MODEL_GEOSET_ANIMATION& GeosetAnimation, TOKEN_OUT_STREAM& TokenStream)
{
	TokenStream.WriteLine("GeosetAnim {");

	if(GeosetAnimation.Data().GeosetId != INVALID_INDEX)
	{
		TokenStream.WriteTab();
		TokenStream.WriteWord("GeosetId ");
		TokenStream.WriteInt(GeosetAnimation.Data().GeosetId);
		TokenStream.WriteLine(",");
	}

	while(TRUE)
	{
		if(GeosetAnimation.Data().Alpha.IsStatic())
		{
			if(GeosetAnimation.Data().Alpha.GetScalar() == 1.0f) break;
		}

		if(!GeosetAnimation.Data().Alpha.Save(TokenStream)) return FALSE;

		break;
	}

	while(TRUE)
	{
		if(!GeosetAnimation.Data().UseColor) break;

		if(GeosetAnimation.Data().Color.IsStatic())
		{
			if(GeosetAnimation.Data().Color.GetVector3() == D3DXVECTOR3(1.0f, 1.0f, 1.0f)) break;
		}

		if(!GeosetAnimation.Data().Color.Save(TokenStream)) return FALSE;

		break;
	}

	if(GeosetAnimation.Data().DropShadow)
	{
		TokenStream.WriteTab();
		TokenStream.WriteLine("DropShadow,");
	}

	TokenStream.WriteLine("}");

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves the model bones
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDL::SaveBones(MODEL& Model, TOKEN_OUT_STREAM& TokenStream)
{
	INT i;

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

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

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model bone
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDL::SaveBone(MODEL_BONE& Bone, TOKEN_OUT_STREAM& TokenStream)
{
	TokenStream.WriteWord("Bone ");
	TokenStream.WriteString(Bone.Data().Name);
	TokenStream.WriteLine(" {");

	if(!SaveBaseData(&Bone.Data(), TokenStream)) return FALSE;

	if(Bone.Data().GeosetId != INVALID_INDEX)
	{
		TokenStream.WriteTab();
		TokenStream.WriteWord("GeosetId ");
		TokenStream.WriteInt(Bone.Data().GeosetId);
		TokenStream.WriteLine(",");
	}
	else
	{
		TokenStream.WriteTab();
		TokenStream.WriteLine("GeosetId Multiple,");
	}

	if(Bone.Data().GeosetAnimationId != INVALID_INDEX)
	{
		TokenStream.WriteTab();
		TokenStream.WriteWord("GeosetAnimId ");
		TokenStream.WriteInt(Bone.Data().GeosetAnimationId);
		TokenStream.WriteLine(",");
	}
	else
	{
		TokenStream.WriteTab();
		TokenStream.WriteLine("GeosetAnimId None,");
	}

	TokenStream.WriteLine("}");

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves the model lights
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDL::SaveLights(MODEL& Model, TOKEN_OUT_STREAM& TokenStream)
{
	INT i;

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

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

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model light
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDL::SaveLight(MODEL_LIGHT& Light, TOKEN_OUT_STREAM& TokenStream)
{
	TokenStream.WriteWord("Light ");
	TokenStream.WriteString(Light.Data().Name);
	TokenStream.WriteLine(" {");

	if(!SaveBaseData(&Light.Data(), TokenStream)) return FALSE;

	switch(Light.Data().Type)
	{
		case 0:
		{
			TokenStream.WriteTab();
			TokenStream.WriteLine("Omnidirectional,");
			break;
		}

		case 1:
		{
			TokenStream.WriteTab();
			TokenStream.WriteLine("Directional,");
			break;
		}

		case 2:
		{
			TokenStream.WriteTab();
			TokenStream.WriteLine("Ambient,");
			break;
		}
	}

	if(!Light.Data().AttenuationStart.Save(TokenStream)) return FALSE;
	if(!Light.Data().AttenuationEnd.Save(TokenStream)) return FALSE;
	if(!Light.Data().Color.Save(TokenStream)) return FALSE;
	if(!Light.Data().Intensity.Save(TokenStream)) return FALSE;
	if(!Light.Data().AmbientColor.Save(TokenStream)) return FALSE;
	if(!Light.Data().AmbientIntensity.Save(TokenStream)) return FALSE;

	while(TRUE)
	{
		if(Light.Data().Visibility.IsStatic())
		{
			if(Light.Data().Visibility.GetScalar() == 1.0f) break;
		}

		if(!Light.Data().Visibility.Save(TokenStream)) return FALSE;

		break;
	}

	TokenStream.WriteLine("}");

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves the model helpers
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDL::SaveHelpers(MODEL& Model, TOKEN_OUT_STREAM& TokenStream)
{
	INT i;

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

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

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model helper
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDL::SaveHelper(MODEL_HELPER& Helper, TOKEN_OUT_STREAM& TokenStream)
{
	TokenStream.WriteWord("Helper ");
	TokenStream.WriteString(Helper.Data().Name);
	TokenStream.WriteLine(" {");

	if(!SaveBaseData(&Helper.Data(), TokenStream)) return FALSE;

	TokenStream.WriteLine("}");

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves the model attachments
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDL::SaveAttachments(MODEL& Model, TOKEN_OUT_STREAM& TokenStream)
{
	INT i;

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

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

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model attachment
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDL::SaveAttachment(MODEL_ATTACHMENT& Attachment, TOKEN_OUT_STREAM& TokenStream)
{
	TokenStream.WriteWord("Attachment ");
	TokenStream.WriteString(Attachment.Data().Name);
	TokenStream.WriteLine(" {");

	if(!SaveBaseData(&Attachment.Data(), TokenStream)) return FALSE;

	if(Attachment.Data().AttachmentId != INVALID_INDEX)
	{
		TokenStream.WriteTab();
		TokenStream.WriteWord("AttachmentID ");
		TokenStream.WriteInt(Attachment.Data().AttachmentId);
		TokenStream.WriteLine(",");
	}

	if(Attachment.Data().Path != "")
	{
		TokenStream.WriteTab();
		TokenStream.WriteWord("Path ");
		TokenStream.WriteString(Attachment.Data().Path);
		TokenStream.WriteLine(",");
	}

	while(TRUE)
	{
		if(Attachment.Data().Visibility.IsStatic())
		{
			if(Attachment.Data().Visibility.GetScalar() == 1.0f) break;
		}

		if(!Attachment.Data().Visibility.Save(TokenStream)) return FALSE;

		break;
	}

	TokenStream.WriteLine("}");

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves the model pivot points
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDL::SavePivotPoints(MODEL& Model, TOKEN_OUT_STREAM& TokenStream)
{
	INT i;

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

	TokenStream.WriteWord("PivotPoints ");
	TokenStream.WriteInt(Model.Data().PivotPointContainer.GetSize());
	TokenStream.WriteLine(" {");

	for(i = 0; i < Model.Data().PivotPointContainer.GetTotalSize(); i++)
	{
		if(Model.Data().PivotPointContainer.ValidIndex(i))
		{
			TokenStream.WriteTab();
			TokenStream.WriteVector3(*(Model.Data().PivotPointContainer[i]));
			TokenStream.WriteLine(",");
		}
	}

	TokenStream.WriteLine("}");

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves the model particle emitters
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDL::SaveParticleEmitters(MODEL& Model, TOKEN_OUT_STREAM& TokenStream)
{
	INT i;

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

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

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model particle emitter
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDL::SaveParticleEmitter(MODEL_PARTICLE_EMITTER& ParticleEmitter, TOKEN_OUT_STREAM& TokenStream)
{
	TokenStream.WriteWord("ParticleEmitter ");
	TokenStream.WriteString(ParticleEmitter.Data().Name);
	TokenStream.WriteLine(" {");

	if(!SaveBaseData(&ParticleEmitter.Data(), TokenStream)) return FALSE;

	if(ParticleEmitter.Data().EmitterUsesMdl)
	{
		TokenStream.WriteTab();
		TokenStream.WriteLine("EmitterUsesMDL,");
	}

	if(ParticleEmitter.Data().EmitterUsesTga)
	{
		TokenStream.WriteTab();
		TokenStream.WriteLine("EmitterUsesTGA,");
	}