Recent changes to Home

WikiPage Home modified by Milan Davidovic

Milan Davidovic — Fri, 05 Oct 2012 09:58:00 -0000

--- v9
+++ v10
@@ -1,4 +1,4 @@
-GLSlayer is a C++ 3D graphics API on top of OpenGL. It provides a streamlined and easy to use interface similar to Direct3D. This comes at the expense of some performance loss, which is OK for some types of applications.
+GLSlayer is a C++ 3D graphics API on top of OpenGL. It provides a streamlined and easy to use interface similar to Direct3D. This comes at the expense of some performance loss, which is OK for some types of applications. OpenGL versions 3.3 to 4.3 are supported, only forward compatible contexts.
 
 Topics:
 -------

WikiPage Home modified by Milan Davidovic

Milan Davidovic — Sat, 05 May 2012 20:35:40 -0000

--- v8 
+++ v9 
@@ -1,6 +1,10 @@
 GLSlayer is a C++ 3D graphics API on top of OpenGL. It provides a streamlined and easy to use interface similar to Direct3D. This comes at the expense of some performance loss, which is OK for some types of applications.
 
+Topics:
+-------
+
 * [Initialization]
+* [OpenGL object encapsulation]
 * [Buffer objects]
 * [Textures and samplers]
 * [Shaders]

WikiPage Home modified by Milan Davidovic

Milan Davidovic — Sat, 05 May 2012 20:19:50 -0000

--- v7 
+++ v8 
@@ -4,9 +4,12 @@
 * [Buffer objects]
 * [Textures and samplers]
 * [Shaders]
+* [Per-fragment operations]
 * [Framebuffer objects]
+* [Setting up geometry sources and layout]
 * [Drawing commands]
-* Setting up geometry sources and layout [VertexStreams]
+* [Conditional rendering]
+* [Tessellation]
 * [Transform feedback]
 * [Synchronization]
 * [Queries]

WikiPage Home modified by Milan Davidovic

Milan Davidovic — Sat, 05 May 2012 19:03:48 -0000

--- v6 
+++ v7 
@@ -1,57 +1,12 @@
-This API was created for my indie game project, I was satisfied how it turned out so I decided to put it on here because I think it can be really useful. I gave it this silly name because I couldn't come up with anything else, but I think it suits well. It is still not thoroughly tested and currently has only Windows support, Linux support will be available soon.
-
-GLSlayer provides a streamlined and easy to use interface similar to Direct3D. This comes at the expense of some performance loss, which is OK for some types of applications.
-
-Creating rendering context is easy (Windows example):
-
-
-gls::FramebufferFormat fbufFormat;
-fbufFormat.colorBits = 32;
-fbufFormat.colorBufferType = gls::COLOR_BUFFER_TYPE_RGBA;
-fbufFormat.depthBits = 24;
-fbufFormat.stencilBits = 8;
-fbufFormat.doubleBuffer = true;
-fbufFormat.multisampleSamples = 8;
-fbufFormat.sRGB = true;
-fbufFormat.swapMethod = gls::SWAP_EXCHANGE;
-
-gls::IRenderContext* renderContext = gls::CreateRenderContext(
-        420, hinstance, hwnd, &fbufFormat, false, nullptr);
-renderContext->SetCurrentContext();
-
-
-This will create forward compatible 4.2 rendering context and load all necessary extensions. Then you can create objects, e.g.:
-
-
-    gls::IBuffer* vertexBuffer = renderContext->CreateBuffer(
-            gls::VERTEX_BUFFER, size, vertices, gls::USAGE_STATIC_DRAW);
-
-
-Then use them:
-
-
-    renderContext->VertexSource(0, vertexBuffer, sizeof(Vertex), 0);
-
-
-After you are done:
-
-
-    renderContext->DestroyBuffer(vertexBuffer);
-    gls::DestroyRenderContext(renderContext);
-
-
-GLSlayer classes that encapsulate OpenGL objects do not expose a Bind() function. I think it is much better to hide bind-to-edit semantics. What these classes do is bind objects if it is needed, by checking if the object that is about to be used is already bound to required target. For example, setting data for a buffer object is implemented something like this:
-
-
-void GLBuffer::BufferData(size_t size, const void* data, BufferUsage usage)
-{
-    if(_id != *_currentId)
-    {
-        glBindBuffer(_target, _id);
-        *_currentId = _id;
-    }
-    glBufferData(_target, size, data, GetGLEnum(usage));
-}
-
-
-where _currentId points to a GLuint of last bound buffer for _target. So if not already bound it will bind the buffer and update the GLuint variable that tracks current ID, and then proceed to update buffer's data. Direct state access extension would be much better, but it is not used because it's not in the core yet and it's incomplete.
+GLSlayer is a C++ 3D graphics API on top of OpenGL. It provides a streamlined and easy to use interface similar to Direct3D. This comes at the expense of some performance loss, which is OK for some types of applications.
+
+* [Initialization]
+* [Buffer objects]
+* [Textures and samplers]
+* [Shaders]
+* [Framebuffer objects]
+* [Drawing commands]
+* Setting up geometry sources and layout [VertexStreams]
+* [Transform feedback]
+* [Synchronization]
+* [Queries]

WikiPage Home modified by Milan Davidovic

Milan Davidovic — Mon, 30 Apr 2012 00:24:41 -0000

--- v5 
+++ v6 
@@ -2,56 +2,56 @@
 
 GLSlayer provides a streamlined and easy to use interface similar to Direct3D. This comes at the expense of some performance loss, which is OK for some types of applications.
 
-Creating a rendering context is easy:
-
-
+Creating rendering context is easy (Windows example):
+
+
 gls::FramebufferFormat fbufFormat;
 fbufFormat.colorBits = 32;
 fbufFormat.colorBufferType = gls::COLOR_BUFFER_TYPE_RGBA;
 fbufFormat.depthBits = 24;
 fbufFormat.stencilBits = 8;
 fbufFormat.doubleBuffer = true;
 fbufFormat.multisampleSamples = 8;
 fbufFormat.sRGB = true;
 fbufFormat.swapMethod = gls::SWAP_EXCHANGE;
 
 gls::IRenderContext* renderContext = gls::CreateRenderContext(
         420, hinstance, hwnd, &fbufFormat, false, nullptr);
 renderContext->SetCurrentContext();
 
 
 This will create forward compatible 4.2 rendering context and load all necessary extensions. Then you can create objects, e.g.:
 
 
-    gls::IBuffer* tex = renderContext->CreateBuffer(
+    gls::IBuffer* vertexBuffer = renderContext->CreateBuffer(
             gls::VERTEX_BUFFER, size, vertices, gls::USAGE_STATIC_DRAW);
 
 
 Then use them:
 
 
     renderContext->VertexSource(0, vertexBuffer, sizeof(Vertex), 0);
 
 
 After you are done:
 
 
     renderContext->DestroyBuffer(vertexBuffer);
     gls::DestroyRenderContext(renderContext);
 
 
-GLSlayer doesn't wrap GLuint names in classes and then expose a Bind() function. I think there is not much benefit in that kind of encapsulation, because you still have to live with OpenGL's bind-to-edit semantics. What it does is keeping track of names of last bound objects for all binding points and then when an object should be used or changed it is bound only if not already. For example, setting data for a buffer object is implemented something like this:
+GLSlayer classes that encapsulate OpenGL objects do not expose a Bind() function. I think it is much better to hide bind-to-edit semantics. What these classes do is bind objects if it is needed, by checking if the object that is about to be used is already bound to required target. For example, setting data for a buffer object is implemented something like this:
 
 
 void GLBuffer::BufferData(size_t size, const void* data, BufferUsage usage)
 {
     if(_id != *_currentId)
     {
         glBindBuffer(_target, _id);
         *_currentId = _id;
     }
     glBufferData(_target, size, data, GetGLEnum(usage));
 }
 
 
-where _currentId points to a GLuint of last bound buffer for current _target. So if not already bound, it will bind the buffer and store buffer name and then update buffer's data. Direct state access extension is not used because it is not in the core yet and it is not complete.
+where _currentId points to a GLuint of last bound buffer for _target. So if not already bound it will bind the buffer and update the GLuint variable that tracks current ID, and then proceed to update buffer's data. Direct state access extension would be much better, but it is not used because it's not in the core yet and it's incomplete.



WikiPage Home modified by Milan Davidovic
Milan Davidovic — Fri, 20 Apr 2012 22:24:28 -0000
--- v4 
+++ v5 
@@ -1,30 +1,30 @@
-This API was created for my indie game project, I was satisfied how it turned out so I decided to put it on here because I think it can be really useful. I gave it this silly name because I couldn't come up with anything else, but I think it suits well.
-
+This API was created for my indie game project, I was satisfied how it turned out so I decided to put it on here because I think it can be really useful. I gave it this silly name because I couldn't come up with anything else, but I think it suits well. It is still not thoroughly tested and currently has only Windows support, Linux support will be available soon.
+
 GLSlayer provides a streamlined and easy to use interface similar to Direct3D. This comes at the expense of some performance loss, which is OK for some types of applications.
 
 Creating a rendering context is easy:
 
 
 gls::FramebufferFormat fbufFormat;
 fbufFormat.colorBits = 32;
 fbufFormat.colorBufferType = gls::COLOR_BUFFER_TYPE_RGBA;
 fbufFormat.depthBits = 24;
 fbufFormat.stencilBits = 8;
 fbufFormat.doubleBuffer = true;
 fbufFormat.multisampleSamples = 8;
 fbufFormat.sRGB = true;
 fbufFormat.swapMethod = gls::SWAP_EXCHANGE;
 
 gls::IRenderContext* renderContext = gls::CreateRenderContext(
         420, hinstance, hwnd, &fbufFormat, false, nullptr);
 renderContext->SetCurrentContext();
 
 
 This will create forward compatible 4.2 rendering context and load all necessary extensions. Then you can create objects, e.g.:
 
 
     gls::IBuffer* tex = renderContext->CreateBuffer(
-            gls::VERTEX_BUFFER, size, data, gls::USAGE_STATIC_DRAW);
+            gls::VERTEX_BUFFER, size, vertices, gls::USAGE_STATIC_DRAW);
 
 
 Then use them:



WikiPage Home modified by Milan Davidovic
Milan Davidovic — Fri, 20 Apr 2012 22:01:45 -0000
--- v3 
+++ v4 
@@ -4,54 +4,54 @@
 
 Creating a rendering context is easy:
 
-
-    gls::FramebufferFormat fbufFormat;
-    fbufFormat.colorBits = 32;
-    fbufFormat.colorBufferType = gls::COLOR_BUFFER_TYPE_RGBA;
-    fbufFormat.depthBits = 24;
-    fbufFormat.stencilBits = 8;
-    fbufFormat.doubleBuffer = true;
-    fbufFormat.multisampleSamples = 8;
-    fbufFormat.sRGB = true;
-    fbufFormat.swapMethod = gls::SWAP_EXCHANGE;
-
-    gls::IRenderContext* renderContext = gls::CreateRenderContext(
-            420, hinstance, hwnd, &fbufFormat, false, nullptr);
-    renderContext->SetCurrentContext();
-
-
+
+gls::FramebufferFormat fbufFormat;
+fbufFormat.colorBits = 32;
+fbufFormat.colorBufferType = gls::COLOR_BUFFER_TYPE_RGBA;
+fbufFormat.depthBits = 24;
+fbufFormat.stencilBits = 8;
+fbufFormat.doubleBuffer = true;
+fbufFormat.multisampleSamples = 8;
+fbufFormat.sRGB = true;
+fbufFormat.swapMethod = gls::SWAP_EXCHANGE;
+
+gls::IRenderContext* renderContext = gls::CreateRenderContext(
+        420, hinstance, hwnd, &fbufFormat, false, nullptr);
+renderContext->SetCurrentContext();
+
+
 This will create forward compatible 4.2 rendering context and load all necessary extensions. Then you can create objects, e.g.:
 
-
+
     gls::IBuffer* tex = renderContext->CreateBuffer(
             gls::VERTEX_BUFFER, size, data, gls::USAGE_STATIC_DRAW);
-
+
 
 Then use them:
 
-
+
     renderContext->VertexSource(0, vertexBuffer, sizeof(Vertex), 0);
-
+
 
 After you are done:
 
-
+
     renderContext->DestroyBuffer(vertexBuffer);
     gls::DestroyRenderContext(renderContext);
-
+
 
 GLSlayer doesn't wrap GLuint names in classes and then expose a Bind() function. I think there is not much benefit in that kind of encapsulation, because you still have to live with OpenGL's bind-to-edit semantics. What it does is keeping track of names of last bound objects for all binding points and then when an object should be used or changed it is bound only if not already. For example, setting data for a buffer object is implemented something like this:
 
-
+
 void GLBuffer::BufferData(size_t size, const void* data, BufferUsage usage)
 {
     if(_id != *_currentId)
     {
         glBindBuffer(_target, _id);
         *_currentId = _id;
     }
     glBufferData(_target, size, data, GetGLEnum(usage));
 }
-
+
 
 where _currentId points to a GLuint of last bound buffer for current _target. So if not already bound, it will bind the buffer and store buffer name and then update buffer's data. Direct state access extension is not used because it is not in the core yet and it is not complete.


WikiPage Home modified by Milan Davidovic
Milan Davidovic — Fri, 20 Apr 2012 21:43:29 -0000

--- v2 
+++ v3 
@@ -14,30 +14,30 @@
     fbufFormat.multisampleSamples = 8;
     fbufFormat.sRGB = true;
     fbufFormat.swapMethod = gls::SWAP_EXCHANGE;
-    
+
     gls::IRenderContext* renderContext = gls::CreateRenderContext(
-			420, hinstance, hwnd, &fbufFormat, false, nullptr);
-	renderContext->SetCurrentContext();
+            420, hinstance, hwnd, &fbufFormat, false, nullptr);
+    renderContext->SetCurrentContext();

This will create forward compatible 4.2 rendering context and load all necessary extensions. Then you can create objects, e.g.:


     gls::IBuffer* tex = renderContext->CreateBuffer(
-			gls::VERTEX_BUFFER, size, data, gls::USAGE_STATIC_DRAW);
+            gls::VERTEX_BUFFER, size, data, gls::USAGE_STATIC_DRAW);

Then use them:


     renderContext->VertexSource(0, vertexBuffer, sizeof(Vertex), 0);

After you are done:


     renderContext->DestroyBuffer(vertexBuffer);
-	gls::DestroyRenderContext(renderContext);
+    gls::DestroyRenderContext(renderContext);

GLSlayer doesn't wrap GLuint names in classes and then expose a Bind() function. I think there is not much benefit in that kind of encapsulation, because you still have to live with OpenGL's bind-to-edit semantics. What it does is keeping track of names of last bound objects for all binding points and then when an object should be used or changed it is bound only if not already. For example, setting data for a buffer object is implemented something like this:

WikiPage Home modified by Milan Davidovic

Milan Davidovic — Fri, 20 Apr 2012 21:42:07 -0000

--- v1 
+++ v2 
@@ -1,8 +1,57 @@
-Welcome to your wiki!
-
-This is the default page, edit it as you see fit. To add a new page simply reference it within brackets, e.g.: [SamplePage].
-
-The wiki uses [Markdown](/p/glslayer/wiki/markdown_syntax/) syntax.
-
-[[project_admins]]
-[[download_button]]
+This API was created for my indie game project, I was satisfied how it turned out so I decided to put it on here because I think it can be really useful. I gave it this silly name because I couldn't come up with anything else, but I think it suits well.
+
+GLSlayer provides a streamlined and easy to use interface similar to Direct3D. This comes at the expense of some performance loss, which is OK for some types of applications.
+
+Creating a rendering context is easy:
+
+
+    gls::FramebufferFormat fbufFormat;
+    fbufFormat.colorBits = 32;
+    fbufFormat.colorBufferType = gls::COLOR_BUFFER_TYPE_RGBA;
+    fbufFormat.depthBits = 24;
+    fbufFormat.stencilBits = 8;
+    fbufFormat.doubleBuffer = true;
+    fbufFormat.multisampleSamples = 8;
+    fbufFormat.sRGB = true;
+    fbufFormat.swapMethod = gls::SWAP_EXCHANGE;
+    
+    gls::IRenderContext* renderContext = gls::CreateRenderContext(
+			420, hinstance, hwnd, &fbufFormat, false, nullptr);
+	renderContext->SetCurrentContext();
+
+
+This will create forward compatible 4.2 rendering context and load all necessary extensions. Then you can create objects, e.g.:
+
+
+    gls::IBuffer* tex = renderContext->CreateBuffer(
+			gls::VERTEX_BUFFER, size, data, gls::USAGE_STATIC_DRAW);
+
+
+Then use them:
+
+
+    renderContext->VertexSource(0, vertexBuffer, sizeof(Vertex), 0);
+
+
+After you are done:
+
+
+    renderContext->DestroyBuffer(vertexBuffer);
+	gls::DestroyRenderContext(renderContext);
+
+
+GLSlayer doesn't wrap GLuint names in classes and then expose a Bind() function. I think there is not much benefit in that kind of encapsulation, because you still have to live with OpenGL's bind-to-edit semantics. What it does is keeping track of names of last bound objects for all binding points and then when an object should be used or changed it is bound only if not already. For example, setting data for a buffer object is implemented something like this:
+
+
+void GLBuffer::BufferData(size_t size, const void* data, BufferUsage usage)
+{
+    if(_id != *_currentId)
+    {
+        glBindBuffer(_target, _id);
+        *_currentId = _id;
+    }
+    glBufferData(_target, size, data, GetGLEnum(usage));
+}
+
+
+where _currentId points to a GLuint of last bound buffer for current _target. So if not already bound, it will bind the buffer and store buffer name and then update buffer's data. Direct state access extension is not used because it is not in the core yet and it is not complete.

WikiPage Home modified by Milan Davidovic

Milan Davidovic — Wed, 18 Apr 2012 20:28:38 -0000

Welcome to your wiki! This is the default page, edit it as you see fit. To add a new page simply reference it within brackets, e.g.: [SamplePage]. The wiki uses [Markdown](/p/glslayer/wiki/markdown_syntax/) syntax. [[project_admins]] [[download_button]]