add mono c# (using dotnet9.0 from https://github.com/dotnet/runtime), add ECS (entt), add some c# code, add fastNoise

Prism-ScriptCore/Prism-ScriptCore.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net9.0</TargetFramework>
+        <RootNamespace>Prism_ScriptCore</RootNamespace>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+</Project>

Prism-ScriptCore/Prism-ScriptCore.sln

@@ -0,0 +1,16 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Prism-ScriptCore", "Prism-ScriptCore.csproj", "{B94EF710-0487-4388-97E3-B650761A849C}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{B94EF710-0487-4388-97E3-B650761A849C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B94EF710-0487-4388-97E3-B650761A849C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B94EF710-0487-4388-97E3-B650761A849C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B94EF710-0487-4388-97E3-B650761A849C}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal

Prism-ScriptCore/Src/Prism/Entity.cs

@@ -0,0 +1,61 @@
+using System.Runtime.CompilerServices;
+
+namespace Prism
+{
+    public class Entity
+    {
+        public uint SceneID { get; private set; }
+        public uint EntityID { get; private set; }
+
+        ~Entity()
+        {
+            Console.WriteLine("Destroyed Entity {0}:{1}", SceneID, EntityID);
+        }
+
+        public T CreateComponent<T>() where T : Component, new()
+        {
+            CreateComponent_Native(SceneID, EntityID, typeof(T));
+            T component = new T();
+            component.Entity = this;
+            return component;
+        }
+
+        public bool HasComponent<T>() where T : Component, new()
+        {
+            return HasComponent_Native(SceneID, EntityID, typeof(T));
+        }
+
+        public T GetComponent<T>() where T : Component, new()
+        {
+            if (HasComponent<T>())
+            {
+                T component = new T();
+                component.Entity = this;
+                return component;
+            }
+            return null;
+        }
+
+        public Mat4 GetTransform()
+        {
+            Mat4 mat4Instance;
+            GetTransform_Native(SceneID, EntityID, out mat4Instance);
+            return mat4Instance;
+        }
+
+        public void SetTransform(Mat4 transform)
+        {
+            SetTransform_Native(SceneID, EntityID, ref transform);
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void CreateComponent_Native(uint sceneID, uint entityID, Type type);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool HasComponent_Native(uint sceneID, uint entityID, Type type);
+        [MethodImpl(MethodImplOptions.InternalCall)] 
+        private static extern void GetTransform_Native(uint sceneID, uint entityID, out Mat4 matrix);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void SetTransform_Native(uint sceneID, uint entityID, ref Mat4 matrix);
+
+    }
+}

Prism-ScriptCore/Src/Prism/Input.cs

@@ -0,0 +1,17 @@
+using System.Runtime.CompilerServices;
+
+namespace Prism
+{
+    public class Input
+    {
+
+        public static bool IsKeyPressed(KeyCode keycode)
+        {
+            return IsKeyPressed_Native(keycode);
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool IsKeyPressed_Native(KeyCode keycode);
+
+    }
+}

Prism-ScriptCore/Src/Prism/KeyCodes.cs

@@ -0,0 +1,138 @@
+// ReSharper disable All
+namespace Prism
+{
+    public enum KeyCode
+    {
+        Space = 32,
+        Apostrophe = 39, /* ' */
+        Comma = 44, /* , */
+        Minus = 45, /* - */
+        Period = 46, /* . */
+        Slash = 47, /* / */
+
+        D0 = 48, /* 0 */
+        D1 = 49, /* 1 */
+        D2 = 50, /* 2 */
+        D3 = 51, /* 3 */
+        D4 = 52, /* 4 */
+        D5 = 53, /* 5 */
+        D6 = 54, /* 6 */
+        D7 = 55, /* 7 */
+        D8 = 56, /* 8 */
+        D9 = 57, /* 9 */
+
+        Semicolon = 59, /* ; */
+        Equal = 61, /* = */
+
+        A = 65,
+        B = 66,
+        C = 67,
+        D = 68,
+        E = 69,
+        F = 70,
+        G = 71,
+        H = 72,
+        I = 73,
+        J = 74,
+        K = 75,
+        L = 76,
+        M = 77,
+        N = 78,
+        O = 79,
+        P = 80,
+        Q = 81,
+        R = 82,
+        S = 83,
+        T = 84,
+        U = 85,
+        V = 86,
+        W = 87,
+        X = 88,
+        Y = 89,
+        Z = 90,
+
+        LeftBracket = 91,  /* [ */
+        Backslash = 92,  /* \ */
+        RightBracket = 93,  /* ] */
+        GraveAccent = 96,  /* ` */
+
+        World1 = 161, /* non-US #1 */
+        World2 = 162, /* non-US #2 */
+
+        /* Function keys */
+        Escape = 256,
+        Enter = 257,
+        Tab = 258,
+        Backspace = 259,
+        Insert = 260,
+        Delete = 261,
+        Right = 262,
+        Left = 263,
+        Down = 264,
+        Up = 265,
+        PageUp = 266,
+        PageDown = 267,
+        Home = 268,
+        End = 269,
+        CapsLock = 280,
+        ScrollLock = 281,
+        NumLock = 282,
+        PrintScreen = 283,
+        Pause = 284,
+        F1 = 290,
+        F2 = 291,
+        F3 = 292,
+        F4 = 293,
+        F5 = 294,
+        F6 = 295,
+        F7 = 296,
+        F8 = 297,
+        F9 = 298,
+        F10 = 299,
+        F11 = 300,
+        F12 = 301,
+        F13 = 302,
+        F14 = 303,
+        F15 = 304,
+        F16 = 305,
+        F17 = 306,
+        F18 = 307,
+        F19 = 308,
+        F20 = 309,
+        F21 = 310,
+        F22 = 311,
+        F23 = 312,
+        F24 = 313,
+        F25 = 314,
+
+        /* Keypad */
+        KP0 = 320,
+        KP1 = 321,
+        KP2 = 322,
+        KP3 = 323,
+        KP4 = 324,
+        KP5 = 325,
+        KP6 = 326,
+        KP7 = 327,
+        KP8 = 328,
+        KP9 = 329,
+        KPDecimal = 330,
+        KPDivide = 331,
+        KPMultiply = 332,
+        KPSubtract = 333,
+        KPAdd = 334,
+        KPEnter = 335,
+        KPEqual = 336,
+
+        LeftShift = 340,
+        LeftControl = 341,
+        LeftAlt = 342,
+        LeftSuper = 343,
+        RightShift = 344,
+        RightControl = 345,
+        RightAlt = 346,
+        RightSuper = 347,
+        Menu = 348
+
+    }
+}

Prism-ScriptCore/Src/Prism/Math/Mat4.cs

@@ -0,0 +1,75 @@
+using System.Runtime.InteropServices;
+
+namespace Prism
+{
+    [StructLayout(LayoutKind.Explicit)]
+    public struct Mat4
+    {
+        [FieldOffset( 0)] public float D00;
+        [FieldOffset( 4)] public float D10;
+        [FieldOffset( 8)] public float D20;
+        [FieldOffset(12)] public float D30;
+        [FieldOffset(16)] public float D01;
+        [FieldOffset(20)] public float D11;
+        [FieldOffset(24)] public float D21;
+        [FieldOffset(28)] public float D31;
+        [FieldOffset(32)] public float D02;
+        [FieldOffset(36)] public float D12;
+        [FieldOffset(40)] public float D22;
+        [FieldOffset(44)] public float D32;
+        [FieldOffset(48)] public float D03;
+        [FieldOffset(52)] public float D13;
+        [FieldOffset(56)] public float D23;
+        [FieldOffset(60)] public float D33;
+
+        public Mat4(float value)
+        {
+            D00 = value; D10 = 0.0f; D20 = 0.0f; D30 = 0.0f;
+            D01 = 0.0f; D11 = value; D21 = 0.0f; D31 = 0.0f;
+            D02 = 0.0f; D12 = 0.0f; D22 = value; D32 = 0.0f;
+            D03 = 0.0f; D13 = 0.0f; D23 = 0.0f; D33 = value;
+        }
+
+        public Vec3 Translation
+        { 
+            get { return new Vec3(D03, D13, D23); }
+            set { D03 = value.X; D13 = value.Y; D23 = value.Z; }
+        }
+
+        public static Mat4 Translate(Vec3 translation)
+        {
+            Mat4 result = new Mat4(1.0f);
+            result.D03 = translation.X;
+            result.D13 = translation.Y;
+            result.D23 = translation.Z;
+            return result;
+        }
+
+        public static Mat4 Scale(Vec3 scale)
+        {
+            Mat4 result = new Mat4(1.0f);
+            result.D00 = scale.X;
+            result.D11 = scale.Y;
+            result.D22 = scale.Z;
+            return result;
+        }
+
+        public static Mat4 Scale(float scale)
+        {
+            Mat4 result = new Mat4(1.0f);
+            result.D00 = scale;
+            result.D11 = scale;
+            result.D22 = scale;
+            return result;
+        }
+
+        public void DebugPrint()
+        {
+            Console.WriteLine("{0:0.00}  {1:0.00}  {2:0.00}  {3:0.00}", D00, D10, D20, D30);
+            Console.WriteLine("{0:0.00}  {1:0.00}  {2:0.00}  {3:0.00}", D01, D11, D21, D31);
+            Console.WriteLine("{0:0.00}  {1:0.00}  {2:0.00}  {3:0.00}", D02, D12, D22, D32);
+            Console.WriteLine("{0:0.00}  {1:0.00}  {2:0.00}  {3:0.00}", D03, D13, D23, D33);
+        }
+
+    }
+}

Prism-ScriptCore/Src/Prism/Math/Noise.cs

@@ -0,0 +1,16 @@
+using System.Runtime.CompilerServices;
+
+namespace Prism
+{
+    public static class Noise
+    {
+        public static float PerlinNoise(float x, float y)
+        {
+            return PerlinNoise_Native(x, y);
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern float PerlinNoise_Native(float x, float y);
+
+    }
+}

Prism-ScriptCore/Src/Prism/Math/Vec2.cs

@@ -0,0 +1,22 @@
+using System.Runtime.InteropServices;
+
+namespace Prism
+{
+    [StructLayout(LayoutKind.Sequential)]
+    public struct Vec2
+    {
+        public float X;
+        public float Y;
+
+        public Vec2(float scalar)
+        {
+            X = Y = scalar;
+        }
+
+        public Vec2(float x, float y)
+        {
+            X = x;
+            Y = y;
+        }
+    }
+}

Prism-ScriptCore/Src/Prism/Math/Vec3.cs

@@ -0,0 +1,26 @@
+using System.Runtime.InteropServices;
+
+namespace Prism
+{
+    [StructLayout(LayoutKind.Explicit)]
+    public struct Vec3
+    {
+        [FieldOffset(0)] public float X;
+        [FieldOffset(4)] public float Y;
+        [FieldOffset(8)] public float Z;
+
+        public Vec3(float scalar)
+        {
+            X = Y = Z = scalar;
+        }
+
+        public Vec3(float x, float y, float z)
+        {
+            X = x;
+            Y = y;
+            Z = z;
+        }
+
+
+    }
+}

Prism-ScriptCore/Src/Prism/Math/Vec4.cs

@@ -0,0 +1,69 @@
+using System.Runtime.InteropServices;
+
+namespace Prism
+{
+    [StructLayout(LayoutKind.Explicit)]
+    public struct Vec4
+    {
+        [FieldOffset(0)] public float X;
+        [FieldOffset(4)] public float Y;
+        [FieldOffset(8)] public float Z;
+        [FieldOffset(12)] public float W;
+
+        public Vec4(float scalar)
+        {
+            X = Y = Z = W =scalar;
+        }
+
+        public Vec4(float x, float y, float z, float w)
+        {
+            X = x;
+            Y = y;
+            Z = z;
+            W = w;
+        }
+
+        public static Vec4 operator+(Vec4 left, Vec4 right)
+        {
+            return new Vec4(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
+        }
+
+        public static Vec4 operator-(Vec4 left, Vec4 right)
+        {
+            return new Vec4(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
+        }
+
+        public static Vec4 operator*(Vec4 left, Vec4 right)
+        {
+            return new Vec4(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
+        }
+
+        public static Vec4 operator *(Vec4 left, float scalar)
+        {
+            return new Vec4(left.X * scalar, left.Y * scalar, left.Z * scalar, left.W * scalar);
+        }
+
+        public static Vec4 operator *(float scalar, Vec4 right)
+        {
+            return new Vec4(scalar * right.X, scalar * right.Y, scalar * right.Z, scalar * right.W);
+        }
+
+        public static Vec4 operator/(Vec4 left, Vec4 right)
+        {
+            return new Vec4(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
+        }
+
+        public static Vec4 operator /(Vec4 left, float scalar)
+        {
+            return new Vec4(left.X / scalar, left.Y / scalar, left.Z / scalar, left.W / scalar);
+        }
+
+        public static Vec4 Lerp(Vec4 a, Vec4 b, float t)
+        {
+            if (t < 0.0f) t = 0.0f;
+            if (t > 1.0f) t = 1.0f;
+            return (1.0f - t) * a + t * b;
+        }
+
+    }
+}

Prism-ScriptCore/Src/Prism/Renderer/Color.cs

@@ -0,0 +1,10 @@
+
+namespace Prism
+{
+    public class Color
+    {
+        public static Vec4 Black { get { return new Vec4(0.0f, 0.0f, 0.0f, 1.0f); } }
+        public static Vec4 White { get { return new Vec4(1.0f, 1.0f, 1.0f, 1.0f); } }
+
+    }
+}

Prism-ScriptCore/Src/Prism/Renderer/Material.cs

@@ -0,0 +1,87 @@
+using System.Runtime.CompilerServices;
+
+namespace Prism
+{
+    public class Material
+    {
+        public void Set(string uniform, float value)
+        {
+            SetFloat_Native(m_UnmanagedInstance, uniform, value);
+        }
+
+        public void Set(string uniform, Texture2D texture)
+        {
+            SetTexture_Native(m_UnmanagedInstance, uniform, texture.m_UnmanagedInstance);
+        }
+
+        public void SetTexture(string uniform, Texture2D texture)
+        {
+            SetTexture_Native(m_UnmanagedInstance, uniform, texture.m_UnmanagedInstance);
+        }
+
+        internal Material(IntPtr unmanagedInstance)
+        {
+            m_UnmanagedInstance = unmanagedInstance;
+        }
+
+        ~Material()
+        {
+            Destructor_Native(m_UnmanagedInstance);
+        }
+
+        internal IntPtr m_UnmanagedInstance;
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern void Destructor_Native(IntPtr unmanagedInstance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern void SetFloat_Native(IntPtr unmanagedInstance, string uniform, float value);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern void SetTexture_Native(IntPtr unmanagedInstance, string uniform, IntPtr texture);
+
+    }
+
+    public class MaterialInstance
+    {
+        public void Set(string uniform, float value)
+        {
+            SetFloat_Native(m_UnmanagedInstance, uniform, value);
+        }
+
+        public void Set(string uniform, Texture2D texture)
+        {
+            SetTexture_Native(m_UnmanagedInstance, uniform, texture.m_UnmanagedInstance);
+        }
+
+        public void Set(string uniform, Vec3 value)
+        {
+            SetVec3_Native(m_UnmanagedInstance, uniform, ref value);
+        }
+
+
+        public void SetTexture(string uniform, Texture2D texture)
+        {
+            SetTexture_Native(m_UnmanagedInstance, uniform, texture.m_UnmanagedInstance);
+        }
+
+        internal MaterialInstance(IntPtr unmanagedInstance)
+        {
+            m_UnmanagedInstance = unmanagedInstance;
+        }
+
+        ~MaterialInstance()
+        {
+            Destructor_Native(m_UnmanagedInstance);
+        }
+
+        internal IntPtr m_UnmanagedInstance;
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern void Destructor_Native(IntPtr unmanagedInstance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern void SetFloat_Native(IntPtr unmanagedInstance, string uniform, float value);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern void SetVec3_Native(IntPtr unmanagedInstance, string uniform, ref Vec3 value);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern void SetTexture_Native(IntPtr unmanagedInstance, string uniform, IntPtr texture);
+    }
+}

Prism-ScriptCore/Src/Prism/Renderer/Mesh.cs

@@ -0,0 +1,54 @@
+using System.Runtime.CompilerServices;
+
+namespace Prism
+{
+    public class Mesh
+    {
+        public Mesh(string filepath)
+        {
+            m_UnmanagedInstance = Constructor_Native(filepath);
+        }
+
+        internal Mesh(IntPtr unmanagedInstance)
+        {
+            m_UnmanagedInstance = unmanagedInstance;
+        }
+
+        ~Mesh()
+        {
+            Destructor_Native(m_UnmanagedInstance);
+        }
+
+        public Material BaseMaterial
+        { 
+            get
+            {
+                return new Material(GetMaterial_Native(m_UnmanagedInstance));
+            }
+        }
+
+        public MaterialInstance GetMaterial(int index)
+        {
+            return new MaterialInstance(GetMaterialByIndex_Native(m_UnmanagedInstance, index));
+        }
+
+        public int GetMaterialCount()
+        {
+            return GetMaterialCount_Native(m_UnmanagedInstance);
+        }
+
+        internal IntPtr m_UnmanagedInstance;
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern IntPtr Constructor_Native(string filepath);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern void Destructor_Native(IntPtr unmanagedInstance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern IntPtr GetMaterial_Native(IntPtr unmanagedInstance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern IntPtr GetMaterialByIndex_Native(IntPtr unmanagedInstance, int index);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern int GetMaterialCount_Native(IntPtr unmanagedInstance);
+
+    }
+}

Prism-ScriptCore/Src/Prism/Renderer/MeshFactory.cs

@@ -0,0 +1,17 @@
+using System.Runtime.CompilerServices;
+
+namespace Prism
+{
+    public static class MeshFactory
+    {
+
+        public static Mesh CreatePlane(float width, float height)
+        {
+            return new Mesh(CreatePlane_Native(width, height));
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern IntPtr CreatePlane_Native(float width, float height);
+
+    }
+}

Prism-ScriptCore/Src/Prism/Renderer/Texture2D.cs

@@ -0,0 +1,34 @@
+using System.Runtime.CompilerServices;
+
+namespace Prism
+{
+    public class Texture2D
+    {
+
+        public Texture2D(uint width, uint height)
+        {
+            m_UnmanagedInstance = Constructor_Native(width, height);
+        }
+
+        ~Texture2D()
+        {
+            Destructor_Native(m_UnmanagedInstance);
+        }
+
+        public void SetData(Vec4[] data)
+        {
+            SetData_Native(m_UnmanagedInstance, data, data.Length);
+        }
+
+        internal IntPtr m_UnmanagedInstance;
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern IntPtr Constructor_Native(uint width, uint height);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern void Destructor_Native(IntPtr unmanagedInstance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern void SetData_Native(IntPtr unmanagedInstance, Vec4[] data, int size);
+
+        
+    }
+}

Prism-ScriptCore/Src/Prism/Scene/Component.cs

@@ -0,0 +1,95 @@
+using System.Runtime.CompilerServices;
+
+namespace Prism
+{
+    public abstract class Component
+    {
+        public Entity Entity { get; set; }
+
+    }
+
+    public class TagComponent : Component
+    {
+        public string Tag
+        {
+            get
+            {
+                return GetTag_Native(Entity.SceneID, Entity.EntityID);
+            }
+            set
+            {
+                SetTag_Native(value);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern string GetTag_Native(uint sceneID, uint entityID);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern void SetTag_Native(string tag);
+
+    }
+
+    public class TransformComponent : Component
+    {
+        public Mat4 Transform
+        {
+            get
+            {
+                Mat4 result;
+                GetTransform_Native(Entity.SceneID, Entity.EntityID, out result);
+                return result;
+            }
+            set
+            {
+                SetTransform_Native(Entity.SceneID, Entity.EntityID, ref value);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern void GetTransform_Native(uint sceneID, uint entityID, out Mat4 result);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern void SetTransform_Native(uint sceneID, uint entityID, ref Mat4 result);
+
+    }
+
+    public class MeshComponent : Component
+    {
+        public Mesh Mesh
+        {
+            get
+            {
+                Mesh result = new Mesh(GetMesh_Native(Entity.SceneID, Entity.EntityID));
+                return result;
+            }
+            set
+            {
+                IntPtr ptr = value == null ? IntPtr.Zero : value.m_UnmanagedInstance;
+                SetMesh_Native(Entity.SceneID, Entity.EntityID, ptr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern IntPtr GetMesh_Native(uint sceneID, uint entityID);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern void SetMesh_Native(uint sceneID, uint entityID, IntPtr unmanagedInstance);
+
+    }
+
+    public class CameraComponent : Component
+    {
+       // TODO
+    }
+
+    public class ScriptComponent : Component
+    {
+        // TODO
+    }
+
+    public class SpriteRendererComponent : Component
+    {
+        // TODO
+    }
+}

Prism-ScriptCore/Src/Prism/SpriteRenderer.cs

@@ -0,0 +1,32 @@
+
+namespace Prism
+{
+    public class SpriteRenderer : Component
+    {
+
+        /* public Texture2D Texture
+         {
+             get
+             {
+                 Texture2D tex;
+                 GetTexture_Native(Entity.EntityID, Entity.SceneID, out tex);
+                 return tex;
+             }
+             set { }
+         }
+
+
+         public Vec4 Color
+         {
+             get;
+             set;
+         }
+
+         public float TilingFactor
+         {
+             get;
+             set;
+         }*/
+
+    }
+}