Implement D3DConstantTable.

src/common/version.h

 #define MAJOR_VERSION 1
 #define MINOR_VERSION 0
 #define BUILD_VERSION 0
-#define BUILD_REVISION 1270
+#define BUILD_REVISION 1271
 
 #define STRINGIFY(x) #x
 #define MACRO_STRINGIFY(x) STRINGIFY(x)

src/libGLESv2/BinaryStream.h

@@ -80,6 +80,17 @@ class BinaryInputStream
         mOffset += length;
     }
 
+    void skip(size_t length)
+    {
+        if (mOffset + length > mLength)
+        {
+            mError = true;
+            return;
+        }
+
+        mOffset += length;
+    }
+
     size_t offset() const
     {
         return mOffset;

src/libGLESv2/D3DConstantTable.cpp

+//
+// Copyright (c) 2012 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.
+//
+
+// D3DConstantTable.cpp: Implements the D3DConstantTable class which parses
+// information about constants from the CTAB comment in a D3D shader blob.
+// Restructures the constant table as a hierarchy of constants in the same
+// way as D3DX.
+
+#include "libGLESv2/D3DConstantTable.h"
+
+#include <d3d9.h>
+#include <d3d9types.h>
+#include <windows.h>
+#include <mmsystem.h>
+
+#include "libGLESv2/BinaryStream.h"
+
+const static int SHADER_VERSION_MASK = D3DVS_VERSION(0, 0);
+const static int FOURCC_CTAB = MAKEFOURCC('C','T','A','B');
+
+namespace gl
+{
+// These structs and constants correspond to the format of the constant table in a shader binary.
+// They match the corresponding structures in d3dx9shader.h.
+namespace ctab
+{
+struct ConstantTable
+{
+    DWORD size;
+    DWORD creator;
+    DWORD version;
+    DWORD constants;
+    DWORD constantInfos;
+    DWORD flags;
+    DWORD target;
+};
+
+struct ConstantInfo
+{
+    DWORD name;
+    WORD registerSet;
+    WORD registerIndex;
+    WORD registerCount;
+    WORD reserved;
+    DWORD typeInfo;
+    DWORD defaultValue;
+};
+
+struct TypeInfo
+{
+    WORD typeClass;
+    WORD type;
+    WORD rows;
+    WORD columns;
+    WORD elements;
+    WORD structMembers;
+    DWORD structMemberInfos;
+};
+
+struct StructMemberInfo
+{
+    DWORD name;
+    DWORD typeInfo;
+};
+}
+
+D3DConstant::D3DConstant(const char *base, const ctab::ConstantInfo *constantInfo)
+{
+    const ctab::TypeInfo *typeInfo = reinterpret_cast<const ctab::TypeInfo*>(base + constantInfo->typeInfo);
+
+    name = base + constantInfo->name;
+    registerSet = static_cast<RegisterSet>(constantInfo->registerSet);
+    registerIndex = constantInfo->registerIndex;
+    registerCount = constantInfo->registerCount;
+    typeClass = static_cast<Class>(typeInfo->typeClass);
+    type = static_cast<Type>(typeInfo->type);
+    rows = typeInfo->rows;
+    columns = typeInfo->columns;
+    elements = typeInfo->elements;
+
+    if (typeClass == CLASS_STRUCT)
+    {
+        addStructMembers(base, registerSet, registerIndex, typeInfo);
+    }
+}
+
+D3DConstant::D3DConstant(const char *base, RegisterSet registerSet, unsigned registerIndex, const ctab::StructMemberInfo *memberInfo)
+    : registerSet(registerSet), registerIndex(registerIndex)
+{
+    const ctab::TypeInfo *typeInfo = reinterpret_cast<const ctab::TypeInfo*>(base + memberInfo->typeInfo);
+
+    name = base + memberInfo->name;
+    registerCount = typeInfo->rows * typeInfo->elements;
+    typeClass = static_cast<Class>(typeInfo->typeClass);
+    type = static_cast<Type>(typeInfo->type);
+    rows = typeInfo->rows;
+    columns = typeInfo->columns;
+    elements = typeInfo->elements;
+
+    if (typeClass == CLASS_STRUCT)
+    {
+        registerCount = addStructMembers(base, registerSet, registerIndex, typeInfo);
+    }
+}
+
+D3DConstant::~D3DConstant()
+{
+    for (size_t j = 0; j < structMembers.size(); ++j)
+    {
+        for (size_t i = 0; i < structMembers[j].size(); ++i)
+        {
+            delete structMembers[j][i];
+        }
+    }
+}
+
+unsigned D3DConstant::addStructMembers(const char *base, RegisterSet registerSet, unsigned registerIndex, const ctab::TypeInfo *typeInfo)
+{
+    const ctab::StructMemberInfo *memberInfos = reinterpret_cast<const ctab::StructMemberInfo*>(
+        base + typeInfo->structMemberInfos);
+
+    unsigned memberIndex = registerIndex;
+
+    structMembers.resize(elements);
+
+    for (unsigned j = 0; j < elements; ++j)
+    {
+        structMembers[j].resize(typeInfo->structMembers);
+
+        for (unsigned i = 0; i < typeInfo->structMembers; ++i)
+        {
+            const ctab::TypeInfo *memberTypeInfo = reinterpret_cast<const ctab::TypeInfo*>(
+                base + memberInfos[i].typeInfo);
+
+            D3DConstant *member = new D3DConstant(base, registerSet, memberIndex, memberInfos + i);
+            memberIndex += member->registerCount;
+
+            structMembers[j][i] = member;
+        }
+    }
+
+    return memberIndex - registerIndex;
+}
+
+D3DConstantTable::D3DConstantTable(void *blob, size_t size) : mError(false)
+{
+    BinaryInputStream stream(blob, size);
+
+    int version;
+    stream.read(&version);
+    if ((version & SHADER_VERSION_MASK) != SHADER_VERSION_MASK)
+    {
+        mError = true;
+        return;
+    }
+
+    const ctab::ConstantTable* constantTable = NULL;
+
+    while (!stream.error())
+    {
+        int token;
+        stream.read(&token);
+
+        if ((token & D3DSI_OPCODE_MASK) == D3DSIO_COMMENT)
+        {
+            size_t length = ((token & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT) * sizeof(DWORD);
+
+            int fourcc;
+            stream.read(&fourcc);
+            if (fourcc == FOURCC_CTAB)
+            {
+                constantTable = reinterpret_cast<const ctab::ConstantTable*>(static_cast<const char*>(blob) + stream.offset());
+                break;
+            }
+
+            stream.skip(length - sizeof(fourcc));
+        }
+        else if (token == D3DSIO_END)
+        {
+            break;
+        }
+    }
+
+    mError = !constantTable || stream.error();
+    if (mError)
+    {
+        return;
+    }
+
+    const char *base = reinterpret_cast<const char*>(constantTable);
+
+    mConstants.resize(constantTable->constants);
+    const ctab::ConstantInfo *constantInfos =
+        reinterpret_cast<const ctab::ConstantInfo*>(base + constantTable->constantInfos);
+    for (size_t i = 0; i < constantTable->constants; ++i)
+    {
+        mConstants[i] = new D3DConstant(base, constantInfos + i);
+    }
+}
+
+D3DConstantTable::~D3DConstantTable()
+{
+    for (size_t i = 0; i < mConstants.size(); ++i)
+    {
+        delete mConstants[i];
+    }
+}
+
+const D3DConstant *D3DConstantTable::getConstant(unsigned index) const
+{
+    return mConstants[index];
+}
+
+const D3DConstant *D3DConstantTable::getConstantByName(const char *name) const
+{
+    for (size_t i = 0; i < mConstants.size(); ++i)
+    {
+        const D3DConstant *constant = getConstant(i);
+        if (constant->name == name)
+        {
+            return constant;
+        }
+    }
+
+    return NULL;
+}
+
+}

src/libGLESv2/D3DConstantTable.h

+//
+// Copyright (c) 2012 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.
+//
+
+// D3DConstantTable.h: Implements the D3DConstantTable class which parses
+// information about constants from the CTAB comment in a D3D shader blob.
+// Restructures the constant table as a hierarchy of constants in the same
+// way as D3DX.
+
+#ifndef LIBGLESV2_D3DCONSTANTTABLE_H_
+#define LIBGLESV2_D3DCONSTANTTABLE_H_
+
+#include <vector>
+
+#include "common/angleutils.h"
+
+namespace gl
+{
+
+namespace ctab
+{
+struct ConstantTable;
+struct ConstantInfo;
+struct TypeInfo;
+struct StructMemberInfo;
+}
+
+struct D3DConstant
+{
+    // These enums match those in d3dx9shader.h.
+    enum Class
+    {
+        CLASS_SCALAR,
+        CLASS_VECTOR,
+        CLASS_MATRIX_ROWS,
+        CLASS_MATRIX_COLUMNS,
+        CLASS_OBJECT,
+        CLASS_STRUCT,
+    };
+
+    enum RegisterSet
+    {
+        RS_BOOL,
+        RS_INT4,
+        RS_FLOAT4,
+        RS_SAMPLER,
+    };
+
+    enum Type
+    {
+        PT_VOID,
+        PT_BOOL,
+        PT_INT,
+        PT_FLOAT,
+        PT_STRING,
+        PT_TEXTURE,
+        PT_TEXTURE1D,
+        PT_TEXTURE2D,
+        PT_TEXTURE3D,
+        PT_TEXTURECUBE,
+        PT_SAMPLER,
+        PT_SAMPLER1D,
+        PT_SAMPLER2D,
+        PT_SAMPLER3D,
+        PT_SAMPLERCUBE,
+        PT_PIXELSHADER,
+        PT_VERTEXSHADER,
+        PT_PIXELFRAGMENT,
+        PT_VERTEXFRAGMENT,
+        PT_UNSUPPORTED,
+    };
+    
+    D3DConstant(const char *base, const ctab::ConstantInfo *constantInfo);
+    ~D3DConstant();
+
+    std::string name;
+    RegisterSet registerSet;
+    unsigned registerIndex;
+    unsigned registerCount;
+    Class typeClass;
+    Type type;
+    unsigned rows;
+    unsigned columns;
+    unsigned elements;
+
+    // Array of structure members.
+    std::vector<std::vector<const D3DConstant*> > structMembers;    
+
+  private:
+    D3DConstant(const char *base, RegisterSet registerSet, unsigned registerIndex, const ctab::StructMemberInfo *memberInfo);
+    unsigned addStructMembers(const char *base, RegisterSet registerSet, unsigned registerIndex, const ctab::TypeInfo *typeInfo);
+};
+
+class D3DConstantTable
+{
+  public:
+    D3DConstantTable(void *blob, size_t size);
+    ~D3DConstantTable();
+
+    bool error() const { return mError; }
+
+    unsigned constants() const { return mConstants.size(); }
+    const D3DConstant *getConstant(unsigned index) const;
+    const D3DConstant *getConstantByName(const char *name) const;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(D3DConstantTable);
+    std::vector<const D3DConstant*> mConstants;
+    bool mError;
+};
+
+}
+
+#endif   // LIBGLESV2_D3DCONSTANTTABLE_H_

src/libGLESv2/Program.h

@@ -10,7 +10,6 @@
 #ifndef LIBGLESV2_PROGRAM_H_
 #define LIBGLESV2_PROGRAM_H_
 
-#include <d3dx9.h>
 #include <string>
 #include <set>
 

src/libGLESv2/ProgramBinary.h

@@ -14,13 +14,14 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 
-#include <d3dx9.h>
 #include <d3dcompiler.h>
 #include <string>
 #include <vector>
 
-#include "libGLESv2/Shader.h"
 #include "libGLESv2/Context.h"
+#include "libGLESv2/D3DConstantTable.h"
+#include "libGLESv2/mathutil.h"
+#include "libGLESv2/Shader.h"
 
 namespace gl
 {
@@ -54,18 +55,18 @@ struct Uniform
             registerCount = 0;
         }
 
-        void set(const D3DXCONSTANT_DESC &constantDescription)
+        void set(const D3DConstant *constant)
         {
-            switch(constantDescription.RegisterSet)
+            switch(constant->registerSet)
             {
-              case D3DXRS_BOOL:    boolIndex = constantDescription.RegisterIndex;    break;
-              case D3DXRS_FLOAT4:  float4Index = constantDescription.RegisterIndex;  break;
-              case D3DXRS_SAMPLER: samplerIndex = constantDescription.RegisterIndex; break;
+              case D3DConstant::RS_BOOL:    boolIndex = constant->registerIndex;    break;
+              case D3DConstant::RS_FLOAT4:  float4Index = constant->registerIndex;  break;
+              case D3DConstant::RS_SAMPLER: samplerIndex = constant->registerIndex; break;
               default: UNREACHABLE();
             }
             
-            ASSERT(registerCount == 0 || registerCount == (int)constantDescription.RegisterCount);
-            registerCount = constantDescription.RegisterCount;
+            ASSERT(registerCount == 0 || registerCount == (int)constant->registerCount);
+            registerCount = constant->registerCount;
         }
 
         int float4Index;
@@ -163,23 +164,23 @@ class ProgramBinary : public RefCountObject
   private:
     DISALLOW_COPY_AND_ASSIGN(ProgramBinary);
 
-    ID3D10Blob *compileToBinary(InfoLog &infoLog, const char *hlsl, const char *profile, ID3DXConstantTable **constantTable);
+    ID3D10Blob *compileToBinary(InfoLog &infoLog, const char *hlsl, const char *profile, D3DConstantTable **constantTable);
 
     int packVaryings(InfoLog &infoLog, const Varying *packing[][4], FragmentShader *fragmentShader);
     bool linkVaryings(InfoLog &infoLog, std::string& pixelHLSL, std::string& vertexHLSL, FragmentShader *fragmentShader, VertexShader *vertexShader);
 
     bool linkAttributes(InfoLog &infoLog, const AttributeBindings &attributeBindings, FragmentShader *fragmentShader, VertexShader *vertexShader);
 
-    bool linkUniforms(InfoLog &infoLog, GLenum shader, ID3DXConstantTable *constantTable);
-    bool defineUniform(InfoLog &infoLog, GLenum shader, const D3DXHANDLE &constantHandle, const D3DXCONSTANT_DESC &constantDescription, std::string name = "");
-    bool defineUniform(GLenum shader, const D3DXCONSTANT_DESC &constantDescription, const std::string &name);
-    Uniform *createUniform(const D3DXCONSTANT_DESC &constantDescription, const std::string &name);
+    bool linkUniforms(InfoLog &infoLog, GLenum shader, D3DConstantTable *constantTable);
+    bool defineUniform(InfoLog &infoLog, GLenum shader, const D3DConstant *constant, std::string name = "");
+    bool defineUniform(GLenum shader, const D3DConstant *constant, const std::string &name);
+    Uniform *createUniform( const D3DConstant *constant, const std::string &name);
     bool applyUniformnfv(Uniform *targetUniform, const GLfloat *v);
     bool applyUniform1iv(Uniform *targetUniform, GLsizei count, const GLint *v);
     bool applyUniform2iv(Uniform *targetUniform, GLsizei count, const GLint *v);
     bool applyUniform3iv(Uniform *targetUniform, GLsizei count, const GLint *v);
     bool applyUniform4iv(Uniform *targetUniform, GLsizei count, const GLint *v);
-    void applyUniformniv(Uniform *targetUniform, GLsizei count, const D3DXVECTOR4 *vector);
+    void applyUniformniv(Uniform *targetUniform, GLsizei count, const Vector4 *vector);
     void applyUniformnbv(Uniform *targetUniform, GLsizei count, int width, const GLboolean *v);
 
     IDirect3DDevice9 *mDevice;
@@ -188,8 +189,8 @@ class ProgramBinary : public RefCountObject
     IDirect3DVertexShader9 *mVertexExecutable;
 
     // These are only used during linking.
-    ID3DXConstantTable *mConstantTablePS;
-    ID3DXConstantTable *mConstantTableVS;
+    D3DConstantTable *mConstantTablePS;
+    D3DConstantTable *mConstantTableVS;
 
     Attribute mLinkedAttribute[MAX_VERTEX_ATTRIBS];
     int mSemanticIndex[MAX_VERTEX_ATTRIBS];

src/libGLESv2/Shader.h

@@ -14,7 +14,6 @@
 
 #define GL_APICALL
 #include <GLES2/gl2.h>
-#include <d3dx9.h>
 #include <string>
 #include <list>
 #include <vector>

src/libGLESv2/libGLESv2.vcproj

@@ -373,6 +373,10 @@
 				>
 			</File>
 			<File
+				RelativePath=".\D3DConstantTable.cpp"
+				>
+			</File>
+			<File
 				RelativePath=".\Fence.cpp"
 				>
 			</File>
@@ -467,6 +471,10 @@
 				>
 			</File>
 			<File
+				RelativePath=".\D3DConstantTable.h"
+				>
+			</File>
+			<File
 				RelativePath=".\Fence.h"
 				>
 			</File>

src/libGLESv2/mathutil.h

@@ -15,6 +15,17 @@
 
 namespace gl
 {
+struct Vector4
+{
+    Vector4() {}
+    Vector4(float x, float y, float z, float w) : x(x), y(y), z(z), w(w) {}
+
+    float x;
+    float y;
+    float z;
+    float w;
+};
+
 inline bool isPow2(int x)
 {
     return (x & (x - 1)) == 0 && (x != 0);