//---------------------------------------------------------------
#endregion
//---------------------------------------------------------------
//---------------------------------------------------------------
#region Methods
//---------------------------------------------------------------
private void Bind()
{
BinormalStream.Bind();
BoneIndicesStream.Bind();
BoneWeightsStream.Bind();
SoftwareBoneIndicesStream.Bind();
SoftwareBoneWeightsStream.Bind();
ColorStream.Bind();
CompressedNormalStream.Bind();
FloatStream.Bind();
IndexStream16.Bind();
IndexStream32.Bind();
IntStream.Bind();
NormalStream.Bind();
PositionStream.Bind();
PositionStream2.Bind();
PositionStream4.Bind();
TangentStream.Bind();
TextureStream.Bind();
}
TRealVar TOZ; //Время обработки заявки в системе
#endregion Fields
#region Constructors
public VU(VS parent, string name)
: base(parent, name)
{
ParentVS = parent;
UVD = new UstroystvoVvoda(this, "УВД" + "(" + name + ")");
UR = new UstroystvoRabota(this, "УОД" + "(" + name + ")");
UV = new UstroystvoVyvoda(this, "УВР" + "(" + name + ")");
this.AddModelObject(UVD);
this.AddModelObject(UR);
this.AddModelObject(UV);
#region Инициализация переменных объектов модели
KVZ = InitModelObject<TIntVar>();
KOZ = InitModelObject<TIntVar>();
TOZ = InitModelObject<TRealVar>();
KPZ = new int[3];
Gener_Vhod = InitModelObject<ExpStream>();
Gener_RazmerVvod = InitModelObject<UniformStream>();
Gener_RazmerVyvoda = InitModelObject<NormalStream>();
// Gener_RazmerRabota = InitModelObject<ExpStream>();
#endregion
#region Инициализация сборщиков статистики
Variance_TOZ = InitModelObject<Variance<Double>>(); //создаем сборщик
Variance_TOZ.ConnectOnSet(TOZ); //подключаем сборщик к переменной
Min_TOZ = InitModelObject<Min<double>>(); //создаем сборщик
Min_TOZ.ConnectOnSet(TOZ); //подключаем сборщик к переменной
Max_TOZ = InitModelObject<Max<double>>(); //создаем сборщик
Max_TOZ.ConnectOnSet(TOZ); //подключаем сборщик к переменной
His_TOZ = InitModelObject<DynamicHistogram>();
His_TOZ.ConnectOnSet(TOZ);
#endregion
}
private SubSetData CreateSubSetData(SubSet subSet)
{
VertexUnit vu = subSet.VertexUnit;
if (!vu.Format.Contains(Semantic.BoneIndices) ||
!vu.Format.Contains(Semantic.BoneIndices) ||
!vu.Format.Contains(Semantic.Position))
{
return(null);
}
SubSetData ssData = new SubSetData();
PositionStream posStream = (PositionStream)vu[typeof(PositionStream)];
ssData.Position = (Vector3[])posStream.Data.Clone();
if (vu.Format.Contains(typeof(NormalStream)))
{
NormalStream normalStream = (NormalStream)vu[typeof(NormalStream)];
ssData.Normal = (Vector3[])normalStream.Data.Clone();
}
return(ssData);
}
/// <summary>
/// Import a mesh from a stream.
/// </summary>
/// <param name="stream">Stream containing mesh data.</param>
public void Import(Stream stream)
{
Profiler.Instance.Begin("Import binary mesh");
// Header
BinaryReader reader = new BinaryReader(stream);
if (ReadString(reader) != "mesh" || ReadString(reader) != "v0.3")
{
throw new NotSupportedException("Can't load mesh, file not supported!");
}
// Joints
int jointNum = ReadInt(reader);
Joint[] joints = new Joint[jointNum];
Matrix4[] jointArray = new Matrix4[jointNum];
Hashtable jointTable = new Hashtable(joints.Length);
for (int i = 0; i < joints.Length; i++)
{
string name = ReadString(reader);
string parent = ReadString(reader);
reader.Read(matrixBytes, 0, matrixBytes.Length);
Matrix4 m = Matrix4.From(matrixBytes);
Joint parentJoint = null;
if (parent != null && jointTable.Contains(parent))
{
parentJoint = (Joint)jointTable[parent];
}
joints[i] = new Joint(name, i, parentJoint);
jointArray[i] = m;
jointTable[name] = joints[i];
}
skeleton = new Skeleton(jointArray, joints);
// SubSet
int subSetNum = ReadInt(reader);
for (int i = 0; i < subSetNum; i++)
{
ArrayList streams = new ArrayList(10);
// Header
if (ReadString(reader) != "subset")
{
throw new NotSupportedException("Error on loading subSet!");
}
string name = ReadString(reader);
string parentJoint = ReadString(reader);
int attributeCount = ReadInt(reader);
StringDictionary attributes = new StringDictionary();
for (int t = 0; t < attributeCount; t++)
{
attributes.Add(ReadString(reader), ReadString(reader));
}
// IndexStream
// Todo Replace ushort.MaxValue with size of vertex unit
IndexStream indexStream = IndexStream.Create(ReadInt(reader), ushort.MaxValue);
byte[] indexBuffer = new byte[indexStream.Size * 4];
reader.Read(indexBuffer, 0, indexStream.Size * 4);
for (int t = 0; t < indexStream.Size; t++)
{
indexStream[t] = BitConverter.ToInt32(indexBuffer, t * 4);
}
int vertexSize = ReadInt(reader);
PositionStream posStream = new PositionStream(vertexSize);
streams.Add(posStream);
byte[] vertexBuffer = new byte[vertexSize * 12];
reader.Read(vertexBuffer, 0, vertexSize * 12);
for (int t = 0; t < vertexSize; t++)
{
posStream[t] = Vector3.From(vertexBuffer, 12 * t);
}
NormalStream normalStream = new NormalStream(vertexSize);
streams.Add(normalStream);
reader.Read(vertexBuffer, 0, vertexSize * 12);
for (int t = 0; t < vertexSize; t++)
{
normalStream[t] = Vector3.From(vertexBuffer, t * 12);
}
ColorStream colorStream = new ColorStream(vertexSize);
streams.Add(colorStream);
reader.Read(vertexBuffer, 0, vertexSize * 12);
for (int t = 0; t < vertexSize; t++)
{
int r = Math.Basic.Clamp((int)(System.BitConverter.ToSingle(vertexBuffer, t * 12) * 255 + 0.5f), 0, 255);
int g = Math.Basic.Clamp((int)(System.BitConverter.ToSingle(vertexBuffer, 4 + t * 12) * 255 + 0.5f), 0, 255);
int b = Math.Basic.Clamp((int)(System.BitConverter.ToSingle(vertexBuffer, 8 + t * 12) * 255 + 0.5f), 0, 255);
colorStream[t] = System.Drawing.Color.FromArgb(r, g, b).ToArgb();
}
TextureStream[] textureStreams = new TextureStream[ReadInt(reader)];
for (int t = 0; t < textureStreams.Length; t++)
{
TextureStream texStream = new TextureStream(vertexSize);
streams.Add(texStream);
reader.Read(vertexBuffer, 0, vertexSize * 8);
for (int j = 0; j < vertexSize; j++)
{
texStream[j] = Vector2.From(vertexBuffer, j * 8);
}
textureStreams[t] = texStream;
}
IBoneIndicesStream boneStream = null;
IBoneWeightsStream weightsStream = null;
int weightNum = ReadInt(reader);
if (weightNum != 0)
{
if (HardwareSkinning)
{
boneStream = new BoneIndicesStream(vertexSize);
weightsStream = new BoneWeightsStream(vertexSize);
}
else
{
boneStream = new SoftwareBoneIndicesStream(vertexSize);
weightsStream = new SoftwareBoneWeightsStream(vertexSize);
}
streams.Add(boneStream);
streams.Add(weightsStream);
ArrayList[] indicesList = new ArrayList[vertexSize];
ArrayList[] weightsList = new ArrayList[vertexSize];
for (int t = 0; t < vertexSize; t++)
{
indicesList[t] = new ArrayList(8);
weightsList[t] = new ArrayList(8);
}
byte[] weightBuffer = new byte[weightNum * 12];
reader.Read(weightBuffer, 0, weightNum * 12);
for (int t = 0; t < weightNum; t++)
{
int vertexIndex = BitConverter.ToInt32(weightBuffer, t * 12);
int jointIndex = BitConverter.ToInt32(weightBuffer, 4 + t * 12);
float weight = BitConverter.ToSingle(weightBuffer, 8 + t * 12);
indicesList[vertexIndex].Add((byte)jointIndex);
weightsList[vertexIndex].Add(weight);
}
for (int t = 0; t < vertexSize; t++)
{
boneStream.SetIndices(t, (byte[])indicesList[t].ToArray(typeof(byte)));
weightsStream.SetWeights(t, (float[])weightsList[t].ToArray(typeof(float)));
}
}
VertexUnit vertexUnit = new VertexUnit(streams);
Mesh mesh = new Mesh(new SubSet(vertexUnit, indexStream));
if (model == null)
{
if (skeleton.Joints.Length != 0)
{
model = new Model(new SkinnedMesh(mesh, skeleton), skeleton);
}
else
{
model = new Model(mesh, skeleton);
}
}
else
{
Joint attachTo = skeleton.RootJoint;
if (parentJoint != "")
{
attachTo = (jointTable[parentJoint] as Joint);
}
model.AttachModel(new Model(mesh, skeleton), attachTo);
}
}
reader.Close();
Profiler.Instance.End("Import binary mesh");
}
// Генератор числа выходящих пассажиров
// DiscreteStream<int> GenKolPassOut;
#endregion
#region Инициализация объектов модели
public SmoModel(Model parent, string name)
: base(parent, name)
{
GenPurchase = InitModelObject<NormalStream>("Генератор времени появления пассажиров");
}
private MD3Part LoadMD3(string part)
{
using (Stream stream = fileSystem.Open(path + part + ".md3")) {
// get header and check if it is ok
MD3_Header header = (MD3_Header)RawSerializer.Deserialize(stream, typeof(MD3_Header));
if (header.Id != 860898377 || header.Version != 15)
{
return(null);
}
// load bone frames
MD3_Frame[] frames = (MD3_Frame[])RawSerializer.DeserializeArray(stream, typeof(MD3_Frame), header.NumFrames);
// load tags
SortedList links = GetLinks((MD3_Tag[])RawSerializer.DeserializeArray(stream, typeof(MD3_Tag), header.NumTags * header.NumFrames));
long meshOffset = stream.Position;
// one mesh for every frame
BlendMesh mesh = new BlendMesh(header.NumFrames);
// load meshes
for (int iMesh = 0; iMesh < header.NumMeshes; iMesh++)
{
stream.Position = meshOffset;
MD3_MeshHeader meshHeader = (MD3_MeshHeader)RawSerializer.Deserialize(stream, typeof(MD3_MeshHeader));
MD3_Skin[] skins = (MD3_Skin[])RawSerializer.DeserializeArray(stream, typeof(MD3_Skin), meshHeader.NumSkins);
stream.Position = meshOffset + meshHeader.TriangleOffset;
MD3_Triangle[] triangles = (MD3_Triangle[])RawSerializer.DeserializeArray(stream, typeof(MD3_Triangle), meshHeader.NumTriangles);
stream.Position = meshOffset + meshHeader.TexCoordOffset;
MD3_TexCoord[] texCoords = (MD3_TexCoord[])RawSerializer.DeserializeArray(stream, typeof(MD3_TexCoord), meshHeader.NumVertices);
stream.Position = meshOffset + meshHeader.VertexOffset;
MD3_Vertex[] vertices = (MD3_Vertex[])RawSerializer.DeserializeArray(stream, typeof(MD3_Vertex), meshHeader.NumFrames * meshHeader.NumVertices);
float scale = 64.0f;
string name = StringHelper.Convert(meshHeader.Name);
ITexture tx = (ITexture)textures[name];
Triangle[] tris = new Triangle[triangles.Length];
for (int i = 0; i < triangles.Length; i++)
{
tris[i].A = (triangles[i]).A;
tris[i].B = (triangles[i]).B;
tris[i].C = (triangles[i]).C;
}
IndexStream indexStream = IndexStream16.FromTriangles(tris);
int vertCount = meshHeader.NumVertices; // *meshHeader.NumFrames;
for (int iFrame = 0; iFrame < meshHeader.NumFrames; iFrame++)
{
VertexUnit vertexUnit = new VertexUnit(VertexFormat.PositionNormalTexture, vertCount);
PositionStream pos = (PositionStream)vertexUnit[typeof(PositionStream)];
NormalStream normal = (NormalStream)vertexUnit[typeof(NormalStream)];
TextureStream tex = (TextureStream)vertexUnit[typeof(TextureStream)];
for (int i = 0; i < vertCount; i++)
{
int vertIndex = iFrame * meshHeader.NumVertices + i;
pos[i] = new Vector3(vertices[vertIndex].X / scale,
vertices[vertIndex].Z / scale,
-vertices[vertIndex].Y / scale);
int texIndex = i % meshHeader.NumVertices;
tex[i] = new Vector2(texCoords[texIndex].U,
texCoords[texIndex].V);
//Normal vector
int compressedNormal = ((MD3_Vertex)vertices[vertIndex]).Normal;
float lng = (compressedNormal & 0xFF) * Math.Basic.PI / 128;
float lat = ((compressedNormal >> 8) & 0xFF) * Math.Basic.PI / 128;
normal[i] = new Vector3(Math.Trigonometry.Cos(lat) * Math.Trigonometry.Sin(lng),
Math.Trigonometry.Cos(lng),
-Math.Trigonometry.Sin(lat) * Math.Trigonometry.Sin(lng));
}
if (mesh.Meshes[iFrame] == null)
{
mesh.Meshes[iFrame] = new Mesh();
}
mesh.Meshes[iFrame].SubSets.Add(new SubSet(vertexUnit, indexStream));
mesh.Meshes[iFrame].Textures.Add(new Textures("color", tx));
}
// Increase the offset into the file
meshOffset += meshHeader.MeshSize;
}
return(new MD3Part(mesh, links));
}
}
public SmoModel(Model parent, string name) : base(parent, name)
{
#region Инициализация переменных состояния модели
Shops = new Shop[N];
for (int i = 0; i < N; i++)
{
Shops[i] = new Shop();
Shops[i].ProductAmountCurrent = InitModelObject <TIntVar>("Текущий объем товара в(во) " + i + "-ом магазине ");
Shops[i].ProductDemandCurrent = InitModelObject <TIntVar>("Текущий объем спроса на товар в(во) " + i + "-ом магазине ");
Shops[i].ProductUnmetDemandCurrent = InitModelObject <TRealVar>("Текущий объем неудовлетворенного спроса в(во) " + i + "-ом магазине ");
Shops[i].ProductUnrealizedCurrent = InitModelObject <TRealVar>("Текущий объем пролежанного товара в(во) " + i + "-ом магазине ");
Shops[i].HasSendRequest = InitModelObject <TIntVar>("Идентификатор подачи заявки в(во) " + i + "-ом магазине ");
Shops[i].RequestsTotalCountCurrent = InitModelObject <TRealVar>("Текцщее количество поданных заявок на пополнение товара в(во) " + i + "-ом магазине ");
Shops[i].RequestsTotalCountAll = InitModelObject <TRealVar>("Суммарное количество поданных заявок на пополнение товара в(во) " + i + "-ом магазине ");
Shops[i].ProductDemandAll = InitModelObject <TIntVar>("Суммарный объем спроса на товар в(во) " + i + "-ом магазине ");
Shops[i].ProductUnmetDemandAll = InitModelObject <TRealVar>("Суммарный объем неудовлетворенного спроса в(во) " + i + "-ом магазине ");
Shops[i].ProductUnrealizedAll = InitModelObject <TRealVar>("Суммарный объем пролежанного товара в(во) " + i + "-ом магазине ");
}
SVST = InitModelObject <TRealVar>("текущий суммарный объем спроса на товар (за день)");
SVSTP = InitModelObject <TRealVar>("Cуммарный объем спроса на товар (за все время)");
// Ряд распределения для времени восстановления товарного запаса в первом магазине
ZR_TV_ValueGenerator1 = InitModelObject <DiscreteStream <double> >("Генератор 'Ряд распределения для времени восстановления товарного запаса в первом магазине': ");
ZR_TV_ValueGenerator1.Table = new Dictionary <double, double>();
// Ряд распределения для времени восстановления товарного запаса во втором магазине
ZR_TV_ValueGenerator2 = InitModelObject <DiscreteStream <double> >("Генератор 'Ряд распределения для времени восстановления товарного запаса во втором магазине': ");
ZR_TV_ValueGenerator2.Table = new Dictionary <double, double>();
#endregion
#region Инициализация генераторов потоков
NormalGenerator_VDS1 = InitModelObject <NormalStream>("генератор потока 'объем дневного спроса в первом магазине'");
NormalGenerator_VDS2 = InitModelObject <NormalStream>("генератор потока 'объем дневного спроса во втором магазине'");
UniformGenerator_TVost1 = InitModelObject <UniformStream>("генератор потока 'время восстановления товарного запаса в первом магазине'");
UniformGenerator_TVost2 = InitModelObject <UniformStream>("генератор потока 'время восстановления товарного запаса во втором магазине'");
#endregion
#region Инициализация сборщиков статистики и подключение их к переменным
//хранение пролеживаемого товара
Variance_SDP_PP = InitModelObjectArray <Variance <double> >(N, "Сборщик статистики: средние дневные потери от пролеживания товара в i-том магазине");
Variance_SDP_PP[0].ConnectOnSet(Shops[0].ProductUnrealizedCurrent);
Variance_SDP_PP[1].ConnectOnSet(Shops[1].ProductUnrealizedCurrent);
Max_SDP_PP = InitModelObjectArray <Max <double> >(N, "Максимум потерь от пролеживания товара в i-том магазине");
Max_SDP_PP[0].ConnectOnSet(Shops[0].ProductUnrealizedCurrent);
Max_SDP_PP[1].ConnectOnSet(Shops[1].ProductUnrealizedCurrent);
Min_SDP_PP = InitModelObjectArray <Min <double> >(N, "Минимум потерь от пролеживания товара в i-том магазине");
Min_SDP_PP[0].ConnectOnSet(Shops[0].ProductUnrealizedCurrent);
Min_SDP_PP[1].ConnectOnSet(Shops[1].ProductUnrealizedCurrent);
//нереализованная прибыль от неудовлетворенного спроса
Variance_SDP_PNP = InitModelObjectArray <Variance <double> >(N, "Сборщик статистики: средние дневные потери от неудовлетворенного спроса в i-том магазине");
Variance_SDP_PNP[0].ConnectOnSet(Shops[0].ProductUnmetDemandCurrent);
Variance_SDP_PNP[1].ConnectOnSet(Shops[1].ProductUnmetDemandCurrent);
Max_SDP_PNP = InitModelObjectArray <Max <double> >(N, "Максимум потерь от нереализованной прибыли в i-том магазине");
Max_SDP_PNP[0].ConnectOnSet(Shops[0].ProductUnmetDemandCurrent);
Max_SDP_PNP[1].ConnectOnSet(Shops[1].ProductUnmetDemandCurrent);
Min_SDP_PNP = InitModelObjectArray <Min <double> >(N, "Минимум потерь от нереализованной прибыли в i-том магазине");
Min_SDP_PNP[0].ConnectOnSet(Shops[0].ProductUnmetDemandCurrent);
Min_SDP_PNP[1].ConnectOnSet(Shops[1].ProductUnmetDemandCurrent);
//потери от подачи заявок
Variance_SDP_PPZ = InitModelObjectArray <Variance <double> >(N, "Сборщик статистики: средние дневные потери от подачи заявок в i-том магазине");
Variance_SDP_PPZ[0].ConnectOnSet(Shops[0].RequestsTotalCountCurrent);
Variance_SDP_PPZ[1].ConnectOnSet(Shops[1].RequestsTotalCountCurrent);
Max_SDP_PPZ = InitModelObjectArray <Max <double> >(N, "Максимум потерь от подачи заявок в i-том магазине");
Max_SDP_PPZ[0].ConnectOnSet(Shops[0].RequestsTotalCountCurrent);
Max_SDP_PPZ[1].ConnectOnSet(Shops[1].RequestsTotalCountCurrent);
Min_SDP_PPZ = InitModelObjectArray <Min <double> >(N, "Минимум потерь от подачи заявок в i-том магазине");
Min_SDP_PPZ[0].ConnectOnSet(Shops[0].RequestsTotalCountCurrent);
Min_SDP_PPZ[1].ConnectOnSet(Shops[1].RequestsTotalCountCurrent);
// суммарные средние дневные потери торговой системы
Variance_SSDS = InitModelObject <Variance <double> >("Сборщик статистики: суммарные средние дневные потери торговой системы");
// SVSTP
Variance_SVSTP = InitModelObject <Variance <double> >("Сборщик статистики: МО объема поставок со склада в магазины.");
Variance_SVSTP.ConnectOnSet(SVSTP);
Max_SVSTP = InitModelObject <Max <double> >("Максимум объема поставок со склада в магазины.");
Max_SVSTP.ConnectOnSet(SVSTP);
Min_SVSTP = InitModelObject <Min <double> >("Минимум объема поставок со склада в магазины.");
Min_SVSTP.ConnectOnSet(SVSTP);
#endregion
}
/// <summary>
/// import a mesh from a stream
/// </summary>
/// <param name="stream">stream containing mesh data</param>
public void Import(Stream stream)
{
model = null;
skeleton = null;
IndexStream indexStream = null;
IVertexStream currentStream = null;
ArrayList streams = new ArrayList();
StringDictionary attributes = new StringDictionary();
XmlTextReader reader = new XmlTextReader(stream);
Matrix4[] jointArray = null;
Joint[] joints = null;
Hashtable jointTable = null;
int index = 0;
int currentJoint = 0;
int vertexCount = 0;
int binding = -1;
ArrayList[] indicesList = null;
ArrayList[] weightsList = null;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
// <mesh>
case "mesh":
if (model != null)
{
throw new GraphicsException("Only one mesh allowed in mesh stream!");
}
model = new Model();
break;
// <subset>
case "subset":
string parentJoint = reader.GetAttribute("parentJoint");
if (parentJoint != null && parentJoint != "")
{
binding = (jointTable[parentJoint] as Joint).Index;
}
else
{
binding = -1;
}
break;
// <attributes>
case "attributes":
break;
case "attribute":
// todo !!!
attributes.Add(reader.GetAttribute("name"), reader.GetAttribute("value"));
break;
//<indexStream>
case "indexStream": {
index = 0;
int size = int.Parse(reader.GetAttribute("size"), culture);
indexStream = new IndexStream16(size);
}
break;
//<triangle>
case "triangle": {
int a = int.Parse(reader.GetAttribute("a"), culture);
int b = int.Parse(reader.GetAttribute("b"), culture);
int c = int.Parse(reader.GetAttribute("c"), culture);
indexStream[index++] = a;
indexStream[index++] = b;
indexStream[index++] = c;
}
break;
//<positionStream>
case "positionStream": {
index = 0;
vertexCount = int.Parse(reader.GetAttribute("size"), culture);
currentStream = new PositionStream(vertexCount);
streams.Add(currentStream);
}
break;
//<vector3>
case "vector3": {
float x = float.Parse(reader.GetAttribute("x"), culture);
float y = float.Parse(reader.GetAttribute("y"), culture);
float z = float.Parse(reader.GetAttribute("z"), culture);
(currentStream as PositionStream)[index++] = new Vector3(x, y, z);
}
break;
//<normalStream>
case "normalStream": {
index = 0;
int size = int.Parse(reader.GetAttribute("size"), culture);
currentStream = new NormalStream(size);
streams.Add(currentStream);
}
break;
//<colorStream>
case "colorStream": {
index = 0;
int size = int.Parse(reader.GetAttribute("size"), culture);
currentStream = new ColorStream(size);
streams.Add(currentStream);
}
break;
//<color>
case "color": {
int r = (int)((float.Parse(reader.GetAttribute("r"), culture)) * 255.0f + 0.5f);
int g = (int)((float.Parse(reader.GetAttribute("g"), culture)) * 255.0f + 0.5f);
int b = (int)((float.Parse(reader.GetAttribute("b"), culture)) * 255.0f + 0.5f);
(currentStream as ColorStream)[index++] = System.Drawing.Color.FromArgb(r, g, b).ToArgb();
}
break;
//<textureStream>
case "textureStream": {
index = 0;
int size = int.Parse(reader.GetAttribute("size"), culture);
currentStream = new TextureStream(size);
streams.Add(currentStream);
}
break;
//<vector2>
case "vector2": {
float x = float.Parse(reader.GetAttribute("x"), culture);
float y = float.Parse(reader.GetAttribute("y"), culture);
(currentStream as TextureStream)[index++] = new Vector2(x, y);
}
break;
case "joints": {
int size = int.Parse(reader.GetAttribute("size"), culture);
jointArray = new Matrix4[size];
joints = new Joint[size];
jointTable = new Hashtable();
currentJoint = 0;
}
break;
case "joint": {
string jointName = reader.GetAttribute("name");
string parentName = reader.GetAttribute("parent");
Matrix4 m = new Matrix4(float.Parse(reader.GetAttribute("a1"), culture),
float.Parse(reader.GetAttribute("a2"), culture),
float.Parse(reader.GetAttribute("a3"), culture),
float.Parse(reader.GetAttribute("a4"), culture),
float.Parse(reader.GetAttribute("b1"), culture),
float.Parse(reader.GetAttribute("b2"), culture),
float.Parse(reader.GetAttribute("b3"), culture),
float.Parse(reader.GetAttribute("b4"), culture),
float.Parse(reader.GetAttribute("c1"), culture),
float.Parse(reader.GetAttribute("c2"), culture),
float.Parse(reader.GetAttribute("c3"), culture),
float.Parse(reader.GetAttribute("c4"), culture),
float.Parse(reader.GetAttribute("d1"), culture),
float.Parse(reader.GetAttribute("d2"), culture),
float.Parse(reader.GetAttribute("d3"), culture),
float.Parse(reader.GetAttribute("d4"), culture));
jointArray[currentJoint] = m; //new Joint(jointName, m);
Joint parent = null;
if (parentName != null && jointTable.Contains(parentName))
{
parent = (Joint)jointTable[parentName];
}
joints[currentJoint] = new Joint(jointName, currentJoint, parent);
jointTable[jointName] = joints[currentJoint];
currentJoint++;
}
break;
case "weights": {
index = 0;
//vertexCount = int.Parse(reader.GetAttribute("size"), culture);
indicesList = new ArrayList[vertexCount];
weightsList = new ArrayList[vertexCount];
for (int i = 0; i < vertexCount; i++)
{
indicesList[i] = new ArrayList(8);
weightsList[i] = new ArrayList(8);
}
}
break;
case "weight": {
int vertexIndex = int.Parse(reader.GetAttribute("vertexIndex"));
byte jointIndex = byte.Parse(reader.GetAttribute("jointIndex"));
float value = float.Parse(reader.GetAttribute("weight"), culture);
indicesList[vertexIndex].Add(jointIndex);
weightsList[vertexIndex].Add(value);
}
break;
}
}
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.Name.Equals("weights"))
{
IBoneIndicesStream bis = null;
IBoneWeightsStream bws = null;
if (HardwareSkinning)
{
bis = new BoneIndicesStream(vertexCount);
bws = new BoneWeightsStream(vertexCount);
}
else
{
bis = new SoftwareBoneIndicesStream(vertexCount);
bws = new SoftwareBoneWeightsStream(vertexCount);
}
for (int i = 0; i < vertexCount; i++)
{
bis.SetIndices(i, (byte[])indicesList[i].ToArray(typeof(byte)));
bws.SetWeights(i, (float[])weightsList[i].ToArray(typeof(float)));
}
streams.Add(bis);
streams.Add(bws);
}
else if (reader.Name.Equals("subset"))
{
VertexUnit vertexUnit = new VertexUnit(streams);
if (binding == -1)
{
model.Mesh = new Mesh(new SubSet(vertexUnit, indexStream));
}
else
{
model.AttachModel(new Model(new Mesh(new SubSet(vertexUnit, indexStream)), null), binding);
}
streams.Clear();
}
}
}
;
reader.Close();
if (jointArray != null && joints != null)
{
skeleton = new Skeleton(jointArray, joints);
}
model.Skeleton = skeleton;
}