private void LoadOrClear()
{
if (size != null && !(Commentaries.Any() && Materials.Any() && Pribors.Any()))
{
using (var db = new SmetaApplication.DbContexts.SmetaDbAppContext())
{
Materials.Clear();
db.MaterialGroups.Where(x => x.WorkId == Id).ToList().ForEach(x =>
{
Materials.Add(new MaterialGroupDemView(x, diff + 1));
});
Pribors.Clear();
db.PriborGroups.Where(x => x.WorkId == Id).ToList().ForEach(x =>
{
Pribors.Add(new PriborGroupView(x));
});
Commentaries.Clear();
db.Commentaries.Where(x => x.WorkSectionId == WorkSectionId).ToList().ForEach(x =>
{
Commentaries.Add(new CommentaryView(x));
});
}
}
else
{
Commentaries.Clear();
Materials.Clear();
Pribors.Clear();
}
}
internal override void SyncChanges()
{
if (!HasChanges)
{
return;
}
base.SyncChanges();
bool created = false;
if (RenderableObject == null)
{
created = true;
RenderableObject = new SimpleVertexObject();
}
var obj = (SimpleVertexObject)RenderableObject;
if (MeshChanged)
{
if (InternalMesh == null)
{
InternalMesh = new StaticInternalMesh(Mesh);
obj.Name = Name;
}
else
{
InternalMesh.SetMesh(Mesh);
}
InternalMesh.Materials.Clear();
foreach (var gameMat in Materials)
{
InternalMesh.Materials.Add(gameMat.RendererMaterial);
}
obj.UseTransparency = Materials.Any(m => m.UseTransparency);
obj.SetVertices(InternalMesh);
MeshChanged = false;
}
if (TransformChanged)
{
var trans = LocalToWorld();
UpdateWorldBounds(trans);
obj.PositionMatrix = trans;
obj.WorldBounds = WorldBounds;
TransformChanged = false;
}
obj.Enabled = Visible;
obj.DrawPriority = DrawPriority;
if (created)
{
RenderContext.Current.AddObject(RenderableObject);
}
}
public materials this[materials m]
{
get
{
if (Materials.Any(l => l == m))
{
return(Materials.First(l => l == m));
}
return(materials.none);
}
}
void OnAddMaterial()
{
var item = GetItemHelper.GetItem();
if (item == null)
{
return;
}
if (Materials.Any(p => p.Item.DomainObject == item))
{
return;
}
Materials.Add(
new ItemQuantityPair()
{
Item = new ItemViewModel(item), Quantity = 1
});
}
/// <summary>
/// Process the model data.
/// </summary>
public virtual void PostProcessing()
{
var vertexBuffersCount = VertexBuffers.Count;
// Bookkeeping array: how many vertices are in each vertex buffer?
var vbCounts = new uint[vertexBuffersCount];
// Bookkeeping array: how many vertices have been consumed from each vertex buffer?
var vbOffsets = new uint[vertexBuffersCount];
// Vertex buffer data readers
var vbReaders = new BinaryReader[vertexBuffersCount];
// Vertex arrays
var vbArrays = new SolidMeshVertex[vertexBuffersCount][];
// Set up vertex buffer readers
for (var i = 0; i < vbReaders.Length; i++)
{
vbReaders[i] = new BinaryReader(new MemoryStream(VertexBuffers[i]));
}
// Filling in vbCounts...
if (vertexBuffersCount == 1)
{
// The mesh descriptor tells us how many vertices exist.
// Since we only have one vertex buffer, we can use the info
// from the mesh descriptor instead of doing the material loop
// seen after this block.
vbCounts[0] = MeshDescriptor.NumVerts;
}
else if (vertexBuffersCount > 1)
{
// Fill in vbCounts by examining every material.
// We need to make sure at least one of our materials
// actually has a NumVerts > 0, otherwise weird things
// will probably happen.
Debug.Assert(Materials.Any(m => m.NumVerts > 0));
foreach (var t in Materials)
{
vbCounts[t.VertexStreamIndex] += t.NumVerts;
}
}
else
{
// If we have no vertex buffers, we can bail out.
return;
}
// Verifying the integrity of our data...
for (var i = 0; i < vbReaders.Length; i++)
{
// To avoid a division-by-zero exception, we allow a vertex buffer to have
// EITHER 0 vertices OR exactly enough data for a given number of vertices.
Debug.Assert(vbCounts[i] == 0 || VertexBuffers[i].Length % vbCounts[i] == 0);
vbArrays[i] = new SolidMeshVertex[vbCounts[i]];
}
// Reading vertices from buffers...
foreach (var solidObjectMaterial in Materials)
{
var vbIndex = solidObjectMaterial.VertexStreamIndex;
var vbStream = vbReaders[vbIndex];
var vbVertexCount = vbCounts[vbIndex];
var vbOffset = vbOffsets[vbIndex];
var vbStride = (int)(vbStream.BaseStream.Length / vbVertexCount);
var numVerts = solidObjectMaterial.NumVerts == 0
? vbVertexCount
: solidObjectMaterial.NumVerts;
if (vbOffset < vbVertexCount)
{
var vbStartPos = vbStream.BaseStream.Position;
for (var i = 0; i < numVerts; i++)
{
Debug.Assert(vbStream.BaseStream.Position - vbStartPos == vbStride * i, "vbStream.BaseStream.Position - vbStartPos == vbStride * i");
vbArrays[vbIndex][vbOffset + i] = GetVertex(vbStream, solidObjectMaterial, vbStride);
}
vbOffsets[vbIndex] += numVerts;
}
else if (vbOffset != vbVertexCount)
{
throw new Exception($"Vertex buffer read is in a weird state. vbOffset={vbOffset} vbVertexCount={vbVertexCount}");
}
}
for (var i = 0; i < vbArrays.Length; i++)
{
ProcessVertices(ref vbArrays[i], i);
}
// Loading vertices into materials...
foreach (var solidObjectMaterial in Materials)
{
var vertexStreamIndex = solidObjectMaterial.VertexStreamIndex;
if (solidObjectMaterial.Indices.Any())
{
var meshVertices = vbArrays[vertexStreamIndex];
var maxReferencedVertex = solidObjectMaterial.Indices.Max();
solidObjectMaterial.Vertices = new SolidMeshVertex[maxReferencedVertex + 1];
for (var j = 0; j <= maxReferencedVertex; j++)
{
solidObjectMaterial.Vertices[j] = meshVertices[j];
}
// Validate material indices
Debug.Assert(solidObjectMaterial.Indices.All(t => t < solidObjectMaterial.Vertices.Length));
}
else
{
solidObjectMaterial.Vertices = Array.Empty <SolidMeshVertex>();
}
}
// Clean up vertex buffers, which are no longer needed
VertexBuffers.Clear();
}
public bool AlreadyInCart(int id)
{
return(Materials.Any(m => m.Id == id));
}
