TextureGL implementation.

src/libANGLE/renderer/gl/RendererGL.cpp

@@ -36,7 +36,7 @@ RendererGL::RendererGL(const FunctionsGL *functions)
       mStateManager(nullptr)
 {
     ASSERT(mFunctions);
-    mStateManager = new StateManagerGL(mFunctions);
+    mStateManager = new StateManagerGL(mFunctions, getRendererCaps());
 }
 
 RendererGL::~RendererGL()
@@ -59,7 +59,7 @@ gl::Error RendererGL::finish()
 gl::Error RendererGL::drawArrays(const gl::Data &data, GLenum mode,
                                  GLint first, GLsizei count, GLsizei instances)
 {
-    mStateManager->setDrawState(*data.state);
+    mStateManager->setDrawState(data);
     mFunctions->drawArrays(mode, first, count);
 
     return gl::Error(GL_NO_ERROR);
@@ -74,7 +74,7 @@ gl::Error RendererGL::drawElements(const gl::Data &data, GLenum mode, GLsizei co
         UNIMPLEMENTED();
     }
 
-    mStateManager->setDrawState(*data.state);
+    mStateManager->setDrawState(data);
     mFunctions->drawElements(mode, count, type, indices);
 
     return gl::Error(GL_NO_ERROR);
@@ -107,7 +107,7 @@ FramebufferImpl *RendererGL::createFramebuffer(const gl::Framebuffer::Data &data
 
 TextureImpl *RendererGL::createTexture(GLenum target)
 {
-    return new TextureGL();
+    return new TextureGL(target, mFunctions, mStateManager);
 }
 
 RenderbufferImpl *RendererGL::createRenderbuffer()

src/libANGLE/renderer/gl/StateManagerGL.cpp

@@ -12,18 +12,28 @@
 #include "libANGLE/VertexArray.h"
 #include "libANGLE/renderer/gl/FunctionsGL.h"
 #include "libANGLE/renderer/gl/ProgramGL.h"
+#include "libANGLE/renderer/gl/TextureGL.h"
 #include "libANGLE/renderer/gl/VertexArrayGL.h"
 
 namespace rx
 {
 
-StateManagerGL::StateManagerGL(const FunctionsGL *functions)
+StateManagerGL::StateManagerGL(const FunctionsGL *functions, const gl::Caps &rendererCaps)
     : mFunctions(functions),
       mProgram(0),
       mVAO(0),
-      mBuffers()
+      mBuffers(),
+      mTextureUnitIndex(0),
+      mTextures(),
+      mUnpackAlignment(4),
+      mUnpackRowLength(0)
 {
     ASSERT(mFunctions);
+
+    mTextures[GL_TEXTURE_2D].resize(rendererCaps.maxCombinedTextureImageUnits);
+    mTextures[GL_TEXTURE_CUBE_MAP].resize(rendererCaps.maxCombinedTextureImageUnits);
+    mTextures[GL_TEXTURE_2D_ARRAY].resize(rendererCaps.maxCombinedTextureImageUnits);
+    mTextures[GL_TEXTURE_3D].resize(rendererCaps.maxCombinedTextureImageUnits);
 }
 
 void StateManagerGL::useProgram(GLuint program)
@@ -53,8 +63,44 @@ void StateManagerGL::bindBuffer(GLenum type, GLuint buffer)
     }
 }
 
-void StateManagerGL::setDrawState(const gl::State &state)
+void StateManagerGL::activeTexture(size_t unit)
+{
+    if (mTextureUnitIndex != unit)
+    {
+        mTextureUnitIndex = unit;
+        mFunctions->activeTexture(GL_TEXTURE0 + mTextureUnitIndex);
+    }
+}
+
+void StateManagerGL::bindTexture(GLenum type, GLuint texture)
 {
+    if (mTextures[type][mTextureUnitIndex] != texture)
+    {
+        mTextures[type][mTextureUnitIndex] = texture;
+        mFunctions->bindTexture(type, texture);
+    }
+}
+
+void StateManagerGL::setPixelUnpackState(GLint alignment, GLint rowLength)
+{
+    if (mUnpackAlignment != alignment)
+    {
+        mUnpackAlignment = alignment;
+        mFunctions->pixelStorei(GL_UNPACK_ALIGNMENT, mUnpackAlignment);
+    }
+
+    if (mUnpackRowLength != rowLength)
+    {
+        mUnpackRowLength = rowLength;
+        mFunctions->pixelStorei(GL_UNPACK_ROW_LENGTH, mUnpackRowLength);
+    }
+}
+
+void StateManagerGL::setDrawState(const gl::Data &data)
+{
+    const gl::State &state = *data.state;
+    const gl::Caps &caps = *data.caps;
+
     const gl::VertexArray *vao = state.getVertexArray();
     const VertexArrayGL *vaoGL = GetImplAs<VertexArrayGL>(vao);
     bindVertexArray(vaoGL->getVertexArrayID());
@@ -62,6 +108,51 @@ void StateManagerGL::setDrawState(const gl::State &state)
     const gl::Program *program = state.getProgram();
     const ProgramGL *programGL = GetImplAs<ProgramGL>(program);
     useProgram(programGL->getProgramID());
+
+    // TODO: Only apply textures referenced by the program.
+    for (auto textureTypeIter = mTextures.begin(); textureTypeIter != mTextures.end(); textureTypeIter++)
+    {
+        GLenum textureType = textureTypeIter->first;
+
+        // Determine if this texture type can exist in the source context
+        bool validTextureType = (textureType == GL_TEXTURE_2D || textureType == GL_TEXTURE_CUBE_MAP ||
+                                 (textureType == GL_TEXTURE_2D_ARRAY && data.clientVersion >= 3) ||
+                                 (textureType == GL_TEXTURE_3D && data.clientVersion >= 3));
+
+        const std::vector<GLuint> &textureVector = textureTypeIter->second;
+        for (size_t textureUnitIndex = 0; textureUnitIndex < textureVector.size(); textureUnitIndex++)
+        {
+            const gl::Texture *texture = nullptr;
+
+            bool validTextureUnit = textureUnitIndex < caps.maxCombinedTextureImageUnits;
+            if (validTextureType && validTextureUnit)
+            {
+                texture = state.getSamplerTexture(textureUnitIndex, textureType);
+            }
+
+            if (texture != nullptr)
+            {
+                const TextureGL *textureGL = GetImplAs<TextureGL>(texture);
+                if (mTextures[textureType][textureUnitIndex] != textureGL->getTextureID())
+                {
+                    activeTexture(textureUnitIndex);
+                    textureGL->syncSamplerState(texture->getSamplerState());
+
+                    bindTexture(textureType, textureGL->getTextureID());
+                }
+
+                // TODO: apply sampler object if one is bound
+            }
+            else
+            {
+                if (mTextures[textureType][textureUnitIndex] != 0)
+                {
+                    activeTexture(textureUnitIndex);
+                    bindTexture(textureType, 0);
+                }
+            }
+        }
+    }
 }
 
 }

src/libANGLE/renderer/gl/StateManagerGL.h

@@ -16,7 +16,8 @@
 
 namespace gl
 {
-class State;
+struct Caps;
+struct Data;
 }
 
 namespace rx
@@ -27,13 +28,16 @@ class FunctionsGL;
 class StateManagerGL
 {
   public:
-    StateManagerGL(const FunctionsGL *functions);
+    StateManagerGL(const FunctionsGL *functions, const gl::Caps &rendererCaps);
 
     void useProgram(GLuint program);
     void bindVertexArray(GLuint vao);
     void bindBuffer(GLenum type, GLuint buffer);
+    void activeTexture(size_t unit);
+    void bindTexture(GLenum type, GLuint texture);
+    void setPixelUnpackState(GLint alignment, GLint rowLength);
 
-    void setDrawState(const gl::State &state);
+    void setDrawState(const gl::Data &data);
 
   private:
     DISALLOW_COPY_AND_ASSIGN(StateManagerGL);
@@ -43,6 +47,12 @@ class StateManagerGL
     GLuint mProgram;
     GLuint mVAO;
     std::map<GLenum, GLuint> mBuffers;
+
+    size_t mTextureUnitIndex;
+    std::map<GLenum, std::vector<GLuint>> mTextures;
+
+    GLint mUnpackAlignment;
+    GLint mUnpackRowLength;
 };
 
 }

src/libANGLE/renderer/gl/TextureGL.cpp

@@ -9,73 +9,194 @@
 #include "libANGLE/renderer/gl/TextureGL.h"
 
 #include "common/debug.h"
+#include "common/utilities.h"
 #include "libANGLE/State.h"
+#include "libANGLE/angletypes.h"
+#include "libANGLE/formatutils.h"
+#include "libANGLE/renderer/gl/BufferGL.h"
+#include "libANGLE/renderer/gl/FunctionsGL.h"
+#include "libANGLE/renderer/gl/StateManagerGL.h"
 
 namespace rx
 {
 
-TextureGL::TextureGL()
-    : TextureImpl()
-{}
+static void SetUnpackStateForTexImage(StateManagerGL *stateManager, const gl::PixelUnpackState &unpack)
+{
+    const gl::Buffer *unpackBuffer = unpack.pixelBuffer.get();
+    if (unpackBuffer != nullptr)
+    {
+        UNIMPLEMENTED();
+    }
+    if (unpack.skipRows != 0 || unpack.skipPixels != 0 || unpack.imageHeight != 0 || unpack.skipImages != 0)
+    {
+        UNIMPLEMENTED();
+    }
+    stateManager->setPixelUnpackState(unpack.alignment, unpack.rowLength);
+}
+
+static bool UseTexImage2D(GLenum textureType)
+{
+    return textureType == GL_TEXTURE_2D || textureType == GL_TEXTURE_CUBE_MAP;
+}
+
+static bool UseTexImage3D(GLenum textureType)
+{
+    return textureType == GL_TEXTURE_2D_ARRAY || textureType == GL_TEXTURE_3D;
+}
+
+static bool CompatableTextureTarget(GLenum textureType, GLenum textureTarget)
+{
+    if (textureType != GL_TEXTURE_CUBE_MAP)
+    {
+        return textureType == textureTarget;
+    }
+    else
+    {
+        return gl::IsCubeMapTextureTarget(textureType);
+    }
+}
+
+TextureGL::TextureGL(GLenum type, const FunctionsGL *functions, StateManagerGL *stateManager)
+    : TextureImpl(),
+      mTextureType(type),
+      mFunctions(functions),
+      mStateManager(stateManager),
+      mAppliedSamplerState(),
+      mTextureID(0)
+{
+    ASSERT(mFunctions);
+    ASSERT(mStateManager);
+
+    mFunctions->genTextures(1, &mTextureID);
+}
 
 TextureGL::~TextureGL()
-{}
+{
+    if (mTextureID)
+    {
+        mFunctions->deleteTextures(1, &mTextureID);
+        mTextureID = 0;
+    }
+}
 
 void TextureGL::setUsage(GLenum usage)
 {
-    UNIMPLEMENTED();
+    // GL_ANGLE_texture_usage not implemented for desktop GL
+    UNREACHABLE();
 }
 
 gl::Error TextureGL::setImage(GLenum target, size_t level, GLenum internalFormat, const gl::Extents &size, GLenum format, GLenum type,
                               const gl::PixelUnpackState &unpack, const uint8_t *pixels)
 {
-    if (unpack.skipRows != 0 || unpack.skipPixels != 0 || unpack.imageHeight != 0 || unpack.skipImages != 0)
+    ASSERT(CompatableTextureTarget(mTextureType, target));
+
+    SetUnpackStateForTexImage(mStateManager, unpack);
+
+    mStateManager->bindTexture(mTextureType, mTextureID);
+    if (UseTexImage2D(mTextureType))
     {
-        UNIMPLEMENTED();
-        return gl::Error(GL_INVALID_OPERATION, "unimplemented pixel store state");
+        ASSERT(size.depth == 1);
+        mFunctions->texImage2D(target, level, internalFormat, size.width, size.height, 0, format, type, pixels);
+    }
+    else if (UseTexImage3D(mTextureType))
+    {
+        mFunctions->texImage3D(target, level, internalFormat, size.width, size.height, size.depth, 0, format, type, pixels);
+    }
+    else
+    {
+        UNREACHABLE();
     }
 
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::Error(GL_NO_ERROR);
 }
 
 gl::Error TextureGL::setSubImage(GLenum target, size_t level, const gl::Box &area, GLenum format, GLenum type,
                                  const gl::PixelUnpackState &unpack, const uint8_t *pixels)
 {
-    if (unpack.skipRows != 0 || unpack.skipPixels != 0 || unpack.imageHeight != 0 || unpack.skipImages != 0)
+    ASSERT(CompatableTextureTarget(mTextureType, target));
+
+    SetUnpackStateForTexImage(mStateManager, unpack);
+
+    mStateManager->bindTexture(mTextureType, mTextureID);
+    if (UseTexImage2D(mTextureType))
     {
-        UNIMPLEMENTED();
-        return gl::Error(GL_INVALID_OPERATION, "unimplemented pixel store state");
+        ASSERT(area.z == 0 && area.depth == 1);
+        mFunctions->texSubImage2D(target, level, area.x, area.y, area.width, area.height, format, type, pixels);
+    }
+    else if (UseTexImage3D(mTextureType))
+    {
+        mFunctions->texSubImage3D(target, level, area.x, area.y, area.z, area.width, area.height, area.depth,
+                                  format, type, pixels);
+    }
+    else
+    {
+        UNREACHABLE();
     }
 
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::Error(GL_NO_ERROR);
 }
 
 gl::Error TextureGL::setCompressedImage(GLenum target, size_t level, GLenum internalFormat, const gl::Extents &size,
                                         const gl::PixelUnpackState &unpack, const uint8_t *pixels)
 {
-    if (unpack.skipRows != 0 || unpack.skipPixels != 0 || unpack.imageHeight != 0 || unpack.skipImages != 0)
+    ASSERT(CompatableTextureTarget(mTextureType, target));
+
+    SetUnpackStateForTexImage(mStateManager, unpack);
+
+    const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat);
+    size_t depthPitch = internalFormatInfo.computeDepthPitch(GL_UNSIGNED_BYTE, size.width, size.height,
+                                                             unpack.alignment, unpack.rowLength);
+    size_t dataSize = internalFormatInfo.computeBlockSize(GL_UNSIGNED_BYTE, size.width, size.height) * depthPitch;
+
+    mStateManager->bindTexture(mTextureType, mTextureID);
+    if (UseTexImage2D(mTextureType))
     {
-        UNIMPLEMENTED();
-        return gl::Error(GL_INVALID_OPERATION, "unimplemented pixel store state");
+        ASSERT(size.depth == 1);
+        mFunctions->compressedTexImage2D(target, level, internalFormat, size.width, size.height, 0, dataSize, pixels);
+    }
+    else if (UseTexImage3D(mTextureType))
+    {
+        mFunctions->compressedTexImage3D(target, level, internalFormat, size.width, size.height, size.depth, 0,
+                                         dataSize, pixels);
+    }
+    else
+    {
+        UNREACHABLE();
     }
 
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::Error(GL_NO_ERROR);
 }
 
 gl::Error TextureGL::setCompressedSubImage(GLenum target, size_t level, const gl::Box &area, GLenum format,
                                            const gl::PixelUnpackState &unpack, const uint8_t *pixels)
 {
-    if (unpack.skipRows != 0 || unpack.skipPixels != 0 || unpack.imageHeight != 0 || unpack.skipImages != 0)
+    ASSERT(CompatableTextureTarget(mTextureType, target));
+
+    SetUnpackStateForTexImage(mStateManager, unpack);
+
+    const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(format);
+    size_t depthPitch = internalFormatInfo.computeDepthPitch(GL_UNSIGNED_BYTE, area.width, area.height,
+                                                             unpack.alignment, unpack.rowLength);
+    size_t dataSize = internalFormatInfo.computeBlockSize(GL_UNSIGNED_BYTE, area.width, area.height) * depthPitch;
+
+    mStateManager->bindTexture(mTextureType, mTextureID);
+    if (UseTexImage2D(mTextureType))
     {
-        UNIMPLEMENTED();
-        return gl::Error(GL_INVALID_OPERATION, "unimplemented pixel store state");
+        ASSERT(area.z == 0 && area.depth == 1);
+        mFunctions->compressedTexSubImage2D(target, level, area.x, area.y, area.width, area.height, format, dataSize,
+                                            pixels);
+    }
+    else if (UseTexImage3D(mTextureType))
+    {
+        mFunctions->compressedTexSubImage3D(target, level, area.x, area.y, area.z, area.width, area.height, area.depth,
+                                            format, dataSize, pixels);
+    }
+    else
+    {
+        UNREACHABLE();
     }
 
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::Error(GL_NO_ERROR);
 }
 
 gl::Error TextureGL::copyImage(GLenum target, size_t level, const gl::Rectangle &sourceArea, GLenum internalFormat,
@@ -94,14 +215,32 @@ gl::Error TextureGL::copySubImage(GLenum target, size_t level, const gl::Offset
 
 gl::Error TextureGL::setStorage(GLenum target, size_t levels, GLenum internalFormat, const gl::Extents &size)
 {
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    // TODO: emulate texture storage with TexImage calls if on GL version <4.2 or the
+    // ARB_texture_storage extension is not available.
+
+    mStateManager->bindTexture(mTextureType, mTextureID);
+    if (UseTexImage2D(mTextureType))
+    {
+        ASSERT(size.depth == 1);
+        mFunctions->texStorage2D(target, levels, internalFormat, size.width, size.height);
+    }
+    else if (UseTexImage3D(mTextureType))
+    {
+        mFunctions->texStorage3D(target, levels, internalFormat, size.width, size.height, size.depth);
+    }
+    else
+    {
+        UNREACHABLE();
+    }
+
+    return gl::Error(GL_NO_ERROR);
 }
 
 gl::Error TextureGL::generateMipmaps()
 {
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    mStateManager->bindTexture(mTextureType, mTextureID);
+    mFunctions->generateMipmap(mTextureType);
+    return gl::Error(GL_NO_ERROR);
 }
 
 void TextureGL::bindTexImage(egl::Surface *surface)
@@ -114,4 +253,45 @@ void TextureGL::releaseTexImage()
     UNIMPLEMENTED();
 }
 
+template <typename T>
+static inline void SyncSamplerStateMember(const FunctionsGL *functions, const gl::SamplerState &newState,
+                                          gl::SamplerState &curState, GLenum textureType, GLenum name,
+                                          T(gl::SamplerState::*samplerMember))
+{
+    if (curState.*samplerMember != newState.*samplerMember)
+    {
+        curState.*samplerMember = newState.*samplerMember;
+        functions->texParameterf(textureType, name, curState.*samplerMember);
+    }
+}
+
+void TextureGL::syncSamplerState(const gl::SamplerState &samplerState) const
+{
+    if (mAppliedSamplerState != samplerState)
+    {
+        mStateManager->bindTexture(mTextureType, mTextureID);
+        SyncSamplerStateMember(mFunctions, samplerState, mAppliedSamplerState, mTextureType, GL_TEXTURE_MIN_FILTER, &gl::SamplerState::minFilter);
+        SyncSamplerStateMember(mFunctions, samplerState, mAppliedSamplerState, mTextureType, GL_TEXTURE_MAG_FILTER, &gl::SamplerState::magFilter);
+        SyncSamplerStateMember(mFunctions, samplerState, mAppliedSamplerState, mTextureType, GL_TEXTURE_WRAP_S, &gl::SamplerState::wrapS);
+        SyncSamplerStateMember(mFunctions, samplerState, mAppliedSamplerState, mTextureType, GL_TEXTURE_WRAP_T, &gl::SamplerState::wrapT);
+        SyncSamplerStateMember(mFunctions, samplerState, mAppliedSamplerState, mTextureType, GL_TEXTURE_WRAP_R, &gl::SamplerState::wrapR);
+        SyncSamplerStateMember(mFunctions, samplerState, mAppliedSamplerState, mTextureType, GL_TEXTURE_MAX_ANISOTROPY_EXT, &gl::SamplerState::maxAnisotropy);
+        SyncSamplerStateMember(mFunctions, samplerState, mAppliedSamplerState, mTextureType, GL_TEXTURE_BASE_LEVEL, &gl::SamplerState::baseLevel);
+        SyncSamplerStateMember(mFunctions, samplerState, mAppliedSamplerState, mTextureType, GL_TEXTURE_MAX_LEVEL, &gl::SamplerState::maxLevel);
+        SyncSamplerStateMember(mFunctions, samplerState, mAppliedSamplerState, mTextureType, GL_TEXTURE_MIN_LOD, &gl::SamplerState::minLod);
+        SyncSamplerStateMember(mFunctions, samplerState, mAppliedSamplerState, mTextureType, GL_TEXTURE_MAX_LOD, &gl::SamplerState::maxLod);
+        SyncSamplerStateMember(mFunctions, samplerState, mAppliedSamplerState, mTextureType, GL_TEXTURE_COMPARE_MODE, &gl::SamplerState::compareMode);
+        SyncSamplerStateMember(mFunctions, samplerState, mAppliedSamplerState, mTextureType, GL_TEXTURE_COMPARE_FUNC, &gl::SamplerState::compareFunc);
+        SyncSamplerStateMember(mFunctions, samplerState, mAppliedSamplerState, mTextureType, GL_TEXTURE_SWIZZLE_R, &gl::SamplerState::swizzleRed);
+        SyncSamplerStateMember(mFunctions, samplerState, mAppliedSamplerState, mTextureType, GL_TEXTURE_SWIZZLE_G, &gl::SamplerState::swizzleGreen);
+        SyncSamplerStateMember(mFunctions, samplerState, mAppliedSamplerState, mTextureType, GL_TEXTURE_SWIZZLE_B, &gl::SamplerState::swizzleBlue);
+        SyncSamplerStateMember(mFunctions, samplerState, mAppliedSamplerState, mTextureType, GL_TEXTURE_SWIZZLE_A, &gl::SamplerState::swizzleAlpha);
+    }
+}
+
+GLuint TextureGL::getTextureID() const
+{
+    return mTextureID;
+}
+
 }

src/libANGLE/renderer/gl/TextureGL.h

@@ -9,15 +9,19 @@
 #ifndef LIBANGLE_RENDERER_GL_TEXTUREGL_H_
 #define LIBANGLE_RENDERER_GL_TEXTUREGL_H_
 
+#include "libANGLE/angletypes.h"
 #include "libANGLE/renderer/TextureImpl.h"
 
 namespace rx
 {
 
+class FunctionsGL;
+class StateManagerGL;
+
 class TextureGL : public TextureImpl
 {
   public:
-    TextureGL();
+    TextureGL(GLenum type, const FunctionsGL *functions, StateManagerGL *stateManager);
     ~TextureGL() override;
 
     void setUsage(GLenum usage) override;
@@ -44,8 +48,19 @@ class TextureGL : public TextureImpl
     void bindTexImage(egl::Surface *surface) override;
     void releaseTexImage() override;
 
+    void syncSamplerState(const gl::SamplerState &samplerState) const;
+    GLuint getTextureID() const;
+
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureGL);
+
+    GLenum mTextureType;
+
+    const FunctionsGL *mFunctions;
+    StateManagerGL *mStateManager;
+
+    mutable gl::SamplerState mAppliedSamplerState;
+    GLuint mTextureID;
 };
 
 }

src/libANGLE/renderer/gl/renderergl_utils.cpp

@@ -18,6 +18,13 @@ namespace rx
 namespace nativegl_gl
 {
 
+static GLint QuerySingleGLInt(const FunctionsGL *functions, GLenum name)
+{
+    GLint result;
+    functions->getIntegerv(name, &result);
+    return result;
+}
+
 void GenerateCaps(const FunctionsGL *functions, gl::Caps *caps, gl::TextureCapsMap *textureCapsMap,
                   gl::Extensions *extensions)
 {
@@ -25,10 +32,10 @@ void GenerateCaps(const FunctionsGL *functions, gl::Caps *caps, gl::TextureCapsM
 
     // Table 6.28, implementation dependent values
     caps->maxElementIndex = static_cast<GLint64>(std::numeric_limits<unsigned int>::max());
-    caps->max3DTextureSize = 256;
-    caps->max2DTextureSize = 2048;
-    caps->maxCubeMapTextureSize = 2048;
-    caps->maxArrayTextureLayers = 256;
+    caps->max3DTextureSize = QuerySingleGLInt(functions, GL_MAX_3D_TEXTURE_SIZE);
+    caps->max2DTextureSize = QuerySingleGLInt(functions, GL_MAX_TEXTURE_SIZE);
+    caps->maxCubeMapTextureSize = QuerySingleGLInt(functions, GL_MAX_CUBE_MAP_TEXTURE_SIZE);
+    caps->maxArrayTextureLayers = QuerySingleGLInt(functions, GL_MAX_ARRAY_TEXTURE_LAYERS);
     caps->maxLODBias = 2.0f;
     caps->maxRenderbufferSize = 2048;
     caps->maxDrawBuffers = 4;
@@ -63,14 +70,14 @@ void GenerateCaps(const FunctionsGL *functions, gl::Caps *caps, gl::TextureCapsM
     caps->maxVertexUniformVectors = 256;
     caps->maxVertexUniformBlocks = 12;
     caps->maxVertexOutputComponents = 64;
-    caps->maxVertexTextureImageUnits = 16;
+    caps->maxVertexTextureImageUnits = QuerySingleGLInt(functions, GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS);
 
     // Table 6.32, implementation dependent fragment shader limits
     caps->maxFragmentUniformComponents = 896;
     caps->maxFragmentUniformVectors = 224;
     caps->maxFragmentUniformBlocks = 12;
     caps->maxFragmentInputComponents = 60;
-    caps->maxTextureImageUnits = 16;
+    caps->maxTextureImageUnits = QuerySingleGLInt(functions, GL_MAX_TEXTURE_IMAGE_UNITS);
     caps->minProgramTexelOffset = -8;
     caps->maxProgramTexelOffset = 7;
 
@@ -83,7 +90,7 @@ void GenerateCaps(const FunctionsGL *functions, gl::Caps *caps, gl::TextureCapsM
     caps->maxCombinedFragmentUniformComponents = (caps->maxFragmentUniformBlocks * (caps->maxUniformBlockSize / 4)) + caps->maxFragmentUniformComponents;
     caps->maxVaryingComponents = 60;
     caps->maxVaryingVectors = 15;
-    caps->maxCombinedTextureImageUnits = 32;
+    caps->maxCombinedTextureImageUnits = caps->maxVertexTextureImageUnits + caps->maxTextureImageUnits;
 
     // Table 6.34, implementation dependent transform feedback limits
     caps->maxTransformFeedbackInterleavedComponents = 64;