public bool SetVertices(MLOD mlod, MLOD.Mesh mesh, VRTF vrtf, Vertex[] vertices, float[] uvscales)
{
bool okay = SetVertices(mlod, mesh.VertexBufferIndex, mesh.StreamOffset, mesh.VertexCount, vrtf, vertices, uvscales);
mesh.VertexCount = vertices.Length;
return(okay);
}
void SetIndices(MLOD mlod, s3pi.GenericRCOLResource.GenericRCOLResource.ChunkReference myIBI, Int32 beforeLength, Int32 afterPos, Int32[] indices)
{
Int32[] before = new Int32[beforeLength];
Array.Copy(mBuffer, 0, before, 0, before.Length);
Int32[] after = new Int32[mBuffer.Length - afterPos];
Array.Copy(mBuffer, afterPos, after, 0, after.Length);
mBuffer = new Int32[before.Length + indices.Length + after.Length];
Array.Copy(before, 0, mBuffer, 0, before.Length);
Array.Copy(indices, 0, mBuffer, before.Length, indices.Length);
Array.Copy(after, 0, mBuffer, before.Length + indices.Length, after.Length);
int offset = beforeLength + indices.Length - afterPos;
if (offset != 0)
{
foreach (var m in mlod.Meshes.FindAll(m => m.IndexBufferIndex.Equals(myIBI)))
{
if (m.StartIndex > beforeLength)
{
m.StartIndex += offset;
foreach (var g in m.GeometryStates)
{
if (g.StartIndex > beforeLength)
{
g.StartIndex += offset;
}
}
}
}
}
}
public bool SetVertices(MLOD mlod, MLOD.Mesh mesh, MLOD.GeometryState geo, VRTF vrtf, Vertex[] vertices, float[] uvscales)
{
long beforeLength = mesh.StreamOffset + (geo.MinVertexIndex * vrtf.Stride);
bool okay = SetVertices(mlod, mesh.VertexBufferIndex, beforeLength, geo.VertexCount, vrtf, vertices, uvscales);
geo.VertexCount = vertices.Length;
return(okay);
}
public static VBSI FromMLOD(MLOD mlod, GenericRCOLResource container)
{
var vbsi = new VBSI(0, null);
foreach (var mesh in mlod.Meshes)
{
var vrtf = (VRTF)GenericRCOLResource.ChunkReference.GetBlock(container, mesh.VertexFormatIndex);
vbsi.Segments.Add(SegmentInfo.FromMesh(mesh, vrtf));
}
return(vbsi);
}
public MeshList(EventHandler handler, MLOD owner, IEnumerable <Mesh> ilt)
: base(null)
{
mOwner = owner;
elementHandler = handler;
foreach (var t in ilt)
{
base.Add(t);
t.Owner = mOwner;
}
this.handler = handler;
}
private bool SetVertices(MLOD mlod, s4pi.GenericRCOLResource.GenericRCOLResource.ChunkReference myVBI, long beforeLength, int count, VRTF vrtf, IEnumerable <Vertex> vertices, float[] uvscales)
{
bool okay = true;
byte[] before = new byte[beforeLength];
Array.Copy(mBuffer, before, before.Length);
long afterPos = Math.Min(mBuffer.Length, beforeLength + (count * vrtf.Stride));
byte[] after = new byte[mBuffer.Length - afterPos];
Array.Copy(mBuffer, afterPos, after, 0, after.Length);
long offset = 0;
using (MemoryStream mg = new MemoryStream())
{
if (!SetVertices(mg, vrtf, vertices, uvscales))
{
okay = false;
}
offset = beforeLength + mg.Length - afterPos;
mBuffer = new byte[before.Length + mg.Length + after.Length];
Array.Copy(before, mBuffer, before.Length);
Array.Copy(mg.ToArray(), 0, mBuffer, before.Length, mg.Length);
Array.Copy(after, 0, mBuffer, before.Length + mg.Length, after.Length);
mg.Close();
}
int voffset = (int)offset / vrtf.Stride;
if (offset != 0)
{
foreach (var m in mlod.Meshes.Where(m => m.VertexBufferIndex.Equals(myVBI) && m.StreamOffset > beforeLength))
{
m.StreamOffset = (uint)(m.StreamOffset + offset);
foreach (var g in m.GeometryStates)
{
if (g.MinVertexIndex * vrtf.Stride > beforeLength)
{
g.MinVertexIndex += voffset;
}
}
}
}
return(okay);
}
public Mesh(int apiVersion, EventHandler handler, MLOD owner)
: base(apiVersion, handler)
{
mOwner = owner;
mMaterialIndex = new GenericRCOLResource.ChunkReference(requestedApiVersion, handler, 0);
mVertexFormatIndex = new GenericRCOLResource.ChunkReference(requestedApiVersion, handler, 0);
mVertexBufferIndex = new GenericRCOLResource.ChunkReference(requestedApiVersion, handler, 0);
mIndexBufferIndex = new GenericRCOLResource.ChunkReference(requestedApiVersion, handler, 0);
mBounds = new BoundingBox(requestedApiVersion, handler);
mSkinControllerIndex = new GenericRCOLResource.ChunkReference(requestedApiVersion, handler, 0);
mJointReferences = new UIntList(handler);
mGeometryStates = new GeometryStateList(handler);
mScaleOffsetIndex = new GenericRCOLResource.ChunkReference(requestedApiVersion, handler, 0);
mMirrorPlane = new Vector4(requestedApiVersion, handler);//mOwner.Version > 0x00000201
}
public Mesh(int apiVersion, EventHandler handler, MLOD owner,
uint name,
GenericRCOLResource.ChunkReference materialIndex, GenericRCOLResource.ChunkReference vertexFormatIndex,
GenericRCOLResource.ChunkReference vertexBufferIndex, GenericRCOLResource.ChunkReference indexBufferIndex,
ModelPrimitiveType primitiveType, MeshFlags flags,
uint streamOffset, int startVertex, int startIndex, int minVertexIndex, int vertexCount, int primitiveCount,
BoundingBox bounds, GenericRCOLResource.ChunkReference skinControllerIndex,
UIntList jointReferences, GeometryStateList geometryStates, GenericRCOLResource.ChunkReference scaleOffsetIndex,
uint parentName, Vector4 mirrorPlane, uint unknown1
)
: base(apiVersion, handler)
{
mOwner = owner;
mName = name;
mMaterialIndex = new GenericRCOLResource.ChunkReference(requestedApiVersion, handler, materialIndex);
mVertexFormatIndex = new GenericRCOLResource.ChunkReference(requestedApiVersion, handler, vertexFormatIndex);
mVertexBufferIndex = new GenericRCOLResource.ChunkReference(requestedApiVersion, handler, vertexBufferIndex);
mIndexBufferIndex = new GenericRCOLResource.ChunkReference(requestedApiVersion, handler, indexBufferIndex);
mPrimitiveType = primitiveType;
mFlags = flags;
mStreamOffset = streamOffset;
mStartVertex = startVertex;
mStartIndex = startIndex;
mMinVertexIndex = minVertexIndex;
mVertexCount = vertexCount;
mPrimitiveCount = primitiveCount;
mBounds = new BoundingBox(requestedApiVersion, handler, bounds);
mSkinControllerIndex = new GenericRCOLResource.ChunkReference(requestedApiVersion, handler, skinControllerIndex);
mJointReferences = jointReferences == null ? null : new UIntList(handler, jointReferences);
mGeometryStates = geometryStates == null ? null : new GeometryStateList(handler, geometryStates);
mScaleOffsetIndex = new GenericRCOLResource.ChunkReference(requestedApiVersion, handler, scaleOffsetIndex);
if (mOwner.Version > 0x00000201)
{
mParentName = parentName;
mMirrorPlane = new Vector4(requestedApiVersion, handler, mirrorPlane);
}
if (mOwner.Version > 0x00000203)
{
mUnknown1 = unknown1;
}
}
public Mesh(int apiVersion, EventHandler handler, MLOD owner, Stream s) : base(apiVersion, handler)
{
mOwner = owner; Parse(s);
}
public bool SetVertices(MLOD mlod, MLOD.Mesh mesh, int geoIndex, VRTF vrtf, Vertex[] vertices, float[] uvscales)
{
return(SetVertices(mlod, mesh, mesh.GeometryStates[geoIndex], vrtf, vertices, uvscales));
}
public MLOD(int apiVersion, EventHandler handler, MLOD basis) : this(apiVersion, handler, basis.Version, new MeshList(handler, basis, basis.mMeshes))
{
}
public bool SetVertices(MLOD mlod, int meshIndex, VRTF vrtf, Vertex[] vertices, float[] uvscales)
{
return(SetVertices(mlod, mlod.Meshes[meshIndex], vrtf, vertices, uvscales));
}
public void SetIndices(MLOD mlod, MLOD.Mesh mesh, int geoStateIndex, Int32[] indices)
{
MLOD.GeometryState geometryState = mesh.GeometryStates[geoStateIndex];
SetIndices(mlod, mesh, geometryState, indices);
}
public void SetIndices(MLOD mlod, MLOD.Mesh mesh, Int32[] indices)
{
SetIndices(mlod, mesh.IndexBufferIndex, mesh.PrimitiveType, mesh.StartIndex, mesh.PrimitiveCount, indices);
mesh.PrimitiveCount = indices.Length / IndexCountFromPrimitiveType(mesh.PrimitiveType);
}
void SetIndices(MLOD mlod, s3pi.GenericRCOLResource.GenericRCOLResource.ChunkReference myIBI, ModelPrimitiveType type, Int32 startIndex, Int32 primCount, Int32[] indices)
{
SetIndices(mlod, myIBI, startIndex, startIndex + primCount * IndexCountFromPrimitiveType(type), indices);
}
public void SetIndices(MLOD mlod, MLOD.Mesh mesh, MLOD.GeometryState geometryState, Int32[] indices)
{
SetIndices(mlod, mesh.IndexBufferIndex, mesh.PrimitiveType, geometryState.StartIndex, geometryState.PrimitiveCount,
indices.Select(x => x + geometryState.MinVertexIndex).ToArray());
geometryState.PrimitiveCount = indices.Length / IndexCountFromPrimitiveType(mesh.PrimitiveType);
}
public MeshList(EventHandler handler, MLOD owner, Stream s) : this(handler, owner)
{
Parse(s);
}
public MeshList(EventHandler handler, MLOD owner) : base(handler)
{
mOwner = owner;
}