Allow to build on platforms that don’t have OpenGL.

build/autotools/m4/lol-gl.m4

@@ -1,7 +1,7 @@
 dnl
 dnl  Lol Engine
 dnl
-dnl  Copyright © 2010—2017 Sam Hocevar <sam@hocevar.net>
+dnl  Copyright © 2010—2020 Sam Hocevar <sam@hocevar.net>
 dnl
 dnl  Lol Engine is free software. It comes without any warranty, to
 dnl  the extent permitted by applicable law. You can redistribute it
@@ -92,6 +92,7 @@ fi
 if test "x${ac_cv_my_stop_looking_for_gl}" = "xno"; then
   PKG_CHECK_MODULES(GL, gl,
    [ac_cv_my_have_gl="yes"
+    ac_cv_my_stop_looking_for_gl="yes"
     AC_DEFINE(HAVE_GL_2X, 1, Define to 1 if GL 2.x is available)],
    [:])
 fi

src/gpu/framebuffer.cpp

@@ -17,8 +17,8 @@
 
 // FIXME: fine-tune this define
 #if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
-
 #include "lolgl.h"
+#endif
 
 namespace lol
 {
@@ -36,7 +36,9 @@ class FramebufferData
     ivec2 m_size;
     bool m_bound;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     GLuint m_fbo, m_texture, m_depth;
+#endif
 };
 
 //
@@ -46,6 +48,7 @@ class FramebufferData
 
 uint32_t FramebufferFormat::GetFormat()
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     switch (m_format)
     {
 #if defined HAVE_GLES_2X
@@ -122,10 +125,14 @@ uint32_t FramebufferFormat::GetFormat()
         assert(false);
         return 0;
     }
+#else
+    return 0;
+#endif
 }
 
 uint32_t FramebufferFormat::GetFormatOrder()
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     switch (m_format)
     {
 #if defined HAVE_GLES_2X
@@ -164,6 +171,9 @@ uint32_t FramebufferFormat::GetFormatOrder()
         assert(false);
         return 0;
     }
+#else
+    return 0;
+#endif
 }
 
 //
@@ -176,6 +186,7 @@ Framebuffer::Framebuffer(ivec2 size, FramebufferFormat fbo_format)
 {
     m_data->m_size = size;
     m_data->m_bound = false;
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
 #if defined GL_VERSION_4_2
     GLenum internal_format = fbo_format.GetFormat();
     GLenum depth = GL_DEPTH_COMPONENT16; /* for WebGL */
@@ -254,10 +265,12 @@ Framebuffer::Framebuffer(ivec2 size, FramebufferFormat fbo_format)
 #else
     glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0);
 #endif
+#endif // defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
 }
 
 Framebuffer::~Framebuffer()
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
 #if defined GL_VERSION_1_1 || defined GL_ES_VERSION_2_0
     glDeleteFramebuffers(1, &m_data->m_fbo);
 #else
@@ -268,13 +281,16 @@ Framebuffer::~Framebuffer()
     if (m_data->m_depth != GL_INVALID_ENUM)
         glDeleteRenderbuffers(1, &m_data->m_depth);
 #endif
+#endif // defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     delete m_data;
 }
 
 TextureUniform Framebuffer::GetTextureUniform() const
 {
     TextureUniform ret;
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     ret.m_flags = m_data->m_texture;
+#endif
     return ret;
 }
 
@@ -288,8 +304,10 @@ old_image Framebuffer::GetImage() const
     old_image ret(m_data->m_size);
 
     u8vec4 *buffer = ret.lock<PixelFormat::RGBA_8>();
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glReadPixels(0, 0, m_data->m_size.x, m_data->m_size.y,
                  GL_RGBA, GL_UNSIGNED_BYTE, buffer);
+#endif
     ret.unlock(buffer);
 
     return ret;
@@ -302,7 +320,7 @@ void Framebuffer::Bind()
 
 #if defined GL_VERSION_1_1 || defined GL_ES_VERSION_2_0
     glBindFramebuffer(GL_FRAMEBUFFER, m_data->m_fbo);
-#else
+#elif defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glBindFramebufferOES(GL_FRAMEBUFFER_OES, m_data->m_fbo);
 #endif
 
@@ -322,7 +340,7 @@ void Framebuffer::Unbind()
 
 #if defined GL_VERSION_1_1 || defined GL_ES_VERSION_2_0
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
-#else
+#elif defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0);
 #endif
 
@@ -331,7 +349,4 @@ void Framebuffer::Unbind()
     m_data->m_bound = false;
 }
 
-} /* namespace lol */
-
-#endif
-
+} // namespace lol

src/gpu/indexbuffer.cpp

@@ -14,8 +14,8 @@
 
 // FIXME: fine-tune this define
 #if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
-
 #include "lolgl.h"
+#endif
 
 namespace lol
 {
@@ -30,7 +30,9 @@ class IndexBufferData
     friend class IndexBuffer;
 
     size_t m_size;
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     GLuint m_ibo;
+#endif
     uint8_t *m_memory;
 };
 
@@ -45,7 +47,9 @@ IndexBuffer::IndexBuffer(size_t size)
     m_data->m_size = size;
     if (!size)
         return;
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glGenBuffers(1, &m_data->m_ibo);
+#endif
     m_data->m_memory = new uint8_t[size];
 }
 
@@ -53,7 +57,9 @@ IndexBuffer::~IndexBuffer()
 {
     if (m_data->m_size)
     {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
         glDeleteBuffers(1, &m_data->m_ibo);
+#endif
         delete[] m_data->m_memory;
     }
     delete m_data;
@@ -78,9 +84,11 @@ void IndexBuffer::unlock()
     if (!m_data->m_size)
         return;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_data->m_ibo);
     glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_data->m_size, m_data->m_memory,
                  GL_STATIC_DRAW);
+#endif
 }
 
 void IndexBuffer::Bind()
@@ -88,10 +96,12 @@ void IndexBuffer::Bind()
     if (!m_data->m_size)
         return;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_data->m_ibo);
     /* XXX: not necessary because we kept track of the size */
     //int size;
     //glGetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_SIZE, &size);
+#endif
 }
 
 void IndexBuffer::Unbind()
@@ -99,10 +109,9 @@ void IndexBuffer::Unbind()
     if (!m_data->m_size)
         return;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-}
-
-} /* namespace lol */
-
 #endif
+}
 
+} // namespace lol

src/gpu/renderer.cpp

@@ -23,10 +23,9 @@
 #   undef far
 #endif
 
-// FIXME: fine-tune this define
 #if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
-
 #include "lolgl.h"
+#endif
 
 namespace lol
 {
@@ -128,6 +127,7 @@ Renderer::~Renderer()
 
 void Renderer::clear(ClearMask mask)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     GLbitfield m = 0;
     if (mask & ClearMask::Color)
         m |= GL_COLOR_BUFFER_BIT;
@@ -136,6 +136,7 @@ void Renderer::clear(ClearMask mask)
     if (mask & ClearMask::Stencil)
         m |= GL_STENCIL_BUFFER_BIT;
     glClear(m);
+#endif
 }
 
 /*
@@ -147,7 +148,9 @@ void Renderer::viewport(ibox2 bounds)
     if (m_data->m_viewport == bounds)
         return;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glViewport(bounds.aa.x, bounds.aa.y, bounds.bb.x, bounds.bb.y);
+#endif
 
     m_data->m_viewport = bounds;
 }
@@ -178,7 +181,9 @@ void Renderer::clear_color(vec4 c)
     if (m_data->m_clear_color == c)
         return;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glClearColor(c.r, c.g, c.b, c.a);
+#endif
 
     m_data->m_clear_color = c;
 }
@@ -199,7 +204,7 @@ void Renderer::clear_depth(float depth)
 
 #if defined HAVE_GLES_2X
     glClearDepthf(depth);
-#else
+#elif defined LOL_USE_GLEW || defined HAVE_GL_2X
     glClearDepth(depth);
 #endif
 
@@ -278,6 +283,7 @@ void Renderer::SetBlendEquation(BlendEquation rgb, BlendEquation alpha)
     if (m_data->m_blend_rgb == rgb && m_data->m_blend_alpha == alpha)
         return;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     GLenum s1[2] = { GL_FUNC_ADD, GL_FUNC_ADD };
     BlendEquation s2[2] = { rgb, alpha };
 
@@ -306,6 +312,7 @@ void Renderer::SetBlendEquation(BlendEquation rgb, BlendEquation alpha)
     }
 
     glBlendEquationSeparate(s1[0], s1[1]);
+#endif
 
     m_data->m_blend_rgb = rgb;
     m_data->m_blend_alpha = alpha;
@@ -330,6 +337,7 @@ void Renderer::SetBlendFunc(BlendFunc src, BlendFunc dst)
     if (m_data->m_blend_src == src && m_data->m_blend_dst == dst)
         return;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     GLenum s1[2] = { GL_ONE, GL_ZERO };
     BlendFunc s2[2] = { src, dst };
 
@@ -379,6 +387,7 @@ void Renderer::SetBlendFunc(BlendFunc src, BlendFunc dst)
         glEnable(GL_BLEND);
         glBlendFunc(s1[0], s1[1]);
     }
+#endif
 
     m_data->m_blend_src = src;
     m_data->m_blend_dst = dst;
@@ -403,6 +412,7 @@ void Renderer::SetDepthFunc(DepthFunc func)
     if (m_data->m_depth_func == func)
         return;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     switch (func)
     {
         case DepthFunc::Disabled:
@@ -429,6 +439,7 @@ void Renderer::SetDepthFunc(DepthFunc func)
         glDisable(GL_DEPTH_TEST);
     else
         glEnable(GL_DEPTH_TEST);
+#endif
 
     m_data->m_depth_func = func;
 }
@@ -447,10 +458,12 @@ void Renderer::SetDepthMask(DepthMask mask)
     if (m_data->m_depth_mask == mask)
         return;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     if (mask == DepthMask::Disabled)
         glDepthMask(GL_FALSE);
     else
         glDepthMask(GL_TRUE);
+#endif
 
     m_data->m_depth_mask = mask;
 }
@@ -469,6 +482,7 @@ void Renderer::SetCullMode(CullMode mode)
     if (m_data->m_cull_mode == mode)
         return;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     switch (mode)
     {
     case CullMode::Disabled:
@@ -485,6 +499,7 @@ void Renderer::SetCullMode(CullMode mode)
         glFrontFace(GL_CCW);
         break;
     }
+#endif
 
     m_data->m_cull_mode = mode;
 }
@@ -537,10 +552,12 @@ void Renderer::SetScissorMode(ScissorMode mode)
     if (m_data->m_scissor_mode == mode)
         return;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     if (mode == ScissorMode::Enabled)
         glEnable(GL_SCISSOR_TEST);
     else
         glDisable(GL_SCISSOR_TEST);
+#endif
 
     m_data->m_scissor_mode = mode;
 }
@@ -550,8 +567,10 @@ void Renderer::SetScissorRect(vec4 rect)
     m_data->m_scissor_rect = rect;
     if (m_data->m_scissor_mode == ScissorMode::Enabled)
     {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
         glScissor((int)rect.x, (int)(Video::GetSize().y - rect.w), (int)(rect.z - rect.x), (int)(rect.w - rect.y));
         //glScissor((int)rect.x, (int)rect.y, (int)(rect.z - rect.x), (int)(rect.w - rect.y));
+#endif
     }
 }
 
@@ -565,7 +584,4 @@ vec4 Renderer::GetScissorRect() const
     return m_data->m_scissor_rect;
 }
 
-} /* namespace lol */
-
-#endif
-
+} // namespace lol

src/gpu/shader.cpp

@@ -30,9 +30,6 @@
 
 #include "lolgl.h"
 
-// FIXME: fine-tune this define
-#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
-
 namespace lol
 {
 
@@ -83,9 +80,11 @@ class ShaderData
 private:
     std::string m_name;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     GLuint prog_id, vert_id, frag_id;
     // Benlitz: using a simple array could be faster since there is never more than a few attribute locations to store
     std::map<uint64_t, GLint> attrib_locations;
+#endif
     std::map<uint64_t, bool> attrib_errors;
     size_t vert_crc, frag_crc;
 
@@ -221,6 +220,7 @@ Shader::Shader(std::string const &name,
 {
     data->m_name = name;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     char errbuf[4096];
     std::string shader_code;
     GLchar const *gl_code;
@@ -355,11 +355,16 @@ Shader::Shader(std::string const &name,
     }
 
     delete[] name_buffer;
+#endif
 }
 
 int Shader::GetAttribCount() const
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     return (int)data->attrib_locations.size();
+#else
+    return 0;
+#endif
 }
 
 ShaderAttrib Shader::GetAttribLocation(VertexUsage usage, int index) const
@@ -368,6 +373,7 @@ ShaderAttrib Shader::GetAttribLocation(VertexUsage usage, int index) const
     ret.m_flags = (uint64_t)(uint16_t)usage.ToScalar() << 16;
     ret.m_flags |= (uint64_t)(uint16_t)index;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     GLint l = -1;
 
     if (!try_get(data->attrib_locations, ret.m_flags, l))
@@ -381,6 +387,7 @@ ShaderAttrib Shader::GetAttribLocation(VertexUsage usage, int index) const
         }
     }
     ret.m_flags |= (uint64_t)(uint32_t)l << 32;
+#endif
     return ret;
 }
 
@@ -391,8 +398,10 @@ ShaderUniform Shader::GetUniformLocation(std::string const& uni) const
 ShaderUniform Shader::GetUniformLocation(char const *uni) const
 {
     ShaderUniform ret;
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     ret.frag = (uintptr_t)glGetUniformLocation(data->prog_id, uni);
     ret.vert = 0;
+#endif
     return ret;
 }
 
@@ -402,63 +411,87 @@ ShaderUniform Shader::GetUniformLocation(char const *uni) const
 
 void Shader::SetUniform(ShaderUniform const &uni, int i)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glUniform1i((GLint)uni.frag, i);
+#endif
 }
 
 void Shader::SetUniform(ShaderUniform const &uni, ivec2 const &v)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glUniform2i((GLint)uni.frag, v.x, v.y);
+#endif
 }
 
 void Shader::SetUniform(ShaderUniform const &uni, ivec3 const &v)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glUniform3i((GLint)uni.frag, v.x, v.y, v.z);
+#endif
 }
 
 void Shader::SetUniform(ShaderUniform const &uni, ivec4 const &v)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glUniform4i((GLint)uni.frag, v.x, v.y, v.z, v.w);
+#endif
 }
 
 void Shader::SetUniform(ShaderUniform const &uni, float f)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glUniform1f((GLint)uni.frag, f);
+#endif
 }
 
 void Shader::SetUniform(ShaderUniform const &uni, vec2 const &v)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glUniform2fv((GLint)uni.frag, 1, &v[0]);
+#endif
 }
 
 void Shader::SetUniform(ShaderUniform const &uni, vec3 const &v)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glUniform3fv((GLint)uni.frag, 1, &v[0]);
+#endif
 }
 
 void Shader::SetUniform(ShaderUniform const &uni, vec4 const &v)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glUniform4fv((GLint)uni.frag, 1, &v[0]);
+#endif
 }
 
 void Shader::SetUniform(ShaderUniform const &uni, mat2 const &m)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glUniformMatrix2fv((GLint)uni.frag, 1, GL_FALSE, &m[0][0]);
+#endif
 }
 
 void Shader::SetUniform(ShaderUniform const &uni, mat3 const &m)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glUniformMatrix3fv((GLint)uni.frag, 1, GL_FALSE, &m[0][0]);
+#endif
 }
 
 void Shader::SetUniform(ShaderUniform const &uni, mat4 const &m)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glUniformMatrix4fv((GLint)uni.frag, 1, GL_FALSE, &m[0][0]);
+#endif
 }
 
 void Shader::SetUniform(ShaderUniform const &uni, TextureUniform tex, int index)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glActiveTexture(GL_TEXTURE0 + index);
     glBindTexture(GL_TEXTURE_2D, (int)tex.m_flags);
+#endif
     SetUniform(uni, index);
 }
 
@@ -468,42 +501,56 @@ void Shader::SetUniform(ShaderUniform const &uni, TextureUniform tex, int index)
 
 void Shader::SetUniform(ShaderUniform const &uni, std::vector<float> const &v)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glUniform1fv((GLint)uni.frag, (GLsizei)v.size(), &v[0]);
+#endif
 }
 
 void Shader::SetUniform(ShaderUniform const &uni, std::vector<vec2> const &v)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glUniform2fv((GLint)uni.frag, (GLsizei)v.size(), &v[0][0]);
+#endif
 }
 
 void Shader::SetUniform(ShaderUniform const &uni, std::vector<vec3> const &v)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glUniform3fv((GLint)uni.frag, (GLsizei)v.size(), &v[0][0]);
+#endif
 }
 
 void Shader::SetUniform(ShaderUniform const &uni, std::vector<vec4> const &v)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glUniform4fv((GLint)uni.frag, (GLsizei)v.size(), &v[0][0]);
+#endif
 }
 
 void Shader::Bind() const
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glUseProgram(data->prog_id);
+#endif
 }
 
 void Shader::Unbind() const
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     /* FIXME: untested */
     glUseProgram(0);
+#endif
 }
 
 Shader::~Shader()
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glDetachShader(data->prog_id, data->vert_id);
     glDetachShader(data->prog_id, data->frag_id);
     glDeleteShader(data->vert_id);
     glDeleteShader(data->frag_id);
     glDeleteProgram(data->prog_id);
+#endif
 }
 
 /* Try to detect shader compiler features */
@@ -516,7 +563,7 @@ int ShaderData::GetVersion()
 #if defined HAVE_GLES_2X
         /* GLES 2.x supports #version 100, that's all. */
         return 100;
-#else
+#elif defined LOL_USE_GLEW || defined HAVE_GL_2X
         char buf[4096];
         GLsizei len;
 
@@ -1055,7 +1102,4 @@ std::string ShaderBuilder::Build()
     return code;
 }
 
-} /* namespace lol */
-
-#endif
-
+} // namespace lol

src/gpu/texture.cpp

@@ -1,7 +1,7 @@
 //
 //  Lol Engine
 //
-//  Copyright © 2010—2017 Sam Hocevar <sam@hocevar.net>
+//  Copyright © 2010—2020 Sam Hocevar <sam@hocevar.net>
 //
 //  Lol Engine is free software. It comes without any warranty, to
 //  the extent permitted by applicable law. You can redistribute it
@@ -14,9 +14,6 @@
 
 #include "lolgl.h"
 
-// FIXME: fine-tune this define
-#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
-
 namespace lol
 {
 
@@ -32,9 +29,11 @@ class TextureData
     ivec2 m_size;
     PixelFormat m_format;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     GLuint m_texture;
     GLint m_internal_format;
     GLenum m_gl_format, m_gl_type;
+#endif
     int m_bytes_per_elem;
 };
 
@@ -53,6 +52,7 @@ Texture::Texture(ivec2 size, PixelFormat format)
     m_data->m_size = size;
     m_data->m_format = format;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     static struct
     {
         GLint internal_format;
@@ -91,35 +91,45 @@ Texture::Texture(ivec2 size, PixelFormat format)
 
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+#endif
 }
 
 TextureUniform Texture::GetTextureUniform() const
 {
     TextureUniform ret;
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     ret.m_flags = m_data->m_texture;
+#endif
     return ret;
 }
 
 void Texture::Bind()
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glBindTexture(GL_TEXTURE_2D, m_data->m_texture);
+#endif
 }
 
 void Texture::SetData(void *data)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glTexImage2D(GL_TEXTURE_2D, 0, m_data->m_internal_format,
                  m_data->m_size.x, m_data->m_size.y, 0,
                  m_data->m_gl_format, m_data->m_gl_type, data);
+#endif
 }
 
 void Texture::SetSubData(ivec2 origin, ivec2 size, void *data)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glTexSubImage2D(GL_TEXTURE_2D, 0, origin.x, origin.y, size.x, size.y,
                     m_data->m_gl_format, m_data->m_gl_type, data);
+#endif
 }
 
 void Texture::SetMagFiltering(TextureMagFilter filter)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glBindTexture(GL_TEXTURE_2D, m_data->m_texture);
     GLenum gl_filter;
     switch (filter)
@@ -133,10 +143,12 @@ void Texture::SetMagFiltering(TextureMagFilter filter)
             break;
     }
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter);
+#endif
 }
 
 void Texture::SetMinFiltering(TextureMinFilter filter)
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glBindTexture(GL_TEXTURE_2D, m_data->m_texture);
     GLenum gl_filter;
     switch (filter)
@@ -162,21 +174,23 @@ void Texture::SetMinFiltering(TextureMinFilter filter)
             break;
     }
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter);
+#endif
 }
 
 void Texture::GenerateMipmaps()
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glBindTexture(GL_TEXTURE_2D, m_data->m_texture);
     glGenerateMipmap(GL_TEXTURE_2D);
+#endif
 }
 
 Texture::~Texture()
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glDeleteTextures(1, &m_data->m_texture);
+#endif
     delete m_data;
 }
 
-} /* namespace lol */
-
-#endif
-
+} // namespace lol

src/gpu/vertexbuffer.cpp

@@ -22,9 +22,6 @@
     #define glDeleteVertexArrays glDeleteVertexArraysOES
 #endif
 
-// FIXME: fine-tune this define
-#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
-
 namespace lol
 {
 
@@ -40,7 +37,9 @@ class VertexBufferData
 
     size_t m_size;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     GLuint m_vbo;
+#endif
     uint8_t *m_memory;
 };
 
@@ -78,18 +77,24 @@ VertexDeclaration::VertexDeclaration(VertexStreamBase const &s1,
     if (&s11 != &VertexStreamBase::Empty) AddStream(s11);
     if (&s12 != &VertexStreamBase::Empty) AddStream(s12);
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glGenVertexArrays(1, &m_vao);
+#endif
 }
 
 VertexDeclaration::~VertexDeclaration()
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glDeleteVertexArrays(1, &m_vao);
+#endif
 }
 
 void VertexDeclaration::Bind()
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     /* FIXME: Nothing to do? */
     glBindVertexArray(m_vao);
+#endif
 }
 
 void VertexDeclaration::DrawElements(MeshPrimitive type, int skip, int count)
@@ -97,7 +102,8 @@ void VertexDeclaration::DrawElements(MeshPrimitive type, int skip, int count)
     if (count <= 0)
         return;
 
-    /* FIXME: this has nothing to do here! */
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
+    // FIXME: this has nothing to do here!
     switch (type.ToScalar())
     {
     case MeshPrimitive::Triangles:
@@ -116,6 +122,7 @@ void VertexDeclaration::DrawElements(MeshPrimitive type, int skip, int count)
         glDrawArrays(GL_LINES, skip, count);
         break;
     }
+#endif
 }
 
 void VertexDeclaration::DrawIndexedElements(MeshPrimitive type, int count, const short* skip, short typeSize)
@@ -123,9 +130,10 @@ void VertexDeclaration::DrawIndexedElements(MeshPrimitive type, int count, const
     if (count <= 0)
         return;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     uint32_t elementType = typeSize == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT;
 
-    /* FIXME: this has nothing to do here! */
+    // FIXME: this has nothing to do here!
     switch (type.ToScalar())
     {
     case MeshPrimitive::Triangles:
@@ -144,10 +152,12 @@ void VertexDeclaration::DrawIndexedElements(MeshPrimitive type, int count, const
         glDrawElements(GL_LINES, count, elementType, skip);
         break;
     }
+#endif
 }
 
 void VertexDeclaration::Unbind()
 {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     for (int i = 0; i < m_count; i++)
     {
         if (m_streams[i].reg >= 0)
@@ -161,6 +171,7 @@ void VertexDeclaration::Unbind()
     }
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glBindVertexArray(0);
+#endif
 }
 
 void VertexDeclaration::SetStream(std::shared_ptr<VertexBuffer> vb,
@@ -188,7 +199,9 @@ void VertexDeclaration::SetStream(std::shared_ptr<VertexBuffer> vb, ShaderAttrib
     if (!vb->m_data->m_size)
         return;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glBindBuffer(GL_ARRAY_BUFFER, vb->m_data->m_vbo);
+#endif
 
     for (int n = 0; n < 12 && attribs[n].m_flags != (uint64_t)0 - 1; n++)
     {
@@ -227,6 +240,7 @@ void VertexDeclaration::SetStream(std::shared_ptr<VertexBuffer> vb, ShaderAttrib
         m_streams[attr_index].reg = reg;
 
         /* Finally, we need to retrieve the type of the data */
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
 #if !defined GL_DOUBLE
 #   define GL_DOUBLE 0
 #endif
@@ -255,9 +269,11 @@ void VertexDeclaration::SetStream(std::shared_ptr<VertexBuffer> vb, ShaderAttrib
         int type_index = m_streams[attr_index].stream_type;
         if (type_index < 0 || type_index >= (int)(sizeof(tlut) / sizeof(*tlut)))
             type_index = 0;
+#endif
 
         if (reg != 0xffffffffu)
         {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
             glEnableVertexAttribArray((GLint)reg);
             if (tlut[type_index].type == GL_FLOAT
                  || tlut[type_index].type == GL_DOUBLE
@@ -284,6 +300,7 @@ void VertexDeclaration::SetStream(std::shared_ptr<VertexBuffer> vb, ShaderAttrib
                                        tlut[type_index].type,
                                        stride, (GLvoid const *)(uintptr_t)offset);
             }
+#endif
 #endif
         }
     }
@@ -358,7 +375,9 @@ VertexBuffer::VertexBuffer(size_t size)
     if (!size)
         return;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glGenBuffers(1, &m_data->m_vbo);
+#endif
     m_data->m_memory = new uint8_t[size];
 }
 
@@ -366,7 +385,9 @@ VertexBuffer::~VertexBuffer()
 {
     if (m_data->m_size)
     {
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
         glDeleteBuffers(1, &m_data->m_vbo);
+#endif
         delete[] m_data->m_memory;
     }
     delete m_data;
@@ -392,13 +413,12 @@ void VertexBuffer::unlock()
     if (!m_data->m_size)
         return;
 
+#if defined LOL_USE_GLEW || defined HAVE_GL_2X || defined HAVE_GLES_2X
     glBindBuffer(GL_ARRAY_BUFFER, m_data->m_vbo);
     glBufferData(GL_ARRAY_BUFFER, m_data->m_size, m_data->m_memory,
                  GL_STATIC_DRAW);
     glBindBuffer(GL_ARRAY_BUFFER, 0);
-}
-
-} /* namespace lol */
-
 #endif
+}
 
+} // namespace lol

src/lol/gpu/shader.h

@@ -25,6 +25,8 @@
 
 #include "engine/entity.h"
 
+#include "lolgl.h"
+
 /* External declaration for LolFx files. */
 #define LOLFX_RESOURCE_DECLARE(name) \
     extern "C" char const *lolfx_resource_##name
@@ -467,5 +469,4 @@ public:
     std::string Build();
 };
 
-} /* namespace lol */
-
+} // namespace lol