/// <summary>
/// Constructs a new skinning data object.
/// </summary>
public InstancedSkinningData(ContentReader input)
{
this.texture = input.ReadObject<Texture2D>();
this.animations = input.ReadObject<IDictionary<string, InstancedAnimationClip>>();
Vector4[] data = new Vector4[this.texture.Width * this.texture.Height];
this.texture.GetData<Vector4>(data);
}
protected internal override SpriteFont Read(
ContentReader input,
SpriteFont existingInstance
)
{
if (existingInstance != null)
{
// Read the texture into the existing texture instance
input.ReadObject <Texture2D>(existingInstance.textureValue);
/* Discard the rest of the SpriteFont data as we are only
* reloading GPU resources for now
*/
input.ReadObject <List <Rectangle> >();
input.ReadObject <List <Rectangle> >();
input.ReadObject <List <char> >();
input.ReadInt32();
input.ReadSingle();
input.ReadObject <List <Vector3> >();
if (input.ReadBoolean())
{
input.ReadChar();
}
return(existingInstance);
}
else
{
// Create a fresh SpriteFont instance
Texture2D texture = input.ReadObject <Texture2D>();
List <Rectangle> glyphs = input.ReadObject <List <Rectangle> >();
List <Rectangle> cropping = input.ReadObject <List <Rectangle> >();
List <char> charMap = input.ReadObject <List <char> >();
int lineSpacing = input.ReadInt32();
float spacing = input.ReadSingle();
List <Vector3> kerning = input.ReadObject <List <Vector3> >();
char? defaultCharacter = null;
if (input.ReadBoolean())
{
defaultCharacter = new char?(input.ReadChar());
}
return(new SpriteFont(
texture,
glyphs,
cropping,
charMap,
lineSpacing,
spacing,
kerning,
defaultCharacter
));
}
}
protected internal override Dictionary <TKey, TValue> Read(ContentReader input, Dictionary <TKey, TValue> existingInstance)
{
int count = input.ReadInt32();
Dictionary <TKey, TValue> dictionary = existingInstance;
if (dictionary == null)
{
dictionary = new Dictionary <TKey, TValue>(count);
}
else
{
dictionary.Clear();
}
for (int i = 0; i < count; i++)
{
TKey key;
TValue value;
#if WINRT
if (keyType.GetTypeInfo().IsValueType)
#else
if (keyType.IsValueType)
#endif
{
key = input.ReadObject <TKey>(keyReader);
}
else
{
int readerType = input.ReadByte();
key = input.ReadObject <TKey>(input.TypeReaders[readerType - 1]);
}
#if WINRT
if (valueType.GetTypeInfo().IsValueType)
#else
if (valueType.IsValueType)
#endif
{
value = input.ReadObject <TValue>(valueReader);
}
else
{
int readerType = input.ReadByte();
value = input.ReadObject <TValue>(input.TypeReaders[readerType - 1]);
}
dictionary.Add(key, value);
}
return(dictionary);
}
private void ReadBones(ContentReader input)
{
ModelBone[] bones = new ModelBone[input.ReadInt32()];
for (int i = 0; i < bones.Length; i++)
{
string name = input.ReadObject<string>();
Matrix transform = input.ReadMatrix();
bones[i] = new ModelBone(i, name, transform);
}
this.bones = new ModelBoneCollection(bones);
foreach (ModelBone bone in bones)
{
ModelBone newParent = this.ReadBoneReference(input);
int size = input.ReadInt32();
ModelBone[] newChildren = new ModelBone[size];
for (int j = 0; j < size; j++)
{
newChildren[j] = this.ReadBoneReference(input);
}
bone.SetParentChildren(newParent, newChildren);
}
}
protected internal override EffectMaterial Read(ContentReader input, EffectMaterial existingInstance)
{
var effect = input.ReadExternalReference <Effect> ();
var effectMaterial = new EffectMaterial(effect);
var dict = input.ReadObject <Dictionary <string, object> > ();
foreach (KeyValuePair <string, object> item in dict)
{
var parameter = effectMaterial.Parameters [item.Key];
if (parameter != null)
{
if (typeof(Texture).IsAssignableFrom(item.Value.GetType()))
{
parameter.SetValue((Texture)item.Value);
}
else
{
throw new NotImplementedException();
}
}
else
{
#if DEBUG
Console.WriteLine("No parameter " + item.Key);
#endif
}
}
return(effectMaterial);
}
/// <summary>
/// Initializes a new instance of the Tower class.
/// </summary>
/// <param name="reader">The Content Reader for Castle XML Files</param>
public Tower(ContentReader reader)
{
id = reader.ReadInt32();
hasCannon = reader.ReadBoolean();
var position = reader.ReadObject<Vector2>();
x = (int)position.X;
y = (int)position.Y;
height = reader.ReadSingle();
corners = reader.ReadInt32();
radius = reader.ReadSingle();
coverRadius = reader.ReadSingle();
coverHeight = reader.ReadSingle();
viewDirection = new Vector3(x, coverHeight + 2, y + 1);
wallTexture = reader.ReadExternalReference<Texture2D>();
coverTexture = reader.ReadExternalReference<Texture2D>();
////InitTowerGraphics();
if (HasCannon)
{
hasCannon = true;
cannon = new Cannon(X, coverHeight, Y, null);
}
}
public InstancedSkinnedModel(ContentReader reader)
{
_model = reader.ReadObject<Model>();
_instancedSkinningData = new InstancedSkinningData(reader);
_graphicsDevice = ((IGraphicsDeviceService)reader.ContentManager.ServiceProvider.GetService(typeof(IGraphicsDeviceService))).GraphicsDevice;
}
public SkyBox(ContentReader input)
{
// Graphics Device-Instanz abrufen
this.GraphicsDevice = ((IGraphicsDeviceService)input.ContentManager.ServiceProvider.GetService(typeof(IGraphicsDeviceService))).GraphicsDevice;
// Vertices einlesen und Vertex Buffer initialisieren
VertexPositionTexture[] vertices = input.ReadObject<VertexPositionTexture[]>();
this.vertexBuffer = new VertexBuffer(this.GraphicsDevice, typeof(VertexPositionTexture), vertices.Length, BufferUsage.None);
this.vertexBuffer.SetData<VertexPositionTexture>(vertices);
// Anzahl der Vertices speichern
this.numVertices = vertices.Length;
// Division durch 3 ergibt die Anzahl der Primitive, da eine Dreiecksliste verwendet wird
this.numPrimitives = this.numPrimitives / 3;
// Vertex-Beschreibung erzeugen
this.vertexDeclaration = new VertexDeclaration(VertexPositionTexture.VertexDeclaration.GetVertexElements());
// BasicEffect-Instanz erzeugen
this.effect = new BasicEffect(this.GraphicsDevice);
// Texturen einlesen
this.frontTexture = input.ReadExternalReference<Texture2D>();
this.backTexture = input.ReadExternalReference<Texture2D>();
this.leftTexture = input.ReadExternalReference<Texture2D>();
this.rightTexture = input.ReadExternalReference<Texture2D>();
this.topTexture = input.ReadExternalReference<Texture2D>();
this.bottomTexture = input.ReadExternalReference<Texture2D>();
}
protected internal override Song Read(ContentReader input, Song existingInstance)
{
var path = input.ReadString();
if (!String.IsNullOrEmpty(path))
{
#if WINRT
const char notSeparator = '/';
const char separator = '\\';
#else
const char notSeparator = '\\';
var separator = Path.DirectorySeparatorChar;
#endif
path = path.Replace(notSeparator, separator);
// Get a uri for the asset path using the file:// schema and no host
var src = new Uri("file:///" + input.AssetName.Replace(notSeparator, separator));
// Add the relative path to the external reference
var dst = new Uri(src, path);
// The uri now contains the path to the external reference within the content manager
// Get the local path and skip the first character (the path separator)
path = dst.LocalPath.Substring(1);
// Adds the ContentManager's RootDirectory
path = Path.Combine(input.ContentManager.RootDirectoryFullPath, path);
}
var durationMs = input.ReadObject <int>();
return(new Song(path, durationMs));
}
protected virtual void ReloadAsset <T>(string originalAssetName, T currentAsset)
{
string assetName = originalAssetName;
if (string.IsNullOrEmpty(assetName))
{
throw new ArgumentNullException("assetName");
}
if (disposed)
{
throw new ObjectDisposedException("ContentManager");
}
if (this.graphicsDeviceService == null)
{
this.graphicsDeviceService = serviceProvider.GetService(typeof(IGraphicsDeviceService)) as IGraphicsDeviceService;
if (this.graphicsDeviceService == null)
{
throw new InvalidOperationException("No Graphics Device Service");
}
}
Stream stream = null;
try
{
// Try to load it traditionally
stream = OpenStream(assetName);
// Try to load as XNB file
try
{
using (BinaryReader xnbReader = new BinaryReader(stream))
{
using (ContentReader reader = GetContentReaderFromXnb(assetName, ref stream, xnbReader, null))
{
reader.InitializeTypeReaders();
reader.ReadObject <T>(currentAsset);
reader.ReadSharedResources();
}
}
}
finally
{
if (stream != null)
{
stream.Dispose();
}
}
}
catch (ContentLoadException)
{
// Try to reload as a non-xnb file.
assetName = FileHelpers.NormalizeFilePathSeparators(
Path.Combine(RootDirectoryFullPath, assetName)
);
assetName = Normalize <T>(assetName);
ReloadRawAsset(currentAsset, assetName, originalAssetName);
}
}
protected internal override Song Read(ContentReader input, Song existingInstance)
{
string path3 = input.ReadString();
string filename = TitleContainer.GetFilename(Path.Combine(input.ContentManager.RootDirectory, input.ContentManager.CurrentAssetDirectory, path3));
input.ReadObject <int>();
return(new Song(filename));
}
/// <summary>
/// Constructor reads instanced model data from our custom XNB format.
/// </summary>
internal InstancedModelPart( ContentReader input, GraphicsDevice graphicsDevice )
{
this.graphicsDevice = graphicsDevice;
// Load the model data.
indexCount = input.ReadInt32();
vertexCount = input.ReadInt32();
vertexStride = input.ReadInt32();
vertexDeclaration = input.ReadObject<VertexDeclaration>();
vertexBuffer = input.ReadObject<VertexBuffer>();
indexBuffer = input.ReadObject<IndexBuffer>();
input.ReadSharedResource<Effect>( delegate( Effect value )
{
effect = value;
// accessors
EffectParameterColor = effect.Parameters["Color"];
EffectParameterDiffuseMap = effect.Parameters["DiffuseMap"];
EffectParameterSpecularPower = effect.Parameters["SpecularPower"];
effectParameterView = effect.Parameters["View"];
effectParameterProjection = effect.Parameters["Projection"];
effectParameterEye = effect.Parameters["Eye"];
effectParameterVertexCount = effect.Parameters["VertexCount"];
effectParameterInstanceTransforms = effect.Parameters["InstanceTransforms"];
} );
// Work out how many shader instances we can fit into a single batch.
int indexOverflowLimit = ushort.MaxValue / vertexCount;
maxInstances = Math.Min( indexOverflowLimit, MaxShaderMatrices );
// On Xbox, we must replicate several copies of our index buffer data for
// the VFetch instancing technique. We could alternatively precompute this
// in the content processor, but that would bloat the size of the XNB file.
// It is more efficient to generate the repeated values at load time.
//
// We also require replicated index data for the Windows ShaderInstancing
// technique, but this is computed lazily on Windows, so as to avoid
// bloating the index buffer if it turns out that we only ever use the
// HardwareInstancingTechnique (which does not require any repeated data).
ReplicateIndexData();
}
protected internal override T?Read(ContentReader input, T?existingInstance)
{
if (input.ReadBoolean())
{
return(input.ReadObject <T>(elementReader));
}
return(null);
}
internal static SkinnedModel Read(ContentReader input)
{
SkinnedModel skinnedModel = new SkinnedModel();
skinnedModel.model = input.ReadObject<Model>();
skinnedModel.ReadBones(input);
skinnedModel.ReadAnimations(input);
return skinnedModel;
}
protected internal override List <T> Read(ContentReader input, List <T> existingInstance)
{
int capacity = input.ReadInt32();
List <T> list = existingInstance ?? new List <T>(capacity);
for (int index = 0; index < capacity; ++index)
{
if (typeof(T).IsValueType)
{
list.Add(input.ReadObject <T>(this.elementReader));
}
else
{
int num = (int)input.ReadByte();
list.Add(input.ReadObject <T>(input.TypeReaders[num - 1]));
}
}
return(list);
}
internal static Model Read(ContentReader input)
{
Model model = new Model();
model.ReadBones(input);
VertexDeclaration[] vertexDeclarations = ReadVertexDeclarations(input);
model.ReadMeshes(input, vertexDeclarations);
model.root = model.ReadBoneReference(input);
model.Tag = input.ReadObject<object>();
return model;
}
protected internal override Dictionary <TKey, TValue> Read(ContentReader input, Dictionary <TKey, TValue> existingInstance)
{
int count = input.ReadInt32();
Dictionary <TKey, TValue> dictionary = existingInstance;
if (dictionary == null)
{
dictionary = new Dictionary <TKey, TValue>(count);
}
else
{
dictionary.Clear();
}
for (int i = 0; i < count; i++)
{
TKey key;
TValue value;
if (ReflectionHelpers.IsValueType(keyType))
{
key = input.ReadObject <TKey>(keyReader);
}
else
{
var readerType = input.Read7BitEncodedInt();
key = readerType > 0 ? input.ReadObject <TKey>(input.TypeReaders[readerType - 1]) : default(TKey);
}
if (ReflectionHelpers.IsValueType(valueType))
{
value = input.ReadObject <TValue>(valueReader);
}
else
{
var readerType = input.Read7BitEncodedInt();
value = readerType > 0 ? input.ReadObject <TValue>(input.TypeReaders[readerType - 1]) : default(TValue);
}
dictionary.Add(key, value);
}
return(dictionary);
}
protected internal override SpriteFont Read(ContentReader input, SpriteFont existingInstance)
{
Texture2D texture = input.ReadObject <Texture2D>();
texture.IsSpriteFontTexture = true;
List <Rectangle> glyphs = input.ReadObject <List <Rectangle> >();
List <Rectangle> cropping = input.ReadObject <List <Rectangle> >();
List <char> charMap = input.ReadObject <List <char> >();
int lineSpacing = input.ReadInt32();
float spacing = input.ReadSingle();
List <Vector3> kerning = input.ReadObject <List <Vector3> >();
char? defaultCharacter = null;
if (input.ReadBoolean())
{
defaultCharacter = new char?(input.ReadChar());
}
return(new SpriteFont(texture, glyphs, cropping, charMap, lineSpacing, spacing, kerning, defaultCharacter));
}
internal static AnimationClip Read(ContentReader input)
{
string animationName = input.ReadString();
TimeSpan animationDuration = input.ReadObject<TimeSpan>();
// Read animation clip channels
Dictionary<string, AnimationChannel> animationChannelDictionary =
new Dictionary<string, AnimationChannel>();
int numAnimationChannels = input.ReadInt32();
for (int i = 0; i < numAnimationChannels; i++)
{
string channelName = input.ReadString();
// Read animation channel keyframes
int numChannelKeyframes = input.ReadInt32();
List<AnimationChannelKeyframe> keyframeList =
new List<AnimationChannelKeyframe>(numChannelKeyframes);
for (int j = 0; j < numChannelKeyframes; j++)
{
TimeSpan keyframeTime = input.ReadObject<TimeSpan>();
// Read keyframe pose
Pose keyframePose;
keyframePose.Translation = input.ReadVector3();
keyframePose.Orientation = input.ReadQuaternion();
keyframePose.Scale = input.ReadVector3();
keyframeList.Add(new AnimationChannelKeyframe(keyframeTime, keyframePose));
}
AnimationChannel animationChannel = new AnimationChannel(keyframeList);
// Add the animation channel to the dictionary
animationChannelDictionary.Add(channelName, animationChannel);
}
return
new AnimationClip(animationName, animationDuration,
new AnimationChannelDictionary(animationChannelDictionary));
}
protected internal override T?Read(ContentReader input, T?existingInstance)
{
if (input.ReadBoolean())
{
return(new T?(input.ReadObject <T>(this.elementReader)));
}
else
{
return(new T?());
}
}
protected internal override Song Read(ContentReader input, Song existingInstance)
{
string path = input.ReadString();
// Songs don't have the full directory path in their .xnb. Build it.
path = Path.Combine(input.ContentManager.RootDirectory, input.ContentManager.CurrentAssetDirectory, path);
path = TitleContainer.GetFilename(path);
/*int durationMS =*/ input.ReadObject <int>();
return(new Song(path));
}
protected internal override Video Read(ContentReader input, Video existingInstance)
{
string path = input.ReadObject <string>();
if (!string.IsNullOrEmpty(path))
{
// Add the ContentManager's RootDirectory
var dirPath = Path.Combine(input.ContentManager.RootDirectoryFullPath, input.AssetName);
// Resolve the relative path
path = FileHelpers.ResolveRelativePath(dirPath, path);
}
var durationMS = input.ReadObject <int>();
var width = input.ReadObject <int>();
var height = input.ReadObject <int>();
var framesPerSecond = input.ReadObject <float>();
var soundTrackType = input.ReadObject <int>(); // 0 = Music, 1 = Dialog, 2 = Music and dialog
return(new Video(path, durationMS)
{
Width = width,
Height = height,
FramesPerSecond = framesPerSecond,
VideoSoundtrackType = (VideoSoundtrackType)soundTrackType
});
}
protected internal override Video Read(
ContentReader input,
Video existingInstance
)
{
string path = FileHelpers.ResolveRelativePath(
Path.Combine(
input.ContentManager.RootDirectoryFullPath,
input.AssetName
),
input.ReadObject <string>()
);
/* The path string includes the ".wmv" extension. Let's see if this
* file exists in a format we actually support...
*/
path = Normalize(path.Substring(0, path.Length - 4));
if (String.IsNullOrEmpty(path))
{
throw new ContentLoadException();
}
int durationMS = input.ReadObject <int>();
int width = input.ReadObject <int>();
int height = input.ReadObject <int>();
float framesPerSecond = input.ReadObject <float>();
VideoSoundtrackType soundTrackType = (VideoSoundtrackType)input.ReadObject <int>();
return(new Video(path, durationMS, width, height, framesPerSecond, soundTrackType));
}
/// <summary>
/// Initializes a new instance of the <see cref="Castle"/> class.
/// </summary>
/// <param name="reader">The castle content reader</param>
public Castle(ContentReader reader)
{
this.id = 0;
if (reader == null)
{
throw new ArgumentNullException("reader");
}
this.name = reader.ReadString();
this.price = reader.ReadInt32();
var tempTowers = reader.ReadObject<Tower[]>();
var sumX = 0.0f;
var sumZ = 0.0f;
this.towers = new Collection<Tower>();
foreach (Tower t in tempTowers)
{
sumX += t.X;
sumZ += t.Y;
this.towers.Add(t);
}
this.walls = new List<Wall>();
var tempWalls = reader.ReadObject<Wall[]>();
foreach (var w in tempWalls)
{
w.SetFromToVectors(
new Vector3(this.towers[w.FromIndex].X, 0.0f, this.towers[w.FromIndex].Y),
new Vector3(this.towers[w.ToIndex].X, 0.0f, this.towers[w.ToIndex].Y));
this.walls.Add(w);
}
this.center = new Vector3(sumX / this.towers.Count, 0.0f, sumZ / this.towers.Count);
this.currentTower = 0;
}
protected internal override T[] Read(ContentReader input, T[] existingInstance)
{
uint num1 = input.ReadUInt32();
T[] objArray = existingInstance ?? new T[(IntPtr)num1];
if (typeof(T).IsValueType)
{
for (uint index = 0U; index < num1; ++index)
{
objArray[(IntPtr)index] = input.ReadObject <T>(this.elementReader);
}
}
else
{
for (uint index = 0U; index < num1; ++index)
{
int num2 = input.Read7BitEncodedInt();
objArray[(IntPtr)index] = num2 > 0 ? input.ReadObject <T>(input.TypeReaders[num2 - 1]) : default(T);
}
}
return(objArray);
}
public InstancedSkinnedModel(ContentReader reader)
{
this.model = reader.ReadObject<Model>();
this.instancedSkinningData = new InstancedSkinningData(reader);
GraphicsDevice device = ((IGraphicsDeviceService)reader.ContentManager.ServiceProvider.GetService(typeof(IGraphicsDeviceService))).GraphicsDevice;
// Create InstancedSkinnedModelMeshes from the ModelMeshes
foreach (ModelMesh mesh in this.model.Meshes)
{
meshes.Add(new InstancedSkinnedModelMesh(mesh, this.instancedSkinningData.AnimationTexture, device));
}
}
internal InstancedModel( ContentReader input )
{
graphicsDevice = RenderHelper.GetGraphicsDevice( input );
int partCount = input.ReadInt32();
for ( int i = 0; i < partCount; i++ )
{
modelParts.Add( new InstancedModelPart( this, input, graphicsDevice ) );
}
Tag = input.ReadObject<object>();
}
protected internal override List <T> Read(ContentReader input, List <T> existingInstance)
{
int count = input.ReadInt32();
List <T> list = existingInstance;
if (list == null)
{
list = new List <T>(count);
}
for (int i = 0; i < count; i++)
{
if (ReflectionHelpers.IsValueType(typeof(T)))
{
list.Add(input.ReadObject <T>(elementReader));
}
else
{
var readerType = input.Read7BitEncodedInt();
list.Add(readerType > 0 ? input.ReadObject <T>(input.TypeReaders[readerType - 1]) : default(T));
}
}
return(list);
}
private T ReadAsset <T>(string assetName, System.IO.Stream assetStream,
Action <IDisposable> recordDisposableObject)
{
// GG EDIT removed code for loading raw assets like pngs
// Load a XNB file
ContentReader reader = new ContentReader(this, assetStream, this.graphicsDeviceService.GraphicsDevice);
ContentTypeReaderManager typeManager = new ContentTypeReaderManager(reader);
reader.TypeReaders = typeManager.LoadAssetReaders(reader);
foreach (ContentTypeReader r in reader.TypeReaders)
{
r.Initialize(typeManager);
}
// we need to read a byte here for things to work out, not sure why
byte dummy = reader.ReadByte();
System.Diagnostics.Debug.Assert(dummy == 0);
// Get the 1-based index of the typereader we should use to start decoding with
int index = reader.ReadByte();
ContentTypeReader contentReader = reader.TypeReaders[index - 1];
object result = reader.ReadObject <T>(contentReader);
reader.Close();
assetStream.Close();
if (result == null)
{
throw new ContentLoadException("Could not load " + assetName + " asset!");
}
// GG EDIT added IDisposable recording
T tresult = (T)result;
if (tresult is IDisposable)
{
if (recordDisposableObject == null)
{
// GG TODO: would call local method here
}
else
{
recordDisposableObject((IDisposable)tresult);
}
}
return(tresult);
}
protected virtual void ReloadAsset <T>(string originalAssetName, T currentAsset)
{
string str = originalAssetName;
if (string.IsNullOrEmpty(str))
{
throw new ArgumentNullException("assetName");
}
if (this.disposed)
{
throw new ObjectDisposedException("ContentManager");
}
if (this.graphicsDeviceService == null)
{
this.graphicsDeviceService = this.serviceProvider.GetService(typeof(IGraphicsDeviceService)) as IGraphicsDeviceService;
if (this.graphicsDeviceService == null)
{
throw new InvalidOperationException("No Graphics Device Service");
}
}
try
{
Stream stream = this.OpenStream(str);
try
{
using (BinaryReader xnbReader = new BinaryReader(stream))
{
using (ContentReader contentReaderFromXnb = this.GetContentReaderFromXnb(str, ref stream, xnbReader, (Action <IDisposable>)null))
{
contentReaderFromXnb.InitializeTypeReaders();
contentReaderFromXnb.ReadObject <T>(currentAsset);
contentReaderFromXnb.ReadSharedResources();
}
}
}
finally
{
if (stream != null)
{
stream.Dispose();
}
}
}
catch (ContentLoadException ex)
{
string assetName = this.Normalize <T>(TitleContainer.GetFilename(Path.Combine(this.RootDirectory, str)));
this.ReloadRawAsset <T>(currentAsset, assetName, originalAssetName);
}
}
protected internal override Song Read(ContentReader input, Song existingInstance)
{
string fileName = input.ReadString();
if (!string.IsNullOrEmpty(fileName))
{
char newChar = Path.DirectorySeparatorChar;
string relativeUri = fileName.Replace('\\', newChar);
string path2 = new Uri(new Uri("file:///" + input.AssetName.Replace('\\', newChar)), relativeUri).LocalPath.Substring(1);
fileName = Path.Combine(input.ContentManager.RootDirectoryFullPath, path2);
}
int durationMS = input.ReadObject <int>();
return(new Song(fileName, durationMS));
}
internal InstancedModelPart( InstancedModel owner, ContentReader input,
GraphicsDevice graphicsDevice)
{
this.owner = owner;
indexCount = input.ReadInt32();
vertexCount = input.ReadInt32();
vertexStride = input.ReadInt32();
vertexDeclaration = input.ReadObject<VertexDeclaration>();
vertexBuffer = input.ReadObject<VertexBuffer>();
indexBuffer = input.ReadObject<IndexBuffer>();
input.ReadSharedResource<Effect>( delegate( Effect value )
{
Effect = value;
effectVertexCountParam = Effect.Parameters["VertexCount"];
effectViewParam = Effect.Parameters["View"];
effectProjectionParam = Effect.Parameters["Projection"];
effectEyeParam = Effect.Parameters["EyePosition"];
} );
originalVertexDeclaration = vertexDeclaration.GetVertexElements();
}
protected internal override T[] Read(ContentReader input, T[] existingInstance)
{
int count = input.ReadInt32();
T[] array = existingInstance;
if (array == null)
{
array = new T[count];
}
for (int i = 0; i < count; i++)
{
Type objectType = typeof(T);
if (objectType.IsValueType)
{
array[i] = input.ReadObject <T>(elementReader);
}
else
{
int readerType = input.ReadByte();
array[i] = input.ReadObject <T>(input.TypeReaders[readerType - 1]);
}
}
return(array);
}
protected internal override T[] Read(ContentReader input, T[] existingInstance)
{
uint count = input.ReadUInt32();
T[] array = existingInstance;
if (array == null)
{
array = new T[count];
}
if (typeof(T).IsValueType)
{
for (uint i = 0; i < count; i += 1)
{
array[i] = input.ReadObject <T>(elementReader);
}
}
else
{
for (uint i = 0; i < count; i += 1)
{
int readerType = input.Read7BitEncodedInt();
if (readerType > 0)
{
array[i] = input.ReadObject <T>(
input.TypeReaders[readerType - 1]
);
}
else
{
array[i] = default(T);
}
}
}
return(array);
}
protected internal override Song Read(ContentReader input, Song existingInstance)
{
var path = input.ReadString();
if (!String.IsNullOrEmpty(path))
{
// Add the ContentManager's RootDirectory
var dirPath = Path.Combine(input.ContentManager.RootDirectoryFullPath, input.AssetName);
// Resolve the relative path
path = FileHelpers.ResolveRelativePath(dirPath, path);
}
var durationMs = input.ReadObject <int>();
return(new Song(path, durationMs));
}
protected internal override EffectMaterial Read(ContentReader input, EffectMaterial existingInstance)
{
EffectMaterial effectMaterial = new EffectMaterial(input.ReadExternalReference <Effect>());
foreach (KeyValuePair <string, object> keyValuePair in input.ReadObject <Dictionary <string, object> >())
{
EffectParameter effectParameter = effectMaterial.Parameters[keyValuePair.Key];
if (effectParameter != null)
{
if (!typeof(Texture).IsAssignableFrom(keyValuePair.Value.GetType()))
{
throw new NotImplementedException();
}
effectParameter.SetValue((Texture)keyValuePair.Value);
}
}
return(effectMaterial);
}
protected internal override Video Read(ContentReader input, Video existingInstance)
{
string path = input.ReadObject <string>();
path = Path.Combine(input.ContentManager.RootDirectory, path);
path = TitleContainer.GetFilename(path);
/*int durationMS =*/ input.ReadObject <int>();
/*int width =*/ input.ReadObject <int>();
/*int height =*/ input.ReadObject <int>();
/*float framesPerSecond =*/ input.ReadObject <Single>();
/*int soundTrackType =*/ input.ReadObject <int>(); // 0 = Music, 1 = Dialog, 2 = Music and dialog
return(new Video(path));
}
protected internal override Song Read(ContentReader input, Song existingInstance)
{
string path = input.ReadString();
path = Path.Combine(input.ContentManager.RootDirectory, path);
path = TitleContainer.GetFilename(path);
/* The path string includes the ".wma" extension. Let's see if this
* file exists in a format we actually support...
*/
path = Normalize(Path.GetFileNameWithoutExtension(path));
if (String.IsNullOrEmpty(path))
{
throw new ContentLoadException();
}
int durationMs = input.ReadObject <int>();
return(new Song(path, durationMs));
}
protected internal override EffectMaterial Read(ContentReader input, EffectMaterial existingInstance)
{
var effect = input.ReadExternalReference <Effect> ();
var effectMaterial = new EffectMaterial(effect);
var dict = input.ReadObject <Dictionary <string, object> > ();
foreach (KeyValuePair <string, object> item in dict)
{
var parameter = effectMaterial.Parameters [item.Key];
if (parameter != null)
{
Type itemType = item.Value.GetType();
if (ReflectionHelpers.IsAssignableFromType(typeof(Texture), itemType))
{
parameter.SetValue((Texture)item.Value);
}
else if (ReflectionHelpers.IsAssignableFromType(typeof(int), itemType))
{
parameter.SetValue((int)item.Value);
}
else if (ReflectionHelpers.IsAssignableFromType(typeof(bool), itemType))
{
parameter.SetValue((bool)item.Value);
}
else if (ReflectionHelpers.IsAssignableFromType(typeof(float), itemType))
{
parameter.SetValue((float)item.Value);
}
else if (ReflectionHelpers.IsAssignableFromType(typeof(float []), itemType))
{
parameter.SetValue((float[])item.Value);
}
else if (ReflectionHelpers.IsAssignableFromType(typeof(Vector2), itemType))
{
parameter.SetValue((Vector2)item.Value);
}
else if (ReflectionHelpers.IsAssignableFromType(typeof(Vector2 []), itemType))
{
parameter.SetValue((Vector2 [])item.Value);
}
else if (ReflectionHelpers.IsAssignableFromType(typeof(Vector3), itemType))
{
parameter.SetValue((Vector3)item.Value);
}
else if (ReflectionHelpers.IsAssignableFromType(typeof(Vector3 []), itemType))
{
parameter.SetValue((Vector3 [])item.Value);
}
else if (ReflectionHelpers.IsAssignableFromType(typeof(Vector4), itemType))
{
parameter.SetValue((Vector4)item.Value);
}
else if (ReflectionHelpers.IsAssignableFromType(typeof(Vector4 []), itemType))
{
parameter.SetValue((Vector4 [])item.Value);
}
else if (ReflectionHelpers.IsAssignableFromType(typeof(Matrix), itemType))
{
parameter.SetValue((Matrix)item.Value);
}
else if (ReflectionHelpers.IsAssignableFromType(typeof(Matrix []), itemType))
{
parameter.SetValue((Matrix[])item.Value);
}
else if (ReflectionHelpers.IsAssignableFromType(typeof(Quaternion), itemType))
{
parameter.SetValue((Quaternion)item.Value);
}
else
{
throw new NotSupportedException("Parameter type is not supported");
}
}
else
{
Debug.WriteLine("No parameter " + item.Key);
}
}
return(effectMaterial);
}
internal static SkinnedModelBasicEffect Read(ContentReader input)
{
IGraphicsDeviceService graphicsDeviceService = (IGraphicsDeviceService)
input.ContentManager.ServiceProvider.GetService(typeof(IGraphicsDeviceService));
GraphicsDevice graphicsDevice = graphicsDeviceService.GraphicsDevice;
SkinnedModelBasicEffect basicEffect = new SkinnedModelBasicEffect(graphicsDevice,
(EffectPool)null);
basicEffect.material.EmissiveColor = input.ReadVector3();
basicEffect.material.DiffuseColor = input.ReadVector3();
basicEffect.material.SpecularColor = input.ReadVector3();
basicEffect.material.SpecularPower = input.ReadSingle();
basicEffect.DiffuseMapEnabled = input.ReadBoolean();
basicEffect.NormalMapEnabled = input.ReadBoolean();
basicEffect.SpecularMapEnabled = input.ReadBoolean();
basicEffect.DiffuseMap = input.ReadObject<Texture2D>(); ;
basicEffect.NormalMap = input.ReadObject<Texture2D>(); ;
basicEffect.SpecularMap = input.ReadObject<Texture2D>(); ;
basicEffect.lightEnabled = false;
basicEffect.enabledLights = EnabledLights.One;
return basicEffect;
}
public T Load <T>(string assetName)
{
string originalAssetName = assetName;
object result = null;
if (this.graphicsDeviceService == null)
{
this.graphicsDeviceService = serviceProvider.GetService(typeof(IGraphicsDeviceService)) as IGraphicsDeviceService;
if (this.graphicsDeviceService == null)
{
throw new InvalidOperationException("No Graphics Device Service");
}
}
if (string.IsNullOrEmpty(assetName))
{
throw new ArgumentException("assetname");
}
if (!string.IsNullOrEmpty(_rootDirectory))
{
assetName = _rootDirectory + Path.DirectorySeparatorChar + assetName;
}
// Check for windows-style directory separator character
assetName = assetName.Replace('\\', Path.DirectorySeparatorChar);
// Get the real file name
if ((typeof(T) == typeof(Texture2D)))
{
assetName = Texture2DReader.Normalize(assetName);
}
if ((typeof(T) == typeof(SpriteFont)))
{
assetName = SpriteFontReader.Normalize(assetName);
}
if ((typeof(T) == typeof(Song)))
{
assetName = SongReader.Normalize(assetName);
}
if ((typeof(T) == typeof(SoundEffect)))
{
assetName = SoundEffectReader.Normalize(assetName);
}
if ((typeof(T) == typeof(Video)))
{
assetName = Video.Normalize(assetName);
}
if ((typeof(T) == typeof(Effect)))
{
assetName = Effect.Normalize(assetName);
}
if (string.IsNullOrEmpty(assetName))
{
throw new ContentLoadException("Could not load " + originalAssetName + " asset!");
}
if (Path.GetExtension(assetName).ToUpper() != ".XNB")
{
if ((typeof(T) == typeof(Texture2D)))
{
result = Texture2D.FromFile(graphicsDeviceService.GraphicsDevice, assetName);
}
if ((typeof(T) == typeof(SpriteFont)))
{
//result = new SpriteFont(Texture2D.FromFile(graphicsDeviceService.GraphicsDevice,assetName), null, null, null, 0, 0.0f, null, null);
throw new NotImplementedException();
}
if ((typeof(T) == typeof(Song)))
{
result = new Song(assetName);
}
if ((typeof(T) == typeof(SoundEffect)))
{
result = new SoundEffect(assetName);
}
if ((typeof(T) == typeof(Video)))
{
result = new Video(assetName);
}
}
else
{
// Load a XNB file
FileStream stream = new FileStream(assetName, FileMode.Open, FileAccess.Read, FileShare.Read);
ContentReader reader = new ContentReader(this, stream, this.graphicsDeviceService.GraphicsDevice);
ContentTypeReaderManager typeManager = new ContentTypeReaderManager(reader);
reader.TypeReaders = typeManager.LoadAssetReaders(reader);
foreach (ContentTypeReader r in reader.TypeReaders)
{
r.Initialize(typeManager);
}
// we need to read a byte here for things to work out, not sure why
reader.ReadByte();
// Get the 1-based index of the typereader we should use to start decoding with
int index = reader.ReadByte();
ContentTypeReader contentReader = reader.TypeReaders[index - 1];
result = reader.ReadObject <T>(contentReader);
reader.Close();
stream.Close();
}
if (result == null)
{
throw new ContentLoadException("Could not load " + originalAssetName + " asset!");
}
return((T)result);
}
internal static SkinnedEffect Read(ContentReader input)
{
IGraphicsDeviceService graphicsDeviceService = (IGraphicsDeviceService)
input.ContentManager.ServiceProvider.GetService(typeof(IGraphicsDeviceService));
GraphicsDevice graphicsDevice = graphicsDeviceService.GraphicsDevice;
SkinnedEffect basicEffect = new SkinnedEffect(graphicsDevice);
input.ReadVector3();
input.ReadVector3();
input.ReadVector3();
input.ReadSingle();
input.ReadBoolean();
input.ReadBoolean();
input.ReadBoolean();
input.ReadObject<Texture2D>();
input.ReadObject<Texture2D>();
input.ReadObject<Texture2D>();
return basicEffect;
}
private void Read(object parent, ContentReader input, MemberInfo member)
{
PropertyInfo property = member as PropertyInfo;
FieldInfo field = member as FieldInfo;
if (property != (PropertyInfo)null && (!property.CanWrite || !property.CanRead))
{
return;
}
if (property != (PropertyInfo)null && property.Name == "Item")
{
MethodInfo getMethod = property.GetGetMethod();
MethodInfo setMethod = property.GetSetMethod();
if (getMethod != (MethodInfo)null && getMethod.GetParameters().Length > 0 || setMethod != (MethodInfo)null && setMethod.GetParameters().Length > 0)
{
return;
}
}
if (Attribute.GetCustomAttribute(member, typeof(ContentSerializerIgnoreAttribute)) != null)
{
return;
}
Attribute customAttribute = Attribute.GetCustomAttribute(member, typeof(ContentSerializerAttribute));
bool flag = false;
if (customAttribute != null)
{
flag = (customAttribute as ContentSerializerAttribute).SharedResource;
}
else if (property != (PropertyInfo)null)
{
foreach (MethodBase methodBase in property.GetAccessors(true))
{
if (!methodBase.IsPublic)
{
return;
}
}
}
else if (!field.IsPublic)
{
return;
}
Type type;
ContentTypeReader typeReader = !(property != (PropertyInfo)null) ? this.manager.GetTypeReader(type = field.FieldType) : this.manager.GetTypeReader(type = property.PropertyType);
if (!flag)
{
object childObject = ReflectiveReader <T> .CreateChildObject(property, field);
object obj = typeReader != null || !(type == typeof(object)) ? input.ReadObject <object>(typeReader, childObject) : input.ReadObject <object>();
if (property != (PropertyInfo)null)
{
property.SetValue(parent, obj, (object[])null);
}
else
{
if (field.IsPrivate && customAttribute == null)
{
return;
}
field.SetValue(parent, obj);
}
}
else
{
Action <object> fixup = (Action <object>)(value =>
{
if (property != (PropertyInfo)null)
{
property.SetValue(parent, value, (object[])null);
}
else
{
field.SetValue(parent, value);
}
});
input.ReadSharedResource <object>(fixup);
}
}
private static VertexDeclaration[] ReadVertexDeclarations(ContentReader input)
{
int length = input.ReadInt32();
VertexDeclaration[] declarationArray = new VertexDeclaration[length];
for (int i = 0; i < length; i++)
{
declarationArray[i] = input.ReadObject<VertexDeclaration>();
}
return declarationArray;
}
internal Map(ContentReader reader)
{
// read in the basic map information
Version = new Version(reader.ReadString());
Orientation = (Orientation)reader.ReadByte();
Width = reader.ReadInt32();
Height = reader.ReadInt32();
TileWidth = reader.ReadInt32();
TileHeight = reader.ReadInt32();
Properties = new PropertyCollection();
Properties.Read(reader);
// create a list for our tiles
List<Tile> tiles = new List<Tile>();
Tiles = new Collection<Tile>(tiles);
// read in each tile set
int numTileSets = reader.ReadInt32();
for (int i = 0; i < numTileSets; i++)
{
// get the id and texture
int firstId = reader.ReadInt32();
string tilesetName = reader.ReadString();
bool collisionSet = reader.ReadBoolean();
Texture2D texture = reader.ReadExternalReference<Texture2D>();
// read in each individual tile
int numTiles = reader.ReadInt32();
for (int j = 0; j < numTiles; j++)
{
int id = firstId + j;
// Read the source rectangle from the file.
Rectangle source = reader.ReadObject<Rectangle>();
PropertyCollection props = new PropertyCollection();
props.Read(reader);
// Read in color data for collision purposes
// You'll probably want to limit this to just the tilesets that are used for collision
// I'm checking for the name of my tileset that contains wall tiles
// Color data takes up a fair bit of RAM
Color[] collisionData = null;
bool[] collisionBitData = null;
if (collisionSet)
{
int numOfBytes = TileWidth * TileHeight;
collisionData = new Color[numOfBytes];
collisionBitData = new bool[numOfBytes];
texture.GetData<Color>(
0,
source,
collisionData,
0,
numOfBytes
);
for (int col = 0; col < numOfBytes; col++)
{
if (collisionData[col].A > 0)
{
collisionBitData[col] = true;
}
}
collisionData = null;
}
Tile t = new Tile(texture, source, props, collisionBitData);
while (id >= tiles.Count)
{
tiles.Add(null);
}
tiles.Insert(id, t);
}
}
// read in all the layers
List<Layer> layers = new List<Layer>();
Layers = new Collection<Layer>(layers);
int numLayers = reader.ReadInt32();
for (int i = 0; i < numLayers; i++)
{
Layer layer = null;
// read generic layer data
string type = reader.ReadString();
string name = reader.ReadString();
int width = reader.ReadInt32();
int height = reader.ReadInt32();
bool visible = reader.ReadBoolean();
float opacity = reader.ReadSingle();
PropertyCollection props = new PropertyCollection();
props.Read(reader);
// using the type, figure out which object to create
if (type == "layer")
{
int[] data = reader.ReadObject<int[]>();
layer = new TileLayer(name, width, height, visible, opacity, props, this, data);
}
else if (type == "objectgroup")
{
List<MapObject> objects = new List<MapObject>();
// read in all of our objects
int numObjects = reader.ReadInt32();
for (int j = 0; j < numObjects; j++)
{
string objName = reader.ReadString();
string objType = reader.ReadString();
Rectangle objLoc = reader.ReadObject<Rectangle>();
List<Point> objPoints = reader.ReadObject<List<Point>>();
PropertyCollection objProps = new PropertyCollection();
objProps.Read(reader);
objects.Add(new MapObject(objName, objType, objLoc, objPoints, objProps));
}
layer = new MapObjectLayer(name, width, height, visible, opacity, props, objects);
}
else
{
throw new Exception("Invalid type: " + type);
}
layers.Add(layer);
namedLayers.Add(name, layer);
}
}
private void loadMD3Data(ContentReader input, MD3Object m)
{
//load meshes
m.meshes = new List<MD3SubMeshes>();
int part = input.ReadInt32();
if (part == 0)
m.part = TMD3Part.HEAD;
else if (part == 1)
m.part = TMD3Part.LOWER;
else
m.part = TMD3Part.UPPER;
m.num_frames = input.ReadInt32();
int sub_meshes_count = input.ReadInt32();
for (int i = 0; i < sub_meshes_count; ++i)
{
MD3SubMeshes sub_mesh = new MD3SubMeshes();
sub_mesh.indices = new List<int>();
sub_mesh.vertices = new List<Vector3>();
sub_mesh.normals = new List<Vector3>();
sub_mesh.text_coord = new List<Vector2>();
sub_mesh.skins = new List<string>();
sub_mesh.meshinfo.strName = input.ReadString();
input.ReadObject<List<int>>(sub_mesh.indices);
input.ReadObject<List<Vector3>>(sub_mesh.vertices);
input.ReadObject<List<Vector3>>(sub_mesh.normals);
input.ReadObject<List<Vector2>>(sub_mesh.text_coord);
m.meshes.Add(sub_mesh);
}
//load tags
m.tags = new List<MD3tag>();
int tags_count = input.ReadInt32();
for (int i = 0; i < tags_count; ++i)
{
MD3tag tag = new MD3tag();
tag.strName = input.ReadString();
tag.vPosition = input.ReadVector3();
tag.rotation = input.ReadMatrix();
m.tags.Add(tag);
}
//load bounding_boxes
m.bounding_boxes = new List<BoundingBox>();
int bb_count = input.ReadInt32();
for (int i = 0; i < bb_count; ++i)
{
BoundingBox bb = new BoundingBox();
bb.Min = input.ReadVector3();
bb.Max = input.ReadVector3();
m.bounding_boxes.Add(bb);
}
}
internal static SkinnedModelBasicEffect Read(ContentReader input)
{
IGraphicsDeviceService graphicsDeviceService = (IGraphicsDeviceService)
input.ContentManager.ServiceProvider.GetService(typeof(IGraphicsDeviceService));
GraphicsDevice graphicsDevice = graphicsDeviceService.GraphicsDevice;
//ResourceContentManager cnt = new ResourceContentManager(input.ContentManager.ServiceProvider, Resource1.ResourceManager); z
#if WINDOWS
SkinnedModelBasicEffect basicEffect = new SkinnedModelBasicEffect(graphicsDevice, Resource1.SkinnedModelEffect);
#else
SkinnedModelBasicEffect basicEffect = new SkinnedModelBasicEffect(graphicsDevice, Resource1.SkinnedModelEffect2);
#endif
input.ReadVector3();
input.ReadVector3();
input.ReadVector3();
input.ReadSingle();
basicEffect.DiffuseMapEnabled = input.ReadBoolean();
basicEffect.NormalMapEnabled = input.ReadBoolean();
basicEffect.SpecularMapEnabled = input.ReadBoolean();
basicEffect.DiffuseMap = input.ReadObject<Texture2D>(); ;
basicEffect.NormalMap = input.ReadObject<Texture2D>(); ;
basicEffect.SpecularMap = input.ReadObject<Texture2D>(); ;
return basicEffect;
}
/// <summary>
/// The constructor reads model data from our custom XNB format.
/// This is called by the CustomModelReader class, which is invoked
/// whenever you ask the ContentManager to read a CustomModel object.
/// </summary>
internal CustomModel( ContentReader input )
{
int partCount = input.ReadInt32();
for ( int i = 0; i < partCount; i++ )
{
ModelPart modelPart = new ModelPart();
// Simple data types like integers can be read directly.
modelPart.TriangleCount = input.ReadInt32();
modelPart.VertexCount = input.ReadInt32();
modelPart.VertexStride = input.ReadInt32();
// These XNA Framework types can be read using the ReadObject method,
// which calls into the appropriate ContentTypeReader for each type.
// The framework provides built-in ContentTypeReader implementations
// for important types such as vertex declarations, vertex buffers,
// index buffers, effects, and textures.
modelPart.VertexDeclaration = input.ReadObject<VertexDeclaration>();
modelPart.VertexBuffer = input.ReadObject<VertexBuffer>();
modelPart.IndexBuffer = input.ReadObject<IndexBuffer>();
// Shared resources have to be read in a special way. Because the same
// object can be referenced from many different parts of the file, the
// actual object data is stored at the end of the XNB binary. When we
// call ReadSharedResource we are just reading an ID that will later be
// used to locate the actual data, so ReadSharedResource is unable to
// directly return the shared instance. Instead, it takes in a delegate
// parameter, and will call us back as soon as the shared value becomes
// available. We use C# anonymous delegate syntax to store the value
// into its final location.
input.ReadSharedResource<Effect>( delegate( Effect effect )
{
//Effect effect = value.Clone( value.GraphicsDevice );
if ( effect.Parameters["DiffuseMap"].GetValueTexture2D() != null )
{
if ( effect.Parameters["NormalMap"].GetValueTexture2D() != null )
{
effect.CurrentTechnique = effect.Techniques["NormalDiffuseColor"];
modelPart.VertexDeclaration = new VertexDeclaration( effect.GraphicsDevice,
VertexPositionNormalTextureTangentBinormal.VertexElements );
}
else
{
effect.CurrentTechnique = effect.Techniques["DiffuseColor"];
modelPart.VertexDeclaration = new VertexDeclaration( effect.GraphicsDevice,
VertexPositionNormalTexture.VertexElements );
}
}
else
{
effect.CurrentTechnique = effect.Techniques["ColorDefault"];
modelPart.VertexDeclaration = new VertexDeclaration( effect.GraphicsDevice,
VertexPositionNormalColor.VertexElements );
}
modelPart.Effect = effect;
modelPart.EffectParamWorld = modelPart.Effect.Parameters["World"];
modelPart.EffectParamView = modelPart.Effect.Parameters["View"];
modelPart.EffectParamProjection = modelPart.Effect.Parameters["Projection"];
modelPart.EffectParamEye = modelPart.Effect.Parameters["Eye"];
modelPart.EffectParamColor = modelPart.Effect.Parameters["Color"];
} );
modelParts.Add( modelPart );
}
}
private void ReadMeshes(ContentReader input, VertexDeclaration[] vertexDeclarations)
{
int length = input.ReadInt32();
ModelMesh[] meshes = new ModelMesh[length];
for (int i = 0; i < length; i++)
{
string name = input.ReadObject<string>();
ModelBone parentBone = this.ReadBoneReference(input);
BoundingSphere boundingSphere = new BoundingSphere();
boundingSphere.Center = input.ReadVector3();
boundingSphere.Radius = input.ReadSingle();
VertexBuffer vertexBuffer = input.ReadObject<VertexBuffer>();
IndexBuffer indexBuffer = input.ReadObject<IndexBuffer>();
object tag = input.ReadObject<object>();
ModelMeshPart[] meshParts = ReadMeshParts(input, vertexBuffer, indexBuffer, vertexDeclarations);
meshes[i] = new ModelMesh(name, parentBone, boundingSphere, vertexBuffer, indexBuffer, meshParts, tag);
}
this.meshes = new ModelMeshCollection(meshes);
}
private void Read(object parent, ContentReader input, MemberInfo member)
{
PropertyInfo property = member as PropertyInfo;
FieldInfo field = member as FieldInfo;
// properties must have public get and set
if (property != null && (property.CanWrite == false || property.CanRead == false))
{
return;
}
if (property != null && property.Name == "Item")
{
#if WINRT
var getMethod = property.GetMethod;
var setMethod = property.SetMethod;
#else
var getMethod = property.GetGetMethod();
var setMethod = property.GetSetMethod();
#endif
if ((getMethod != null && getMethod.GetParameters().Length > 0) ||
(setMethod != null && setMethod.GetParameters().Length > 0))
{
/*
* This is presumably a property like this[indexer] and this
* should not get involved in the object deserialization
* */
return;
}
}
#if WINRT
Attribute attr = member.GetCustomAttribute(typeof(ContentSerializerIgnoreAttribute));
#else
Attribute attr = Attribute.GetCustomAttribute(member, typeof(ContentSerializerIgnoreAttribute));
#endif
if (attr != null)
{
return;
}
#if WINRT
Attribute attr2 = member.GetCustomAttribute(typeof(ContentSerializerAttribute));
#else
Attribute attr2 = Attribute.GetCustomAttribute(member, typeof(ContentSerializerAttribute));
#endif
bool isSharedResource = false;
if (attr2 != null)
{
var cs = attr2 as ContentSerializerAttribute;
isSharedResource = cs.SharedResource;
}
else
{
if (property != null)
{
#if WINRT
if (property.GetMethod != null && !property.GetMethod.IsPublic)
{
return;
}
if (property.SetMethod != null && !property.SetMethod.IsPublic)
{
return;
}
#else
foreach (MethodInfo info in property.GetAccessors(true))
{
if (info.IsPublic == false)
{
return;
}
}
#endif
}
else
{
if (!field.IsPublic)
{
return;
}
}
}
ContentTypeReader reader = null;
Type elementType = null;
if (property != null)
{
reader = manager.GetTypeReader(elementType = property.PropertyType);
}
else
{
reader = manager.GetTypeReader(elementType = field.FieldType);
}
if (!isSharedResource)
{
object existingChildObject = CreateChildObject(property, field);
object obj2;
if (reader == null && elementType == typeof(object))
{
/* Reading elements serialized as "object" */
obj2 = input.ReadObject <object>();
}
else
{
/* Default */
obj2 = input.ReadObject(reader, existingChildObject);
}
if (property != null)
{
property.SetValue(parent, obj2, null);
}
else
{
// Private fields can be serialized if they have ContentSerializerAttribute added to them
if (field.IsPrivate == false || attr2 != null)
{
field.SetValue(parent, obj2);
}
}
}
else
{
Action <object> action = delegate(object value)
{
if (property != null)
{
property.SetValue(parent, value, null);
}
else
{
field.SetValue(parent, value);
}
};
input.ReadSharedResource(action);
}
}
private static ModelMeshPart[] ReadMeshParts(ContentReader input, VertexBuffer vertexBuffer, IndexBuffer indexBuffer, VertexDeclaration[] vertexDeclarations)
{
int length = input.ReadInt32();
ModelMeshPart[] meshParts = new ModelMeshPart[length];
for (int i = 0; i < length; i++)
{
int streamOffset = input.ReadInt32();
int baseVertex = input.ReadInt32();
int numVertices = input.ReadInt32();
int startIndex = input.ReadInt32();
int primitiveCount = input.ReadInt32();
int index = input.ReadInt32();
VertexDeclaration vertexDeclaration = vertexDeclarations[index];
object tag = input.ReadObject<object>();
meshParts[i] = new ModelMeshPart(streamOffset, baseVertex, numVertices, startIndex, primitiveCount, vertexBuffer, indexBuffer, vertexDeclaration, tag);
int uniqueI = i;
input.ReadSharedResource<Effect>(delegate(Effect effect)
{
meshParts[uniqueI].Effect = effect;
});
}
return meshParts;
}
internal static SkinnedModelBasicEffect Read(ContentReader input)
{
Effect effect = input.ReadObject<Effect>();
SkinnedModelBasicEffect basicEffect = new SkinnedModelBasicEffect(effect);
basicEffect.material.EmissiveColor = input.ReadVector3();
basicEffect.material.DiffuseColor = input.ReadVector3();
basicEffect.material.SpecularColor = input.ReadVector3();
basicEffect.material.SpecularPower = input.ReadSingle();
basicEffect.DiffuseMapEnabled = input.ReadBoolean();
basicEffect.NormalMapEnabled = input.ReadBoolean();
basicEffect.SpecularMapEnabled = input.ReadBoolean();
basicEffect.DiffuseMap = input.ReadExternalReference<Texture2D>();
basicEffect.NormalMap = input.ReadExternalReference<Texture2D>();
basicEffect.SpecularMap = input.ReadExternalReference<Texture2D>();
basicEffect.lightEnabled = false;
basicEffect.enabledLights = EnabledLights.One;
return basicEffect;
}
private void ReadMeshes(ContentReader input)
{
int numMeshes = input.ReadInt32();
List<SkinnedModelMesh> meshList = new List<SkinnedModelMesh>(numMeshes);
for (int i = 0; i < numMeshes; i++)
{
meshList.Add(input.ReadObject<SkinnedModelMesh>());
}
meshes = new SkinnedModelMeshCollection(meshList);
}
internal Map(ContentReader reader)
{
// read in the basic map information
Version = new Version(reader.ReadString());
Orientation = (Orientation)reader.ReadByte();
WidthInTiles = reader.ReadInt32();
HeightInTiles = reader.ReadInt32();
TileWidth = reader.ReadInt32();
TileHeight = reader.ReadInt32();
Properties = new PropertyCollection(reader);
bool makeTilesUnique = reader.ReadBoolean();
// create a list for our tiles
List<Tile> tiles = new List<Tile>();
Tiles = new ReadOnlyCollection<Tile>(tiles);
// read in each tile set
int numTileSets = reader.ReadInt32();
for (int i = 0; i < numTileSets; i++)
{
// get the id and texture
int firstId = reader.ReadInt32();
Texture2D texture = reader.ReadExternalReference<Texture2D>();
// read in each individual tile
int numTiles = reader.ReadInt32();
for (int j = 0; j < numTiles; j++)
{
int id = firstId + j;
Rectangle source = reader.ReadObject<Rectangle>();
PropertyCollection props = new PropertyCollection(reader);
Tile t = new Tile(texture, source, props);
while (id >= tiles.Count)
{
tiles.Add(null);
}
tiles.Insert(id, t);
}
}
// read in all the layers
List<Layer> layers = new List<Layer>();
Layers = new ReadOnlyCollection<Layer>(layers);
int numLayers = reader.ReadInt32();
for (int i = 0; i < numLayers; i++)
{
Layer layer = null;
// read generic layer data
string type = reader.ReadString();
string name = reader.ReadString();
int width = reader.ReadInt32();
int height = reader.ReadInt32();
bool visible = reader.ReadBoolean();
float opacity = reader.ReadSingle();
PropertyCollection props = new PropertyCollection(reader);
// calculate the default layer depth of the layer
float layerDepth = 1f - (LayerDepthSpacing * i);
// using the type, figure out which object to create
if (type == "layer")
{
uint[] data = reader.ReadObject<uint[]>();
layer = new TileLayer(name, width, height, layerDepth, visible, opacity, props, this, data, makeTilesUnique);
}
else if (type == "objectgroup")
{
List<MapObject> objects = new List<MapObject>();
// read in all of our objects
int numObjects = reader.ReadInt32();
for (int j = 0; j < numObjects; j++)
{
string objName = reader.ReadString();
string objType = reader.ReadString();
Rectangle objLoc = reader.ReadObject<Rectangle>();
PropertyCollection objProps = new PropertyCollection(reader);
objects.Add(new MapObject(objName, objType, objLoc, objProps));
}
layer = new MapObjectLayer(name, width, height, layerDepth, visible, opacity, props, objects);
// read in the layer's color
(layer as MapObjectLayer).Color = reader.ReadColor();
}
else
{
throw new Exception("Invalid type: " + type);
}
layers.Add(layer);
namedLayers.Add(name, layer);
}
}
protected internal override Model Read(ContentReader reader, Model existingInstance)
{
// Read the bone names and transforms.
uint boneCount = reader.ReadUInt32();
List <ModelBone> bones = new List <ModelBone>((int)boneCount);
for (uint i = 0; i < boneCount; i += 1)
{
string name = reader.ReadObject <string>();
Matrix matrix = reader.ReadMatrix();
ModelBone bone = new ModelBone {
Transform = matrix,
Index = (int)i,
Name = name
};
bones.Add(bone);
}
// Read the bone hierarchy.
for (int i = 0; i < boneCount; i += 1)
{
ModelBone bone = bones[i];
// Read the parent bone reference.
int parentIndex = ReadBoneReference(reader, boneCount);
if (parentIndex != -1)
{
bone.Parent = bones[parentIndex];
}
// Read the child bone references.
uint childCount = reader.ReadUInt32();
if (childCount != 0)
{
for (uint j = 0; j < childCount; j += 1)
{
int childIndex = ReadBoneReference(reader, boneCount);
if (childIndex != -1)
{
bone.AddChild(bones[childIndex]);
}
}
}
}
List <ModelMesh> meshes = new List <ModelMesh>();
// Read the mesh data.
int meshCount = reader.ReadInt32();
for (int i = 0; i < meshCount; i += 1)
{
string name = reader.ReadObject <string>();
int parentBoneIndex = ReadBoneReference(reader, boneCount);
BoundingSphere boundingSphere = reader.ReadBoundingSphere();
// Tag
object meshTag = reader.ReadObject <object>();
// Read the mesh part data.
int partCount = reader.ReadInt32();
List <ModelMeshPart> parts = new List <ModelMeshPart>(partCount);
for (uint j = 0; j < partCount; j += 1)
{
ModelMeshPart part;
if (existingInstance != null)
{
part = existingInstance.Meshes[i].MeshParts[(int)j];
}
else
{
part = new ModelMeshPart();
}
part.VertexOffset = reader.ReadInt32();
part.NumVertices = reader.ReadInt32();
part.StartIndex = reader.ReadInt32();
part.PrimitiveCount = reader.ReadInt32();
// Tag
part.Tag = reader.ReadObject <object>();
parts.Add(part);
int jj = (int)j;
reader.ReadSharedResource <VertexBuffer>(
delegate(VertexBuffer v)
{
parts[jj].VertexBuffer = v;
}
);
reader.ReadSharedResource <IndexBuffer>(
delegate(IndexBuffer v)
{
parts[jj].IndexBuffer = v;
}
);
reader.ReadSharedResource <Effect>(
delegate(Effect v)
{
parts[jj].Effect = v;
}
);
}
if (existingInstance != null)
{
continue;
}
ModelMesh mesh = new ModelMesh(reader.GraphicsDevice, parts);
mesh.Tag = meshTag;
mesh.Name = name;
mesh.ParentBone = bones[parentBoneIndex];
mesh.ParentBone.AddMesh(mesh);
mesh.BoundingSphere = boundingSphere;
meshes.Add(mesh);
}
if (existingInstance != null)
{
// Read past remaining data and return existing instance
ReadBoneReference(reader, boneCount);
reader.ReadObject <object>();
return(existingInstance);
}
// Read the final pieces of model data.
int rootBoneIndex = ReadBoneReference(reader, boneCount);
Model model = new Model(reader.GraphicsDevice, bones, meshes);
model.Root = bones[rootBoneIndex];
model.BuildHierarchy();
// Tag?
model.Tag = reader.ReadObject <object>();
return(model);
}
internal static SkinnedModelMesh Read(ContentReader input)
{
SkinnedModelMesh skinnedModelPart = new SkinnedModelMesh();
skinnedModelPart.numVertices = input.ReadInt32();
skinnedModelPart.numTriangles = input.ReadInt32();
skinnedModelPart.vertices = input.ReadObject<VertexBuffer>();
skinnedModelPart.indices = input.ReadObject<IndexBuffer>();
skinnedModelPart.effect = input.ReadObject<SkinnedModelBasicEffect>();
return skinnedModelPart;
}