Color GetLightPathColor(Vector3 pos, Vector3 dir, float length)
{
RayTrace.Ray ray = new RayTrace.Ray(pos, dir, length);
RayTrace.Intersect(ref ray);
if (ray.geomID == RayTrace.Invalid)
{
return(Color.white);
}
else
{
SimpleModel model = scene.models[(int)ray.geomID];
SimpleMesh mesh = model.mesh;
int t0 = mesh.triangles[ray.primID * 3 + 0];
int t1 = mesh.triangles[ray.primID * 3 + 1];
int t2 = mesh.triangles[ray.primID * 3 + 2];
Vector2 uv = RayTraceTool.Lerp(mesh.uv[t0], mesh.uv[t1], mesh.uv[t2], ray.u, ray.v);
Vector3 hitPos = ray.pos + ray.dir * ray.length;
Color texColor = model.material.PointSample(uv);
if (texColor.a < 0.99f)
{
Color aheadColor = GetLightPathColor(hitPos, dir * 0.01f, length - ray.length);
Color blendColor = (aheadColor * (1 - texColor.a)) + (texColor * texColor.a);
return(blendColor);
}
}
return(Color.black);
}
public void UVWEquals1Test()
{
var uvw = new List <Vector3>();
uvw.Add(new Vector3(0.625f, 0.5f, 0));
uvw.Add(new Vector3(0.875f, 0.5f, 0));
uvw.Add(new Vector3(0.875f, 0.75f, 0));
uvw.Add(new Vector3(0.625f, 0.75f, 0));
uvw.Add(new Vector3(0.375f, 0.75f, 0));
uvw.Add(new Vector3(0.625f, 1f, 0));
uvw.Add(new Vector3(0.375f, 1f, 0));
uvw.Add(new Vector3(0.375f, 0, 0));
uvw.Add(new Vector3(0.625f, 0, 0));
uvw.Add(new Vector3(0.625f, 0.25f, 0));
uvw.Add(new Vector3(0.375f, 0.25f, 0));
uvw.Add(new Vector3(0.125f, 0.5f, 0));
uvw.Add(new Vector3(0.375f, 0.5f, 0));
uvw.Add(new Vector3(0.125f, 0.75f, 0));
SimpleMesh simpleMesh;
using (var memstream = new MemoryStream(Properties.Resources.cube2))
{
using (var reader = new StreamReader(memstream))
{
simpleMesh = SimpleMesh.LoadFromObj(reader);
}
}
Assert.IsTrue(simpleMesh.uvw.SequenceEqual(uvw));
}
public void ChunkRecieved(SimpleMesh mesh)
{
MeshCollider collider = (MeshCollider)this.collider;
Mesh oldmesh = filter.sharedMesh;
filter.sharedMesh = null;
collider.sharedMesh = null;
if (oldmesh != null)
{
Mesh.Destroy(oldmesh);
}
Mesh m = mesh.CreateMesh();
MeshRenderer r = GetComponent <MeshRenderer>();
if (mesh.Submeshes.Count > 0)
{
r.sharedMaterials = mesh.Submeshes.Select(me => me.RenderMaterial).ToArray();
}
else
{
r.sharedMaterial = mesh.RenderMaterial;
}
filter.sharedMesh = m;
collider.sharedMesh = m;
}
private SimpleMesh <PositionNormalTexture> GenerateHeightMapMesh(float[,] heightData, DXDevice dxDevice)
{
PositionNormalTexture[] vertexBuffer;
int[] indexBuffer;
int xCount = heightData.GetUpperBound(0) + 1;
int yCount = heightData.GetUpperBound(1) + 2;
CreateHeightVertexAndIndexBuffer(heightData,
centerPosition: new Vector3(0, 0, 0),
size: new Vector3(1000, MaxHeightMapHeight, 1000.0f * (float)yCount / (float)xCount),
vertexBuffer: out vertexBuffer,
indexBuffer: out indexBuffer);
var heightMapMesh = new SimpleMesh <PositionNormalTexture>(vertexBuffer,
indexBuffer,
inputLayoutType: InputLayoutType.Position | InputLayoutType.Normal | InputLayoutType.TextureCoordinate,
name: "HeightSimpleMesh");
// If DXDevice is already initialized, then we can also initialize (create DirectX resources) for the SimpleMesh.
// This will create the DirectX resources and send them to the GPU
if (dxDevice != null)
{
heightMapMesh.InitializeResources(dxDevice);
}
return(heightMapMesh);
}
public virtual MeshSO Create(SimpleMesh mesh, SOMaterial setMaterial)
{
Mesh umesh = UnityUtil.SimpleMeshToUnityMesh(mesh, false);
Create(umesh, setMaterial);
return(this);
}
void generateAll(System.Object threadContext)
{
blocks = new Block[(resolutionX + 1) * (resolutionY + 1) * (resolutionZ + 1)];
mesh = new SimpleMesh();
generationDone = false;
meshCreated = false;
generateBlocks(density);
generateGeometry();
// generateGeomNormals();
finalVertices = new Vector3[mesh.vtx.Count / 3];
finalNormals = new Vector3[mesh.norms.Count / 3];
finalFaces = new int[mesh.faces.Count];
for (int i = 0; i < mesh.vtx.Count / 3; i++)
{
finalVertices[i] = new Vector3(mesh.vtx[i * 3], mesh.vtx[i * 3 + 1], mesh.vtx[i * 3 + 2]);
}
for (int i = 0; i < mesh.norms.Count / 3; i++)
{
finalNormals[i] = new Vector3(mesh.norms[i * 3], mesh.norms[i * 3 + 1], mesh.norms[i * 3 + 2]);
}
for (int i = 0; i < mesh.faces.Count; i++)
{
finalFaces[i] = mesh.faces[i];
}
// Thread.Sleep(5000);
generationDone = true; // on attend la resynchronisation avec le thread principal de Unity pour charger les données en CG
}
public static void WriteGeneratedMesh(MeshGenerator gen, string sFilename)
{
SimpleMesh mesh = new SimpleMesh();
gen.MakeMesh(mesh);
TestUtil.WriteDebugMesh(mesh, sFilename);
}
public static void EmitMeshSO(SceneSerializer s, IOutputStream o, MeshSO so)
{
o.AddAttribute(IOStrings.ASOName, so.Name);
o.AddAttribute(IOStrings.ASOUuid, so.UUID);
s.EmitTransform(o, so);
SimpleMesh m = so.GetSimpleMesh(true);
s.EmitMeshBinary(m, o);
}
/// <summary>
/// Converts g3.SimpleMesh to UnityEngine.Mesh
/// </summary>
/// <param name="simpleMesh">SimpleMesh</param>
/// <returns>UnityEngine.Mesh</returns>
public static Mesh ToMesh(this SimpleMesh simpleMesh)
{
Mesh unityMesh = new Mesh();
MeshTransforms.ConvertZUpToYUp(simpleMesh);
Vector3[] vertices = new Vector3[simpleMesh.VertexCount];
Color[] colors = new Color[simpleMesh.VertexCount];
Vector2[] uvs = new Vector2[simpleMesh.VertexCount];
Vector3[] normals = new Vector3[simpleMesh.VertexCount];
NewVertexInfo data;
for (int i = 0; i < simpleMesh.VertexCount; i++)
{
data = simpleMesh.GetVertexAll(i);
vertices[i] = (Vector3)data.v;
if (data.bHaveC)
{
colors[i] = (Color)data.c;
}
if (data.bHaveUV)
{
uvs[i] = (Vector2)data.uv;
}
if (data.bHaveN)
{
normals[i] = (Vector3)data.n;
}
}
unityMesh.vertices = vertices;
if (simpleMesh.HasVertexColors)
{
unityMesh.colors = colors;
}
if (simpleMesh.HasVertexUVs)
{
unityMesh.uv = uvs;
}
if (simpleMesh.HasVertexNormals)
{
unityMesh.normals = normals;
}
int[] triangles = new int[simpleMesh.TriangleCount * 3];
int j = 0;
foreach (Index3i tri in simpleMesh.TrianglesItr())
{
triangles[j * 3] = tri.a;
triangles[j * 3 + 1] = tri.b;
triangles[j * 3 + 2] = tri.c;
j++;
}
unityMesh.triangles = triangles;
return(unityMesh);
}
public SimpleMesh GetWorldMesh(DetailLevel lod, SimulationObject parent)
{
int i = (int)lod;
if (WorldTransformedMeshes[i] != null)
{
return(WorldTransformedMeshes[i]);
}
else
{
// Get the untransformed mesh
SimpleMesh mesh = GetMesh(lod);
// Copy to our new mesh
SimpleMesh transformedMesh = new SimpleMesh();
transformedMesh.Indices = new List <ushort>(mesh.Indices);
transformedMesh.Path.Open = mesh.Path.Open;
transformedMesh.Path.Points = new List <PathPoint>(mesh.Path.Points);
transformedMesh.Prim = mesh.Prim;
transformedMesh.Profile.Concave = mesh.Profile.Concave;
transformedMesh.Profile.Faces = new List <ProfileFace>(mesh.Profile.Faces);
transformedMesh.Profile.MaxX = mesh.Profile.MaxX;
transformedMesh.Profile.MinX = mesh.Profile.MinX;
transformedMesh.Profile.Open = mesh.Profile.Open;
transformedMesh.Profile.Positions = new List <Vector3>(mesh.Profile.Positions);
transformedMesh.Profile.TotalOutsidePoints = mesh.Profile.TotalOutsidePoints;
transformedMesh.Vertices = new List <Vertex>(mesh.Vertices);
// Construct a matrix to transform to world space
Matrix4 transform = Matrix4.Identity;
if (parent != null)
{
// Apply parent rotation and translation first
transform *= Matrix4.CreateFromQuaternion(parent.Prim.Rotation);
transform *= Matrix4.CreateTranslation(parent.Prim.Position);
}
transform *= Matrix4.CreateScale(this.Prim.Scale);
transform *= Matrix4.CreateFromQuaternion(this.Prim.Rotation);
transform *= Matrix4.CreateTranslation(this.Prim.Position);
// Transform the mesh
for (int j = 0; j < transformedMesh.Vertices.Count; j++)
{
Vertex vertex = transformedMesh.Vertices[j];
vertex.Position *= transform;
transformedMesh.Vertices[j] = vertex;
}
WorldTransformedMeshes[i] = transformedMesh;
return(transformedMesh);
}
}
public override void OnInspectorGUI()
{
EditorGUI.BeginChangeCheck();
serializedObject.Update();
DrawDefaultInspector();
if (EditorGUI.EndChangeCheck() || Event.current.commandName == "UndoRedoPerformed")
{
SimpleMesh m = (SimpleMesh)target;
m.SetMesh();
}
}
public virtual SceneObject BuildMeshSO(FScene scene, TypedAttribSet attributes)
{
MeshSO so = new MeshSO();
SimpleMesh m = RestoreSimpleMesh(attributes, true);
so.Create(m, scene.DefaultSOMaterial);
RestoreSOInfo(so, attributes);
RestoreTransform(so, attributes);
RestoreMaterial(so, attributes);
return(so);
}
public virtual SceneObject BuildMeshSO(FScene scene, TypedAttribSet attributes)
{
MeshSO so = new MeshSO();
SimpleMesh m = RestoreSimpleMesh(attributes, true);
so.Create(m, scene.DefaultSOMaterial);
safe_set_property_s(attributes, IOStrings.ASOName, (s) => { so.Name = s; });
RestoreTransform(so, attributes);
RestoreMaterial(so, attributes);
return(so);
}
public static UnityEngine.Mesh SimpleMeshToUnityMesh(SimpleMesh m, bool bSwapLeftRight)
{
if (m.VertexCount > 65000 || m.TriangleCount > 65000)
{
Debug.Log("[SimpleMeshReader] attempted to import object larger than 65000 verts/tris, not supported by Unity!");
return(null);
}
UnityEngine.Mesh unityMesh = new UnityEngine.Mesh();
Vector3[] vertices = dvector_to_vector3(m.Vertices);
Vector3[] normals = (m.HasVertexNormals) ? dvector_to_vector3(m.Normals) : null;
if (bSwapLeftRight)
{
int nV = vertices.Length;
for (int i = 0; i < nV; ++i)
{
vertices[i].x = -vertices[i].x;
vertices[i].z = -vertices[i].z;
if (normals != null)
{
normals[i].x = -normals[i].x;
normals[i].z = -normals[i].z;
}
}
}
unityMesh.vertices = vertices;
if (m.HasVertexNormals)
{
unityMesh.normals = normals;
}
if (m.HasVertexColors)
{
unityMesh.colors = dvector_to_color(m.Colors);
}
if (m.HasVertexUVs)
{
unityMesh.uv = dvector_to_vector2(m.UVs);
}
unityMesh.triangles = m.GetTriangleArray();
if (m.HasVertexNormals == false)
{
unityMesh.RecalculateNormals();
}
return(unityMesh);
}
void OnSceneGUI()
{
SimpleMesh m = (SimpleMesh)target;
EditorGUI.BeginChangeCheck();
for (int i = 0; i < m.mesh_points.Length; i++)
{
m.mesh_points[i] = Handles.PositionHandle(m.transform.position + (Vector3)m.mesh_points[i], Quaternion.identity) - m.transform.position;
}
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(m, "SimpleMesh");
m.SetMesh();
}
}
public SimpleMesh GetMesh(DetailLevel lod)
{
int i = (int)lod;
if (Meshes[i] != null)
{
return(Meshes[i]);
}
else
{
Primitive prim = (Primitive)Prim;
SimpleMesh mesh = Server.Mesher.GenerateSimpleMesh(prim, lod);
Meshes[i] = mesh;
return(mesh);
}
}
static void HandleMeshMessage(PacketBuffer packet, NetworkReader reader, Dictionary <ulong, Resource> resources)
{
uint meshId = 0;
// Peek the mesh ID.
meshId = packet.PeekUInt32(PacketHeader.Size);
Resource resource;
SimpleMesh mesh = null;
// If it exists, make sure it's a mesh.
if (resources.TryGetValue(ResourceUtil.UniqueKey(new PlaceholderMesh(meshId)), out resource))
{
Assert.Equal((ushort)RoutingID.Mesh, resource.TypeID);
mesh = (SimpleMesh)resource;
}
switch (packet.Header.MessageID)
{
case (int)MeshMessageType.Invalid:
Assert.True(false, "Invalid mesh message sent");
break;
case (int)MeshMessageType.Destroy:
Assert.NotNull(mesh);
resources.Remove(mesh.UniqueKey());
break;
case (int)MeshMessageType.Create:
// Create message. Should not already exists.
Assert.Null(mesh);//, "Recreating existing mesh.");
mesh = new SimpleMesh(meshId);
Assert.True(mesh.ReadCreate(reader));
resources.Add(mesh.UniqueKey(), mesh);
break;
// Not handling these messages.
case (int)MeshMessageType.Redefine:
case (int)MeshMessageType.Finalise:
break;
default:
Assert.NotNull(mesh);
mesh.ReadTransfer(packet.Header.MessageID, reader);
break;
}
}
private SimpleMesh ToMesh()
{
int vcount = GetVertexCount();
MdalVertexIterator vi = Mdal.MDAL_M_vertexIterator(this);
VectorArray3d v = vi.GetVertexes(vcount);
bool hasColors;
VectorArray3f c = GetColors(vcount, out hasColors);
SimpleMesh mesh = new SimpleMesh();
mesh.AppendVertices(v, null, c);
int fcount = GetFaceCount();
MdalFaceIterator fi = Mdal.MDAL_M_faceIterator(this);
IndexArray3i tri = fi.GetTris(fcount, Mdal.MDAL_M_faceVerticesMaximumCount(this));
mesh.AppendTriangles(tri);
return(mesh);
}
public void LoadMesh1Test()
{
try
{
SimpleMesh simpleMesh;
using (var memstream = new MemoryStream(Properties.Resources.cube2))
{
using (var reader = new StreamReader(memstream))
{
simpleMesh = SimpleMesh.LoadFromObj(reader);
}
}
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
public void StartRecord()
{
if (isRecord)
{
return;
}
skinnedMesh = new SkinnedMesh();
SimpleMesh simpleMesh = new SimpleMesh();
//Vertices
for (var i = 0; i < skinnedMeshRenderer.sharedMesh.vertices.Length; i++)
{
simpleMesh.Vertices.Add(new MeshInfomation.Vertex {
X = skinnedMeshRenderer.sharedMesh.vertices[i].x, Y = skinnedMeshRenderer.sharedMesh.vertices[i].y, Z = skinnedMeshRenderer.sharedMesh.vertices[i].z
});
}
//UV
for (var i = 0; i < skinnedMeshRenderer.sharedMesh.uv.Length; i++)
{
simpleMesh.UV.Add(new MeshInfomation.UV {
X = skinnedMeshRenderer.sharedMesh.uv[i].x, Y = skinnedMeshRenderer.sharedMesh.uv[i].y
});
}
//Normals
for (var i = 0; i < skinnedMeshRenderer.sharedMesh.normals.Length; i++)
{
simpleMesh.Normals.Add(new MeshInfomation.Normal {
X = skinnedMeshRenderer.sharedMesh.normals[i].x, Y = skinnedMeshRenderer.sharedMesh.normals[i].y, Z = skinnedMeshRenderer.sharedMesh.normals[i].z
});
}
//Indices
for (var i = 0; i < skinnedMeshRenderer.sharedMesh.GetIndices(0).Length; i++)
{
simpleMesh.Indices.Add(skinnedMeshRenderer.sharedMesh.GetIndices(0)[i]);
}
skinnedMesh.Mesh = simpleMesh;
frameCount = 0;
isRecord = true;
}
static VertexDeclaration GetVertexDeclaration(SimpleMesh mesh)
{
var elements = new List <VertexElement>();
elements.Add(VertexElement.Position <Vector3>());
if (mesh.HasVertexNormals)
{
elements.Add(VertexElement.Normal <Vector3>());
}
if (mesh.HasVertexUVs)
{
elements.Add(VertexElement.TextureCoordinate <Vector2>());
}
if (mesh.HasVertexColors)
{
elements.Add(VertexElement.Color <Color>());
}
return(new VertexDeclaration(elements.ToArray()));
}
MeshResource CreateMeshResource(uint id, List <Vector3> uverts, List <Vector3> unormals, List <int> indices)
{
SimpleMesh mesh = new SimpleMesh(id, MeshDrawType.Triangles,
MeshComponentFlag.Vertex | MeshComponentFlag.Normal | MeshComponentFlag.Index);
for (int i = 0; i < uverts.Count; ++i)
{
mesh.AddVertex(Tes.Maths.Vector3Ext.FromUnity(uverts[i]));
}
for (int i = 0; i < unormals.Count; ++i)
{
mesh.AddNormal(Tes.Maths.Vector3Ext.FromUnity(unormals[i]));
}
mesh.AddIndices(indices);
return(mesh);
}
/// <summary>
/// Emit a SimpleMesh as an AsciiMeshStruct
/// </summary>
public static void EmitMeshAscii(this SceneSerializer s, SimpleMesh m, IOutputStream o)
{
o.BeginStruct(IOStrings.AsciiMeshStruct);
o.AddAttribute(IOStrings.AMeshVertices3, m.VerticesItr());
if (m.HasVertexNormals)
{
o.AddAttribute(IOStrings.AMeshNormals3, m.NormalsItr());
}
if (m.HasVertexColors)
{
o.AddAttribute(IOStrings.AMeshColors3, m.ColorsItr());
}
if (m.HasVertexUVs)
{
o.AddAttribute(IOStrings.AMeshUVs2, m.UVsItr());
}
o.AddAttribute(IOStrings.AMeshTriangles, m.TrianglesItr());
o.EndStruct();
}
public static void WriteObj(FileInfo file, IGeometryData geo)
{
var meshes = new List <WriteMesh>();
var mesh = new SimpleMesh();
var map = new Dictionary <Vector3, int>();
var indeces = new List <int>();
for (var index = 0; index < geo.Positions.Length; index++)
{
var v = geo.Positions[index];
if (!map.ContainsKey(v))
{
map.Add(v, map.Count);
}
}
for (var index = 0; index < geo.Indices.Length; index++)
{
var i = geo.Indices[index];
var v = geo.Positions[i];
indeces.Add(map[v]);
}
var points = map.Keys.ToArray();
var pcount = points.Length * 3;
var pp = new double[pcount];
var pindex = 0;
for (var index = 0; index < points.Length; index++)
{
var v = points[index];
pp[pindex++] = v.X;
pp[pindex++] = v.Y;
pp[pindex++] = v.Z;
}
mesh.Initialize(new VectorArray3d(pp), new VectorArray3i(indeces.ToArray()));
meshes.Add(new WriteMesh(mesh, $"d3dlab export"));
StandardMeshWriter.WriteFile(file.FullName, meshes, WriteOptions.Defaults);
}
public void VerticesEquals1Test()
{
SimpleMesh simpleMesh;
using (var reader = new StreamReader("G:\\cube2.obj"))
{
simpleMesh = SimpleMesh.LoadFromObj(reader);
}
var vertices = new List <Vector3>();
vertices.Add(new Vector3(100.000000f, 100.000000f, -100.000000f));
vertices.Add(new Vector3(100.000000f, -100.000000f, -100.000000f));
vertices.Add(new Vector3(100.000000f, 100.000000f, 100.000000f));
vertices.Add(new Vector3(100.000000f, -100.000000f, 100.000000f));
vertices.Add(new Vector3(-100.000000f, 100.000000f, -100.000000f));
vertices.Add(new Vector3(-100.000000f, -100.000000f, -100.000000f));
vertices.Add(new Vector3(-100.000000f, 100.000000f, 100.000000f));
vertices.Add(new Vector3(-100.000000f, -100.000000f, 100.000000f));
Assert.IsTrue(simpleMesh.vertices.SequenceEqual(vertices));
}
public void NormalsEquals1Test()
{
SimpleMesh simpleMesh;
using (var memstream = new MemoryStream(Properties.Resources.cube2))
{
using (var reader = new StreamReader(memstream))
{
simpleMesh = SimpleMesh.LoadFromObj(reader);
}
}
var normals = new List <Vector3>();
normals.Add(new Vector3(0, 1, 0));
normals.Add(new Vector3(0, 0, 1));
normals.Add(new Vector3(-1, 0, 0));
normals.Add(new Vector3(0, -1, 0));
normals.Add(new Vector3(1, 0, 0));
normals.Add(new Vector3(0, 0, -1));
Assert.IsTrue(simpleMesh.normals.SequenceEqual(normals));
}
public void Export(string path)
{
SimpleMesh mesh = new SimpleMesh();
//Vertices
for (var i = 0; i < meshFilter.mesh.vertices.Length; i++)
{
mesh.Vertices.Add(new MeshInfomation.Vertex {
X = meshFilter.mesh.vertices[i].x, Y = meshFilter.mesh.vertices[i].y, Z = meshFilter.mesh.vertices[i].z
});
}
//UV
for (var i = 0; i < meshFilter.mesh.uv.Length; i++)
{
mesh.UV.Add(new MeshInfomation.UV {
X = meshFilter.mesh.uv[i].x, Y = meshFilter.mesh.uv[i].y
});
}
//Normals
for (var i = 0; i < meshFilter.mesh.normals.Length; i++)
{
mesh.Normals.Add(new MeshInfomation.Normal {
X = meshFilter.mesh.normals[i].x, Y = meshFilter.mesh.normals[i].y, Z = meshFilter.mesh.normals[i].z
});
}
//Indices
for (var i = 0; i < meshFilter.mesh.GetIndices(0).Length; i++)
{
mesh.Indices.Add(meshFilter.mesh.GetIndices(0)[i]);
}
var json = JsonConvert.SerializeObject(mesh);
File.WriteAllText(path, json);
//print (json);
}
private MeshBase CreateTubePathMesh(Vector3[] pathPositions, float radius, int segmentsCount, bool isTubeClosed, Color4 tubeColor)
{
int pathPositionsCount = pathPositions.Length;
// Preallocate the positions, indices, normals and textures collections - this prevents resizing the collection when the elements are added to them
int totalPositionsCount = segmentsCount * pathPositionsCount;
int shownSegmentsCount = pathPositionsCount - 1;
int totalTriangleIndicesCount = shownSegmentsCount * segmentsCount * 2 * 3; // 2 triangles for each segment * No. of shown segments * 3 indices per triangle
if (isTubeClosed)
{
totalTriangleIndicesCount += (segmentsCount - 2) * 2 * 3; // Add closing triangles (for triangle strip)
}
var vertexBuffer = new PositionNormal[totalPositionsCount];
var indexBuffer = new int[totalTriangleIndicesCount];
AddTubePathMesh(pathPositions, radius, segmentsCount, isTubeClosed, vertexBuffer, indexBuffer, vertexBufferStartIndex: 0, indexBufferStartIndex: 0);
var simpleMesh = new SimpleMesh <PositionNormal>(vertexBuffer,
indexBuffer,
inputLayoutType: InputLayoutType.Position | InputLayoutType.Normal);
// Quickly calculate mesh BoundingBox
// If this is not done here, then BoundingBox is calculated in SimpleMesh with checking all the tube path's positions.
// To prevent checking all the positions, we can simplify the calculation of bounding box with using
// all path positions and then extending this for radius into all directions.
// This will create slightly bigger bounding box but this is not a problem.
var positionsBoundingBox = BoundingBox.FromPoints(pathPositions);
simpleMesh.Bounds = new Bounds(new Vector3(positionsBoundingBox.Minimum.X - radius, positionsBoundingBox.Minimum.Y - radius, positionsBoundingBox.Minimum.Z - radius),
new Vector3(positionsBoundingBox.Maximum.X + radius, positionsBoundingBox.Maximum.Y + radius, positionsBoundingBox.Maximum.Z + radius));
_disposables.Add(simpleMesh);
return(simpleMesh);
}
private void MeshDone(SimpleMesh mesh)
{
Mesh m = mesh.CreateMesh();
MeshRenderer r = GetComponent <MeshRenderer>();
if (mesh.Submeshes.Count > 0)
{
r.materials = mesh.Submeshes.Select(me => me.RenderMaterial).ToArray();
}
else
{
r.material = mesh.RenderMaterial;
}
filter.sharedMesh = m;
MeshCollider collider = (MeshCollider)this.collider;
if (collider != null)
{
collider.sharedMesh = m;
}
}
private void LoadDebugPrim()
{
Prims = new List <FacetedMesh>();
Primitive prim = new Primitive();
prim.Textures = new Primitive.TextureEntry(UUID.Zero);
prim.Scale = Vector3.One;
prim.PrimData = ObjectManager.BuildBasicShape(PrimType.Cylinder);
prim.PrimData.ProfileHollow = 0.95f;
SimpleMesh simpleMesh = Render.Plugin.GenerateSimpleMesh(prim, DetailLevel.High);
FacetedMesh facetedMesh = new FacetedMesh();
facetedMesh.Faces = new List <Face> {
new Face {
Vertices = simpleMesh.Vertices, Indices = simpleMesh.Indices
}
};
facetedMesh.Path = simpleMesh.Path;
facetedMesh.Profile = simpleMesh.Profile;
facetedMesh.Prim = prim;
LoadMesh(facetedMesh, ".");
PopulatePrimCombobox();
glControl.Invalidate();
}
// Use this for initialization
void Start()
{
simpleMesh = gameObject.GetComponent<SimpleMesh>();
}
