All surfaces follow D3D Y convention

src/libGLESv2/mathutil.h

 //
 // Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 
 // mathutil.h: Math and bit manipulation functions.
 
 #ifndef LIBGLESV2_MATHUTIL_H_
 #define LIBGLESV2_MATHUTIL_H_
 
 #include <math.h>
+#include <windows.h>
 
 namespace gl
 {
 inline bool isPow2(int x)
 {
     return (x & (x - 1)) == 0 && (x != 0);
 }
 
 inline int log2(int x)
 {
     int r = 0;
     while ((x >> r) > 1) r++;
     return r;
 }
 
 inline unsigned int ceilPow2(unsigned int x)
 {
     if (x != 0) x--;
     x |= x >> 1;
     x |= x >> 2;
     x |= x >> 4;
     x |= x >> 8;
     x |= x >> 16;
     x++;
 
     return x;
 }
 
+template<typename T, typename MIN, typename MAX>

[dgkoch, 2010/12/23 20:19:23]

Do you really want to allow different types for min/max?  Seems like you'd want
them all to be of type T.

[apatrick1, 2011/01/07 23:40:22]

int min = 0;
LONG max = 1;
clamp(0.5, min, max);

would be an error without different types for T, MIN and MAX. I can go through
and fix all 16 errors if you like :)

[dgkoch, 2011/01/11 20:00:07]

Fair enough.  Can leave it then.

+inline T clamp(T x, MIN min, MAX max)
+{
+    return x < min ? min : (x > max ? max : x);
+}
+
 inline float clamp01(float x)
 {
-    return x < 0 ? 0 : (x > 1 ? 1 : x);
+    return clamp(x, 0.0f, 1.0f);
 }
 
 template<const int n>
 inline unsigned int unorm(float x)
 {
     const unsigned int max = 0xFFFFFFFF >> (32 - n);
 
     if (x > 1)
     {
         return max;
     }
     else if (x < 0)
     {
         return 0;
     }
     else
     {
         return (unsigned int)(max * x + 0.5f);
     }
 }
+
+inline RECT transformPixelRect(GLint x, GLint y, GLint w, GLint h, GLint surfaceHeight)
+{
+    RECT rect = {x,
+                 surfaceHeight - y - h,
+                 x + w,
+                 surfaceHeight - y};
+    return rect;
+}
+
+inline int transformPixelYOffset(GLint yoffset, GLint h, GLint surfaceHeight)
+{
+    return surfaceHeight - yoffset - h;
+}
+
+inline GLenum adjustWinding(GLenum winding)
+{
+    ASSERT(winding == GL_CW || winding == GL_CCW);
+    return winding == GL_CW ? GL_CCW : GL_CW;
+}
 }
 
 #endif   // LIBGLESV2_MATHUTIL_H_