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