public virtual RegisterResponseInfo Register(Guid clientId, string meshId, PeerNodeAddress address) { Guid registrationId = Guid.NewGuid(); DateTime expires = DateTime.UtcNow + this.RefreshInterval; RegistrationEntry entry = null; MeshEntry meshEntry = null; lock (this.ThisLock) { entry = new RegistrationEntry(clientId, registrationId, meshId, expires, address); meshEntry = this.GetMeshEntry(meshId); if (meshEntry.Service2EntryTable.ContainsKey(address.ServicePath)) { PeerExceptionHelper.ThrowInvalidOperation_DuplicatePeerRegistration(address.ServicePath); } LiteLock liteLock = null; try { LiteLock.Acquire(out liteLock, meshEntry.Gate, true); meshEntry.EntryTable.Add(registrationId, entry); meshEntry.EntryList.Add(entry); meshEntry.Service2EntryTable.Add(address.ServicePath, entry); } finally { LiteLock.Release(liteLock); } } return(new RegisterResponseInfo(registrationId, this.RefreshInterval)); }
public List <LODData> LodForName(string name) { if (MeshByName.ContainsKey(name)) { var meshEntry = MeshByName[name]; if (meshEntry.Lods != null) { ++meshEntry.ReferenceCount; return(meshEntry.Lods); } if (meshEntry.Loaded) { // TaskLoad() completed meshEntry.GenerateMeshes(db); return(null); //meshEntry.GenerateMeshes(); //++meshEntry.ReferenceCount; //return meshEntry.Lods; } // TaskLoad in progress or failed return(null); } var newEntry = new MeshEntry(); MeshByName[name] = newEntry; var token = newEntry.TaskLoadToken.Token; Task.Run(() => { newEntry.TaskLoad(name); }, token); return(null); }
/// <summary> /// Handle triangle count. /// </summary> /// <param name="obj"></param> /// <param name="msg"></param> /// <param name="packet"></param> /// <param name="reader"></param> /// <returns></returns> protected override Error PostHandleMessage(CreateMessage msg, PacketBuffer packet, BinaryReader reader, ShapeCache cache, int shapeIndex) { int vertexCount = reader.ReadInt32(); int indexCount = reader.ReadInt32(); MeshDrawType drawType = (MeshDrawType)reader.ReadByte(); RenderMesh mesh = new RenderMesh(drawType, vertexCount, indexCount); MeshEntry meshEntry = new MeshEntry { Mesh = mesh, CalculateNormals = (msg.Flags & (ushort)MeshShapeFlag.CalculateNormals) != 0, DrawScale = 0.0f }; if (packet.Header.VersionMajor == 0 && packet.Header.VersionMinor == 1) { // Legacy handling. meshEntry.DrawScale = 0.0f; } else { meshEntry.DrawScale = reader.ReadSingle(); } cache.SetShapeDataByIndex(shapeIndex, meshEntry); if (meshEntry.CalculateNormals) { _toCalculateNormals.Add(mesh); } return(base.PostHandleMessage(msg, packet, reader, cache, shapeIndex)); }
private void CleanupMeshEntry(MeshEntry meshEntry) { List <Guid> list = new List <Guid>(); if (this.opened) { LiteLock liteLock = null; try { LiteLock.Acquire(out liteLock, meshEntry.Gate, true); foreach (KeyValuePair <Guid, RegistrationEntry> pair in meshEntry.EntryTable) { if ((pair.Value.Expires <= DateTime.UtcNow) || (pair.Value.State == RegistrationState.Deleted)) { list.Add(pair.Key); meshEntry.EntryList.Remove(pair.Value); meshEntry.Service2EntryTable.Remove(pair.Value.Address.ServicePath); } } foreach (Guid guid in list) { meshEntry.EntryTable.Remove(guid); } } finally { LiteLock.Release(liteLock); } } }
public virtual void Unregister(UnregisterInfo unregisterInfo) { if (unregisterInfo == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("unregisterinfo", System.ServiceModel.SR.GetString("PeerNullRegistrationInfo")); } this.ThrowIfClosed("Unregister"); if ((!unregisterInfo.HasBody() || string.IsNullOrEmpty(unregisterInfo.MeshId)) || (unregisterInfo.RegistrationId == Guid.Empty)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("unregisterInfo", System.ServiceModel.SR.GetString("PeerInvalidMessageBody", new object[] { unregisterInfo })); } RegistrationEntry entry = null; MeshEntry meshEntry = this.GetMeshEntry(unregisterInfo.MeshId, false); LiteLock liteLock = null; try { LiteLock.Acquire(out liteLock, meshEntry.Gate, true); if (!meshEntry.EntryTable.TryGetValue(unregisterInfo.RegistrationId, out entry)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("unregisterInfo", System.ServiceModel.SR.GetString("PeerInvalidMessageBody", new object[] { unregisterInfo })); } meshEntry.EntryTable.Remove(unregisterInfo.RegistrationId); meshEntry.EntryList.Remove(entry); meshEntry.Service2EntryTable.Remove(entry.Address.ServicePath); entry.State = RegistrationState.Deleted; } finally { LiteLock.Release(liteLock); } }
//always call this from a readlock void CleanupMeshEntry(MeshEntry meshEntry) { List <Guid> remove = new List <Guid>(); if (!opened) { return; } LiteLock ll = null; try { LiteLock.Acquire(out ll, meshEntry.Gate, true); foreach (KeyValuePair <Guid, RegistrationEntry> item in meshEntry.EntryTable) { if ((item.Value.Expires <= DateTime.UtcNow) || (item.Value.State == RegistrationState.Deleted)) { remove.Add(item.Key); meshEntry.EntryList.Remove(item.Value); meshEntry.Service2EntryTable.Remove(item.Value.Address.ServicePath); } } foreach (Guid id in remove) { meshEntry.EntryTable.Remove(id); } } finally { LiteLock.Release(ll); } }
MeshEntry GetMeshEntry(string meshId, bool createIfNotExists) { MeshEntry meshEntry = null; LiteLock ll = null; try { LiteLock.Acquire(out ll, gate); if (!this.meshId2Entry.TryGetValue(meshId, out meshEntry) && createIfNotExists) { meshEntry = new MeshEntry(); try { ll.UpgradeToWriterLock(); meshId2Entry.Add(meshId, meshEntry); } finally { ll.DowngradeFromWriterLock(); } } } finally { LiteLock.Release(ll); } Fx.Assert(meshEntry != null || !createIfNotExists, "GetMeshEntry failed to get an entry!"); return(meshEntry); }
private void CleanupMeshEntry(MeshEntry meshEntry) { List<Guid> list = new List<Guid>(); if (this.opened) { LiteLock liteLock = null; try { LiteLock.Acquire(out liteLock, meshEntry.Gate, true); foreach (KeyValuePair<Guid, RegistrationEntry> pair in meshEntry.EntryTable) { if ((pair.Value.Expires <= DateTime.UtcNow) || (pair.Value.State == RegistrationState.Deleted)) { list.Add(pair.Key); meshEntry.EntryList.Remove(pair.Value); meshEntry.Service2EntryTable.Remove(pair.Value.Address.ServicePath); } } foreach (Guid guid in list) { meshEntry.EntryTable.Remove(guid); } } finally { LiteLock.Release(liteLock); } } }
private MeshEntry GetMeshEntry(string meshId, bool createIfNotExists) { MeshEntry entry = null; LiteLock liteLock = null; try { LiteLock.Acquire(out liteLock, this.gate); if (this.meshId2Entry.TryGetValue(meshId, out entry) || !createIfNotExists) { return(entry); } entry = new MeshEntry(); try { liteLock.UpgradeToWriterLock(); this.meshId2Entry.Add(meshId, entry); } finally { liteLock.DowngradeFromWriterLock(); } } finally { LiteLock.Release(liteLock); } return(entry); }
/// <summary> /// Calculate the featurevector of one mesh using all descriptor calculators of the featuremanager. /// </summary> /// <param name="entry">The mesh of which the featurevector should be calculated.</param> /// <returns>The featurevector.</returns> private FeatureVector CalculateVector(MeshEntry entry, bool replace = false) { // Check if we already ran the computations for this entry. if (features.TryGetValue(entry.Name, out FeatureVector found)) { // If we may not change the vector then just give the old one. if (!replace) { return(found); } // If we may change the vector then update the content and save that // in the database. FeatureVector expanded = ExpandVector(entry, found); features.Remove(entry.Name); features.Add(entry.Name, expanded); return(expanded); } else { // If we do not own it then create a new one to save and return. FeatureVector created = CreateVector(entry); features.Add(entry.Name, created); return(created); } }
public virtual RegisterResponseInfo Update(UpdateInfo updateInfo) { if (updateInfo == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("updateInfo", SR.GetString(SR.PeerNullRegistrationInfo)); } ThrowIfClosed("Update"); if (!updateInfo.HasBody() || String.IsNullOrEmpty(updateInfo.MeshId) || updateInfo.NodeAddress == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("updateInfo", SR.GetString(SR.PeerInvalidMessageBody, updateInfo)); } Guid registrationId = updateInfo.RegistrationId; RegistrationEntry entry; MeshEntry meshEntry = GetMeshEntry(updateInfo.MeshId); LiteLock ll = null; //handle cases when Update ----s with Register. if (updateInfo.RegistrationId == Guid.Empty || meshEntry == null) { return(Register(updateInfo.ClientId, updateInfo.MeshId, updateInfo.NodeAddress)); } // // preserve locking order between ThisLock and the LiteLock. lock (ThisLock) { try { LiteLock.Acquire(out ll, meshEntry.Gate); if (!meshEntry.EntryTable.TryGetValue(updateInfo.RegistrationId, out entry)) { try { // upgrade to writer lock ll.UpgradeToWriterLock(); return(Register(updateInfo.ClientId, updateInfo.MeshId, updateInfo.NodeAddress)); } finally { ll.DowngradeFromWriterLock(); } } lock (entry) { entry.Address = updateInfo.NodeAddress; entry.Expires = DateTime.UtcNow + this.RefreshInterval; } } finally { LiteLock.Release(ll); } } return(new RegisterResponseInfo(registrationId, RefreshInterval)); }
public static MeshData BoxData(int x, int y, int z, MeshData meshData, MeshEntry meshPrfb) { float bottom = 0.5f; float yVals = meshPrfb.ySize - bottom;// float xVals = meshPrfb.xSize / 2f; float zVals = meshPrfb.zSize / 2f; //List<float> deformations = new List<float>(8); //for(int i = 0; i < meshPrfb.deformPointCount; i++) //{ // //set a random entry to random dformation // SetRandomIndexValue(meshPrfb, deformations); //} //Trunk //North meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y - bottom + meshPrfb.yPos, z + zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos, z + zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos + meshPrfb.difLeftRightYTop, z + zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y - bottom + meshPrfb.yPos + meshPrfb.difLeftRightYBottom, z + zVals + meshPrfb.zPos)); meshData.AddQuadTriangles(); meshData.uv.AddRange(GetUVs.FaceUVs(meshPrfb.face)); //East meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y - bottom + meshPrfb.yPos, z - zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos, z - zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos, z + zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y - bottom + meshPrfb.yPos, z + zVals + meshPrfb.zPos)); meshData.AddQuadTriangles(); meshData.uv.AddRange(GetUVs.FaceUVs(meshPrfb.face)); //South meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y - bottom + meshPrfb.yPos + meshPrfb.difLeftRightYBottom, z - zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos + meshPrfb.difLeftRightYTop, z - zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos, z - zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y - bottom + meshPrfb.yPos, z - zVals + meshPrfb.zPos)); meshData.AddQuadTriangles(); meshData.uv.AddRange(GetUVs.FaceUVs(meshPrfb.face)); //West meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y - bottom + meshPrfb.yPos + meshPrfb.difLeftRightYBottom, z + zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos + meshPrfb.difLeftRightYTop, z + zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos + meshPrfb.difLeftRightYTop, z - zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y - bottom + meshPrfb.yPos + meshPrfb.difLeftRightYBottom, z - zVals + meshPrfb.zPos)); meshData.AddQuadTriangles(); meshData.uv.AddRange(GetUVs.FaceUVs(meshPrfb.face)); //Up meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos + meshPrfb.difLeftRightYTop, z + zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos, z + zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos, z - zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos + meshPrfb.difLeftRightYTop, z - zVals + meshPrfb.zPos)); meshData.AddQuadTriangles(); meshData.uv.AddRange(GetUVs.FaceUVs(meshPrfb.face)); return(meshData); }
public virtual ResolveResponseInfo Resolve(ResolveInfo resolveInfo) { if (resolveInfo == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("resolveInfo", System.ServiceModel.SR.GetString("PeerNullResolveInfo")); } this.ThrowIfClosed("Resolve"); if (!resolveInfo.HasBody()) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("resolveInfo", System.ServiceModel.SR.GetString("PeerInvalidMessageBody", new object[] { resolveInfo })); } int num = 0; int num2 = 0; int maxAddresses = resolveInfo.MaxAddresses; ResolveResponseInfo info = new ResolveResponseInfo(); List <PeerNodeAddress> list = new List <PeerNodeAddress>(); List <RegistrationEntry> entryList = null; MeshEntry meshEntry = this.GetMeshEntry(resolveInfo.MeshId, false); if (meshEntry != null) { LiteLock liteLock = null; try { LiteLock.Acquire(out liteLock, meshEntry.Gate); entryList = meshEntry.EntryList; if (entryList.Count <= maxAddresses) { foreach (RegistrationEntry entry3 in entryList) { list.Add(entry3.Address); } } else { Random random = new Random(); while (num < maxAddresses) { num2 = random.Next(entryList.Count); RegistrationEntry entry = entryList[num2]; PeerNodeAddress item = entry.Address; if (!list.Contains(item)) { list.Add(item); } num++; } } } finally { LiteLock.Release(liteLock); } } info.Addresses = list.ToArray(); return(info); }
/// <summary> /// Creates a new vector for the current entry to be added in the database. /// </summary> /// <param name="entry">The element whose <see cref="FeatureVector"/> /// should be created.</param> /// <returns>A <see cref="FeatureVector"/> containing the information /// for the provided mesh.</returns> private FeatureVector CreateVector(MeshEntry entry) { IList <IDescriptor> descriptors = new List <IDescriptor>(); IMesh mesh = entry.Mesh; // Cach the mesh hear to help LazyMesh a bit. foreach (DescriptorCalculator calculator in DescriptorCalculators) { descriptors.Add(calculator(mesh)); } return(new FeatureVector(descriptors.ToArray())); }
/// <summary> /// Expands an already existing vector with new information if /// new descriptors have been added since the last creation. /// </summary> /// <param name="entry">The element which will be used to calculate /// new features.</param> /// <param name="baseVector">The previous <see cref="FeatureVector"/> /// from this entry which should be enlarged with more information.</param> /// <returns>The new <see cref="FeatureVector"/> with all the descriptors.</returns> private FeatureVector ExpandVector(MeshEntry entry, FeatureVector baseVector) { FeatureVector newVector = CreateVector(entry); IEnumerable <IDescriptor> updates = ExceptWith(newVector.Descriptors, baseVector.Descriptors); IList <IDescriptor> descriptors = baseVector.Descriptors.ToList(); foreach (IDescriptor desc in updates) { descriptors.Add(desc); } return(new FeatureVector(descriptors.ToArray())); }
internal virtual void CleanupActivity(object state) { if (!opened) { return; } if (!isCleaning) { lock (ThisLock) { if (!isCleaning) { isCleaning = true; try { MeshEntry meshEntry = null; //acquire a write lock. from the reader/writer lock can we postpone until no contention? ICollection <string> keys = null; LiteLock ll = null; try { LiteLock.Acquire(out ll, gate); keys = meshId2Entry.Keys; } finally { LiteLock.Release(ll); } foreach (string meshId in keys) { meshEntry = GetMeshEntry(meshId); CleanupMeshEntry(meshEntry); } } finally { isCleaning = false; if (opened) { timer.Set(this.CleanupInterval); } } } } } }
public virtual RefreshResponseInfo Refresh(RefreshInfo refreshInfo) { if (refreshInfo == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("refreshInfo", SR.GetString(SR.PeerNullRefreshInfo)); } ThrowIfClosed("Refresh"); if (!refreshInfo.HasBody() || String.IsNullOrEmpty(refreshInfo.MeshId) || refreshInfo.RegistrationId == Guid.Empty) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("refreshInfo", SR.GetString(SR.PeerInvalidMessageBody, refreshInfo)); } RefreshResult result = RefreshResult.RegistrationNotFound; RegistrationEntry entry = null; MeshEntry meshEntry = GetMeshEntry(refreshInfo.MeshId, false); LiteLock ll = null; if (meshEntry != null) { try { LiteLock.Acquire(out ll, meshEntry.Gate); if (!meshEntry.EntryTable.TryGetValue(refreshInfo.RegistrationId, out entry)) { return(new RefreshResponseInfo(RefreshInterval, result)); } lock (entry) { if (entry.State == RegistrationState.OK) { entry.Expires = DateTime.UtcNow + RefreshInterval; result = RefreshResult.Success; } } } finally { LiteLock.Release(ll); } } return(new RefreshResponseInfo(RefreshInterval, result)); }
internal virtual void CleanupActivity(object state) { if (this.opened && !this.isCleaning) { lock (this.ThisLock) { if (!this.isCleaning) { this.isCleaning = true; try { MeshEntry meshEntry = null; ICollection <string> keys = null; LiteLock liteLock = null; try { LiteLock.Acquire(out liteLock, this.gate); keys = this.meshId2Entry.Keys; } finally { LiteLock.Release(liteLock); } foreach (string str in keys) { meshEntry = this.GetMeshEntry(str); this.CleanupMeshEntry(meshEntry); } } finally { this.isCleaning = false; if (this.opened) { this.timer.Set(this.CleanupInterval); } } } } } }
public virtual RefreshResponseInfo Refresh(RefreshInfo refreshInfo) { if (refreshInfo == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("refreshInfo", System.ServiceModel.SR.GetString("PeerNullRefreshInfo")); } this.ThrowIfClosed("Refresh"); if ((!refreshInfo.HasBody() || string.IsNullOrEmpty(refreshInfo.MeshId)) || (refreshInfo.RegistrationId == Guid.Empty)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("refreshInfo", System.ServiceModel.SR.GetString("PeerInvalidMessageBody", new object[] { refreshInfo })); } RefreshResult registrationNotFound = RefreshResult.RegistrationNotFound; RegistrationEntry entry = null; MeshEntry meshEntry = this.GetMeshEntry(refreshInfo.MeshId, false); LiteLock liteLock = null; if (meshEntry != null) { try { LiteLock.Acquire(out liteLock, meshEntry.Gate); if (!meshEntry.EntryTable.TryGetValue(refreshInfo.RegistrationId, out entry)) { return(new RefreshResponseInfo(this.RefreshInterval, registrationNotFound)); } lock (entry) { if (entry.State == RegistrationState.OK) { entry.Expires = DateTime.UtcNow + this.RefreshInterval; registrationNotFound = RefreshResult.Success; } } } finally { LiteLock.Release(liteLock); } } return(new RefreshResponseInfo(this.RefreshInterval, registrationNotFound)); }
/// <summary> /// Creates a mesh shape for serialising <paramref name="shapeComponent"/> and its associated mesh data. /// </summary> /// <param name="shapeComponent">The component to create a shape for.</param> /// <returns>A shape instance suitable for configuring to generate serialisation messages.</returns> protected override Shapes.Shape CreateSerialisationShape(ShapeCache cache, int shapeIndex, CreateMessage shapeData) { MeshEntry meshEntry = cache.GetShapeDataByIndex <MeshEntry>(shapeIndex); RenderMesh mesh = meshEntry.Mesh; Debug.Log($"serialise mesh. Normals? {mesh.HasNormals}"); Shapes.MeshShape meshShape = new Shapes.MeshShape(meshEntry.Mesh.DrawType, Maths.Vector3Ext.FromUnity(mesh.Vertices), mesh.Indices, shapeData.ObjectID, shapeData.Category); if (mesh.HasNormals && !meshEntry.CalculateNormals) { // We have normals which were not locally calculated. meshShape.Normals = Tes.Maths.Vector3Ext.FromUnity(mesh.Normals); } meshShape.SetAttributes(shapeData.Attributes); return(meshShape); }
public virtual RegisterResponseInfo Register(Guid clientId, string meshId, PeerNodeAddress address) { Guid registrationId = Guid.NewGuid(); DateTime expiry = DateTime.UtcNow + RefreshInterval; RegistrationEntry entry = null; MeshEntry meshEntry = null; lock (ThisLock) { entry = new RegistrationEntry(clientId, registrationId, meshId, expiry, address); meshEntry = GetMeshEntry(meshId); if (meshEntry.Service2EntryTable.ContainsKey(address.ServicePath)) { PeerExceptionHelper.ThrowInvalidOperation_DuplicatePeerRegistration(address.ServicePath); } LiteLock ll = null; try { // meshEntry.gate can be held by this thread for write if this is coming from update // else MUST not be held at all. if (!meshEntry.Gate.IsWriterLockHeld) { LiteLock.Acquire(out ll, meshEntry.Gate, true); } meshEntry.EntryTable.Add(registrationId, entry); meshEntry.EntryList.Add(entry); meshEntry.Service2EntryTable.Add(address.ServicePath, entry); } finally { if (ll != null) { LiteLock.Release(ll); } } } return(new RegisterResponseInfo(registrationId, RefreshInterval)); }
public virtual RegisterResponseInfo Update(UpdateInfo updateInfo) { if (updateInfo == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("updateInfo", System.ServiceModel.SR.GetString("PeerNullRegistrationInfo")); } this.ThrowIfClosed("Update"); if ((!updateInfo.HasBody() || string.IsNullOrEmpty(updateInfo.MeshId)) || (updateInfo.NodeAddress == null)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("updateInfo", System.ServiceModel.SR.GetString("PeerInvalidMessageBody", new object[] { updateInfo })); } Guid registrationId = updateInfo.RegistrationId; MeshEntry meshEntry = this.GetMeshEntry(updateInfo.MeshId); LiteLock liteLock = null; if ((updateInfo.RegistrationId == Guid.Empty) || (meshEntry == null)) { return(this.Register(updateInfo.ClientId, updateInfo.MeshId, updateInfo.NodeAddress)); } try { RegistrationEntry entry; LiteLock.Acquire(out liteLock, meshEntry.Gate); if (!meshEntry.EntryTable.TryGetValue(updateInfo.RegistrationId, out entry)) { return(this.Register(updateInfo.ClientId, updateInfo.MeshId, updateInfo.NodeAddress)); } lock (entry) { entry.Address = updateInfo.NodeAddress; entry.Expires = DateTime.UtcNow + this.RefreshInterval; } } finally { LiteLock.Release(liteLock); } return(new RegisterResponseInfo(registrationId, this.RefreshInterval)); }
public virtual void Unregister(UnregisterInfo unregisterInfo) { if (unregisterInfo == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("unregisterinfo", SR.GetString(SR.PeerNullRegistrationInfo)); } ThrowIfClosed("Unregister"); if (!unregisterInfo.HasBody() || String.IsNullOrEmpty(unregisterInfo.MeshId) || unregisterInfo.RegistrationId == Guid.Empty) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("unregisterInfo", SR.GetString(SR.PeerInvalidMessageBody, unregisterInfo)); } RegistrationEntry registration = null; MeshEntry meshEntry = GetMeshEntry(unregisterInfo.MeshId, false); //there could be a ---- that two different threads could be working on the same entry //we wont optimize for that case. LiteLock ll = null; try { LiteLock.Acquire(out ll, meshEntry.Gate, true); if (!meshEntry.EntryTable.TryGetValue(unregisterInfo.RegistrationId, out registration)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("unregisterInfo", SR.GetString(SR.PeerInvalidMessageBody, unregisterInfo)); } meshEntry.EntryTable.Remove(unregisterInfo.RegistrationId); meshEntry.EntryList.Remove(registration); meshEntry.Service2EntryTable.Remove(registration.Address.ServicePath); registration.State = RegistrationState.Deleted; } finally { LiteLock.Release(ll); } }
protected void RenderObject(CameraContext cameraContext, ShapeCache cache, int shapeIndex) { CreateMessage shape = cache.GetShapeByIndex(shapeIndex); if (CategoriesState != null && !CategoriesState.IsActive(shape.Category)) { return; } MeshEntry meshEntry = cache.GetShapeDataByIndex <MeshEntry>(shapeIndex); Matrix4x4 transform = cache.GetShapeTransformByIndex(shapeIndex); // TODO: (KS) select command buffer for transparent rendering. CommandBuffer renderQueue = cameraContext.OpaqueBuffer; Material material = meshEntry.Material; RenderMesh mesh = meshEntry.Mesh; if (material == null || mesh == null) { return; } Matrix4x4 modelWorld = cameraContext.TesSceneToWorldTransform * transform; // Transform and cull bounds // FIXME: (KS) this really isn't how culling should be performed. Bounds bounds = GeometryUtility.CalculateBounds(new Vector3[] { mesh.MinBounds, mesh.MaxBounds }, modelWorld); if (!GeometryUtility.TestPlanesAABB(cameraContext.CameraFrustumPlanes, bounds)) { return; } if (mesh.HasColours) { material.SetBuffer("_Colours", mesh.ColoursBuffer); } if (mesh.HasNormals) { material.SetBuffer("_Normals", mesh.NormalsBuffer); } // if (mesh.HasUVs) // { // material.SetBuffer("uvs", mesh.UvsBuffer); // } if (material.HasProperty("_Color")) { material.SetColor("_Color", Maths.ColourExt.ToUnity(new Maths.Colour(shape.Attributes.Colour))); } if (material.HasProperty("_Tint")) { material.SetColor("_Tint", Maths.ColourExt.ToUnity(mesh.Tint)); } if (material.HasProperty("_BackColour")) { material.SetColor("_BackColour", Maths.ColourExt.ToUnity(new Maths.Colour(shape.Attributes.Colour))); } // TODO: (KS) Need to derive this from the shape properties. if (mesh.Topology == MeshTopology.Points) { // Set min/max shader values. if (material.HasProperty("_BoundsMin")) { material.SetVector("_BoundsMin", mesh.MinBounds); } if (material.HasProperty("_BoundsMax")) { material.SetVector("_BoundsMax", mesh.MaxBounds); } float pointScale = (meshEntry.DrawScale > 0) ? meshEntry.DrawScale : 1.0f; material.SetFloat("_PointSize", GlobalSettings.PointSize * pointScale); // Colour by height if we have a zero colour value. if (shape.Attributes.Colour == 0) { material.SetColor("_Color", Color.white); material.SetColor("_BackColour", Color.white); switch (CoordinateFrameUtil.AxisIndex(ServerInfo.CoordinateFrame, 2)) { case 0: material.EnableKeyword("WITH_COLOURS_RANGE_X"); break; case 1: material.EnableKeyword("WITH_COLOURS_RANGE_Y"); break; default: case 2: material.EnableKeyword("WITH_COLOURS_RANGE_Z"); break; } } } // Bind vertices and draw. material.SetBuffer("_Vertices", mesh.VertexBuffer); if (mesh.IndexBuffer != null) { renderQueue.DrawProcedural(mesh.IndexBuffer, modelWorld, material, 0, mesh.Topology, mesh.IndexCount); } else { renderQueue.DrawProcedural(modelWorld, material, 0, mesh.Topology, mesh.VertexCount); } }
public virtual ResolveResponseInfo Resolve(ResolveInfo resolveInfo) { if (resolveInfo == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("resolveInfo", SR.GetString(SR.PeerNullResolveInfo)); } ThrowIfClosed("Resolve"); if (!resolveInfo.HasBody()) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("resolveInfo", SR.GetString(SR.PeerInvalidMessageBody, resolveInfo)); } int currentCount = 0; int index = 0; int maxEntries = resolveInfo.MaxAddresses; ResolveResponseInfo response = new ResolveResponseInfo(); List <PeerNodeAddress> results = new List <PeerNodeAddress>(); List <RegistrationEntry> entries = null; PeerNodeAddress address; RegistrationEntry entry; MeshEntry meshEntry = GetMeshEntry(resolveInfo.MeshId, false); if (meshEntry != null) { LiteLock ll = null; try { LiteLock.Acquire(out ll, meshEntry.Gate); entries = meshEntry.EntryList; if (entries.Count <= maxEntries) { foreach (RegistrationEntry e in entries) { results.Add(e.Address); } } else { Random random = new Random(); while (currentCount < maxEntries) { index = random.Next(entries.Count); entry = entries[index]; Fx.Assert(entry.State == RegistrationState.OK, "A deleted registration is still around!"); address = entry.Address; if (!results.Contains(address)) { results.Add(address); } currentCount++; } } } finally { LiteLock.Release(ll); } } response.Addresses = results.ToArray(); return(response); }
public void GenerateObjSet(string filePath, Model stgpv, ObjectDatabase objdb, TextureDatabase texturedb, StageDatabase staged, string acpath, divamodgen divamods, bool doProcess = true, bool debug = false) { /* * var stgpv = new Model(); * var textures = new MikuMikuLibrary.Textures.TextureSet(); * var texdb = new TextureDatabase(); * * using (var farcArchive = BinaryFile.Load<FarcArchive>(filePath)) * using (var entryStream = farcArchive.Open(farcArchive.Entries.Where(c => c.Contains("txi")).First(), EntryStreamMode.MemoryStream)) * texdb.Load(entryStream); * * if (debug) * { * string farcpath = acpath + "\\rom\\objset\\" + Path.GetFileNameWithoutExtension(filePath).Replace("stgpv0", "stgpv8") + ".farc"; * * using (var farcArchive = BinaryFile.Load<FarcArchive>(farcpath)) * using (var entryStream = farcArchive.Open(farcArchive.Entries.Where(c => c.Contains("tex")).First(), EntryStreamMode.MemoryStream)) * textures.Load(entryStream); * * } * else * { * using (var farcArchive = BinaryFile.Load<FarcArchive>(filePath)) * using (var entryStream = farcArchive.Open(farcArchive.Entries.Where(c => c.Contains("txd")).First(), EntryStreamMode.MemoryStream)) * textures.Load(entryStream); * * using (var farcArchive = BinaryFile.Load<FarcArchive>(filePath)) * using (var entryStream = farcArchive.Open(farcArchive.Entries.First(), EntryStreamMode.MemoryStream)) * stgpv.Load(entryStream, textures, texdb); * } * */ if (Path.GetFileNameWithoutExtension(filePath).Contains("effpv")) { filePath = Path.GetDirectoryName(filePath) + "\\" + Path.GetFileNameWithoutExtension(filePath).Replace("effpv", "stgpv") + "hrc2.farc"; } var texdb = new TextureDatabase(); //using (var farcArchive = BinaryFile.Load<FarcArchive>(filePath)) //using (var entryStream = farcArchive.Open(farcArchive.Entries.Where(c => c.Contains("txi")).First(), EntryStreamMode.MemoryStream)) // texdb.Load(entryStream); var objentry = new ObjectEntry(); objentry.ArchiveFileName = Path.GetFileName(filePath).Replace("stgpv0", "stgpv8"); objentry.FileName = Path.GetFileNameWithoutExtension(filePath).Replace("stgpv0", "stgpv8") + "_obj.bin"; objentry.Id = FindUnusedID(objdb); objentry.Name = Path.GetFileNameWithoutExtension(filePath).Replace("stgpv0", "stgpv8").ToUpper(); objentry.TextureFileName = Path.GetFileNameWithoutExtension(filePath).Replace("stgpv0", "stgpv8") + "_tex.bin"; int ground_id = -1; ushort counter = 1; foreach (var meshes in stgpv.Meshes) { meshes.SubMeshes.RemoveAll(x => x.Vertices == null || x.Vertices.Length == 0); meshes.Name = meshes.Name.Replace("STGPV0", "STGPV8"); meshes.Name = meshes.Name.Replace("EFFPV", "STGPV"); if (Path.GetFileName(filePath).Contains("hrc")) { int pvid = int.Parse(Path.GetFileName(filePath).Substring(5, 3)); if (pvid < 200) { pvid = pvid + 800; } { var check2 = divamods.Divamods.Where(c => c.pvid == pvid).FirstOrDefault(); if (check2 == null) { divamods.Divamods.Add(new pdaconversion.divamods(pvid)); Logs.WriteLine("objset: Created new PV at id " + pvid); check2 = divamods.Divamods.Where(c => c.pvid == pvid).First(); } check2.item_pv.Add(meshes.Name); Logs.WriteLine("objset: Added item_pv for PV at id " + pvid + "," + meshes.Name); } if (pvid >= 800) { var check2 = divamods.Divamods.Where(c => c.pvid == (pvid - 100)).FirstOrDefault(); if (check2 == null) { divamods.Divamods.Add(new pdaconversion.divamods(pvid - 100)); Logs.WriteLine("objset: Created new PV at id " + (pvid - 100)); check2 = divamods.Divamods.Where(c => c.pvid == (pvid - 100)).First(); } check2.item_pv.Add(meshes.Name); Logs.WriteLine("objset: Added item_pv for PV at id " + (pvid - 100) + "," + meshes.Name); } } var meshentry = new MeshEntry(); meshes.Id = counter; meshentry.Id = (ushort)meshes.Id; meshentry.Name = meshes.Name; if (meshes.Name.Contains("GND")) { ground_id = meshes.Id; } objentry.Meshes.Add(meshentry); if (doProcess) { if (!debug) { /* * foreach (var submeshes in meshes.SubMeshes) * { * foreach (var indexTable in submeshes.IndexTables) * { * ushort[] triangleStrip = Stripifier.Stripify(indexTable.Indices); * if (triangleStrip != null) * { * indexTable.PrimitiveType = PrimitiveType.TriangleStrip; * indexTable.Indices = triangleStrip; * } * } * } */ } //foreach (var textures in M) foreach (var material in meshes.Materials) { if ((Path.GetFileName(filePath).Contains("hrc2")) || (Path.GetFileName(filePath).Contains("hrc"))) { material.Shader = "ITEM"; material.IsAlphaEnabled = false; //material.Field00 = 0x00000001; //material.Field02 = 0x00000A80; //material.Diffuse.Field00 = 0x00000000; //material.Diffuse.Field01 = 0x016400E1; //material.Diffuse.Field02 = 0x000000F1; MikuMikuLibrary.Misc.Color asdf = new MikuMikuLibrary.Misc.Color(0, 0, 0, 0); material.SpecularColor = asdf; //material.AmbientColor = asdf; //material.EmissionColor = asdf; //material.SpecularColor = asdf; //material.Shininess = 1; //material.Diffuse.Field00 = 0x00000000; //material.Diffuse.Field01 = 0x002400E0; //material.Diffuse.Field02 = 0x000000F1; if (material.Ambient.TextureId == 1509989155) { material.Ambient.TextureId = -1; } if (material.Normal.TextureId == 1509989155) { material.Normal.TextureId = -1; } if (material.Specular.TextureId == 1509989155) { material.Specular.TextureId = -1; material.SpecularColor = asdf; } //else { material.Field00 = 0x0000002D; } /* * * // this blacken the screen on STAGE SHADER * material.Specular.Field01 = 0x002418C3; * material.Specular.Field02 = 0x000000F3; * material.Specular.Field05 = 1; * material.Specular.Field06 = 1; * material.Specular.Field11 = 1; * material.Specular.Field16 = 1; * material.Specular.Field21 = 1; * * * material.Specular.TextureId = -1; * material.Specular.Field01 = 0x00000000; * material.Specular.Field02 = 0x000000F0; * material.Specular.Field05 = 1; * material.Specular.Field06 = 0; * material.Specular.Field11 = 0; * material.Specular.Field16 = 0; * material.Specular.Field21 = 0; * * material.Reflection.TextureId = -1; * material.Reflection.Field01 = 0x00000000; * material.Reflection.Field02 = 0x000000F0; * material.Reflection.Field05 = 1; * material.Reflection.Field06 = 0; * material.Reflection.Field11 = 0; * material.Reflection.Field16 = 0; * material.Reflection.Field21 = 0; */ if (material.Reflection.TextureId == 1509989155) { material.Reflection.TextureId = -1; } if (material.ToonCurve.TextureId == 1509989155) { material.ToonCurve.TextureId = -1; } if (material.SpecularPower.TextureId == 1509989155) { material.SpecularPower.TextureId = -1; } if (material.Texture08.TextureId == 1509989155) { material.Texture08.TextureId = -1; } } else { material.Shader = "BLINN"; //material.Field00 = 0x0000000D; //material.Field02 = 0x00000A80; MikuMikuLibrary.Misc.Color asdf = new MikuMikuLibrary.Misc.Color(0, 0, 0, 0); //material.AmbientColor = asdf; //material.EmissionColor = asdf; //material.Shininess = 1; //material.Diffuse.Field00 = 0x00000230; //material.Diffuse.Field02 = 0x002418C3; if (material.Ambient.TextureId == 1509989155) { material.Ambient.TextureId = -1; } if (material.Normal.TextureId == 1509989155) { material.Normal.TextureId = -1; } if (material.Specular.TextureId == 1509989155) { material.Specular.TextureId = -1; material.SpecularColor = asdf; } //else { material.Field00 = 0x0000002D; } /* * * // this blacken the screen on STAGE SHADER * material.Specular.Field01 = 0x002418C3; * material.Specular.Field02 = 0x000000F3; * material.Specular.Field05 = 1; * material.Specular.Field06 = 1; * material.Specular.Field11 = 1; * material.Specular.Field16 = 1; * material.Specular.Field21 = 1; * */ /* * material.Specular.TextureId = -1; * material.Specular.Field01 = 0x00000000; * material.Specular.Field02 = 0x000000F0; * material.Specular.Field05 = 5; * material.Specular.Field06 = 0; * material.Specular.Field11 = 0; * material.Specular.Field16 = 0; * material.Specular.Field21 = 0; * * * material.Normal.Field01 = 0x00000000; * material.Normal.Field02 = 0x000000F0; * material.Normal.Field05 = 5; * material.Normal.Field06 = 0; * material.Normal.Field11 = 0; * material.Normal.Field16 = 0; * material.Normal.Field21 = 0; * * * material.ToonCurve.TextureId = -1; * material.ToonCurve.Field01 = 0x00000000; * material.ToonCurve.Field02 = 0x000000F0; * material.ToonCurve.Field05 = 5; * material.ToonCurve.Field06 = 0; * material.ToonCurve.Field11 = 0; * material.ToonCurve.Field16 = 0; * material.ToonCurve.Field21 = 0; */ if (material.Reflection.TextureId == 1509989155) { material.Reflection.TextureId = -1; } if (material.ToonCurve.TextureId == 1509989155) { material.ToonCurve.TextureId = -1; } if (material.SpecularPower.TextureId == 1509989155) { material.SpecularPower.TextureId = -1; } if (material.Texture08.TextureId == 1509989155) { material.Texture08.TextureId = -1; } } } } counter++; } stgpv.TextureSet.Format = BinaryFormat.DT; stgpv.Format = BinaryFormat.DT; if (doProcess) { stgpv.Save("temp\\" + Path.GetFileNameWithoutExtension(filePath) + "_obj.bin", null, texturedb, null); } objdb.Objects.Add(objentry); if (Path.GetFileNameWithoutExtension(filePath).Count() == 8) { StageEntry stage = new StageEntry(); stage.Id = FindUnusedID(staged); stage.Name = Path.GetFileNameWithoutExtension(filePath).Replace("stgpv0", "stgpv8").ToUpper(); stage.ObjectGroundId = (short)ground_id; stage.ObjectGroundIdFlag = (short)objentry.Id; stage.ObjectId3 = -1; stage.ObjectIdFlag3 = -1; stage.ObjectId5 = -1; stage.ObjectIdFlag5 = -1; stage.ObjectId7 = -1; stage.ObjectIdFlag7 = -1; stage.RingRectangleX = -8; stage.RingRectangleY = -8; stage.RingRectangleWidth = 16; stage.RingRectangleHeight = 16; stage.RingRingHeight = 0; stage.RingOutHeight = -1000; stage.Field00 = 1; stage.Field11 = -1; stage.Field02 = -1; stage.LensFlareScaleX = -1; stage.LensFlareScaleY = -1; stage.LensFlareScaleZ = -1; stage.ObjectSkyId = -1; stage.ObjectSkyIdFlag = -1; stage.ObjectReflectId = -1; stage.ObjectReflectIdFlag = -1; stage.CollisionFilePath = @"rom/STGTST_COLI.000.bin"; stage.ObjectId1 = (short)objentry.Id; stage.StageEffect1 = StageEntry.StageEffect.Empty; stage.Auth3dName = "EFF" + stage.Name; staged.Stages.Add(stage); } if (doProcess) { var newfarc = new FarcArchive(); newfarc.Add(Path.GetFileNameWithoutExtension(filePath).Replace("stgpv0", "stgpv8") + "_obj.bin", "temp\\" + Path.GetFileNameWithoutExtension(filePath) + "_obj.bin"); newfarc.Add(Path.GetFileNameWithoutExtension(filePath).Replace("stgpv0", "stgpv8") + "_tex.bin", "temp\\" + Path.GetFileNameWithoutExtension(filePath) + "_tex.bin"); newfarc.Alignment = 16; newfarc.IsCompressed = false; newfarc.Save(acpath + "\\rom\\objset\\" + Path.GetFileNameWithoutExtension(filePath).Replace("stgpv0", "stgpv8") + ".farc"); } }
/// <summary> /// Release the mesh resources of <paramref name="obj"/>. /// </summary> /// <param name="obj"></param> void ResetObject(ShapeCache cache, int shapeIndex) { MeshEntry meshEntry = cache.GetShapeDataByIndex <MeshEntry>(shapeIndex); meshEntry.Mesh.ReleaseBuffers(); }
//always call this from a readlock void CleanupMeshEntry(MeshEntry meshEntry) { List<Guid> remove = new List<Guid>(); if (!opened) return; LiteLock ll = null; try { LiteLock.Acquire(out ll, meshEntry.Gate, true); foreach (KeyValuePair<Guid, RegistrationEntry> item in meshEntry.EntryTable) { if ((item.Value.Expires <= DateTime.UtcNow) || (item.Value.State == RegistrationState.Deleted)) { remove.Add(item.Key); meshEntry.EntryList.Remove(item.Value); meshEntry.Service2EntryTable.Remove(item.Value.Address.ServicePath); } } foreach (Guid id in remove) { meshEntry.EntryTable.Remove(id); } } finally { LiteLock.Release(ll); } }
public static MeshData BoxData(int x, int y, int z, MeshData meshData, MeshEntry meshPrfb, Cube.Type optionalFace) { float bottom = 0.5f; float yVals = meshPrfb.ySize - bottom;// float xVals = meshPrfb.xSize / 2f; float zVals = meshPrfb.zSize / 2f; //Trunk //North meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y - bottom + meshPrfb.yPos, z + zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos, z + zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos + meshPrfb.difLeftRightYTop, z + zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y - bottom + meshPrfb.yPos + meshPrfb.difLeftRightYBottom, z + zVals + meshPrfb.zPos)); meshData.AddQuadTriangles(); if (meshPrfb.face == Cube.Type.None) { meshData.uv.AddRange(GetUVs.FaceUVs(optionalFace)); } else { meshData.uv.AddRange(GetUVs.FaceUVs(meshPrfb.face)); } //East meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y - bottom + meshPrfb.yPos, z - zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos, z - zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos, z + zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y - bottom + meshPrfb.yPos, z + zVals + meshPrfb.zPos)); meshData.AddQuadTriangles(); if (meshPrfb.face == Cube.Type.None) { meshData.uv.AddRange(GetUVs.FaceUVs(optionalFace)); } else { meshData.uv.AddRange(GetUVs.FaceUVs(meshPrfb.face)); } //South meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y - bottom + meshPrfb.yPos + meshPrfb.difLeftRightYBottom, z - zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos + meshPrfb.difLeftRightYTop, z - zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos, z - zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y - bottom + meshPrfb.yPos, z - zVals + meshPrfb.zPos)); meshData.AddQuadTriangles(); if (meshPrfb.face == Cube.Type.None) { meshData.uv.AddRange(GetUVs.FaceUVs(optionalFace)); } else { meshData.uv.AddRange(GetUVs.FaceUVs(meshPrfb.face)); } //West meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y - bottom + meshPrfb.yPos + meshPrfb.difLeftRightYBottom, z + zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos + meshPrfb.difLeftRightYTop, z + zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos + meshPrfb.difLeftRightYTop, z - zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y - bottom + meshPrfb.yPos + meshPrfb.difLeftRightYBottom, z - zVals + meshPrfb.zPos)); meshData.AddQuadTriangles(); if (meshPrfb.face == Cube.Type.None) { meshData.uv.AddRange(GetUVs.FaceUVs(optionalFace)); } else { meshData.uv.AddRange(GetUVs.FaceUVs(meshPrfb.face)); } //Up meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos + meshPrfb.difLeftRightYTop, z + zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos, z + zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x + xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos, z - zVals + meshPrfb.zPos)); meshData.AddVertex(new Vector3(x - xVals + meshPrfb.xPos, y + yVals + meshPrfb.yPos + meshPrfb.difLeftRightYTop, z - zVals + meshPrfb.zPos)); meshData.AddQuadTriangles(); if (meshPrfb.face == Cube.Type.None) { meshData.uv.AddRange(GetUVs.FaceUVs(optionalFace)); } else { meshData.uv.AddRange(GetUVs.FaceUVs(meshPrfb.face)); } return(meshData); }
private MeshEntry GetMeshEntry(string meshId, bool createIfNotExists) { MeshEntry entry = null; LiteLock liteLock = null; try { LiteLock.Acquire(out liteLock, this.gate); if (this.meshId2Entry.TryGetValue(meshId, out entry) || !createIfNotExists) { return entry; } entry = new MeshEntry(); try { liteLock.UpgradeToWriterLock(); this.meshId2Entry.Add(meshId, entry); } finally { liteLock.DowngradeFromWriterLock(); } } finally { LiteLock.Release(liteLock); } return entry; }
/// <summary> /// Overridden to handle triangle data in the <paramref name="msg"/> /// </summary> /// <param name="msg"></param> /// <param name="packet"></param> /// <param name="reader"></param> /// <returns></returns> protected override Error HandleMessage(DataMessage msg, PacketBuffer packet, BinaryReader reader) { ShapeCache cache = (msg.ObjectID == 0) ? _transientCache : _shapeCache; int shapeIndex = (msg.ObjectID == 0) ? _lastTransientIndex : cache.GetShapeIndex(msg.ObjectID); if (shapeIndex < 0) { return(new Error(ErrorCode.InvalidObjectID, msg.ObjectID)); } // Naive support for multiple packets. Assume: // - In order. MeshEntry meshEntry = cache.GetShapeDataByIndex <MeshEntry>(shapeIndex); // Well, this is confusing indirection... int readComponent = MeshShape.ReadDataComponentDeferred( reader, (uint)meshEntry.Mesh.VertexCount, (uint)meshEntry.Mesh.IndexCount, // Vertex handler. new MeshShape.ComponentBlockReader((MeshShape.SendDataType dataType, BinaryReader reader2, uint offset, uint count) => { return(ReadMeshVector3Data(reader2, offset, count, (Vector3[] buffer, int writeOffset, int writeCount) => { meshEntry.Mesh.SetVertices(buffer, 0, writeOffset, writeCount, true); })); }), // Index handler new MeshShape.ComponentBlockReader((MeshShape.SendDataType dataType, BinaryReader reader2, uint offset, uint count) => { return(ReadIndexComponent(reader2, offset, count, meshEntry.Mesh)); }), // Normals handler. new MeshShape.ComponentBlockReader((MeshShape.SendDataType dataType, BinaryReader reader2, uint offset, uint count) => { return(ReadMeshVector3Data(reader2, offset, count, (Vector3[] buffer, int writeOffset, int writeCount) => { if (dataType == MeshShape.SendDataType.UniformNormal) { // Only one normal for the whole mesh. // Fill the buffer and write in chunks. for (int i = 1; i < buffer.Length; ++i) { buffer[i] = buffer[0]; } int localOffset = 0; for (int i = 0; i < meshEntry.Mesh.VertexCount; i += buffer.Length) { int blockCount = Math.Min(buffer.Length, meshEntry.Mesh.VertexCount - localOffset); meshEntry.Mesh.SetNormals(buffer, 0, localOffset, blockCount); writeOffset += blockCount; } } else { meshEntry.Mesh.SetNormals(buffer, 0, writeOffset, writeCount); } })); }), // Colours handler. new MeshShape.ComponentBlockReader((MeshShape.SendDataType dataType, BinaryReader reader2, uint offset, uint count) => { return(ReadColourComponent(reader2, offset, count, meshEntry.Mesh)); }) ); if (readComponent == -1) { return(new Error(ErrorCode.MalformedMessage, DataMessage.MessageID)); } if (readComponent == (int)(MeshShape.SendDataType.Vertices | MeshShape.SendDataType.End)) { // Finalise the material. meshEntry.Material = CreateMaterial(cache.GetShapeByIndex(shapeIndex), meshEntry); cache.SetShapeDataByIndex(shapeIndex, meshEntry); } return(new Error()); }
MeshEntry GetMeshEntry(string meshId, bool createIfNotExists) { MeshEntry meshEntry = null; LiteLock ll = null; try { LiteLock.Acquire(out ll, gate); if (!this.meshId2Entry.TryGetValue(meshId, out meshEntry) && createIfNotExists) { meshEntry = new MeshEntry(); try { ll.UpgradeToWriterLock(); meshId2Entry.Add(meshId, meshEntry); } finally { ll.DowngradeFromWriterLock(); } } } finally { LiteLock.Release(ll); } Fx.Assert(meshEntry != null || !createIfNotExists, "GetMeshEntry failed to get an entry!"); return meshEntry; }
public void LoadMesh(Mesh mesh, Matrix4x4 transform) { UnloadMesh(mesh); var textureCoords = mesh.TextureCoordinateChannelCount > 0 ? mesh.TextureCoordinateChannels[0].Select(uv => uv.AsUvPoint()) : null; var triangleIndices = new List<int>(mesh.FaceCount * 4); foreach (var face in mesh.Faces) { triangleIndices.Add(face.Indices[0]); triangleIndices.Add(face.Indices[1]); triangleIndices.Add(face.Indices[2]); if (face.IndexCount == 4) { triangleIndices.Add(face.Indices[0]); triangleIndices.Add(face.Indices[2]); triangleIndices.Add(face.Indices[3]); } if (face.IndexCount > 4) { Debug.WriteLine($"Found {face.IndexCount}gon, only generating quad"); } } var geometry = new MeshGeometry3D { Positions = new Point3DCollection( mesh.Vertices.Select(v => new Point3D(v.X, v.Y, v.Z))), Normals = new Vector3DCollection( mesh.Normals.Select(n => new Vector3D(n.X, n.Y, n.Z))), TriangleIndices = new Int32Collection(triangleIndices), TextureCoordinates = textureCoords != null ? new PointCollection(textureCoords) : null }; var diffuse = _textureProvider.GetTexture(mesh, TextureType.Diffuse); // the ViewPortUnits is very important, or the brush will map MaxU x MaxV to 1 x 1 // see https://books.google.no/books?id=ubgRAAAAQBAJ&pg=PA582&lpg=PA582 // TileMode also seems necessary var brush = diffuse != null ? new ImageBrush(diffuse) { ViewportUnits = BrushMappingMode.Absolute, TileMode = TileMode.Tile } : (Brush) Brushes.Pink; // because reasons? transform = Matrix4x4.Transpose(transform); var geometryModel = new GeometryModel3D { Material = new MaterialGroup { Children = new MaterialCollection { new DiffuseMaterial(brush), } }, Geometry = geometry, }; var group = new Model3DGroup() { Transform = transform.ToTransform3D(), }; group.Children.Add(geometryModel); _meshModelGroup.Children.Add(group); var (wireFrame, wireFrameGeometry) = CreateWireFrame(mesh); wireFrame.Transform = transform.ToTransform3D(); _wireFrameModelGroup.Children.Add(wireFrame); _meshes[mesh] = new MeshEntry(group, wireFrame, geometry, wireFrameGeometry); }
public override void MarkDirty(Box box) { if (this.Map.main.EditorEnabled || !this.Map.EnablePhysics || box.Type.Fake) return; MeshEntry entry = null; if (!this.meshes.TryGetValue(box.ChunkHash, out entry)) { entry = new MeshEntry(); this.meshes[box.ChunkHash] = entry; } entry.Dirty = true; }
/// <summary> /// Select the material for <paramref name="shape"/> based on <paramref name="meshData"/> /// configuration. /// </summary> /// <remarks> /// Wire frame selection may only be made for triangle draw types. In this case the /// <see cref="ShapeComponent"/> is checked for it's <code>Wireframe</code> flag. /// </remarks> /// <param name="shape">The shape object to select a material for.</param> /// <param name="meshData">Details of the mesh shape we are selecting a material for.</param> /// <returns>The appropriate material for rendering <paramref name="meshData"/>.</returns> Material CreateMaterial(CreateMessage shape, MeshEntry meshEntry) { Material mat; switch (meshEntry.Mesh.DrawType) { case MeshDrawType.Points: mat = new Material(Materials[MaterialLibrary.Points]); MaterialLibrary.SetupMaterial(mat, meshEntry.Mesh); int pointSize = (Materials != null) ? Materials.DefaultPointSize : 4; mat.SetInt("_LeftHanded", ServerInfo.IsLeftHanded ? 1 : 0); break; case MeshDrawType.Voxels: mat = new Material(Materials[MaterialLibrary.Voxels]); MaterialLibrary.SetupMaterial(mat, meshEntry.Mesh); mat.SetInt("_LeftHanded", ServerInfo.IsLeftHanded ? 1 : 0); break; default: case MeshDrawType.Lines: mat = new Material(Materials[MaterialLibrary.OpaqueMesh]); if (meshEntry.Mesh.HasColours) { mat.EnableKeyword("WITH_COLOURS_UINT"); } break; case MeshDrawType.Triangles: // Check wire frame. if ((shape.Flags & (uint)ObjectFlag.Wireframe) != 0u) { mat = new Material(Materials[MaterialLibrary.WireframeMesh]); } else if ((shape.Flags & (uint)ObjectFlag.Transparent) != 0u) { mat = new Material(Materials[MaterialLibrary.TransparentMesh]); } else if ((shape.Flags & (uint)ObjectFlag.TwoSided) != 0u) { mat = new Material(Materials[MaterialLibrary.OpaqueTwoSidedMesh]); } else { //mat = new Material(Materials[MaterialLibrary.OpaqueTwoSidedMesh]); mat = new Material(Materials[MaterialLibrary.OpaqueMesh]); } MaterialLibrary.SetupMaterial(mat, meshEntry.Mesh); break; } if (mat.HasProperty("_Color")) { mat.SetColor("_Color", Maths.ColourExt.ToUnity(new Maths.Colour(shape.Attributes.Colour))); } if (mat.HasProperty("_BackColour")) { mat.SetColor("_BackColour", Maths.ColourExt.ToUnity(new Maths.Colour(shape.Attributes.Colour))); } return(mat); }