public MeshBlock(string id, Type type, BlockBounds blockBounds, SplittedRegion splittedRegion, Quaternion rotation, int occludeOrder)
{
Id = id;
BlockType = type;
RotationQuat = rotation;
OccludeOrder = occludeOrder;
OriginalBounds = blockBounds;
SplittedRegion = splittedRegion;
RotatedBlockBounds = blockBounds.Copy();
TypeCode = TypeToTypeCode[type];
MeshSource = ProceduralMeshSource.GetInstance(TypeCode);
}
public Batch(IMeshSource meshSource)
{
MeshSource = meshSource;
GeometryMesh g = meshSource as GeometryMesh;
if (g != null)
{
//BoundingBox = g.Geometry.BoundingBox();
BoundingSphere = g.Geometry.ComputeBoundingSphere();
}
else
{
BoundingSphere.Center = Vector3.Zero;
BoundingSphere.Radius = float.MaxValue;
}
}
public void ExportMeshModel(IMeshSource mesh, string mdlFilePath, AssetKey key, DateTime lastWriteDateTimeUtc)
{
if (!_engine.Options.ExportMeshes)
{
return;
}
using (var file = _engine.TryCreate(key, mdlFilePath, lastWriteDateTimeUtc))
{
if (file != null)
{
using (var writer = new BinaryWriter(file))
{
WriteMesh(writer, mesh);
}
}
}
}
/*public void Initialize()
* {
* }*/
public void Render(RenderStack.Scene.Frame frame)
{
if (indexBufferRange.Count == 0)
{
return;
}
#if false
IMeshSource meshSource = HoverModel.Batch.MeshSource;
if (meshSource is GeometryMesh && selectionMesh != null)
{
renderer.CurrentModel = null;
renderer.CurrentMaterial = null;
renderer.CurrentProgram = renderer.Programs["WideLine"];
renderer.CurrentFrame = HoverModel.Frame;
renderer.CurrentMesh = selectionMesh.GetMesh;
if (!RenderStack.Graphics.Configuration.GL3)
{
GL.LineWidth(lineWidth);
}
}
#endif
// \todo Use renderstate
GL.PolygonOffset(-1.0f, 1.0f);
GL.Enable(EnableCap.PolygonOffsetFill);
renderer.Requested.Material = material;
renderer.Requested.Program = material.Program;
if (
(RenderStack.Graphics.Configuration.canUseGeometryShaders) ||
(RenderStack.Graphics.Configuration.glslVersion < 330)
)
{
GL.LineWidth(LineWidth);
}
renderer.SetFrame(frame);
renderer.Requested.Mesh = Mesh;
renderer.Requested.MeshMode = MeshMode.EdgeLines;
// \todo Use renderstate
GL.PolygonOffset(-1.0f, 1.0f);
GL.Disable(EnableCap.PolygonOffsetFill);
renderer.RenderCurrent();
}
private Urho3DBone[] BuildBones(IMeshSource skinnedMeshRenderer)
{
if (skinnedMeshRenderer == null || skinnedMeshRenderer.BonesCount == 0)
{
return(new Urho3DBone[0]);
}
//var unityBones = skinnedMeshRenderer.bones;
var bones = new Urho3DBone[skinnedMeshRenderer.BonesCount];
for (var index = 0; index < bones.Length; index++)
{
var bone = new Urho3DBone();
var unityBone = skinnedMeshRenderer.GetBoneTransform(index);
var parentIndex = skinnedMeshRenderer.GetBoneParent(index);
if (parentIndex.HasValue)
{
bone.parent = parentIndex.Value;
}
bone.name = unityBone.name ?? "bone" + index;
//if (bone.parent != 0)
//{
bone.actualPos = unityBone.localPosition;
bone.actualRot = unityBone.localRotation;
bone.actualScale = unityBone.localScale;
//}
//else
//{
// bone.actualPos = unityBone.position;
// bone.actualRot = unityBone.rotation;
// bone.actualScale = unityBone.lossyScale;
//}
bone.binding = skinnedMeshRenderer.GetBoneBindPose(index);
bones[index] = bone;
}
return(bones);
}
public Batch(IMeshSource meshSource, Material material)
: this(meshSource)
{
Material = material;
}
public void UpdateHover(Model renderModel, uint modelPolygonId)
{
HoverPolygon = null;
if(renderModel != null)
{
if(HoverModel != renderModel)
{
HoverModel = renderModel;
HoverGroup.Clear();
HoverGroup.Add(renderModel);
}
//if(Configuration.hoverDebug)
{
PolygonIds.Clear();
PolygonIds.Add(modelPolygonId);
// Temp debug code
IMeshSource meshSource = HoverModel.Batch.MeshSource;
if (meshSource is GeometryMesh original)
{
if (original.Geometry.PolygonAttributes.Contains<Vector3>("polygon_normals"))
{
if (modelPolygonId < original.Geometry.Polygons.Count)
{
HoverPolygon = original.Geometry.Polygons[(int)modelPolygonId];
#if true
//selectionMesh.Geometry = Geometry.Clone(original.Geometry, SelectedPolygonIds).Destination;
//selectionMesh.BuildMeshFromGeometry();
Frame hoverFrame = HoverModel.Frame;
Polygon polygon = HoverPolygon;
var polygonNormals = original.Geometry.PolygonAttributes.Find<Vector3>("polygon_normals");
var polygonCentroids = original.Geometry.PolygonAttributes.Find<Vector3>("polygon_centroids");
Vector3 normalInModel = polygonNormals[polygon];
Vector3 positionInModel = hoverFrame.LocalToWorld.InverseMatrix.TransformPoint(HoverPosition);
var pointLocations = original.Geometry.PointAttributes.Find<Vector3>("point_locations");
Corner pivotCorner = original.Geometry.ClosestPolygonCorner(polygon, positionInModel);
Point pivotPoint = pivotCorner.Point;
HoverPoint = pivotPoint;
Edge firstEdge;
Edge secondEdge;
original.Geometry.PolygonCornerEdges(polygon, pivotCorner, out firstEdge, out secondEdge);
Point firstEdgeOutPoint = firstEdge.Other(pivotPoint);
Point secondEdgeOutPoint = secondEdge.Other(pivotPoint);
Vector3 pivotLocation = hoverFrame.LocalToWorld.Matrix.TransformPoint(pointLocations[pivotPoint]);
Vector3 firstOutLocation = hoverFrame.LocalToWorld.Matrix.TransformPoint(pointLocations[firstEdgeOutPoint]);
Vector3 secondOutLocation = hoverFrame.LocalToWorld.Matrix.TransformPoint(pointLocations[secondEdgeOutPoint]);
Vector3 normal = hoverFrame.LocalToWorld.Matrix.TransformDirection(normalInModel);
Vector3 firstDirection = Vector3.Normalize(firstOutLocation - pivotLocation);
Vector3 secondDirection = Vector3.Normalize(secondOutLocation - pivotLocation);
Vector3 centroid = hoverFrame.LocalToWorld.Matrix.TransformPoint(polygonCentroids[polygon]);
if (Configuration.hoverDebug)
{
lineRenderer.Begin();
lineRenderer.Line(HoverPosition, HoverPosition + 0.5f * normal, new Vector4(1.0f, 1.0f, 1.0f, 1.0f));
lineRenderer.Line(centroid, centroid + 0.25f * normal, new Vector4(0.5f, 0.5f, 0.5f, 1.0f));
/*LineRenderer.Line(pivotLocation, pivotLocation + normal);
LineRenderer.Line(pivotLocation - firstDirection * 1.0f, pivotLocation + firstDirection * 1.0f);
LineRenderer.Line(pivotLocation - secondDirection * 1.0f, pivotLocation + secondDirection * 1.0f);*/
lineRenderer.End();
}
}
#endif
}
}
}
}
else
{
if(HoverModel != null)
{
HoverGroup.Clear();
}
HoverModel = null;
}
}
private void WriteMesh(BinaryWriter writer, IMeshSource mesh)
{
writer.Write(Magic2);
writer.Write(1);
for (var vbIndex = 0; vbIndex < 1 /*_mesh.vertexBufferCount*/; ++vbIndex)
{
var positions = mesh.Vertices;
var normals = mesh.Normals;
var colors = mesh.Colors;
var tangents = mesh.Tangents;
var boneWeights = mesh.BoneWeights;
var uvs = mesh.TexCoords0;
var uvs2 = mesh.TexCoords1;
var uvs3 = mesh.TexCoords2;
var uvs4 = mesh.TexCoords3;
writer.Write(positions.Count);
var elements = new List <MeshStreamWriter>();
if (positions.Count > 0)
{
elements.Add(new MeshVector3Stream(positions, VertexElementSemantic.SEM_POSITION));
}
if (normals.Count > 0)
{
elements.Add(new MeshVector3Stream(normals, VertexElementSemantic.SEM_NORMAL));
}
if (boneWeights.Length > 0)
{
var indices = new Vector4[boneWeights.Length];
var weights = new Vector4[boneWeights.Length];
for (var i = 0; i < boneWeights.Length; ++i)
{
indices[i] = new Vector4(boneWeights[i].boneIndex0, boneWeights[i].boneIndex1,
boneWeights[i].boneIndex2, boneWeights[i].boneIndex3);
weights[i] = new Vector4(boneWeights[i].weight0, boneWeights[i].weight1,
boneWeights[i].weight2, boneWeights[i].weight3);
}
elements.Add(new MeshVector4Stream(weights, VertexElementSemantic.SEM_BLENDWEIGHTS));
elements.Add(new MeshUByte4Stream(indices, VertexElementSemantic.SEM_BLENDINDICES));
}
if (colors.Count > 0)
{
elements.Add(new MeshColor32Stream(colors, VertexElementSemantic.SEM_COLOR));
}
if (tangents.Count > 0)
{
elements.Add(new MeshVector4Stream(FlipW(tangents), VertexElementSemantic.SEM_TANGENT));
}
if (uvs.Count > 0)
{
elements.Add(new MeshUVStream(uvs, VertexElementSemantic.SEM_TEXCOORD));
}
if (uvs2.Count > 0)
{
elements.Add(new MeshUVStream(uvs2, VertexElementSemantic.SEM_TEXCOORD, 1));
}
if (uvs3.Count > 0)
{
elements.Add(new MeshUVStream(uvs3, VertexElementSemantic.SEM_TEXCOORD, 2));
}
if (uvs4.Count > 0)
{
elements.Add(new MeshUVStream(uvs4, VertexElementSemantic.SEM_TEXCOORD, 3));
}
writer.Write(elements.Count);
for (var i = 0; i < elements.Count; ++i)
{
writer.Write(elements[i].Element);
}
var morphableVertexRangeStartIndex = 0;
var morphableVertexCount = 0;
writer.Write(morphableVertexRangeStartIndex);
writer.Write(morphableVertexCount);
for (var index = 0; index < positions.Count; ++index)
{
for (var i = 0; i < elements.Count; ++i)
{
elements[i].Write(writer, index);
}
}
var indicesPerSubMesh = new List <IList <int> >();
var totalIndices = 0;
for (var subMeshIndex = 0; subMeshIndex < mesh.SubMeshCount; ++subMeshIndex)
{
var indices = mesh.GetIndices(subMeshIndex);
indicesPerSubMesh.Add(indices);
totalIndices += indices.Count;
}
writer.Write(1);
writer.Write(totalIndices);
if (positions.Count < 65536)
{
writer.Write(2);
for (var subMeshIndex = 0; subMeshIndex < mesh.SubMeshCount; ++subMeshIndex)
{
for (var i = 0; i < indicesPerSubMesh[subMeshIndex].Count; ++i)
{
writer.Write((ushort)indicesPerSubMesh[subMeshIndex][i]);
}
}
}
else
{
writer.Write(4);
for (var subMeshIndex = 0; subMeshIndex < mesh.SubMeshCount; ++subMeshIndex)
{
for (var i = 0; i < indicesPerSubMesh[subMeshIndex].Count; ++i)
{
writer.Write(indicesPerSubMesh[subMeshIndex][i]);
}
}
}
writer.Write(indicesPerSubMesh.Count);
totalIndices = 0;
for (var subMeshIndex = 0; subMeshIndex < indicesPerSubMesh.Count; ++subMeshIndex)
{
var numberOfBoneMappingEntries = 0;
writer.Write(numberOfBoneMappingEntries);
var numberOfLODLevels = 1;
writer.Write(numberOfLODLevels);
writer.Write(0.0f);
writer.Write((int)PrimitiveType.TRIANGLE_LIST);
writer.Write(0);
writer.Write(0);
writer.Write(totalIndices);
writer.Write(indicesPerSubMesh[subMeshIndex].Count);
totalIndices += indicesPerSubMesh[subMeshIndex].Count;
}
var numMorphTargets = 0;
writer.Write(numMorphTargets);
var bones = BuildBones(mesh);
var numOfBones = bones.Length;
writer.Write(numOfBones);
var boneIndex = 0;
foreach (var bone in bones)
{
WriteStringSZ(writer, _engine.DecorateName(bone.name));
writer.Write(bone.parent); //Parent
Write(writer, bone.actualPos);
Write(writer, bone.actualRot);
Write(writer, bone.actualScale);
var d = new[]
{
bone.binding.m00, bone.binding.m01, bone.binding.m02, bone.binding.m03,
bone.binding.m10, bone.binding.m11, bone.binding.m12, bone.binding.m13,
bone.binding.m20, bone.binding.m21, bone.binding.m22, bone.binding.m23
};
foreach (var v in d)
{
writer.Write(v);
}
using (var e = GetBoneVertices(boneWeights, boneIndex).GetEnumerator())
{
if (!e.MoveNext())
{
writer.Write((byte)3);
//R
writer.Write(0.1f);
//BBox
Write(writer, new Vector3(-0.1f, -0.1f, -0.1f));
Write(writer, new Vector3(0.1f, 0.1f, 0.1f));
}
else
{
var binding = bone.binding;
//binding = binding.inverse;
var center = binding.MultiplyPoint(positions[e.Current]);
var min = center;
var max = center;
while (e.MoveNext())
{
var originalPosition = positions[e.Current];
var p = binding.MultiplyPoint(originalPosition);
if (p.x < min.x)
{
min.x = p.x;
}
if (p.y < min.y)
{
min.y = p.y;
}
if (p.z < min.z)
{
min.z = p.z;
}
if (p.x > max.x)
{
max.x = p.x;
}
if (p.y > max.y)
{
max.y = p.y;
}
if (p.z > max.z)
{
max.z = p.z;
}
}
writer.Write((byte)3);
//R
writer.Write(Math.Max(max.magnitude, min.magnitude));
//BBox
Write(writer, min);
Write(writer, max);
}
}
++boneIndex;
}
float minX, minY, minZ;
float maxX, maxY, maxZ;
maxX = maxY = maxZ = float.MinValue;
minX = minY = minZ = float.MaxValue;
for (var i = 0; i < positions.Count; ++i)
{
if (minX > positions[i].x)
{
minX = positions[i].x;
}
if (minY > positions[i].y)
{
minY = positions[i].y;
}
if (minZ > positions[i].z)
{
minZ = positions[i].z;
}
if (maxX < positions[i].x)
{
maxX = positions[i].x;
}
if (maxY < positions[i].y)
{
maxY = positions[i].y;
}
if (maxZ < positions[i].z)
{
maxZ = positions[i].z;
}
}
writer.Write(minX);
writer.Write(minY);
writer.Write(minZ);
writer.Write(maxX);
writer.Write(maxY);
writer.Write(maxZ);
}
}
