Implement queries and enums for buffer mapping.

src/common/mathutil.h

@@ -65,6 +65,19 @@ inline int clampToInt(unsigned int x)
     return static_cast<int>(std::min(x, static_cast<unsigned int>(std::numeric_limits<int>::max())));
 }
 
+template <typename DestT, typename SrcT>
+inline DestT clampCast(SrcT value)
+{
+    // This assumes SrcT can properly represent DestT::min/max
+    // Unfortunately we can't use META_ASSERT without C++11 constexpr support
+    ASSERT(static_cast<DestT>(static_cast<SrcT>(std::numeric_limits<DestT>::min())) == std::numeric_limits<DestT>::min());
+    ASSERT(static_cast<DestT>(static_cast<SrcT>(std::numeric_limits<DestT>::max())) == std::numeric_limits<DestT>::max());
+
+    SrcT lo = static_cast<SrcT>(std::numeric_limits<DestT>::min());
+    SrcT hi = static_cast<SrcT>(std::numeric_limits<DestT>::max());
+    return static_cast<DestT>(value > lo ? (value > hi ? hi : value) : lo);
+}
+
 template<typename T, typename MIN, typename MAX>
 inline T clamp(T x, MIN min, MAX max)
 {

src/libGLESv2/Buffer.cpp

@@ -106,9 +106,9 @@ rx::BufferStorage *Buffer::getStorage() const
     return mBufferStorage;
 }
 
-unsigned int Buffer::size() const
+GLint64 Buffer::size() const
 {
-    return mBufferStorage->getSize();
+    return static_cast<GLint64>(mBufferStorage->getSize());
 }
 
 GLenum Buffer::usage() const

src/libGLESv2/Buffer.h

@@ -47,7 +47,7 @@ class Buffer : public RefCountObject
     GLint64 mapLength() const;
 
     rx::BufferStorage *getStorage() const;
-    unsigned int size() const;
+    GLint64 size() const;
 
     void markTransformFeedbackUsage();
 

src/libGLESv2/libGLESv2.cpp

@@ -2487,6 +2487,11 @@ void __stdcall glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params
                 return gl::error(GL_INVALID_ENUM);
             }
 
+            if (!gl::ValidBufferParameter(context, pname))
+            {
+                return gl::error(GL_INVALID_ENUM);
+            }
+
             gl::Buffer *buffer = context->getTargetBuffer(target);
 
             if (!buffer)
@@ -2498,12 +2503,24 @@ void __stdcall glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params
             switch (pname)
             {
               case GL_BUFFER_USAGE:
-                *params = buffer->usage();
+                *params = static_cast<GLint>(buffer->usage());
                 break;
               case GL_BUFFER_SIZE:
-                *params = buffer->size();
+                *params = gl::clampCast<GLint>(buffer->size());
                 break;
-              default: return gl::error(GL_INVALID_ENUM);
+              case GL_BUFFER_ACCESS_FLAGS:
+                *params = buffer->accessFlags();
+                break;
+              case GL_BUFFER_MAPPED:
+                *params = static_cast<GLint>(buffer->mapped());
+                break;
+              case GL_BUFFER_MAP_OFFSET:
+                *params = gl::clampCast<GLint>(buffer->mapOffset());
+                break;
+              case GL_BUFFER_MAP_LENGTH:
+                *params = gl::clampCast<GLint>(buffer->mapLength());
+                break;
+              default: UNREACHABLE(); break;
             }
         }
     }
@@ -6657,8 +6674,24 @@ void __stdcall glGetBufferPointerv(GLenum target, GLenum pname, GLvoid** params)
                 return gl::error(GL_INVALID_OPERATION);
             }
 
-            // glGetBufferPointerv
-            UNIMPLEMENTED();
+            if (!gl::ValidBufferTarget(context, target))
+            {
+                return gl::error(GL_INVALID_ENUM);
+            }
+
+            if (pname != GL_BUFFER_MAP_POINTER)
+            {
+                return gl::error(GL_INVALID_ENUM);
+            }
+
+            gl::Buffer *buffer = context->getTargetBuffer(target);
+
+            if (!buffer || !buffer->mapped())
+            {
+                *params = NULL;
+            }
+
+            *params = buffer->mapPointer();
         }
     }
     catch(std::bad_alloc&)
@@ -9228,8 +9261,46 @@ void __stdcall glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64* pa
                 return gl::error(GL_INVALID_OPERATION);
             }
 
-            // glGetBufferParameteri64v
-            UNIMPLEMENTED();
+            if (!gl::ValidBufferTarget(context, target))
+            {
+                return gl::error(GL_INVALID_ENUM);
+            }
+
+            if (!gl::ValidBufferParameter(context, pname))
+            {
+                return gl::error(GL_INVALID_ENUM);
+            }
+
+            gl::Buffer *buffer = context->getTargetBuffer(target);
+
+            if (!buffer)
+            {
+                // A null buffer means that "0" is bound to the requested buffer target
+                return gl::error(GL_INVALID_OPERATION);
+            }
+
+            switch (pname)
+            {
+              case GL_BUFFER_USAGE:
+                *params = static_cast<GLint64>(buffer->usage());
+                break;
+              case GL_BUFFER_SIZE:
+                *params = buffer->size();
+                break;
+              case GL_BUFFER_ACCESS_FLAGS:
+                *params = static_cast<GLint64>(buffer->accessFlags());
+                break;
+              case GL_BUFFER_MAPPED:
+                *params = static_cast<GLint64>(buffer->mapped());
+                break;
+              case GL_BUFFER_MAP_OFFSET:
+                *params = buffer->mapOffset();
+                break;
+              case GL_BUFFER_MAP_LENGTH:
+                *params = buffer->mapLength();
+                break;
+              default: UNREACHABLE(); break;
+            }
         }
     }
     catch(std::bad_alloc&)

src/libGLESv2/validationES.cpp

@@ -94,6 +94,27 @@ bool ValidBufferTarget(const Context *context, GLenum target)
     }
 }
 
+bool ValidBufferParameter(const Context *context, GLenum pname)
+{
+    switch (pname)
+    {
+      case GL_BUFFER_USAGE:
+      case GL_BUFFER_SIZE:
+        return true;
+
+      // GL_BUFFER_MAP_POINTER is a special case, and may only be
+      // queried with GetBufferPointerv
+      case GL_BUFFER_ACCESS_FLAGS:
+      case GL_BUFFER_MAPPED:
+      case GL_BUFFER_MAP_OFFSET:
+      case GL_BUFFER_MAP_LENGTH:
+        return (context->getClientVersion() >= 3);
+
+      default:
+        return false;
+    }
+}
+
 bool ValidMipLevel(const Context *context, GLenum target, GLint level)
 {
     int maxLevel = 0;

src/libGLESv2/validationES.h

@@ -18,6 +18,7 @@ bool ValidCap(const Context *context, GLenum cap);
 bool ValidTextureTarget(const Context *context, GLenum target);
 bool ValidFramebufferTarget(GLenum target);
 bool ValidBufferTarget(const Context *context, GLenum target);
+bool ValidBufferParameter(const Context *context, GLenum pname);
 bool ValidMipLevel(const Context *context, GLenum target, GLint level);
 bool ValidImageSize(const gl::Context *context, GLenum target, GLint level, GLsizei width, GLsizei height, GLsizei depth);
 bool ValidCompressedImageSize(const gl::Context *context, GLenum internalFormat, GLsizei width, GLsizei height);