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)); }