LibGL shader modification, LibGL texture1D and textureRectangle added

Change-Id: I89cc195563b8f57ebc807b3bf231bc71274cdf42 Reviewed-on: https://swiftshader-review.googlesource.com/3464Reviewed-by: Maxime Grégoire <mgregoire@google.com> Tested-by: Maxime Grégoire <mgregoire@google.com>

LibGL shader modification, LibGL texture1D and textureRectangle added
f0338bbc · Maxime Grégoire · e2b31f2f · f0338bbc · f0338bbc · f0338bbc
Commit f0338bbc authored Jun 10, 2015 by Maxime Grégoire
25 changed files
--- a/src/OpenGL/compiler/BaseTypes.h
+++ b/src/OpenGL/compiler/BaseTypes.h
@@ -129,10 +129,21 @@ enum TQualifier : unsigned char
    EvqInOut,
    EvqConstReadOnly,
+	// built-ins read by fragment shader
+	EvqMultiTexCoord0,
+	EvqMultiTexCoord1,
+	EvqMultiTexCoord2,
+	EvqMultiTexCoord3,
+	EvqMultiTexCoord4,
+	EvqMultiTexCoord5,
+	EvqMultiTexCoord6,
+	EvqMultiTexCoord7,
    // built-ins written by vertex shader
    EvqPosition,
    EvqPointSize,
    EvqInstanceID,
+	EvqTexCoords,
    // built-ins read by fragment shader
    EvqFragCoord,
@@ -201,7 +212,16 @@ inline const char *getQualifierString(TQualifier qualifier)
    case EvqPosition:       return "Position";       break;
    case EvqPointSize:      return "PointSize";      break;
    case EvqInstanceID:     return "InstanceID";     break;
-    case EvqFragCoord:      return "FragCoord";      break;
+	case EvqFragCoord:      return "FragCoord";      break;
+	case EvqMultiTexCoord0:      return "MultiTexCoord0";      break;
+	case EvqMultiTexCoord1:      return "MultiTexCoord1";      break;
+	case EvqMultiTexCoord2:      return "MultiTexCoord2";      break;
+	case EvqMultiTexCoord3:      return "MultiTexCoord3";      break;
+	case EvqMultiTexCoord4:      return "MultiTexCoord4";      break;
+	case EvqMultiTexCoord5:      return "MultiTexCoord5";      break;
+	case EvqMultiTexCoord6:      return "MultiTexCoord6";      break;
+	case EvqMultiTexCoord7:      return "MultiTexCoord7";      break;
+	case EvqTexCoords:       return "TexCoords";       break;
    case EvqFrontFacing:    return "FrontFacing";    break;
    case EvqFragColor:      return "FragColor";      break;
    case EvqFragData:       return "FragData";       break;

--- a/src/OpenGL/compiler/Compiler.cpp
+++ b/src/OpenGL/compiler/Compiler.cpp
 //
 // Copyright (c) 2002-2013 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.
 //
 #include "Compiler.h"
 #include "AnalyzeCallDepth.h"
 #include "Initialize.h"
 #include "InitializeParseContext.h"
 #include "InitializeGlobals.h"
 #include "ParseHelper.h"
 #include "ValidateLimitations.h"
-namespace 
+namespace
 {
-class TScopedPoolAllocator {
+	class TScopedPoolAllocator {
-public:
+	public:
-    TScopedPoolAllocator(TPoolAllocator* allocator, bool pushPop)
+		TScopedPoolAllocator(TPoolAllocator* allocator, bool pushPop)
-        : mAllocator(allocator), mPushPopAllocator(pushPop) {
+			: mAllocator(allocator), mPushPopAllocator(pushPop) {
-        if (mPushPopAllocator) mAllocator->push();
+			if(mPushPopAllocator) mAllocator->push();
-        SetGlobalPoolAllocator(mAllocator);
+			SetGlobalPoolAllocator(mAllocator);
-    }
+		}
-    ~TScopedPoolAllocator() {
+		~TScopedPoolAllocator() {
-        SetGlobalPoolAllocator(NULL);
+			SetGlobalPoolAllocator(NULL);
-        if (mPushPopAllocator) mAllocator->pop();
+			if(mPushPopAllocator) mAllocator->pop();
-    }
+		}
-private:
+	private:
-    TPoolAllocator* mAllocator;
+		TPoolAllocator* mAllocator;
-    bool mPushPopAllocator;
+		bool mPushPopAllocator;
-};
+	};
 }  // namespace
 //
 // Initialize built-in resources with minimum expected values.
 //
 ShBuiltInResources::ShBuiltInResources()
 {
-    // Constants.
+	// Constants.
-    MaxVertexAttribs = 8;
+	MaxVertexAttribs = 8;
-    MaxVertexUniformVectors = 128;
+	MaxVertexUniformVectors = 128;
-    MaxVaryingVectors = 8;
+	MaxVaryingVectors = 8;
-    MaxVertexTextureImageUnits = 0;
+	MaxVertexTextureImageUnits = 0;
-    MaxCombinedTextureImageUnits = 8;
+	MaxCombinedTextureImageUnits = 8;
-    MaxTextureImageUnits = 8;
+	MaxTextureImageUnits = 8;
-    MaxFragmentUniformVectors = 16;
+	MaxTextureCoords = 8;
-    MaxDrawBuffers = 1;
+	MaxFragmentUniformVectors = 16;
-    MaxVertexOutputVectors = 16;
+	MaxDrawBuffers = 1;
-    MaxFragmentInputVectors = 15;
+	MaxVertexOutputVectors = 16;
-    MinProgramTexelOffset = -8;
+	MaxFragmentInputVectors = 15;
-    MaxProgramTexelOffset = 7;
+	MinProgramTexelOffset = -8;
+	MaxProgramTexelOffset = 7;
-    // Extensions.
-    OES_standard_derivatives = 0;
+	// Extensions.
-	OES_fragment_precision_high = 0;
+	OES_standard_derivatives = 0;
-    OES_EGL_image_external = 0;
+	OES_fragment_precision_high = 0;
+	OES_EGL_image_external = 0;
-	MaxCallStackDepth = UINT_MAX;
-}
+	MaxCallStackDepth = UINT_MAX;
+}
-TCompiler::TCompiler(GLenum type)
-    : shaderType(type),
+TCompiler::TCompiler(GLenum type)
-      maxCallStackDepth(UINT_MAX)
+	: shaderType(type),
-{
+	maxCallStackDepth(UINT_MAX)
-	allocator.push();
+{
-    SetGlobalPoolAllocator(&allocator);
+	allocator.push();
-}
+	SetGlobalPoolAllocator(&allocator);
+}
-TCompiler::~TCompiler()
-{
+TCompiler::~TCompiler()
-	SetGlobalPoolAllocator(NULL);
+{
-    allocator.popAll();
+	SetGlobalPoolAllocator(NULL);
-}
+	allocator.popAll();
+}
-bool TCompiler::Init(const ShBuiltInResources& resources)
-{
+bool TCompiler::Init(const ShBuiltInResources& resources)
-    shaderVersion = 100;
+{
-    maxCallStackDepth = resources.MaxCallStackDepth;
+	shaderVersion = 100;
-    TScopedPoolAllocator scopedAlloc(&allocator, false);
+	maxCallStackDepth = resources.MaxCallStackDepth;
+	TScopedPoolAllocator scopedAlloc(&allocator, false);
-    // Generate built-in symbol table.
-    if (!InitBuiltInSymbolTable(resources))
+	// Generate built-in symbol table.
-        return false;
+	if(!InitBuiltInSymbolTable(resources))
-    InitExtensionBehavior(resources, extensionBehavior);
+		return false;
+	InitExtensionBehavior(resources, extensionBehavior);
-    return true;
-}
+	return true;
+}
-bool TCompiler::compile(const char* const shaderStrings[],
-                        const int numStrings,
+bool TCompiler::compile(const char* const shaderStrings[],
-                        int compileOptions)
+	const int numStrings,
-{
+	int compileOptions)
-    TScopedPoolAllocator scopedAlloc(&allocator, true);
+{
-    clearResults();
+	TScopedPoolAllocator scopedAlloc(&allocator, true);
+	clearResults();
-    if (numStrings == 0)
-        return true;
+	if(numStrings == 0)
+		return true;
-    // First string is path of source file if flag is set. The actual source follows.
-    const char* sourcePath = NULL;
+	// First string is path of source file if flag is set. The actual source follows.
-    int firstSource = 0;
+	const char* sourcePath = NULL;
-    if (compileOptions & SH_SOURCE_PATH)
+	int firstSource = 0;
-    {
+	if(compileOptions & SH_SOURCE_PATH)
-        sourcePath = shaderStrings[0];
+	{
-        ++firstSource;
+		sourcePath = shaderStrings[0];
-    }
+		++firstSource;
+	}
-    TIntermediate intermediate(infoSink);
-    TParseContext parseContext(symbolTable, extensionBehavior, intermediate,
+	TIntermediate intermediate(infoSink);
-                               shaderType, compileOptions, true,
+	TParseContext parseContext(symbolTable, extensionBehavior, intermediate,
-                               sourcePath, infoSink);
+		shaderType, compileOptions, false,
-    SetGlobalParseContext(&parseContext);
+		sourcePath, infoSink);
+	SetGlobalParseContext(&parseContext);
-    // We preserve symbols at the built-in level from compile-to-compile.
-    // Start pushing the user-defined symbols at global level.
+	// We preserve symbols at the built-in level from compile-to-compile.
-    symbolTable.push();
+	// Start pushing the user-defined symbols at global level.
-    if (!symbolTable.atGlobalLevel())
+	symbolTable.push();
-        infoSink.info.message(EPrefixInternalError, "Wrong symbol table level");
+	if(!symbolTable.atGlobalLevel())
+		infoSink.info.message(EPrefixInternalError, "Wrong symbol table level");
-    // Parse shader.
-    bool success =
+	// Parse shader.
-        (PaParseStrings(numStrings - firstSource, &shaderStrings[firstSource], NULL, &parseContext) == 0) &&
+	bool success =
-        (parseContext.treeRoot != NULL);
+		(PaParseStrings(numStrings - firstSource, &shaderStrings[firstSource], NULL, &parseContext) == 0) &&
+		(parseContext.treeRoot != NULL);
-    shaderVersion = parseContext.getShaderVersion();
+	shaderVersion = parseContext.getShaderVersion();
-    if (success) {
-        TIntermNode* root = parseContext.treeRoot;
+	if(success) {
-        success = intermediate.postProcess(root);
+		TIntermNode* root = parseContext.treeRoot;
+		success = intermediate.postProcess(root);
-        if (success)
-            success = validateCallDepth(root, infoSink);
+		if(success)
+			success = validateCallDepth(root, infoSink);
-        if (success && (compileOptions & SH_VALIDATE_LOOP_INDEXING))
-            success = validateLimitations(root);
+		if(success && (compileOptions & SH_VALIDATE_LOOP_INDEXING))
+			success = validateLimitations(root);
-        if (success && (compileOptions & SH_INTERMEDIATE_TREE))
-            intermediate.outputTree(root);
+		if(success && (compileOptions & SH_INTERMEDIATE_TREE))
+			intermediate.outputTree(root);
-        if (success && (compileOptions & SH_OBJECT_CODE))
-            success = translate(root);
+		if(success && (compileOptions & SH_OBJECT_CODE))
-    }
+			success = translate(root);
+	}
-    // Ensure symbol table is returned to the built-in level,
-    // throwing away all but the built-ins.
+	// Ensure symbol table is returned to the built-in level,
-    while (!symbolTable.atBuiltInLevel())
+	// throwing away all but the built-ins.
-        symbolTable.pop();
+	while(!symbolTable.atBuiltInLevel())
+		symbolTable.pop();
-    return success;
-}
+	return success;
+}
-bool TCompiler::InitBuiltInSymbolTable(const ShBuiltInResources &resources)
-{
+bool TCompiler::InitBuiltInSymbolTable(const ShBuiltInResources &resources)
-    assert(symbolTable.isEmpty());
+{
-    symbolTable.push();   // COMMON_BUILTINS
+	assert(symbolTable.isEmpty());
-    symbolTable.push();   // ESSL1_BUILTINS
+	symbolTable.push();   // COMMON_BUILTINS
-    symbolTable.push();   // ESSL3_BUILTINS
+	symbolTable.push();   // ESSL1_BUILTINS
+	symbolTable.push();   // ESSL3_BUILTINS
-	TPublicType integer;
-	integer.type = EbtInt;
+	TPublicType integer;
-	integer.primarySize = 1;
+	integer.type = EbtInt;
-	integer.secondarySize = 1;
+	integer.primarySize = 1;
-	integer.array = false;
+	integer.secondarySize = 1;
+	integer.array = false;
-	TPublicType floatingPoint;
-	floatingPoint.type = EbtFloat;
+	TPublicType floatingPoint;
-	floatingPoint.primarySize = 1;
+	floatingPoint.type = EbtFloat;
-	floatingPoint.secondarySize = 1;
+	floatingPoint.primarySize = 1;
-	floatingPoint.array = false;
+	floatingPoint.secondarySize = 1;
+	floatingPoint.array = false;
-	switch(shaderType)
-	{
+	switch(shaderType)
-    case GL_FRAGMENT_SHADER:
+	{
-		symbolTable.setDefaultPrecision(integer, EbpMedium);
+	case GL_FRAGMENT_SHADER:
-        break;
+		symbolTable.setDefaultPrecision(integer, EbpMedium);
-    case GL_VERTEX_SHADER:
+		symbolTable.setDefaultPrecision(floatingPoint, EbpHigh);
-		symbolTable.setDefaultPrecision(integer, EbpHigh);
+		break;
-		symbolTable.setDefaultPrecision(floatingPoint, EbpHigh);
+	case GL_VERTEX_SHADER:
-        break;
+		symbolTable.setDefaultPrecision(integer, EbpHigh);
-    default: assert(false && "Language not supported");
+		symbolTable.setDefaultPrecision(floatingPoint, EbpHigh);
-    }
+		break;
+	default: assert(false && "Language not supported");
-	InsertBuiltInFunctions(shaderType, resources, symbolTable);
+	}
-    IdentifyBuiltIns(shaderType, resources, symbolTable);
+	InsertBuiltInFunctions(shaderType, resources, symbolTable);
-    return true;
+	IdentifyBuiltIns(shaderType, resources, symbolTable);
-}
+	return true;
-void TCompiler::clearResults()
+}
-{
-    infoSink.info.erase();
+void TCompiler::clearResults()
-    infoSink.obj.erase();
+{
-    infoSink.debug.erase();
+	infoSink.info.erase();
-}
+	infoSink.obj.erase();
+	infoSink.debug.erase();
-bool TCompiler::validateCallDepth(TIntermNode *root, TInfoSink &infoSink)
+}
-{
-    AnalyzeCallDepth validator(root);
+bool TCompiler::validateCallDepth(TIntermNode *root, TInfoSink &infoSink)
+{
-	unsigned int depth = validator.analyzeCallDepth();
+	AnalyzeCallDepth validator(root);
-	if(depth == 0)
+	unsigned int depth = validator.analyzeCallDepth();
-	{
-        infoSink.info.prefix(EPrefixError);
+	if(depth == 0)
-        infoSink.info << "Missing main()";
+	{
-        return false;
+		infoSink.info.prefix(EPrefixError);
-	}
+		infoSink.info << "Missing main()";
-    else if(depth == UINT_MAX)
+		return false;
-	{
+	}
-        infoSink.info.prefix(EPrefixError);
+	else if(depth == UINT_MAX)
-        infoSink.info << "Function recursion detected";
+	{
-        return false;
+		infoSink.info.prefix(EPrefixError);
-	}
+		infoSink.info << "Function recursion detected";
-	else if(depth > maxCallStackDepth)
+		return false;
-	{
+	}
-        infoSink.info.prefix(EPrefixError);
+	else if(depth > maxCallStackDepth)
-        infoSink.info << "Function call stack too deep";
+	{
-        return false;
+		infoSink.info.prefix(EPrefixError);
-	}
+		infoSink.info << "Function call stack too deep";
+		return false;
-    return true;
+	}
-}
+	return true;
-bool TCompiler::validateLimitations(TIntermNode* root) {
+}
-    ValidateLimitations validate(shaderType, infoSink.info);
-    root->traverse(&validate);
+bool TCompiler::validateLimitations(TIntermNode* root) {
-    return validate.numErrors() == 0;
+	ValidateLimitations validate(shaderType, infoSink.info);
-}
+	root->traverse(&validate);
+	return validate.numErrors() == 0;
-const TExtensionBehavior& TCompiler::getExtensionBehavior() const
+}
-{
-    return extensionBehavior;
+const TExtensionBehavior& TCompiler::getExtensionBehavior() const
-}
+{
+	return extensionBehavior;
-bool InitCompilerGlobals()
+}
-{
-    if(!InitializePoolIndex())
+bool InitCompilerGlobals()
-	{
+{
-        assert(0 && "InitCompilerGlobals(): Failed to initalize global pool");
+	if(!InitializePoolIndex())
-        return false;
+	{
-    }
+		assert(0 && "InitCompilerGlobals(): Failed to initalize global pool");
+		return false;
-    if(!InitializeParseContextIndex())
+	}
-	{
-        assert(0 && "InitCompilerGlobals(): Failed to initalize parse context");
+	if(!InitializeParseContextIndex())
-        return false;
+	{
-    }
+		assert(0 && "InitCompilerGlobals(): Failed to initalize parse context");
+		return false;
-    return true;
+	}
-}
+	return true;
-void FreeCompilerGlobals()
+}
-{
-    FreeParseContextIndex();
+void FreeCompilerGlobals()
-    FreePoolIndex();
+{
-}
+	FreeParseContextIndex();
+	FreePoolIndex();
+}
--- a/src/OpenGL/compiler/Compiler.h
+++ b/src/OpenGL/compiler/Compiler.h
@@ -37,6 +37,7 @@ struct ShBuiltInResources
    int MaxVertexTextureImageUnits;
    int MaxCombinedTextureImageUnits;
    int MaxTextureImageUnits;
+	int MaxTextureCoords;
    int MaxFragmentUniformVectors;
    int MaxDrawBuffers;
    int MaxVertexOutputVectors;

--- a/src/OpenGL/compiler/Initialize.cpp
+++ b/src/OpenGL/compiler/Initialize.cpp
 //
 // Copyright (c) 2002-2013 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.
 //
 //
 // Create strings that declare built-in definitions, add built-ins that
 // cannot be expressed in the files, and establish mappings between 
 // built-in functions and operators.
 //
 #include "Initialize.h"
 #include "intermediate.h"
 void InsertBuiltInFunctions(GLenum type, const ShBuiltInResources &resources, TSymbolTable &symbolTable)
 {
 	TType *float1 = new TType(EbtFloat);
 	TType *float2 = new TType(EbtFloat, 2);
 	TType *float3 = new TType(EbtFloat, 3);
 	TType *float4 = new TType(EbtFloat, 4);
 	TType *genType = new TType(EbtGenType);
-    TType *int1 = new TType(EbtInt);
+	TType *int1 = new TType(EbtInt);
-    TType *uint1 = new TType(EbtUInt);
+	TType *uint1 = new TType(EbtUInt);
-    TType *genIType = new TType(EbtGenIType);
+	TType *genIType = new TType(EbtGenIType);
-    TType *genUType = new TType(EbtGenUType);
+	TType *genUType = new TType(EbtGenUType);
-    TType *genBType = new TType(EbtGenBType);
+	TType *genBType = new TType(EbtGenBType);
-    //
+	//
-    // Angle and Trigonometric Functions.
+	// Angle and Trigonometric Functions.
-    //
+	//
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpRadians, genType, "radians", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpRadians, genType, "radians", genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpDegrees, genType, "degrees", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpDegrees, genType, "degrees", genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpSin, genType, "sin", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpSin, genType, "sin", genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpCos, genType, "cos", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpCos, genType, "cos", genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpTan, genType, "tan", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpTan, genType, "tan", genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpAsin, genType, "asin", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpAsin, genType, "asin", genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpAcos, genType, "acos", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpAcos, genType, "acos", genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpAtan, genType, "atan", genType, genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpAtan, genType, "atan", genType, genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpAtan, genType, "atan", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpAtan, genType, "atan", genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpSinh, genType, "sinh", genType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpSinh, genType, "sinh", genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpCosh, genType, "cosh", genType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpCosh, genType, "cosh", genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTanh, genType, "tanh", genType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTanh, genType, "tanh", genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpAsinh, genType, "asinh", genType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpAsinh, genType, "asinh", genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpAcosh, genType, "acosh", genType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpAcosh, genType, "acosh", genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpAtanh, genType, "atanh", genType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpAtanh, genType, "atanh", genType);
-    //
+	//
-    // Exponential Functions.
+	// Exponential Functions.
-    //
+	//
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpPow, genType, "pow", genType, genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpPow, genType, "pow", genType, genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpExp, genType, "exp", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpExp, genType, "exp", genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpLog, genType, "log", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpLog, genType, "log", genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpExp2, genType, "exp2", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpExp2, genType, "exp2", genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpLog2, genType, "log2", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpLog2, genType, "log2", genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpSqrt, genType, "sqrt", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpSqrt, genType, "sqrt", genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpInverseSqrt, genType, "inversesqrt", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpInverseSqrt, genType, "inversesqrt", genType);
-    //
+	//
-    // Common Functions.
+	// Common Functions.
-    //
+	//
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpAbs, genType, "abs", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpAbs, genType, "abs", genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpAbs, genIType, "abs", genIType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpAbs, genIType, "abs", genIType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpSign, genType, "sign", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpSign, genType, "sign", genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpSign, genIType, "sign", genIType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpSign, genIType, "sign", genIType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpFloor, genType, "floor", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpFloor, genType, "floor", genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTrunc, genType, "trunc", genType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTrunc, genType, "trunc", genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpRound, genType, "round", genType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpRound, genType, "round", genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpRoundEven, genType, "roundEven", genType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpRoundEven, genType, "roundEven", genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpCeil, genType, "ceil", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpCeil, genType, "ceil", genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpFract, genType, "fract", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpFract, genType, "fract", genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMod, genType, "mod", genType, float1);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMod, genType, "mod", genType, float1);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMod, genType, "mod", genType, genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMod, genType, "mod", genType, genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMin, genType, "min", genType, float1);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMin, genType, "min", genType, float1);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMin, genType, "min", genType, genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMin, genType, "min", genType, genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMin, genIType, "min", genIType, genIType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMin, genIType, "min", genIType, genIType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMin, genIType, "min", genIType, int1);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMin, genIType, "min", genIType, int1);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMin, genUType, "min", genUType, genUType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMin, genUType, "min", genUType, genUType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMin, genUType, "min", genUType, uint1);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMin, genUType, "min", genUType, uint1);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMax, genType, "max", genType, float1);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMax, genType, "max", genType, float1);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMax, genType, "max", genType, genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMax, genType, "max", genType, genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMax, genIType, "max", genIType, genIType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMax, genIType, "max", genIType, genIType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMax, genIType, "max", genIType, int1);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMax, genIType, "max", genIType, int1);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMax, genUType, "max", genUType, genUType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMax, genUType, "max", genUType, genUType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMax, genUType, "max", genUType, uint1);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMax, genUType, "max", genUType, uint1);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpClamp, genType, "clamp", genType, float1, float1);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpClamp, genType, "clamp", genType, float1, float1);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpClamp, genType, "clamp", genType, genType, genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpClamp, genType, "clamp", genType, genType, genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpClamp, genIType, "clamp", genIType, int1, int1);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpClamp, genIType, "clamp", genIType, int1, int1);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpClamp, genIType, "clamp", genIType, genIType, genIType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpClamp, genIType, "clamp", genIType, genIType, genIType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpClamp, genUType, "clamp", genUType, uint1, uint1);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpClamp, genUType, "clamp", genUType, uint1, uint1);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpClamp, genUType, "clamp", genUType, genUType, genUType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpClamp, genUType, "clamp", genUType, genUType, genUType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMix, genType, "mix", genType, genType, float1);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMix, genType, "mix", genType, genType, float1);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMix, genType, "mix", genType, genType, genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMix, genType, "mix", genType, genType, genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpStep, genType, "step", genType, genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpStep, genType, "step", genType, genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpStep, genType, "step", float1, genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpStep, genType, "step", float1, genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpSmoothStep, genType, "smoothstep", genType, genType, genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpSmoothStep, genType, "smoothstep", genType, genType, genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpSmoothStep, genType, "smoothstep", float1, float1, genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpSmoothStep, genType, "smoothstep", float1, float1, genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpIsNan, genBType, "isnan", genType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpIsNan, genBType, "isnan", genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpIsInf, genBType, "isinf", genType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpIsInf, genBType, "isinf", genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpFloatBitsToInt, genIType, "floatBitsToInt", genType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpFloatBitsToInt, genIType, "floatBitsToInt", genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpFloatBitsToUint, genUType, "floatBitsToUint", genType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpFloatBitsToUint, genUType, "floatBitsToUint", genType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpIntBitsToFloat, genType, "intBitsToFloat", genIType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpIntBitsToFloat, genType, "intBitsToFloat", genIType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpUintBitsToFloat, genType, "uintBitsToFloat", genUType);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpUintBitsToFloat, genType, "uintBitsToFloat", genUType);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpPackSnorm2x16, uint1, "packSnorm2x16", float2);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpPackSnorm2x16, uint1, "packSnorm2x16", float2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpPackUnorm2x16, uint1, "packUnorm2x16", float2);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpPackUnorm2x16, uint1, "packUnorm2x16", float2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpPackHalf2x16, uint1, "packHalf2x16", float2);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpPackHalf2x16, uint1, "packHalf2x16", float2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpUnpackSnorm2x16, float2, "unpackSnorm2x16", uint1);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpUnpackSnorm2x16, float2, "unpackSnorm2x16", uint1);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpUnpackUnorm2x16, float2, "unpackUnorm2x16", uint1);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpUnpackUnorm2x16, float2, "unpackUnorm2x16", uint1);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpUnpackHalf2x16, float2, "unpackHalf2x16", uint1);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpUnpackHalf2x16, float2, "unpackHalf2x16", uint1);
-    //
+	//
-    // Geometric Functions.
+	// Geometric Functions.
-    //
+	//
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpLength, float1, "length", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpLength, float1, "length", genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpDistance, float1, "distance", genType, genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpDistance, float1, "distance", genType, genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpDot, float1, "dot", genType, genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpDot, float1, "dot", genType, genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpCross, float3, "cross", float3, float3);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpCross, float3, "cross", float3, float3);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpNormalize, genType, "normalize", genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpNormalize, genType, "normalize", genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpFaceForward, genType, "faceforward", genType, genType, genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpFaceForward, genType, "faceforward", genType, genType, genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpReflect, genType, "reflect", genType, genType);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpReflect, genType, "reflect", genType, genType);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpRefract, genType, "refract", genType, genType, float1);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpRefract, genType, "refract", genType, genType, float1);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpFtransform, float4, "ftransform", 0);
-	TType *mat2 = new TType(EbtFloat, 2, 2);
-	TType *mat2x3 = new TType(EbtFloat, 2, 3);
+	TType *mat2 = new TType(EbtFloat, 2, 2);
-	TType *mat2x4 = new TType(EbtFloat, 2, 4);
+	TType *mat2x3 = new TType(EbtFloat, 2, 3);
-	TType *mat3x2 = new TType(EbtFloat, 3, 2);
+	TType *mat2x4 = new TType(EbtFloat, 2, 4);
-	TType *mat3 = new TType(EbtFloat, 3, 3);
+	TType *mat3x2 = new TType(EbtFloat, 3, 2);
-	TType *mat3x4 = new TType(EbtFloat, 3, 4);
+	TType *mat3 = new TType(EbtFloat, 3, 3);
-	TType *mat4x2 = new TType(EbtFloat, 4, 2);
+	TType *mat3x4 = new TType(EbtFloat, 3, 4);
-	TType *mat4x3 = new TType(EbtFloat, 4, 3);
+	TType *mat4x2 = new TType(EbtFloat, 4, 2);
-	TType *mat4 = new TType(EbtFloat, 4, 4);
+	TType *mat4x3 = new TType(EbtFloat, 4, 3);
+	TType *mat4 = new TType(EbtFloat, 4, 4);
-    //
-    // Matrix Functions.
+	//
-    //
+	// Matrix Functions.
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMul, mat2, "matrixCompMult", mat2, mat2);
+	//
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMul, mat3, "matrixCompMult", mat3, mat3);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMul, mat2, "matrixCompMult", mat2, mat2);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMul, mat4, "matrixCompMult", mat4, mat4);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMul, mat3, "matrixCompMult", mat3, mat3);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMul, mat2x3, "matrixCompMult", mat2x3, mat2x3);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpMul, mat4, "matrixCompMult", mat4, mat4);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMul, mat3x2, "matrixCompMult", mat3x2, mat3x2);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMul, mat2x3, "matrixCompMult", mat2x3, mat2x3);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMul, mat2x4, "matrixCompMult", mat2x4, mat2x4);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMul, mat3x2, "matrixCompMult", mat3x2, mat3x2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMul, mat4x2, "matrixCompMult", mat4x2, mat4x2);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMul, mat2x4, "matrixCompMult", mat2x4, mat2x4);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMul, mat3x4, "matrixCompMult", mat3x4, mat3x4);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMul, mat4x2, "matrixCompMult", mat4x2, mat4x2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMul, mat4x3, "matrixCompMult", mat4x3, mat4x3);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMul, mat3x4, "matrixCompMult", mat3x4, mat3x4);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpMul, mat4x3, "matrixCompMult", mat4x3, mat4x3);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat2, "outerProduct", float2, float2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat3, "outerProduct", float3, float3);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat2, "outerProduct", float2, float2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat4, "outerProduct", float4, float4);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat3, "outerProduct", float3, float3);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat2x3, "outerProduct", float3, float2);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat4, "outerProduct", float4, float4);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat3x2, "outerProduct", float2, float3);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat2x3, "outerProduct", float3, float2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat2x4, "outerProduct", float4, float2);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat3x2, "outerProduct", float2, float3);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat4x2, "outerProduct", float2, float4);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat2x4, "outerProduct", float4, float2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat3x4, "outerProduct", float4, float3);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat4x2, "outerProduct", float2, float4);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat4x3, "outerProduct", float3, float4);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat3x4, "outerProduct", float4, float3);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpOuterProduct, mat4x3, "outerProduct", float3, float4);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat2, "transpose", mat2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat3, "transpose", mat3);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat2, "transpose", mat2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat4, "transpose", mat4);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat3, "transpose", mat3);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat2x3, "transpose", mat3x2);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat4, "transpose", mat4);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat3x2, "transpose", mat2x3);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat2x3, "transpose", mat3x2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat2x4, "transpose", mat4x2);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat3x2, "transpose", mat2x3);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat4x2, "transpose", mat2x4);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat2x4, "transpose", mat4x2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat3x4, "transpose", mat4x3);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat4x2, "transpose", mat2x4);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat4x3, "transpose", mat3x4);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat3x4, "transpose", mat4x3);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpTranspose, mat4x3, "transpose", mat3x4);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpDeterminant, float1, "determinant", mat2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpDeterminant, float1, "determinant", mat3);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpDeterminant, float1, "determinant", mat2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpDeterminant, float1, "determinant", mat4);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpDeterminant, float1, "determinant", mat3);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpDeterminant, float1, "determinant", mat4);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpInverse, mat2, "inverse", mat2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpInverse, mat3, "inverse", mat3);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpInverse, mat2, "inverse", mat2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpInverse, mat4, "inverse", mat4);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpInverse, mat3, "inverse", mat3);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpInverse, mat4, "inverse", mat4);
-	TType *bool1 = new TType(EbtBool);
-	TType *vec = new TType(EbtVec);
+	TType *bool1 = new TType(EbtBool);
-	TType *ivec = new TType(EbtIVec);
+	TType *vec = new TType(EbtVec);
+	TType *ivec = new TType(EbtIVec);
 	TType *uvec = new TType(EbtUVec);
 	TType *bvec = new TType(EbtBVec);
-    //
+	//
-    // Vector relational functions.
+	// Vector relational functions.
-    //
+	//
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpLessThan, bvec, "lessThan", vec, vec);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpLessThan, bvec, "lessThan", vec, vec);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpLessThan, bvec, "lessThan", ivec, ivec);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpLessThan, bvec, "lessThan", ivec, ivec);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpLessThan, bvec, "lessThan", uvec, uvec);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpLessThan, bvec, "lessThan", uvec, uvec);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpLessThanEqual, bvec, "lessThanEqual", vec, vec);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpLessThanEqual, bvec, "lessThanEqual", vec, vec);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpLessThanEqual, bvec, "lessThanEqual", ivec, ivec);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpLessThanEqual, bvec, "lessThanEqual", ivec, ivec);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpLessThanEqual, bvec, "lessThanEqual", uvec, uvec);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpLessThanEqual, bvec, "lessThanEqual", uvec, uvec);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpGreaterThan, bvec, "greaterThan", vec, vec);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpGreaterThan, bvec, "greaterThan", vec, vec);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpGreaterThan, bvec, "greaterThan", ivec, ivec);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpGreaterThan, bvec, "greaterThan", ivec, ivec);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpGreaterThan, bvec, "greaterThan", uvec, uvec);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpGreaterThan, bvec, "greaterThan", uvec, uvec);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpGreaterThanEqual, bvec, "greaterThanEqual", vec, vec);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpGreaterThanEqual, bvec, "greaterThanEqual", vec, vec);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpGreaterThanEqual, bvec, "greaterThanEqual", ivec, ivec);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpGreaterThanEqual, bvec, "greaterThanEqual", ivec, ivec);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpGreaterThanEqual, bvec, "greaterThanEqual", uvec, uvec);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpGreaterThanEqual, bvec, "greaterThanEqual", uvec, uvec);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpVectorEqual, bvec, "equal", vec, vec);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpVectorEqual, bvec, "equal", vec, vec);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpVectorEqual, bvec, "equal", ivec, ivec);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpVectorEqual, bvec, "equal", ivec, ivec);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpVectorEqual, bvec, "equal", uvec, uvec);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpVectorEqual, bvec, "equal", uvec, uvec);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpVectorEqual, bvec, "equal", bvec, bvec);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpVectorEqual, bvec, "equal", bvec, bvec);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpVectorNotEqual, bvec, "notEqual", vec, vec);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpVectorNotEqual, bvec, "notEqual", vec, vec);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpVectorNotEqual, bvec, "notEqual", ivec, ivec);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpVectorNotEqual, bvec, "notEqual", ivec, ivec);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpVectorNotEqual, bvec, "notEqual", uvec, uvec);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpVectorNotEqual, bvec, "notEqual", uvec, uvec);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpVectorNotEqual, bvec, "notEqual", bvec, bvec);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpVectorNotEqual, bvec, "notEqual", bvec, bvec);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpAny, bool1, "any", bvec);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpAny, bool1, "any", bvec);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpAll, bool1, "all", bvec);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpAll, bool1, "all", bvec);
-    symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpVectorLogicalNot, bvec, "not", bvec);
+	symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpVectorLogicalNot, bvec, "not", bvec);
 	TType *sampler2D = new TType(EbtSampler2D);
 	TType *samplerCube = new TType(EbtSamplerCube);
 	TType *sampler3D = new TType(EbtSampler3D);
-    //
+	//
-    // Texture Functions for GLSL ES 1.0
+	// Texture Functions for GLSL ES 1.0
-    //
+	//
-    symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2D", sampler2D, float2);
+	symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2D", sampler2D, float2);
-    symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DProj", sampler2D, float3);
+	symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DProj", sampler2D, float3);
-    symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DProj", sampler2D, float4);
+	symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DProj", sampler2D, float4);
-    symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "textureCube", samplerCube, float3);
+	symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "textureCube", samplerCube, float3);
 	symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture3D", sampler3D, float3);
 	if(resources.OES_EGL_image_external)
-    {
+	{
-        TType *samplerExternalOES = new TType(EbtSamplerExternalOES);
+		TType *samplerExternalOES = new TType(EbtSamplerExternalOES);
-        symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2D", samplerExternalOES, float2);
+		symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2D", samplerExternalOES, float2);
-        symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DProj", samplerExternalOES, float3);
+		symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DProj", samplerExternalOES, float3);
-        symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DProj", samplerExternalOES, float4);
+		symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DProj", samplerExternalOES, float4);
 		symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture3D", samplerExternalOES, float3);
-    }
+	}
 	if(type == GL_FRAGMENT_SHADER)
 	{
-        symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2D", sampler2D, float2, float1);
+		symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2D", sampler2D, float2, float1);
-        symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DProj", sampler2D, float3, float1);
+		symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DProj", sampler2D, float3, float1);
-        symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DProj", sampler2D, float4, float1);
+		symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DProj", sampler2D, float4, float1);
-        symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "textureCube", samplerCube, float3, float1);
+		symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "textureCube", samplerCube, float3, float1);
 		if(resources.OES_standard_derivatives)
 		{
 			symbolTable.insertBuiltIn(ESSL1_BUILTINS, EOpDFdx, "GL_OES_standard_derivatives", genType, "dFdx", genType);
 			symbolTable.insertBuiltIn(ESSL1_BUILTINS, EOpDFdy, "GL_OES_standard_derivatives", genType, "dFdy", genType);
-			symbolTable.insertBuiltIn(ESSL1_BUILTINS, EOpFwidth,"GL_OES_standard_derivatives", genType, "fwidth", genType);
+			symbolTable.insertBuiltIn(ESSL1_BUILTINS, EOpFwidth, "GL_OES_standard_derivatives", genType, "fwidth", genType);
 		}
 	}
 	if(type == GL_VERTEX_SHADER)
 	{
 		symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DLod", sampler2D, float2, float1);
 		symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DProjLod", sampler2D, float3, float1);
 		symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DProjLod", sampler2D, float4, float1);
 		symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "textureCubeLod", samplerCube, float3, float1);
 		symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture3DLod", sampler3D, float3, float1);
 	}
-    TType *gvec4 = new TType(EbtGVec4);
+	TType *gvec4 = new TType(EbtGVec4);
-    TType *gsampler2D = new TType(EbtGSampler2D);
+	TType *gsampler2D = new TType(EbtGSampler2D);
-    TType *gsamplerCube = new TType(EbtGSamplerCube);
+	TType *gsamplerCube = new TType(EbtGSamplerCube);
-    TType *gsampler3D = new TType(EbtGSampler3D);
+	TType *gsampler3D = new TType(EbtGSampler3D);
-    TType *gsampler2DArray = new TType(EbtGSampler2DArray);
+	TType *gsampler2DArray = new TType(EbtGSampler2DArray);
-    //
+	//
-    // Texture Functions for GLSL ES 3.0
+	// Texture Functions for GLSL ES 3.0
-    //
+	//
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "texture", gsampler2D, float2);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "texture", gsampler2D, float2);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "texture", gsampler3D, float3);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "texture", gsampler3D, float3);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "texture", gsamplerCube, float3);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "texture", gsamplerCube, float3);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "texture", gsampler2DArray, float3);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "texture", gsampler2DArray, float3);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureProj", gsampler2D, float3);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureProj", gsampler2D, float3);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureProj", gsampler2D, float4);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureProj", gsampler2D, float4);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureProj", gsampler3D, float4);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureProj", gsampler3D, float4);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureLod", gsampler2D, float2, float1);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureLod", gsampler2D, float2, float1);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureLod", gsampler3D, float3, float1);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureLod", gsampler3D, float3, float1);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureLod", gsamplerCube, float3, float1);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureLod", gsamplerCube, float3, float1);
-    symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureLod", gsampler2DArray, float3, float1);
+	symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureLod", gsampler2DArray, float3, float1);
-    if(type == GL_FRAGMENT_SHADER)
+	if(type == GL_FRAGMENT_SHADER)
-    {
+	{
-        symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "texture", gsampler2D, float2, float1);
+		symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "texture", gsampler2D, float2, float1);
-        symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "texture", gsampler3D, float3, float1);
+		symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "texture", gsampler3D, float3, float1);
-        symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "texture", gsamplerCube, float3, float1);
+		symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "texture", gsamplerCube, float3, float1);
-        symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "texture", gsampler2DArray, float3, float1);
+		symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "texture", gsampler2DArray, float3, float1);
-        symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureProj", gsampler2D, float3, float1);
+		symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureProj", gsampler2D, float3, float1);
-        symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureProj", gsampler2D, float4, float1);
+		symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureProj", gsampler2D, float4, float1);
-        symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureProj", gsampler3D, float4, float1);
+		symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureProj", gsampler3D, float4, float1);
-    }
+	}
-    //
+	//
-    // Depth range in window coordinates
+	// Depth range in window coordinates
-    //
+	//
 	TTypeList *members = NewPoolTTypeList();
-	TTypeLine near = {new TType(EbtFloat, EbpHigh, EvqGlobal, 1), 0};
+	TTypeLine near = { new TType(EbtFloat, EbpHigh, EvqGlobal, 1), 0 };
-	TTypeLine far = {new TType(EbtFloat, EbpHigh, EvqGlobal, 1), 0};
+	TTypeLine far = { new TType(EbtFloat, EbpHigh, EvqGlobal, 1), 0 };
-	TTypeLine diff = {new TType(EbtFloat, EbpHigh, EvqGlobal, 1), 0};
+	TTypeLine diff = { new TType(EbtFloat, EbpHigh, EvqGlobal, 1), 0 };
 	near.type->setFieldName("near");
 	far.type->setFieldName("far");
 	diff.type->setFieldName("diff");
 	members->push_back(near);
 	members->push_back(far);
 	members->push_back(diff);
 	TVariable *depthRangeParameters = new TVariable(NewPoolTString("gl_DepthRangeParameters"), TType(members, "gl_DepthRangeParameters"), true);
 	symbolTable.insert(COMMON_BUILTINS, *depthRangeParameters);
 	TVariable *depthRange = new TVariable(NewPoolTString("gl_DepthRange"), TType(members, "gl_DepthRangeParameters"));
 	depthRange->setQualifier(EvqUniform);
 	symbolTable.insert(COMMON_BUILTINS, *depthRange);
-    //
+	//
-    // Implementation dependent built-in constants.
+	// Implementation dependent built-in constants.
-    //
+	//
-    symbolTable.insertConstInt(COMMON_BUILTINS, "gl_MaxVertexAttribs", resources.MaxVertexAttribs);
+	symbolTable.insertConstInt(COMMON_BUILTINS, "gl_MaxVertexAttribs", resources.MaxVertexAttribs);
-    symbolTable.insertConstInt(COMMON_BUILTINS, "gl_MaxVertexUniformVectors", resources.MaxVertexUniformVectors);
+	symbolTable.insertConstInt(COMMON_BUILTINS, "gl_MaxVertexUniformVectors", resources.MaxVertexUniformVectors);
-    symbolTable.insertConstInt(COMMON_BUILTINS, "gl_MaxVertexTextureImageUnits", resources.MaxVertexTextureImageUnits);
+	symbolTable.insertConstInt(COMMON_BUILTINS, "gl_MaxVertexTextureImageUnits", resources.MaxVertexTextureImageUnits);
-    symbolTable.insertConstInt(COMMON_BUILTINS, "gl_MaxCombinedTextureImageUnits", resources.MaxCombinedTextureImageUnits);
+	symbolTable.insertConstInt(COMMON_BUILTINS, "gl_MaxCombinedTextureImageUnits", resources.MaxCombinedTextureImageUnits);
-    symbolTable.insertConstInt(COMMON_BUILTINS, "gl_MaxTextureImageUnits", resources.MaxTextureImageUnits);
+	symbolTable.insertConstInt(COMMON_BUILTINS, "gl_MaxTextureImageUnits", resources.MaxTextureImageUnits);
-    symbolTable.insertConstInt(COMMON_BUILTINS, "gl_MaxFragmentUniformVectors", resources.MaxFragmentUniformVectors);
+	symbolTable.insertConstInt(COMMON_BUILTINS, "gl_MaxFragmentUniformVectors", resources.MaxFragmentUniformVectors);
-    symbolTable.insertConstInt(ESSL1_BUILTINS, "gl_MaxVaryingVectors", resources.MaxVaryingVectors);
+	symbolTable.insertConstInt(ESSL1_BUILTINS, "gl_MaxTextureCoords", resources.MaxTextureCoords);
-    symbolTable.insertConstInt(ESSL1_BUILTINS, "gl_MaxDrawBuffers", resources.MaxDrawBuffers);
+	symbolTable.insertConstInt(ESSL1_BUILTINS, "gl_MaxVaryingVectors", resources.MaxVaryingVectors);
-    symbolTable.insertConstInt(ESSL3_BUILTINS, "gl_MaxVertexOutputVectors", resources.MaxVertexOutputVectors);
+	symbolTable.insertConstInt(ESSL1_BUILTINS, "gl_MaxDrawBuffers", resources.MaxDrawBuffers);
-    symbolTable.insertConstInt(ESSL3_BUILTINS, "gl_MaxFragmentInputVectors", resources.MaxFragmentInputVectors);
+	symbolTable.insertConstInt(ESSL3_BUILTINS, "gl_MaxVertexOutputVectors", resources.MaxVertexOutputVectors);
-    symbolTable.insertConstInt(ESSL3_BUILTINS, "gl_MinProgramTexelOffset", resources.MinProgramTexelOffset);
+	symbolTable.insertConstInt(ESSL3_BUILTINS, "gl_MaxFragmentInputVectors", resources.MaxFragmentInputVectors);
-    symbolTable.insertConstInt(ESSL3_BUILTINS, "gl_MaxProgramTexelOffset", resources.MaxProgramTexelOffset);
+	symbolTable.insertConstInt(ESSL3_BUILTINS, "gl_MinProgramTexelOffset", resources.MinProgramTexelOffset);
-}
+	symbolTable.insertConstInt(ESSL3_BUILTINS, "gl_MaxProgramTexelOffset", resources.MaxProgramTexelOffset);
+}
-void IdentifyBuiltIns(GLenum shaderType,
-                      const ShBuiltInResources &resources,
+void IdentifyBuiltIns(GLenum shaderType,
-                      TSymbolTable &symbolTable)
+	const ShBuiltInResources &resources,
-{
+	TSymbolTable &symbolTable)
-    //
+{
-    // First, insert some special built-in variables that are not in 
+	//
-    // the built-in header files.
+	// First, insert some special built-in variables that are not in 
-    //
+	// the built-in header files.
-    switch(shaderType)
+	//
-	{
+	switch(shaderType)
-    case GL_FRAGMENT_SHADER:
+	{
-        symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_FragCoord"), TType(EbtFloat, EbpMedium, EvqFragCoord,   4)));
+	case GL_FRAGMENT_SHADER:
-        symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_FrontFacing"), TType(EbtBool,  EbpUndefined, EvqFrontFacing, 1)));
+		symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_FragCoord"), TType(EbtFloat, EbpMedium, EvqFragCoord, 4)));
-        symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_PointCoord"), TType(EbtFloat, EbpMedium, EvqPointCoord,  2)));
+		symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_FrontFacing"), TType(EbtBool, EbpUndefined, EvqFrontFacing, 1)));
-        symbolTable.insert(ESSL1_BUILTINS, *new TVariable(NewPoolTString("gl_FragColor"), TType(EbtFloat, EbpMedium, EvqFragColor,   4)));
+		symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_PointCoord"), TType(EbtFloat, EbpMedium, EvqPointCoord, 2)));
-        symbolTable.insert(ESSL1_BUILTINS, *new TVariable(NewPoolTString("gl_FragData[gl_MaxDrawBuffers]"), TType(EbtFloat, EbpMedium, EvqFragData,    4)));
+		symbolTable.insert(ESSL1_BUILTINS, *new TVariable(NewPoolTString("gl_FragColor"), TType(EbtFloat, EbpMedium, EvqFragColor, 4)));
-        break;
+		symbolTable.insert(ESSL1_BUILTINS, *new TVariable(NewPoolTString("gl_FragData[gl_MaxDrawBuffers]"), TType(EbtFloat, EbpMedium, EvqFragData, 4)));
-    case GL_VERTEX_SHADER:
+		break;
-        symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_Position"), TType(EbtFloat, EbpHigh, EvqPosition,    4)));
+	case GL_VERTEX_SHADER:
-        symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_PointSize"), TType(EbtFloat, EbpMedium, EvqPointSize,   1)));
+		symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_MultiTexCoord0"), TType(EbtFloat, EbpMedium, EvqMultiTexCoord0, 4)));
-        symbolTable.insert(ESSL3_BUILTINS, *new TVariable(NewPoolTString("gl_InstanceID"), TType(EbtInt, EbpHigh, EvqInstanceID, 1)));
+		symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_MultiTexCoord1"), TType(EbtFloat, EbpMedium, EvqMultiTexCoord1, 4)));
-        break;
+		symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_MultiTexCoord2"), TType(EbtFloat, EbpMedium, EvqMultiTexCoord2, 4)));
-    default: assert(false && "Language not supported");
+		symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_MultiTexCoord3"), TType(EbtFloat, EbpMedium, EvqMultiTexCoord3, 4)));
-    }
+		symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_MultiTexCoord4"), TType(EbtFloat, EbpMedium, EvqMultiTexCoord4, 4)));
+		symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_MultiTexCoord5"), TType(EbtFloat, EbpMedium, EvqMultiTexCoord5, 4)));
-    // Finally add resource-specific variables.
+		symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_MultiTexCoord6"), TType(EbtFloat, EbpMedium, EvqMultiTexCoord6, 4)));
-    switch(shaderType)
+		symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_MultiTexCoord7"), TType(EbtFloat, EbpMedium, EvqMultiTexCoord7, 4)));
-    {
+		symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_Position"), TType(EbtFloat, EbpMedium, EvqPosition, 4)));
-    case GL_FRAGMENT_SHADER:
+		symbolTable.insert(COMMON_BUILTINS, *new TVariable(NewPoolTString("gl_PointSize"), TType(EbtFloat, EbpMedium, EvqPointSize, 1)));
-		{
+		symbolTable.insert(ESSL3_BUILTINS, *new TVariable(NewPoolTString("gl_InstanceID"), TType(EbtInt, EbpHigh, EvqInstanceID, 1)));
-            // Set up gl_FragData.  The array size.
+		break;
-            TType fragData(EbtFloat, EbpMedium, EvqFragData, 4, 1, true);
+	default: assert(false && "Language not supported");
-            fragData.setArraySize(resources.MaxDrawBuffers);
+	}
-            symbolTable.insert(ESSL1_BUILTINS, *new TVariable(NewPoolTString("gl_FragData"), fragData));
-		}
+	// Set up gl_TexCoord
-		break;
+	TType texCoord(EbtFloat, EbpMedium, EvqTexCoords, 4, 1, true);
-    default: break;
+	texCoord.setArraySize(resources.MaxTextureCoords);
-    }
+	symbolTable.insert(ESSL1_BUILTINS, *new TVariable(NewPoolTString("gl_TexCoord"), texCoord));
-}
+	// Finally add resource-specific variables.
-void InitExtensionBehavior(const ShBuiltInResources& resources,
+	switch(shaderType)
-                           TExtensionBehavior& extBehavior)
+	{
-{
+	case GL_FRAGMENT_SHADER:
-    if(resources.OES_standard_derivatives)
+	{
-        extBehavior["GL_OES_standard_derivatives"] = EBhUndefined;
+		// Set up gl_FragData.  The array size.
-	if(resources.OES_fragment_precision_high)
+		TType fragData(EbtFloat, EbpMedium, EvqFragData, 4, 1, true);
-        extBehavior["GL_FRAGMENT_PRECISION_HIGH"] = EBhUndefined;
+		fragData.setArraySize(resources.MaxDrawBuffers);
-    if(resources.OES_EGL_image_external)
+		symbolTable.insert(ESSL1_BUILTINS, *new TVariable(NewPoolTString("gl_FragData"), fragData));
-        extBehavior["GL_OES_EGL_image_external"] = EBhUndefined;
+	}
-}
+	break;
+	case GL_VERTEX_SHADER:	break;
+	default: break;
+	}
+}
+void InitExtensionBehavior(const ShBuiltInResources& resources,
+	TExtensionBehavior& extBehavior)
+{
+	if(resources.OES_standard_derivatives)
+		extBehavior["GL_OES_standard_derivatives"] = EBhUndefined;
+	if(resources.OES_fragment_precision_high)
+		extBehavior["GL_FRAGMENT_PRECISION_HIGH"] = EBhUndefined;
+	if(resources.OES_EGL_image_external)
+		extBehavior["GL_OES_EGL_image_external"] = EBhUndefined;
+}
--- a/src/OpenGL/compiler/OutputASM.cpp
+++ b/src/OpenGL/compiler/OutputASM.cpp
@@ -652,6 +652,12 @@ namespace glsl
 		case EOpFwidth:           if(visit == PostVisit) emit(sw::Shader::OPCODE_FWIDTH, result, arg); break;
 		case EOpAny:              if(visit == PostVisit) emit(sw::Shader::OPCODE_ANY, result, arg); break;
 		case EOpAll:              if(visit == PostVisit) emit(sw::Shader::OPCODE_ALL, result, arg); break;
+		case EOpFtransform:		  
+			if(visit == PostVisit)
+			{
+				emit(sw::Shader::OPCODE_NOP, result, arg);
+			}
+			break;
 		case EOpTranspose:
 			if(visit == PostVisit)
 			{
@@ -1078,6 +1084,7 @@ namespace glsl
 		case EOpFaceForward: if(visit == PostVisit) emit(sw::Shader::OPCODE_FORWARD(dim(arg[0])), result, arg[0], arg[1], arg[2]); break;
 		case EOpReflect:     if(visit == PostVisit) emit(sw::Shader::OPCODE_REFLECT(dim(arg[0])), result, arg[0], arg[1]); break;
 		case EOpRefract:     if(visit == PostVisit) emit(sw::Shader::OPCODE_REFRACT(dim(arg[0])), result, arg[0], arg[1], arg[2]); break;
+		case EOpFtransform:	 break;
 		case EOpMul:
 			if(visit == PostVisit)
 			{
@@ -1870,6 +1877,15 @@ namespace glsl
 		case EvqFragCoord:           return sw::Shader::PARAMETER_MISCTYPE;
 		case EvqFrontFacing:         return sw::Shader::PARAMETER_MISCTYPE;
 		case EvqPointCoord:          return sw::Shader::PARAMETER_INPUT;
+		case EvqMultiTexCoord0:          return sw::Shader::PARAMETER_INPUT;
+		case EvqMultiTexCoord1:          return sw::Shader::PARAMETER_INPUT;
+		case EvqMultiTexCoord2:          return sw::Shader::PARAMETER_INPUT;
+		case EvqMultiTexCoord3:          return sw::Shader::PARAMETER_INPUT;
+		case EvqMultiTexCoord4:          return sw::Shader::PARAMETER_INPUT;
+		case EvqMultiTexCoord5:          return sw::Shader::PARAMETER_INPUT;
+		case EvqMultiTexCoord6:          return sw::Shader::PARAMETER_INPUT;
+		case EvqMultiTexCoord7:          return sw::Shader::PARAMETER_INPUT;
+		case EvqTexCoords:				return sw::Shader::PARAMETER_TEXTURE;
 		case EvqFragColor:           return sw::Shader::PARAMETER_COLOROUT;
 		case EvqFragData:            return sw::Shader::PARAMETER_COLOROUT;
 		default: UNREACHABLE();
@@ -1903,6 +1919,15 @@ namespace glsl
 		case EvqPosition:            return varyingRegister(operand);
 		case EvqPointSize:           return varyingRegister(operand);
 		case EvqInstanceID:          vertexShader->instanceIdDeclared = true; return 0;
+		case EvqMultiTexCoord0:		return 0; //UNIMPLEMENTED();
+		case EvqMultiTexCoord1:		return 0; //UNIMPLEMENTED();
+		case EvqMultiTexCoord2:		return 0; //UNIMPLEMENTED();
+		case EvqMultiTexCoord3:		return 0; //UNIMPLEMENTED();
+		case EvqMultiTexCoord4:		return 0; //UNIMPLEMENTED();
+		case EvqMultiTexCoord5:		return 0; //UNIMPLEMENTED();
+		case EvqMultiTexCoord6:		return 0; //UNIMPLEMENTED();
+		case EvqMultiTexCoord7:		return 0; //UNIMPLEMENTED();
+		case EvqTexCoords:			 return 0;
 		case EvqFragCoord:           pixelShader->vPosDeclared = true;  return 0;
 		case EvqFrontFacing:         pixelShader->vFaceDeclared = true; return 1;
 		case EvqPointCoord:          return varyingRegister(operand);

--- a/src/OpenGL/compiler/ParseHelper.cpp
+++ b/src/OpenGL/compiler/ParseHelper.cpp
@@ -319,7 +319,15 @@ bool TParseContext::lValueErrorCheck(int line, const char* op, TIntermTyped* nod
    case EvqFlatIn:
    case EvqCentroidIn:
    case EvqVaryingIn:      message = "can't modify a varying";      break;
-    case EvqInput:          message = "can't modify an input";       break;
+	case EvqInput:          message = "can't modify an input";       break;
+	case EvqMultiTexCoord0:      message = "can't modify gl_MultiTexCoord0";   break;
+	case EvqMultiTexCoord1:      message = "can't modify gl_MultiTexCoord1";   break;
+	case EvqMultiTexCoord2:      message = "can't modify gl_MultiTexCoord2";   break;
+	case EvqMultiTexCoord3:      message = "can't modify gl_MultiTexCoord3";   break;
+	case EvqMultiTexCoord4:      message = "can't modify gl_MultiTexCoord4";   break;
+	case EvqMultiTexCoord5:      message = "can't modify gl_MultiTexCoord5";   break;
+	case EvqMultiTexCoord6:      message = "can't modify gl_MultiTexCoord6";   break;
+	case EvqMultiTexCoord7:      message = "can't modify gl_MultiTexCoord7";   break;
    case EvqFragCoord:      message = "can't modify gl_FragCoord";   break;
    case EvqFrontFacing:    message = "can't modify gl_FrontFacing"; break;
    case EvqPointCoord:     message = "can't modify gl_PointCoord";  break;

--- a/src/OpenGL/compiler/SymbolTable.h
+++ b/src/OpenGL/compiler/SymbolTable.h
@@ -346,28 +346,28 @@ public:
 	void insertBuiltIn(ESymbolLevel level, TOperator op, const char *ext, TType *rvalue, const char *name, TType *ptype1, TType *ptype2 = 0, TType *ptype3 = 0, TType *ptype4 = 0)
 	{
-		if(ptype1->getBasicType() == EbtGSampler2D)
+		if(ptype1 && ptype1->getBasicType() == EbtGSampler2D)
 		{
 			bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
 			insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler2D), ptype2, ptype3, ptype4);
 			insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISampler2D), ptype2, ptype3, ptype4);
 			insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSampler2D), ptype2, ptype3, ptype4);
 		}
-		else if(ptype1->getBasicType() == EbtGSampler3D)
+		else if(ptype1 && ptype1->getBasicType() == EbtGSampler3D)
 		{
 			bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
 			insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler3D), ptype2, ptype3, ptype4);
 			insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISampler3D), ptype2, ptype3, ptype4);
 			insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSampler3D), ptype2, ptype3, ptype4);
 		}
-		else if(ptype1->getBasicType() == EbtGSamplerCube)
+		else if(ptype1 && ptype1->getBasicType() == EbtGSamplerCube)
 		{
 			bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
 			insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSamplerCube), ptype2, ptype3, ptype4);
 			insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISamplerCube), ptype2, ptype3, ptype4);
 			insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSamplerCube), ptype2, ptype3, ptype4);
 		}
-		else if(ptype1->getBasicType() == EbtGSampler2DArray)
+		else if(ptype1 && ptype1->getBasicType() == EbtGSampler2DArray)
 		{
 			bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
 			insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler2DArray), ptype2, ptype3, ptype4);
@@ -393,8 +393,11 @@ public:
 		{
 			TFunction *function = new TFunction(NewPoolTString(name), *rvalue, op, ext);
-			TParameter param1 = {0, ptype1};
+			if(ptype1)
-			function->addParameter(param1);
+			{
+				TParameter param1 = { 0, ptype1 };
+				function->addParameter(param1);
+			}
 			if(ptype2)
 			{

--- a/src/OpenGL/compiler/intermOut.cpp
+++ b/src/OpenGL/compiler/intermOut.cpp
@@ -298,6 +298,7 @@ bool TOutputTraverser::visitAggregate(Visit visit, TIntermAggregate* node)
        case EOpFaceForward:   out << "face-forward";            break;
        case EOpReflect:       out << "reflect";                 break;
        case EOpRefract:       out << "refract";                 break;
+		case EOpFtransform:		out << "ftransform";			break;
        case EOpMul:           out << "component-wise multiply"; break;
        case EOpOuterProduct:  out << "outer product";           break;

--- a/src/OpenGL/compiler/intermediate.h
+++ b/src/OpenGL/compiler/intermediate.h
@@ -155,6 +155,7 @@ enum TOperator {
    EOpFaceForward,
    EOpReflect,
    EOpRefract,
+	EOpFtransform,
    EOpDFdx,            // Fragment only, OES_standard_derivatives extension
    EOpDFdy,            // Fragment only, OES_standard_derivatives extension

--- a/src/OpenGL/libGL/Context.cpp
+++ b/src/OpenGL/libGL/Context.cpp
@@ -136,7 +136,8 @@ Context::Context(const Context *shareContext)
    mTexture2DZero = new Texture2D(0);
    mProxyTexture2DZero = new Texture2D(0);
-    mTextureCubeMapZero = new TextureCubeMap(0);
+	mTextureCubeMapZero = new TextureCubeMap(0);
+	mTexture1DZero = new Texture1D(0);
    mState.activeSampler = 0;
    bindArrayBuffer(0);
@@ -150,7 +151,16 @@ Context::Context(const Context *shareContext)
    mState.currentProgram = 0;
    mState.packAlignment = 4;
-    mState.unpackAlignment = 4;
+	mState.unpackAlignment = 4;
+	mState.unpackSwapBytes = false;
+	mState.unpackLsbFirst = false;
+	mState.unpackRowLength = 0;
+	mState.unpackSkipRows = 0;
+	mState.unpackSkipPixels = 0;
+	mState.unpackSkipImages = 0;
+	mState.unpackImageHeight = 0;
+	mState.textureEnvMode = GL_MODULATE;
    mVertexDataManager = NULL;
    mIndexDataManager = NULL;
@@ -178,6 +188,11 @@ Context::Context(const Context *shareContext)
    drawing = false;
    drawMode = 0;   // FIXME
+	sharedList = false;
+	sharedContextHandle = NULL;
+	clientAttribStack = new std::stack<ClientAttributes>();
    mState.vertexAttribute[sw::Color0].mCurrentValue[0] = 1.0f;
    mState.vertexAttribute[sw::Color0].mCurrentValue[1] = 1.0f;
    mState.vertexAttribute[sw::Color0].mCurrentValue[2] = 1.0f;
@@ -252,11 +267,14 @@ Context::~Context()
    mTexture2DZero = NULL;
 	mProxyTexture2DZero = NULL;
-    mTextureCubeMapZero = NULL;
+	mTextureCubeMapZero = NULL;
+	mTexture1DZero = NULL;
    delete mVertexDataManager;
    delete mIndexDataManager;
+	delete clientAttribStack;
    mResourceManager->release();
 	delete device;
 }
@@ -774,6 +792,76 @@ GLint Context::getUnpackAlignment() const
    return mState.unpackAlignment;
 }
+void Context::setUnpackSwapBytes(bool swapBytes)
+{
+	mState.unpackSwapBytes = swapBytes;
+}
+bool Context::getUnpackSwapBytes() const
+{
+	return mState.unpackSwapBytes;
+}
+void Context::setUnpackLsbFirst(bool lsbFirst)
+{
+	mState.unpackLsbFirst = lsbFirst;
+}
+bool Context::getUnpackLsbFirst() const
+{
+	return mState.unpackLsbFirst;
+}
+void Context::setUnpackRowLength(GLint length)
+{
+	mState.unpackRowLength = length;
+}
+GLint Context::getUnpackRowLength() const
+{
+	return mState.unpackRowLength;
+}
+void Context::setUnpackSkipRows(GLint skipRows)
+{
+	mState.unpackSkipRows = skipRows;
+}
+GLint Context::getUnpackSkipRows() const
+{
+	return mState.unpackSkipRows;
+}
+void Context::setUnpackSkipPixels(GLint skipPixels)
+{
+	mState.unpackSkipPixels = skipPixels;
+}
+GLint Context::getUnpackSkipPixels() const
+{
+	return mState.unpackSkipPixels;
+}
+void Context::setUnpackSkipImages(GLint skipImages)
+{
+	mState.unpackSkipImages = skipImages;
+}
+GLint Context::getUnpackSkipImages() const
+{
+	return mState.unpackSkipImages;
+}
+void Context::setUnpackImageHeight(GLint imageHeight)
+{
+	mState.unpackImageHeight = imageHeight;
+}
+GLint Context::getUnpackImageHeight() const
+{
+	return mState.unpackImageHeight;
+}
 GLuint Context::createBuffer()
 {
    return mResourceManager->createBuffer();
@@ -978,6 +1066,13 @@ void Context::bindElementArrayBuffer(unsigned int buffer)
    mState.elementArrayBuffer = getBuffer(buffer);
 }
+void Context::bindTexture1D(GLuint texture)
+{
+	mResourceManager->checkTextureAllocation(texture, TEXTURE_1D);
+	mState.samplerTexture[TEXTURE_1D][mState.activeSampler] = getTexture(texture);
+}
 void Context::bindTexture2D(GLuint texture)
 {
    mResourceManager->checkTextureAllocation(texture, TEXTURE_2D);
@@ -1203,9 +1298,14 @@ Program *Context::getCurrentProgram()
    return mResourceManager->getProgram(mState.currentProgram);
 }
+Texture1D *Context::getTexture1D()
+{
+	return static_cast<Texture1D*>(getSamplerTexture(mState.activeSampler, TEXTURE_1D));
+}
 Texture2D *Context::getTexture2D(GLenum target)
 {
-    if(target == GL_TEXTURE_2D)
+	if(target == GL_TEXTURE_2D || /*target == GL_TEXTURE_1D ||*/ target == GL_TEXTURE_RECTANGLE)
    {
        return static_cast<Texture2D*>(getSamplerTexture(mState.activeSampler, TEXTURE_2D));
    }
@@ -1234,6 +1334,7 @@ Texture *Context::getSamplerTexture(unsigned int sampler, TextureType type)
        case TEXTURE_2D:       return mTexture2DZero;
        case PROXY_TEXTURE_2D: return mProxyTexture2DZero;
        case TEXTURE_CUBE:     return mTextureCubeMapZero;
+		case TEXTURE_1D:	   return mTexture1DZero;
        default: UNREACHABLE();
        }
    }
@@ -1337,7 +1438,13 @@ bool Context::getIntegerv(GLenum pname, GLint *params)
    // case, this should make no difference to the calling application. You may find it in 
    // Context::getFloatv.
    switch (pname)
-    {
+	{
+	case GL_TEXTURE_RECTANGLE:				  *params = getRectangleTextureEnable(); break;
+	case GL_MAX_GEOMETRY_OUTPUT_VERTICES:	  *params = 1024; break;
+	case GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX: *params = 1048576; break;
+	case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:	  *params = 16384; break;
+	case GL_MAX_TEXTURE_STACK_DEPTH:		  *params = MAX_TEXTURE_STACK_DEPTH;    break;
+	case GL_MAX_TEXTURE_UNITS:				  *params = MAX_TEXTURE_IMAGE_UNITS;		  break;
    case GL_MAX_VERTEX_ATTRIBS:               *params = MAX_VERTEX_ATTRIBS;               break;
    case GL_MAX_VERTEX_UNIFORM_VECTORS:       *params = MAX_VERTEX_UNIFORM_VECTORS;       break;
    case GL_MAX_VERTEX_UNIFORM_COMPONENTS:    *params = MAX_VERTEX_UNIFORM_VECTORS * 4;   break;   // FIXME: Verify
@@ -1506,6 +1613,7 @@ bool Context::getIntegerv(GLenum pname, GLint *params)
            }
        }
        break;
+	case GL_TEXTURE_BINDING_1D:
    case GL_TEXTURE_BINDING_2D:
        {
            if(mState.activeSampler < 0 || mState.activeSampler > MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1)
@@ -2060,6 +2168,8 @@ void Context::applyTextures()
 void Context::applyTextures(sw::SamplerType samplerType)
 {
+	GLenum texEnvMode = getTextureEnvMode();
    Program *programObject = getCurrentProgram();
    int samplerCount = (samplerType == sw::SAMPLER_PIXEL) ? MAX_TEXTURE_IMAGE_UNITS : MAX_VERTEX_TEXTURE_IMAGE_UNITS;   // Range of samplers of given sampler type
@@ -2097,6 +2207,10 @@ void Context::applyTextures(sw::SamplerType samplerType)
 				applyTexture(samplerType, samplerIndex, texture);
+				GLenum texFormat = texture->getFormat(GL_TEXTURE_2D, 0);
+				sw::TextureStage::StageOperation rgbOperation, alphaOperation;
+				es2sw::ConvertTextureOperations(texEnvMode, texFormat, &rgbOperation, &alphaOperation);
                device->setStageOperation(samplerIndex, sw::TextureStage::STAGE_MODULATE);
                device->setFirstArgument(samplerIndex, sw::TextureStage::SOURCE_TEXTURE);
                device->setSecondArgument(samplerIndex, sw::TextureStage::SOURCE_CURRENT);
@@ -2423,6 +2537,27 @@ void Context::readPixels(GLint x, GLint y, GLsizei width, GLsizei height,
 	renderTarget->release();
 }
+void Context::setTextureEnvMode(GLenum texEnvMode)
+{
+	switch(texEnvMode)
+	{
+	case GL_MODULATE:
+	case GL_DECAL:
+	case GL_BLEND:
+	case GL_ADD:
+	case GL_REPLACE:
+		mState.textureEnvMode = texEnvMode;
+		break;
+	default:
+		UNREACHABLE();
+	}
+}
+GLenum Context::getTextureEnvMode()
+{
+	return mState.textureEnvMode;
+}
 void Context::clear(GLbitfield mask)
 {
    Framebuffer *framebuffer = getDrawFramebuffer();
@@ -3205,6 +3340,56 @@ void Context::ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top
 	currentMatrixStack().ortho(left, right, bottom, top, zNear, zFar);
 }
+void Context::pushClientAttrib(GLbitfield mask)
+{
+	if(clientAttribStack->size() >= MAX_CLIENT_ATTRIB_STACK_DEPTH)
+	{
+		return error(GL_STACK_OVERFLOW);
+	}
+	ClientAttributes attributes;
+	attributes.mask = mask;
+	attributes.unpackSwapBytes = mState.unpackSwapBytes;
+	attributes.unpackLsbFirst = mState.unpackLsbFirst;
+	attributes.unpackImageHeight = mState.unpackImageHeight;
+	attributes.unpackRowLength = mState.unpackRowLength;
+	attributes.unpackSkipRows = mState.unpackSkipRows;
+	attributes.unpackSkipPixels = mState.unpackSkipPixels;
+	attributes.unpackAlignment = mState.unpackAlignment;
+	attributes.packAlignment = mState.packAlignment;
+	attributes.unpackSkipImages = mState.unpackSkipImages;
+	//TODO: other pack options
+	clientAttribStack->push(attributes);
+}
+void Context::popClientAttrib()
+{
+	if(clientAttribStack->empty())
+	{
+		return;
+	}
+	if(clientAttribStack->top().mask & GL_CLIENT_PIXEL_STORE_BIT)
+	{
+		setUnpackSwapBytes(clientAttribStack->top().unpackSwapBytes);
+		setUnpackLsbFirst(clientAttribStack->top().unpackLsbFirst);
+		setUnpackImageHeight(clientAttribStack->top().unpackImageHeight);
+		setUnpackRowLength(clientAttribStack->top().unpackRowLength);
+		setUnpackSkipRows(clientAttribStack->top().unpackSkipRows);
+		setUnpackSkipPixels(clientAttribStack->top().unpackSkipPixels);
+		setUnpackAlignment(clientAttribStack->top().unpackAlignment);
+		setPackAlignment(clientAttribStack->top().packAlignment);
+		setUnpackSkipImages(clientAttribStack->top().unpackSkipImages);
+		//TODO: other pack options
+	}
+	if(clientAttribStack->top().mask & GL_CLIENT_VERTEX_ARRAY_BIT)
+	{
+		UNIMPLEMENTED();
+	}
+	clientAttribStack->pop();
+}
 void Context::setLighting(bool enable)
 {
    if(drawing)
@@ -3285,7 +3470,7 @@ void Context::setShadeModel(GLenum mode)
 void Context::setLight(int index, bool enable)
 {
-    device->setLightEnable(index, enable);
+	device->setLightEnable(index, enable);
 }
 void Context::setNormalizeNormals(bool enable)
@@ -3293,6 +3478,26 @@ void Context::setNormalizeNormals(bool enable)
 	device->setNormalizeNormals(enable);
 }
+void Context::setRectangleTextureEnable(bool enable)
+{
+	device->setRectangleTextureEnable(enable);
+}
+bool Context::getRectangleTextureEnable()
+{
+	return device->getRectangleTextureEnable();
+}
+void Context::set1DTextureEnable(bool enable)
+{
+	device->set1DTextureEnable(enable);
+}
+bool Context::get1DTextureEnable()
+{
+	return device->get1DTextureEnable();
+}
 GLuint Context::genLists(GLsizei range)
 {
 	if(drawing)
@@ -3343,6 +3548,12 @@ void Context::newList(GLuint list, GLenum mode)
 	listIndex = list;
 	listMode = mode;
+	if(sharedList)
+	{
+		gl::Context* ctx = (gl::Context*)sharedContextHandle;
+		ctx->newList(list, mode);
+	}
 }
 void Context::endList()
@@ -3355,6 +3566,12 @@ void Context::endList()
    ASSERT(list);
 	delete displayList[listIndex];
    displayList[listIndex] = list;
+	if(sharedList)
+	{
+		gl::Context* ctx = (gl::Context*)sharedContextHandle;
+		ctx->endList();
+	}
    list = 0;
 	listIndex = 0;
@@ -3378,17 +3595,34 @@ void Context::deleteList(GLuint list)
 	firstFreeIndex = std::min(firstFreeIndex , list);
 }
+void Context::shareDisplayListSpace(HGLRC hglrc)
+{
+	sharedList = true;
+	sharedContextHandle = hglrc;
+}
 void Context::listCommand(Command *command)
 {
    ASSERT(list);
 	list->list.push_back(command);
 	if(listMode == GL_COMPILE_AND_EXECUTE)
 	{
 		listMode = 0;
 		command->call();
 		listMode = GL_COMPILE_AND_EXECUTE;
 	}
+	if(sharedList)
+	{
+		gl::Context* ctx = (gl::Context*)sharedContextHandle;
+		if(ctx == NULL)
+		{
+			return error(GL_INVALID_OPERATION);
+		}
+		ctx->listCommand(command);
+	}
 }
 void APIENTRY glVertexAttribArray(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr)

--- a/src/OpenGL/libGL/Context.h
+++ b/src/OpenGL/libGL/Context.h
@@ -31,6 +31,7 @@
 #include <map>
 #include <string>
 #include <list>
+#include <stack>
 namespace gl
 {
@@ -293,6 +294,7 @@ class Shader;
 class Program;
 class Texture;
 class Texture2D;
+class Texture1D;
 class TextureCubeMap;
 class Framebuffer;
 class Renderbuffer;
@@ -309,12 +311,15 @@ class Query;
 enum
 {
-    MAX_VERTEX_ATTRIBS = 9,
+	MAX_TEXTURE_COORDS = 8,
+	MAX_CLIENT_ATTRIB_STACK_DEPTH = 16,
+	MAX_TEXTURE_STACK_DEPTH = 10,
+    MAX_VERTEX_ATTRIBS = 16,
 	MAX_UNIFORM_VECTORS = 256,   // Device limit
    MAX_VERTEX_UNIFORM_VECTORS = 256 - 3,   // Reserve space for gl_DepthRange
    MAX_VARYING_VECTORS = 10,
-    MAX_TEXTURE_IMAGE_UNITS = 2,
+    MAX_TEXTURE_IMAGE_UNITS = 16,
-    MAX_VERTEX_TEXTURE_IMAGE_UNITS = 1,
+    MAX_VERTEX_TEXTURE_IMAGE_UNITS = 4,
    MAX_COMBINED_TEXTURE_IMAGE_UNITS = MAX_TEXTURE_IMAGE_UNITS + MAX_VERTEX_TEXTURE_IMAGE_UNITS,
    MAX_FRAGMENT_UNIFORM_VECTORS = 224 - 3,    // Reserve space for gl_DepthRange
    MAX_DRAW_BUFFERS = 1,
@@ -488,8 +493,31 @@ struct State
    BindingPointer<Texture> samplerTexture[TEXTURE_TYPE_COUNT][MAX_COMBINED_TEXTURE_IMAGE_UNITS];
 	BindingPointer<Query> activeQuery[QUERY_TYPE_COUNT];
-    GLint unpackAlignment;
+	GLint unpackAlignment;
-    GLint packAlignment;
+	GLint packAlignment;
+	bool unpackSwapBytes;
+	bool unpackLsbFirst;
+	GLint unpackRowLength;
+	GLint unpackSkipRows;
+	GLint unpackSkipPixels;
+	GLint unpackSkipImages;
+	GLint unpackImageHeight;
+	GLenum textureEnvMode;
+};
+struct ClientAttributes
+{
+	GLint unpackAlignment;
+	GLint packAlignment;
+	bool unpackSwapBytes;
+	bool unpackLsbFirst;
+	GLint unpackRowLength;
+	GLint unpackSkipRows;
+	GLint unpackSkipPixels;
+	GLint unpackSkipImages;
+	GLint unpackImageHeight;
+	GLbitfield mask;
 };
 class Context
@@ -583,6 +611,20 @@ public:
    void setPackAlignment(GLint alignment);
    GLint getPackAlignment() const;
+	void setUnpackSwapBytes(bool swapBytes);
+	bool getUnpackSwapBytes() const;
+	void setUnpackLsbFirst(bool length);
+	bool getUnpackLsbFirst() const;
+	void setUnpackRowLength(GLint length);
+	GLint getUnpackRowLength() const;
+	void setUnpackSkipRows(GLint skipRows);
+	GLint getUnpackSkipRows() const;
+	void setUnpackSkipPixels(GLint skipRows);
+	GLint getUnpackSkipPixels() const;
+	void setUnpackSkipImages(GLint skipImage);
+	GLint getUnpackSkipImages() const;
+	void setUnpackImageHeight(GLint imageHeight);
+	GLint getUnpackImageHeight() const;
    // These create  and destroy methods are merely pass-throughs to 
    // ResourceManager, which owns these object types
@@ -611,7 +653,8 @@ public:
    void deleteQuery(GLuint query);
    void bindArrayBuffer(GLuint buffer);
-    void bindElementArrayBuffer(GLuint buffer);
+	void bindElementArrayBuffer(GLuint buffer);
+	void bindTexture1D(GLuint texture);
    void bindTexture2D(GLuint texture);
    void bindTextureCubeMap(GLuint texture);
    void bindReadFramebuffer(GLuint framebuffer);
@@ -639,10 +682,11 @@ public:
    Buffer *getArrayBuffer();
    Buffer *getElementArrayBuffer();
-    Program *getCurrentProgram();
+	Program *getCurrentProgram();
    Texture2D *getTexture2D(GLenum target);
-    TextureCubeMap *getTextureCubeMap();
+	TextureCubeMap *getTextureCubeMap();
-    Texture *getSamplerTexture(unsigned int sampler, TextureType type);
+	Texture *getSamplerTexture(unsigned int sampler, TextureType type);
+	Texture1D *getTexture1D();
    Framebuffer *getReadFramebuffer();
    Framebuffer *getDrawFramebuffer();
@@ -659,6 +703,9 @@ public:
    void finish();
    void flush();
+	void setTextureEnvMode(GLenum texEnvMode);
+	GLenum getTextureEnvMode();
    void recordInvalidEnum();
    void recordInvalidValue();
    void recordInvalidOperation();
@@ -685,6 +732,9 @@ public:
 	void frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
    void ortho(double left, double right, double bottom, double top, double zNear, double zFar);   // FIXME: GLdouble
+	void pushClientAttrib(GLbitfield mask);
+	void popClientAttrib();
    void setLighting(bool enabled);
    void setFog(bool enabled);
 	void setAlphaTest(bool enabled);
@@ -693,6 +743,10 @@ public:
 	void setShadeModel(GLenum mode);
    void setLight(int index, bool enable);
 	void setNormalizeNormals(bool enable);
+	void setRectangleTextureEnable(bool enable);
+	bool getRectangleTextureEnable();
+	void set1DTextureEnable(bool enable);
+	bool get1DTextureEnable();
 	GLuint genLists(GLsizei range);
 	void newList(GLuint list, GLenum mode);
@@ -702,6 +756,7 @@ public:
 	GLuint getListIndex() {return listIndex;}
 	GLenum getListMode() {return listMode;}
 	void listCommand(Command *command);
+	void shareDisplayListSpace(HGLRC hglrc);
 	void captureAttribs();
    void captureDrawArrays(GLenum mode, GLint first, GLsizei count);
@@ -742,6 +797,7 @@ private:
    BindingPointer<Texture2D> mTexture2DZero;
    BindingPointer<Texture2D> mProxyTexture2DZero;
    BindingPointer<TextureCubeMap> mTextureCubeMapZero;
+	BindingPointer<Texture1D> mTexture1DZero;
    typedef std::map<GLint, Framebuffer*> FramebufferMap;
    FramebufferMap mFramebufferMap;
@@ -789,12 +845,16 @@ private:
 	sw::MatrixStack projection;
 	sw::MatrixStack texture[8];
+	std::stack<ClientAttributes> *clientAttribStack;
 	GLenum listMode;
 	//std::map<GLuint, GLuint> listMap;
 	std::map<GLuint, DisplayList*> displayList;
    DisplayList *list;
 	GLuint listIndex;
 	GLuint firstFreeIndex;
+	bool sharedList;
+	HGLRC sharedContextHandle;
 	GLenum clientTexture;

--- a/src/OpenGL/libGL/Device.cpp
+++ b/src/OpenGL/libGL/Device.cpp
@@ -157,6 +157,9 @@ namespace gl
        setSpecularMaterialSource(sw::MATERIAL_MATERIAL);
        setAmbientMaterialSource(sw::MATERIAL_COLOR1);
        setEmissiveMaterialSource(sw::MATERIAL_MATERIAL);
+		rectangleTextureEnable = false;
+		oneDTextureEnable = false;
 	}
 	Device::~Device()
@@ -441,6 +444,26 @@ namespace gl
 		scissorEnable = enable;
 	}
+	void Device::setRectangleTextureEnable(bool enable)
+	{
+		rectangleTextureEnable = enable;
+	}
+	bool Device::getRectangleTextureEnable()
+	{
+		return rectangleTextureEnable;
+	}
+	void Device::set1DTextureEnable(bool enable)
+	{
+		oneDTextureEnable = enable;
+	}
+	bool Device::get1DTextureEnable()
+	{
+		return oneDTextureEnable;
+	}
 	void Device::setRenderTarget(Image *renderTarget)
 	{
 		if(renderTarget)

--- a/src/OpenGL/libGL/Device.hpp
+++ b/src/OpenGL/libGL/Device.hpp
@@ -59,6 +59,10 @@ namespace gl
 		virtual void setPixelShader(sw::PixelShader *shader);
 		virtual void setPixelShaderConstantF(unsigned int startRegister, const float *constantData, unsigned int count);
 		virtual void setScissorEnable(bool enable);
+		virtual void setRectangleTextureEnable(bool enable);
+		virtual bool getRectangleTextureEnable();
+		virtual void set1DTextureEnable(bool enable);
+		virtual bool get1DTextureEnable();
 		virtual void setRenderTarget(Image *renderTarget);
 		virtual void setScissorRect(const sw::Rect &rect);
 		virtual void setVertexShader(sw::VertexShader *shader);

--- a/src/OpenGL/libGL/ResourceManager.cpp
+++ b/src/OpenGL/libGL/ResourceManager.cpp
@@ -322,8 +322,12 @@ void ResourceManager::checkTextureAllocation(GLuint texture, TextureType type)
    if(!getTexture(texture) && texture != 0)
    {
        Texture *textureObject;
-        if(type == TEXTURE_2D)
+		if(type == TEXTURE_1D)
+		{
+			textureObject = new Texture1D(texture);
+		}
+        else if(type == TEXTURE_2D)
        {
            textureObject = new Texture2D(texture);
        }
@@ -331,7 +335,7 @@ void ResourceManager::checkTextureAllocation(GLuint texture, TextureType type)
        {
            textureObject = new TextureCubeMap(texture);
        }
-        else
+		else
        {
            UNREACHABLE();
            return;

--- a/src/OpenGL/libGL/ResourceManager.h
+++ b/src/OpenGL/libGL/ResourceManager.h
@@ -36,7 +36,8 @@ enum TextureType
 {
    TEXTURE_2D,
    PROXY_TEXTURE_2D,
-    TEXTURE_CUBE,
+	TEXTURE_CUBE,
+	TEXTURE_1D,
    TEXTURE_TYPE_COUNT,
    TEXTURE_UNKNOWN

--- a/src/OpenGL/libGL/Shader.cpp
+++ b/src/OpenGL/libGL/Shader.cpp
@@ -167,6 +167,7 @@ TranslatorASM *Shader::createCompiler(GLenum shaderType)
 	resources.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
 	resources.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
 	resources.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
+	resources.MaxTextureCoords = MAX_TEXTURE_COORDS;
 	resources.MaxFragmentUniformVectors = MAX_FRAGMENT_UNIFORM_VECTORS;
 	resources.MaxDrawBuffers = MAX_DRAW_BUFFERS;
 	resources.OES_standard_derivatives = 1;

--- a/src/OpenGL/libGL/Texture.cpp
+++ b/src/OpenGL/libGL/Texture.cpp
@@ -168,11 +168,11 @@ GLfloat Texture::getMaxAnisotropy() const
    return mMaxAnisotropy;
 }
-void Texture::setImage(GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, Image *image)
+void Texture::setImage(GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, Image *image, int xOffset)
 {
    if(pixels && image)
    {
-		image->loadImageData(0, 0, 0, image->getWidth(), image->getHeight(), 1, format, type, unpackAlignment, pixels);
+		image->loadImageData(xOffset/*0*/, 0, 0, image->getWidth(), image->getHeight(), 1, format, type, unpackAlignment, pixels);
    }
 }
@@ -184,7 +184,7 @@ void Texture::setCompressedImage(GLsizei imageSize, const void *pixels, Image *i
    }
 }
-void Texture::subImage(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, Image *image)
+void Texture::subImage(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, Image *image, bool is2DTexture)
 {
 	if(!image)
 	{
@@ -201,7 +201,7 @@ void Texture::subImage(GLint xoffset, GLint yoffset, GLsizei width, GLsizei heig
        return error(GL_INVALID_OPERATION);
    }
-    if(format != image->getFormat())
+    if(format != image->getFormat() && is2DTexture)
    {
        return error(GL_INVALID_OPERATION);
    }
@@ -367,7 +367,7 @@ int Texture2D::getLevelCount() const
 	return levels;
 }
-void Texture2D::setImage(GLint level, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels)
+void Texture2D::setImage(GLint level, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, int xOffset)
 {
 	if(image[level])
 	{
@@ -381,7 +381,7 @@ void Texture2D::setImage(GLint level, GLsizei width, GLsizei height, GLenum form
 		return error(GL_OUT_OF_MEMORY);
 	}
-    Texture::setImage(format, type, unpackAlignment, pixels, image[level]);
+    Texture::setImage(format, type, unpackAlignment, pixels, image[level], xOffset);
 }
 void Texture2D::setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels)
@@ -1038,4 +1038,57 @@ Image *TextureCubeMap::getRenderTarget(GLenum target, unsigned int level)
 	return image[face][level];
 }
+Texture1D::Texture1D(GLuint name) : Texture2D(name)
+{
+}
+Texture1D::~Texture1D()
+{
+}
+GLenum Texture1D::getTarget() const
+{
+	return GL_TEXTURE_1D;
+}
+GLenum Texture1D::getFormat(GLenum target, GLint level) const
+{
+	ASSERT(target == GL_TEXTURE_1D);
+	return image[level] ? image[level]->getFormat() : 0;
+}
+GLenum Texture1D::getType(GLenum target, GLint level) const
+{
+	ASSERT(target == GL_TEXTURE_1D);
+	return image[level] ? image[level]->getType() : 0;
+}
+GLsizei Texture1D::getWidth(GLenum target, GLint level) const
+{
+	ASSERT(target == GL_TEXTURE_1D || target == GL_PROXY_TEXTURE_1D);
+	return image[level] ? image[level]->getWidth() : 0;
+}
+GLsizei Texture1D::getHeight(GLenum target, GLint level) const
+{
+	ASSERT(target == GL_TEXTURE_1D || target == GL_PROXY_TEXTURE_1D);
+	return image[level] ? image[level]->getHeight() : 0;
+}
+sw::Format Texture1D::getInternalFormat(GLenum target, GLint level) const
+{
+	ASSERT(target == GL_TEXTURE_1D || target == GL_PROXY_TEXTURE_1D);
+	return image[level] ? image[level]->getInternalFormat() : sw::FORMAT_NULL;
+}
+void Texture1D::subImage(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels)
+{
+	Texture::subImage(xoffset, yoffset, width, height, format, type, unpackAlignment, pixels, image[level], false);
+}
+bool Texture1D::isCompressed(GLenum target, GLint level) const
+{
+	return IsCompressed(getFormat(target, level));
+}
 }
--- a/src/OpenGL/libGL/Texture.h
+++ b/src/OpenGL/libGL/Texture.h
@@ -88,8 +88,8 @@ public:
    virtual void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source) = 0;
 protected:
-    void setImage(GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, Image *image);
+	void setImage(GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, Image *image, int xOffset = 0);
-    void subImage(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, Image *image);
+	void subImage(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, Image *image, bool is2DTexture = true);
    void setCompressedImage(GLsizei imageSize, const void *pixels, Image *image);
    void subImageCompressed(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels, Image *image);
@@ -126,7 +126,7 @@ public:
    virtual sw::Format getInternalFormat(GLenum target, GLint level) const;
 	virtual int getLevelCount() const;
-    void setImage(GLint level, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels);
+	void setImage(GLint level, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, int xOffset = 0);
    void setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels);
    void subImage(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels);
    void subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels);
@@ -216,6 +216,21 @@ private:
 	unsigned int mFaceProxyRefs[6];
 };
+class Texture1D : public Texture2D
+{
+public:
+	explicit Texture1D(GLuint name);
+	virtual ~Texture1D();
+	virtual GLenum getTarget() const;
+	virtual GLenum getFormat(GLenum target, GLint level) const;
+	virtual GLenum getType(GLenum target, GLint level) const;
+	virtual GLsizei getWidth(GLenum target, GLint level) const;
+	virtual GLsizei getHeight(GLenum target, GLint level) const;
+	virtual sw::Format getInternalFormat(GLenum target, GLint level) const;
+	virtual void subImage(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels);
+	virtual bool isCompressed(GLenum target, GLint level) const;
+};
 }
 #endif   // LIBGL_TEXTURE_H_
--- a/src/OpenGL/libGL/libGL.cpp
+++ b/src/OpenGL/libGL/libGL.cpp
--- a/src/OpenGL/libGL/libGL.def
+++ b/src/OpenGL/libGL/libGL.def
@@ -368,5 +368,6 @@ EXPORTS
 	wglUseFontBitmapsW	@366
 	wglUseFontOutlinesA	@367
 	wglUseFontOutlinesW	@368
+	wglCreateContextAttribsARB @369
 	Register
\ No newline at end of file
--- a/src/OpenGL/libGL/utilities.cpp
+++ b/src/OpenGL/libGL/utilities.cpp
@@ -309,7 +309,7 @@ namespace gl
 	bool IsTextureTarget(GLenum target)
 	{
-		return target == GL_TEXTURE_2D || IsCubemapTextureTarget(target);
+		return target == GL_TEXTURE_1D || target == GL_TEXTURE_RECTANGLE || target == GL_TEXTURE_2D || IsCubemapTextureTarget(target);
 	}
 	// Verify that format/type are one of the combinations from table 3.4.
@@ -617,6 +617,59 @@ namespace es2sw
 		}
 	}
+	void ConvertTextureOperations(GLenum texEnvMode, GLenum texFormat, sw::TextureStage::StageOperation *rgbOperation, sw::TextureStage::StageOperation *alphaOperation)
+	{
+		switch(texEnvMode)
+		{
+		case GL_MODULATE:
+			switch(texFormat)
+			{
+			case GL_LUMINANCE_ALPHA:
+				*rgbOperation = sw::TextureStage::STAGE_MODULATE;
+				*alphaOperation = sw::TextureStage::STAGE_MODULATE;
+				break;
+			case GL_RGB:
+				*rgbOperation = sw::TextureStage::STAGE_MODULATE;
+				*alphaOperation = sw::TextureStage::STAGE_SELECTARG2;
+				break;
+			case GL_RGBA:
+				*rgbOperation = sw::TextureStage::STAGE_MODULATE;
+				*alphaOperation = sw::TextureStage::STAGE_MODULATE;
+				break;
+			case GL_ALPHA:
+			case GL_LUMINANCE:
+				UNIMPLEMENTED();
+				// Default operations for compatibility
+				*rgbOperation = sw::TextureStage::STAGE_MODULATE;
+				*alphaOperation = sw::TextureStage::STAGE_MODULATE;
+				break;
+			default: UNREACHABLE();
+			}
+			break;
+		case GL_REPLACE:
+			*rgbOperation = sw::TextureStage::STAGE_SELECTARG1;
+			*alphaOperation = sw::TextureStage::STAGE_SELECTARG1;
+			break;
+		case GL_ADD:
+			*rgbOperation = sw::TextureStage::STAGE_ADD;
+			*alphaOperation = sw::TextureStage::STAGE_SELECTARG1;
+			break;
+		case GL_DECAL:
+		case GL_BLEND:
+			// Default operations for compatibility
+			*rgbOperation = sw::TextureStage::STAGE_MODULATE;
+			*alphaOperation = sw::TextureStage::STAGE_MODULATE;
+			UNIMPLEMENTED();
+			break;
+		default:
+			UNREACHABLE();
+		}
+	}
 	bool ConvertPrimitiveType(GLenum primitiveType, GLsizei elementCount,  gl::PrimitiveType &swPrimitiveType, int &primitiveCount)
 	{
 		switch(primitiveType)

--- a/src/OpenGL/libGL/utilities.h
+++ b/src/OpenGL/libGL/utilities.h
@@ -69,6 +69,7 @@ namespace es2sw
 	void ConvertMinFilter(GLenum texFilter, sw::FilterType *minFilter, sw::MipmapType *mipFilter, float maxAnisotropy);
 	bool ConvertPrimitiveType(GLenum primitiveType, GLsizei elementCount,  gl::PrimitiveType &swPrimitiveType, int &primitiveCount);
 	sw::Format ConvertRenderbufferFormat(GLenum format);
+	void ConvertTextureOperations(GLenum texEnvMode, GLenum texFormat, sw::TextureStage::StageOperation *rgbOperation, sw::TextureStage::StageOperation *alphaOperation);
 }
 namespace sw2es

--- a/src/Renderer/Context.hpp
+++ b/src/Renderer/Context.hpp
@@ -284,6 +284,8 @@ namespace sw
 		// Set fixed-function pixel pipeline states, return true when modified
 		bool setDepthBufferEnable(bool depthBufferEnable);
+		void setRectangleTextureEnable(bool rectangleTextureEnable);
 		bool setAlphaBlendEnable(bool alphaBlendEnable);
 		bool setSourceBlendFactor(BlendFactor sourceBlendFactor);
 		bool setDestBlendFactor(BlendFactor destBlendFactor);

--- a/src/Renderer/VertexProcessor.cpp
+++ b/src/Renderer/VertexProcessor.cpp
@@ -213,6 +213,16 @@ namespace sw
 		updateLighting = true;
 	}
+	void VertexProcessor::setRectangleTextureEnable(bool enable)
+	{
+		rectangleTextureEnable = enable;
+	}
+	bool VertexProcessor::getRectangleTextureEnable()
+	{
+		return rectangleTextureEnable;
+	}
 	void VertexProcessor::setSpecularEnable(bool specularEnable)
 	{
 		context->setSpecularEnable(specularEnable);

--- a/src/Renderer/VertexProcessor.hpp
+++ b/src/Renderer/VertexProcessor.hpp
@@ -196,6 +196,9 @@ namespace sw
 		virtual void setLightEnable(unsigned int light, bool lightEnable);
 		virtual void setSpecularEnable(bool specularEnable);
+		void setRectangleTextureEnable(bool enable);
+		bool getRectangleTextureEnable();
 		virtual void setGlobalAmbient(const Color<float> &globalAmbient);
 		virtual void setLightPosition(unsigned int light, const Point &lightPosition);
 		virtual void setLightViewPosition(unsigned int light, const Point &lightPosition);
@@ -296,6 +299,8 @@ namespace sw
 		bool updateBaseMatrix;
 		bool updateProjectionMatrix;
 		bool updateLighting;
+		bool rectangleTextureEnable;
+		bool oneDTextureEnable;
 	};
 }