feat: adds receving logic

ObjectsUnity.cs

@@ -0,0 +1,248 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace Objects.Geometry
+{
+
+
+  /// <summary>
+  /// Base definition for all rendered stream objects. Any Speckle object that needs to be
+  /// displayed with a game object should inherit from this class.
+  /// </summary>
+  public abstract class UnityGeometry
+  {
+    /// <summary>
+    /// The gameobject that will be displayed. The <c>Transform</c> parent will be assigned
+    /// by the <c>SpeckleUnityReceiver</c>.
+    /// </summary>
+    public GameObject gameObject;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public Renderer renderer;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public UnityGeometry()
+    {
+      gameObject = new GameObject();
+
+    }
+  }
+
+  /// <summary>
+  /// A stream object represented as a gameobject with a <c>MeshRenderer</c>. Also adds a 
+  /// <c>MeshCollider</c> to the object. The material is assigned by the <c>SpeckleUnityReceiver</c>.
+  /// </summary>
+  public class UnityMesh : UnityGeometry
+  {
+    /// <summary>
+    /// 
+    /// </summary>
+    public static bool RecentreMeshTransforms = false;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public UnityEngine.Mesh mesh;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public MeshRenderer meshRenderer;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="type"></param>
+    /// <param name="verts"></param>
+    /// <param name="tris"></param>
+    public UnityMesh(string type, Vector3[] verts, int[] tris) : base()
+    {
+      gameObject.name = type;
+
+      mesh = gameObject.AddComponent<MeshFilter>().mesh;
+      renderer = meshRenderer = gameObject.AddComponent<MeshRenderer>();
+
+      if (verts.Length >= 65535)
+        mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
+
+      // center transform pivot according to the bounds of the model
+      if (RecentreMeshTransforms)
+      {
+        Bounds meshBounds = new Bounds();
+        meshBounds.center = verts[0];
+
+        for (int i = 1; i < verts.Length; i++)
+        {
+          meshBounds.Encapsulate(verts[i]);
+        }
+
+        gameObject.transform.position = meshBounds.center;
+
+        // offset mesh vertices
+        for (int i = 0; i < verts.Length; i++)
+        {
+          verts[i] -= meshBounds.center;
+        }
+      }
+
+      // assign mesh properties
+      mesh.vertices = verts;
+      mesh.triangles = tris;
+
+      mesh.RecalculateNormals();
+      mesh.RecalculateTangents();
+
+      //generate uvs doesn't work as intended. Leaving out for now
+      //GenerateUVs (ref mesh);
+
+      //Add mesh collider
+      MeshCollider mc = gameObject.AddComponent<MeshCollider>();
+      mc.sharedMesh = mesh;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="mesh"></param>
+    /// <returns></returns>
+    protected void GenerateUVs(ref UnityEngine.Mesh mesh)
+    {
+      Vector3 p = Vector3.up;
+      Vector3 u = Vector3.Cross(p, Vector3.forward);
+      if (Vector3.Dot(u, u) < 0.001f)
+      {
+        u = Vector3.right;
+      }
+      else
+      {
+        u = Vector3.Normalize(u);
+      }
+
+      Vector3 v = Vector3.Normalize(Vector3.Cross(p, u));
+      Vector3[] vertexs = mesh.vertices;
+      int[] tris = mesh.triangles;
+      Vector2[] uvs = new Vector2[vertexs.Length];
+
+      for (int i = 0; i < tris.Length; i += 3)
+      {
+
+        Vector3 a = vertexs[tris[i]];
+        Vector3 b = vertexs[tris[i + 1]];
+        Vector3 c = vertexs[tris[i + 2]];
+        Vector3 side1 = b - a;
+        Vector3 side2 = c - a;
+        Vector3 N = Vector3.Cross(side1, side2);
+
+        N = new Vector3(Mathf.Abs(N.normalized.x), Mathf.Abs(N.normalized.y), Mathf.Abs(N.normalized.z));
+
+
+
+        if (N.x > N.y && N.x > N.z)
+        {
+          uvs[tris[i]] = new Vector2(vertexs[tris[i]].z, vertexs[tris[i]].y);
+          uvs[tris[i + 1]] = new Vector2(vertexs[tris[i + 1]].z, vertexs[tris[i + 1]].y);
+          uvs[tris[i + 2]] = new Vector2(vertexs[tris[i + 2]].z, vertexs[tris[i + 2]].y);
+        }
+        else if (N.y > N.x && N.y > N.z)
+        {
+          uvs[tris[i]] = new Vector2(vertexs[tris[i]].x, vertexs[tris[i]].z);
+          uvs[tris[i + 1]] = new Vector2(vertexs[tris[i + 1]].x, vertexs[tris[i + 1]].z);
+          uvs[tris[i + 2]] = new Vector2(vertexs[tris[i + 2]].x, vertexs[tris[i + 2]].z);
+        }
+        else if (N.z > N.x && N.z > N.y)
+        {
+          uvs[tris[i]] = new Vector2(vertexs[tris[i]].x, vertexs[tris[i]].y);
+          uvs[tris[i + 1]] = new Vector2(vertexs[tris[i + 1]].x, vertexs[tris[i + 1]].y);
+          uvs[tris[i + 2]] = new Vector2(vertexs[tris[i + 2]].x, vertexs[tris[i + 2]].y);
+        }
+
+      }
+
+      mesh.uv = uvs;
+    }
+  }
+
+  /// <summary>
+  /// Used to display lines, curves, or polylines as a game object with a <c>LineRenderer</c>.
+  /// The material is assigned by the <c>SpeckleUnityReceiver</c>.
+  /// </summary>
+  public class UnityPolyline : UnityGeometry
+  {
+    /// <summary>
+    /// 
+    /// </summary>
+    public static float LineWidth = 1;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public LineRenderer lineRenderer;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="type"></param>
+    /// <param name="points"></param>
+    public UnityPolyline(string type, Vector3[] points) : base()
+    {
+      gameObject.name = type;
+
+      //create line renderer       
+      renderer = lineRenderer = gameObject.AddComponent<LineRenderer>();
+
+      lineRenderer.positionCount = points.Length;
+      lineRenderer.SetPositions(points);
+      lineRenderer.numCornerVertices = lineRenderer.numCapVertices = 8;
+      lineRenderer.startWidth = lineRenderer.endWidth = LineWidth;
+    }
+  }
+
+
+  /// <summary>
+  /// Display Point. Uses a line renderer for display. The material is assigned by the
+  /// <c>SpeckleUnityReceiver</c>.
+  /// </summary>
+  public class UnityPoint : UnityGeometry
+  {
+    /// <summary>
+    /// 
+    /// </summary>
+    public static float PointDiameter = 1;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public Vector3 point;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public LineRenderer lineRenderer;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="type"></param>
+    /// <param name="point"></param>
+    public UnityPoint(string type, Vector3 point) : base()
+    {
+      gameObject.name = type;
+
+      this.point = point;
+
+      //create line renderer       
+      renderer = lineRenderer = gameObject.AddComponent<LineRenderer>();
+      lineRenderer.SetPositions(new Vector3[2] { point, point });
+      lineRenderer.numCornerVertices = lineRenderer.numCapVertices = 8;
+      lineRenderer.startWidth = lineRenderer.endWidth = PointDiameter;
+    }
+  }
+}