diff --git a/Src/Game.NET/Core/Engine.cs b/Src/Game.NET/Core/Engine.cs
index db935d2..e72eba0 100644
--- a/Src/Game.NET/Core/Engine.cs
+++ b/Src/Game.NET/Core/Engine.cs
@@ -1,4 +1,9 @@
-using Game.NET.Logic;
+using System.Collections.Generic;
+using Game.NET.Gfx;
+using Game.NET.Logic;
+using OpenTK;
+using OpenTK.Graphics;
+using OpenTK.Graphics.OpenGL;
 
 namespace Game.NET.Core
 {
@@ -10,6 +15,25 @@ public class Engine
 
         public bool IsDone { get; private set; }
 
+        public IResourceManager ResourceManager
+        {
+            get
+            {
+                if (_resourceManager == null)
+                    _resourceManager = new ResourceManager();
+                return _resourceManager;
+            }
+        }
+
+        private List<State> states = new List<State>();
+
+        private GameWindow window;
+        private Renderer renderer = new Renderer();
+        private IResourceManager _resourceManager;
+        
+        private float fpsTime;
+        private int frames;
+
         public Engine()
         {
             IsDone = true;
@@ -18,9 +42,12 @@ public Engine()
         public bool Init(string[] argv = null, string config = "Config.cfg")
         {
             IsDone = false;
+
+            renderer.CreateBatch("default");
+
             return true;
         }
-
+        
         public void SwitchState(State state)
         {
             if (CurrentState != null) CurrentState.End();
@@ -30,9 +57,48 @@ public void SwitchState(State state)
             if (CurrentState != null) CurrentState.Start();
         }
 
+        public void ProcessInput()
+        {
+            if(CurrentState != null) CurrentState.ProcessInput();
+        }
+
+        public void Update(GameTime time)
+        {
+            time.RealTime += time.DeltaTime;
+            time.Time += time.Speed * time.DeltaTime;
+
+            if (fpsTime >= 1.0f)
+            {
+                time.Fps = frames / fpsTime;
+                frames = 0;
+                fpsTime = 0.0f;
+            }
+            
+            if (CurrentState != null) CurrentState.Update(time);
+        }
+
+        public void Draw(GameTime time)
+        {
+            frames++;
+            fpsTime += time.DeltaTime;
+
+            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
+
+            if (CurrentState != null) CurrentState.Draw(renderer, time);
+
+            renderer.Draw();
+        }
+
+        public void Exit()
+        {
+            IsDone = true;
+        }
+
         public void CleanUp()
         {
             IsDone = true;
+            // free data
+            ResourceManager.CleanAll();
         }
     }
 }
diff --git a/Src/Game.NET/Core/ResourceManager/ResourceManager.cs b/Src/Game.NET/Core/ResourceManager/ResourceManager.cs
index 9a05135..123de65 100644
--- a/Src/Game.NET/Core/ResourceManager/ResourceManager.cs
+++ b/Src/Game.NET/Core/ResourceManager/ResourceManager.cs
@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 
 namespace Game.NET
 {
@@ -52,6 +53,7 @@ public void Remove<T>(T resource) where T : Resource
         {
             if (Contains<T>(resource.Name))
             {
+                Delete(resource);
                 _resources.Remove(resource.Name);
             }
         }
@@ -60,13 +62,28 @@ public void Remove<T>(string name) where T : Resource
         {
             if (Contains<T>(name))
             {
+                Delete(_resources[name]);
                 _resources.Remove(name);
             }
         }
 
         public void CleanAll()
         {
+            foreach (var resource in _resources)
+            {
+                Delete(resource.Value);
+            }
+
             _resources.Clear();
         }
+
+        private void Delete(Resource resource)
+        {
+            IDisposable disposable = resource as IDisposable;
+            if (disposable != null)
+            {
+                disposable.Dispose();
+            }
+        }
     }
 }
diff --git a/Src/Game.NET/Game.NET.csproj b/Src/Game.NET/Game.NET.csproj
index 8ac3461..0bc40f8 100644
--- a/Src/Game.NET/Game.NET.csproj
+++ b/Src/Game.NET/Game.NET.csproj
@@ -23,6 +23,7 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <Prefer32Bit>false</Prefer32Bit>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>
@@ -58,12 +59,24 @@
     <Compile Include="Core\Engine.cs" />
     <Compile Include="Core\GameTime.cs" />
     <Compile Include="Core\Input.cs" />
+    <Compile Include="Gfx\RenderBatch.cs" />
+    <Compile Include="Gfx\Renderer.cs" />
+    <Compile Include="Gfx\RenderTarget.cs" />
+    <Compile Include="Gfx\Sprite.cs" />
     <Compile Include="Gfx\TransitionEffect.cs" />
     <Compile Include="Logic\Entity.cs" />
     <Compile Include="Logic\State.cs" />
     <Compile Include="Logic\Transition.cs" />
     <Compile Include="Parsing\Menu\MenuParsingService.cs" />
     <Compile Include="Parsing\Menu\MenuParsingWorker.cs" />
+    <Compile Include="Resources\Material\Material.cs" />
+    <Compile Include="Resources\Material\Matrix4Uniform.cs" />
+    <Compile Include="Resources\MeshFactory.cs" />
+    <Compile Include="Resources\Mesh\VertexAttribute.cs" />
+    <Compile Include="Resources\Mesh\SubMesh.cs" />
+    <Compile Include="Resources\Material\Uniform.cs" />
+    <Compile Include="Resources\Mesh\Vertex.cs" />
+    <Compile Include="Resources\SpriteSheet.cs" />
     <Compile Include="States\Menu\Menu.cs" />
     <Compile Include="States\Menu\MenuEntry.cs" />
     <Compile Include="Utils\Exception\GameException.cs" />
@@ -78,7 +91,7 @@
     <Compile Include="Resources\ShaderFactory.cs" />
     <Compile Include="Resources\Shader\ShaderFileInfo.cs" />
     <Compile Include="Resources\Shader\ShaderProgram.cs" />
-    <Compile Include="Resources\Mesh\SubMesh.cs" />
+    <Compile Include="Resources\Mesh\ObjSubMesh.cs" />
     <Compile Include="Utils\OpenTKExtensions\VectorExtension.cs" />
     <Compile Include="Parsing\FileParser.cs" />
     <Compile Include="Parsing\FileType.cs" />
@@ -94,6 +107,7 @@
   </ItemGroup>
   <ItemGroup>
     <Folder Include="Logic\Dialog\" />
+    <Folder Include="Parsing\State\" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/Src/Game.NET/Gfx/RenderBatch.cs b/Src/Game.NET/Gfx/RenderBatch.cs
new file mode 100644
index 0000000..59e25b7
--- /dev/null
+++ b/Src/Game.NET/Gfx/RenderBatch.cs
@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using OpenTK.Graphics.OpenGL;
+
+namespace Game.NET.Gfx
+{
+    public class RenderBatch
+    {
+        private List<Renderer.DrawMeshCommand> _commands = new List<Renderer.DrawMeshCommand>();
+
+        public void Add(Renderer.DrawMeshCommand cmd)
+        {
+            _commands.Add(cmd);
+        }
+
+        public void Submit()
+        {
+            foreach (var cmd in _commands)
+            {
+                cmd.material.Use();
+                cmd.mesh.Use();
+                
+                //GL.DrawElements(cmd.mode, cmd.count, cmd.type, cmd.mesh.indicies);
+            }
+
+            _commands.Clear();
+        }
+    }
+}
diff --git a/Src/Game.NET/Gfx/RenderTarget.cs b/Src/Game.NET/Gfx/RenderTarget.cs
new file mode 100644
index 0000000..6d3fb52
--- /dev/null
+++ b/Src/Game.NET/Gfx/RenderTarget.cs
@@ -0,0 +1,11 @@
+namespace Game.NET.Gfx
+{
+    public abstract class RenderTarget
+    {
+        public abstract void Use();
+
+        public abstract void Clear();
+
+        public abstract void Swap();
+    }
+}
diff --git a/Src/Game.NET/Gfx/Renderer.cs b/Src/Game.NET/Gfx/Renderer.cs
new file mode 100644
index 0000000..90f14c4
--- /dev/null
+++ b/Src/Game.NET/Gfx/Renderer.cs
@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+using Game.NET.Resources;
+using OpenTK.Graphics.OpenGL;
+
+namespace Game.NET.Gfx
+{
+    public class Renderer
+    {
+        private Dictionary<string, RenderBatch> batches = new Dictionary<string, RenderBatch>();
+        private RenderTarget _target;
+
+        public class DrawMeshCommand
+        {
+            public BaseSubMesh mesh;
+            public Material material;
+        }
+
+        public void SetRenderTarget(RenderTarget target)
+        {
+            _target = target;
+        }
+
+        public void CreateBatch(string name)
+        {
+            batches.Add(name, new RenderBatch());
+        }
+
+        public void DrawMesh(DrawMeshCommand cmd, string batch)
+        {
+            batches[batch].Add(cmd);
+        }
+
+        public void Draw()
+        {
+            if (_target == null)
+                return;
+
+            _target.Use();
+            _target.Clear();
+
+            foreach (var batch in batches.Values)
+            {
+                batch.Submit();
+            }
+
+            _target.Swap();
+        }
+    }
+}
diff --git a/Src/Game.NET/Gfx/Sprite.cs b/Src/Game.NET/Gfx/Sprite.cs
new file mode 100644
index 0000000..4c6aa50
--- /dev/null
+++ b/Src/Game.NET/Gfx/Sprite.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Game.NET.Gfx
+{
+    class Sprite
+    {
+    }
+}
diff --git a/Src/Game.NET/Logic/State.cs b/Src/Game.NET/Logic/State.cs
index 188d7f7..6fa8ac2 100644
--- a/Src/Game.NET/Logic/State.cs
+++ b/Src/Game.NET/Logic/State.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using Game.NET.Core;
+using Game.NET.Gfx;
 
 namespace Game.NET.Logic
 {
@@ -22,5 +23,7 @@ public State(Engine engine)
         public abstract void ProcessInput();
 
         public abstract void CleanUp();
+
+        public abstract void Draw(Renderer renderer, GameTime time);
     }
 }
diff --git a/Src/Game.NET/Logic/Transition.cs b/Src/Game.NET/Logic/Transition.cs
index fa76b2e..99c4b94 100644
--- a/Src/Game.NET/Logic/Transition.cs
+++ b/Src/Game.NET/Logic/Transition.cs
@@ -1,4 +1,5 @@
 using Game.NET.Core;
+using Game.NET.Gfx;
 
 namespace Game.NET.Logic
 {
@@ -58,13 +59,13 @@ public override void Update(GameTime gameTime)
                 _engine.SwitchState(TargetState);
         }
 
-        /*public override void Draw()
+        public override void Draw(Renderer renderer, GameTime time)
         {
             if (InitialState != null && Out != null && !Out.IsFinished)
                 Out.Draw(InitialState);
             else if (TargetState != null && In != null)
                 In.Draw(TargetState);
-        }*/
+        }
 
         public override void ProcessInput()
         {
@@ -75,7 +76,7 @@ public override void CleanUp()
         {
 
         }
-
+        
         #endregion
     }
 }
\ No newline at end of file
diff --git a/Src/Game.NET/Parsing/FileParser.cs b/Src/Game.NET/Parsing/FileParser.cs
index 891efaa..b161637 100644
--- a/Src/Game.NET/Parsing/FileParser.cs
+++ b/Src/Game.NET/Parsing/FileParser.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.IO;
+using Game.NET.Logic;
 using Game.NET.Parsing.IO;
 using Game.NET.Parsing.Obj;
 
@@ -24,10 +25,10 @@ private static IDictionary<FileType, IParsingService> GetDefaultServices()
         {
             return new Dictionary<FileType, IParsingService>()
             {
-                [FileType.Obj] = new ObjParsingService(),
+                [FileType.Obj] = new ObjParsingService()
             };
         }
-
+        
         public Mesh LoadMesh(string path, FileType fileType)
         {
             string fileName = Path.GetFileName(path);
diff --git a/Src/Game.NET/Parsing/FileType.cs b/Src/Game.NET/Parsing/FileType.cs
index cbb22bc..b0081c1 100644
--- a/Src/Game.NET/Parsing/FileType.cs
+++ b/Src/Game.NET/Parsing/FileType.cs
@@ -2,6 +2,8 @@
 {
     public enum FileType : byte
     {
-        Obj = 0
+        Obj = 0,
+        State = 1,
+        Menu = 2
     }
 }
diff --git a/Src/Game.NET/Parsing/Obj/ObjParsingWorker.cs b/Src/Game.NET/Parsing/Obj/ObjParsingWorker.cs
index df2c040..32cd834 100644
--- a/Src/Game.NET/Parsing/Obj/ObjParsingWorker.cs
+++ b/Src/Game.NET/Parsing/Obj/ObjParsingWorker.cs
@@ -12,13 +12,13 @@ internal class ObjParsingWorker
 
         public void ProcessObject(string line, Mesh mesh)
         {
-            mesh.SubMeshes.Add(new SubMesh());
+            mesh.ObjSubMeshes.Add(new ObjSubMesh());
         }
 
         public void ProcessVertex(string line, Mesh mesh)
         {
-            if (!mesh.SubMeshes.Any())
-                mesh.SubMeshes.Add(new SubMesh());
+            if (!mesh.ObjSubMeshes.Any())
+                mesh.ObjSubMeshes.Add(new ObjSubMesh());
 
             var tokens = line.Split(' ');
             if (tokens.Length != 4) return;
@@ -30,7 +30,7 @@ public void ProcessVertex(string line, Mesh mesh)
                 Z = float.Parse(tokens[3], Style, Info)
             };
 
-            mesh.SubMeshes.Last().Vertices.Add(vertex);
+            mesh.ObjSubMeshes.Last().Vertices.Add(vertex);
 
             //	Bounds
             if (vertex.X < mesh.MinVertex.X) mesh.MinVertex.X = vertex.X;
@@ -44,23 +44,23 @@ public void ProcessVertex(string line, Mesh mesh)
 
         public void ProcessTextCoord(string line, Mesh mesh)
         {
-            if(!mesh.SubMeshes.Any()) throw new InvalidOperationException("Cannot add texture because submesh collection is empty");
+            if(!mesh.ObjSubMeshes.Any()) throw new InvalidOperationException("Cannot add texture because submesh collection is empty");
 
             var tokens = line.Split(' ');
             if (tokens.Length != 3) return;
 
-            Vector3 texture = new Vector3
+            Vector2 texture = new Vector2
             {
                 X = float.Parse(tokens[1], Style, Info),
                 Y = float.Parse(tokens[2], Style, Info)
             };
 
-            mesh.SubMeshes.Last().Textures.Add(texture);
+            mesh.ObjSubMeshes.Last().Textures.Add(texture);
         }
 
         public void ProcessNormal(string line, Mesh mesh)
         {
-            if (!mesh.SubMeshes.Any()) throw new InvalidOperationException("Cannot add normal because submesh collection is empty");
+            if (!mesh.ObjSubMeshes.Any()) throw new InvalidOperationException("Cannot add normal because submesh collection is empty");
 
             var tokens = line.Split(' ');
             if (tokens.Length != 4) return;
@@ -72,12 +72,12 @@ public void ProcessNormal(string line, Mesh mesh)
                 Z = float.Parse(tokens[3], Style, Info)
             };
 
-            mesh.SubMeshes.Last().Normals.Add(normal);
+            mesh.ObjSubMeshes.Last().Normals.Add(normal);
         }
 
         public void ProcessFace(string line, Mesh mesh)
         {
-            if (!mesh.SubMeshes.Any()) throw new InvalidOperationException("Cannot add face because submesh collection is empty");
+            if (!mesh.ObjSubMeshes.Any()) throw new InvalidOperationException("Cannot add face because submesh collection is empty");
 
             var tokens = line.Remove(0, 2).Split(' ');
 
@@ -107,7 +107,7 @@ public void ProcessFace(string line, Mesh mesh)
                 face.Items.Add(item);
             }
 
-            mesh.SubMeshes.Last().Faces.Add(face);
+            mesh.ObjSubMeshes.Last().Faces.Add(face);
         }
     }
 }
diff --git a/Src/Game.NET/Resources/Material/Material.cs b/Src/Game.NET/Resources/Material/Material.cs
new file mode 100644
index 0000000..63c80fa
--- /dev/null
+++ b/Src/Game.NET/Resources/Material/Material.cs
@@ -0,0 +1,54 @@
+using System.Collections.Generic;
+using OpenTK.Graphics.OpenGL;
+
+namespace Game.NET.Resources
+{
+    public class MaterialParameter<T>
+    {
+        public T value;
+        public int location;
+
+        public MaterialParameter(int loc, T val)
+        {
+            location = loc;
+            value = val;
+        }
+    }
+
+    public class Material : Resource
+    {
+        public readonly ShaderProgram program;
+        
+        private Dictionary<string, UniformBase> uniforms = new Dictionary<string, UniformBase>();
+
+        public Material(ShaderProgram program)
+        {
+            this.program = program;
+        }
+
+        public void AddUniform<T>(string name, Uniform<T> uniform)
+        {
+            if (!uniforms.ContainsKey(name))
+            {
+                uniforms.Add(name, uniform);
+            }
+        }
+
+        public void Set<T>(string name, T value)
+        {
+            if(uniforms.ContainsKey(name))
+                ((Uniform<T>) uniforms[name]).Set(value, program);
+        }
+        
+        public void Use()
+        {
+            GL.UseProgram(program.Handle);
+            foreach (var uni in uniforms.Values)
+            {
+                uni.Bind();
+            }
+        }
+
+        // public void SetTexture(string name, Texture texture)
+    }
+}
diff --git a/Src/Game.NET/Resources/Material/Matrix4Uniform.cs b/Src/Game.NET/Resources/Material/Matrix4Uniform.cs
new file mode 100644
index 0000000..96df0b7
--- /dev/null
+++ b/Src/Game.NET/Resources/Material/Matrix4Uniform.cs
@@ -0,0 +1,18 @@
+using OpenTK;
+using OpenTK.Graphics.OpenGL;
+
+namespace Game.NET.Resources
+{
+    public class Matrix4Uniform : Uniform<Matrix4>
+    {
+        public Matrix4Uniform(string name, Matrix4 value, ShaderProgram program) : base(name)
+        {
+            Set(value, program);
+        }
+
+        public override void Bind()
+        {
+            GL.UniformMatrix4(location, false, ref stored);
+        }
+    }
+}
diff --git a/Src/Game.NET/Resources/Material/Uniform.cs b/Src/Game.NET/Resources/Material/Uniform.cs
new file mode 100644
index 0000000..e8807a7
--- /dev/null
+++ b/Src/Game.NET/Resources/Material/Uniform.cs
@@ -0,0 +1,31 @@
+using OpenTK.Graphics.OpenGL;
+
+namespace Game.NET.Resources
+{
+    public abstract class UniformBase
+    {
+        public readonly string Name;
+        protected int location;
+
+        public abstract void Bind();
+
+        protected UniformBase(string name)
+        {
+            Name = name;
+        }
+    }
+
+    public abstract class Uniform<T> : UniformBase
+    {
+        protected T stored;
+
+        protected Uniform(string name)
+            : base(name) { }
+
+        public void Set(T value, ShaderProgram program)
+        {
+            stored = value;
+            location = GL.GetUniformLocation(program.Handle, Name);
+        }
+    }
+}
diff --git a/Src/Game.NET/Resources/Mesh/Mesh.cs b/Src/Game.NET/Resources/Mesh/Mesh.cs
index 2c334d8..15b34f9 100644
--- a/Src/Game.NET/Resources/Mesh/Mesh.cs
+++ b/Src/Game.NET/Resources/Mesh/Mesh.cs
@@ -1,30 +1,90 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Numerics;
+using Game.NET.Resources;
+using OpenTK.Graphics.OpenGL;
 
 namespace Game.NET
 {
-    public class Mesh : Resource
+    public class Mesh : Resource, IDisposable
     {
         public string Filename { get; set; }
         public Vector3 MinVertex;
         public Vector3 MaxVertex;
+        private bool _disposed;
 
-        public List<SubMesh> SubMeshes { get; set; }
+        public List<ObjSubMesh> ObjSubMeshes { get; set; }
+        private List<BaseSubMesh> SubMeshes { get; set; }
 
         public Mesh(string fileName = null)
         {
             Filename = fileName;
             MinVertex = new Vector3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity);
             MaxVertex = new Vector3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity);
-            SubMeshes = new List<SubMesh>();
+            ObjSubMeshes = new List<ObjSubMesh>();
+            SubMeshes = new List<BaseSubMesh>();
         }
 
-        public Mesh(string filename, List<SubMesh> subMeshes)
+        public Mesh(string filename, List<ObjSubMesh> objSubMeshes)
         {
             Filename = filename;
             MinVertex = new Vector3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity);
             MaxVertex = new Vector3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity);
-            SubMeshes = subMeshes;
+            ObjSubMeshes = objSubMeshes;
+            SubMeshes = new List<BaseSubMesh>();
+        }
+
+        public void Upload(BufferUsageHint usage)
+        {
+            foreach (var subMesh in SubMeshes)
+            {
+                subMesh.Upload(usage);
+            }
+        }
+
+        public void CopyDataFromObj<T>(int vertexSize, SubMesh<T>.ParseVertex parser, bool clearAfter = false) where T : struct
+        {
+            SubMeshes.Clear();
+
+            foreach (var objSubMesh in ObjSubMeshes)
+            {
+                SubMesh<T> submesh = new SubMesh<T>(vertexSize);
+                submesh.CopyDataFromObj(objSubMesh, parser);
+                SubMeshes.Add(submesh);
+            }
+
+            if (clearAfter)
+            {
+                ObjSubMeshes.Clear();
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        public virtual void Dispose(bool disposing)
+        {
+            if (_disposed) return;
+
+            if (disposing)
+            {
+                foreach (var subMesh in SubMeshes)
+                {
+                    subMesh.Dispose();
+                }
+
+                ObjSubMeshes.Clear();
+            }
+
+            _disposed = true;
+        }
+
+        ~Mesh()
+        {
+            Dispose(false);
         }
     }
 }
diff --git a/Src/Game.NET/Resources/Mesh/ObjSubMesh.cs b/Src/Game.NET/Resources/Mesh/ObjSubMesh.cs
new file mode 100644
index 0000000..8485c09
--- /dev/null
+++ b/Src/Game.NET/Resources/Mesh/ObjSubMesh.cs
@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using System.Numerics;
+using OpenTK.Graphics.OpenGL;
+
+namespace Game.NET
+{
+    public class ObjSubMesh
+    {
+        public ObjSubMesh()
+        {
+            Vertices = new List<Vector3>();
+            Textures = new List<Vector2>();
+            Normals = new List<Vector3>();
+            Faces = new List<Face>();
+        }
+
+        public List<Vector3> Vertices { get; set; }
+        public List<Vector2> Textures { get; set; }
+        public List<Vector3> Normals  { get ;set; }
+        public List<Face> Faces { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/Src/Game.NET/Resources/Mesh/SubMesh.cs b/Src/Game.NET/Resources/Mesh/SubMesh.cs
index 148bf3b..0cc708a 100644
--- a/Src/Game.NET/Resources/Mesh/SubMesh.cs
+++ b/Src/Game.NET/Resources/Mesh/SubMesh.cs
@@ -1,21 +1,108 @@
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Numerics;
+using OpenTK.Graphics;
+using OpenTK.Graphics.OpenGL;
 
-namespace Game.NET
+namespace Game.NET.Resources
 {
-    public class SubMesh
+    public abstract class BaseSubMesh : IDisposable
     {
-        public SubMesh()
+        public abstract void Create();
+        public abstract void Upload(BufferUsageHint usage);
+        public abstract void Use();
+        public abstract void Dispose();
+    }
+
+    public class SubMesh<Vertex> : BaseSubMesh where Vertex : struct
+    {
+        public int Handle;
+        public int Index;
+
+        private readonly int vertexSize;
+
+        private Vertex[] vertices;
+        private uint[] indicies;
+        private bool _disposed;
+
+        public delegate Vertex ParseVertex(Vector3? pos, Vector3? norm, Vector2? tex);
+
+        public SubMesh(int vertexSize)
+        {
+            this.vertexSize = vertexSize;
+        }
+
+        public override void Create()
+        {
+            if (Handle != 0)
+                return;
+
+            Handle = GL.GenBuffer();
+            Index = GL.GenBuffer();
+        }
+        
+        internal void CopyDataFromObj(ObjSubMesh obj, ParseVertex parser)
         {
-            Vertices = new List<Vector3>();
-            Textures = new List<Vector3>();
-            Normals = new List<Vector3>();
-            Faces = new List<Face>();
+            List<Vertex> vertList = new List<Vertex>();
+            List<uint> indList = new List<uint>();
+            
+            foreach (var face in obj.Faces.SelectMany(face => face.Items))
+            {
+                Vertex vertex = parser
+                (
+                    obj.Vertices.Any() ? new Vector3?(obj.Vertices[(int) face.Vertex]) : null,
+                    obj.Normals.Any() ? new Vector3?(obj.Normals [(int) face.Normal]) : null,
+                    obj.Textures.Any() ? new Vector2?(obj.Textures[(int) face.Texture]) : null
+                );
+
+                if (!vertList.Contains(vertex))
+                {
+                    vertList.Add(vertex);
+                }
+
+                indList.Add((uint) vertList.IndexOf(vertex));
+            }
+
+            indicies = indList.ToArray();
+            vertices = vertList.ToArray();
         }
 
-        public List<Vector3> Vertices { get; set; }
-        public List<Vector3> Textures { get; set; }
-        public List<Vector3> Normals  {get ;set;}
-        public List<Face> Faces { get; set; }
+        public override void Upload(BufferUsageHint usage)
+        {
+            Use();
+            GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertices.Length * vertexSize), vertices, usage);
+            GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(indicies.Length * sizeof(uint)), indicies, usage);
+        }
+
+        public override void Use()
+        {
+            GL.BindBuffer(BufferTarget.ArrayBuffer, Handle);
+            GL.BindBuffer(BufferTarget.ElementArrayBuffer, Index);
+        }
+
+        public override void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed) return;
+
+            if (GraphicsContext.CurrentContext == null || GraphicsContext.CurrentContext.IsDisposed)
+                return;
+            
+            GL.DeleteBuffer(Handle);
+            GL.DeleteBuffer(Index);
+            
+            _disposed = true;
+        }
+
+        ~SubMesh()
+        {
+            Dispose(false);
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/Src/Game.NET/Resources/Mesh/Vertex.cs b/Src/Game.NET/Resources/Mesh/Vertex.cs
new file mode 100644
index 0000000..f8d65a6
--- /dev/null
+++ b/Src/Game.NET/Resources/Mesh/Vertex.cs
@@ -0,0 +1,21 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace Game.NET.Resources.Mesh
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct Vertex
+    {
+        public Vector3 Position;
+        public Vector2 Texture;
+        public Vector3 Normal;
+        // public Color4? Color;
+
+        public Vertex(Vector3 pos, Vector3 norm, Vector2 tex)
+        {
+            Position = pos;
+            Normal = norm;
+            Texture = tex;
+        }
+    }
+}
diff --git a/Src/Game.NET/Resources/Mesh/VertexAttribute.cs b/Src/Game.NET/Resources/Mesh/VertexAttribute.cs
new file mode 100644
index 0000000..b5ee601
--- /dev/null
+++ b/Src/Game.NET/Resources/Mesh/VertexAttribute.cs
@@ -0,0 +1,33 @@
+using OpenTK.Graphics.OpenGL;
+
+namespace Game.NET.Resources
+{
+    public class VertexAttribute
+    {
+        public readonly string Name;
+        public readonly VertexAttribPointerType Type;
+        public readonly int Size;
+        public readonly bool Normalize;
+        public readonly int Stride;
+        public readonly int Offset;
+        private bool _disposed;
+
+        public VertexAttribute(string name, VertexAttribPointerType type, int size, bool normalize, int stride, int offset)
+        {
+            Name = name;
+            Type = type;
+            Size = size;
+            Normalize = normalize;
+            Stride = stride;
+            Offset = offset;
+        }
+
+        public void Use(ShaderProgram program)
+        {
+            int index = GL.GetAttribLocation(program.Handle, Name);
+            
+            GL.EnableVertexAttribArray(index);
+            GL.VertexAttribPointer(index, Size, Type, Normalize, Stride, Offset);
+        }
+    }
+}
diff --git a/Src/Game.NET/Resources/MeshFactory.cs b/Src/Game.NET/Resources/MeshFactory.cs
new file mode 100644
index 0000000..5e38968
--- /dev/null
+++ b/Src/Game.NET/Resources/MeshFactory.cs
@@ -0,0 +1,41 @@
+using Game.NET.Parsing;
+using Game.NET.Resources.Mesh;
+using OpenTK.Graphics.OpenGL;
+
+namespace Game.NET.Resources
+{
+    public class MeshFactory
+    {
+        private readonly IResourceManager _resourceManager;
+        
+        public MeshFactory(IResourceManager resourceManager)
+        {
+            _resourceManager = resourceManager;
+        }
+        
+        public NET.Mesh LoadMeshFromObj<T>(string path, int sizeOfT, SubMesh<T>.ParseVertex vertexFormatter, BufferUsageHint usage = BufferUsageHint.StaticDraw, bool clearAfter = false) where T : struct
+        {
+            FileParser parser = new FileParser();
+            NET.Mesh result = parser.LoadMesh(path, FileType.Obj);
+
+            result.CopyDataFromObj<T>(sizeOfT, vertexFormatter, clearAfter);
+            result.Upload(usage);
+
+            _resourceManager.Insert(path, result);
+
+            return result;
+        }
+
+        public unsafe NET.Mesh LoadMeshFromObj(string path, BufferUsageHint usage = BufferUsageHint.StaticDraw, bool clearAfter = false)
+        {
+            return LoadMeshFromObj<Vertex>
+            (
+                path,
+                sizeof(Vertex),
+                (pos, norm, tex) => new Vertex(pos.Value, norm.Value, tex.Value), 
+                usage, 
+                clearAfter
+            );
+        }
+    }
+}
diff --git a/Src/Game.NET/Resources/Shader/Shader.cs b/Src/Game.NET/Resources/Shader/Shader.cs
index 7d0d51d..ef7b5bc 100644
--- a/Src/Game.NET/Resources/Shader/Shader.cs
+++ b/Src/Game.NET/Resources/Shader/Shader.cs
@@ -1,4 +1,5 @@
 using System;
+using OpenTK.Graphics;
 using OpenTK.Graphics.OpenGL;
 
 namespace Game.NET
@@ -62,6 +63,9 @@ protected virtual void Dispose(bool disposing)
         {
             if (_disposed) return;
 
+            if (GraphicsContext.CurrentContext == null || GraphicsContext.CurrentContext.IsDisposed)
+                return;
+
             GL.DeleteShader(Handle);
             Handle = -1;
             IsCompiled = false;
diff --git a/Src/Game.NET/Resources/ShaderFactory.cs b/Src/Game.NET/Resources/ShaderFactory.cs
index c4de053..ebaac26 100644
--- a/Src/Game.NET/Resources/ShaderFactory.cs
+++ b/Src/Game.NET/Resources/ShaderFactory.cs
@@ -8,13 +8,8 @@ namespace Game.NET
     public class ShaderFactory
     {
         private readonly IResourceManager _resourceManager;
-
-        public ShaderFactory() : this(new ResourceManager())
-        {
-            
-        }
-
-        internal ShaderFactory(IResourceManager resourceManager)
+        
+        public ShaderFactory(IResourceManager resourceManager)
         {
             _resourceManager = resourceManager;
         }
diff --git a/Src/Game.NET/Resources/SpriteSheet.cs b/Src/Game.NET/Resources/SpriteSheet.cs
new file mode 100644
index 0000000..381ee71
--- /dev/null
+++ b/Src/Game.NET/Resources/SpriteSheet.cs
@@ -0,0 +1,6 @@
+namespace Game.NET.Resources
+{
+    class SpriteSheet
+    {
+    }
+}
diff --git a/Src/Game.NET/States/Menu/Menu.cs b/Src/Game.NET/States/Menu/Menu.cs
index e67abdf..d4bf68d 100644
--- a/Src/Game.NET/States/Menu/Menu.cs
+++ b/Src/Game.NET/States/Menu/Menu.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using Game.NET.Core;
+using Game.NET.Gfx;
 using Game.NET.Logic;
 
 namespace Game.NET.States
@@ -44,6 +45,11 @@ public override void Update(GameTime gameTime)
 
         }
 
+        public override void Draw(Renderer renderer, GameTime time)
+        {
+
+        }
+
         public override void ProcessInput()
         {
             //if (Input.GetButton(Input.Button.Down).IsDown
diff --git a/Src/Tests/Game.NET.AcceptanceTests/ObjFileParserAcceptanceTests.cs b/Src/Tests/Game.NET.AcceptanceTests/ObjFileParserAcceptanceTests.cs
index a483b2d..1d5b091 100644
--- a/Src/Tests/Game.NET.AcceptanceTests/ObjFileParserAcceptanceTests.cs
+++ b/Src/Tests/Game.NET.AcceptanceTests/ObjFileParserAcceptanceTests.cs
@@ -31,10 +31,10 @@ public void CanLoadSampleObject()
             Assert.That(mesh.Filename, Is.EqualTo(fileName));
 
             // object
-            Assert.That(mesh.SubMeshes.Count, Is.EqualTo(1));
+            Assert.That(mesh.ObjSubMeshes.Count, Is.EqualTo(1));
 
             // vertex
-            SubMesh submesh = mesh.SubMeshes.First();
+            ObjSubMesh submesh = mesh.ObjSubMeshes.First();
             Assert.That(submesh.Vertices.Count, Is.EqualTo(12));
 
             // normal
diff --git a/Src/Tests/Game.NET.Tests/Model/MeshTests.cs b/Src/Tests/Game.NET.Tests/Model/MeshTests.cs
index 35abcfe..34da4d8 100644
--- a/Src/Tests/Game.NET.Tests/Model/MeshTests.cs
+++ b/Src/Tests/Game.NET.Tests/Model/MeshTests.cs
@@ -23,19 +23,19 @@ public void CanInitializePropertiesByConstructor(string fileName)
             Mesh mesh = new Mesh(fileName);
 
             Assert.That(mesh.Filename, Is.EqualTo(fileName));
-            Assert.That(mesh.SubMeshes, Is.Not.Null.And.Empty);
+            Assert.That(mesh.ObjSubMeshes, Is.Not.Null.And.Empty);
         }
 
         [Test]
         public void CanInitializeAllPropertiesByConstructor()
         {
             string filename = _fixture.Create<string>();
-            List<SubMesh> subMeshes = _fixture.Create<List<SubMesh>>();
+            List<ObjSubMesh> subMeshes = _fixture.Create<List<ObjSubMesh>>();
         
             Mesh mesh = new Mesh(filename, subMeshes);
 
             Assert.That(mesh.Filename, Is.EqualTo(filename));
-            Assert.That(mesh.SubMeshes, Is.Not.Null.And.EquivalentTo(subMeshes));
+            Assert.That(mesh.ObjSubMeshes, Is.Not.Null.And.EquivalentTo(subMeshes));
         }
     }
 }
diff --git a/Src/Tests/Game.NET.Tests/Model/SubMeshTests.cs b/Src/Tests/Game.NET.Tests/Model/SubMeshTests.cs
index 1478c11..6d6a1e7 100644
--- a/Src/Tests/Game.NET.Tests/Model/SubMeshTests.cs
+++ b/Src/Tests/Game.NET.Tests/Model/SubMeshTests.cs
@@ -8,7 +8,7 @@ public class SubMeshTests
         [Test]
         public void CanInitializePropertiesByConstructor()
         {
-            SubMesh subMesh = new SubMesh();
+            ObjSubMesh subMesh = new ObjSubMesh();
 
             Assert.That(subMesh.Faces, Is.Not.Null.And.Empty);
             Assert.That(subMesh.Normals, Is.Not.Null.And.Empty);
diff --git a/Src/Tests/Game.NET.Tests/Parsing/Obj/ObjParsingServiceTests.cs b/Src/Tests/Game.NET.Tests/Parsing/Obj/ObjParsingServiceTests.cs
index 584db2b..8491f8c 100644
--- a/Src/Tests/Game.NET.Tests/Parsing/Obj/ObjParsingServiceTests.cs
+++ b/Src/Tests/Game.NET.Tests/Parsing/Obj/ObjParsingServiceTests.cs
@@ -40,7 +40,7 @@ public void ReturnWhenLineIsEmpty(string line)
             Assert.That(mesh.MinVertex, Is.EqualTo(emptyMesh.MinVertex));
             Assert.That(mesh.MaxVertex, Is.EqualTo(emptyMesh.MaxVertex));
             Assert.That(mesh.Filename, Is.Null);
-            Assert.That(mesh.SubMeshes, Is.Empty);
+            Assert.That(mesh.ObjSubMeshes, Is.Empty);
         }
 
         [Test]
diff --git a/Src/Tests/Game.NET.Tests/Parsing/Obj/ObjParsingWorkerTests.cs b/Src/Tests/Game.NET.Tests/Parsing/Obj/ObjParsingWorkerTests.cs
index bddc60d..9f8ab85 100644
--- a/Src/Tests/Game.NET.Tests/Parsing/Obj/ObjParsingWorkerTests.cs
+++ b/Src/Tests/Game.NET.Tests/Parsing/Obj/ObjParsingWorkerTests.cs
@@ -12,11 +12,11 @@ public class ObjParsingWorkerTests
         public void ProcessObject_ShouldAddNewSubmesh()
         {
             Mesh mesh = new Mesh();
-            int baseSubmeshCount = mesh.SubMeshes.Count;
+            int baseSubmeshCount = mesh.ObjSubMeshes.Count;
             ObjParsingWorker worker = new ObjParsingWorker();
             worker.ProcessObject(string.Empty, mesh);
 
-            Assert.That(mesh.SubMeshes.Count, Is.EqualTo(baseSubmeshCount + 1));
+            Assert.That(mesh.ObjSubMeshes.Count, Is.EqualTo(baseSubmeshCount + 1));
         }
 
         [Test]
@@ -24,10 +24,10 @@ public void ProcessVertex_ShouldAddSubmeshIfCollectionIsEmpty()
         {
             Mesh mesh = new Mesh();
             ObjParsingWorker worker = new ObjParsingWorker();
-            int baseSubmeshCount = mesh.SubMeshes.Count;
+            int baseSubmeshCount = mesh.ObjSubMeshes.Count;
             worker.ProcessVertex(string.Empty, mesh);
 
-            Assert.That(mesh.SubMeshes.Count, Is.EqualTo(baseSubmeshCount + 1));
+            Assert.That(mesh.ObjSubMeshes.Count, Is.EqualTo(baseSubmeshCount + 1));
         }
 
         [Test]
@@ -35,7 +35,7 @@ public void ProcessVertex_ShouldAddVector3ToTheLastSubmeshAndAssingMinVertex()
         {
             Mesh mesh = new Mesh();
             ObjParsingWorker worker = new ObjParsingWorker();
-            int baseSubmeshCount = mesh.SubMeshes.Count;
+            int baseSubmeshCount = mesh.ObjSubMeshes.Count;
 
             float x = 1.000000f;
             float y = 1.000000f;
@@ -43,10 +43,10 @@ public void ProcessVertex_ShouldAddVector3ToTheLastSubmeshAndAssingMinVertex()
             string line = $"v {x} {y} {z}";
             worker.ProcessVertex(line, mesh);
 
-            Assert.That(mesh.SubMeshes.Count, Is.EqualTo(baseSubmeshCount + 1));
-            Assert.That(mesh.SubMeshes.Last().Vertices.Count, Is.EqualTo(1));
+            Assert.That(mesh.ObjSubMeshes.Count, Is.EqualTo(baseSubmeshCount + 1));
+            Assert.That(mesh.ObjSubMeshes.Last().Vertices.Count, Is.EqualTo(1));
 
-            Vector3 lastVerticle = mesh.SubMeshes.Last().Vertices.First();
+            Vector3 lastVerticle = mesh.ObjSubMeshes.Last().Vertices.First();
 
             Assert.That(lastVerticle.X, Is.EqualTo(x));
             Assert.That(lastVerticle.Y, Is.EqualTo(y));
@@ -108,19 +108,19 @@ public void ProcessTextCoord_ThrowsWhenSubmeshCollecionIsEmpty()
         public void ProcessTextCoord_ShouldReturnWhereThereIsInvalidNumberOfTokens(string line)
         {
             Mesh mesh = new Mesh();
-            mesh.SubMeshes.Add(new SubMesh());
+            mesh.ObjSubMeshes.Add(new ObjSubMesh());
             ObjParsingWorker worker = new ObjParsingWorker();
             worker.ProcessTextCoord(line, mesh);
 
-            Assert.That(mesh.SubMeshes.Last().Textures, Is.Empty);
+            Assert.That(mesh.ObjSubMeshes.Last().Textures, Is.Empty);
         }
 
         [Test]
         public void ProcessTextCoord_ShouldAddTextureToTheLastSubmesh()
         {
             Mesh mesh = new Mesh();
-            mesh.SubMeshes.Add(new SubMesh());
-            mesh.SubMeshes.Add(new SubMesh());
+            mesh.ObjSubMeshes.Add(new ObjSubMesh());
+            mesh.ObjSubMeshes.Add(new ObjSubMesh());
 
             float x = 1.000000f;
             float y = 1.000000f;
@@ -128,7 +128,7 @@ public void ProcessTextCoord_ShouldAddTextureToTheLastSubmesh()
             ObjParsingWorker worker = new ObjParsingWorker();
             worker.ProcessTextCoord(line, mesh);
 
-            Vector3 lastTexture = mesh.SubMeshes.Last().Textures.First();
+            Vector2 lastTexture = mesh.ObjSubMeshes.Last().Textures.First();
             Assert.That(lastTexture.X, Is.EqualTo(x));
             Assert.That(lastTexture.Y, Is.EqualTo(y));
         }
@@ -147,19 +147,19 @@ public void ProcessNormal_ThrowsWhenSubmeshCollecionIsEmpty()
         public void ProcessNormal_ShouldReturnWhereThereIsInvalidNumberOfTokens(string line)
         {
             Mesh mesh = new Mesh();
-            mesh.SubMeshes.Add(new SubMesh());
+            mesh.ObjSubMeshes.Add(new ObjSubMesh());
             ObjParsingWorker worker = new ObjParsingWorker();
             worker.ProcessNormal(line, mesh);
 
-            Assert.That(mesh.SubMeshes.Last().Textures, Is.Empty);
+            Assert.That(mesh.ObjSubMeshes.Last().Textures, Is.Empty);
         }
 
         [Test]
         public void ProcessNormal_ShouldAddTextureToTheLastSubmesh()
         {
             Mesh mesh = new Mesh();
-            mesh.SubMeshes.Add(new SubMesh());
-            mesh.SubMeshes.Add(new SubMesh());
+            mesh.ObjSubMeshes.Add(new ObjSubMesh());
+            mesh.ObjSubMeshes.Add(new ObjSubMesh());
 
             float x = 1.000000f;
             float y = 1.000000f;
@@ -168,7 +168,7 @@ public void ProcessNormal_ShouldAddTextureToTheLastSubmesh()
             ObjParsingWorker worker = new ObjParsingWorker();
             worker.ProcessNormal(line, mesh);
 
-            Vector3 lastTexture = mesh.SubMeshes.Last().Normals.First();
+            Vector3 lastTexture = mesh.ObjSubMeshes.Last().Normals.First();
             Assert.That(lastTexture.X, Is.EqualTo(x));
             Assert.That(lastTexture.Y, Is.EqualTo(y));
         }
@@ -186,15 +186,15 @@ public void ProcessFace_ThrowsWhenSubmeshCollecionIsEmpty()
         public void ProcessFace_ShouldAddFaceWithOneFaceItemWithVertex()
         {
             Mesh mesh = new Mesh();
-            mesh.SubMeshes.Add(new SubMesh());
+            mesh.ObjSubMeshes.Add(new ObjSubMesh());
             ObjParsingWorker worker = new ObjParsingWorker();
 
             uint value = 3;
             string line = $"f {value}";
             worker.ProcessFace(line, mesh);
 
-            Assert.That(mesh.SubMeshes.Last().Faces.First().Items.Count, Is.EqualTo(1));
-            FaceItem faceItem = mesh.SubMeshes.Last().Faces.First().Items.First();
+            Assert.That(mesh.ObjSubMeshes.Last().Faces.First().Items.Count, Is.EqualTo(1));
+            FaceItem faceItem = mesh.ObjSubMeshes.Last().Faces.First().Items.First();
             Assert.That(faceItem.Vertex, Is.EqualTo(value));
         }
 
@@ -202,14 +202,14 @@ public void ProcessFace_ShouldAddFaceWithOneFaceItemWithVertex()
         public void ProcessFace_ShouldAddFaceItemWithoutVertex()
         {
             Mesh mesh = new Mesh();
-            mesh.SubMeshes.Add(new SubMesh());
+            mesh.ObjSubMeshes.Add(new ObjSubMesh());
             ObjParsingWorker worker = new ObjParsingWorker();
 
             string line = "f ";
             worker.ProcessFace(line, mesh);
 
-            Assert.That(mesh.SubMeshes.Last().Faces.First().Items.Count, Is.EqualTo(1));
-            FaceItem faceItem = mesh.SubMeshes.Last().Faces.First().Items.First();
+            Assert.That(mesh.ObjSubMeshes.Last().Faces.First().Items.Count, Is.EqualTo(1));
+            FaceItem faceItem = mesh.ObjSubMeshes.Last().Faces.First().Items.First();
             Assert.That(faceItem.Vertex, Is.EqualTo(default(uint)));
         }
 
@@ -217,7 +217,7 @@ public void ProcessFace_ShouldAddFaceItemWithoutVertex()
         public void ProcessFace_ShouldAddFaceWithOneFaceItemWithVertexAndTexture()
         {
             Mesh mesh = new Mesh();
-            mesh.SubMeshes.Add(new SubMesh());
+            mesh.ObjSubMeshes.Add(new ObjSubMesh());
             ObjParsingWorker worker = new ObjParsingWorker();
 
             uint x = 3;
@@ -225,8 +225,8 @@ public void ProcessFace_ShouldAddFaceWithOneFaceItemWithVertexAndTexture()
             string line = $"f {x}/{y}";
             worker.ProcessFace(line, mesh);
 
-            Assert.That(mesh.SubMeshes.Last().Faces.First().Items.Count, Is.EqualTo(1));
-            FaceItem faceItem = mesh.SubMeshes.Last().Faces.First().Items.First();
+            Assert.That(mesh.ObjSubMeshes.Last().Faces.First().Items.Count, Is.EqualTo(1));
+            FaceItem faceItem = mesh.ObjSubMeshes.Last().Faces.First().Items.First();
             Assert.That(faceItem.Vertex, Is.EqualTo(x));
             Assert.That(faceItem.Texture, Is.EqualTo(y));
         }
@@ -235,14 +235,14 @@ public void ProcessFace_ShouldAddFaceWithOneFaceItemWithVertexAndTexture()
         public void ProcessFace_ShouldAddFaceItemWithoutVertexValueAndTexture()
         {
             Mesh mesh = new Mesh();
-            mesh.SubMeshes.Add(new SubMesh());
+            mesh.ObjSubMeshes.Add(new ObjSubMesh());
             ObjParsingWorker worker = new ObjParsingWorker();
 
             string line = "f /";
             worker.ProcessFace(line, mesh);
 
-            Assert.That(mesh.SubMeshes.Last().Faces.First().Items.Count, Is.EqualTo(1));
-            FaceItem faceItem = mesh.SubMeshes.Last().Faces.First().Items.First();
+            Assert.That(mesh.ObjSubMeshes.Last().Faces.First().Items.Count, Is.EqualTo(1));
+            FaceItem faceItem = mesh.ObjSubMeshes.Last().Faces.First().Items.First();
             Assert.That(faceItem.Vertex, Is.EqualTo(default(uint)));
             Assert.That(faceItem.Texture, Is.EqualTo(default(uint)));
         }
@@ -251,7 +251,7 @@ public void ProcessFace_ShouldAddFaceItemWithoutVertexValueAndTexture()
         public void ProcessFace_ShouldAddFaceWithOneFaceItemWithVertexTextureAndNormal()
         {
             Mesh mesh = new Mesh();
-            mesh.SubMeshes.Add(new SubMesh());
+            mesh.ObjSubMeshes.Add(new ObjSubMesh());
             ObjParsingWorker worker = new ObjParsingWorker();
 
             uint x = 3;
@@ -260,8 +260,8 @@ public void ProcessFace_ShouldAddFaceWithOneFaceItemWithVertexTextureAndNormal()
             string line = $"f {x}/{y}/{z}";
             worker.ProcessFace(line, mesh);
 
-            Assert.That(mesh.SubMeshes.Last().Faces.First().Items.Count, Is.EqualTo(1));
-            FaceItem faceItem = mesh.SubMeshes.Last().Faces.First().Items.First();
+            Assert.That(mesh.ObjSubMeshes.Last().Faces.First().Items.Count, Is.EqualTo(1));
+            FaceItem faceItem = mesh.ObjSubMeshes.Last().Faces.First().Items.First();
             Assert.That(faceItem.Vertex, Is.EqualTo(x));
             Assert.That(faceItem.Texture, Is.EqualTo(y));
             Assert.That(faceItem.Normal, Is.EqualTo(z));
@@ -271,14 +271,14 @@ public void ProcessFace_ShouldAddFaceWithOneFaceItemWithVertexTextureAndNormal()
         public void ProcessFace_ShouldAddFaceItemWithoutVertexTextureAndNormal()
         {
             Mesh mesh = new Mesh();
-            mesh.SubMeshes.Add(new SubMesh());
+            mesh.ObjSubMeshes.Add(new ObjSubMesh());
             ObjParsingWorker worker = new ObjParsingWorker();
 
             string line = "f //";
             worker.ProcessFace(line, mesh);
 
-            Assert.That(mesh.SubMeshes.Last().Faces.First().Items.Count, Is.EqualTo(1));
-            FaceItem faceItem = mesh.SubMeshes.Last().Faces.First().Items.First();
+            Assert.That(mesh.ObjSubMeshes.Last().Faces.First().Items.Count, Is.EqualTo(1));
+            FaceItem faceItem = mesh.ObjSubMeshes.Last().Faces.First().Items.First();
             Assert.That(faceItem.Vertex, Is.EqualTo(default(uint)));
             Assert.That(faceItem.Texture, Is.EqualTo(default(uint)));
             Assert.That(faceItem.Normal, Is.EqualTo(default(uint)));