Update SwiftShader to April code dump.
April code dump from Transgaming. Adds new shader compiler.
diff --git a/src/OpenGL ES 2.0/common/angleutils.h b/src/OpenGL ES 2.0/common/angleutils.h
index 24c766b..1d55111 100644
--- a/src/OpenGL ES 2.0/common/angleutils.h
+++ b/src/OpenGL ES 2.0/common/angleutils.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// angleutils.h: Common ANGLE utilities.
diff --git a/src/OpenGL ES 2.0/common/debug.cpp b/src/OpenGL ES 2.0/common/debug.cpp
index 44f9667..fbc122d 100644
--- a/src/OpenGL ES 2.0/common/debug.cpp
+++ b/src/OpenGL ES 2.0/common/debug.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// debug.cpp: Debugging utilities.
diff --git a/src/OpenGL ES 2.0/common/debug.h b/src/OpenGL ES 2.0/common/debug.h
index 31d8371..bfab636 100644
--- a/src/OpenGL ES 2.0/common/debug.h
+++ b/src/OpenGL ES 2.0/common/debug.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// debug.h: Debugging utilities.
@@ -67,6 +72,7 @@
#endif
// A macro for code which is not expected to be reached under valid assumptions
+
#if !defined(NDEBUG)
#define UNREACHABLE() do { \
ERR("\t! Unreachable reached: %s(%d)\n", __FUNCTION__, __LINE__); \
diff --git a/src/OpenGL ES 2.0/compiler/BaseTypes.h b/src/OpenGL ES 2.0/compiler/BaseTypes.h
index 9f4a860..3334436 100644
--- a/src/OpenGL ES 2.0/compiler/BaseTypes.h
+++ b/src/OpenGL ES 2.0/compiler/BaseTypes.h
@@ -45,6 +45,7 @@
EbtGuardSamplerEnd, // non type: see implementation of IsSampler()
EbtStruct,
EbtAddress, // should be deprecated??
+ EbtInvariant, // used as a type when qualifying a previously declared variable as being invariant
};
inline const char* getBasicString(TBasicType t)
diff --git a/src/OpenGL ES 2.0/compiler/Compiler.cpp b/src/OpenGL ES 2.0/compiler/Compiler.cpp
index 28bebef..bae2db2 100644
--- a/src/OpenGL ES 2.0/compiler/Compiler.cpp
+++ b/src/OpenGL ES 2.0/compiler/Compiler.cpp
@@ -9,7 +9,6 @@
#include "compiler/ParseHelper.h"
#include "compiler/ShHandle.h"
#include "compiler/ValidateLimitations.h"
-#include "compiler/MapLongVariableNames.h"
namespace {
bool InitializeSymbolTable(
@@ -152,12 +151,6 @@
if (success && (compileOptions & SH_VALIDATE_LOOP_INDEXING))
success = validateLimitations(root);
- // Call mapLongVariableNames() before collectAttribsUniforms() so in
- // collectAttribsUniforms() we already have the mapped symbol names and
- // we could composite mapped and original variable names.
- if (success && (compileOptions & SH_MAP_LONG_VARIABLE_NAMES))
- mapLongVariableNames(root);
-
if (success && (compileOptions & SH_ATTRIBUTES_UNIFORMS))
collectAttribsUniforms(root);
@@ -227,14 +220,3 @@
CollectAttribsUniforms collect(attribs, uniforms);
root->traverse(&collect);
}
-
-void TCompiler::mapLongVariableNames(TIntermNode* root)
-{
- MapLongVariableNames map(varyingLongNameMap);
- root->traverse(&map);
-}
-
-int TCompiler::getMappedNameMaxLength() const
-{
- return MAX_IDENTIFIER_NAME_SIZE + 1;
-}
diff --git a/src/OpenGL ES 2.0/compiler/Compiler.vcxproj b/src/OpenGL ES 2.0/compiler/Compiler.vcxproj
new file mode 100644
index 0000000..7443422
--- /dev/null
+++ b/src/OpenGL ES 2.0/compiler/Compiler.vcxproj
@@ -0,0 +1,218 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup Label="ProjectConfigurations">
+ <ProjectConfiguration Include="Debug|Win32">
+ <Configuration>Debug</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Profile|Win32">
+ <Configuration>Profile</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|Win32">
+ <Configuration>Release</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ </ItemGroup>
+ <PropertyGroup Label="Globals">
+ <ProjectGuid>{5B3A6DB8-1E7E-40D7-92B9-DA8AAE619FAD}</ProjectGuid>
+ <RootNamespace>compiler</RootNamespace>
+ <Keyword>Win32Proj</Keyword>
+ <ProjectName>Compiler</ProjectName>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <CharacterSet>NotSet</CharacterSet>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <CharacterSet>NotSet</CharacterSet>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <CharacterSet>NotSet</CharacterSet>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+ <ImportGroup Label="ExtensionSettings">
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <PropertyGroup Label="UserMacros" />
+ <PropertyGroup>
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+ <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Platform)\$(Configuration)\</OutDir>
+ <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Platform)\$(Configuration)\</IntDir>
+ <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Platform)\$(Configuration)\</OutDir>
+ <OutDir Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">$(Platform)\$(Configuration)\</OutDir>
+ <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Platform)\$(Configuration)\</IntDir>
+ <IntDir Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">$(Platform)\$(Configuration)\</IntDir>
+ <IncludePath Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">..\include;$(DXSDK_DIR)\Include;$(VCInstallDir)PlatformSDK\include;$(IncludePath)</IncludePath>
+ <IncludePath Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">..\include;$(DXSDK_DIR)\Include;$(VCInstallDir)PlatformSDK\include;$(IncludePath)</IncludePath>
+ <IncludePath Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">..\include;$(DXSDK_DIR)\Include;$(VCInstallDir)PlatformSDK\include;$(IncludePath)</IncludePath>
+ </PropertyGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <ClCompile>
+ <Optimization>Disabled</Optimization>
+ <AdditionalIncludeDirectories>$(ProjectDir);$(ProjectDir)../;$(ProjectDir)../../;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <MinimalRebuild>true</MinimalRebuild>
+ <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+ <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+ <PrecompiledHeader>
+ </PrecompiledHeader>
+ <WarningLevel>Level3</WarningLevel>
+ <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+ <BrowseInformation>true</BrowseInformation>
+ </ClCompile>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <ClCompile>
+ <Optimization>MaxSpeed</Optimization>
+ <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+ <AdditionalIncludeDirectories>$(ProjectDir);$(ProjectDir)../;$(ProjectDir)../../;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;NOMINMAX;_SECURE_SCL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+ <PrecompiledHeader>
+ </PrecompiledHeader>
+ <WarningLevel>Level3</WarningLevel>
+ <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+ </ClCompile>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+ <ClCompile>
+ <Optimization>MaxSpeed</Optimization>
+ <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+ <AdditionalIncludeDirectories>$(ProjectDir);$(ProjectDir)../;$(ProjectDir)../../;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;NOMINMAX;_SECURE_SCL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+ <PrecompiledHeader>
+ </PrecompiledHeader>
+ <WarningLevel>Level3</WarningLevel>
+ <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+ <OmitFramePointers>false</OmitFramePointers>
+ </ClCompile>
+ </ItemDefinitionGroup>
+ <ItemGroup>
+ <ClCompile Include="Compiler.cpp" />
+ <ClCompile Include="DetectRecursion.cpp" />
+ <ClCompile Include="InfoSink.cpp" />
+ <ClCompile Include="Initialize.cpp" />
+ <ClCompile Include="InitializeDll.cpp" />
+ <ClCompile Include="Intermediate.cpp" />
+ <ClCompile Include="intermOut.cpp" />
+ <ClCompile Include="IntermTraverse.cpp" />
+ <ClCompile Include="ossource_win.cpp" />
+ <ClCompile Include="OutputASM.cpp" />
+ <ClCompile Include="parseConst.cpp" />
+ <ClCompile Include="ParseHelper.cpp" />
+ <ClCompile Include="PoolAlloc.cpp" />
+ <ClCompile Include="QualifierAlive.cpp" />
+ <ClCompile Include="RemoveTree.cpp" />
+ <ClCompile Include="ShaderLang.cpp" />
+ <ClCompile Include="SymbolTable.cpp" />
+ <ClCompile Include="TranslatorASM.cpp" />
+ <ClCompile Include="util.cpp" />
+ <ClCompile Include="ValidateLimitations.cpp" />
+ <ClCompile Include="VariableInfo.cpp" />
+ <ClCompile Include="preprocessor\atom.c" />
+ <ClCompile Include="preprocessor\cpp.c" />
+ <ClCompile Include="preprocessor\cppstruct.c" />
+ <ClCompile Include="preprocessor\memory.c" />
+ <ClCompile Include="preprocessor\scanner.c" />
+ <ClCompile Include="preprocessor\symbols.c" />
+ <ClCompile Include="preprocessor\tokens.c" />
+ <ClCompile Include="glslang_lex.cpp" />
+ <ClCompile Include="glslang_tab.cpp" />
+ </ItemGroup>
+ <ItemGroup>
+ <CustomBuild Include="glslang.l">
+ <Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ </Message>
+ <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ </Command>
+ <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(AdditionalInputs)</AdditionalInputs>
+ <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(Outputs)</Outputs>
+ <Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ </Message>
+ <Message Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+ </Message>
+ <Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ </Command>
+ <Command Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+ </Command>
+ <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(AdditionalInputs)</AdditionalInputs>
+ <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">%(AdditionalInputs)</AdditionalInputs>
+ <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(Outputs)</Outputs>
+ <Outputs Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">%(Outputs)</Outputs>
+ </CustomBuild>
+ <CustomBuild Include="glslang.y">
+ <Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ </Message>
+ <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ </Command>
+ <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(Outputs)</Outputs>
+ <Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ </Message>
+ <Message Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+ </Message>
+ <Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ </Command>
+ <Command Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+ </Command>
+ <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(Outputs)</Outputs>
+ <Outputs Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">%(Outputs)</Outputs>
+ </CustomBuild>
+ </ItemGroup>
+ <ItemGroup>
+ <ClInclude Include="..\include\GLSLANG\ShaderLang.h" />
+ <ClInclude Include="BaseTypes.h" />
+ <ClInclude Include="Common.h" />
+ <ClInclude Include="ConstantUnion.h" />
+ <ClInclude Include="DetectRecursion.h" />
+ <ClInclude Include="InfoSink.h" />
+ <ClInclude Include="Initialize.h" />
+ <ClInclude Include="InitializeDll.h" />
+ <ClInclude Include="InitializeGlobals.h" />
+ <ClInclude Include="InitializeParseContext.h" />
+ <ClInclude Include="intermediate.h" />
+ <ClInclude Include="localintermediate.h" />
+ <ClInclude Include="MMap.h" />
+ <ClInclude Include="osinclude.h" />
+ <ClInclude Include="OutputASM.h" />
+ <ClInclude Include="ParseHelper.h" />
+ <ClInclude Include="PoolAlloc.h" />
+ <ClInclude Include="QualifierAlive.h" />
+ <ClInclude Include="RemoveTree.h" />
+ <ClInclude Include="ShHandle.h" />
+ <ClInclude Include="SymbolTable.h" />
+ <ClInclude Include="TranslatorASM.h" />
+ <ClInclude Include="Types.h" />
+ <ClInclude Include="util.h" />
+ <ClInclude Include="ValidateLimitations.h" />
+ <ClInclude Include="VariableInfo.h" />
+ <ClInclude Include="preprocessor\atom.h" />
+ <ClInclude Include="preprocessor\compile.h" />
+ <ClInclude Include="preprocessor\cpp.h" />
+ <ClInclude Include="preprocessor\memory.h" />
+ <ClInclude Include="preprocessor\parser.h" />
+ <ClInclude Include="preprocessor\preprocess.h" />
+ <ClInclude Include="preprocessor\scanner.h" />
+ <ClInclude Include="preprocessor\slglobals.h" />
+ <ClInclude Include="preprocessor\symbols.h" />
+ <ClInclude Include="preprocessor\tokens.h" />
+ <ClInclude Include="glslang_tab.h" />
+ </ItemGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+ <ImportGroup Label="ExtensionTargets">
+ </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/src/OpenGL ES 2.0/compiler/Compiler.vcxproj.filters b/src/OpenGL ES 2.0/compiler/Compiler.vcxproj.filters
new file mode 100644
index 0000000..574a5e8
--- /dev/null
+++ b/src/OpenGL ES 2.0/compiler/Compiler.vcxproj.filters
@@ -0,0 +1,238 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup>
+ <Filter Include="Source Files">
+ <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+ <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+ </Filter>
+ <Filter Include="Source Files\preprocessor">
+ <UniqueIdentifier>{01ac9b3c-03a5-4ac1-af5a-59fcf0258595}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="Source Files\generated">
+ <UniqueIdentifier>{1add4406-d193-4c4e-a8ec-c41c8d0bd499}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="Header Files">
+ <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+ <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+ </Filter>
+ <Filter Include="Header Files\preprocessor">
+ <UniqueIdentifier>{63184d78-5261-4b85-a56c-1c69e626cdf3}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="Header Files\generated">
+ <UniqueIdentifier>{a56a1771-4799-47ac-ace9-6955dd3f055b}</UniqueIdentifier>
+ </Filter>
+ </ItemGroup>
+ <ItemGroup>
+ <ClCompile Include="Compiler.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="InfoSink.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="Initialize.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="InitializeDll.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="Intermediate.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="intermOut.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="IntermTraverse.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="ossource_win.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="parseConst.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="ParseHelper.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="PoolAlloc.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="QualifierAlive.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="RemoveTree.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="ShaderLang.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="SymbolTable.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="util.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="ValidateLimitations.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="VariableInfo.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="preprocessor\atom.c">
+ <Filter>Source Files\preprocessor</Filter>
+ </ClCompile>
+ <ClCompile Include="preprocessor\cpp.c">
+ <Filter>Source Files\preprocessor</Filter>
+ </ClCompile>
+ <ClCompile Include="preprocessor\cppstruct.c">
+ <Filter>Source Files\preprocessor</Filter>
+ </ClCompile>
+ <ClCompile Include="preprocessor\memory.c">
+ <Filter>Source Files\preprocessor</Filter>
+ </ClCompile>
+ <ClCompile Include="preprocessor\scanner.c">
+ <Filter>Source Files\preprocessor</Filter>
+ </ClCompile>
+ <ClCompile Include="preprocessor\symbols.c">
+ <Filter>Source Files\preprocessor</Filter>
+ </ClCompile>
+ <ClCompile Include="preprocessor\tokens.c">
+ <Filter>Source Files\preprocessor</Filter>
+ </ClCompile>
+ <ClCompile Include="glslang_lex.cpp">
+ <Filter>Source Files\generated</Filter>
+ </ClCompile>
+ <ClCompile Include="glslang_tab.cpp">
+ <Filter>Source Files\generated</Filter>
+ </ClCompile>
+ <ClCompile Include="DetectRecursion.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="OutputASM.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="TranslatorASM.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ </ItemGroup>
+ <ItemGroup>
+ <ClInclude Include="BaseTypes.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="Common.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="ConstantUnion.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="InfoSink.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="Initialize.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="InitializeDll.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="InitializeGlobals.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="InitializeParseContext.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="intermediate.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="localintermediate.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="MMap.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="osinclude.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="ParseHelper.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="PoolAlloc.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="QualifierAlive.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="RemoveTree.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="ShHandle.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="SymbolTable.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="Types.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="util.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="ValidateLimitations.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="VariableInfo.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="preprocessor\atom.h">
+ <Filter>Header Files\preprocessor</Filter>
+ </ClInclude>
+ <ClInclude Include="preprocessor\compile.h">
+ <Filter>Header Files\preprocessor</Filter>
+ </ClInclude>
+ <ClInclude Include="preprocessor\cpp.h">
+ <Filter>Header Files\preprocessor</Filter>
+ </ClInclude>
+ <ClInclude Include="preprocessor\memory.h">
+ <Filter>Header Files\preprocessor</Filter>
+ </ClInclude>
+ <ClInclude Include="preprocessor\parser.h">
+ <Filter>Header Files\preprocessor</Filter>
+ </ClInclude>
+ <ClInclude Include="preprocessor\preprocess.h">
+ <Filter>Header Files\preprocessor</Filter>
+ </ClInclude>
+ <ClInclude Include="preprocessor\scanner.h">
+ <Filter>Header Files\preprocessor</Filter>
+ </ClInclude>
+ <ClInclude Include="preprocessor\slglobals.h">
+ <Filter>Header Files\preprocessor</Filter>
+ </ClInclude>
+ <ClInclude Include="preprocessor\symbols.h">
+ <Filter>Header Files\preprocessor</Filter>
+ </ClInclude>
+ <ClInclude Include="preprocessor\tokens.h">
+ <Filter>Header Files\preprocessor</Filter>
+ </ClInclude>
+ <ClInclude Include="glslang_tab.h">
+ <Filter>Header Files\generated</Filter>
+ </ClInclude>
+ <ClInclude Include="DetectRecursion.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="..\include\GLSLANG\ShaderLang.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="OutputASM.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="TranslatorASM.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ </ItemGroup>
+ <ItemGroup>
+ <CustomBuild Include="glslang.l">
+ <Filter>Source Files</Filter>
+ </CustomBuild>
+ <CustomBuild Include="glslang.y">
+ <Filter>Source Files</Filter>
+ </CustomBuild>
+ </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/src/OpenGL ES 2.0/compiler/ConstantUnion.h b/src/OpenGL ES 2.0/compiler/ConstantUnion.h
index d28a11b..89e83e4 100644
--- a/src/OpenGL ES 2.0/compiler/ConstantUnion.h
+++ b/src/OpenGL ES 2.0/compiler/ConstantUnion.h
@@ -1,5 +1,5 @@
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
@@ -24,6 +24,19 @@
float getFConst() const { return fConst; }
bool getBConst() const { return bConst; }
+ float getAsFloat()
+ {
+ const int FFFFFFFFh = 0xFFFFFFFF;
+
+ switch(type)
+ {
+ case EbtInt: return (float)iConst;
+ case EbtFloat: return fConst;
+ case EbtBool: return (bConst == true) ? (float&)FFFFFFFFh : 0;
+ default: return 0;
+ }
+ }
+
bool operator==(const int i) const
{
return i == iConst;
diff --git a/src/OpenGL ES 2.0/compiler/Initialize.cpp b/src/OpenGL ES 2.0/compiler/Initialize.cpp
index 74a2de3..8c33d36 100644
--- a/src/OpenGL ES 2.0/compiler/Initialize.cpp
+++ b/src/OpenGL ES 2.0/compiler/Initialize.cpp
@@ -612,9 +612,9 @@
switch(type) {
case SH_FRAGMENT_SHADER: {
// Set up gl_FragData. The array size.
- TType fragData(EbtFloat, EbpMedium, EvqFragColor, 4, false, true);
+ TType fragData(EbtFloat, EbpMedium, EvqFragData, 4, false, true);
fragData.setArraySize(resources.MaxDrawBuffers);
- symbolTable.insert(*new TVariable(NewPoolTString("gl_FragData"), fragData));
+ symbolTable.insert(*new TVariable(NewPoolTString("gl_FragData"), fragData));
}
break;
default: break;
diff --git a/src/OpenGL ES 2.0/compiler/Intermediate.cpp b/src/OpenGL ES 2.0/compiler/Intermediate.cpp
index e1e8da2..d75083d 100644
--- a/src/OpenGL ES 2.0/compiler/Intermediate.cpp
+++ b/src/OpenGL ES 2.0/compiler/Intermediate.cpp
@@ -1,5 +1,5 @@
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
@@ -656,6 +656,7 @@
// Make a selection node.
//
TIntermSelection* node = new TIntermSelection(cond, trueBlock, falseBlock, trueBlock->getType());
+ node->getTypePointer()->setQualifier(EvqTemporary);
node->setLine(line);
return node;
@@ -845,6 +846,11 @@
setType(operand->getType());
+ // Unary operations results in temporary variables unless const.
+ if (operand->getQualifier() != EvqConst) {
+ getTypePointer()->setQualifier(EvqTemporary);
+ }
+
return true;
}
diff --git a/src/OpenGL ES 2.0/compiler/OutputASM.cpp b/src/OpenGL ES 2.0/compiler/OutputASM.cpp
new file mode 100644
index 0000000..49a1262
--- /dev/null
+++ b/src/OpenGL ES 2.0/compiler/OutputASM.cpp
@@ -0,0 +1,2196 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "compiler/OutputASM.h"
+
+#include "common/debug.h"
+#include "compiler/InfoSink.h"
+
+#include "libGLESv2/Shader.h"
+
+#define GL_APICALL
+#include <GLES2/gl2.h>
+
+namespace sh
+{
+ static const unsigned char swizzleSize[5] = {0x00, 0x00, 0x54, 0xA4, 0xE4}; // (void), xxxx, xyyy, xyzz, xyzw
+
+ // Integer to TString conversion
+ TString str(int i)
+ {
+ char buffer[20];
+ sprintf(buffer, "%d", i);
+ return buffer;
+ }
+
+ class Temporary : public TIntermSymbol
+ {
+ public:
+ Temporary(OutputASM *assembler) : TIntermSymbol(0, "tmp", TType(EbtFloat, EbpHigh, EvqTemporary, 4, false, false)), assembler(assembler)
+ {
+ }
+
+ ~Temporary()
+ {
+ assembler->freeTemporary(this);
+ }
+
+ private:
+ OutputASM *const assembler;
+ };
+
+ class Constant : public TIntermConstantUnion
+ {
+ public:
+ Constant(float x, float y, float z, float w) : TIntermConstantUnion(constants, TType(EbtFloat, EbpHigh, EvqConst, 4, false, false))
+ {
+ constants[0].setFConst(x);
+ constants[1].setFConst(y);
+ constants[2].setFConst(z);
+ constants[3].setFConst(w);
+ }
+
+ Constant(bool b) : TIntermConstantUnion(constants, TType(EbtBool, EbpHigh, EvqConst, 1, false, false))
+ {
+ constants[0].setBConst(b);
+ }
+
+ Constant(int i) : TIntermConstantUnion(constants, TType(EbtInt, EbpHigh, EvqConst, 1, false, false))
+ {
+ constants[0].setIConst(i);
+ }
+
+ ~Constant()
+ {
+ }
+
+ private:
+ ConstantUnion constants[4];
+ };
+
+ Uniform::Uniform(GLenum type, const std::string &name, int arraySize, int registerIndex)
+ {
+ this->type = type;
+ this->name = name;
+ this->arraySize = arraySize;
+ this->registerIndex = registerIndex;
+ }
+
+ Attribute::Attribute()
+ {
+ type = GL_NONE;
+ arraySize = 0;
+ registerIndex = 0;
+ }
+
+ Attribute::Attribute(GLenum type, const std::string &name, int arraySize, int registerIndex)
+ {
+ this->type = type;
+ this->name = name;
+ this->arraySize = arraySize;
+ this->registerIndex = registerIndex;
+ }
+
+ OutputASM::OutputASM(TParseContext &context, gl::Shader *shaderObject) : TIntermTraverser(true, true, true), mContext(context), shaderObject(shaderObject)
+ {
+ shader = 0;
+ pixelShader = 0;
+ vertexShader = 0;
+
+ if(shaderObject)
+ {
+ shader = shaderObject->getShader();
+ pixelShader = shaderObject->getPixelShader();
+ vertexShader = shaderObject->getVertexShader();
+ }
+
+ functionArray.push_back(Function(0, "main(", 0, 0));
+ currentFunction = 0;
+ }
+
+ OutputASM::~OutputASM()
+ {
+ }
+
+ void OutputASM::output()
+ {
+ if(shader)
+ {
+ emitShader(GLOBAL);
+
+ if(functionArray.size() > 1) // Only call main() when there are other functions
+ {
+ Instruction *callMain = emit(sw::Shader::OPCODE_CALL);
+ callMain->dst.type = sw::Shader::PARAMETER_LABEL;
+ callMain->dst.index = 0; // main()
+
+ emit(sw::Shader::OPCODE_RET);
+ }
+
+ emitShader(FUNCTION);
+ }
+ }
+
+ void OutputASM::emitShader(Scope scope)
+ {
+ emitScope = scope;
+ currentScope = GLOBAL;
+ mContext.treeRoot->traverse(this);
+ }
+
+ void OutputASM::freeTemporary(Temporary *temporary)
+ {
+ free(temporaries, temporary);
+ }
+
+ bool OutputASM::visitBinary(Visit visit, TIntermBinary *node)
+ {
+ if(currentScope != emitScope)
+ {
+ return false;
+ }
+
+ TIntermTyped *result = node;
+ TIntermTyped *left = node->getLeft();
+ TIntermTyped *right = node->getRight();
+ const TType &leftType = left->getType();
+ const TType &rightType = right->getType();
+ const TType &resultType = node->getType();
+
+ switch(node->getOp())
+ {
+ case EOpAssign:
+ if(visit == PostVisit)
+ {
+ assignLvalue(left, right);
+ copy(result, right);
+ }
+ break;
+ case EOpInitialize:
+ if(visit == PostVisit)
+ {
+ copy(left, right);
+ }
+ break;
+ case EOpMatrixTimesScalarAssign:
+ if(visit == PostVisit)
+ {
+ for(int i = 0; i < leftType.getNominalSize(); i++)
+ {
+ Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);
+ mul->dst.index += i;
+ argument(mul->src[0], left, i);
+ }
+
+ assignLvalue(left, result);
+ }
+ break;
+ case EOpVectorTimesMatrixAssign:
+ if(visit == PostVisit)
+ {
+ int size = leftType.getNominalSize();
+
+ for(int i = 0; i < size; i++)
+ {
+ Instruction *dot = emit(sw::Shader::OPCODE_DP(size), result, left, right);
+ dot->dst.mask = 1 << i;
+ argument(dot->src[1], right, i);
+ }
+
+ assignLvalue(left, result);
+ }
+ break;
+ case EOpMatrixTimesMatrixAssign:
+ if(visit == PostVisit)
+ {
+ int dim = leftType.getNominalSize();
+
+ for(int i = 0; i < dim; i++)
+ {
+ Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);
+ mul->dst.index += i;
+ argument(mul->src[1], right, i);
+ mul->src[1].swizzle = 0x00;
+
+ for(int j = 1; j < dim; j++)
+ {
+ Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, left, right, result);
+ mad->dst.index += i;
+ argument(mad->src[0], left, j);
+ argument(mad->src[1], right, i);
+ mad->src[1].swizzle = j * 0x55;
+ argument(mad->src[2], result, i);
+ }
+ }
+
+ assignLvalue(left, result);
+ }
+ break;
+ case EOpIndexDirect:
+ if(visit == PostVisit)
+ {
+ int index = right->getAsConstantUnion()->getUnionArrayPointer()->getIConst();
+
+ if(result->isMatrix() || result->isStruct())
+ {
+ ASSERT(left->isArray());
+ copy(result, left, index * left->elementRegisterCount());
+ }
+ else if(result->isRegister())
+ {
+ Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, left);
+
+ if(left->isRegister())
+ {
+ mov->src[0].swizzle = index;
+ }
+ else if(left->isArray())
+ {
+ argument(mov->src[0], left, index * left->elementRegisterCount());
+ }
+ else if(left->isMatrix())
+ {
+ ASSERT(index < left->getNominalSize()); // FIXME: Report semantic error
+ argument(mov->src[0], left, index);
+ }
+ else UNREACHABLE();
+ }
+ else UNREACHABLE();
+ }
+ break;
+ case EOpIndexIndirect:
+ if(visit == PostVisit)
+ {
+ if(left->isArray() || left->isMatrix())
+ {
+ for(int index = 0; index < result->totalRegisterCount(); index++)
+ {
+ Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, left);
+
+ mov->dst.index += index;
+ argument(mov->src[0], left, index);
+
+ if(left->totalRegisterCount() > 1)
+ {
+ sw::Shader::SourceParameter relativeRegister;
+ argument(relativeRegister, right);
+
+ mov->src[0].rel.type = relativeRegister.type;
+ mov->src[0].rel.index = relativeRegister.index;
+ mov->src[0].rel.scale = result->totalRegisterCount();
+ mov->src[0].rel.deterministic = !(vertexShader && left->getQualifier() == EvqUniform);
+ }
+ }
+ }
+ else if(left->isRegister())
+ {
+ emit(sw::Shader::OPCODE_EXTRACT, result, left, right);
+ }
+ else UNREACHABLE();
+ }
+ break;
+ case EOpIndexDirectStruct:
+ if(visit == PostVisit)
+ {
+ ASSERT(leftType.isStruct());
+
+ const TTypeList *structure = leftType.getStruct();
+ const TString &fieldName = rightType.getFieldName();
+ int fieldOffset = 0;
+
+ for(size_t i = 0; i < structure->size(); i++)
+ {
+ const TType &fieldType = *(*structure)[i].type;
+
+ if(fieldType.getFieldName() == fieldName)
+ {
+ break;
+ }
+
+ fieldOffset += fieldType.totalRegisterCount();
+ }
+
+ copy(result, left, fieldOffset);
+ }
+ break;
+ case EOpVectorSwizzle:
+ if(visit == PostVisit)
+ {
+ int swizzle = 0;
+ TIntermAggregate *components = right->getAsAggregate();
+
+ if(components)
+ {
+ TIntermSequence &sequence = components->getSequence();
+ int component = 0;
+
+ for(TIntermSequence::iterator sit = sequence.begin(); sit != sequence.end(); sit++)
+ {
+ TIntermConstantUnion *element = (*sit)->getAsConstantUnion();
+
+ if(element)
+ {
+ int i = element->getUnionArrayPointer()[0].getIConst();
+ swizzle |= i << (component * 2);
+ component++;
+ }
+ else UNREACHABLE();
+ }
+ }
+ else UNREACHABLE();
+
+ Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, left);
+ mov->src[0].swizzle = swizzle;
+ }
+ break;
+ case EOpAddAssign: if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_ADD, result, left, left, right); break;
+ case EOpAdd: if(visit == PostVisit) emit(sw::Shader::OPCODE_ADD, result, left, right); break;
+ case EOpSubAssign: if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_SUB, result, left, left, right); break;
+ case EOpSub: if(visit == PostVisit) emit(sw::Shader::OPCODE_SUB, result, left, right); break;
+ case EOpMulAssign: if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_MUL, result, left, left, right); break;
+ case EOpMul: if(visit == PostVisit) emit(sw::Shader::OPCODE_MUL, result, left, right); break;
+ case EOpDivAssign: if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_DIV, result, left, left, right); break;
+ case EOpDiv: if(visit == PostVisit) emit(sw::Shader::OPCODE_DIV, result, left, right); break;
+ case EOpEqual:
+ if(visit == PostVisit)
+ {
+ emitCmp(sw::Shader::CONTROL_EQ, result, left, right);
+
+ for(int index = 1; index < left->totalRegisterCount(); index++)
+ {
+ Temporary equal(this);
+ emitCmp(sw::Shader::CONTROL_EQ, &equal, left, right, index);
+ emit(sw::Shader::OPCODE_AND, result, result, &equal);
+ }
+ }
+ break;
+ case EOpNotEqual:
+ if(visit == PostVisit)
+ {
+ emitCmp(sw::Shader::CONTROL_NE, result, left, right);
+
+ for(int index = 1; index < left->totalRegisterCount(); index++)
+ {
+ Temporary notEqual(this);
+ emitCmp(sw::Shader::CONTROL_NE, ¬Equal, left, right, index);
+ emit(sw::Shader::OPCODE_OR, result, result, ¬Equal);
+ }
+ }
+ break;
+ case EOpLessThan: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LT, result, left, right); break;
+ case EOpGreaterThan: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GT, result, left, right); break;
+ case EOpLessThanEqual: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LE, result, left, right); break;
+ case EOpGreaterThanEqual: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GE, result, left, right); break;
+ case EOpVectorTimesScalarAssign: if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_MUL, result, left, left, right); break;
+ case EOpVectorTimesScalar: if(visit == PostVisit) emit(sw::Shader::OPCODE_MUL, result, left, right); break;
+ case EOpMatrixTimesScalar:
+ if(visit == PostVisit)
+ {
+ for(int i = 0; i < leftType.getNominalSize(); i++)
+ {
+ Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);
+ mul->dst.index += i;
+ argument(mul->src[0], left, i);
+ }
+ }
+ break;
+ case EOpVectorTimesMatrix:
+ if(visit == PostVisit)
+ {
+ int size = leftType.getNominalSize();
+
+ for(int i = 0; i < size; i++)
+ {
+ Instruction *dot = emit(sw::Shader::OPCODE_DP(size), result, left, right);
+ dot->dst.mask = 1 << i;
+ argument(dot->src[1], right, i);
+ }
+ }
+ break;
+ case EOpMatrixTimesVector:
+ if(visit == PostVisit)
+ {
+ Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);
+ mul->src[1].swizzle = 0x00;
+
+ for(int i = 1; i < leftType.getNominalSize(); i++)
+ {
+ Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, left, right, result);
+ argument(mad->src[0], left, i);
+ mad->src[1].swizzle = i * 0x55;
+ }
+ }
+ break;
+ case EOpMatrixTimesMatrix:
+ if(visit == PostVisit)
+ {
+ int dim = leftType.getNominalSize();
+
+ for(int i = 0; i < dim; i++)
+ {
+ Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);
+ mul->dst.index += i;
+ argument(mul->src[1], right, i);
+ mul->src[1].swizzle = 0x00;
+
+ for(int j = 1; j < dim; j++)
+ {
+ Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, left, right, result);
+ mad->dst.index += i;
+ argument(mad->src[0], left, j);
+ argument(mad->src[1], right, i);
+ mad->src[1].swizzle = j * 0x55;
+ argument(mad->src[2], result, i);
+ }
+ }
+ }
+ break;
+ case EOpLogicalOr: if(visit == PostVisit) emit(sw::Shader::OPCODE_OR, result, left, right); break;
+ case EOpLogicalXor: if(visit == PostVisit) emit(sw::Shader::OPCODE_XOR, result, left, right); break;
+ case EOpLogicalAnd: if(visit == PostVisit) emit(sw::Shader::OPCODE_AND, result, left, right); break;
+ default: UNREACHABLE();
+ }
+
+ return true;
+ }
+
+ bool OutputASM::visitUnary(Visit visit, TIntermUnary *node)
+ {
+ if(currentScope != emitScope)
+ {
+ return false;
+ }
+
+ TIntermTyped *result = node;
+ TIntermTyped *arg = node->getOperand();
+
+ switch(node->getOp())
+ {
+ case EOpNegative:
+ if(visit == PostVisit)
+ {
+ for(int index = 0; index < arg->totalRegisterCount(); index++)
+ {
+ Instruction *neg = emit(sw::Shader::OPCODE_MOV, result, arg);
+ neg->dst.index += index;
+ argument(neg->src[0], arg, index);
+ neg->src[0].modifier = sw::Shader::MODIFIER_NEGATE;
+ }
+ }
+ break;
+ case EOpVectorLogicalNot: if(visit == PostVisit) emit(sw::Shader::OPCODE_NOT, result, arg); break;
+ case EOpLogicalNot: if(visit == PostVisit) emit(sw::Shader::OPCODE_NOT, result, arg); break;
+ case EOpPostIncrement:
+ if(visit == PostVisit)
+ {
+ copy(result, arg);
+
+ for(int index = 0; index < arg->totalRegisterCount(); index++)
+ {
+ Instruction *add = emit(sw::Shader::OPCODE_ADD, arg, arg, &Constant(1.0f, 1.0f, 1.0f, 1.0f));
+ add->dst.index += index;
+ argument(add->src[0], arg, index);
+ }
+
+ assignLvalue(arg, arg);
+ }
+ break;
+ case EOpPostDecrement:
+ if(visit == PostVisit)
+ {
+ copy(result, arg);
+
+ for(int index = 0; index < arg->totalRegisterCount(); index++)
+ {
+ Instruction *sub = emit(sw::Shader::OPCODE_SUB, arg, arg, &Constant(1.0f, 1.0f, 1.0f, 1.0f));
+ sub->dst.index += index;
+ argument(sub->src[0], arg, index);
+ }
+
+ assignLvalue(arg, arg);
+ }
+ break;
+ case EOpPreIncrement:
+ if(visit == PostVisit)
+ {
+ for(int index = 0; index < arg->totalRegisterCount(); index++)
+ {
+ Instruction *add = emit(sw::Shader::OPCODE_ADD, result, arg, &Constant(1.0f, 1.0f, 1.0f, 1.0f));
+ add->dst.index += index;
+ argument(add->src[0], arg, index);
+ }
+
+ assignLvalue(arg, result);
+ }
+ break;
+ case EOpPreDecrement:
+ if(visit == PostVisit)
+ {
+ for(int index = 0; index < arg->totalRegisterCount(); index++)
+ {
+ Instruction *sub = emit(sw::Shader::OPCODE_SUB, result, arg, &Constant(1.0f, 1.0f, 1.0f, 1.0f));
+ sub->dst.index += index;
+ argument(sub->src[0], arg, index);
+ }
+
+ assignLvalue(arg, result);
+ }
+ break;
+ case EOpConvIntToBool: if(visit == PostVisit) emit(sw::Shader::OPCODE_F2B, result, arg); break; // Integers are implemented as float
+ case EOpConvFloatToBool: if(visit == PostVisit) emit(sw::Shader::OPCODE_F2B, result, arg); break;
+ case EOpConvBoolToFloat: if(visit == PostVisit) emit(sw::Shader::OPCODE_B2F, result, arg); break;
+ case EOpConvIntToFloat: if(visit == PostVisit) emit(sw::Shader::OPCODE_MOV, result, arg); break; // Integers are implemented as float
+ case EOpConvFloatToInt: if(visit == PostVisit) emit(sw::Shader::OPCODE_TRUNC, result, arg); break; // Integers are implemented as float
+ case EOpConvBoolToInt: if(visit == PostVisit) emit(sw::Shader::OPCODE_B2F, result, arg); break; // Integers are implemented as float
+ case EOpRadians: if(visit == PostVisit) emit(sw::Shader::OPCODE_MUL, result, arg, &Constant(1.74532925e-2f, 1.74532925e-2f, 1.74532925e-2f, 1.74532925e-2f)); break;
+ case EOpDegrees: if(visit == PostVisit) emit(sw::Shader::OPCODE_MUL, result, arg, &Constant(5.72957795e+1f, 5.72957795e+1f, 5.72957795e+1f, 5.72957795e+1f)); break;
+ case EOpSin: if(visit == PostVisit) emit(sw::Shader::OPCODE_SIN, result, arg); break;
+ case EOpCos: if(visit == PostVisit) emit(sw::Shader::OPCODE_COS, result, arg); break;
+ case EOpTan: if(visit == PostVisit) emit(sw::Shader::OPCODE_TAN, result, arg); break;
+ case EOpAsin: if(visit == PostVisit) emit(sw::Shader::OPCODE_ASIN, result, arg); break;
+ case EOpAcos: if(visit == PostVisit) emit(sw::Shader::OPCODE_ACOS, result, arg); break;
+ case EOpAtan: if(visit == PostVisit) emit(sw::Shader::OPCODE_ATAN, result, arg); break;
+ case EOpExp: if(visit == PostVisit) emit(sw::Shader::OPCODE_EXP, result, arg); break;
+ case EOpLog: if(visit == PostVisit) emit(sw::Shader::OPCODE_LOG, result, arg); break;
+ case EOpExp2: if(visit == PostVisit) emit(sw::Shader::OPCODE_EXP2, result, arg); break;
+ case EOpLog2: if(visit == PostVisit) emit(sw::Shader::OPCODE_LOG2, result, arg); break;
+ case EOpSqrt: if(visit == PostVisit) emit(sw::Shader::OPCODE_SQRT, result, arg); break;
+ case EOpInverseSqrt: if(visit == PostVisit) emit(sw::Shader::OPCODE_RSQ, result, arg); break;
+ case EOpAbs: if(visit == PostVisit) emit(sw::Shader::OPCODE_ABS, result, arg); break;
+ case EOpSign: if(visit == PostVisit) emit(sw::Shader::OPCODE_SGN, result, arg); break;
+ case EOpFloor: if(visit == PostVisit) emit(sw::Shader::OPCODE_FLOOR, result, arg); break;
+ case EOpCeil: if(visit == PostVisit) emit(sw::Shader::OPCODE_CEIL, result, arg, result); break;
+ case EOpFract: if(visit == PostVisit) emit(sw::Shader::OPCODE_FRC, result, arg); break;
+ case EOpLength: if(visit == PostVisit) emit(sw::Shader::OPCODE_LEN(dim(arg)), result, arg); break;
+ case EOpNormalize: if(visit == PostVisit) emit(sw::Shader::OPCODE_NRM(dim(arg)), result, arg); break;
+ case EOpDFdx: if(visit == PostVisit) emit(sw::Shader::OPCODE_DFDX, result, arg); break;
+ case EOpDFdy: if(visit == PostVisit) emit(sw::Shader::OPCODE_DFDY, result, arg); break;
+ 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;
+ default: UNREACHABLE();
+ }
+
+ return true;
+ }
+
+ bool OutputASM::visitAggregate(Visit visit, TIntermAggregate *node)
+ {
+ if(currentScope != emitScope && node->getOp() != EOpFunction && node->getOp() != EOpSequence)
+ {
+ return false;
+ }
+
+ TIntermTyped *result = node;
+ const TType &resultType = node->getType();
+ TIntermSequence &arg = node->getSequence();
+ int argumentCount = arg.size();
+
+ switch(node->getOp())
+ {
+ case EOpSequence: break;
+ case EOpDeclaration: break;
+ case EOpPrototype: break;
+ case EOpComma:
+ if(visit == PostVisit)
+ {
+ copy(result, arg[1]);
+ }
+ break;
+ case EOpFunction:
+ if(visit == PreVisit)
+ {
+ const TString &name = node->getName();
+
+ if(emitScope == FUNCTION)
+ {
+ if(functionArray.size() > 1) // No need for a label when there's only main()
+ {
+ Instruction *label = emit(sw::Shader::OPCODE_LABEL);
+ label->dst.type = sw::Shader::PARAMETER_LABEL;
+
+ const Function &function = findFunction(name);
+ label->dst.index = function.label;
+ currentFunction = function.label;
+ }
+ }
+ else if(emitScope == GLOBAL)
+ {
+ if(name != "main(")
+ {
+ TIntermSequence &arguments = node->getSequence()[0]->getAsAggregate()->getSequence();
+ functionArray.push_back(Function(functionArray.size(), name, &arguments, node));
+ }
+ }
+ else UNREACHABLE();
+
+ currentScope = FUNCTION;
+ }
+ else if(visit == PostVisit)
+ {
+ if(emitScope == FUNCTION)
+ {
+ if(functionArray.size() > 1) // No need to return when there's only main()
+ {
+ emit(sw::Shader::OPCODE_RET);
+ }
+ }
+
+ currentScope = GLOBAL;
+ }
+ break;
+ case EOpFunctionCall:
+ if(visit == PostVisit)
+ {
+ if(node->isUserDefined())
+ {
+ const TString &name = node->getName();
+ const Function &function = findFunction(name);
+ TIntermSequence &arguments = *function.arg;
+
+ for(int i = 0; i < argumentCount; i++)
+ {
+ TIntermTyped *in = arguments[i]->getAsTyped();
+
+ if(in->getQualifier() == EvqIn ||
+ in->getQualifier() == EvqInOut ||
+ in->getQualifier() == EvqConstReadOnly)
+ {
+ copy(in, arg[i]);
+ }
+ }
+
+ Instruction *call = emit(sw::Shader::OPCODE_CALL);
+ call->dst.type = sw::Shader::PARAMETER_LABEL;
+ call->dst.index = function.label;
+
+ if(function.ret && function.ret->getType().getBasicType() != EbtVoid)
+ {
+ copy(result, function.ret);
+ }
+
+ for(int i = 0; i < argumentCount; i++)
+ {
+ TIntermTyped *argument = arguments[i]->getAsTyped();
+ TIntermTyped *out = arg[i]->getAsTyped();
+
+ if(argument->getQualifier() == EvqOut ||
+ argument->getQualifier() == EvqInOut)
+ {
+ copy(out, argument);
+ }
+ }
+ }
+ else
+ {
+ TString name = TFunction::unmangleName(node->getName());
+
+ if(name == "texture2D" || name == "textureCube")
+ {
+ if(argumentCount == 2)
+ {
+ emit(sw::Shader::OPCODE_TEX, result, arg[1], arg[0]);
+ }
+ else if(argumentCount == 3) // bias
+ {
+ Temporary uvwb(this);
+ emit(sw::Shader::OPCODE_MOV, &uvwb, arg[1]);
+ Instruction *bias = emit(sw::Shader::OPCODE_MOV, &uvwb, arg[2]);
+ bias->dst.mask = 0x8;
+
+ Instruction *tex = emit(sw::Shader::OPCODE_TEX, result, &uvwb, arg[0]); // FIXME: Implement an efficient TEXLDB instruction
+ tex->bias = true;
+ }
+ else UNREACHABLE();
+ }
+ else if(name == "texture2DProj")
+ {
+ TIntermTyped *t = arg[1]->getAsTyped();
+
+ if(argumentCount == 2)
+ {
+ Instruction *tex = emit(sw::Shader::OPCODE_TEX, result, arg[1], arg[0]);
+ tex->project = true;
+
+ if(t->getNominalSize() == 3)
+ {
+ tex->src[0].swizzle = 0xA4;
+ }
+ else ASSERT(t->getNominalSize() == 4);
+ }
+ else if(argumentCount == 3) // bias
+ {
+ Temporary proj(this);
+ emit(sw::Shader::OPCODE_MOV, &proj, arg[1]);
+
+ if(t->getNominalSize() == 3)
+ {
+ Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, &proj);
+ div->src[0].swizzle = 0xAA;
+ div->dst.mask = 0x3;
+ }
+ else if(t->getNominalSize() == 4)
+ {
+ Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, &proj);
+ div->src[0].swizzle = 0xFF;
+ div->dst.mask = 0x3;
+ }
+ else UNREACHABLE();
+
+ Instruction *bias = emit(sw::Shader::OPCODE_MOV, &proj, arg[2]);
+ bias->dst.mask = 0x8;
+
+ Instruction *tex = emit(sw::Shader::OPCODE_TEX, result, &proj, arg[0]);
+ tex->bias = true;
+ }
+ else UNREACHABLE();
+ }
+ else if(name == "texture2DLod" || name == "textureCubeLod")
+ {
+ Temporary uvwb(this);
+ emit(sw::Shader::OPCODE_MOV, &uvwb, arg[1]);
+ Instruction *lod = emit(sw::Shader::OPCODE_MOV, &uvwb, arg[2]);
+ lod->dst.mask = 0x8;
+
+ emit(sw::Shader::OPCODE_TEXLDL, result, &uvwb, arg[0]);
+ }
+ else if(name == "texture2DProjLod")
+ {
+ TIntermTyped *t = arg[1]->getAsTyped();
+
+ Temporary proj(this);
+ emit(sw::Shader::OPCODE_MOV, &proj, arg[1]);
+
+ if(t->getNominalSize() == 3)
+ {
+ Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, &proj);
+ div->src[0].swizzle = 0xAA;
+ div->dst.mask = 0x3;
+ }
+ else if(t->getNominalSize() == 4)
+ {
+ Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, &proj);
+ div->src[0].swizzle = 0xFF;
+ div->dst.mask = 0x3;
+ }
+ else UNREACHABLE();
+
+ Instruction *lod = emit(sw::Shader::OPCODE_MOV, &proj, arg[2]);
+ lod->dst.mask = 0x8;
+
+ emit(sw::Shader::OPCODE_TEXLDL, result, &proj, arg[0]);
+ }
+ else UNREACHABLE();
+ }
+ }
+ break;
+ case EOpParameters: break;
+ case EOpConstructFloat:
+ case EOpConstructVec2:
+ case EOpConstructVec3:
+ case EOpConstructVec4:
+ case EOpConstructBool:
+ case EOpConstructBVec2:
+ case EOpConstructBVec3:
+ case EOpConstructBVec4:
+ case EOpConstructInt:
+ case EOpConstructIVec2:
+ case EOpConstructIVec3:
+ case EOpConstructIVec4:
+ if(visit == PostVisit)
+ {
+ int component = 0;
+
+ for(int i = 0; i < argumentCount; i++)
+ {
+ TIntermTyped *argi = arg[i]->getAsTyped();
+ int size = argi->getNominalSize();
+ ASSERT(!argi->isMatrix());
+
+ Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, argi);
+ mov->dst.mask = (0xF << component) & 0xF;
+ mov->src[0].swizzle = swizzleSize[size] << (component * 2);
+
+ component += size;
+ }
+ }
+ break;
+ case EOpConstructMat2:
+ case EOpConstructMat3:
+ case EOpConstructMat4:
+ if(visit == PostVisit)
+ {
+ TIntermTyped *arg0 = arg[0]->getAsTyped();
+ const int dim = result->getNominalSize();
+
+ if(arg0->isMatrix())
+ {
+ for(int i = 0; i < dim; i++)
+ {
+ if(dim > dim2(arg0))
+ {
+ // Initialize to identity matrix
+ Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, &Constant((i == 0 ? 1.0f : 0.0f), (i == 1 ? 1.0f : 0.0f), (i == 2 ? 1.0f : 0.0f), (i == 3 ? 1.0f : 0.0f)));
+ mov->dst.index += i;
+ }
+
+ if(i < dim2(arg0))
+ {
+ Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, arg0);
+ mov->dst.index += i;
+ mov->dst.mask = 0xF >> (4 - dim2(arg0));
+ argument(mov->src[0], arg0, i);
+ }
+ }
+ }
+ else
+ {
+ int column = 0;
+ int row = 0;
+
+ for(int i = 0; i < argumentCount; i++)
+ {
+ TIntermTyped *argi = arg[i]->getAsTyped();
+ int size = argi->getNominalSize();
+ int element = 0;
+
+ while(element < size)
+ {
+ Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, argi);
+ mov->dst.index += column;
+ mov->dst.mask = (0xF << row) & 0xF;
+ mov->src[0].swizzle = (swizzleSize[size] << (row * 2)) + 0x55 * element;
+
+ int end = row + size - element;
+ column = end >= dim ? column + 1 : column;
+ element = element + dim - row;
+ row = end >= dim ? 0 : end;
+ }
+ }
+ }
+ }
+ break;
+ case EOpConstructStruct:
+ if(visit == PostVisit)
+ {
+ int offset = 0;
+ for(int i = 0; i < argumentCount; i++)
+ {
+ TIntermTyped *argi = arg[i]->getAsTyped();
+ int size = argi->totalRegisterCount();
+
+ for(int index = 0; index < size; index++)
+ {
+ Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, argi);
+ mov->dst.index += index + offset;
+ mov->dst.mask = writeMask(result, offset + index);
+ argument(mov->src[0], argi, index);
+ }
+
+ offset += size;
+ }
+ }
+ break;
+ case EOpLessThan: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LT, result, arg[0], arg[1]); break;
+ case EOpGreaterThan: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GT, result, arg[0], arg[1]); break;
+ case EOpLessThanEqual: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LE, result, arg[0], arg[1]); break;
+ case EOpGreaterThanEqual: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GE, result, arg[0], arg[1]); break;
+ case EOpVectorEqual: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_EQ, result, arg[0], arg[1]); break;
+ case EOpVectorNotEqual: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_NE, result, arg[0], arg[1]); break;
+ case EOpMod: if(visit == PostVisit) emit(sw::Shader::OPCODE_MOD, result, arg[0], arg[1]); break;
+ case EOpPow: if(visit == PostVisit) emit(sw::Shader::OPCODE_POW, result, arg[0], arg[1]); break;
+ case EOpAtan: if(visit == PostVisit) emit(sw::Shader::OPCODE_ATAN2, result, arg[0], arg[1]); break;
+ case EOpMin: if(visit == PostVisit) emit(sw::Shader::OPCODE_MIN, result, arg[0], arg[1]); break;
+ case EOpMax: if(visit == PostVisit) emit(sw::Shader::OPCODE_MAX, result, arg[0], arg[1]); break;
+ case EOpClamp:
+ if(visit == PostVisit)
+ {
+ emit(sw::Shader::OPCODE_MAX, result, arg[0], arg[1]);
+ emit(sw::Shader::OPCODE_MIN, result, result, arg[2]);
+ }
+ break;
+ case EOpMix: if(visit == PostVisit) emit(sw::Shader::OPCODE_LRP, result, arg[2], arg[1], arg[0]); break;
+ case EOpStep: if(visit == PostVisit) emit(sw::Shader::OPCODE_STEP, result, arg[0], arg[1]); break;
+ case EOpSmoothStep: if(visit == PostVisit) emit(sw::Shader::OPCODE_SMOOTH, result, arg[0], arg[1], arg[2]); break;
+ case EOpDistance: if(visit == PostVisit) emit(sw::Shader::OPCODE_DIST(dim(arg[0])), result, arg[0], arg[1]); break;
+ case EOpDot: if(visit == PostVisit) emit(sw::Shader::OPCODE_DP(dim(arg[0])), result, arg[0], arg[1]); break;
+ case EOpCross: if(visit == PostVisit) emit(sw::Shader::OPCODE_CRS, result, arg[0], arg[1]); break;
+ 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 EOpMul:
+ if(visit == PostVisit)
+ {
+ ASSERT(dim2(arg[0]) == dim2(arg[1]));
+
+ for(int i = 0; i < dim2(arg[0]); i++)
+ {
+ Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, arg[0], arg[1]);
+ mul->dst.index += i;
+ argument(mul->src[0], arg[0], i);
+ argument(mul->src[1], arg[1], i);
+ }
+ }
+ break;
+ default: UNREACHABLE();
+ }
+
+ return true;
+ }
+
+ bool OutputASM::visitSelection(Visit visit, TIntermSelection *node)
+ {
+ if(currentScope != emitScope)
+ {
+ return false;
+ }
+
+ TIntermTyped *condition = node->getCondition();
+ TIntermNode *trueBlock = node->getTrueBlock();
+ TIntermNode *falseBlock = node->getFalseBlock();
+ TIntermConstantUnion *constantCondition = condition->getAsConstantUnion();
+
+ condition->traverse(this);
+
+ if(node->usesTernaryOperator())
+ {
+ if(constantCondition)
+ {
+ bool trueCondition = constantCondition->getUnionArrayPointer()->getBConst();
+
+ if(trueCondition)
+ {
+ trueBlock->traverse(this);
+ copy(node, trueBlock);
+ }
+ else
+ {
+ falseBlock->traverse(this);
+ copy(node, falseBlock);
+ }
+ }
+ else if(trivial(node, 6)) // Fast to compute both potential results and no side effects
+ {
+ trueBlock->traverse(this);
+ falseBlock->traverse(this);
+ emit(sw::Shader::OPCODE_SELECT, node, condition, trueBlock, falseBlock);
+ }
+ else
+ {
+ emit(sw::Shader::OPCODE_IF, 0, condition);
+
+ if(trueBlock)
+ {
+ trueBlock->traverse(this);
+ copy(node, trueBlock);
+ }
+
+ if(falseBlock)
+ {
+ emit(sw::Shader::OPCODE_ELSE);
+ falseBlock->traverse(this);
+ copy(node, falseBlock);
+ }
+
+ emit(sw::Shader::OPCODE_ENDIF);
+ }
+ }
+ else // if/else statement
+ {
+ if(constantCondition)
+ {
+ bool trueCondition = constantCondition->getUnionArrayPointer()->getBConst();
+
+ if(trueCondition)
+ {
+ if(trueBlock)
+ {
+ trueBlock->traverse(this);
+ }
+ }
+ else
+ {
+ if(falseBlock)
+ {
+ falseBlock->traverse(this);
+ }
+ }
+ }
+ else
+ {
+ emit(sw::Shader::OPCODE_IF, 0, condition);
+
+ if(trueBlock)
+ {
+ trueBlock->traverse(this);
+ }
+
+ if(falseBlock)
+ {
+ emit(sw::Shader::OPCODE_ELSE);
+ falseBlock->traverse(this);
+ }
+
+ emit(sw::Shader::OPCODE_ENDIF);
+ }
+ }
+
+ return false;
+ }
+
+ bool OutputASM::visitLoop(Visit visit, TIntermLoop *node)
+ {
+ if(currentScope != emitScope)
+ {
+ return false;
+ }
+
+ TIntermNode *init = node->getInit();
+ TIntermTyped *condition = node->getCondition();
+ TIntermTyped *expression = node->getExpression();
+ TIntermNode *body = node->getBody();
+
+ if(node->getType() == ELoopDoWhile)
+ {
+ Temporary iterate(this);
+ emit(sw::Shader::OPCODE_MOV, &iterate, &Constant(true));
+
+ emit(sw::Shader::OPCODE_WHILE, 0, &iterate); // FIXME: Implement real do-while
+
+ if(body)
+ {
+ body->traverse(this);
+ }
+
+ emit(sw::Shader::OPCODE_TEST);
+
+ condition->traverse(this);
+ emit(sw::Shader::OPCODE_MOV, &iterate, condition);
+
+ emit(sw::Shader::OPCODE_ENDWHILE);
+ }
+ else
+ {
+ if(init)
+ {
+ init->traverse(this);
+ }
+
+ condition->traverse(this);
+
+ emit(sw::Shader::OPCODE_WHILE, 0, condition);
+
+ if(body)
+ {
+ body->traverse(this);
+ }
+
+ emit(sw::Shader::OPCODE_TEST);
+
+ if(expression)
+ {
+ expression->traverse(this);
+ }
+
+ condition->traverse(this);
+
+ emit(sw::Shader::OPCODE_ENDWHILE);
+ }
+
+ return false;
+ }
+
+ bool OutputASM::visitBranch(Visit visit, TIntermBranch *node)
+ {
+ if(currentScope != emitScope)
+ {
+ return false;
+ }
+
+ switch(node->getFlowOp())
+ {
+ case EOpKill: if(visit == PostVisit) emit(sw::Shader::OPCODE_DISCARD); break;
+ case EOpBreak: if(visit == PostVisit) emit(sw::Shader::OPCODE_BREAK); break;
+ case EOpContinue: if(visit == PostVisit) emit(sw::Shader::OPCODE_CONTINUE); break;
+ case EOpReturn:
+ if(visit == PostVisit)
+ {
+ TIntermTyped *value = node->getExpression();
+
+ if(value)
+ {
+ copy(functionArray[currentFunction].ret, value);
+ }
+
+ emit(sw::Shader::OPCODE_LEAVE);
+ }
+ break;
+ default: UNREACHABLE();
+ }
+
+ return true;
+ }
+
+ Instruction *OutputASM::emit(sw::Shader::Opcode op, TIntermTyped *dst, TIntermNode *src0, TIntermNode *src1, TIntermNode *src2)
+ {
+ if(dst && registerType(dst) == sw::Shader::PARAMETER_SAMPLER)
+ {
+ op = sw::Shader::OPCODE_NOP; // Can't assign to a sampler, but this will be hit when indexing sampler arrays
+ }
+
+ Instruction *instruction = new Instruction(op);
+
+ if(dst)
+ {
+ instruction->dst.type = registerType(dst);
+ instruction->dst.index = registerIndex(dst);
+ instruction->dst.mask = writeMask(dst);
+ instruction->dst.integer = (dst->getBasicType() == EbtInt);
+ }
+
+ argument(instruction->src[0], src0);
+ argument(instruction->src[1], src1);
+ argument(instruction->src[2], src2);
+
+ shader->append(instruction);
+
+ return instruction;
+ }
+
+ void OutputASM::emitAssign(sw::Shader::Opcode op, TIntermTyped *result, TIntermTyped *lhs, TIntermTyped *src0, TIntermTyped *src1)
+ {
+ emit(op, result, src0, src1);
+ assignLvalue(lhs, result);
+ }
+
+ void OutputASM::emitCmp(sw::Shader::Control cmpOp, TIntermTyped *dst, TIntermNode *left, TIntermNode *right, int index)
+ {
+ bool boolean = (left->getAsTyped()->getBasicType() == EbtBool);
+ sw::Shader::Opcode opcode = boolean ? sw::Shader::OPCODE_ICMP : sw::Shader::OPCODE_CMP;
+
+ Instruction *cmp = emit(opcode, dst, left, right);
+ cmp->control = cmpOp;
+ argument(cmp->src[0], left, index);
+ argument(cmp->src[1], right, index);
+ }
+
+ int componentCount(const TType &type, int registers)
+ {
+ if(registers == 0)
+ {
+ return 0;
+ }
+
+ if(type.isArray() && registers >= type.elementRegisterCount())
+ {
+ int index = registers / type.elementRegisterCount();
+ registers -= index * type.elementRegisterCount();
+ return index * type.getElementSize() + componentCount(type, registers);
+ }
+
+ if(type.isStruct())
+ {
+ TTypeList *structure = type.getStruct();
+ int elements = 0;
+
+ for(TTypeList::const_iterator field = structure->begin(); field != structure->end(); field++)
+ {
+ const TType &fieldType = *field->type;
+
+ if(fieldType.totalRegisterCount() <= registers)
+ {
+ registers -= fieldType.totalRegisterCount();
+ elements += fieldType.getObjectSize();
+ }
+ else // Register within this field
+ {
+ return elements + componentCount(fieldType, registers);
+ }
+ }
+ }
+ else if(type.isMatrix())
+ {
+ return registers * type.getNominalSize();
+ }
+
+ UNREACHABLE();
+ return 0;
+ }
+
+ int registerSize(const TType &type, int registers)
+ {
+ if(registers == 0)
+ {
+ if(type.isStruct())
+ {
+ return registerSize(*type.getStruct()->begin()->type, 0);
+ }
+
+ return type.getNominalSize();
+ }
+
+ if(type.isArray() && registers >= type.elementRegisterCount())
+ {
+ int index = registers / type.elementRegisterCount();
+ registers -= index * type.elementRegisterCount();
+ return registerSize(type, registers);
+ }
+
+ if(type.isStruct())
+ {
+ TTypeList *structure = type.getStruct();
+ int elements = 0;
+
+ for(TTypeList::const_iterator field = structure->begin(); field != structure->end(); field++)
+ {
+ const TType &fieldType = *field->type;
+
+ if(fieldType.totalRegisterCount() <= registers)
+ {
+ registers -= fieldType.totalRegisterCount();
+ elements += fieldType.getObjectSize();
+ }
+ else // Register within this field
+ {
+ return registerSize(fieldType, registers);
+ }
+ }
+ }
+ else if(type.isMatrix())
+ {
+ return registerSize(type, 0);
+ }
+
+ UNREACHABLE();
+ return 0;
+ }
+
+ void OutputASM::argument(sw::Shader::SourceParameter ¶meter, TIntermNode *argument, int index)
+ {
+ if(argument)
+ {
+ TIntermTyped *arg = argument->getAsTyped();
+ const TType &type = arg->getType();
+ const TTypeList *structure = type.getStruct();
+ ASSERT(index < arg->totalRegisterCount());
+
+ int size = registerSize(type, index);
+
+ parameter.type = registerType(arg);
+
+ if(arg->getQualifier() == EvqConst)
+ {
+ int component = componentCount(type, index);
+ ConstantUnion *constants = arg->getAsConstantUnion()->getUnionArrayPointer();
+
+ for(int i = 0; i < 4; i++)
+ {
+ if(size == 1) // Replicate
+ {
+ parameter.value[i] = constants[component + 0].getAsFloat();
+ }
+ else if(i < size)
+ {
+ parameter.value[i] = constants[component + i].getAsFloat();
+ }
+ else
+ {
+ parameter.value[i] = 0.0f;
+ }
+ }
+ }
+ else
+ {
+ parameter.index = registerIndex(arg) + index;
+
+ if(registerType(arg) == sw::Shader::PARAMETER_SAMPLER)
+ {
+ TIntermBinary *binary = argument->getAsBinaryNode();
+
+ if(binary)
+ {
+ TIntermTyped *left = binary->getLeft();
+ TIntermTyped *right = binary->getRight();
+
+ if(binary->getOp() == EOpIndexDirect)
+ {
+ parameter.index += right->getAsConstantUnion()->getUnionArrayPointer()->getIConst();
+ }
+ else if(binary->getOp() == EOpIndexIndirect)
+ {
+ if(left->getArraySize() > 1)
+ {
+ parameter.rel.type = registerType(binary->getRight());
+ parameter.rel.index = registerIndex(binary->getRight());
+ parameter.rel.scale = 1;
+ parameter.rel.deterministic = true;
+ }
+ }
+ else UNREACHABLE();
+ }
+ }
+ }
+
+ if(!IsSampler(arg->getBasicType()))
+ {
+ parameter.swizzle = swizzleSize[size];
+ }
+ }
+ }
+
+ void OutputASM::copy(TIntermTyped *dst, TIntermNode *src, int offset)
+ {
+ for(int index = 0; index < dst->totalRegisterCount(); index++)
+ {
+ Instruction *mov = emit(sw::Shader::OPCODE_MOV, dst, src);
+ mov->dst.index += index;
+ mov->dst.mask = writeMask(dst, index);
+ argument(mov->src[0], src, offset + index);
+ }
+ }
+
+ int swizzleElement(int swizzle, int index)
+ {
+ return (swizzle >> (index * 2)) & 0x03;
+ }
+
+ int swizzleSwizzle(int leftSwizzle, int rightSwizzle)
+ {
+ return (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 0)) << 0) |
+ (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 1)) << 2) |
+ (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 2)) << 4) |
+ (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 3)) << 6);
+ }
+
+ void OutputASM::assignLvalue(TIntermTyped *dst, TIntermNode *src)
+ {
+ TIntermBinary *binary = dst->getAsBinaryNode();
+
+ if(binary && binary->getOp() == EOpIndexIndirect && dst->isScalar())
+ {
+ Instruction *insert = new Instruction(sw::Shader::OPCODE_INSERT);
+
+ Temporary address(this);
+ lvalue(insert->dst, address, dst);
+
+ insert->src[0].type = insert->dst.type;
+ insert->src[0].index = insert->dst.index;
+ insert->src[0].rel = insert->dst.rel;
+ argument(insert->src[1], src);
+ argument(insert->src[2], binary->getRight());
+
+ shader->append(insert);
+ }
+ else
+ {
+ for(int offset = 0; offset < dst->totalRegisterCount(); offset++)
+ {
+ Instruction *mov = new Instruction(sw::Shader::OPCODE_MOV);
+
+ Temporary address(this);
+ int swizzle = lvalue(mov->dst, address, dst);
+ mov->dst.index += offset;
+
+ if(offset > 0)
+ {
+ mov->dst.mask = writeMask(dst, offset);
+ }
+
+ argument(mov->src[0], src, offset);
+ mov->src[0].swizzle = swizzleSwizzle(mov->src[0].swizzle, swizzle);
+
+ shader->append(mov);
+ }
+ }
+ }
+
+ int OutputASM::lvalue(sw::Shader::DestinationParameter &dst, Temporary &address, TIntermTyped *node)
+ {
+ TIntermTyped *result = node;
+ TIntermBinary *binary = node->getAsBinaryNode();
+ TIntermSymbol *symbol = node->getAsSymbolNode();
+
+ if(binary)
+ {
+ TIntermTyped *left = binary->getLeft();
+ TIntermTyped *right = binary->getRight();
+
+ int leftSwizzle = lvalue(dst, address, left); // Resolve the l-value of the left side
+
+ switch(binary->getOp())
+ {
+ case EOpIndexDirect:
+ {
+ int rightIndex = right->getAsConstantUnion()->getUnionArrayPointer()->getIConst();
+
+ if(left->isRegister())
+ {
+ int leftMask = dst.mask;
+
+ dst.mask = 1;
+ while((leftMask & dst.mask) == 0)
+ {
+ dst.mask = dst.mask << 1;
+ }
+
+ int element = swizzleElement(leftSwizzle, rightIndex);
+ dst.mask = 1 << element;
+
+ return element;
+ }
+ else if(left->isArray() || left->isMatrix())
+ {
+ dst.index += rightIndex * result->totalRegisterCount();
+ return 0xE4;
+ }
+ else UNREACHABLE();
+ }
+ break;
+ case EOpIndexIndirect:
+ {
+ if(left->isRegister())
+ {
+ // Requires INSERT instruction (handled by calling function)
+ }
+ else if(left->isArray() || left->isMatrix())
+ {
+ int scale = result->totalRegisterCount();
+
+ if(dst.rel.type == sw::Shader::PARAMETER_VOID) // Use the index register as the relative address directly
+ {
+ if(left->totalRegisterCount() > 1)
+ {
+ sw::Shader::SourceParameter relativeRegister;
+ argument(relativeRegister, right);
+
+ dst.rel.index = relativeRegister.index;
+ dst.rel.type = relativeRegister.type;
+ dst.rel.scale = scale;
+ dst.rel.deterministic = !(vertexShader && left->getQualifier() == EvqUniform);
+ }
+ }
+ else if(dst.rel.index != registerIndex(&address)) // Move the previous index register to the address register
+ {
+ if(scale == 1)
+ {
+ Instruction *mad = emit(sw::Shader::OPCODE_MAD, &address, &address, &Constant((int)dst.rel.scale), right);
+ mad->src[0].index = dst.rel.index;
+ mad->src[0].type = dst.rel.type;
+ }
+ else
+ {
+ Instruction *mul = emit(sw::Shader::OPCODE_MUL, &address, &address, &Constant((int)dst.rel.scale));
+ mul->src[0].index = dst.rel.index;
+ mul->src[0].type = dst.rel.type;
+
+ emit(sw::Shader::OPCODE_MAD, &address, right, &Constant(scale), &address);
+ }
+
+ dst.rel.type = sw::Shader::PARAMETER_TEMP;
+ dst.rel.index = registerIndex(&address);
+ dst.rel.scale = 1;
+ }
+ else // Just add the new index to the address register
+ {
+ if(scale == 1)
+ {
+ emit(sw::Shader::OPCODE_ADD, &address, &address, right);
+ }
+ else
+ {
+ emit(sw::Shader::OPCODE_MAD, &address, right, &Constant(scale), &address);
+ }
+ }
+ }
+ else UNREACHABLE();
+ }
+ break;
+ case EOpIndexDirectStruct:
+ {
+ const TTypeList *structure = left->getType().getStruct();
+ const TString &fieldName = right->getType().getFieldName();
+
+ int offset = 0;
+ for(TTypeList::const_iterator field = structure->begin(); field != structure->end(); field++)
+ {
+ if(field->type->getFieldName() == fieldName)
+ {
+ dst.type = registerType(left);
+ dst.index += offset;
+ dst.mask = writeMask(right);
+
+ return 0xE4;
+ }
+
+ offset += field->type->totalRegisterCount();
+ }
+ }
+ break;
+ case EOpVectorSwizzle:
+ {
+ ASSERT(left->isRegister());
+
+ int leftMask = dst.mask;
+
+ int swizzle = 0;
+ int rightMask = 0;
+
+ TIntermSequence &sequence = right->getAsAggregate()->getSequence();
+
+ for(unsigned int i = 0; i < sequence.size(); i++)
+ {
+ int index = sequence[i]->getAsConstantUnion()->getUnionArrayPointer()->getIConst();
+
+ int element = swizzleElement(leftSwizzle, index);
+ rightMask = rightMask | (1 << element);
+ swizzle = swizzle | swizzleElement(leftSwizzle, i) << (element * 2);
+ }
+
+ dst.mask = leftMask & rightMask;
+
+ return swizzle;
+ }
+ break;
+ default:
+ UNREACHABLE(); // Not an l-value operator
+ break;
+ }
+ }
+ else if(symbol)
+ {
+ dst.type = registerType(symbol);
+ dst.index = registerIndex(symbol);
+ dst.mask = writeMask(symbol);
+ return 0xE4;
+ }
+
+ return 0xE4;
+ }
+
+ sw::Shader::ParameterType OutputASM::registerType(TIntermTyped *operand)
+ {
+ if(IsSampler(operand->getBasicType()) && (operand->getQualifier() == EvqUniform || operand->getQualifier() == EvqTemporary)) // Function parameters are temporaries
+ {
+ return sw::Shader::PARAMETER_SAMPLER;
+ }
+
+ switch(operand->getQualifier())
+ {
+ case EvqTemporary: return sw::Shader::PARAMETER_TEMP;
+ case EvqGlobal: return sw::Shader::PARAMETER_TEMP;
+ case EvqConst: return sw::Shader::PARAMETER_FLOAT4LITERAL; // All converted to float
+ case EvqAttribute: return sw::Shader::PARAMETER_INPUT;
+ case EvqVaryingIn: return sw::Shader::PARAMETER_INPUT;
+ case EvqVaryingOut: return sw::Shader::PARAMETER_OUTPUT;
+ case EvqInvariantVaryingIn: return sw::Shader::PARAMETER_INPUT; // FIXME: Guarantee invariance at the backend
+ case EvqInvariantVaryingOut: return sw::Shader::PARAMETER_OUTPUT; // FIXME: Guarantee invariance at the backend
+ case EvqUniform: return sw::Shader::PARAMETER_CONST;
+ case EvqIn: return sw::Shader::PARAMETER_TEMP;
+ case EvqOut: return sw::Shader::PARAMETER_TEMP;
+ case EvqInOut: return sw::Shader::PARAMETER_TEMP;
+ case EvqConstReadOnly: return sw::Shader::PARAMETER_TEMP;
+ case EvqPosition: return sw::Shader::PARAMETER_OUTPUT;
+ case EvqPointSize: return sw::Shader::PARAMETER_OUTPUT;
+ case EvqFragCoord: return sw::Shader::PARAMETER_MISCTYPE;
+ case EvqFrontFacing: return sw::Shader::PARAMETER_MISCTYPE;
+ case EvqPointCoord: return sw::Shader::PARAMETER_INPUT;
+ case EvqFragColor: return sw::Shader::PARAMETER_COLOROUT;
+ case EvqFragData: return sw::Shader::PARAMETER_COLOROUT;
+ default: UNREACHABLE();
+ }
+
+ return sw::Shader::PARAMETER_VOID;
+ }
+
+ int OutputASM::registerIndex(TIntermTyped *operand)
+ {
+ if(registerType(operand) == sw::Shader::PARAMETER_SAMPLER)
+ {
+ return samplerRegister(operand);
+ }
+
+ switch(operand->getQualifier())
+ {
+ case EvqTemporary: return temporaryRegister(operand);
+ case EvqGlobal: return temporaryRegister(operand);
+ case EvqConst: UNREACHABLE();
+ case EvqAttribute: return attributeRegister(operand);
+ case EvqVaryingIn: return varyingRegister(operand);
+ case EvqVaryingOut: return varyingRegister(operand);
+ case EvqInvariantVaryingIn: return varyingRegister(operand);
+ case EvqInvariantVaryingOut: return varyingRegister(operand);
+ case EvqUniform: return uniformRegister(operand);
+ case EvqIn: return temporaryRegister(operand);
+ case EvqOut: return temporaryRegister(operand);
+ case EvqInOut: return temporaryRegister(operand);
+ case EvqConstReadOnly: return temporaryRegister(operand);
+ case EvqPosition: return varyingRegister(operand);
+ case EvqPointSize: return varyingRegister(operand);
+ case EvqFragCoord: pixelShader->vPosDeclared = true; return 0;
+ case EvqFrontFacing: pixelShader->vFaceDeclared = true; return 1;
+ case EvqPointCoord: return varyingRegister(operand);
+ case EvqFragColor: return 0;
+ case EvqFragData: return 0;
+ default: UNREACHABLE();
+ }
+
+ return 0;
+ }
+
+ int OutputASM::writeMask(TIntermTyped *destination, int index)
+ {
+ if(destination->getQualifier() == EvqPointSize)
+ {
+ return 0x2; // Point size stored in the y component
+ }
+
+ return 0xF >> (4 - registerSize(destination->getType(), index));
+ }
+
+ // Conservatively checks whether an expression is fast to compute and has no side effects
+ bool OutputASM::trivial(TIntermTyped *expression, int budget)
+ {
+ if(!expression->isRegister())
+ {
+ return false;
+ }
+
+ return cost(expression, budget) >= 0;
+ }
+
+ // Returns the remaining computing budget (if < 0 the expression is too expensive or has side effects)
+ int OutputASM::cost(TIntermNode *expression, int budget)
+ {
+ if(budget < 0)
+ {
+ return budget;
+ }
+
+ if(expression->getAsSymbolNode())
+ {
+ return budget;
+ }
+ else if(expression->getAsConstantUnion())
+ {
+ return budget;
+ }
+ else if(expression->getAsBinaryNode())
+ {
+ TIntermBinary *binary = expression->getAsBinaryNode();
+
+ switch(binary->getOp())
+ {
+ case EOpVectorSwizzle:
+ case EOpIndexDirect:
+ case EOpIndexDirectStruct:
+ return cost(binary->getLeft(), budget - 0);
+ case EOpAdd:
+ case EOpSub:
+ case EOpMul:
+ return cost(binary->getLeft(), cost(binary->getRight(), budget - 1));
+ default:
+ return -1;
+ }
+ }
+ else if(expression->getAsUnaryNode())
+ {
+ TIntermUnary *unary = expression->getAsUnaryNode();
+
+ switch(unary->getOp())
+ {
+ case EOpAbs:
+ case EOpNegative:
+ return cost(unary->getOperand(), budget - 1);
+ default:
+ return -1;
+ }
+ }
+ else if(expression->getAsSelectionNode())
+ {
+ TIntermSelection *selection = expression->getAsSelectionNode();
+
+ if(selection->usesTernaryOperator())
+ {
+ TIntermTyped *condition = selection->getCondition();
+ TIntermNode *trueBlock = selection->getTrueBlock();
+ TIntermNode *falseBlock = selection->getFalseBlock();
+ TIntermConstantUnion *constantCondition = condition->getAsConstantUnion();
+
+ if(constantCondition)
+ {
+ bool trueCondition = constantCondition->getUnionArrayPointer()->getBConst();
+
+ if(trueCondition)
+ {
+ return cost(trueBlock, budget - 0);
+ }
+ else
+ {
+ return cost(falseBlock, budget - 0);
+ }
+ }
+ else
+ {
+ return cost(trueBlock, cost(falseBlock, budget - 2));
+ }
+ }
+ }
+
+ return -1;
+ }
+
+ const Function &OutputASM::findFunction(const TString &name)
+ {
+ for(unsigned int f = 0; f < functionArray.size(); f++)
+ {
+ if(functionArray[f].name == name)
+ {
+ return functionArray[f];
+ }
+ }
+
+ UNREACHABLE();
+ return functionArray[0];
+ }
+
+ int OutputASM::temporaryRegister(TIntermTyped *temporary)
+ {
+ return allocate(temporaries, temporary);
+ }
+
+ int OutputASM::varyingRegister(TIntermTyped *varying)
+ {
+ int var = lookup(varyings, varying);
+
+ if(var == -1)
+ {
+ var = allocate(varyings, varying);
+ const TType &type = varying->getType();
+ int size = varying->getNominalSize();
+
+ if(pixelShader)
+ {
+ if(varying->getQualifier() == EvqPointCoord)
+ {
+ ASSERT(varying->isRegister());
+ if(size >= 1) pixelShader->semantic[var][0] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);
+ if(size >= 2) pixelShader->semantic[var][1] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);
+ if(size >= 3) pixelShader->semantic[var][2] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);
+ if(size >= 4) pixelShader->semantic[var][3] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);
+ }
+ else
+ {
+ for(int i = 0; i < varying->totalRegisterCount(); i++)
+ {
+ if(size >= 1) pixelShader->semantic[var + i][0] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);
+ if(size >= 2) pixelShader->semantic[var + i][1] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);
+ if(size >= 3) pixelShader->semantic[var + i][2] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);
+ if(size >= 4) pixelShader->semantic[var + i][3] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);
+ }
+ }
+ }
+ else if(vertexShader) // Semantic indexes will be reassigned during program link to match the pixel shader
+ {
+ if(varying->getQualifier() == EvqPosition)
+ {
+ ASSERT(varying->isRegister());
+ vertexShader->output[var][0] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);
+ vertexShader->output[var][1] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);
+ vertexShader->output[var][2] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);
+ vertexShader->output[var][3] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);
+ vertexShader->positionRegister = var;
+ }
+ else if(varying->getQualifier() == EvqPointSize)
+ {
+ ASSERT(varying->isRegister());
+ vertexShader->output[var][0] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);
+ vertexShader->output[var][1] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);
+ vertexShader->output[var][2] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);
+ vertexShader->output[var][3] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);
+ vertexShader->pointSizeRegister = var;
+ }
+ }
+ else UNREACHABLE();
+
+ if(varying->getQualifier() != EvqPointCoord) // gl_PointCoord does not need linking
+ {
+ gl::VaryingList &activeVaryings = shaderObject->varyings;
+ const char *name = varying->getAsSymbolNode()->getSymbol().c_str();
+ activeVaryings.push_back(gl::Varying(glVariableType(type), name, varying->getArraySize(), var, 0));
+ }
+ }
+
+ return var;
+ }
+
+ int OutputASM::uniformRegister(TIntermTyped *uniform)
+ {
+ const TType &type = uniform->getType();
+ ASSERT(!IsSampler(type.getBasicType()));
+ TIntermSymbol *symbol = uniform->getAsSymbolNode();
+ ASSERT(symbol);
+
+ if(symbol)
+ {
+ int index = lookup(uniforms, uniform);
+
+ if(index == -1)
+ {
+ index = allocate(uniforms, uniform);
+ const TString &name = symbol->getSymbol().c_str();
+
+ declareUniform(type, name, index);
+ }
+
+ return index;
+ }
+
+ return 0;
+ }
+
+ int OutputASM::attributeRegister(TIntermTyped *attribute)
+ {
+ ASSERT(!attribute->isArray());
+ ASSERT(attribute->getBasicType() == EbtFloat);
+
+ int index = lookup(attributes, attribute);
+
+ if(index == -1)
+ {
+ TIntermSymbol *symbol = attribute->getAsSymbolNode();
+ ASSERT(symbol);
+
+ if(symbol)
+ {
+ index = allocate(attributes, attribute);
+ const TType &type = attribute->getType();
+
+ sw::VertexShader *vertexShader = static_cast<sw::VertexShader*>(shader);
+
+ for(int i = 0; i < attribute->totalRegisterCount(); i++)
+ {
+ vertexShader->input[index + i] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, index + i);
+ }
+
+ ActiveAttributes &activeAttributes = shaderObject->activeAttributes;
+
+ const char *name = symbol->getSymbol().c_str();
+ activeAttributes.push_back(Attribute(glVariableType(type), name, 0, index));
+ }
+ }
+
+ return index;
+ }
+
+ int OutputASM::samplerRegister(TIntermTyped *sampler)
+ {
+ const TType &type = sampler->getType();
+ ASSERT(IsSampler(type.getBasicType()));
+ const TTypeList *structure = type.getStruct();
+ TIntermSymbol *symbol = sampler->getAsSymbolNode();
+ TIntermBinary *binary = sampler->getAsBinaryNode();
+
+ if(symbol)
+ {
+ int index = lookup(samplers, sampler);
+
+ if(index == -1)
+ {
+ index = allocate(samplers, sampler);
+ ActiveUniforms &activeUniforms = shaderObject->activeUniforms;
+ const char *name = symbol->getSymbol().c_str();
+ activeUniforms.push_back(Uniform(glVariableType(type), name, sampler->getArraySize(), index));
+
+ for(int i = 0; i < sampler->totalRegisterCount(); i++)
+ {
+ shader->declareSampler(i);
+ }
+ }
+
+ return index;
+ }
+ else if(binary)
+ {
+ ASSERT(binary->getOp() == EOpIndexDirect || binary->getOp() == EOpIndexIndirect);
+
+ return samplerRegister(binary->getLeft()); // Index added later
+ }
+ else UNREACHABLE();
+
+ return 0;
+ }
+
+ int OutputASM::lookup(VariableArray &list, TIntermTyped *variable)
+ {
+ for(unsigned int i = 0; i < list.size(); i++)
+ {
+ if(list[i] == variable)
+ {
+ return i; // Pointer match
+ }
+ }
+
+ TIntermSymbol *varSymbol = variable->getAsSymbolNode();
+
+ if(varSymbol)
+ {
+ for(unsigned int i = 0; i < list.size(); i++)
+ {
+ if(list[i])
+ {
+ TIntermSymbol *listSymbol = list[i]->getAsSymbolNode();
+
+ if(listSymbol)
+ {
+ if(listSymbol->getId() == varSymbol->getId())
+ {
+ ASSERT(listSymbol->getSymbol() == varSymbol->getSymbol());
+ ASSERT(listSymbol->getType() == varSymbol->getType());
+ ASSERT(listSymbol->getQualifier() == varSymbol->getQualifier());
+
+ return i;
+ }
+ }
+ }
+ }
+ }
+
+ return -1;
+ }
+
+ int OutputASM::allocate(VariableArray &list, TIntermTyped *variable)
+ {
+ int index = lookup(list, variable);
+
+ if(index == -1)
+ {
+ unsigned int registerCount = variable->totalRegisterCount();
+
+ for(unsigned int i = 0; i < list.size(); i++)
+ {
+ if(list[i] == 0)
+ {
+ unsigned int j = 1;
+ for( ; j < registerCount && (i + j) < list.size(); j++)
+ {
+ if(list[i + j] != 0)
+ {
+ break;
+ }
+ }
+
+ if(j == registerCount) // Found free slots
+ {
+ for(unsigned int j = 0; j < registerCount; j++)
+ {
+ list[i + j] = variable;
+ }
+
+ return i;
+ }
+ }
+ }
+
+ index = list.size();
+
+ for(unsigned int i = 0; i < registerCount; i++)
+ {
+ list.push_back(variable);
+ }
+ }
+
+ return index;
+ }
+
+ void OutputASM::free(VariableArray &list, TIntermTyped *variable)
+ {
+ int index = lookup(list, variable);
+
+ if(index >= 0)
+ {
+ list[index] = 0;
+ }
+ }
+
+ void OutputASM::declareUniform(const TType &type, const TString &name, int index)
+ {
+ const TTypeList *structure = type.getStruct();
+ ActiveUniforms &activeUniforms = shaderObject->activeUniforms;
+
+ if(!structure)
+ {
+ activeUniforms.push_back(Uniform(glVariableType(type), name.c_str(), type.getArraySize(), index));
+ }
+ else
+ {
+ if(type.isArray())
+ {
+ int elementIndex = index;
+
+ for(int i = 0; i < type.getArraySize(); i++)
+ {
+ for(size_t j = 0; j < structure->size(); j++)
+ {
+ const TType &fieldType = *(*structure)[j].type;
+ const TString &fieldName = fieldType.getFieldName();
+
+ const TString uniformName = name + "[" + str(i) + "]." + fieldName;
+ declareUniform(fieldType, uniformName, elementIndex);
+ elementIndex += fieldType.elementRegisterCount();
+ }
+ }
+ }
+ else
+ {
+ int fieldIndex = index;
+
+ for(size_t i = 0; i < structure->size(); i++)
+ {
+ const TType &fieldType = *(*structure)[i].type;
+ const TString &fieldName = fieldType.getFieldName();
+
+ const TString uniformName = name + "." + fieldName;
+ declareUniform(fieldType, uniformName, fieldIndex);
+ fieldIndex += fieldType.totalRegisterCount();
+ }
+ }
+ }
+ }
+
+ GLenum OutputASM::glVariableType(const TType &type)
+ {
+ if(type.getBasicType() == EbtFloat)
+ {
+ if(type.isScalar())
+ {
+ return GL_FLOAT;
+ }
+ else if(type.isVector())
+ {
+ switch(type.getNominalSize())
+ {
+ case 2: return GL_FLOAT_VEC2;
+ case 3: return GL_FLOAT_VEC3;
+ case 4: return GL_FLOAT_VEC4;
+ default: UNREACHABLE();
+ }
+ }
+ else if(type.isMatrix())
+ {
+ switch(type.getNominalSize())
+ {
+ case 2: return GL_FLOAT_MAT2;
+ case 3: return GL_FLOAT_MAT3;
+ case 4: return GL_FLOAT_MAT4;
+ default: UNREACHABLE();
+ }
+ }
+ else UNREACHABLE();
+ }
+ else if(type.getBasicType() == EbtInt)
+ {
+ if(type.isScalar())
+ {
+ return GL_INT;
+ }
+ else if(type.isVector())
+ {
+ switch(type.getNominalSize())
+ {
+ case 2: return GL_INT_VEC2;
+ case 3: return GL_INT_VEC3;
+ case 4: return GL_INT_VEC4;
+ default: UNREACHABLE();
+ }
+ }
+ else UNREACHABLE();
+ }
+ else if(type.getBasicType() == EbtBool)
+ {
+ if(type.isScalar())
+ {
+ return GL_BOOL;
+ }
+ else if(type.isVector())
+ {
+ switch(type.getNominalSize())
+ {
+ case 2: return GL_BOOL_VEC2;
+ case 3: return GL_BOOL_VEC3;
+ case 4: return GL_BOOL_VEC4;
+ default: UNREACHABLE();
+ }
+ }
+ else UNREACHABLE();
+ }
+ else if(type.getBasicType() == EbtInt)
+ {
+ if(type.isScalar())
+ {
+ return GL_INT;
+ }
+ else if(type.isVector())
+ {
+ switch(type.getNominalSize())
+ {
+ case 2: return GL_INT_VEC2;
+ case 3: return GL_INT_VEC3;
+ case 4: return GL_INT_VEC4;
+ default: UNREACHABLE();
+ }
+ }
+ else UNREACHABLE();
+ }
+ else if(type.getBasicType() == EbtBool)
+ {
+ if(type.isScalar())
+ {
+ return GL_BOOL;
+ }
+ else if(type.isVector())
+ {
+ switch(type.getNominalSize())
+ {
+ case 2: return GL_BOOL_VEC2;
+ case 3: return GL_BOOL_VEC3;
+ case 4: return GL_BOOL_VEC4;
+ default: UNREACHABLE();
+ }
+ }
+ else UNREACHABLE();
+ }
+ else if(type.getBasicType() == EbtSampler2D)
+ {
+ return GL_SAMPLER_2D;
+ }
+ else if(type.getBasicType() == EbtSamplerCube)
+ {
+ return GL_SAMPLER_CUBE;
+ }
+ else UNREACHABLE();
+
+ return GL_NONE;
+ }
+
+ int OutputASM::dim(TIntermNode *v)
+ {
+ TIntermTyped *vector = v->getAsTyped();
+ ASSERT(vector && vector->isRegister());
+ return vector->getNominalSize();
+ }
+
+ int OutputASM::dim2(TIntermNode *m)
+ {
+ TIntermTyped *matrix = m->getAsTyped();
+ ASSERT(matrix && matrix->isMatrix() && !matrix->isArray());
+ return matrix->getNominalSize();
+ }
+}
diff --git a/src/OpenGL ES 2.0/compiler/OutputASM.h b/src/OpenGL ES 2.0/compiler/OutputASM.h
new file mode 100644
index 0000000..ab0ba34
--- /dev/null
+++ b/src/OpenGL ES 2.0/compiler/OutputASM.h
@@ -0,0 +1,160 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#ifndef COMPILER_OUTPUTASM_H_
+#define COMPILER_OUTPUTASM_H_
+
+#include "intermediate.h"
+#include "ParseHelper.h"
+#include "Shader/PixelShader.hpp"
+#include "Shader/VertexShader.hpp"
+
+#define GL_APICALL
+#include <GLES2/gl2.h>
+
+#include <list>
+#include <set>
+#include <map>
+
+namespace gl
+{
+ class Shader;
+}
+
+namespace sh
+{
+ struct Uniform
+ {
+ Uniform(GLenum type, const std::string &name, int arraySize, int registerIndex);
+
+ GLenum type;
+ std::string name;
+ int arraySize;
+
+ int registerIndex;
+ };
+
+ typedef std::vector<Uniform> ActiveUniforms;
+
+ struct Attribute
+ {
+ Attribute();
+ Attribute(GLenum type, const std::string &name, int arraySize, int registerIndex);
+
+ GLenum type;
+ std::string name;
+ int arraySize;
+
+ int registerIndex;
+ };
+
+ struct Function
+ {
+ Function(int label, const char *name, TIntermSequence *arg, TIntermTyped *ret) : label(label), name(name), arg(arg), ret(ret)
+ {
+ }
+
+ Function(int label, const TString &name, TIntermSequence *arg, TIntermTyped *ret) : label(label), name(name), arg(arg), ret(ret)
+ {
+ }
+
+ const int label;
+ const TString name;
+ TIntermSequence *const arg;
+ TIntermTyped *const ret;
+ };
+
+ typedef sw::Shader::Instruction Instruction;
+ typedef std::vector<Attribute> ActiveAttributes;
+
+ class Temporary;
+
+ class OutputASM : public TIntermTraverser
+ {
+ public:
+ explicit OutputASM(TParseContext &context, gl::Shader *shaderObject);
+ ~OutputASM();
+
+ void output();
+
+ void freeTemporary(Temporary *temporary);
+
+ protected:
+ enum Scope
+ {
+ GLOBAL,
+ FUNCTION
+ };
+
+ void emitShader(Scope scope);
+
+ // Visit AST nodes and output their code to the body stream
+ virtual bool visitBinary(Visit visit, TIntermBinary*);
+ virtual bool visitUnary(Visit visit, TIntermUnary*);
+ virtual bool visitSelection(Visit visit, TIntermSelection*);
+ virtual bool visitAggregate(Visit visit, TIntermAggregate*);
+ virtual bool visitLoop(Visit visit, TIntermLoop*);
+ virtual bool visitBranch(Visit visit, TIntermBranch*);
+
+ Instruction *emit(sw::Shader::Opcode op, TIntermTyped *dst = 0, TIntermNode *src0 = 0, TIntermNode *src1 = 0, TIntermNode *src2 = 0);
+ void emitAssign(sw::Shader::Opcode op, TIntermTyped *result, TIntermTyped *lhs, TIntermTyped *src0, TIntermTyped *src1 = 0);
+ void emitCmp(sw::Shader::Control cmpOp, TIntermTyped *dst, TIntermNode *left, TIntermNode *right, int index = 0);
+ void argument(sw::Shader::SourceParameter ¶meter, TIntermNode *argument, int index = 0);
+ void copy(TIntermTyped *dst, TIntermNode *src, int offset = 0);
+ void assignLvalue(TIntermTyped *dst, TIntermNode *src);
+ int lvalue(sw::Shader::DestinationParameter &dst, Temporary &address, TIntermTyped *node);
+ sw::Shader::ParameterType registerType(TIntermTyped *operand);
+ int registerIndex(TIntermTyped *operand);
+ int writeMask(TIntermTyped *destination, int index = 0);
+ bool trivial(TIntermTyped *expression, int budget); // Fast to compute and no side effects
+ int cost(TIntermNode *expression, int budget);
+ const Function &findFunction(const TString &name);
+
+ int temporaryRegister(TIntermTyped *temporary);
+ int varyingRegister(TIntermTyped *varying);
+ int uniformRegister(TIntermTyped *uniform);
+ int attributeRegister(TIntermTyped *attribute);
+ int samplerRegister(TIntermTyped *sampler);
+
+ typedef std::vector<TIntermTyped*> VariableArray;
+
+ int lookup(VariableArray &list, TIntermTyped *variable);
+ int allocate(VariableArray &list, TIntermTyped *variable);
+ void free(VariableArray &list, TIntermTyped *variable);
+
+ void declareUniform(const TType &type, const TString &name, int index);
+ GLenum glVariableType(const TType &type);
+
+ static int dim(TIntermNode *v);
+ static int dim2(TIntermNode *m);
+
+ gl::Shader *const shaderObject;
+ sw::Shader *shader;
+ sw::PixelShader *pixelShader;
+ sw::VertexShader *vertexShader;
+
+ VariableArray temporaries;
+ VariableArray uniforms;
+ VariableArray varyings;
+ VariableArray attributes;
+ VariableArray samplers;
+
+ Scope emitScope;
+ Scope currentScope;
+
+ int currentFunction;
+ std::vector<Function> functionArray;
+
+ TParseContext &mContext;
+ };
+}
+
+#endif // COMPILER_OUTPUTASM_H_
diff --git a/src/OpenGL ES 2.0/compiler/ParseHelper.cpp b/src/OpenGL ES 2.0/compiler/ParseHelper.cpp
index ab7c182..2fa9ba5 100644
--- a/src/OpenGL ES 2.0/compiler/ParseHelper.cpp
+++ b/src/OpenGL ES 2.0/compiler/ParseHelper.cpp
@@ -1,5 +1,5 @@
//
-// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
@@ -462,10 +462,8 @@
}
}
if (identifier.find("__") != TString::npos) {
- //error(line, "Two consecutive underscores are reserved for future use.", identifier.c_str(), "", "");
- //return true;
- infoSink.info.message(EPrefixWarning, "Two consecutive underscores are reserved for future use.", line);
- return false;
+ error(line, "identifiers containing two consecutive underscores (__) are reserved as possible future keywords", identifier.c_str(), "", "");
+ return true;
}
}
@@ -552,7 +550,7 @@
return true;
}
- if (!type->isMatrix()) {
+ if (!type->isMatrix() || !matrixInMatrix) {
if ((op != EOpConstructStruct && size != 1 && size < type->getObjectSize()) ||
(op == EOpConstructStruct && size < type->getObjectSize())) {
error(line, "not enough data provided for construction", "constructor", "");
diff --git a/src/OpenGL ES 2.0/compiler/PoolAlloc.h b/src/OpenGL ES 2.0/compiler/PoolAlloc.h
index 55e09db..c33dfd9 100644
--- a/src/OpenGL ES 2.0/compiler/PoolAlloc.h
+++ b/src/OpenGL ES 2.0/compiler/PoolAlloc.h
@@ -253,12 +253,18 @@
pointer address(reference x) const { return &x; }
const_pointer address(const_reference x) const { return &x; }
- pool_allocator() : allocator(GlobalPoolAllocator) { }
- pool_allocator(TPoolAllocator& a) : allocator(a) { }
+ pool_allocator() : allocator(&GlobalPoolAllocator) { }
+ pool_allocator(TPoolAllocator& a) : allocator(&a) { }
pool_allocator(const pool_allocator<T>& p) : allocator(p.allocator) { }
+ template <class Other>
+ pool_allocator<T>& operator=(const pool_allocator<Other>& p) {
+ allocator = p.allocator;
+ return *this;
+ }
+
template<class Other>
- pool_allocator(const pool_allocator<Other>& p) : allocator(p.getAllocator()) { }
+ pool_allocator(const pool_allocator<Other>& p) : allocator(&p.getAllocator()) { }
#if defined(__SUNPRO_CC) && !defined(_RWSTD_ALLOCATOR)
// libCStd on some platforms have a different allocate/deallocate interface.
@@ -290,11 +296,11 @@
size_type max_size() const { return static_cast<size_type>(-1) / sizeof(T); }
size_type max_size(int size) const { return static_cast<size_type>(-1) / size; }
- void setAllocator(TPoolAllocator* a) { allocator = *a; }
- TPoolAllocator& getAllocator() const { return allocator; }
+ void setAllocator(TPoolAllocator *a) { allocator = a; }
+ TPoolAllocator& getAllocator() const { return *allocator; }
protected:
- TPoolAllocator& allocator;
+ TPoolAllocator *allocator;
};
#endif // _POOLALLOC_INCLUDED_
diff --git a/src/OpenGL ES 2.0/compiler/ShHandle.h b/src/OpenGL ES 2.0/compiler/ShHandle.h
index 17e2fe0..28263b7 100644
--- a/src/OpenGL ES 2.0/compiler/ShHandle.h
+++ b/src/OpenGL ES 2.0/compiler/ShHandle.h
@@ -57,7 +57,6 @@
TInfoSink& getInfoSink() { return infoSink; }
const TVariableInfoList& getAttribs() const { return attribs; }
const TVariableInfoList& getUniforms() const { return uniforms; }
- int getMappedNameMaxLength() const;
protected:
ShShaderType getShaderType() const { return shaderType; }
@@ -73,8 +72,6 @@
bool validateLimitations(TIntermNode* root);
// Collect info for all attribs and uniforms.
void collectAttribsUniforms(TIntermNode* root);
- // Map long variable names into shorter ones.
- void mapLongVariableNames(TIntermNode* root);
// Translate to object code.
virtual void translate(TIntermNode* root) = 0;
diff --git a/src/OpenGL ES 2.0/compiler/ShaderLang.cpp b/src/OpenGL ES 2.0/compiler/ShaderLang.cpp
index 051e4ec..4fd7cae 100644
--- a/src/OpenGL ES 2.0/compiler/ShaderLang.cpp
+++ b/src/OpenGL ES 2.0/compiler/ShaderLang.cpp
@@ -37,8 +37,7 @@
int* length,
int* size,
ShDataType* type,
- char* name,
- char* mappedName)
+ char* name)
{
if (!handle || !size || !type || !name)
return;
@@ -60,8 +59,6 @@
*size = varInfo.size;
*type = varInfo.type;
strcpy(name, varInfo.name.c_str());
- if (mappedName)
- strcpy(mappedName, varInfo.mappedName.c_str());
}
//
@@ -197,9 +194,6 @@
case SH_ACTIVE_ATTRIBUTE_MAX_LENGTH:
*params = getVariableMaxLength(compiler->getAttribs());
break;
- case SH_MAPPED_NAME_MAX_LENGTH:
- *params = compiler->getMappedNameMaxLength();
- break;
default: UNREACHABLE();
}
}
@@ -241,11 +235,10 @@
int* length,
int* size,
ShDataType* type,
- char* name,
- char* mappedName)
+ char* name)
{
getVariableInfo(SH_ACTIVE_ATTRIBUTES,
- handle, index, length, size, type, name, mappedName);
+ handle, index, length, size, type, name);
}
void ShGetActiveUniform(const ShHandle handle,
@@ -253,9 +246,8 @@
int* length,
int* size,
ShDataType* type,
- char* name,
- char* mappedName)
+ char* name)
{
getVariableInfo(SH_ACTIVE_UNIFORMS,
- handle, index, length, size, type, name, mappedName);
+ handle, index, length, size, type, name);
}
diff --git a/src/OpenGL ES 2.0/compiler/SymbolTable.h b/src/OpenGL ES 2.0/compiler/SymbolTable.h
index 38bc657..5789240 100644
--- a/src/OpenGL ES 2.0/compiler/SymbolTable.h
+++ b/src/OpenGL ES 2.0/compiler/SymbolTable.h
@@ -302,6 +302,12 @@
assert(table.size() >= 2);
return table[1];
}
+
+ TSymbolTableLevel* getOuterLevel() {
+ assert(table.size() >= 2);
+ return table[currentLevel() - 1];
+ }
+
void relateToOperator(const char* name, TOperator op) {
table[0]->relateToOperator(name, op);
}
diff --git a/src/OpenGL ES 2.0/compiler/TranslatorASM.cpp b/src/OpenGL ES 2.0/compiler/TranslatorASM.cpp
new file mode 100644
index 0000000..d1f8093
--- /dev/null
+++ b/src/OpenGL ES 2.0/compiler/TranslatorASM.cpp
@@ -0,0 +1,42 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "TranslatorASM.h"
+
+TranslatorASM::TranslatorASM(gl::Shader *shaderObject, ShShaderType type, ShShaderSpec spec) : TCompiler(type, spec), shaderObject(shaderObject)
+{
+}
+
+void TranslatorASM::translate(TIntermNode* root)
+{
+ TParseContext& parseContext = *GetGlobalParseContext();
+ sh::OutputASM outputASM(parseContext, shaderObject);
+
+ outputASM.output();
+}
+
+//
+// This function must be provided to create the actual
+// compile object used by higher level code. It returns
+// a subclass of TCompiler.
+//
+TCompiler* ConstructCompiler(ShShaderType type, ShShaderSpec spec)
+{
+ return new TranslatorASM(0, type, spec);
+}
+
+//
+// Delete the compiler made by ConstructCompiler
+//
+void DeleteCompiler(TCompiler* compiler)
+{
+ delete compiler;
+}
\ No newline at end of file
diff --git a/src/OpenGL ES 2.0/compiler/TranslatorASM.h b/src/OpenGL ES 2.0/compiler/TranslatorASM.h
new file mode 100644
index 0000000..1705043
--- /dev/null
+++ b/src/OpenGL ES 2.0/compiler/TranslatorASM.h
@@ -0,0 +1,37 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#ifndef COMPILER_TRANSLATORASM_H_
+#define COMPILER_TRANSLATORASM_H_
+
+#include "ShHandle.h"
+#include "OutputASM.h"
+#include "Shader/PixelShader.hpp"
+#include "Shader/VertexShader.hpp"
+
+namespace gl
+{
+ class Shader;
+}
+
+class TranslatorASM : public TCompiler
+{
+public:
+ TranslatorASM(gl::Shader *shaderObject, ShShaderType type, ShShaderSpec spec);
+
+protected:
+ virtual void translate(TIntermNode* root);
+
+private:
+ gl::Shader *const shaderObject;
+};
+
+#endif // COMPILER_TRANSLATORASM_H_
diff --git a/src/OpenGL ES 2.0/compiler/Types.h b/src/OpenGL ES 2.0/compiler/Types.h
index d0fcc08..1112c5a 100644
--- a/src/OpenGL ES 2.0/compiler/Types.h
+++ b/src/OpenGL ES 2.0/compiler/Types.h
@@ -1,5 +1,5 @@
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
@@ -9,7 +9,7 @@
#include "compiler/BaseTypes.h"
#include "compiler/Common.h"
-#include "compiler/debug.h"
+#include "common/debug.h"
//
// Need to have association of line numbers to types in a list for building structs.
@@ -168,23 +168,72 @@
// One-dimensional size of single instance type
int getNominalSize() const { return size; }
void setNominalSize(int s) { size = s; }
+
// Full size of single instance of type
- int getObjectSize() const
- {
- int totalSize;
+ int getObjectSize() const
+ {
+ if(isArray())
+ {
+ return getElementSize() * std::max(getArraySize(), getMaxArraySize());
+ }
+ else
+ {
+ return getElementSize();
+ }
+ }
- if (getBasicType() == EbtStruct)
- totalSize = getStructSize();
- else if (matrix)
- totalSize = size * size;
- else
- totalSize = size;
+ int getElementSize() const
+ {
+ if(getBasicType() == EbtStruct)
+ {
+ return getStructSize();
+ }
+ else if(matrix)
+ {
+ return size * size;
+ }
+ else // Vector or scalar
+ {
+ return size;
+ }
+ }
- if (isArray())
- totalSize *= std::max(getArraySize(), getMaxArraySize());
+ int elementRegisterCount() const
+ {
+ TTypeList *structure = getStruct();
- return totalSize;
- }
+ if(structure)
+ {
+ int registerCount = 0;
+
+ for(size_t i = 0; i < structure->size(); i++)
+ {
+ registerCount += (*structure)[i].type->totalRegisterCount();
+ }
+
+ return registerCount;
+ }
+ else if(isMatrix())
+ {
+ return getNominalSize();
+ }
+ else
+ {
+ return 1;
+ }
+ }
+
+ int totalRegisterCount() const
+ {
+ if(array)
+ {
+ return arraySize * elementRegisterCount();
+ }
+ else
+ {
+ return elementRegisterCount();
+ }
+ }
bool isMatrix() const { return matrix ? true : false; }
void setMatrix(bool m) { matrix = m; }
@@ -200,6 +249,8 @@
bool isVector() const { return size > 1 && !matrix; }
bool isScalar() const { return size == 1 && !matrix && !structure; }
+ bool isRegister() const { return !matrix && !structure && !array; } // Fits in a 4-element register
+ bool isStruct() const { return structure != 0; }
TTypeList* getStruct() const { return structure; }
void setStruct(TTypeList* s) { structure = s; }
diff --git a/src/OpenGL ES 2.0/compiler/VariableInfo.cpp b/src/OpenGL ES 2.0/compiler/VariableInfo.cpp
index a13a896..071d05e 100644
--- a/src/OpenGL ES 2.0/compiler/VariableInfo.cpp
+++ b/src/OpenGL ES 2.0/compiler/VariableInfo.cpp
@@ -1,5 +1,5 @@
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
@@ -70,37 +70,32 @@
static void getBuiltInVariableInfo(const TType& type,
const TString& name,
- const TString& mappedName,
TVariableInfoList& infoList);
static void getUserDefinedVariableInfo(const TType& type,
const TString& name,
- const TString& mappedName,
TVariableInfoList& infoList);
// Returns info for an attribute or uniform.
static void getVariableInfo(const TType& type,
const TString& name,
- const TString& mappedName,
TVariableInfoList& infoList)
{
if (type.getBasicType() == EbtStruct) {
if (type.isArray()) {
for (int i = 0; i < type.getArraySize(); ++i) {
TString lname = name + arrayBrackets(i);
- TString lmappedName = mappedName + arrayBrackets(i);
- getUserDefinedVariableInfo(type, lname, lmappedName, infoList);
+ getUserDefinedVariableInfo(type, lname, infoList);
}
} else {
- getUserDefinedVariableInfo(type, name, mappedName, infoList);
+ getUserDefinedVariableInfo(type, name, infoList);
}
} else {
- getBuiltInVariableInfo(type, name, mappedName, infoList);
+ getBuiltInVariableInfo(type, name, infoList);
}
}
void getBuiltInVariableInfo(const TType& type,
const TString& name,
- const TString& mappedName,
TVariableInfoList& infoList)
{
ASSERT(type.getBasicType() != EbtStruct);
@@ -108,11 +103,9 @@
TVariableInfo varInfo;
if (type.isArray()) {
varInfo.name = (name + "[0]").c_str();
- varInfo.mappedName = (mappedName + "[0]").c_str();
varInfo.size = type.getArraySize();
} else {
varInfo.name = name.c_str();
- varInfo.mappedName = mappedName.c_str();
varInfo.size = 1;
}
varInfo.type = getVariableDataType(type);
@@ -121,7 +114,6 @@
void getUserDefinedVariableInfo(const TType& type,
const TString& name,
- const TString& mappedName,
TVariableInfoList& infoList)
{
ASSERT(type.getBasicType() == EbtStruct);
@@ -131,7 +123,6 @@
const TType* fieldType = (*structure)[i].type;
getVariableInfo(*fieldType,
name + "." + fieldType->getFieldName(),
- mappedName + "." + fieldType->getFieldName(),
infoList);
}
}
@@ -195,7 +186,6 @@
// TIntermSymbol nodes in the sequence.
ASSERT(variable != NULL);
getVariableInfo(variable->getType(),
- variable->getOriginalSymbol(),
variable->getSymbol(),
infoList);
}
diff --git a/src/OpenGL ES 2.0/compiler/VariableInfo.h b/src/OpenGL ES 2.0/compiler/VariableInfo.h
index 667acaf..77902d9 100644
--- a/src/OpenGL ES 2.0/compiler/VariableInfo.h
+++ b/src/OpenGL ES 2.0/compiler/VariableInfo.h
@@ -1,5 +1,5 @@
//
-// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
@@ -14,7 +14,6 @@
// It is currently being used to store info about active attribs and uniforms.
struct TVariableInfo {
TPersistString name;
- TPersistString mappedName;
ShDataType type;
int size;
};
diff --git a/src/OpenGL ES 2.0/compiler/debug.cpp b/src/OpenGL ES 2.0/compiler/debug.cpp
deleted file mode 100644
index 9642e1e..0000000
--- a/src/OpenGL ES 2.0/compiler/debug.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-
-// debug.cpp: Debugging utilities.
-
-#include "compiler/debug.h"
-
-#include <stdarg.h>
-#include <stdio.h>
-
-#include "compiler/ParseHelper.h"
-
-static const int kTraceBufferLen = 1024;
-
-#ifdef TRACE_ENABLED
-extern "C" {
-void Trace(const char *format, ...) {
- if (!format) return;
-
- TParseContext* parseContext = GetGlobalParseContext();
- if (parseContext) {
- char buf[kTraceBufferLen];
- va_list args;
- va_start(args, format);
- vsnprintf(buf, kTraceBufferLen, format, args);
- va_end(args);
-
- parseContext->infoSink.debug << buf;
- }
-}
-} // extern "C"
-#endif // TRACE_ENABLED
-
diff --git a/src/OpenGL ES 2.0/compiler/debug.h b/src/OpenGL ES 2.0/compiler/debug.h
deleted file mode 100644
index 7a37151..0000000
--- a/src/OpenGL ES 2.0/compiler/debug.h
+++ /dev/null
@@ -1,53 +0,0 @@
-//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-
-// debug.h: Debugging utilities.
-
-#ifndef COMPILER_DEBUG_H_
-#define COMPILER_DEBUG_H_
-
-#include <assert.h>
-
-#ifdef _DEBUG
-#define TRACE_ENABLED // define to enable debug message tracing
-#endif // _DEBUG
-
-// Outputs text to the debug log
-#ifdef TRACE_ENABLED
-
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-void Trace(const char* format, ...);
-#ifdef __cplusplus
-}
-#endif // __cplusplus
-
-#else // TRACE_ENABLED
-
-#define Trace(...) ((void)0)
-
-#endif // TRACE_ENABLED
-
-// A macro asserting a condition and outputting failures to the debug log
-#define ASSERT(expression) do { \
- if(!(expression)) \
- Trace("Assert failed: %s(%d): "#expression"\n", __FUNCTION__, __LINE__); \
- assert(expression); \
-} while(0)
-
-#define UNIMPLEMENTED() do { \
- Trace("Unimplemented invoked: %s(%d)\n", __FUNCTION__, __LINE__); \
- assert(false); \
-} while(0)
-
-#define UNREACHABLE() do { \
- Trace("Unreachable reached: %s(%d)\n", __FUNCTION__, __LINE__); \
- assert(false); \
-} while(0)
-
-#endif // COMPILER_DEBUG_H_
-
diff --git a/src/OpenGL ES 2.0/compiler/generate_parser.sh b/src/OpenGL ES 2.0/compiler/generate_parser.sh
new file mode 100644
index 0000000..e472191
--- /dev/null
+++ b/src/OpenGL ES 2.0/compiler/generate_parser.sh
@@ -0,0 +1,27 @@
+#!/bin/bash
+# Copyright (c) 2010 The ANGLE Project Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# Generates GLSL ES parser - glslang_lex.cpp, glslang_tab.h, and glslang_tab.cpp
+
+run_flex()
+{
+input_file=$script_dir/$1.l
+output_source=$script_dir/$1_lex.cpp
+flex --noline --nounistd --outfile=$output_source $input_file
+}
+
+run_bison()
+{
+input_file=$script_dir/$1.y
+output_header=$script_dir/$1_tab.h
+output_source=$script_dir/$1_tab.cpp
+bison --no-lines --skeleton=yacc.c --defines=$output_header --output=$output_source $input_file
+}
+
+script_dir=$(dirname $0)
+
+# Generate Parser
+run_flex glslang
+run_bison glslang
diff --git a/src/OpenGL ES 2.0/compiler/glslang.l b/src/OpenGL ES 2.0/compiler/glslang.l
index 5a7c5d5..166610f 100644
--- a/src/OpenGL ES 2.0/compiler/glslang.l
+++ b/src/OpenGL ES 2.0/compiler/glslang.l
@@ -1,6 +1,6 @@
/*
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
@@ -9,18 +9,30 @@
Based on ANSI C grammar, Lex specification:
http://www.lysator.liu.se/c/ANSI-C-grammar-l.html
-IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_glslang_lexer.sh,
+IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_parser.sh,
WHICH GENERATES THE GLSL ES LEXER (glslang_lex.cpp).
*/
%top{
//
-// Copyright (c) 2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
-// This file is auto-generated by generate_glslang_lexer.sh. DO NOT EDIT!
+// This file is auto-generated by generate_parser.sh. DO NOT EDIT!
+
+// Ignore errors in auto-generated code.
+#if defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic ignored "-Wswitch-enum"
+#elif defined(_MSC_VER)
+#pragma warning(disable: 4065)
+#pragma warning(disable: 4189)
+#pragma warning(disable: 4505)
+#pragma warning(disable: 4701)
+#endif
}
%{
@@ -145,6 +157,7 @@
"extern" { return reserved_word(yyscanner); }
"external" { return reserved_word(yyscanner); }
"interface" { return reserved_word(yyscanner); }
+"flat" { return reserved_word(yyscanner); }
"long" { return reserved_word(yyscanner); }
"short" { return reserved_word(yyscanner); }
@@ -152,6 +165,7 @@
"half" { return reserved_word(yyscanner); }
"fixed" { return reserved_word(yyscanner); }
"unsigned" { return reserved_word(yyscanner); }
+"superp" { return reserved_word(yyscanner); }
"input" { return reserved_word(yyscanner); }
"output" { return reserved_word(yyscanner); }
@@ -159,12 +173,22 @@
"hvec2" { return reserved_word(yyscanner); }
"hvec3" { return reserved_word(yyscanner); }
"hvec4" { return reserved_word(yyscanner); }
-"fvec2" { return reserved_word(yyscanner); }
-"fvec3" { return reserved_word(yyscanner); }
-"fvec4" { return reserved_word(yyscanner); }
"dvec2" { return reserved_word(yyscanner); }
"dvec3" { return reserved_word(yyscanner); }
"dvec4" { return reserved_word(yyscanner); }
+"fvec2" { return reserved_word(yyscanner); }
+"fvec3" { return reserved_word(yyscanner); }
+"fvec4" { return reserved_word(yyscanner); }
+
+"sampler1D" { return reserved_word(yyscanner); }
+"sampler3D" { return reserved_word(yyscanner); }
+
+"sampler1DShadow" { return reserved_word(yyscanner); }
+"sampler2DShadow" { return reserved_word(yyscanner); }
+
+"sampler2DRect" { return reserved_word(yyscanner); }
+"sampler3DRect" { return reserved_word(yyscanner); }
+"sampler2DRectShadow" { return reserved_word(yyscanner); }
"sizeof" { return reserved_word(yyscanner); }
"cast" { return reserved_word(yyscanner); }
@@ -480,6 +504,8 @@
msg = TString("extension '") + extName + "' is not supported";
context->infoSink.info.message(EPrefixWarning, msg.c_str(), yylineno);
break;
+ default:
+ break;
}
return;
} else
diff --git a/src/OpenGL ES 2.0/compiler/glslang.y b/src/OpenGL ES 2.0/compiler/glslang.y
index b6fa163..69c35e7 100644
--- a/src/OpenGL ES 2.0/compiler/glslang.y
+++ b/src/OpenGL ES 2.0/compiler/glslang.y
@@ -129,7 +129,7 @@
%type <interm.intermNode> declaration external_declaration
%type <interm.intermNode> for_init_statement compound_statement_no_new_scope
%type <interm.nodePair> selection_rest_statement for_rest_statement
-%type <interm.intermNode> iteration_statement jump_statement statement_no_new_scope
+%type <interm.intermNode> iteration_statement jump_statement statement_no_new_scope statement_with_scope
%type <interm> single_declaration init_declarator_list
%type <interm> parameter_declaration parameter_declarator parameter_type_specifier
@@ -975,6 +975,8 @@
prototype->setOp(EOpPrototype);
$$ = prototype;
+
+ context->symbolTable.pop();
}
| init_declarator_list SEMICOLON {
if ($1.intermAggregate)
@@ -1019,7 +1021,9 @@
$$.function = $1;
$$.line = $2.line;
- context->symbolTable.insert(*$$.function);
+ // We're at the inner scope level of the function's arguments and body statement.
+ // Add the function prototype to the surrounding scope instead.
+ context->symbolTable.getOuterLevel()->insert(*$$.function);
}
;
@@ -1077,6 +1081,8 @@
TType type($1);
function = new TFunction($2.string, type);
$$ = function;
+
+ context->symbolTable.push();
}
;
@@ -1185,6 +1191,12 @@
}
}
| init_declarator_list COMMA IDENTIFIER {
+ if ($1.type.type == EbtInvariant && !$3.symbol)
+ {
+ context->error($3.line, "undeclared identifier declared as invariant", $3.string->c_str(), "");
+ context->recover();
+ }
+
TIntermSymbol* symbol = context->intermediate.addSymbol(0, *$3.string, TType($1.type), $3.line);
$$.intermAggregate = context->intermediate.growAggregate($1.intermNode, symbol, $3.line);
@@ -1349,8 +1361,21 @@
}
| INVARIANT IDENTIFIER {
VERTEX_ONLY("invariant declaration", $1.line);
- $$.qualifier = EvqInvariantVaryingOut;
- $$.intermAggregate = 0;
+ if (context->globalErrorCheck($1.line, context->symbolTable.atGlobalLevel(), "invariant varying"))
+ context->recover();
+ $$.type.setBasic(EbtInvariant, EvqInvariantVaryingOut, $2.line);
+ if (!$2.symbol)
+ {
+ context->error($2.line, "undeclared identifier declared as invariant", $2.string->c_str(), "");
+ context->recover();
+
+ $$.intermAggregate = 0;
+ }
+ else
+ {
+ TIntermSymbol *symbol = context->intermediate.addSymbol(0, *$2.string, TType($$.type), $2.line);
+ $$.intermAggregate = context->intermediate.makeAggregate(symbol, $2.line);
+ }
}
//
@@ -1782,6 +1807,11 @@
| simple_statement { $$ = $1; }
;
+statement_with_scope
+ : { context->symbolTable.push(); } compound_statement_no_new_scope { context->symbolTable.pop(); $$ = $2; }
+ | { context->symbolTable.push(); } simple_statement { context->symbolTable.pop(); $$ = $2; }
+ ;
+
compound_statement_no_new_scope
// Statement that doesn't create a new scope, for selection_statement, iteration_statement
: LEFT_BRACE RIGHT_BRACE {
@@ -1819,11 +1849,11 @@
;
selection_rest_statement
- : statement ELSE statement {
+ : statement_with_scope ELSE statement_with_scope {
$$.node1 = $1;
$$.node2 = $3;
}
- | statement {
+ | statement_with_scope {
$$.node1 = $1;
$$.node2 = 0;
}
@@ -1860,7 +1890,7 @@
$$ = context->intermediate.addLoop(ELoopWhile, 0, $4, 0, $6, $1.line);
--context->loopNestingLevel;
}
- | DO { ++context->loopNestingLevel; } statement WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON {
+ | DO { ++context->loopNestingLevel; } statement_with_scope WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON {
if (context->boolErrorCheck($8.line, $6))
context->recover();
@@ -1997,11 +2027,6 @@
}
//
- // New symbol table scope for body of function plus its arguments
- //
- context->symbolTable.push();
-
- //
// Remember the return type for later checking for RETURN statements.
//
context->currentFunctionType = &(prevDec->getReturnType());
@@ -2053,7 +2078,7 @@
context->error($1.line, "function does not return a value:", "", $1.function->getName().c_str());
context->recover();
}
- context->symbolTable.pop();
+
$$ = context->intermediate.growAggregate($1.intermAggregate, $3, 0);
context->intermediate.setAggregateOperator($$, EOpFunction, $1.line);
$$->getAsAggregate()->setName($1.function->getMangledName().c_str());
@@ -2067,6 +2092,8 @@
if ($3 && $3->getAsAggregate())
$$->getAsAggregate()->setEndLine($3->getAsAggregate()->getEndLine());
+
+ context->symbolTable.pop();
}
;
diff --git a/src/OpenGL ES 2.0/compiler/glslang_lex.cpp b/src/OpenGL ES 2.0/compiler/glslang_lex.cpp
index 9d5f53f..19acca5 100644
--- a/src/OpenGL ES 2.0/compiler/glslang_lex.cpp
+++ b/src/OpenGL ES 2.0/compiler/glslang_lex.cpp
@@ -1,15 +1,27 @@
-#line 17 "compiler/glslang.l"
+#line 17 "./glslang.l"
//
-// Copyright (c) 2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
-// This file is auto-generated by generate_glslang_lexer.sh. DO NOT EDIT!
+// This file is auto-generated by generate_parser.sh. DO NOT EDIT!
+
+// Ignore errors in auto-generated code.
+#if defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic ignored "-Wswitch-enum"
+#elif defined(_MSC_VER)
+#pragma warning(disable: 4065)
+#pragma warning(disable: 4189)
+#pragma warning(disable: 4505)
+#pragma warning(disable: 4701)
+#endif
-#line 13 "compiler/glslang_lex.cpp"
+#line 25 "./glslang_lex.cpp"
#define YY_INT_ALIGNED short int
@@ -371,8 +383,8 @@
*yy_cp = '\0'; \
yyg->yy_c_buf_p = yy_cp;
-#define YY_NUM_RULES 145
-#define YY_END_OF_BUFFER 146
+#define YY_NUM_RULES 154
+#define YY_END_OF_BUFFER 155
/* This struct is not used in this scanner,
but its presence is necessary. */
struct yy_trans_info
@@ -380,53 +392,57 @@
flex_int32_t yy_verify;
flex_int32_t yy_nxt;
};
-static yyconst flex_int16_t yy_accept[411] =
+static yyconst flex_int16_t yy_accept[448] =
{ 0,
- 0, 0, 0, 0, 0, 0, 146, 144, 143, 143,
- 128, 134, 139, 123, 124, 132, 131, 120, 129, 127,
- 133, 92, 92, 121, 117, 135, 122, 136, 140, 88,
- 125, 126, 138, 88, 88, 88, 88, 88, 88, 88,
- 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
- 88, 88, 88, 118, 137, 119, 130, 3, 4, 3,
- 142, 145, 141, 114, 100, 119, 108, 103, 98, 106,
- 96, 107, 97, 95, 2, 1, 99, 94, 90, 91,
- 0, 0, 92, 126, 118, 125, 115, 111, 113, 112,
- 116, 88, 104, 110, 88, 88, 88, 88, 88, 88,
+ 0, 0, 0, 0, 0, 0, 155, 153, 152, 152,
+ 137, 143, 148, 132, 133, 141, 140, 129, 138, 136,
+ 142, 101, 101, 130, 126, 144, 131, 145, 149, 97,
+ 134, 135, 147, 97, 97, 97, 97, 97, 97, 97,
+ 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
+ 97, 97, 97, 127, 146, 128, 139, 3, 4, 3,
+ 151, 154, 150, 123, 109, 128, 117, 112, 107, 115,
+ 105, 116, 106, 104, 2, 1, 108, 103, 99, 100,
+ 0, 0, 101, 135, 127, 134, 124, 120, 122, 121,
+ 125, 97, 113, 119, 97, 97, 97, 97, 97, 97,
- 88, 88, 88, 88, 17, 88, 88, 88, 88, 88,
- 88, 88, 88, 88, 88, 88, 88, 88, 20, 22,
- 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
- 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
- 88, 88, 88, 88, 88, 88, 105, 109, 5, 141,
- 0, 1, 94, 0, 0, 93, 89, 101, 102, 48,
- 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
- 88, 88, 88, 88, 88, 88, 88, 18, 88, 88,
- 88, 88, 88, 88, 88, 88, 26, 88, 88, 88,
- 88, 88, 88, 88, 88, 23, 88, 88, 88, 88,
+ 97, 97, 97, 97, 17, 97, 97, 97, 97, 97,
+ 97, 97, 97, 97, 97, 97, 97, 97, 20, 22,
+ 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
+ 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
+ 97, 97, 97, 97, 97, 97, 97, 114, 118, 5,
+ 150, 0, 1, 103, 0, 0, 102, 98, 110, 111,
+ 48, 97, 97, 97, 97, 97, 97, 97, 97, 97,
+ 97, 97, 97, 97, 97, 97, 97, 97, 97, 18,
+ 97, 97, 97, 97, 97, 97, 97, 97, 26, 97,
+ 97, 97, 97, 97, 97, 97, 97, 23, 97, 97,
- 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
- 88, 88, 88, 88, 88, 88, 88, 88, 0, 95,
- 0, 94, 88, 28, 88, 88, 85, 88, 88, 88,
- 88, 88, 88, 88, 21, 51, 88, 88, 88, 88,
- 88, 56, 70, 88, 88, 88, 88, 88, 88, 88,
- 88, 67, 9, 33, 34, 35, 88, 88, 88, 88,
- 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
- 88, 54, 29, 88, 88, 88, 88, 88, 88, 36,
- 37, 38, 27, 88, 88, 88, 15, 42, 43, 44,
- 49, 12, 88, 88, 88, 88, 81, 82, 83, 88,
+ 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
+ 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
+ 97, 0, 104, 0, 103, 97, 28, 97, 97, 94,
+ 97, 97, 97, 97, 97, 97, 97, 21, 51, 97,
+ 97, 97, 67, 97, 97, 56, 71, 97, 97, 97,
+ 97, 97, 97, 97, 97, 68, 9, 33, 34, 35,
+ 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
+ 97, 97, 97, 97, 97, 97, 54, 29, 97, 97,
+ 97, 97, 97, 97, 36, 37, 38, 27, 97, 97,
+ 97, 15, 42, 43, 44, 49, 12, 97, 97, 97,
- 30, 71, 25, 78, 79, 80, 7, 75, 76, 77,
- 88, 24, 73, 88, 88, 39, 40, 41, 88, 88,
- 88, 88, 88, 88, 88, 88, 88, 68, 88, 88,
- 88, 88, 88, 88, 88, 50, 88, 87, 88, 88,
- 19, 88, 88, 88, 88, 69, 64, 59, 88, 88,
- 88, 88, 88, 74, 55, 88, 62, 32, 88, 84,
- 63, 47, 57, 88, 88, 88, 88, 88, 88, 88,
- 88, 58, 31, 88, 88, 88, 8, 88, 88, 88,
- 88, 88, 52, 13, 88, 14, 88, 88, 16, 65,
- 88, 88, 88, 60, 88, 88, 88, 53, 72, 61,
+ 97, 80, 81, 82, 97, 30, 72, 25, 83, 84,
+ 85, 7, 77, 78, 79, 97, 24, 75, 97, 97,
+ 39, 40, 41, 97, 97, 97, 97, 97, 97, 97,
+ 97, 97, 69, 97, 97, 97, 97, 97, 97, 97,
+ 97, 50, 97, 96, 97, 97, 19, 97, 97, 97,
+ 97, 70, 64, 59, 97, 97, 97, 97, 97, 76,
+ 55, 97, 62, 32, 97, 93, 63, 47, 74, 57,
+ 97, 97, 97, 97, 97, 97, 97, 97, 58, 31,
+ 97, 97, 97, 8, 97, 97, 97, 97, 97, 52,
+ 13, 97, 14, 97, 97, 16, 65, 97, 97, 97,
- 11, 66, 6, 86, 10, 45, 88, 88, 46, 0
+ 60, 97, 97, 97, 97, 97, 53, 73, 61, 11,
+ 66, 6, 95, 10, 86, 45, 87, 97, 97, 97,
+ 97, 97, 97, 97, 97, 97, 97, 46, 97, 97,
+ 97, 97, 97, 90, 97, 91, 97, 97, 97, 88,
+ 97, 89, 97, 97, 97, 92, 0
} ;
static yyconst flex_int32_t yy_ec[256] =
@@ -436,15 +452,15 @@
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 2, 4, 1, 1, 1, 5, 6, 1, 7,
8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
- 18, 19, 16, 16, 16, 20, 20, 21, 22, 23,
- 24, 25, 26, 1, 27, 27, 28, 29, 30, 27,
- 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
- 31, 31, 31, 31, 31, 31, 31, 32, 31, 31,
- 33, 1, 34, 35, 31, 1, 36, 37, 38, 39,
+ 18, 19, 20, 20, 20, 21, 21, 22, 23, 24,
+ 25, 26, 27, 1, 28, 28, 29, 30, 31, 28,
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
+ 32, 33, 34, 32, 32, 32, 32, 35, 32, 32,
+ 36, 1, 37, 38, 32, 1, 39, 40, 41, 42,
- 40, 41, 42, 43, 44, 31, 45, 46, 47, 48,
- 49, 50, 31, 51, 52, 53, 54, 55, 56, 57,
- 58, 59, 60, 61, 62, 63, 1, 1, 1, 1,
+ 43, 44, 45, 46, 47, 32, 48, 49, 50, 51,
+ 52, 53, 32, 54, 55, 56, 57, 58, 59, 60,
+ 61, 62, 63, 64, 65, 66, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
@@ -461,195 +477,209 @@
1, 1, 1, 1, 1
} ;
-static yyconst flex_int32_t yy_meta[64] =
+static yyconst flex_int32_t yy_meta[67] =
{ 0,
1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 3, 3, 3, 3, 3, 3,
- 1, 1, 1, 1, 1, 1, 3, 3, 3, 3,
- 4, 4, 1, 1, 1, 3, 3, 3, 3, 3,
- 3, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 1,
- 1, 1, 1
+ 1, 1, 3, 1, 4, 4, 4, 4, 4, 4,
+ 4, 1, 1, 1, 1, 1, 1, 5, 5, 5,
+ 4, 6, 6, 6, 6, 1, 1, 1, 5, 5,
+ 5, 5, 4, 5, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 1, 1, 1, 1
} ;
-static yyconst flex_int16_t yy_base[416] =
+static yyconst flex_int16_t yy_base[455] =
{ 0,
- 0, 0, 61, 62, 71, 0, 606, 607, 607, 607,
- 581, 42, 129, 607, 607, 580, 126, 607, 125, 123,
- 137, 149, 157, 578, 607, 175, 578, 44, 607, 0,
- 607, 607, 120, 95, 103, 142, 146, 136, 156, 552,
- 168, 162, 551, 120, 158, 545, 173, 558, 172, 178,
- 111, 186, 554, 607, 159, 607, 607, 607, 607, 582,
- 607, 607, 0, 607, 607, 607, 607, 607, 607, 607,
- 607, 607, 607, 222, 607, 0, 607, 228, 254, 262,
- 281, 0, 290, 607, 607, 607, 571, 607, 607, 607,
- 570, 0, 607, 607, 546, 539, 542, 550, 549, 536,
+ 0, 0, 64, 65, 74, 0, 649, 650, 650, 650,
+ 623, 44, 135, 650, 650, 622, 132, 650, 131, 129,
+ 144, 157, 148, 620, 650, 158, 620, 46, 650, 0,
+ 650, 650, 126, 99, 113, 145, 138, 138, 154, 592,
+ 160, 108, 591, 165, 163, 585, 156, 598, 175, 181,
+ 154, 177, 594, 650, 161, 650, 650, 650, 650, 625,
+ 650, 650, 0, 650, 650, 650, 650, 650, 650, 650,
+ 650, 650, 650, 228, 650, 0, 650, 235, 176, 226,
+ 264, 0, 227, 650, 650, 650, 613, 650, 650, 650,
+ 612, 0, 650, 650, 586, 579, 582, 590, 589, 576,
- 551, 538, 544, 532, 529, 542, 529, 526, 526, 532,
- 520, 527, 524, 534, 520, 526, 529, 530, 0, 204,
- 529, 207, 515, 528, 519, 521, 511, 525, 522, 524,
- 507, 512, 509, 498, 183, 512, 508, 510, 499, 502,
- 212, 507, 499, 511, 186, 504, 607, 607, 607, 0,
- 306, 0, 316, 332, 270, 342, 0, 607, 607, 0,
- 496, 500, 509, 506, 490, 490, 161, 505, 502, 502,
- 500, 497, 489, 495, 482, 493, 496, 0, 493, 481,
- 488, 485, 489, 482, 471, 470, 483, 486, 483, 478,
- 469, 294, 474, 477, 468, 465, 469, 475, 466, 457,
+ 591, 578, 584, 572, 569, 582, 569, 566, 566, 572,
+ 560, 189, 565, 575, 561, 567, 570, 571, 0, 237,
+ 570, 179, 556, 569, 560, 562, 552, 566, 563, 565,
+ 548, 553, 550, 539, 221, 547, 552, 548, 550, 539,
+ 542, 217, 547, 539, 551, 214, 544, 650, 650, 650,
+ 0, 282, 0, 289, 306, 318, 325, 0, 650, 650,
+ 0, 536, 540, 549, 546, 530, 530, 212, 545, 542,
+ 542, 540, 537, 529, 535, 522, 533, 519, 535, 0,
+ 532, 520, 527, 524, 528, 521, 510, 509, 522, 525,
+ 522, 517, 508, 294, 513, 516, 507, 504, 508, 514,
- 460, 458, 468, 454, 452, 452, 454, 451, 462, 461,
- 278, 456, 451, 440, 320, 458, 460, 449, 348, 354,
- 360, 366, 450, 0, 448, 336, 0, 440, 438, 446,
- 435, 452, 441, 370, 0, 0, 435, 445, 445, 430,
- 373, 0, 0, 432, 376, 433, 427, 426, 427, 426,
- 379, 0, 0, 0, 0, 0, 422, 423, 428, 419,
- 432, 427, 426, 418, 422, 414, 417, 421, 426, 425,
- 416, 0, 0, 422, 411, 411, 416, 415, 412, 0,
- 0, 0, 0, 402, 414, 416, 0, 0, 0, 0,
- 0, 0, 404, 405, 399, 409, 0, 0, 0, 400,
+ 505, 496, 499, 497, 507, 493, 491, 504, 490, 492,
+ 489, 500, 499, 221, 494, 489, 478, 311, 496, 498,
+ 487, 332, 339, 346, 353, 488, 0, 486, 358, 0,
+ 478, 476, 484, 473, 490, 479, 361, 0, 0, 473,
+ 483, 483, 0, 468, 364, 0, 0, 470, 367, 471,
+ 465, 464, 465, 464, 370, 0, 0, 0, 0, 0,
+ 460, 461, 466, 457, 470, 465, 464, 456, 460, 452,
+ 455, 459, 464, 450, 462, 453, 0, 0, 459, 448,
+ 448, 453, 452, 449, 0, 0, 0, 0, 439, 451,
+ 453, 0, 0, 0, 0, 0, 0, 441, 442, 436,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 407, 0, 0, 405, 401, 0, 0, 0, 397, 393,
- 398, 388, 401, 387, 400, 389, 396, 0, 394, 396,
- 380, 389, 395, 390, 378, 0, 380, 0, 379, 382,
- 0, 371, 370, 370, 383, 0, 385, 0, 384, 383,
- 368, 381, 368, 0, 0, 371, 0, 0, 363, 0,
- 0, 0, 0, 360, 371, 364, 368, 303, 297, 288,
- 300, 0, 0, 283, 290, 269, 0, 277, 274, 255,
- 232, 255, 0, 0, 244, 0, 236, 226, 0, 0,
- 225, 208, 211, 0, 185, 202, 131, 0, 0, 0,
+ 446, 0, 0, 0, 437, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 444, 0, 0, 442, 438,
+ 0, 0, 0, 434, 430, 435, 425, 438, 424, 437,
+ 426, 433, 0, 431, 433, 417, 419, 425, 431, 426,
+ 414, 0, 416, 0, 415, 418, 0, 407, 406, 406,
+ 419, 0, 421, 0, 420, 419, 404, 417, 404, 0,
+ 0, 407, 0, 0, 399, 0, 0, 0, 0, 0,
+ 396, 407, 400, 406, 403, 398, 390, 402, 0, 0,
+ 395, 402, 391, 0, 400, 397, 387, 374, 395, 0,
+ 0, 395, 0, 393, 392, 0, 0, 391, 377, 389,
- 0, 0, 0, 0, 0, 0, 134, 117, 0, 607,
- 398, 400, 402, 406, 142
+ 0, 380, 400, 399, 398, 362, 0, 0, 0, 0,
+ 0, 0, 0, 0, 368, 254, 368, 360, 353, 355,
+ 351, 353, 352, 355, 352, 292, 278, 0, 275, 259,
+ 272, 240, 239, 243, 210, 0, 178, 187, 167, 0,
+ 184, 0, 177, 116, 103, 0, 650, 403, 407, 408,
+ 411, 417, 421, 422
} ;
-static yyconst flex_int16_t yy_def[416] =
+static yyconst flex_int16_t yy_def[455] =
{ 0,
- 410, 1, 411, 411, 410, 5, 410, 410, 410, 410,
- 410, 410, 410, 410, 410, 410, 410, 410, 410, 410,
- 410, 410, 410, 410, 410, 410, 410, 410, 410, 412,
- 410, 410, 410, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 410, 410, 410, 410, 410, 410, 410,
- 410, 410, 413, 410, 410, 410, 410, 410, 410, 410,
- 410, 410, 410, 410, 410, 414, 410, 410, 410, 410,
- 410, 415, 410, 410, 410, 410, 410, 410, 410, 410,
- 410, 412, 410, 410, 412, 412, 412, 412, 412, 412,
+ 447, 1, 448, 448, 447, 5, 447, 447, 447, 447,
+ 447, 447, 447, 447, 447, 447, 447, 447, 447, 447,
+ 447, 447, 449, 447, 447, 447, 447, 447, 447, 450,
+ 447, 447, 447, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 447, 447, 447, 447, 447, 447, 447,
+ 447, 447, 451, 447, 447, 447, 447, 447, 447, 447,
+ 447, 447, 447, 447, 447, 452, 447, 447, 22, 453,
+ 447, 454, 449, 447, 447, 447, 447, 447, 447, 447,
+ 447, 450, 447, 447, 450, 450, 450, 450, 450, 450,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 410, 410, 410, 413,
- 410, 414, 410, 410, 410, 410, 415, 410, 410, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 447, 447, 447,
+ 451, 447, 452, 447, 447, 447, 447, 454, 447, 447,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 410, 410,
- 410, 410, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 447, 447, 447, 447, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
- 412, 412, 412, 412, 412, 412, 412, 412, 412, 0,
- 410, 410, 410, 410, 410
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 450, 450, 450, 450,
+ 450, 450, 450, 450, 450, 450, 0, 447, 447, 447,
+ 447, 447, 447, 447
} ;
-static yyconst flex_int16_t yy_nxt[671] =
+static yyconst flex_int16_t yy_nxt[717] =
{ 0,
8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 23, 23, 23, 23,
- 24, 25, 26, 27, 28, 29, 30, 30, 30, 30,
- 30, 30, 31, 32, 33, 34, 35, 36, 37, 38,
- 39, 40, 41, 42, 30, 43, 44, 45, 46, 47,
- 48, 49, 50, 51, 52, 53, 30, 30, 30, 54,
- 55, 56, 57, 59, 59, 65, 66, 90, 91, 60,
- 60, 8, 61, 62, 8, 8, 8, 8, 8, 8,
+ 23, 24, 25, 26, 27, 28, 29, 30, 30, 30,
+ 30, 30, 30, 30, 30, 31, 32, 33, 34, 35,
+ 36, 37, 38, 39, 40, 41, 42, 30, 43, 44,
+ 45, 46, 47, 48, 49, 50, 51, 52, 53, 30,
+ 30, 30, 54, 55, 56, 57, 59, 59, 65, 66,
+ 90, 91, 60, 60, 8, 61, 62, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
- 8, 8, 8, 8, 8, 8, 8, 63, 63, 63,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
- 63, 63, 63, 8, 8, 8, 63, 63, 63, 63,
+ 8, 63, 63, 63, 63, 63, 63, 63, 63, 8,
+ 8, 8, 63, 63, 63, 63, 63, 63, 63, 63,
63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
- 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
- 8, 8, 8, 8, 67, 70, 72, 74, 74, 74,
- 74, 74, 74, 93, 157, 75, 95, 96, 73, 71,
- 76, 97, 68, 98, 94, 123, 409, 99, 141, 124,
- 77, 78, 142, 79, 79, 79, 79, 79, 80, 78,
- 408, 83, 83, 83, 83, 83, 83, 100, 81, 85,
- 82, 107, 147, 108, 407, 103, 81, 101, 81, 104,
- 102, 110, 109, 125, 105, 86, 81, 87, 88, 111,
+ 63, 63, 63, 63, 63, 63, 8, 8, 8, 8,
+ 67, 70, 72, 74, 74, 74, 74, 74, 74, 74,
+ 93, 119, 75, 95, 96, 73, 71, 76, 120, 68,
+ 78, 446, 85, 94, 97, 121, 98, 445, 77, 78,
+ 99, 79, 79, 79, 79, 79, 79, 80, 81, 86,
+ 103, 87, 88, 100, 104, 148, 107, 81, 108, 105,
+ 81, 82, 110, 101, 128, 106, 102, 109, 116, 81,
- 106, 112, 119, 116, 113, 82, 126, 132, 128, 120,
- 114, 117, 229, 230, 133, 134, 121, 137, 204, 148,
- 138, 143, 118, 129, 135, 144, 130, 136, 139, 216,
- 406, 217, 405, 205, 145, 140, 74, 74, 74, 74,
- 74, 74, 153, 153, 153, 153, 153, 153, 396, 184,
- 404, 151, 185, 186, 190, 211, 187, 154, 188, 397,
- 403, 151, 191, 212, 402, 401, 78, 154, 79, 79,
- 79, 79, 79, 80, 78, 400, 80, 80, 80, 80,
- 80, 80, 399, 81, 156, 156, 156, 156, 156, 156,
- 155, 81, 155, 81, 398, 156, 156, 156, 156, 156,
+ 111, 125, 112, 123, 142, 113, 117, 124, 143, 129,
+ 447, 114, 130, 132, 126, 144, 82, 118, 444, 145,
+ 133, 134, 443, 138, 149, 442, 139, 178, 146, 192,
+ 135, 136, 441, 137, 140, 447, 440, 193, 78, 78,
+ 179, 141, 74, 74, 74, 74, 74, 74, 74, 154,
+ 154, 154, 154, 154, 154, 154, 81, 81, 152, 206,
+ 219, 439, 220, 214, 280, 155, 232, 233, 81, 81,
+ 152, 215, 281, 156, 207, 156, 438, 155, 157, 157,
+ 157, 157, 157, 157, 157, 186, 420, 421, 187, 188,
+ 437, 222, 189, 222, 190, 436, 223, 223, 223, 223,
- 156, 81, 78, 395, 83, 83, 83, 83, 83, 83,
- 254, 255, 256, 394, 393, 219, 392, 219, 275, 81,
- 220, 220, 220, 220, 220, 220, 276, 391, 390, 81,
- 153, 153, 153, 153, 153, 153, 280, 281, 282, 389,
- 388, 221, 387, 221, 386, 154, 222, 222, 222, 222,
- 222, 222, 288, 289, 290, 154, 156, 156, 156, 156,
- 156, 156, 220, 220, 220, 220, 220, 220, 220, 220,
- 220, 220, 220, 220, 222, 222, 222, 222, 222, 222,
- 222, 222, 222, 222, 222, 222, 297, 298, 299, 304,
- 305, 306, 308, 309, 310, 316, 317, 318, 58, 58,
+ 223, 223, 223, 154, 154, 154, 154, 154, 154, 154,
+ 258, 259, 260, 435, 434, 224, 433, 224, 432, 155,
+ 225, 225, 225, 225, 225, 225, 225, 285, 286, 287,
+ 431, 155, 157, 157, 157, 157, 157, 157, 157, 157,
+ 157, 157, 157, 157, 157, 157, 223, 223, 223, 223,
+ 223, 223, 223, 223, 223, 223, 223, 223, 223, 223,
+ 225, 225, 225, 225, 225, 225, 225, 225, 225, 225,
+ 225, 225, 225, 225, 293, 294, 295, 302, 303, 304,
+ 309, 310, 311, 313, 314, 315, 321, 322, 323, 403,
+ 404, 405, 430, 429, 428, 427, 426, 425, 424, 423,
- 58, 58, 92, 92, 150, 150, 152, 385, 152, 152,
- 384, 383, 382, 381, 380, 379, 378, 377, 376, 375,
- 374, 373, 372, 371, 370, 369, 368, 367, 366, 365,
- 364, 363, 362, 361, 360, 359, 358, 357, 356, 355,
- 354, 353, 352, 351, 350, 349, 348, 347, 346, 345,
- 344, 343, 342, 341, 340, 339, 338, 337, 336, 335,
- 334, 333, 332, 331, 330, 329, 328, 327, 326, 325,
- 324, 323, 322, 321, 320, 319, 315, 314, 313, 312,
- 311, 307, 303, 302, 301, 300, 296, 295, 294, 293,
- 292, 291, 287, 286, 285, 284, 283, 279, 278, 277,
+ 422, 419, 406, 58, 58, 58, 58, 58, 58, 83,
+ 83, 92, 92, 92, 151, 151, 151, 153, 418, 153,
+ 153, 153, 153, 80, 80, 158, 158, 417, 416, 415,
+ 414, 413, 412, 411, 410, 409, 408, 407, 402, 401,
+ 400, 399, 398, 397, 396, 395, 394, 393, 392, 391,
+ 390, 389, 388, 387, 386, 385, 384, 383, 382, 381,
+ 380, 379, 378, 377, 376, 375, 374, 373, 372, 371,
+ 370, 369, 368, 367, 366, 365, 364, 363, 362, 361,
+ 360, 359, 358, 357, 356, 355, 354, 353, 352, 351,
+ 350, 349, 348, 347, 346, 345, 344, 343, 342, 341,
- 274, 273, 272, 271, 270, 269, 268, 267, 266, 265,
- 264, 263, 262, 261, 260, 259, 258, 257, 253, 252,
- 251, 250, 249, 248, 247, 246, 245, 244, 243, 242,
- 241, 240, 239, 238, 237, 236, 235, 234, 233, 232,
- 231, 228, 227, 226, 225, 224, 223, 218, 215, 214,
- 213, 210, 209, 208, 207, 206, 203, 202, 201, 200,
- 199, 198, 197, 196, 195, 194, 193, 192, 189, 183,
- 182, 181, 180, 179, 178, 177, 176, 175, 174, 173,
- 172, 171, 170, 169, 168, 167, 166, 165, 164, 163,
- 162, 161, 160, 159, 158, 149, 146, 131, 127, 122,
+ 340, 339, 338, 337, 336, 335, 334, 333, 332, 331,
+ 330, 329, 328, 327, 326, 325, 324, 320, 319, 318,
+ 317, 316, 312, 308, 307, 306, 305, 301, 300, 299,
+ 298, 297, 296, 292, 291, 290, 289, 288, 284, 283,
+ 282, 279, 278, 277, 276, 275, 274, 273, 272, 271,
+ 270, 269, 268, 267, 266, 265, 264, 263, 262, 261,
+ 257, 256, 255, 254, 253, 252, 251, 250, 249, 248,
+ 247, 246, 245, 244, 243, 242, 241, 240, 239, 238,
+ 237, 236, 235, 234, 231, 230, 229, 228, 227, 226,
+ 221, 218, 217, 216, 213, 212, 211, 210, 209, 208,
- 115, 89, 84, 69, 64, 410, 7, 410, 410, 410,
- 410, 410, 410, 410, 410, 410, 410, 410, 410, 410,
- 410, 410, 410, 410, 410, 410, 410, 410, 410, 410,
- 410, 410, 410, 410, 410, 410, 410, 410, 410, 410,
- 410, 410, 410, 410, 410, 410, 410, 410, 410, 410,
- 410, 410, 410, 410, 410, 410, 410, 410, 410, 410,
- 410, 410, 410, 410, 410, 410, 410, 410, 410, 410
+ 205, 204, 203, 202, 201, 200, 199, 198, 197, 196,
+ 195, 194, 191, 185, 184, 183, 182, 181, 180, 177,
+ 176, 175, 174, 173, 172, 171, 170, 169, 168, 167,
+ 166, 165, 164, 163, 162, 161, 160, 159, 150, 147,
+ 131, 127, 122, 115, 89, 84, 69, 64, 447, 7,
+ 447, 447, 447, 447, 447, 447, 447, 447, 447, 447,
+ 447, 447, 447, 447, 447, 447, 447, 447, 447, 447,
+ 447, 447, 447, 447, 447, 447, 447, 447, 447, 447,
+ 447, 447, 447, 447, 447, 447, 447, 447, 447, 447,
+ 447, 447, 447, 447, 447, 447, 447, 447, 447, 447,
+
+ 447, 447, 447, 447, 447, 447, 447, 447, 447, 447,
+ 447, 447, 447, 447, 447, 447
} ;
-static yyconst flex_int16_t yy_chk[671] =
+static yyconst flex_int16_t yy_chk[717] =
{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
@@ -657,77 +687,83 @@
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 3, 4, 12, 12, 28, 28, 3,
- 4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 1, 1, 1, 1, 1, 1, 3, 4, 12, 12,
+ 28, 28, 3, 4, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 13, 17, 19, 20, 20, 20,
- 20, 20, 20, 33, 415, 21, 34, 34, 19, 17,
- 21, 35, 13, 35, 33, 44, 408, 35, 51, 44,
- 21, 22, 51, 22, 22, 22, 22, 22, 22, 23,
- 407, 23, 23, 23, 23, 23, 23, 36, 22, 26,
- 22, 38, 55, 38, 397, 37, 23, 36, 22, 37,
- 36, 39, 38, 45, 37, 26, 23, 26, 26, 39,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 13, 17, 19, 20, 20, 20, 20, 20, 20, 20,
+ 33, 42, 21, 34, 34, 19, 17, 21, 42, 13,
+ 23, 445, 26, 33, 35, 42, 35, 444, 21, 22,
+ 35, 22, 22, 22, 22, 22, 22, 22, 23, 26,
+ 37, 26, 26, 36, 37, 55, 38, 22, 38, 37,
+ 23, 22, 39, 36, 47, 37, 36, 38, 41, 22,
- 37, 39, 42, 41, 39, 22, 45, 49, 47, 42,
- 39, 41, 167, 167, 49, 49, 42, 50, 135, 55,
- 50, 52, 41, 47, 49, 52, 47, 49, 50, 145,
- 396, 145, 395, 135, 52, 50, 74, 74, 74, 74,
- 74, 74, 78, 78, 78, 78, 78, 78, 381, 120,
- 393, 74, 120, 120, 122, 141, 120, 78, 120, 381,
- 392, 74, 122, 141, 391, 388, 79, 78, 79, 79,
- 79, 79, 79, 79, 80, 387, 80, 80, 80, 80,
- 80, 80, 385, 79, 155, 155, 155, 155, 155, 155,
- 81, 80, 81, 79, 382, 81, 81, 81, 81, 81,
+ 39, 45, 39, 44, 51, 39, 41, 44, 51, 47,
+ 79, 39, 47, 49, 45, 52, 22, 41, 443, 52,
+ 49, 49, 441, 50, 55, 439, 50, 112, 52, 122,
+ 49, 49, 438, 49, 50, 79, 437, 122, 80, 83,
+ 112, 50, 74, 74, 74, 74, 74, 74, 74, 78,
+ 78, 78, 78, 78, 78, 78, 80, 83, 74, 135,
+ 146, 435, 146, 142, 214, 78, 168, 168, 80, 83,
+ 74, 142, 214, 81, 135, 81, 434, 78, 81, 81,
+ 81, 81, 81, 81, 81, 120, 416, 416, 120, 120,
+ 433, 152, 120, 152, 120, 432, 152, 152, 152, 152,
- 81, 80, 83, 380, 83, 83, 83, 83, 83, 83,
- 192, 192, 192, 379, 378, 151, 376, 151, 211, 83,
- 151, 151, 151, 151, 151, 151, 211, 375, 374, 83,
- 153, 153, 153, 153, 153, 153, 215, 215, 215, 371,
- 370, 154, 369, 154, 368, 153, 154, 154, 154, 154,
- 154, 154, 226, 226, 226, 153, 156, 156, 156, 156,
- 156, 156, 219, 219, 219, 219, 219, 219, 220, 220,
- 220, 220, 220, 220, 221, 221, 221, 221, 221, 221,
- 222, 222, 222, 222, 222, 222, 234, 234, 234, 241,
- 241, 241, 245, 245, 245, 251, 251, 251, 411, 411,
+ 152, 152, 152, 154, 154, 154, 154, 154, 154, 154,
+ 194, 194, 194, 431, 430, 155, 429, 155, 427, 154,
+ 155, 155, 155, 155, 155, 155, 155, 218, 218, 218,
+ 426, 154, 156, 156, 156, 156, 156, 156, 156, 157,
+ 157, 157, 157, 157, 157, 157, 222, 222, 222, 222,
+ 222, 222, 222, 223, 223, 223, 223, 223, 223, 223,
+ 224, 224, 224, 224, 224, 224, 224, 225, 225, 225,
+ 225, 225, 225, 225, 229, 229, 229, 237, 237, 237,
+ 245, 245, 245, 249, 249, 249, 255, 255, 255, 388,
+ 388, 388, 425, 424, 423, 422, 421, 420, 419, 418,
- 411, 411, 412, 412, 413, 413, 414, 367, 414, 414,
- 366, 365, 364, 359, 356, 353, 352, 351, 350, 349,
- 347, 345, 344, 343, 342, 340, 339, 337, 335, 334,
- 333, 332, 331, 330, 329, 327, 326, 325, 324, 323,
- 322, 321, 320, 319, 315, 314, 311, 300, 296, 295,
- 294, 293, 286, 285, 284, 279, 278, 277, 276, 275,
- 274, 271, 270, 269, 268, 267, 266, 265, 264, 263,
- 262, 261, 260, 259, 258, 257, 250, 249, 248, 247,
- 246, 244, 240, 239, 238, 237, 233, 232, 231, 230,
- 229, 228, 225, 223, 218, 217, 216, 214, 213, 212,
+ 417, 415, 388, 448, 448, 448, 448, 448, 448, 449,
+ 449, 450, 450, 450, 451, 451, 451, 452, 406, 452,
+ 452, 452, 452, 453, 453, 454, 454, 405, 404, 403,
+ 402, 400, 399, 398, 395, 394, 392, 389, 387, 386,
+ 385, 383, 382, 381, 378, 377, 376, 375, 374, 373,
+ 372, 371, 365, 362, 359, 358, 357, 356, 355, 353,
+ 351, 350, 349, 348, 346, 345, 343, 341, 340, 339,
+ 338, 337, 336, 335, 334, 332, 331, 330, 329, 328,
+ 327, 326, 325, 324, 320, 319, 316, 305, 301, 300,
+ 299, 298, 291, 290, 289, 284, 283, 282, 281, 280,
- 210, 209, 208, 207, 206, 205, 204, 203, 202, 201,
- 200, 199, 198, 197, 196, 195, 194, 193, 191, 190,
- 189, 188, 187, 186, 185, 184, 183, 182, 181, 180,
- 179, 177, 176, 175, 174, 173, 172, 171, 170, 169,
- 168, 166, 165, 164, 163, 162, 161, 146, 144, 143,
- 142, 140, 139, 138, 137, 136, 134, 133, 132, 131,
- 130, 129, 128, 127, 126, 125, 124, 123, 121, 118,
- 117, 116, 115, 114, 113, 112, 111, 110, 109, 108,
- 107, 106, 105, 104, 103, 102, 101, 100, 99, 98,
- 97, 96, 95, 91, 87, 60, 53, 48, 46, 43,
+ 279, 276, 275, 274, 273, 272, 271, 270, 269, 268,
+ 267, 266, 265, 264, 263, 262, 261, 254, 253, 252,
+ 251, 250, 248, 244, 242, 241, 240, 236, 235, 234,
+ 233, 232, 231, 228, 226, 221, 220, 219, 217, 216,
+ 215, 213, 212, 211, 210, 209, 208, 207, 206, 205,
+ 204, 203, 202, 201, 200, 199, 198, 197, 196, 195,
+ 193, 192, 191, 190, 189, 188, 187, 186, 185, 184,
+ 183, 182, 181, 179, 178, 177, 176, 175, 174, 173,
+ 172, 171, 170, 169, 167, 166, 165, 164, 163, 162,
+ 147, 145, 144, 143, 141, 140, 139, 138, 137, 136,
- 40, 27, 24, 16, 11, 7, 410, 410, 410, 410,
- 410, 410, 410, 410, 410, 410, 410, 410, 410, 410,
- 410, 410, 410, 410, 410, 410, 410, 410, 410, 410,
- 410, 410, 410, 410, 410, 410, 410, 410, 410, 410,
- 410, 410, 410, 410, 410, 410, 410, 410, 410, 410,
- 410, 410, 410, 410, 410, 410, 410, 410, 410, 410,
- 410, 410, 410, 410, 410, 410, 410, 410, 410, 410
+ 134, 133, 132, 131, 130, 129, 128, 127, 126, 125,
+ 124, 123, 121, 118, 117, 116, 115, 114, 113, 111,
+ 110, 109, 108, 107, 106, 105, 104, 103, 102, 101,
+ 100, 99, 98, 97, 96, 95, 91, 87, 60, 53,
+ 48, 46, 43, 40, 27, 24, 16, 11, 7, 447,
+ 447, 447, 447, 447, 447, 447, 447, 447, 447, 447,
+ 447, 447, 447, 447, 447, 447, 447, 447, 447, 447,
+ 447, 447, 447, 447, 447, 447, 447, 447, 447, 447,
+ 447, 447, 447, 447, 447, 447, 447, 447, 447, 447,
+ 447, 447, 447, 447, 447, 447, 447, 447, 447, 447,
+
+ 447, 447, 447, 447, 447, 447, 447, 447, 447, 447,
+ 447, 447, 447, 447, 447, 447
} ;
/* Table of booleans, true if rule could match eol. */
-static yyconst flex_int32_t yy_rule_can_match_eol[146] =
+static yyconst flex_int32_t yy_rule_can_match_eol[155] =
{ 0,
0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -736,7 +772,7 @@
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 1, 0, 0, };
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, };
/* The intent behind this definition is that it'll catch
* any uses of REJECT which flex missed.
@@ -747,7 +783,7 @@
#define YY_RESTORE_YY_MORE_OFFSET
/*
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
@@ -756,7 +792,7 @@
Based on ANSI C grammar, Lex specification:
http://www.lysator.liu.se/c/ANSI-C-grammar-l.html
-IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_glslang_lexer.sh,
+IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_parser.sh,
WHICH GENERATES THE GLSL ES LEXER (glslang_lex.cpp).
*/
@@ -1062,13 +1098,13 @@
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 411 )
+ if ( yy_current_state >= 448 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
++yy_cp;
}
- while ( yy_current_state != 410 );
+ while ( yy_current_state != 447 );
yy_cp = yyg->yy_last_accepting_cpos;
yy_current_state = yyg->yy_last_accepting_state;
@@ -1449,233 +1485,269 @@
YY_BREAK
case 88:
YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+ YY_BREAK
+case 89:
+YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+ YY_BREAK
+case 90:
+YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+ YY_BREAK
+case 91:
+YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+ YY_BREAK
+case 92:
+YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+ YY_BREAK
+case 93:
+YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+ YY_BREAK
+case 94:
+YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+ YY_BREAK
+case 95:
+YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+ YY_BREAK
+case 96:
+YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+ YY_BREAK
+case 97:
+YY_RULE_SETUP
{
yylval->lex.string = NewPoolTString(yytext);
return check_type(yyscanner);
}
YY_BREAK
-case 89:
-YY_RULE_SETUP
-{ yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); }
- YY_BREAK
-case 90:
-YY_RULE_SETUP
-{ yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); }
- YY_BREAK
-case 91:
-YY_RULE_SETUP
-{ context->error(yylineno, "Invalid Octal number.", yytext, "", ""); context->recover(); return 0;}
- YY_BREAK
-case 92:
-YY_RULE_SETUP
-{ yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); }
- YY_BREAK
-case 93:
-YY_RULE_SETUP
-{ yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
- YY_BREAK
-case 94:
-YY_RULE_SETUP
-{ yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
- YY_BREAK
-case 95:
-YY_RULE_SETUP
-{ yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
- YY_BREAK
-case 96:
-YY_RULE_SETUP
-{ return(ADD_ASSIGN); }
- YY_BREAK
-case 97:
-YY_RULE_SETUP
-{ return(SUB_ASSIGN); }
- YY_BREAK
case 98:
YY_RULE_SETUP
-{ return(MUL_ASSIGN); }
+{ yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); }
YY_BREAK
case 99:
YY_RULE_SETUP
-{ return(DIV_ASSIGN); }
+{ yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); }
YY_BREAK
case 100:
YY_RULE_SETUP
-{ return(MOD_ASSIGN); }
+{ context->error(yylineno, "Invalid Octal number.", yytext, "", ""); context->recover(); return 0;}
YY_BREAK
case 101:
YY_RULE_SETUP
-{ return(LEFT_ASSIGN); }
+{ yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); }
YY_BREAK
case 102:
YY_RULE_SETUP
-{ return(RIGHT_ASSIGN); }
+{ yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
YY_BREAK
case 103:
YY_RULE_SETUP
-{ return(AND_ASSIGN); }
+{ yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
YY_BREAK
case 104:
YY_RULE_SETUP
-{ return(XOR_ASSIGN); }
+{ yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
YY_BREAK
case 105:
YY_RULE_SETUP
-{ return(OR_ASSIGN); }
+{ return(ADD_ASSIGN); }
YY_BREAK
case 106:
YY_RULE_SETUP
-{ return(INC_OP); }
+{ return(SUB_ASSIGN); }
YY_BREAK
case 107:
YY_RULE_SETUP
-{ return(DEC_OP); }
+{ return(MUL_ASSIGN); }
YY_BREAK
case 108:
YY_RULE_SETUP
-{ return(AND_OP); }
+{ return(DIV_ASSIGN); }
YY_BREAK
case 109:
YY_RULE_SETUP
-{ return(OR_OP); }
+{ return(MOD_ASSIGN); }
YY_BREAK
case 110:
YY_RULE_SETUP
-{ return(XOR_OP); }
+{ return(LEFT_ASSIGN); }
YY_BREAK
case 111:
YY_RULE_SETUP
-{ return(LE_OP); }
+{ return(RIGHT_ASSIGN); }
YY_BREAK
case 112:
YY_RULE_SETUP
-{ return(GE_OP); }
+{ return(AND_ASSIGN); }
YY_BREAK
case 113:
YY_RULE_SETUP
-{ return(EQ_OP); }
+{ return(XOR_ASSIGN); }
YY_BREAK
case 114:
YY_RULE_SETUP
-{ return(NE_OP); }
+{ return(OR_ASSIGN); }
YY_BREAK
case 115:
YY_RULE_SETUP
-{ return(LEFT_OP); }
+{ return(INC_OP); }
YY_BREAK
case 116:
YY_RULE_SETUP
-{ return(RIGHT_OP); }
+{ return(DEC_OP); }
YY_BREAK
case 117:
YY_RULE_SETUP
-{ context->lexAfterType = false; return(SEMICOLON); }
+{ return(AND_OP); }
YY_BREAK
case 118:
YY_RULE_SETUP
-{ context->lexAfterType = false; return(LEFT_BRACE); }
+{ return(OR_OP); }
YY_BREAK
case 119:
YY_RULE_SETUP
-{ return(RIGHT_BRACE); }
+{ return(XOR_OP); }
YY_BREAK
case 120:
YY_RULE_SETUP
-{ if (context->inTypeParen) context->lexAfterType = false; return(COMMA); }
+{ return(LE_OP); }
YY_BREAK
case 121:
YY_RULE_SETUP
-{ return(COLON); }
+{ return(GE_OP); }
YY_BREAK
case 122:
YY_RULE_SETUP
-{ context->lexAfterType = false; return(EQUAL); }
+{ return(EQ_OP); }
YY_BREAK
case 123:
YY_RULE_SETUP
-{ context->lexAfterType = false; context->inTypeParen = true; return(LEFT_PAREN); }
+{ return(NE_OP); }
YY_BREAK
case 124:
YY_RULE_SETUP
-{ context->inTypeParen = false; return(RIGHT_PAREN); }
+{ return(LEFT_OP); }
YY_BREAK
case 125:
YY_RULE_SETUP
-{ return(LEFT_BRACKET); }
+{ return(RIGHT_OP); }
YY_BREAK
case 126:
YY_RULE_SETUP
-{ return(RIGHT_BRACKET); }
+{ context->lexAfterType = false; return(SEMICOLON); }
YY_BREAK
case 127:
YY_RULE_SETUP
-{ BEGIN(FIELDS); return(DOT); }
+{ context->lexAfterType = false; return(LEFT_BRACE); }
YY_BREAK
case 128:
YY_RULE_SETUP
-{ return(BANG); }
+{ return(RIGHT_BRACE); }
YY_BREAK
case 129:
YY_RULE_SETUP
-{ return(DASH); }
+{ if (context->inTypeParen) context->lexAfterType = false; return(COMMA); }
YY_BREAK
case 130:
YY_RULE_SETUP
-{ return(TILDE); }
+{ return(COLON); }
YY_BREAK
case 131:
YY_RULE_SETUP
-{ return(PLUS); }
+{ context->lexAfterType = false; return(EQUAL); }
YY_BREAK
case 132:
YY_RULE_SETUP
-{ return(STAR); }
+{ context->lexAfterType = false; context->inTypeParen = true; return(LEFT_PAREN); }
YY_BREAK
case 133:
YY_RULE_SETUP
-{ return(SLASH); }
+{ context->inTypeParen = false; return(RIGHT_PAREN); }
YY_BREAK
case 134:
YY_RULE_SETUP
-{ return(PERCENT); }
+{ return(LEFT_BRACKET); }
YY_BREAK
case 135:
YY_RULE_SETUP
-{ return(LEFT_ANGLE); }
+{ return(RIGHT_BRACKET); }
YY_BREAK
case 136:
YY_RULE_SETUP
-{ return(RIGHT_ANGLE); }
+{ BEGIN(FIELDS); return(DOT); }
YY_BREAK
case 137:
YY_RULE_SETUP
-{ return(VERTICAL_BAR); }
+{ return(BANG); }
YY_BREAK
case 138:
YY_RULE_SETUP
-{ return(CARET); }
+{ return(DASH); }
YY_BREAK
case 139:
YY_RULE_SETUP
-{ return(AMPERSAND); }
+{ return(TILDE); }
YY_BREAK
case 140:
YY_RULE_SETUP
-{ return(QUESTION); }
+{ return(PLUS); }
YY_BREAK
case 141:
YY_RULE_SETUP
+{ return(STAR); }
+ YY_BREAK
+case 142:
+YY_RULE_SETUP
+{ return(SLASH); }
+ YY_BREAK
+case 143:
+YY_RULE_SETUP
+{ return(PERCENT); }
+ YY_BREAK
+case 144:
+YY_RULE_SETUP
+{ return(LEFT_ANGLE); }
+ YY_BREAK
+case 145:
+YY_RULE_SETUP
+{ return(RIGHT_ANGLE); }
+ YY_BREAK
+case 146:
+YY_RULE_SETUP
+{ return(VERTICAL_BAR); }
+ YY_BREAK
+case 147:
+YY_RULE_SETUP
+{ return(CARET); }
+ YY_BREAK
+case 148:
+YY_RULE_SETUP
+{ return(AMPERSAND); }
+ YY_BREAK
+case 149:
+YY_RULE_SETUP
+{ return(QUESTION); }
+ YY_BREAK
+case 150:
+YY_RULE_SETUP
{
BEGIN(INITIAL);
yylval->lex.string = NewPoolTString(yytext);
return FIELD_SELECTION;
}
YY_BREAK
-case 142:
+case 151:
YY_RULE_SETUP
{}
YY_BREAK
-case 143:
-/* rule 143 can match eol */
+case 152:
+/* rule 152 can match eol */
YY_RULE_SETUP
{ }
YY_BREAK
@@ -1684,11 +1756,11 @@
case YY_STATE_EOF(FIELDS):
{ context->AfterEOF = true; yyterminate(); }
YY_BREAK
-case 144:
+case 153:
YY_RULE_SETUP
{ context->warning(yylineno, "Unknown char", yytext, ""); return 0; }
YY_BREAK
-case 145:
+case 154:
YY_RULE_SETUP
ECHO;
YY_BREAK
@@ -1984,7 +2056,7 @@
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 411 )
+ if ( yy_current_state >= 448 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
@@ -2013,11 +2085,11 @@
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 411 )
+ if ( yy_current_state >= 448 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
- yy_is_jam = (yy_current_state == 410);
+ yy_is_jam = (yy_current_state == 447);
return yy_is_jam ? 0 : yy_current_state;
}
@@ -3096,6 +3168,8 @@
msg = TString("extension '") + extName + "' is not supported";
context->infoSink.info.message(EPrefixWarning, msg.c_str(), yylineno);
break;
+ default:
+ break;
}
return;
} else
diff --git a/src/OpenGL ES 2.0/compiler/glslang_tab.cpp b/src/OpenGL ES 2.0/compiler/glslang_tab.cpp
index 83ac524..1396583 100644
--- a/src/OpenGL ES 2.0/compiler/glslang_tab.cpp
+++ b/src/OpenGL ES 2.0/compiler/glslang_tab.cpp
@@ -1,24 +1,22 @@
-/* A Bison parser, made by GNU Bison 2.3. */
+/* A Bison parser, made by GNU Bison 2.4.2. */
/* Skeleton implementation for Bison's Yacc-like parsers in C
-
- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
- Free Software Foundation, Inc.
-
- This program is free software; you can redistribute it and/or modify
+
+ Copyright (C) 1984, 1989-1990, 2000-2006, 2009-2010 Free Software
+ Foundation, Inc.
+
+ This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* As a special exception, you may create a larger work that contains
part or all of the Bison parser skeleton and distribute that work
@@ -29,7 +27,7 @@
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
-
+
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
@@ -47,7 +45,7 @@
#define YYBISON 1
/* Bison version. */
-#define YYBISON_VERSION "2.3"
+#define YYBISON_VERSION "2.4.2"
/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"
@@ -55,11 +53,55 @@
/* Pure parsers. */
#define YYPURE 1
+/* Push parsers. */
+#define YYPUSH 0
+
+/* Pull parsers. */
+#define YYPULL 1
+
/* Using locations. */
#define YYLSP_NEEDED 0
+/* Copy the first part of user declarations. */
+
+
+//
+// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// This file is auto-generated by generate_glslang_parser.sh. DO NOT EDIT!
+
+#include "compiler/SymbolTable.h"
+#include "compiler/ParseHelper.h"
+#include "GLSLANG/ShaderLang.h"
+
+#define YYLEX_PARAM context->scanner
+
+
+
+/* Enabling traces. */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+
+/* Enabling verbose error messages. */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 0
+#endif
+
+/* Enabling the token table. */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
+#endif
+
+
/* Tokens. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
@@ -159,142 +201,14 @@
QUESTION = 348
};
#endif
-/* Tokens. */
-#define INVARIANT 258
-#define HIGH_PRECISION 259
-#define MEDIUM_PRECISION 260
-#define LOW_PRECISION 261
-#define PRECISION 262
-#define ATTRIBUTE 263
-#define CONST_QUAL 264
-#define BOOL_TYPE 265
-#define FLOAT_TYPE 266
-#define INT_TYPE 267
-#define BREAK 268
-#define CONTINUE 269
-#define DO 270
-#define ELSE 271
-#define FOR 272
-#define IF 273
-#define DISCARD 274
-#define RETURN 275
-#define BVEC2 276
-#define BVEC3 277
-#define BVEC4 278
-#define IVEC2 279
-#define IVEC3 280
-#define IVEC4 281
-#define VEC2 282
-#define VEC3 283
-#define VEC4 284
-#define MATRIX2 285
-#define MATRIX3 286
-#define MATRIX4 287
-#define IN_QUAL 288
-#define OUT_QUAL 289
-#define INOUT_QUAL 290
-#define UNIFORM 291
-#define VARYING 292
-#define STRUCT 293
-#define VOID_TYPE 294
-#define WHILE 295
-#define SAMPLER2D 296
-#define SAMPLERCUBE 297
-#define IDENTIFIER 298
-#define TYPE_NAME 299
-#define FLOATCONSTANT 300
-#define INTCONSTANT 301
-#define BOOLCONSTANT 302
-#define FIELD_SELECTION 303
-#define LEFT_OP 304
-#define RIGHT_OP 305
-#define INC_OP 306
-#define DEC_OP 307
-#define LE_OP 308
-#define GE_OP 309
-#define EQ_OP 310
-#define NE_OP 311
-#define AND_OP 312
-#define OR_OP 313
-#define XOR_OP 314
-#define MUL_ASSIGN 315
-#define DIV_ASSIGN 316
-#define ADD_ASSIGN 317
-#define MOD_ASSIGN 318
-#define LEFT_ASSIGN 319
-#define RIGHT_ASSIGN 320
-#define AND_ASSIGN 321
-#define XOR_ASSIGN 322
-#define OR_ASSIGN 323
-#define SUB_ASSIGN 324
-#define LEFT_PAREN 325
-#define RIGHT_PAREN 326
-#define LEFT_BRACKET 327
-#define RIGHT_BRACKET 328
-#define LEFT_BRACE 329
-#define RIGHT_BRACE 330
-#define DOT 331
-#define COMMA 332
-#define COLON 333
-#define EQUAL 334
-#define SEMICOLON 335
-#define BANG 336
-#define DASH 337
-#define TILDE 338
-#define PLUS 339
-#define STAR 340
-#define SLASH 341
-#define PERCENT 342
-#define LEFT_ANGLE 343
-#define RIGHT_ANGLE 344
-#define VERTICAL_BAR 345
-#define CARET 346
-#define AMPERSAND 347
-#define QUESTION 348
-
-/* Copy the first part of user declarations. */
-
-
-//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-
-// This file is auto-generated by generate_glslang_parser.sh. DO NOT EDIT!
-
-#include "compiler/SymbolTable.h"
-#include "compiler/ParseHelper.h"
-#include "GLSLANG/ShaderLang.h"
-
-#define YYLEX_PARAM context->scanner
-
-
-/* Enabling traces. */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-
-/* Enabling verbose error messages. */
-#ifdef YYERROR_VERBOSE
-# undef YYERROR_VERBOSE
-# define YYERROR_VERBOSE 1
-#else
-# define YYERROR_VERBOSE 0
-#endif
-
-/* Enabling the token table. */
-#ifndef YYTOKEN_TABLE
-# define YYTOKEN_TABLE 0
-#endif
-
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef union YYSTYPE
-
{
+
+
struct {
TSourceLoc line;
union {
@@ -324,17 +238,16 @@
TTypeList* typeList;
};
} interm;
-}
-/* Line 193 of yacc.c. */
- YYSTYPE;
+
+
+} YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1
-# define YYSTYPE_IS_TRIVIAL 1
#endif
-
/* Copy the second part of user declarations. */
@@ -364,8 +277,6 @@
}
-/* Line 216 of yacc.c. */
-
#ifdef short
# undef short
@@ -440,14 +351,14 @@
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static int
-YYID (int i)
+YYID (int yyi)
#else
static int
-YYID (i)
- int i;
+YYID (yyi)
+ int yyi;
#endif
{
- return i;
+ return yyi;
}
#endif
@@ -528,9 +439,9 @@
/* A type that is properly aligned for any stack member. */
union yyalloc
{
- yytype_int16 yyss;
- YYSTYPE yyvs;
- };
+ yytype_int16 yyss_alloc;
+ YYSTYPE yyvs_alloc;
+};
/* The size of the maximum gap between one aligned stack and the next. */
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
@@ -564,12 +475,12 @@
elements in the stack, and YYPTR gives the new location of the
stack. Advance YYPTR to a properly aligned location for the next
stack. */
-# define YYSTACK_RELOCATE(Stack) \
+# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
do \
{ \
YYSIZE_T yynewbytes; \
- YYCOPY (&yyptr->Stack, Stack, yysize); \
- Stack = &yyptr->Stack; \
+ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
+ Stack = &yyptr->Stack_alloc; \
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \
} \
@@ -580,16 +491,16 @@
/* YYFINAL -- State number of the termination state. */
#define YYFINAL 69
/* YYLAST -- Last index in YYTABLE. */
-#define YYLAST 1334
+#define YYLAST 1419
/* YYNTOKENS -- Number of terminals. */
#define YYNTOKENS 94
/* YYNNTS -- Number of nonterminals. */
-#define YYNNTS 78
+#define YYNNTS 81
/* YYNRULES -- Number of rules. */
-#define YYNRULES 193
+#define YYNRULES 197
/* YYNRULES -- Number of states. */
-#define YYNSTATES 296
+#define YYNSTATES 300
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
#define YYUNDEFTOK 2
@@ -659,16 +570,16 @@
368, 370, 372, 374, 376, 378, 380, 386, 391, 393,
396, 400, 402, 406, 408, 413, 415, 417, 419, 421,
423, 425, 427, 429, 431, 434, 435, 436, 442, 444,
- 446, 449, 453, 455, 458, 460, 463, 469, 473, 475,
- 477, 482, 483, 490, 491, 500, 501, 509, 511, 513,
- 515, 516, 519, 523, 526, 529, 532, 536, 539, 541,
- 544, 546, 548, 549
+ 446, 447, 450, 451, 454, 457, 461, 463, 466, 468,
+ 471, 477, 481, 483, 485, 490, 491, 498, 499, 508,
+ 509, 517, 519, 521, 523, 524, 527, 531, 534, 537,
+ 540, 544, 547, 549, 552, 554, 556, 557
};
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
static const yytype_int16 yyrhs[] =
{
- 168, 0, -1, 43, -1, 95, -1, 46, -1, 45,
+ 171, 0, -1, 43, -1, 95, -1, 46, -1, 45,
-1, 47, -1, 70, 122, 71, -1, 96, -1, 97,
72, 98, 73, -1, 99, -1, 97, 76, 48, -1,
97, 51, -1, 97, 52, -1, 122, -1, 100, -1,
@@ -710,20 +621,21 @@
-1, 143, -1, 142, 143, -1, 137, 144, 80, -1,
145, -1, 144, 77, 145, -1, 43, -1, 43, 72,
123, 73, -1, 120, -1, 124, -1, 150, -1, 149,
- -1, 147, -1, 156, -1, 157, -1, 160, -1, 167,
- -1, 74, 75, -1, -1, -1, 74, 151, 155, 152,
- 75, -1, 154, -1, 149, -1, 74, 75, -1, 74,
- 155, 75, -1, 148, -1, 155, 148, -1, 80, -1,
- 122, 80, -1, 18, 70, 122, 71, 158, -1, 148,
- 16, 148, -1, 148, -1, 122, -1, 135, 43, 79,
- 146, -1, -1, 40, 70, 161, 159, 71, 153, -1,
- -1, 15, 162, 148, 40, 70, 122, 71, 80, -1,
- -1, 17, 70, 163, 164, 166, 71, 153, -1, 156,
- -1, 147, -1, 159, -1, -1, 165, 80, -1, 165,
- 80, 122, -1, 14, 80, -1, 13, 80, -1, 20,
- 80, -1, 20, 122, 80, -1, 19, 80, -1, 169,
- -1, 168, 169, -1, 170, -1, 124, -1, -1, 125,
- 171, 154, -1
+ -1, 147, -1, 159, -1, 160, -1, 163, -1, 170,
+ -1, 74, 75, -1, -1, -1, 74, 151, 158, 152,
+ 75, -1, 157, -1, 149, -1, -1, 155, 157, -1,
+ -1, 156, 149, -1, 74, 75, -1, 74, 158, 75,
+ -1, 148, -1, 158, 148, -1, 80, -1, 122, 80,
+ -1, 18, 70, 122, 71, 161, -1, 154, 16, 154,
+ -1, 154, -1, 122, -1, 135, 43, 79, 146, -1,
+ -1, 40, 70, 164, 162, 71, 153, -1, -1, 15,
+ 165, 154, 40, 70, 122, 71, 80, -1, -1, 17,
+ 70, 166, 167, 169, 71, 153, -1, 159, -1, 147,
+ -1, 162, -1, -1, 168, 80, -1, 168, 80, 122,
+ -1, 14, 80, -1, 13, 80, -1, 20, 80, -1,
+ 20, 122, 80, -1, 19, 80, -1, 172, -1, 171,
+ 172, -1, 173, -1, 124, -1, -1, 125, 174, 157,
+ -1
};
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
@@ -736,19 +648,19 @@
755, 766, 770, 771, 781, 791, 801, 814, 815, 825,
838, 842, 846, 850, 851, 864, 865, 878, 879, 892,
893, 910, 911, 924, 925, 926, 927, 928, 932, 935,
- 946, 954, 979, 984, 991, 1027, 1030, 1037, 1045, 1066,
- 1085, 1096, 1125, 1130, 1140, 1145, 1155, 1158, 1161, 1164,
- 1170, 1177, 1187, 1203, 1221, 1245, 1268, 1272, 1290, 1298,
- 1330, 1350, 1426, 1435, 1458, 1461, 1467, 1475, 1483, 1491,
- 1494, 1501, 1504, 1507, 1513, 1516, 1531, 1535, 1539, 1543,
- 1552, 1557, 1562, 1567, 1572, 1577, 1582, 1587, 1592, 1597,
- 1603, 1609, 1615, 1620, 1625, 1630, 1643, 1656, 1664, 1667,
- 1682, 1713, 1717, 1723, 1731, 1747, 1751, 1755, 1756, 1762,
- 1763, 1764, 1765, 1766, 1770, 1771, 1771, 1771, 1781, 1782,
- 1787, 1790, 1800, 1803, 1809, 1810, 1814, 1822, 1826, 1836,
- 1841, 1858, 1858, 1863, 1863, 1870, 1870, 1878, 1881, 1887,
- 1890, 1896, 1900, 1907, 1914, 1921, 1928, 1939, 1948, 1952,
- 1959, 1962, 1968, 1968
+ 946, 954, 981, 986, 993, 1031, 1034, 1041, 1049, 1070,
+ 1091, 1102, 1131, 1136, 1146, 1151, 1161, 1164, 1167, 1170,
+ 1176, 1183, 1193, 1215, 1233, 1257, 1280, 1284, 1302, 1310,
+ 1342, 1362, 1451, 1460, 1483, 1486, 1492, 1500, 1508, 1516,
+ 1519, 1526, 1529, 1532, 1538, 1541, 1556, 1560, 1564, 1568,
+ 1577, 1582, 1587, 1592, 1597, 1602, 1607, 1612, 1617, 1622,
+ 1628, 1634, 1640, 1645, 1650, 1655, 1668, 1681, 1689, 1692,
+ 1707, 1738, 1742, 1748, 1756, 1772, 1776, 1780, 1781, 1787,
+ 1788, 1789, 1790, 1791, 1795, 1796, 1796, 1796, 1806, 1807,
+ 1811, 1811, 1812, 1812, 1817, 1820, 1830, 1833, 1839, 1840,
+ 1844, 1852, 1856, 1866, 1871, 1888, 1888, 1893, 1893, 1900,
+ 1900, 1908, 1911, 1917, 1920, 1926, 1930, 1937, 1944, 1951,
+ 1958, 1969, 1978, 1982, 1989, 1992, 1998, 1998
};
#endif
@@ -795,13 +707,13 @@
"struct_declaration_list", "struct_declaration",
"struct_declarator_list", "struct_declarator", "initializer",
"declaration_statement", "statement", "simple_statement",
- "compound_statement", "@1", "@2", "statement_no_new_scope",
- "compound_statement_no_new_scope", "statement_list",
- "expression_statement", "selection_statement",
- "selection_rest_statement", "condition", "iteration_statement", "@3",
- "@4", "@5", "for_init_statement", "conditionopt", "for_rest_statement",
+ "compound_statement", "$@1", "$@2", "statement_no_new_scope",
+ "statement_with_scope", "$@3", "$@4", "compound_statement_no_new_scope",
+ "statement_list", "expression_statement", "selection_statement",
+ "selection_rest_statement", "condition", "iteration_statement", "$@5",
+ "$@6", "$@7", "for_init_statement", "conditionopt", "for_rest_statement",
"jump_statement", "translation_unit", "external_declaration",
- "function_definition", "@6", 0
+ "function_definition", "$@8", 0
};
#endif
@@ -842,10 +754,10 @@
140, 140, 140, 140, 140, 140, 141, 141, 142, 142,
143, 144, 144, 145, 145, 146, 147, 148, 148, 149,
149, 149, 149, 149, 150, 151, 152, 150, 153, 153,
- 154, 154, 155, 155, 156, 156, 157, 158, 158, 159,
- 159, 161, 160, 162, 160, 163, 160, 164, 164, 165,
- 165, 166, 166, 167, 167, 167, 167, 167, 168, 168,
- 169, 169, 171, 170
+ 155, 154, 156, 154, 157, 157, 158, 158, 159, 159,
+ 160, 161, 161, 162, 162, 164, 163, 165, 163, 166,
+ 163, 167, 167, 168, 168, 169, 169, 170, 170, 170,
+ 170, 170, 171, 171, 172, 172, 174, 173
};
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
@@ -867,10 +779,10 @@
1, 1, 1, 1, 1, 1, 5, 4, 1, 2,
3, 1, 3, 1, 4, 1, 1, 1, 1, 1,
1, 1, 1, 1, 2, 0, 0, 5, 1, 1,
- 2, 3, 1, 2, 1, 2, 5, 3, 1, 1,
- 4, 0, 6, 0, 8, 0, 7, 1, 1, 1,
- 0, 2, 3, 2, 2, 2, 3, 2, 1, 2,
- 1, 1, 0, 3
+ 0, 2, 0, 2, 2, 3, 1, 2, 1, 2,
+ 5, 3, 1, 1, 4, 0, 6, 0, 8, 0,
+ 7, 1, 1, 1, 0, 2, 3, 2, 2, 2,
+ 3, 2, 1, 2, 1, 1, 0, 3
};
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
@@ -881,33 +793,33 @@
0, 0, 111, 112, 113, 0, 105, 104, 119, 117,
118, 123, 124, 125, 126, 127, 128, 120, 121, 122,
129, 130, 131, 108, 106, 0, 116, 132, 133, 135,
- 191, 192, 0, 76, 86, 0, 91, 96, 0, 102,
- 0, 109, 114, 134, 0, 188, 190, 107, 101, 0,
+ 195, 196, 0, 76, 86, 0, 91, 96, 0, 102,
+ 0, 109, 114, 134, 0, 192, 194, 107, 101, 0,
0, 0, 71, 0, 74, 86, 0, 87, 88, 89,
77, 0, 86, 0, 72, 97, 103, 110, 0, 1,
- 189, 0, 0, 0, 0, 138, 0, 193, 78, 83,
+ 193, 0, 0, 0, 0, 138, 0, 197, 78, 83,
85, 90, 0, 92, 79, 0, 0, 2, 5, 4,
6, 27, 0, 0, 0, 34, 33, 32, 3, 8,
28, 10, 15, 16, 0, 0, 21, 0, 35, 0,
38, 41, 42, 47, 50, 51, 52, 53, 55, 57,
59, 70, 0, 25, 73, 0, 143, 0, 141, 137,
- 139, 0, 0, 173, 0, 0, 0, 0, 0, 155,
- 160, 164, 35, 61, 68, 0, 146, 0, 102, 149,
- 162, 148, 147, 0, 150, 151, 152, 153, 80, 82,
+ 139, 0, 0, 177, 0, 0, 0, 0, 0, 155,
+ 164, 168, 35, 61, 68, 0, 146, 0, 102, 149,
+ 166, 148, 147, 0, 150, 151, 152, 153, 80, 82,
84, 0, 0, 98, 0, 145, 100, 29, 30, 0,
12, 13, 0, 0, 19, 18, 0, 116, 22, 24,
31, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 115, 136, 0, 0, 140,
- 184, 183, 0, 175, 0, 187, 185, 0, 171, 154,
- 0, 64, 65, 66, 67, 63, 0, 0, 165, 161,
- 163, 0, 93, 0, 95, 99, 7, 0, 14, 26,
+ 188, 187, 162, 179, 0, 191, 189, 0, 175, 154,
+ 0, 64, 65, 66, 67, 63, 0, 0, 169, 165,
+ 167, 0, 93, 0, 95, 99, 7, 0, 14, 26,
11, 17, 23, 36, 37, 40, 39, 45, 46, 43,
44, 48, 49, 54, 56, 58, 0, 0, 142, 0,
- 0, 0, 186, 0, 156, 62, 69, 0, 94, 9,
- 0, 144, 0, 178, 177, 180, 0, 169, 0, 0,
- 0, 81, 60, 0, 179, 0, 0, 168, 166, 0,
- 0, 157, 0, 181, 0, 0, 0, 159, 172, 158,
- 0, 182, 176, 167, 170, 174
+ 0, 0, 0, 0, 190, 0, 156, 62, 69, 0,
+ 94, 9, 0, 144, 0, 161, 163, 182, 181, 184,
+ 162, 173, 0, 0, 0, 81, 60, 0, 183, 0,
+ 0, 172, 170, 0, 0, 157, 0, 185, 0, 162,
+ 0, 159, 176, 158, 0, 186, 180, 171, 174, 178
};
/* YYDEFGOTO[NTERM-NUM]. */
@@ -918,301 +830,298 @@
116, 117, 118, 119, 120, 143, 144, 216, 145, 122,
146, 147, 32, 33, 34, 79, 60, 61, 80, 35,
36, 37, 38, 123, 40, 41, 42, 43, 74, 75,
- 127, 128, 166, 149, 150, 151, 152, 210, 270, 288,
- 289, 153, 154, 155, 278, 269, 156, 253, 202, 250,
- 265, 275, 276, 157, 44, 45, 46, 53
+ 127, 128, 166, 149, 150, 151, 152, 210, 274, 292,
+ 249, 250, 251, 293, 153, 154, 155, 282, 273, 156,
+ 255, 202, 252, 269, 279, 280, 157, 44, 45, 46,
+ 53
};
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
-#define YYPACT_NINF -250
+#define YYPACT_NINF -258
static const yytype_int16 yypact[] =
{
- 1225, 36, -250, -250, -250, 150, -250, -250, -250, -250,
- -250, -250, -250, -250, -250, -250, -250, -250, -250, -250,
- -250, -250, -250, -250, -250, -33, -250, -250, -250, -250,
- -250, -60, -22, -17, 21, -62, -250, 22, 1266, -250,
- 1290, -250, 11, -250, 1138, -250, -250, -250, -250, 1290,
- 14, 1266, -250, 27, -250, 34, 41, -250, -250, -250,
- -250, 1266, 129, 61, -250, 17, -250, -250, 908, -250,
- -250, 31, 1266, 72, 1042, -250, 283, -250, -250, -250,
- -250, 90, 1266, -46, -250, 194, 908, 65, -250, -250,
- -250, -250, 908, 908, 908, -250, -250, -250, -250, -250,
- -40, -250, -250, -250, 80, -25, 975, 87, -250, 908,
- 35, 13, -250, -26, 68, -250, -250, -250, 110, 109,
- -54, -250, 96, -250, -250, 1083, 98, 33, -250, -250,
- -250, 91, 92, -250, 104, 107, 99, 760, 108, 105,
- -250, -250, 24, -250, -250, 37, -250, -60, 112, -250,
- -250, -250, -250, 365, -250, -250, -250, -250, 111, -250,
- -250, 827, 908, -250, 113, -250, -250, -250, -250, 4,
- -250, -250, 908, 1179, -250, -250, 908, 114, -250, -250,
- -250, 908, 908, 908, 908, 908, 908, 908, 908, 908,
- 908, 908, 908, 908, 908, -250, -250, 908, 72, -250,
- -250, -250, 447, -250, 908, -250, -250, 42, -250, -250,
- 447, -250, -250, -250, -250, -250, 908, 908, -250, -250,
- -250, 908, -250, 115, -250, -250, -250, 116, 117, -250,
- 120, -250, -250, -250, -250, 35, 35, -250, -250, -250,
- -250, -26, -26, -250, 110, 109, 51, 119, -250, 144,
- 611, 23, -250, 693, 447, -250, -250, 122, -250, -250,
- 908, -250, 123, -250, -250, 693, 447, 117, 153, 126,
- 128, -250, -250, 908, -250, 127, 137, 171, -250, 130,
- 529, -250, 28, 908, 529, 447, 908, -250, -250, -250,
- 131, 117, -250, -250, -250, -250
+ 1310, 46, -258, -258, -258, 123, -258, -258, -258, -258,
+ -258, -258, -258, -258, -258, -258, -258, -258, -258, -258,
+ -258, -258, -258, -258, -258, -9, -258, -258, -258, -258,
+ -258, -47, -34, -57, 21, 24, -258, 17, 1351, -258,
+ 1375, -258, 3, -258, 1223, -258, -258, -258, -258, 1375,
+ 11, 1351, -258, 56, -258, 33, 96, -258, -258, -258,
+ -258, 1351, 121, 106, -258, 14, -258, -258, 993, -258,
+ -258, 71, 1351, 114, 1127, -258, 286, -258, -258, -258,
+ -258, 120, 1351, 16, -258, 197, 993, 95, -258, -258,
+ -258, -258, 993, 993, 993, -258, -258, -258, -258, -258,
+ -33, -258, -258, -258, 97, 23, 1060, 99, -258, 993,
+ -70, -11, -258, -26, 65, -258, -258, -258, 109, 108,
+ -41, -258, 98, -258, -258, 1168, 100, 37, -258, -258,
+ -258, 90, 93, -258, 104, 105, 101, 845, 110, 107,
+ -258, -258, 18, -258, -258, 38, -258, -47, 113, -258,
+ -258, -258, -258, 368, -258, -258, -258, -258, 112, -258,
+ -258, 912, 993, -258, 115, -258, -258, -258, -258, 25,
+ -258, -258, 993, 1264, -258, -258, 993, 116, -258, -258,
+ -258, 993, 993, 993, 993, 993, 993, 993, 993, 993,
+ 993, 993, 993, 993, 993, -258, -258, 993, 114, -258,
+ -258, -258, 111, -258, 993, -258, -258, 42, -258, -258,
+ 450, -258, -258, -258, -258, -258, 993, 993, -258, -258,
+ -258, 993, -258, 117, -258, -258, -258, 118, 102, -258,
+ 119, -258, -258, -258, -258, -70, -70, -258, -258, -258,
+ -258, -26, -26, -258, 109, 108, 82, 122, -258, 152,
+ 56, 614, 696, 28, -258, 778, 450, -258, -258, 124,
+ -258, -258, 993, -258, 128, -258, -258, -258, -258, 778,
+ 111, 102, 150, 129, 131, -258, -258, 993, -258, 132,
+ 133, 178, -258, 134, 532, -258, 35, 993, 532, 111,
+ 993, -258, -258, -258, 135, 102, -258, -258, -258, -258
};
/* YYPGOTO[NTERM-NUM]. */
static const yytype_int16 yypgoto[] =
{
- -250, -250, -250, -250, -250, -250, -250, 39, -250, -250,
- -250, -250, -45, -250, -18, -250, -79, -30, -250, -250,
- -250, 38, 52, 20, -250, -63, -85, -250, -92, -71,
- 6, 9, -250, -250, -250, 132, 172, 166, 148, -250,
- -250, -246, -21, 0, 226, -24, -250, -250, 162, -66,
- -250, 45, -159, -3, -136, -249, -250, -250, -250, -36,
- 196, 46, 1, -250, -250, -13, -250, -250, -250, -250,
- -250, -250, -250, -250, -250, 211, -250, -250
+ -258, -258, -258, -258, -258, -258, -258, 41, -258, -258,
+ -258, -258, -45, -258, -60, -258, -77, -28, -258, -258,
+ -258, 20, 39, 40, -258, -63, -85, -258, -91, -71,
+ 6, 9, -258, -258, -258, 148, 161, 155, 164, -258,
+ -258, -244, -24, 0, 227, -14, -258, -258, 162, -66,
+ -258, 49, -155, -15, -149, -239, -258, -258, -258, -38,
+ -257, -258, -258, -51, 43, 2, -258, -258, -12, -258,
+ -258, -258, -258, -258, -258, -258, -258, -258, 214, -258,
+ -258
};
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
positive, shift that token. If negative, reduce the rule which
number is the opposite. If zero, do what YYDEFACT says.
If YYTABLE_NINF, syntax error. */
-#define YYTABLE_NINF -76
+#define YYTABLE_NINF -161
static const yytype_int16 yytable[] =
{
- 39, 165, 169, 224, 193, 121, 30, 268, 130, 31,
- 50, 170, 171, 62, 164, 63, 67, 220, 64, 268,
- 52, 178, 121, 108, 56, 71, 161, 185, 186, 6,
- 7, 287, 172, 162, 62, 287, 173, 56, 66, 194,
- 108, 51, 6, 7, 39, 207, 175, 167, 168, 54,
- 30, 73, 176, 31, 57, 58, 59, 23, 24, 130,
- 55, 81, 187, 188, 180, 65, 249, 57, 58, 59,
- 23, 24, 73, 47, 73, 226, 148, 165, 47, 48,
- 228, 217, 81, 68, 211, 212, 213, 84, 72, 85,
- 223, 232, -75, 214, 266, 183, 86, 184, 121, 290,
- 217, 76, 246, 215, 83, 217, 237, 238, 239, 240,
- 198, 124, 251, 199, 217, 126, 108, 218, 220, 217,
- 181, 182, 252, 189, 190, 73, 247, 294, 217, 260,
- 277, 255, 256, 158, 121, -26, 233, 234, 108, 108,
- 108, 108, 108, 108, 108, 108, 108, 108, 108, 293,
- 257, 174, 108, 148, 2, 3, 4, 179, 121, 241,
- 242, 267, 57, 58, 59, 235, 236, 191, 192, 195,
- 197, 200, 201, 267, 203, 272, 108, 204, 208, 205,
- 209, 282, -25, 221, 262, -20, 225, 285, 258, 259,
- -27, 291, 261, 273, 217, 271, 279, 280, 2, 3,
- 4, 165, 148, 281, 8, 9, 10, 283, 284, 286,
- 148, 295, 231, 245, 159, 11, 12, 13, 14, 15,
- 16, 17, 18, 19, 20, 21, 22, 78, 82, 243,
- 160, 49, 25, 26, 125, 27, 28, 87, 29, 88,
- 89, 90, 91, 248, 244, 92, 93, 263, 292, 77,
- 148, 264, 274, 148, 148, 70, 254, 0, 0, 0,
- 0, 0, 0, 0, 94, 148, 148, 163, 0, 0,
- 0, 0, 0, 0, 0, 95, 96, 0, 97, 0,
- 148, 0, 0, 0, 148, 148, 1, 2, 3, 4,
- 5, 6, 7, 8, 9, 10, 131, 132, 133, 0,
- 134, 135, 136, 137, 11, 12, 13, 14, 15, 16,
- 17, 18, 19, 20, 21, 22, 0, 0, 0, 23,
- 24, 25, 26, 138, 27, 28, 87, 29, 88, 89,
- 90, 91, 0, 0, 92, 93, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 94, 0, 0, 0, 139, 140, 0,
- 0, 0, 0, 141, 95, 96, 0, 97, 1, 2,
- 3, 4, 5, 6, 7, 8, 9, 10, 131, 132,
- 133, 0, 134, 135, 136, 137, 11, 12, 13, 14,
- 15, 16, 17, 18, 19, 20, 21, 22, 0, 0,
- 0, 23, 24, 25, 26, 138, 27, 28, 87, 29,
- 88, 89, 90, 91, 0, 0, 92, 93, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 94, 0, 0, 0, 139,
- 219, 0, 0, 0, 0, 141, 95, 96, 0, 97,
- 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
- 131, 132, 133, 0, 134, 135, 136, 137, 11, 12,
+ 39, 165, 77, 169, 220, 121, 30, 224, 130, 31,
+ 62, 272, 266, 281, 164, 181, 182, 193, 170, 171,
+ 55, 178, 121, 108, 56, 272, 67, 185, 186, 6,
+ 7, 62, 297, 52, 50, 71, 56, 54, 66, 172,
+ 108, 6, 7, 173, 39, 291, 207, 167, 168, 291,
+ 30, 73, 194, 31, 57, 58, 59, 23, 24, 130,
+ 65, 81, 187, 188, 180, 51, 57, 58, 59, 23,
+ 24, 183, 73, 184, 73, 68, 148, 165, 211, 212,
+ 213, 228, 81, 47, 84, 72, 85, 214, 161, 48,
+ 223, 232, -75, 86, 175, 162, 226, 215, 121, 270,
+ 176, 63, 217, 246, 64, 217, 294, 220, 237, 238,
+ 239, 240, 217, 253, 198, 217, 108, 199, 218, 217,
+ 189, 190, 254, 235, 236, 73, 247, 2, 3, 4,
+ 76, 257, 258, 47, 121, 298, 233, 234, 108, 108,
+ 108, 108, 108, 108, 108, 108, 108, 108, 108, 83,
+ 259, 124, 108, 148, 57, 58, 59, 126, 121, 217,
+ 262, 241, 242, 158, 271, -26, 191, 192, 174, 179,
+ 200, 195, 197, 201, 203, 204, 108, 276, 271, 217,
+ 208, 205, 209, -25, 221, -160, 286, -20, 225, -27,
+ 260, 261, 264, 283, 289, 263, 295, 275, 277, 265,
+ 284, 2, 3, 4, 288, 165, 285, 8, 9, 10,
+ 148, 243, 287, 290, 231, 299, 78, 82, 11, 12,
13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
- 0, 0, 0, 23, 24, 25, 26, 138, 27, 28,
- 87, 29, 88, 89, 90, 91, 0, 0, 92, 93,
+ 159, 244, 49, 245, 125, 25, 26, 267, 27, 28,
+ 87, 29, 88, 89, 90, 91, 160, 248, 92, 93,
+ 296, 148, 148, 256, 268, 148, 148, 278, 70, 0,
+ 0, 0, 0, 0, 0, 0, 0, 94, 0, 148,
+ 163, 0, 0, 0, 0, 0, 0, 0, 95, 96,
+ 0, 97, 0, 0, 148, 0, 0, 0, 148, 1,
+ 2, 3, 4, 5, 6, 7, 8, 9, 10, 131,
+ 132, 133, 0, 134, 135, 136, 137, 11, 12, 13,
+ 14, 15, 16, 17, 18, 19, 20, 21, 22, 0,
+ 0, 0, 23, 24, 25, 26, 138, 27, 28, 87,
+ 29, 88, 89, 90, 91, 0, 0, 92, 93, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 94, 0, 0,
- 0, 139, 0, 0, 0, 0, 0, 141, 95, 96,
- 0, 97, 1, 2, 3, 4, 5, 6, 7, 8,
- 9, 10, 131, 132, 133, 0, 134, 135, 136, 137,
- 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
- 21, 22, 0, 0, 0, 23, 24, 25, 26, 138,
- 27, 28, 87, 29, 88, 89, 90, 91, 0, 0,
- 92, 93, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 94,
- 0, 0, 0, 76, 0, 0, 0, 0, 0, 141,
- 95, 96, 0, 97, 1, 2, 3, 4, 5, 6,
- 7, 8, 9, 10, 0, 0, 0, 0, 0, 0,
- 0, 0, 11, 12, 13, 14, 15, 16, 17, 18,
- 19, 20, 21, 22, 0, 0, 0, 23, 24, 25,
- 26, 0, 27, 28, 87, 29, 88, 89, 90, 91,
- 0, 0, 92, 93, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 94, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 141, 95, 96, 0, 97, 56, 2, 3, 4,
- 0, 6, 7, 8, 9, 10, 0, 0, 0, 0,
- 0, 0, 0, 0, 11, 12, 13, 14, 15, 16,
- 17, 18, 19, 20, 21, 22, 0, 0, 0, 23,
- 24, 25, 26, 0, 27, 28, 87, 29, 88, 89,
- 90, 91, 0, 0, 92, 93, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 94, 2, 3, 4, 0, 0, 0,
- 8, 9, 10, 0, 95, 96, 0, 97, 0, 0,
- 0, 11, 12, 13, 14, 15, 16, 17, 18, 19,
- 20, 21, 22, 0, 0, 0, 0, 0, 25, 26,
- 0, 27, 28, 87, 29, 88, 89, 90, 91, 0,
+ 0, 0, 0, 0, 0, 0, 94, 0, 0, 0,
+ 139, 140, 0, 0, 0, 0, 141, 95, 96, 0,
+ 97, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+ 10, 131, 132, 133, 0, 134, 135, 136, 137, 11,
+ 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+ 22, 0, 0, 0, 23, 24, 25, 26, 138, 27,
+ 28, 87, 29, 88, 89, 90, 91, 0, 0, 92,
+ 93, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 94, 0,
+ 0, 0, 139, 219, 0, 0, 0, 0, 141, 95,
+ 96, 0, 97, 1, 2, 3, 4, 5, 6, 7,
+ 8, 9, 10, 131, 132, 133, 0, 134, 135, 136,
+ 137, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+ 20, 21, 22, 0, 0, 0, 23, 24, 25, 26,
+ 138, 27, 28, 87, 29, 88, 89, 90, 91, 0,
0, 92, 93, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 94, 2, 3, 4, 0, 0, 0, 8, 9, 10,
- 206, 95, 96, 0, 97, 0, 0, 0, 11, 12,
- 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
- 0, 0, 0, 0, 0, 25, 26, 0, 27, 28,
- 87, 29, 88, 89, 90, 91, 0, 0, 92, 93,
+ 94, 0, 0, 0, 139, 0, 0, 0, 0, 0,
+ 141, 95, 96, 0, 97, 1, 2, 3, 4, 5,
+ 6, 7, 8, 9, 10, 131, 132, 133, 0, 134,
+ 135, 136, 137, 11, 12, 13, 14, 15, 16, 17,
+ 18, 19, 20, 21, 22, 0, 0, 0, 23, 24,
+ 25, 26, 138, 27, 28, 87, 29, 88, 89, 90,
+ 91, 0, 0, 92, 93, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 94, 0, 0,
- 222, 0, 0, 0, 0, 0, 0, 0, 95, 96,
- 0, 97, 2, 3, 4, 0, 0, 0, 8, 9,
+ 0, 0, 94, 0, 0, 0, 76, 0, 0, 0,
+ 0, 0, 141, 95, 96, 0, 97, 1, 2, 3,
+ 4, 5, 6, 7, 8, 9, 10, 131, 132, 133,
+ 0, 134, 135, 136, 137, 11, 12, 13, 14, 15,
+ 16, 17, 18, 19, 20, 21, 22, 0, 0, 0,
+ 23, 24, 25, 26, 138, 27, 28, 87, 29, 88,
+ 89, 90, 91, 0, 0, 92, 93, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 94, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 141, 95, 96, 0, 97, 1,
+ 2, 3, 4, 5, 6, 7, 8, 9, 10, 0,
+ 0, 0, 0, 0, 0, 0, 0, 11, 12, 13,
+ 14, 15, 16, 17, 18, 19, 20, 21, 22, 0,
+ 0, 0, 23, 24, 25, 26, 0, 27, 28, 87,
+ 29, 88, 89, 90, 91, 0, 0, 92, 93, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 94, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 141, 95, 96, 0,
+ 97, 56, 2, 3, 4, 0, 6, 7, 8, 9,
10, 0, 0, 0, 0, 0, 0, 0, 0, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
- 22, 0, 0, 0, 0, 0, 25, 26, 0, 27,
+ 22, 0, 0, 0, 23, 24, 25, 26, 0, 27,
28, 87, 29, 88, 89, 90, 91, 0, 0, 92,
93, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 94, 2,
3, 4, 0, 0, 0, 8, 9, 10, 0, 95,
96, 0, 97, 0, 0, 0, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 0, 0,
- 0, 0, 0, 25, 177, 0, 27, 28, 87, 29,
+ 0, 0, 0, 25, 26, 0, 27, 28, 87, 29,
88, 89, 90, 91, 0, 0, 92, 93, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 94, 2, 3, 4, 0,
- 0, 0, 8, 9, 10, 0, 95, 96, 0, 97,
+ 0, 0, 8, 9, 10, 206, 95, 96, 0, 97,
0, 0, 0, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 0, 0, 0, 0, 0,
- 25, 26, 0, 27, 28, 0, 29, 2, 3, 4,
+ 25, 26, 0, 27, 28, 87, 29, 88, 89, 90,
+ 91, 0, 0, 92, 93, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 94, 0, 0, 222, 0, 0, 0, 0,
+ 0, 0, 0, 95, 96, 0, 97, 2, 3, 4,
0, 0, 0, 8, 9, 10, 0, 0, 0, 0,
0, 0, 0, 0, 11, 12, 13, 14, 15, 16,
- 17, 18, 19, 20, 21, 22, 0, 129, 0, 0,
- 0, 25, 26, 0, 27, 28, 0, 29, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 69, 0,
- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
- 10, 0, 0, 0, 0, 0, 0, 0, 196, 11,
+ 17, 18, 19, 20, 21, 22, 0, 0, 0, 0,
+ 0, 25, 26, 0, 27, 28, 87, 29, 88, 89,
+ 90, 91, 0, 0, 92, 93, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 94, 2, 3, 4, 0, 0, 0,
+ 8, 9, 10, 0, 95, 96, 0, 97, 0, 0,
+ 0, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+ 20, 21, 22, 0, 0, 0, 0, 0, 25, 177,
+ 0, 27, 28, 87, 29, 88, 89, 90, 91, 0,
+ 0, 92, 93, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 94, 2, 3, 4, 0, 0, 0, 8, 9, 10,
+ 0, 95, 96, 0, 97, 0, 0, 0, 11, 12,
+ 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
+ 0, 0, 0, 0, 0, 25, 26, 0, 27, 28,
+ 0, 29, 2, 3, 4, 0, 0, 0, 8, 9,
+ 10, 0, 0, 0, 0, 0, 0, 0, 0, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
- 22, 0, 0, 0, 23, 24, 25, 26, 0, 27,
- 28, 0, 29, 2, 3, 4, 0, 0, 0, 8,
- 9, 10, 0, 0, 0, 0, 0, 0, 0, 0,
- 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
- 21, 22, 0, 0, 0, 0, 0, 25, 26, 0,
- 27, 28, 229, 29, 0, 0, 0, 230, 1, 2,
- 3, 4, 5, 6, 7, 8, 9, 10, 0, 0,
- 0, 0, 0, 0, 0, 0, 11, 12, 13, 14,
+ 22, 0, 129, 0, 0, 0, 25, 26, 0, 27,
+ 28, 0, 29, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 69, 0, 0, 1, 2, 3, 4,
+ 5, 6, 7, 8, 9, 10, 0, 0, 0, 0,
+ 0, 0, 0, 196, 11, 12, 13, 14, 15, 16,
+ 17, 18, 19, 20, 21, 22, 0, 0, 0, 23,
+ 24, 25, 26, 0, 27, 28, 0, 29, 2, 3,
+ 4, 0, 0, 0, 8, 9, 10, 0, 0, 0,
+ 0, 0, 0, 0, 0, 11, 12, 13, 14, 15,
+ 16, 17, 18, 19, 20, 21, 22, 0, 0, 0,
+ 0, 0, 25, 26, 0, 27, 28, 229, 29, 0,
+ 0, 0, 230, 1, 2, 3, 4, 5, 6, 7,
+ 8, 9, 10, 0, 0, 0, 0, 0, 0, 0,
+ 0, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+ 20, 21, 22, 0, 0, 0, 23, 24, 25, 26,
+ 0, 27, 28, 0, 29, 2, 3, 4, 0, 0,
+ 0, 8, 9, 10, 0, 0, 0, 0, 0, 0,
+ 0, 0, 11, 12, 13, 14, 15, 16, 17, 18,
+ 19, 20, 21, 22, 0, 8, 9, 10, 0, 25,
+ 26, 0, 27, 28, 0, 29, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 0, 0,
- 0, 23, 24, 25, 26, 0, 27, 28, 0, 29,
- 2, 3, 4, 0, 0, 0, 8, 9, 10, 0,
- 0, 0, 0, 0, 0, 0, 0, 11, 12, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 0,
- 8, 9, 10, 0, 25, 26, 0, 27, 28, 0,
- 29, 11, 12, 13, 14, 15, 16, 17, 18, 19,
- 20, 21, 22, 0, 0, 0, 0, 0, 25, 26,
- 0, 27, 28, 0, 29
+ 0, 0, 0, 25, 26, 0, 27, 28, 0, 29
};
static const yytype_int16 yycheck[] =
{
- 0, 86, 94, 162, 58, 68, 0, 253, 74, 0,
- 43, 51, 52, 34, 85, 77, 40, 153, 80, 265,
- 80, 106, 85, 68, 3, 49, 72, 53, 54, 8,
- 9, 280, 72, 79, 55, 284, 76, 3, 38, 93,
- 85, 74, 8, 9, 44, 137, 71, 92, 93, 71,
- 44, 51, 77, 44, 33, 34, 35, 36, 37, 125,
- 77, 61, 88, 89, 109, 43, 202, 33, 34, 35,
- 36, 37, 72, 37, 74, 71, 76, 162, 37, 43,
- 172, 77, 82, 72, 60, 61, 62, 70, 74, 72,
- 161, 176, 71, 69, 71, 82, 79, 84, 161, 71,
- 77, 74, 194, 79, 43, 77, 185, 186, 187, 188,
- 77, 80, 204, 80, 77, 43, 161, 80, 254, 77,
- 85, 86, 80, 55, 56, 125, 197, 286, 77, 78,
- 266, 216, 217, 43, 197, 70, 181, 182, 183, 184,
- 185, 186, 187, 188, 189, 190, 191, 192, 193, 285,
- 221, 71, 197, 153, 4, 5, 6, 70, 221, 189,
- 190, 253, 33, 34, 35, 183, 184, 57, 59, 73,
- 72, 80, 80, 265, 70, 260, 221, 70, 70, 80,
- 75, 273, 70, 72, 40, 71, 73, 16, 73, 73,
- 70, 283, 73, 70, 77, 73, 43, 71, 4, 5,
- 6, 286, 202, 75, 10, 11, 12, 80, 71, 79,
- 210, 80, 173, 193, 82, 21, 22, 23, 24, 25,
- 26, 27, 28, 29, 30, 31, 32, 55, 62, 191,
- 82, 5, 38, 39, 72, 41, 42, 43, 44, 45,
- 46, 47, 48, 198, 192, 51, 52, 250, 284, 53,
- 250, 250, 265, 253, 254, 44, 210, -1, -1, -1,
- -1, -1, -1, -1, 70, 265, 266, 73, -1, -1,
- -1, -1, -1, -1, -1, 81, 82, -1, 84, -1,
- 280, -1, -1, -1, 284, 285, 3, 4, 5, 6,
- 7, 8, 9, 10, 11, 12, 13, 14, 15, -1,
- 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
- 27, 28, 29, 30, 31, 32, -1, -1, -1, 36,
- 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
- 47, 48, -1, -1, 51, 52, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 70, -1, -1, -1, 74, 75, -1,
- -1, -1, -1, 80, 81, 82, -1, 84, 3, 4,
- 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
- 15, -1, 17, 18, 19, 20, 21, 22, 23, 24,
- 25, 26, 27, 28, 29, 30, 31, 32, -1, -1,
- -1, 36, 37, 38, 39, 40, 41, 42, 43, 44,
- 45, 46, 47, 48, -1, -1, 51, 52, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 70, -1, -1, -1, 74,
- 75, -1, -1, -1, -1, 80, 81, 82, -1, 84,
- 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
- 13, 14, 15, -1, 17, 18, 19, 20, 21, 22,
+ 0, 86, 53, 94, 153, 68, 0, 162, 74, 0,
+ 34, 255, 251, 270, 85, 85, 86, 58, 51, 52,
+ 77, 106, 85, 68, 3, 269, 40, 53, 54, 8,
+ 9, 55, 289, 80, 43, 49, 3, 71, 38, 72,
+ 85, 8, 9, 76, 44, 284, 137, 92, 93, 288,
+ 44, 51, 93, 44, 33, 34, 35, 36, 37, 125,
+ 43, 61, 88, 89, 109, 74, 33, 34, 35, 36,
+ 37, 82, 72, 84, 74, 72, 76, 162, 60, 61,
+ 62, 172, 82, 37, 70, 74, 72, 69, 72, 43,
+ 161, 176, 71, 79, 71, 79, 71, 79, 161, 71,
+ 77, 77, 77, 194, 80, 77, 71, 256, 185, 186,
+ 187, 188, 77, 204, 77, 77, 161, 80, 80, 77,
+ 55, 56, 80, 183, 184, 125, 197, 4, 5, 6,
+ 74, 216, 217, 37, 197, 290, 181, 182, 183, 184,
+ 185, 186, 187, 188, 189, 190, 191, 192, 193, 43,
+ 221, 80, 197, 153, 33, 34, 35, 43, 221, 77,
+ 78, 189, 190, 43, 255, 70, 57, 59, 71, 70,
+ 80, 73, 72, 80, 70, 70, 221, 262, 269, 77,
+ 70, 80, 75, 70, 72, 74, 277, 71, 73, 70,
+ 73, 73, 40, 43, 16, 73, 287, 73, 70, 250,
+ 71, 4, 5, 6, 71, 290, 75, 10, 11, 12,
+ 210, 191, 80, 79, 173, 80, 55, 62, 21, 22,
23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
- -1, -1, -1, 36, 37, 38, 39, 40, 41, 42,
- 43, 44, 45, 46, 47, 48, -1, -1, 51, 52,
+ 82, 192, 5, 193, 72, 38, 39, 252, 41, 42,
+ 43, 44, 45, 46, 47, 48, 82, 198, 51, 52,
+ 288, 251, 252, 210, 252, 255, 256, 269, 44, -1,
+ -1, -1, -1, -1, -1, -1, -1, 70, -1, 269,
+ 73, -1, -1, -1, -1, -1, -1, -1, 81, 82,
+ -1, 84, -1, -1, 284, -1, -1, -1, 288, 3,
+ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+ 14, 15, -1, 17, 18, 19, 20, 21, 22, 23,
+ 24, 25, 26, 27, 28, 29, 30, 31, 32, -1,
+ -1, -1, 36, 37, 38, 39, 40, 41, 42, 43,
+ 44, 45, 46, 47, 48, -1, -1, 51, 52, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 70, -1, -1,
- -1, 74, -1, -1, -1, -1, -1, 80, 81, 82,
- -1, 84, 3, 4, 5, 6, 7, 8, 9, 10,
- 11, 12, 13, 14, 15, -1, 17, 18, 19, 20,
- 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
- 31, 32, -1, -1, -1, 36, 37, 38, 39, 40,
- 41, 42, 43, 44, 45, 46, 47, 48, -1, -1,
- 51, 52, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
- -1, -1, -1, 74, -1, -1, -1, -1, -1, 80,
- 81, 82, -1, 84, 3, 4, 5, 6, 7, 8,
- 9, 10, 11, 12, -1, -1, -1, -1, -1, -1,
- -1, -1, 21, 22, 23, 24, 25, 26, 27, 28,
- 29, 30, 31, 32, -1, -1, -1, 36, 37, 38,
- 39, -1, 41, 42, 43, 44, 45, 46, 47, 48,
- -1, -1, 51, 52, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 70, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 80, 81, 82, -1, 84, 3, 4, 5, 6,
- -1, 8, 9, 10, 11, 12, -1, -1, -1, -1,
- -1, -1, -1, -1, 21, 22, 23, 24, 25, 26,
- 27, 28, 29, 30, 31, 32, -1, -1, -1, 36,
- 37, 38, 39, -1, 41, 42, 43, 44, 45, 46,
- 47, 48, -1, -1, 51, 52, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 70, 4, 5, 6, -1, -1, -1,
- 10, 11, 12, -1, 81, 82, -1, 84, -1, -1,
- -1, 21, 22, 23, 24, 25, 26, 27, 28, 29,
- 30, 31, 32, -1, -1, -1, -1, -1, 38, 39,
- -1, 41, 42, 43, 44, 45, 46, 47, 48, -1,
+ -1, -1, -1, -1, -1, -1, 70, -1, -1, -1,
+ 74, 75, -1, -1, -1, -1, 80, 81, 82, -1,
+ 84, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+ 12, 13, 14, 15, -1, 17, 18, 19, 20, 21,
+ 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+ 32, -1, -1, -1, 36, 37, 38, 39, 40, 41,
+ 42, 43, 44, 45, 46, 47, 48, -1, -1, 51,
+ 52, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 70, -1,
+ -1, -1, 74, 75, -1, -1, -1, -1, 80, 81,
+ 82, -1, 84, 3, 4, 5, 6, 7, 8, 9,
+ 10, 11, 12, 13, 14, 15, -1, 17, 18, 19,
+ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+ 30, 31, 32, -1, -1, -1, 36, 37, 38, 39,
+ 40, 41, 42, 43, 44, 45, 46, 47, 48, -1,
-1, 51, 52, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 70, 4, 5, 6, -1, -1, -1, 10, 11, 12,
- 80, 81, 82, -1, 84, -1, -1, -1, 21, 22,
- 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
- -1, -1, -1, -1, -1, 38, 39, -1, 41, 42,
- 43, 44, 45, 46, 47, 48, -1, -1, 51, 52,
+ 70, -1, -1, -1, 74, -1, -1, -1, -1, -1,
+ 80, 81, 82, -1, 84, 3, 4, 5, 6, 7,
+ 8, 9, 10, 11, 12, 13, 14, 15, -1, 17,
+ 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
+ 28, 29, 30, 31, 32, -1, -1, -1, 36, 37,
+ 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+ 48, -1, -1, 51, 52, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 70, -1, -1,
- 73, -1, -1, -1, -1, -1, -1, -1, 81, 82,
- -1, 84, 4, 5, 6, -1, -1, -1, 10, 11,
+ -1, -1, 70, -1, -1, -1, 74, -1, -1, -1,
+ -1, -1, 80, 81, 82, -1, 84, 3, 4, 5,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ -1, 17, 18, 19, 20, 21, 22, 23, 24, 25,
+ 26, 27, 28, 29, 30, 31, 32, -1, -1, -1,
+ 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
+ 46, 47, 48, -1, -1, 51, 52, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 70, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 80, 81, 82, -1, 84, 3,
+ 4, 5, 6, 7, 8, 9, 10, 11, 12, -1,
+ -1, -1, -1, -1, -1, -1, -1, 21, 22, 23,
+ 24, 25, 26, 27, 28, 29, 30, 31, 32, -1,
+ -1, -1, 36, 37, 38, 39, -1, 41, 42, 43,
+ 44, 45, 46, 47, 48, -1, -1, 51, 52, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 70, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 80, 81, 82, -1,
+ 84, 3, 4, 5, 6, -1, 8, 9, 10, 11,
12, -1, -1, -1, -1, -1, -1, -1, -1, 21,
22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
- 32, -1, -1, -1, -1, -1, 38, 39, -1, 41,
+ 32, -1, -1, -1, 36, 37, 38, 39, -1, 41,
42, 43, 44, 45, 46, 47, 48, -1, -1, 51,
52, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 70, 4,
@@ -1223,35 +1132,56 @@
45, 46, 47, 48, -1, -1, 51, 52, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 70, 4, 5, 6, -1,
- -1, -1, 10, 11, 12, -1, 81, 82, -1, 84,
+ -1, -1, 10, 11, 12, 80, 81, 82, -1, 84,
-1, -1, -1, 21, 22, 23, 24, 25, 26, 27,
28, 29, 30, 31, 32, -1, -1, -1, -1, -1,
- 38, 39, -1, 41, 42, -1, 44, 4, 5, 6,
+ 38, 39, -1, 41, 42, 43, 44, 45, 46, 47,
+ 48, -1, -1, 51, 52, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 70, -1, -1, 73, -1, -1, -1, -1,
+ -1, -1, -1, 81, 82, -1, 84, 4, 5, 6,
-1, -1, -1, 10, 11, 12, -1, -1, -1, -1,
-1, -1, -1, -1, 21, 22, 23, 24, 25, 26,
- 27, 28, 29, 30, 31, 32, -1, 75, -1, -1,
- -1, 38, 39, -1, 41, 42, -1, 44, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 0, -1,
- -1, 3, 4, 5, 6, 7, 8, 9, 10, 11,
- 12, -1, -1, -1, -1, -1, -1, -1, 75, 21,
- 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
- 32, -1, -1, -1, 36, 37, 38, 39, -1, 41,
- 42, -1, 44, 4, 5, 6, -1, -1, -1, 10,
- 11, 12, -1, -1, -1, -1, -1, -1, -1, -1,
- 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
- 31, 32, -1, -1, -1, -1, -1, 38, 39, -1,
- 41, 42, 43, 44, -1, -1, -1, 48, 3, 4,
- 5, 6, 7, 8, 9, 10, 11, 12, -1, -1,
- -1, -1, -1, -1, -1, -1, 21, 22, 23, 24,
- 25, 26, 27, 28, 29, 30, 31, 32, -1, -1,
- -1, 36, 37, 38, 39, -1, 41, 42, -1, 44,
- 4, 5, 6, -1, -1, -1, 10, 11, 12, -1,
- -1, -1, -1, -1, -1, -1, -1, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, -1,
- 10, 11, 12, -1, 38, 39, -1, 41, 42, -1,
- 44, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+ 27, 28, 29, 30, 31, 32, -1, -1, -1, -1,
+ -1, 38, 39, -1, 41, 42, 43, 44, 45, 46,
+ 47, 48, -1, -1, 51, 52, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 70, 4, 5, 6, -1, -1, -1,
+ 10, 11, 12, -1, 81, 82, -1, 84, -1, -1,
+ -1, 21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, -1, -1, -1, -1, -1, 38, 39,
- -1, 41, 42, -1, 44
+ -1, 41, 42, 43, 44, 45, 46, 47, 48, -1,
+ -1, 51, 52, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 70, 4, 5, 6, -1, -1, -1, 10, 11, 12,
+ -1, 81, 82, -1, 84, -1, -1, -1, 21, 22,
+ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+ -1, -1, -1, -1, -1, 38, 39, -1, 41, 42,
+ -1, 44, 4, 5, 6, -1, -1, -1, 10, 11,
+ 12, -1, -1, -1, -1, -1, -1, -1, -1, 21,
+ 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+ 32, -1, 75, -1, -1, -1, 38, 39, -1, 41,
+ 42, -1, 44, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 0, -1, -1, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, 12, -1, -1, -1, -1,
+ -1, -1, -1, 75, 21, 22, 23, 24, 25, 26,
+ 27, 28, 29, 30, 31, 32, -1, -1, -1, 36,
+ 37, 38, 39, -1, 41, 42, -1, 44, 4, 5,
+ 6, -1, -1, -1, 10, 11, 12, -1, -1, -1,
+ -1, -1, -1, -1, -1, 21, 22, 23, 24, 25,
+ 26, 27, 28, 29, 30, 31, 32, -1, -1, -1,
+ -1, -1, 38, 39, -1, 41, 42, 43, 44, -1,
+ -1, -1, 48, 3, 4, 5, 6, 7, 8, 9,
+ 10, 11, 12, -1, -1, -1, -1, -1, -1, -1,
+ -1, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+ 30, 31, 32, -1, -1, -1, 36, 37, 38, 39,
+ -1, 41, 42, -1, 44, 4, 5, 6, -1, -1,
+ -1, 10, 11, 12, -1, -1, -1, -1, -1, -1,
+ -1, -1, 21, 22, 23, 24, 25, 26, 27, 28,
+ 29, 30, 31, 32, -1, 10, 11, 12, -1, 38,
+ 39, -1, 41, 42, -1, 44, 21, 22, 23, 24,
+ 25, 26, 27, 28, 29, 30, 31, 32, -1, -1,
+ -1, -1, -1, 38, 39, -1, 41, 42, -1, 44
};
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
@@ -1262,10 +1192,10 @@
12, 21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, 36, 37, 38, 39, 41, 42, 44,
124, 125, 126, 127, 128, 133, 134, 135, 136, 137,
- 138, 139, 140, 141, 168, 169, 170, 37, 43, 138,
- 43, 74, 80, 171, 71, 77, 3, 33, 34, 35,
+ 138, 139, 140, 141, 171, 172, 173, 37, 43, 138,
+ 43, 74, 80, 174, 71, 77, 3, 33, 34, 35,
130, 131, 136, 77, 80, 43, 137, 139, 72, 0,
- 169, 139, 74, 137, 142, 143, 74, 154, 130, 129,
+ 172, 139, 74, 137, 142, 143, 74, 157, 130, 129,
132, 137, 131, 43, 70, 72, 79, 43, 45, 46,
47, 48, 51, 52, 70, 81, 82, 84, 95, 96,
97, 99, 100, 101, 102, 103, 104, 105, 106, 107,
@@ -1273,21 +1203,21 @@
118, 119, 123, 137, 80, 142, 43, 144, 145, 75,
143, 13, 14, 15, 17, 18, 19, 20, 40, 74,
75, 80, 106, 119, 120, 122, 124, 125, 137, 147,
- 148, 149, 150, 155, 156, 157, 160, 167, 43, 129,
+ 148, 149, 150, 158, 159, 160, 163, 170, 43, 129,
132, 72, 79, 73, 123, 120, 146, 106, 106, 122,
51, 52, 72, 76, 71, 71, 77, 39, 120, 70,
106, 85, 86, 82, 84, 53, 54, 88, 89, 55,
56, 57, 59, 58, 93, 73, 75, 72, 77, 80,
- 80, 80, 162, 70, 70, 80, 80, 122, 70, 75,
+ 80, 80, 165, 70, 70, 80, 80, 122, 70, 75,
151, 60, 61, 62, 69, 79, 121, 77, 80, 75,
148, 72, 73, 123, 146, 73, 71, 98, 122, 43,
48, 101, 120, 106, 106, 108, 108, 110, 110, 110,
- 110, 111, 111, 115, 116, 117, 122, 123, 145, 148,
- 163, 122, 80, 161, 155, 120, 120, 123, 73, 73,
- 78, 73, 40, 147, 156, 164, 71, 122, 135, 159,
- 152, 73, 120, 70, 159, 165, 166, 148, 158, 43,
- 71, 75, 122, 80, 71, 16, 79, 149, 153, 154,
- 71, 122, 153, 148, 146, 80
+ 110, 111, 111, 115, 116, 117, 122, 123, 145, 154,
+ 155, 156, 166, 122, 80, 164, 158, 120, 120, 123,
+ 73, 73, 78, 73, 40, 157, 149, 147, 159, 167,
+ 71, 122, 135, 162, 152, 73, 120, 70, 162, 168,
+ 169, 154, 161, 43, 71, 75, 122, 80, 71, 16,
+ 79, 149, 153, 157, 71, 122, 153, 154, 146, 80
};
#define yyerrok (yyerrstatus = 0)
@@ -1302,9 +1232,18 @@
/* Like YYERROR except do call yyerror. This remains here temporarily
to ease the transition to the new meaning of YYERROR, for GCC.
- Once GCC version 2 has supplanted version 1, this can go. */
+ Once GCC version 2 has supplanted version 1, this can go. However,
+ YYFAIL appears to be in use. Nevertheless, it is formally deprecated
+ in Bison 2.4.2's NEWS entry, where a plan to phase it out is
+ discussed. */
#define YYFAIL goto yyerrlab
+#if defined YYFAIL
+ /* This is here to suppress warnings from the GCC cpp's
+ -Wunused-macros. Normally we don't worry about that warning, but
+ some users do, and we want to make it easy for users to remove
+ YYFAIL uses, which will produce warnings from Bison 2.5. */
+#endif
#define YYRECOVERING() (!!yyerrstatus)
@@ -1475,17 +1414,20 @@
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
-yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
+yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
#else
static void
-yy_stack_print (bottom, top)
- yytype_int16 *bottom;
- yytype_int16 *top;
+yy_stack_print (yybottom, yytop)
+ yytype_int16 *yybottom;
+ yytype_int16 *yytop;
#endif
{
YYFPRINTF (stderr, "Stack now");
- for (; bottom <= top; ++bottom)
- YYFPRINTF (stderr, " %d", *bottom);
+ for (; yybottom <= yytop; yybottom++)
+ {
+ int yybot = *yybottom;
+ YYFPRINTF (stderr, " %d", yybot);
+ }
YYFPRINTF (stderr, "\n");
}
@@ -1520,11 +1462,11 @@
/* The symbols being reduced. */
for (yyi = 0; yyi < yynrhs; yyi++)
{
- fprintf (stderr, " $%d = ", yyi + 1);
+ YYFPRINTF (stderr, " $%d = ", yyi + 1);
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
&(yyvsp[(yyi + 1) - (yynrhs)])
, context);
- fprintf (stderr, "\n");
+ YYFPRINTF (stderr, "\n");
}
}
@@ -1806,10 +1748,8 @@
break;
}
}
-
/* Prevent warnings from -Wmissing-prototypes. */
-
#ifdef YYPARSE_PARAM
#if defined __STDC__ || defined __cplusplus
int yyparse (void *YYPARSE_PARAM);
@@ -1828,10 +1768,9 @@
-
-/*----------.
-| yyparse. |
-`----------*/
+/*-------------------------.
+| yyparse or yypush_parse. |
+`-------------------------*/
#ifdef YYPARSE_PARAM
#if (defined __STDC__ || defined __C99__FUNC__ \
@@ -1855,22 +1794,46 @@
#endif
#endif
{
- /* The look-ahead symbol. */
+/* The lookahead symbol. */
int yychar;
-/* The semantic value of the look-ahead symbol. */
+/* The semantic value of the lookahead symbol. */
YYSTYPE yylval;
-/* Number of syntax errors so far. */
-int yynerrs;
+ /* Number of syntax errors so far. */
+ int yynerrs;
- int yystate;
+ int yystate;
+ /* Number of tokens to shift before error messages enabled. */
+ int yyerrstatus;
+
+ /* The stacks and their tools:
+ `yyss': related to states.
+ `yyvs': related to semantic values.
+
+ Refer to the stacks thru separate pointers, to allow yyoverflow
+ to reallocate them elsewhere. */
+
+ /* The state stack. */
+ yytype_int16 yyssa[YYINITDEPTH];
+ yytype_int16 *yyss;
+ yytype_int16 *yyssp;
+
+ /* The semantic value stack. */
+ YYSTYPE yyvsa[YYINITDEPTH];
+ YYSTYPE *yyvs;
+ YYSTYPE *yyvsp;
+
+ YYSIZE_T yystacksize;
+
int yyn;
int yyresult;
- /* Number of tokens to shift before error messages enabled. */
- int yyerrstatus;
- /* Look-ahead token as an internal (translated) token number. */
- int yytoken = 0;
+ /* Lookahead token as an internal (translated) token number. */
+ int yytoken;
+ /* The variables used to return semantic value and location from the
+ action routines. */
+ YYSTYPE yyval;
+
#if YYERROR_VERBOSE
/* Buffer for error messages, and its allocated size. */
char yymsgbuf[128];
@@ -1878,51 +1841,28 @@
YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
#endif
- /* Three stacks and their tools:
- `yyss': related to states,
- `yyvs': related to semantic values,
- `yyls': related to locations.
-
- Refer to the stacks thru separate pointers, to allow yyoverflow
- to reallocate them elsewhere. */
-
- /* The state stack. */
- yytype_int16 yyssa[YYINITDEPTH];
- yytype_int16 *yyss = yyssa;
- yytype_int16 *yyssp;
-
- /* The semantic value stack. */
- YYSTYPE yyvsa[YYINITDEPTH];
- YYSTYPE *yyvs = yyvsa;
- YYSTYPE *yyvsp;
-
-
-
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
- YYSIZE_T yystacksize = YYINITDEPTH;
-
- /* The variables used to return semantic value and location from the
- action routines. */
- YYSTYPE yyval;
-
-
/* The number of symbols on the RHS of the reduced rule.
Keep to zero when no symbol should be popped. */
int yylen = 0;
+ yytoken = 0;
+ yyss = yyssa;
+ yyvs = yyvsa;
+ yystacksize = YYINITDEPTH;
+
YYDPRINTF ((stderr, "Starting parse\n"));
yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
- yychar = YYEMPTY; /* Cause a token to be read. */
+ yychar = YYEMPTY; /* Cause a token to be read. */
/* Initialize stack pointers.
Waste one element of value and location stack
so that they stay on the same level as the state stack.
The wasted elements are never initialized. */
-
yyssp = yyss;
yyvsp = yyvs;
@@ -1952,7 +1892,6 @@
YYSTYPE *yyvs1 = yyvs;
yytype_int16 *yyss1 = yyss;
-
/* Each stack pointer address is followed by the size of the
data in use in that stack, in bytes. This used to be a
conditional around just the two extra args, but that might
@@ -1960,7 +1899,6 @@
yyoverflow (YY_("memory exhausted"),
&yyss1, yysize * sizeof (*yyssp),
&yyvs1, yysize * sizeof (*yyvsp),
-
&yystacksize);
yyss = yyss1;
@@ -1983,9 +1921,8 @@
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
if (! yyptr)
goto yyexhaustedlab;
- YYSTACK_RELOCATE (yyss);
- YYSTACK_RELOCATE (yyvs);
-
+ YYSTACK_RELOCATE (yyss_alloc, yyss);
+ YYSTACK_RELOCATE (yyvs_alloc, yyvs);
# undef YYSTACK_RELOCATE
if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);
@@ -1996,7 +1933,6 @@
yyssp = yyss + yysize - 1;
yyvsp = yyvs + yysize - 1;
-
YYDPRINTF ((stderr, "Stack size increased to %lu\n",
(unsigned long int) yystacksize));
@@ -2006,6 +1942,9 @@
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+ if (yystate == YYFINAL)
+ YYACCEPT;
+
goto yybackup;
/*-----------.
@@ -2014,16 +1953,16 @@
yybackup:
/* Do appropriate processing given the current state. Read a
- look-ahead token if we need one and don't already have one. */
+ lookahead token if we need one and don't already have one. */
- /* First try to decide what to do without reference to look-ahead token. */
+ /* First try to decide what to do without reference to lookahead token. */
yyn = yypact[yystate];
if (yyn == YYPACT_NINF)
goto yydefault;
- /* Not known => get a look-ahead token if don't already have one. */
+ /* Not known => get a lookahead token if don't already have one. */
- /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
+ /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
if (yychar == YYEMPTY)
{
YYDPRINTF ((stderr, "Reading a token: "));
@@ -2055,20 +1994,16 @@
goto yyreduce;
}
- if (yyn == YYFINAL)
- YYACCEPT;
-
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus)
yyerrstatus--;
- /* Shift the look-ahead token. */
+ /* Shift the lookahead token. */
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
- /* Discard the shifted token unless it is eof. */
- if (yychar != YYEOF)
- yychar = YYEMPTY;
+ /* Discard the shifted token. */
+ yychar = YYEMPTY;
yystate = yyn;
*++yyvsp = yylval;
@@ -2140,14 +2075,14 @@
(yyval.interm.intermTypedNode) = context->intermediate.addSymbol(variable->getUniqueId(),
variable->getName(),
variable->getType(), (yyvsp[(1) - (1)].lex).line);
- ;}
+ }
break;
case 3:
{
(yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
- ;}
+ }
break;
case 4:
@@ -2164,7 +2099,7 @@
ConstantUnion *unionArray = new ConstantUnion[1];
unionArray->setIConst((yyvsp[(1) - (1)].lex).i);
(yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtInt, EbpUndefined, EvqConst), (yyvsp[(1) - (1)].lex).line);
- ;}
+ }
break;
case 5:
@@ -2173,7 +2108,7 @@
ConstantUnion *unionArray = new ConstantUnion[1];
unionArray->setFConst((yyvsp[(1) - (1)].lex).f);
(yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtFloat, EbpUndefined, EvqConst), (yyvsp[(1) - (1)].lex).line);
- ;}
+ }
break;
case 6:
@@ -2182,21 +2117,21 @@
ConstantUnion *unionArray = new ConstantUnion[1];
unionArray->setBConst((yyvsp[(1) - (1)].lex).b);
(yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(1) - (1)].lex).line);
- ;}
+ }
break;
case 7:
{
(yyval.interm.intermTypedNode) = (yyvsp[(2) - (3)].interm.intermTypedNode);
- ;}
+ }
break;
case 8:
{
(yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
- ;}
+ }
break;
case 9:
@@ -2273,14 +2208,14 @@
(yyval.interm.intermTypedNode)->setType(TType((yyvsp[(1) - (4)].interm.intermTypedNode)->getBasicType(), (yyvsp[(1) - (4)].interm.intermTypedNode)->getPrecision(), EvqTemporary));
else
(yyval.interm.intermTypedNode)->setType((yyvsp[(1) - (4)].interm.intermTypedNode)->getType());
- ;}
+ }
break;
case 10:
{
(yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
- ;}
+ }
break;
case 11:
@@ -2393,7 +2328,7 @@
(yyval.interm.intermTypedNode) = (yyvsp[(1) - (3)].interm.intermTypedNode);
}
// don't delete $3.string, it's from the pool
- ;}
+ }
break;
case 12:
@@ -2407,7 +2342,7 @@
context->recover();
(yyval.interm.intermTypedNode) = (yyvsp[(1) - (2)].interm.intermTypedNode);
}
- ;}
+ }
break;
case 13:
@@ -2421,7 +2356,7 @@
context->recover();
(yyval.interm.intermTypedNode) = (yyvsp[(1) - (2)].interm.intermTypedNode);
}
- ;}
+ }
break;
case 14:
@@ -2430,7 +2365,7 @@
if (context->integerErrorCheck((yyvsp[(1) - (1)].interm.intermTypedNode), "[]"))
context->recover();
(yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
- ;}
+ }
break;
case 15:
@@ -2530,14 +2465,14 @@
}
}
delete fnCall;
- ;}
+ }
break;
case 16:
{
(yyval.interm) = (yyvsp[(1) - (1)].interm);
- ;}
+ }
break;
case 17:
@@ -2546,7 +2481,7 @@
context->error((yyvsp[(3) - (3)].interm).line, "methods are not supported", "", "");
context->recover();
(yyval.interm) = (yyvsp[(3) - (3)].interm);
- ;}
+ }
break;
case 18:
@@ -2554,7 +2489,7 @@
{
(yyval.interm) = (yyvsp[(1) - (2)].interm);
(yyval.interm).line = (yyvsp[(2) - (2)].lex).line;
- ;}
+ }
break;
case 19:
@@ -2562,7 +2497,7 @@
{
(yyval.interm) = (yyvsp[(1) - (2)].interm);
(yyval.interm).line = (yyvsp[(2) - (2)].lex).line;
- ;}
+ }
break;
case 20:
@@ -2570,7 +2505,7 @@
{
(yyval.interm).function = (yyvsp[(1) - (2)].interm.function);
(yyval.interm).intermNode = 0;
- ;}
+ }
break;
case 21:
@@ -2578,7 +2513,7 @@
{
(yyval.interm).function = (yyvsp[(1) - (1)].interm.function);
(yyval.interm).intermNode = 0;
- ;}
+ }
break;
case 22:
@@ -2588,7 +2523,7 @@
(yyvsp[(1) - (2)].interm.function)->addParameter(param);
(yyval.interm).function = (yyvsp[(1) - (2)].interm.function);
(yyval.interm).intermNode = (yyvsp[(2) - (2)].interm.intermTypedNode);
- ;}
+ }
break;
case 23:
@@ -2598,14 +2533,14 @@
(yyvsp[(1) - (3)].interm).function->addParameter(param);
(yyval.interm).function = (yyvsp[(1) - (3)].interm).function;
(yyval.interm).intermNode = context->intermediate.growAggregate((yyvsp[(1) - (3)].interm).intermNode, (yyvsp[(3) - (3)].interm.intermTypedNode), (yyvsp[(2) - (3)].lex).line);
- ;}
+ }
break;
case 24:
{
(yyval.interm.function) = (yyvsp[(1) - (2)].interm.function);
- ;}
+ }
break;
case 25:
@@ -2671,7 +2606,7 @@
TType type((yyvsp[(1) - (1)].interm.type));
TFunction *function = new TFunction(&tempString, type, op);
(yyval.interm.function) = function;
- ;}
+ }
break;
case 26:
@@ -2682,7 +2617,7 @@
TType type(EbtVoid, EbpUndefined);
TFunction *function = new TFunction((yyvsp[(1) - (1)].lex).string, type);
(yyval.interm.function) = function;
- ;}
+ }
break;
case 27:
@@ -2693,14 +2628,14 @@
TType type(EbtVoid, EbpUndefined);
TFunction *function = new TFunction((yyvsp[(1) - (1)].lex).string, type);
(yyval.interm.function) = function;
- ;}
+ }
break;
case 28:
{
(yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
- ;}
+ }
break;
case 29:
@@ -2714,7 +2649,7 @@
context->recover();
(yyval.interm.intermTypedNode) = (yyvsp[(2) - (2)].interm.intermTypedNode);
}
- ;}
+ }
break;
case 30:
@@ -2728,7 +2663,7 @@
context->recover();
(yyval.interm.intermTypedNode) = (yyvsp[(2) - (2)].interm.intermTypedNode);
}
- ;}
+ }
break;
case 31:
@@ -2749,27 +2684,27 @@
}
} else
(yyval.interm.intermTypedNode) = (yyvsp[(2) - (2)].interm.intermTypedNode);
- ;}
+ }
break;
case 32:
- { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpNull; ;}
+ { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpNull; }
break;
case 33:
- { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpNegative; ;}
+ { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpNegative; }
break;
case 34:
- { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpLogicalNot; ;}
+ { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpLogicalNot; }
break;
case 35:
- { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+ { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
break;
case 36:
@@ -2782,7 +2717,7 @@
context->recover();
(yyval.interm.intermTypedNode) = (yyvsp[(1) - (3)].interm.intermTypedNode);
}
- ;}
+ }
break;
case 37:
@@ -2795,12 +2730,12 @@
context->recover();
(yyval.interm.intermTypedNode) = (yyvsp[(1) - (3)].interm.intermTypedNode);
}
- ;}
+ }
break;
case 38:
- { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+ { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
break;
case 39:
@@ -2812,7 +2747,7 @@
context->recover();
(yyval.interm.intermTypedNode) = (yyvsp[(1) - (3)].interm.intermTypedNode);
}
- ;}
+ }
break;
case 40:
@@ -2824,17 +2759,17 @@
context->recover();
(yyval.interm.intermTypedNode) = (yyvsp[(1) - (3)].interm.intermTypedNode);
}
- ;}
+ }
break;
case 41:
- { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+ { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
break;
case 42:
- { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+ { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
break;
case 43:
@@ -2848,7 +2783,7 @@
unionArray->setBConst(false);
(yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
}
- ;}
+ }
break;
case 44:
@@ -2862,7 +2797,7 @@
unionArray->setBConst(false);
(yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
}
- ;}
+ }
break;
case 45:
@@ -2876,7 +2811,7 @@
unionArray->setBConst(false);
(yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
}
- ;}
+ }
break;
case 46:
@@ -2890,12 +2825,12 @@
unionArray->setBConst(false);
(yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
}
- ;}
+ }
break;
case 47:
- { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+ { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
break;
case 48:
@@ -2909,7 +2844,7 @@
unionArray->setBConst(false);
(yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
}
- ;}
+ }
break;
case 49:
@@ -2923,27 +2858,27 @@
unionArray->setBConst(false);
(yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
}
- ;}
+ }
break;
case 50:
- { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+ { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
break;
case 51:
- { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+ { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
break;
case 52:
- { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+ { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
break;
case 53:
- { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+ { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
break;
case 54:
@@ -2957,12 +2892,12 @@
unionArray->setBConst(false);
(yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
}
- ;}
+ }
break;
case 55:
- { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+ { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
break;
case 56:
@@ -2976,12 +2911,12 @@
unionArray->setBConst(false);
(yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
}
- ;}
+ }
break;
case 57:
- { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+ { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
break;
case 58:
@@ -2995,12 +2930,12 @@
unionArray->setBConst(false);
(yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
}
- ;}
+ }
break;
case 59:
- { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+ { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
break;
case 60:
@@ -3018,12 +2953,12 @@
context->recover();
(yyval.interm.intermTypedNode) = (yyvsp[(5) - (5)].interm.intermTypedNode);
}
- ;}
+ }
break;
case 61:
- { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+ { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
break;
case 62:
@@ -3037,39 +2972,39 @@
context->recover();
(yyval.interm.intermTypedNode) = (yyvsp[(1) - (3)].interm.intermTypedNode);
}
- ;}
+ }
break;
case 63:
- { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpAssign; ;}
+ { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpAssign; }
break;
case 64:
- { FRAG_VERT_ONLY("*=", (yyvsp[(1) - (1)].lex).line); (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpMulAssign; ;}
+ { FRAG_VERT_ONLY("*=", (yyvsp[(1) - (1)].lex).line); (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpMulAssign; }
break;
case 65:
- { FRAG_VERT_ONLY("/=", (yyvsp[(1) - (1)].lex).line); (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpDivAssign; ;}
+ { FRAG_VERT_ONLY("/=", (yyvsp[(1) - (1)].lex).line); (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpDivAssign; }
break;
case 66:
- { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpAddAssign; ;}
+ { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpAddAssign; }
break;
case 67:
- { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpSubAssign; ;}
+ { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpSubAssign; }
break;
case 68:
{
(yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
- ;}
+ }
break;
case 69:
@@ -3081,7 +3016,7 @@
context->recover();
(yyval.interm.intermTypedNode) = (yyvsp[(3) - (3)].interm.intermTypedNode);
}
- ;}
+ }
break;
case 70:
@@ -3090,7 +3025,7 @@
if (context->constErrorCheck((yyvsp[(1) - (1)].interm.intermTypedNode)))
context->recover();
(yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
- ;}
+ }
break;
case 71:
@@ -3119,7 +3054,9 @@
prototype->setOp(EOpPrototype);
(yyval.interm.intermNode) = prototype;
- ;}
+
+ context->symbolTable.pop();
+ }
break;
case 72:
@@ -3128,7 +3065,7 @@
if ((yyvsp[(1) - (2)].interm).intermAggregate)
(yyvsp[(1) - (2)].interm).intermAggregate->setOp(EOpDeclaration);
(yyval.interm.intermNode) = (yyvsp[(1) - (2)].interm).intermAggregate;
- ;}
+ }
break;
case 73:
@@ -3136,7 +3073,7 @@
{
context->symbolTable.setDefaultPrecision( (yyvsp[(3) - (4)].interm.type).type, (yyvsp[(2) - (4)].interm.precision) );
(yyval.interm.intermNode) = 0;
- ;}
+ }
break;
case 74:
@@ -3172,22 +3109,24 @@
(yyval.interm).function = (yyvsp[(1) - (2)].interm.function);
(yyval.interm).line = (yyvsp[(2) - (2)].lex).line;
- context->symbolTable.insert(*(yyval.interm).function);
- ;}
+ // We're at the inner scope level of the function's arguments and body statement.
+ // Add the function prototype to the surrounding scope instead.
+ context->symbolTable.getOuterLevel()->insert(*(yyval.interm).function);
+ }
break;
case 75:
{
(yyval.interm.function) = (yyvsp[(1) - (1)].interm.function);
- ;}
+ }
break;
case 76:
{
(yyval.interm.function) = (yyvsp[(1) - (1)].interm.function);
- ;}
+ }
break;
case 77:
@@ -3199,7 +3138,7 @@
(yyvsp[(1) - (2)].interm.function)->addParameter((yyvsp[(2) - (2)].interm).param);
else
delete (yyvsp[(2) - (2)].interm).param.type;
- ;}
+ }
break;
case 78:
@@ -3221,7 +3160,7 @@
(yyval.interm.function) = (yyvsp[(1) - (3)].interm.function);
(yyvsp[(1) - (3)].interm.function)->addParameter((yyvsp[(3) - (3)].interm).param);
}
- ;}
+ }
break;
case 79:
@@ -3240,7 +3179,9 @@
TType type((yyvsp[(1) - (3)].interm.type));
function = new TFunction((yyvsp[(2) - (3)].lex).string, type);
(yyval.interm.function) = function;
- ;}
+
+ context->symbolTable.push();
+ }
break;
case 80:
@@ -3255,7 +3196,7 @@
TParameter param = {(yyvsp[(2) - (2)].lex).string, new TType((yyvsp[(1) - (2)].interm.type))};
(yyval.interm).line = (yyvsp[(2) - (2)].lex).line;
(yyval.interm).param = param;
- ;}
+ }
break;
case 81:
@@ -3277,7 +3218,7 @@
TParameter param = { (yyvsp[(2) - (5)].lex).string, type };
(yyval.interm).line = (yyvsp[(2) - (5)].lex).line;
(yyval.interm).param = param;
- ;}
+ }
break;
case 82:
@@ -3286,7 +3227,7 @@
(yyval.interm) = (yyvsp[(3) - (3)].interm);
if (context->paramErrorCheck((yyvsp[(3) - (3)].interm).line, (yyvsp[(1) - (3)].interm.type).qualifier, (yyvsp[(2) - (3)].interm.qualifier), (yyval.interm).param.type))
context->recover();
- ;}
+ }
break;
case 83:
@@ -3297,7 +3238,7 @@
context->recover();
if (context->paramErrorCheck((yyvsp[(2) - (2)].interm).line, EvqTemporary, (yyvsp[(1) - (2)].interm.qualifier), (yyval.interm).param.type))
context->recover();
- ;}
+ }
break;
case 84:
@@ -3306,7 +3247,7 @@
(yyval.interm) = (yyvsp[(3) - (3)].interm);
if (context->paramErrorCheck((yyvsp[(3) - (3)].interm).line, (yyvsp[(1) - (3)].interm.type).qualifier, (yyvsp[(2) - (3)].interm.qualifier), (yyval.interm).param.type))
context->recover();
- ;}
+ }
break;
case 85:
@@ -3317,35 +3258,35 @@
context->recover();
if (context->paramErrorCheck((yyvsp[(2) - (2)].interm).line, EvqTemporary, (yyvsp[(1) - (2)].interm.qualifier), (yyval.interm).param.type))
context->recover();
- ;}
+ }
break;
case 86:
{
(yyval.interm.qualifier) = EvqIn;
- ;}
+ }
break;
case 87:
{
(yyval.interm.qualifier) = EvqIn;
- ;}
+ }
break;
case 88:
{
(yyval.interm.qualifier) = EvqOut;
- ;}
+ }
break;
case 89:
{
(yyval.interm.qualifier) = EvqInOut;
- ;}
+ }
break;
case 90:
@@ -3353,7 +3294,7 @@
{
TParameter param = { 0, new TType((yyvsp[(1) - (1)].interm.type)) };
(yyval.interm).param = param;
- ;}
+ }
break;
case 91:
@@ -3367,12 +3308,18 @@
context->recover();
}
}
- ;}
+ }
break;
case 92:
{
+ if ((yyvsp[(1) - (3)].interm).type.type == EbtInvariant && !(yyvsp[(3) - (3)].lex).symbol)
+ {
+ context->error((yyvsp[(3) - (3)].lex).line, "undeclared identifier declared as invariant", (yyvsp[(3) - (3)].lex).string->c_str(), "");
+ context->recover();
+ }
+
TIntermSymbol* symbol = context->intermediate.addSymbol(0, *(yyvsp[(3) - (3)].lex).string, TType((yyvsp[(1) - (3)].interm).type), (yyvsp[(3) - (3)].lex).line);
(yyval.interm).intermAggregate = context->intermediate.growAggregate((yyvsp[(1) - (3)].interm).intermNode, symbol, (yyvsp[(3) - (3)].lex).line);
@@ -3387,7 +3334,7 @@
context->recover();
if (symbol && variable)
symbol->setId(variable->getUniqueId());
- ;}
+ }
break;
case 93:
@@ -3409,7 +3356,7 @@
if (context->arrayErrorCheck((yyvsp[(4) - (5)].lex).line, *(yyvsp[(3) - (5)].lex).string, (yyvsp[(1) - (5)].interm).type, variable))
context->recover();
}
- ;}
+ }
break;
case 94:
@@ -3437,7 +3384,7 @@
type.setArraySize(size);
(yyval.interm).intermAggregate = context->intermediate.growAggregate((yyvsp[(1) - (6)].interm).intermNode, context->intermediate.addSymbol(variable ? variable->getUniqueId() : 0, *(yyvsp[(3) - (6)].lex).string, type, (yyvsp[(3) - (6)].lex).line), (yyvsp[(3) - (6)].lex).line);
}
- ;}
+ }
break;
case 95:
@@ -3461,7 +3408,7 @@
context->recover();
(yyval.interm).intermAggregate = 0;
}
- ;}
+ }
break;
case 96:
@@ -3469,7 +3416,7 @@
{
(yyval.interm).type = (yyvsp[(1) - (1)].interm.type);
(yyval.interm).intermAggregate = context->intermediate.makeAggregate(context->intermediate.addSymbol(0, "", TType((yyvsp[(1) - (1)].interm.type)), (yyvsp[(1) - (1)].interm.type).line), (yyvsp[(1) - (1)].interm.type).line);
- ;}
+ }
break;
case 97:
@@ -3491,7 +3438,7 @@
context->recover();
if (variable && symbol)
symbol->setId(variable->getUniqueId());
- ;}
+ }
break;
case 98:
@@ -3503,7 +3450,7 @@
TIntermSymbol* symbol = context->intermediate.addSymbol(0, *(yyvsp[(2) - (4)].lex).string, TType((yyvsp[(1) - (4)].interm.type)), (yyvsp[(2) - (4)].lex).line);
(yyval.interm).intermAggregate = context->intermediate.makeAggregate(symbol, (yyvsp[(2) - (4)].lex).line);
(yyval.interm).type = (yyvsp[(1) - (4)].interm.type);
- ;}
+ }
break;
case 99:
@@ -3539,7 +3486,7 @@
if (variable && symbol)
symbol->setId(variable->getUniqueId());
}
- ;}
+ }
break;
case 100:
@@ -3563,16 +3510,29 @@
context->recover();
(yyval.interm).intermAggregate = 0;
}
- ;}
+ }
break;
case 101:
{
VERTEX_ONLY("invariant declaration", (yyvsp[(1) - (2)].lex).line);
- (yyval.interm).qualifier = EvqInvariantVaryingOut;
- (yyval.interm).intermAggregate = 0;
- ;}
+ if (context->globalErrorCheck((yyvsp[(1) - (2)].lex).line, context->symbolTable.atGlobalLevel(), "invariant varying"))
+ context->recover();
+ (yyval.interm).type.setBasic(EbtInvariant, EvqInvariantVaryingOut, (yyvsp[(2) - (2)].lex).line);
+ if (!(yyvsp[(2) - (2)].lex).symbol)
+ {
+ context->error((yyvsp[(2) - (2)].lex).line, "undeclared identifier declared as invariant", (yyvsp[(2) - (2)].lex).string->c_str(), "");
+ context->recover();
+
+ (yyval.interm).intermAggregate = 0;
+ }
+ else
+ {
+ TIntermSymbol *symbol = context->intermediate.addSymbol(0, *(yyvsp[(2) - (2)].lex).string, TType((yyval.interm).type), (yyvsp[(2) - (2)].lex).line);
+ (yyval.interm).intermAggregate = context->intermediate.makeAggregate(symbol, (yyvsp[(2) - (2)].lex).line);
+ }
+ }
break;
case 102:
@@ -3585,7 +3545,7 @@
context->recover();
(yyvsp[(1) - (1)].interm.type).setArray(false);
}
- ;}
+ }
break;
case 103:
@@ -3609,14 +3569,14 @@
}
(yyval.interm.type) = (yyvsp[(2) - (2)].interm.type);
(yyval.interm.type).qualifier = (yyvsp[(1) - (2)].interm.type).qualifier;
- ;}
+ }
break;
case 104:
{
(yyval.interm.type).setBasic(EbtVoid, EvqConst, (yyvsp[(1) - (1)].lex).line);
- ;}
+ }
break;
case 105:
@@ -3626,7 +3586,7 @@
if (context->globalErrorCheck((yyvsp[(1) - (1)].lex).line, context->symbolTable.atGlobalLevel(), "attribute"))
context->recover();
(yyval.interm.type).setBasic(EbtVoid, EvqAttribute, (yyvsp[(1) - (1)].lex).line);
- ;}
+ }
break;
case 106:
@@ -3638,7 +3598,7 @@
(yyval.interm.type).setBasic(EbtVoid, EvqVaryingOut, (yyvsp[(1) - (1)].lex).line);
else
(yyval.interm.type).setBasic(EbtVoid, EvqVaryingIn, (yyvsp[(1) - (1)].lex).line);
- ;}
+ }
break;
case 107:
@@ -3650,7 +3610,7 @@
(yyval.interm.type).setBasic(EbtVoid, EvqInvariantVaryingOut, (yyvsp[(1) - (2)].lex).line);
else
(yyval.interm.type).setBasic(EbtVoid, EvqInvariantVaryingIn, (yyvsp[(1) - (2)].lex).line);
- ;}
+ }
break;
case 108:
@@ -3659,14 +3619,14 @@
if (context->globalErrorCheck((yyvsp[(1) - (1)].lex).line, context->symbolTable.atGlobalLevel(), "uniform"))
context->recover();
(yyval.interm.type).setBasic(EbtVoid, EvqUniform, (yyvsp[(1) - (1)].lex).line);
- ;}
+ }
break;
case 109:
{
(yyval.interm.type) = (yyvsp[(1) - (1)].interm.type);
- ;}
+ }
break;
case 110:
@@ -3674,35 +3634,35 @@
{
(yyval.interm.type) = (yyvsp[(2) - (2)].interm.type);
(yyval.interm.type).precision = (yyvsp[(1) - (2)].interm.precision);
- ;}
+ }
break;
case 111:
{
(yyval.interm.precision) = EbpHigh;
- ;}
+ }
break;
case 112:
{
(yyval.interm.precision) = EbpMedium;
- ;}
+ }
break;
case 113:
{
(yyval.interm.precision) = EbpLow;
- ;}
+ }
break;
case 114:
{
(yyval.interm.type) = (yyvsp[(1) - (1)].interm.type);
- ;}
+ }
break;
case 115:
@@ -3718,7 +3678,7 @@
context->recover();
(yyval.interm.type).setArray(true, size);
}
- ;}
+ }
break;
case 116:
@@ -3726,7 +3686,7 @@
{
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtVoid, qual, (yyvsp[(1) - (1)].lex).line);
- ;}
+ }
break;
case 117:
@@ -3734,7 +3694,7 @@
{
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtFloat, qual, (yyvsp[(1) - (1)].lex).line);
- ;}
+ }
break;
case 118:
@@ -3742,7 +3702,7 @@
{
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtInt, qual, (yyvsp[(1) - (1)].lex).line);
- ;}
+ }
break;
case 119:
@@ -3750,7 +3710,7 @@
{
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtBool, qual, (yyvsp[(1) - (1)].lex).line);
- ;}
+ }
break;
case 120:
@@ -3759,7 +3719,7 @@
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtFloat, qual, (yyvsp[(1) - (1)].lex).line);
(yyval.interm.type).setAggregate(2);
- ;}
+ }
break;
case 121:
@@ -3768,7 +3728,7 @@
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtFloat, qual, (yyvsp[(1) - (1)].lex).line);
(yyval.interm.type).setAggregate(3);
- ;}
+ }
break;
case 122:
@@ -3777,7 +3737,7 @@
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtFloat, qual, (yyvsp[(1) - (1)].lex).line);
(yyval.interm.type).setAggregate(4);
- ;}
+ }
break;
case 123:
@@ -3786,7 +3746,7 @@
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtBool, qual, (yyvsp[(1) - (1)].lex).line);
(yyval.interm.type).setAggregate(2);
- ;}
+ }
break;
case 124:
@@ -3795,7 +3755,7 @@
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtBool, qual, (yyvsp[(1) - (1)].lex).line);
(yyval.interm.type).setAggregate(3);
- ;}
+ }
break;
case 125:
@@ -3804,7 +3764,7 @@
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtBool, qual, (yyvsp[(1) - (1)].lex).line);
(yyval.interm.type).setAggregate(4);
- ;}
+ }
break;
case 126:
@@ -3813,7 +3773,7 @@
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtInt, qual, (yyvsp[(1) - (1)].lex).line);
(yyval.interm.type).setAggregate(2);
- ;}
+ }
break;
case 127:
@@ -3822,7 +3782,7 @@
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtInt, qual, (yyvsp[(1) - (1)].lex).line);
(yyval.interm.type).setAggregate(3);
- ;}
+ }
break;
case 128:
@@ -3831,7 +3791,7 @@
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtInt, qual, (yyvsp[(1) - (1)].lex).line);
(yyval.interm.type).setAggregate(4);
- ;}
+ }
break;
case 129:
@@ -3841,7 +3801,7 @@
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtFloat, qual, (yyvsp[(1) - (1)].lex).line);
(yyval.interm.type).setAggregate(2, true);
- ;}
+ }
break;
case 130:
@@ -3851,7 +3811,7 @@
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtFloat, qual, (yyvsp[(1) - (1)].lex).line);
(yyval.interm.type).setAggregate(3, true);
- ;}
+ }
break;
case 131:
@@ -3861,7 +3821,7 @@
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtFloat, qual, (yyvsp[(1) - (1)].lex).line);
(yyval.interm.type).setAggregate(4, true);
- ;}
+ }
break;
case 132:
@@ -3870,7 +3830,7 @@
FRAG_VERT_ONLY("sampler2D", (yyvsp[(1) - (1)].lex).line);
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtSampler2D, qual, (yyvsp[(1) - (1)].lex).line);
- ;}
+ }
break;
case 133:
@@ -3879,7 +3839,7 @@
FRAG_VERT_ONLY("samplerCube", (yyvsp[(1) - (1)].lex).line);
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtSamplerCube, qual, (yyvsp[(1) - (1)].lex).line);
- ;}
+ }
break;
case 134:
@@ -3888,7 +3848,7 @@
FRAG_VERT_ONLY("struct", (yyvsp[(1) - (1)].interm.type).line);
(yyval.interm.type) = (yyvsp[(1) - (1)].interm.type);
(yyval.interm.type).qualifier = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
- ;}
+ }
break;
case 135:
@@ -3902,7 +3862,7 @@
TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
(yyval.interm.type).setBasic(EbtStruct, qual, (yyvsp[(1) - (1)].lex).line);
(yyval.interm.type).userDef = &structure;
- ;}
+ }
break;
case 136:
@@ -3919,7 +3879,7 @@
}
(yyval.interm.type).setBasic(EbtStruct, EvqTemporary, (yyvsp[(1) - (5)].lex).line);
(yyval.interm.type).userDef = structure;
- ;}
+ }
break;
case 137:
@@ -3928,14 +3888,14 @@
TType* structure = new TType((yyvsp[(3) - (4)].interm.typeList), TString(""));
(yyval.interm.type).setBasic(EbtStruct, EvqTemporary, (yyvsp[(1) - (4)].lex).line);
(yyval.interm.type).userDef = structure;
- ;}
+ }
break;
case 138:
{
(yyval.interm.typeList) = (yyvsp[(1) - (1)].interm.typeList);
- ;}
+ }
break;
case 139:
@@ -3951,7 +3911,7 @@
}
(yyval.interm.typeList)->push_back((*(yyvsp[(2) - (2)].interm.typeList))[i]);
}
- ;}
+ }
break;
case 140:
@@ -3983,7 +3943,7 @@
type->setTypeName((yyvsp[(1) - (3)].interm.type).userDef->getTypeName());
}
}
- ;}
+ }
break;
case 141:
@@ -3991,14 +3951,14 @@
{
(yyval.interm.typeList) = NewPoolTTypeList();
(yyval.interm.typeList)->push_back((yyvsp[(1) - (1)].interm.typeLine));
- ;}
+ }
break;
case 142:
{
(yyval.interm.typeList)->push_back((yyvsp[(3) - (3)].interm.typeLine));
- ;}
+ }
break;
case 143:
@@ -4010,7 +3970,7 @@
(yyval.interm.typeLine).type = new TType(EbtVoid, EbpUndefined);
(yyval.interm.typeLine).line = (yyvsp[(1) - (1)].lex).line;
(yyval.interm.typeLine).type->setFieldName(*(yyvsp[(1) - (1)].lex).string);
- ;}
+ }
break;
case 144:
@@ -4027,67 +3987,67 @@
if (context->arraySizeErrorCheck((yyvsp[(2) - (4)].lex).line, (yyvsp[(3) - (4)].interm.intermTypedNode), size))
context->recover();
(yyval.interm.typeLine).type->setArraySize(size);
- ;}
+ }
break;
case 145:
- { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+ { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
break;
case 146:
- { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+ { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
break;
case 147:
- { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermAggregate); ;}
+ { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermAggregate); }
break;
case 148:
- { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+ { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
break;
case 149:
- { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+ { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
break;
case 150:
- { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+ { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
break;
case 151:
- { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+ { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
break;
case 152:
- { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+ { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
break;
case 153:
- { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+ { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
break;
case 154:
- { (yyval.interm.intermAggregate) = 0; ;}
+ { (yyval.interm.intermAggregate) = 0; }
break;
case 155:
- { context->symbolTable.push(); ;}
+ { context->symbolTable.push(); }
break;
case 156:
- { context->symbolTable.pop(); ;}
+ { context->symbolTable.pop(); }
break;
case 157:
@@ -4098,96 +4058,116 @@
(yyvsp[(3) - (5)].interm.intermAggregate)->setEndLine((yyvsp[(5) - (5)].lex).line);
}
(yyval.interm.intermAggregate) = (yyvsp[(3) - (5)].interm.intermAggregate);
- ;}
+ }
break;
case 158:
- { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+ { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
break;
case 159:
- { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+ { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
break;
case 160:
- {
- (yyval.interm.intermNode) = 0;
- ;}
+ { context->symbolTable.push(); }
break;
case 161:
+ { context->symbolTable.pop(); (yyval.interm.intermNode) = (yyvsp[(2) - (2)].interm.intermNode); }
+ break;
+
+ case 162:
+
+ { context->symbolTable.push(); }
+ break;
+
+ case 163:
+
+ { context->symbolTable.pop(); (yyval.interm.intermNode) = (yyvsp[(2) - (2)].interm.intermNode); }
+ break;
+
+ case 164:
+
+ {
+ (yyval.interm.intermNode) = 0;
+ }
+ break;
+
+ case 165:
+
{
if ((yyvsp[(2) - (3)].interm.intermAggregate)) {
(yyvsp[(2) - (3)].interm.intermAggregate)->setOp(EOpSequence);
(yyvsp[(2) - (3)].interm.intermAggregate)->setEndLine((yyvsp[(3) - (3)].lex).line);
}
(yyval.interm.intermNode) = (yyvsp[(2) - (3)].interm.intermAggregate);
- ;}
- break;
-
- case 162:
-
- {
- (yyval.interm.intermAggregate) = context->intermediate.makeAggregate((yyvsp[(1) - (1)].interm.intermNode), 0);
- ;}
- break;
-
- case 163:
-
- {
- (yyval.interm.intermAggregate) = context->intermediate.growAggregate((yyvsp[(1) - (2)].interm.intermAggregate), (yyvsp[(2) - (2)].interm.intermNode), 0);
- ;}
- break;
-
- case 164:
-
- { (yyval.interm.intermNode) = 0; ;}
- break;
-
- case 165:
-
- { (yyval.interm.intermNode) = static_cast<TIntermNode*>((yyvsp[(1) - (2)].interm.intermTypedNode)); ;}
+ }
break;
case 166:
{
- if (context->boolErrorCheck((yyvsp[(1) - (5)].lex).line, (yyvsp[(3) - (5)].interm.intermTypedNode)))
- context->recover();
- (yyval.interm.intermNode) = context->intermediate.addSelection((yyvsp[(3) - (5)].interm.intermTypedNode), (yyvsp[(5) - (5)].interm.nodePair), (yyvsp[(1) - (5)].lex).line);
- ;}
+ (yyval.interm.intermAggregate) = context->intermediate.makeAggregate((yyvsp[(1) - (1)].interm.intermNode), 0);
+ }
break;
case 167:
{
- (yyval.interm.nodePair).node1 = (yyvsp[(1) - (3)].interm.intermNode);
- (yyval.interm.nodePair).node2 = (yyvsp[(3) - (3)].interm.intermNode);
- ;}
+ (yyval.interm.intermAggregate) = context->intermediate.growAggregate((yyvsp[(1) - (2)].interm.intermAggregate), (yyvsp[(2) - (2)].interm.intermNode), 0);
+ }
break;
case 168:
- {
- (yyval.interm.nodePair).node1 = (yyvsp[(1) - (1)].interm.intermNode);
- (yyval.interm.nodePair).node2 = 0;
- ;}
+ { (yyval.interm.intermNode) = 0; }
break;
case 169:
+ { (yyval.interm.intermNode) = static_cast<TIntermNode*>((yyvsp[(1) - (2)].interm.intermTypedNode)); }
+ break;
+
+ case 170:
+
+ {
+ if (context->boolErrorCheck((yyvsp[(1) - (5)].lex).line, (yyvsp[(3) - (5)].interm.intermTypedNode)))
+ context->recover();
+ (yyval.interm.intermNode) = context->intermediate.addSelection((yyvsp[(3) - (5)].interm.intermTypedNode), (yyvsp[(5) - (5)].interm.nodePair), (yyvsp[(1) - (5)].lex).line);
+ }
+ break;
+
+ case 171:
+
+ {
+ (yyval.interm.nodePair).node1 = (yyvsp[(1) - (3)].interm.intermNode);
+ (yyval.interm.nodePair).node2 = (yyvsp[(3) - (3)].interm.intermNode);
+ }
+ break;
+
+ case 172:
+
+ {
+ (yyval.interm.nodePair).node1 = (yyvsp[(1) - (1)].interm.intermNode);
+ (yyval.interm.nodePair).node2 = 0;
+ }
+ break;
+
+ case 173:
+
{
(yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
if (context->boolErrorCheck((yyvsp[(1) - (1)].interm.intermTypedNode)->getLine(), (yyvsp[(1) - (1)].interm.intermTypedNode)))
context->recover();
- ;}
+ }
break;
- case 170:
+ case 174:
{
TIntermNode* intermNode;
@@ -4202,29 +4182,29 @@
context->recover();
(yyval.interm.intermTypedNode) = 0;
}
- ;}
+ }
break;
- case 171:
+ case 175:
- { context->symbolTable.push(); ++context->loopNestingLevel; ;}
+ { context->symbolTable.push(); ++context->loopNestingLevel; }
break;
- case 172:
+ case 176:
{
context->symbolTable.pop();
(yyval.interm.intermNode) = context->intermediate.addLoop(ELoopWhile, 0, (yyvsp[(4) - (6)].interm.intermTypedNode), 0, (yyvsp[(6) - (6)].interm.intermNode), (yyvsp[(1) - (6)].lex).line);
--context->loopNestingLevel;
- ;}
+ }
break;
- case 173:
+ case 177:
- { ++context->loopNestingLevel; ;}
+ { ++context->loopNestingLevel; }
break;
- case 174:
+ case 178:
{
if (context->boolErrorCheck((yyvsp[(8) - (8)].lex).line, (yyvsp[(6) - (8)].interm.intermTypedNode)))
@@ -4232,79 +4212,79 @@
(yyval.interm.intermNode) = context->intermediate.addLoop(ELoopDoWhile, 0, (yyvsp[(6) - (8)].interm.intermTypedNode), 0, (yyvsp[(3) - (8)].interm.intermNode), (yyvsp[(4) - (8)].lex).line);
--context->loopNestingLevel;
- ;}
- break;
-
- case 175:
-
- { context->symbolTable.push(); ++context->loopNestingLevel; ;}
- break;
-
- case 176:
-
- {
- context->symbolTable.pop();
- (yyval.interm.intermNode) = context->intermediate.addLoop(ELoopFor, (yyvsp[(4) - (7)].interm.intermNode), reinterpret_cast<TIntermTyped*>((yyvsp[(5) - (7)].interm.nodePair).node1), reinterpret_cast<TIntermTyped*>((yyvsp[(5) - (7)].interm.nodePair).node2), (yyvsp[(7) - (7)].interm.intermNode), (yyvsp[(1) - (7)].lex).line);
- --context->loopNestingLevel;
- ;}
- break;
-
- case 177:
-
- {
- (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
- ;}
- break;
-
- case 178:
-
- {
- (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
- ;}
+ }
break;
case 179:
- {
- (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
- ;}
+ { context->symbolTable.push(); ++context->loopNestingLevel; }
break;
case 180:
{
- (yyval.interm.intermTypedNode) = 0;
- ;}
+ context->symbolTable.pop();
+ (yyval.interm.intermNode) = context->intermediate.addLoop(ELoopFor, (yyvsp[(4) - (7)].interm.intermNode), reinterpret_cast<TIntermTyped*>((yyvsp[(5) - (7)].interm.nodePair).node1), reinterpret_cast<TIntermTyped*>((yyvsp[(5) - (7)].interm.nodePair).node2), (yyvsp[(7) - (7)].interm.intermNode), (yyvsp[(1) - (7)].lex).line);
+ --context->loopNestingLevel;
+ }
break;
case 181:
{
- (yyval.interm.nodePair).node1 = (yyvsp[(1) - (2)].interm.intermTypedNode);
- (yyval.interm.nodePair).node2 = 0;
- ;}
+ (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
+ }
break;
case 182:
{
- (yyval.interm.nodePair).node1 = (yyvsp[(1) - (3)].interm.intermTypedNode);
- (yyval.interm.nodePair).node2 = (yyvsp[(3) - (3)].interm.intermTypedNode);
- ;}
+ (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
+ }
break;
case 183:
{
+ (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
+ }
+ break;
+
+ case 184:
+
+ {
+ (yyval.interm.intermTypedNode) = 0;
+ }
+ break;
+
+ case 185:
+
+ {
+ (yyval.interm.nodePair).node1 = (yyvsp[(1) - (2)].interm.intermTypedNode);
+ (yyval.interm.nodePair).node2 = 0;
+ }
+ break;
+
+ case 186:
+
+ {
+ (yyval.interm.nodePair).node1 = (yyvsp[(1) - (3)].interm.intermTypedNode);
+ (yyval.interm.nodePair).node2 = (yyvsp[(3) - (3)].interm.intermTypedNode);
+ }
+ break;
+
+ case 187:
+
+ {
if (context->loopNestingLevel <= 0) {
context->error((yyvsp[(1) - (2)].lex).line, "continue statement only allowed in loops", "", "");
context->recover();
}
(yyval.interm.intermNode) = context->intermediate.addBranch(EOpContinue, (yyvsp[(1) - (2)].lex).line);
- ;}
+ }
break;
- case 184:
+ case 188:
{
if (context->loopNestingLevel <= 0) {
@@ -4312,10 +4292,10 @@
context->recover();
}
(yyval.interm.intermNode) = context->intermediate.addBranch(EOpBreak, (yyvsp[(1) - (2)].lex).line);
- ;}
+ }
break;
- case 185:
+ case 189:
{
(yyval.interm.intermNode) = context->intermediate.addBranch(EOpReturn, (yyvsp[(1) - (2)].lex).line);
@@ -4323,10 +4303,10 @@
context->error((yyvsp[(1) - (2)].lex).line, "non-void function must return a value", "return", "");
context->recover();
}
- ;}
+ }
break;
- case 186:
+ case 190:
{
(yyval.interm.intermNode) = context->intermediate.addBranch(EOpReturn, (yyvsp[(2) - (3)].interm.intermTypedNode), (yyvsp[(1) - (3)].lex).line);
@@ -4338,50 +4318,50 @@
context->error((yyvsp[(1) - (3)].lex).line, "function return is not matching type:", "return", "");
context->recover();
}
- ;}
- break;
-
- case 187:
-
- {
- FRAG_ONLY("discard", (yyvsp[(1) - (2)].lex).line);
- (yyval.interm.intermNode) = context->intermediate.addBranch(EOpKill, (yyvsp[(1) - (2)].lex).line);
- ;}
- break;
-
- case 188:
-
- {
- (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
- context->treeRoot = (yyval.interm.intermNode);
- ;}
- break;
-
- case 189:
-
- {
- (yyval.interm.intermNode) = context->intermediate.growAggregate((yyvsp[(1) - (2)].interm.intermNode), (yyvsp[(2) - (2)].interm.intermNode), 0);
- context->treeRoot = (yyval.interm.intermNode);
- ;}
- break;
-
- case 190:
-
- {
- (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
- ;}
+ }
break;
case 191:
{
- (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
- ;}
+ FRAG_ONLY("discard", (yyvsp[(1) - (2)].lex).line);
+ (yyval.interm.intermNode) = context->intermediate.addBranch(EOpKill, (yyvsp[(1) - (2)].lex).line);
+ }
break;
case 192:
{
+ (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
+ context->treeRoot = (yyval.interm.intermNode);
+ }
+ break;
+
+ case 193:
+
+ {
+ (yyval.interm.intermNode) = context->intermediate.growAggregate((yyvsp[(1) - (2)].interm.intermNode), (yyvsp[(2) - (2)].interm.intermNode), 0);
+ context->treeRoot = (yyval.interm.intermNode);
+ }
+ break;
+
+ case 194:
+
+ {
+ (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
+ }
+ break;
+
+ case 195:
+
+ {
+ (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
+ }
+ break;
+
+ case 196:
+
+ {
TFunction* function = (yyvsp[(1) - (1)].interm).function;
TFunction* prevDec = static_cast<TFunction*>(context->symbolTable.find(function->getMangledName()));
//
@@ -4413,11 +4393,6 @@
}
//
- // New symbol table scope for body of function plus its arguments
- //
- context->symbolTable.push();
-
- //
// Remember the return type for later checking for RETURN statements.
//
context->currentFunctionType = &(prevDec->getReturnType());
@@ -4461,10 +4436,10 @@
context->intermediate.setAggregateOperator(paramNodes, EOpParameters, (yyvsp[(1) - (1)].interm).line);
(yyvsp[(1) - (1)].interm).intermAggregate = paramNodes;
context->loopNestingLevel = 0;
- ;}
+ }
break;
- case 193:
+ case 197:
{
//?? Check that all paths return a value if return type != void ?
@@ -4473,7 +4448,7 @@
context->error((yyvsp[(1) - (3)].interm).line, "function does not return a value:", "", (yyvsp[(1) - (3)].interm).function->getName().c_str());
context->recover();
}
- context->symbolTable.pop();
+
(yyval.interm.intermNode) = context->intermediate.growAggregate((yyvsp[(1) - (3)].interm).intermAggregate, (yyvsp[(3) - (3)].interm.intermNode), 0);
context->intermediate.setAggregateOperator((yyval.interm.intermNode), EOpFunction, (yyvsp[(1) - (3)].interm).line);
(yyval.interm.intermNode)->getAsAggregate()->setName((yyvsp[(1) - (3)].interm).function->getMangledName().c_str());
@@ -4487,11 +4462,12 @@
if ((yyvsp[(3) - (3)].interm.intermNode) && (yyvsp[(3) - (3)].interm.intermNode)->getAsAggregate())
(yyval.interm.intermNode)->getAsAggregate()->setEndLine((yyvsp[(3) - (3)].interm.intermNode)->getAsAggregate()->getEndLine());
- ;}
+
+ context->symbolTable.pop();
+ }
break;
-/* Line 1267 of yacc.c. */
default: break;
}
@@ -4503,7 +4479,6 @@
*++yyvsp = yyval;
-
/* Now `shift' the result of the reduction. Determine what state
that goes to, based on the state we popped back to and the rule
number reduced by. */
@@ -4568,7 +4543,7 @@
if (yyerrstatus == 3)
{
- /* If just tried and failed to reuse look-ahead token after an
+ /* If just tried and failed to reuse lookahead token after an
error, discard it. */
if (yychar <= YYEOF)
@@ -4585,7 +4560,7 @@
}
}
- /* Else will try to reuse look-ahead token after shifting the error
+ /* Else will try to reuse lookahead token after shifting the error
token. */
goto yyerrlab1;
@@ -4642,9 +4617,6 @@
YY_STACK_PRINT (yyss, yyssp);
}
- if (yyn == YYFINAL)
- YYACCEPT;
-
*++yyvsp = yylval;
@@ -4669,7 +4641,7 @@
yyresult = 1;
goto yyreturn;
-#ifndef yyoverflow
+#if !defined(yyoverflow) || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here. |
`-------------------------------------------------*/
@@ -4680,7 +4652,7 @@
#endif
yyreturn:
- if (yychar != YYEOF && yychar != YYEMPTY)
+ if (yychar != YYEMPTY)
yydestruct ("Cleanup: discarding lookahead",
yytoken, &yylval, context);
/* Do not reclaim the symbols of the rule which action triggered
diff --git a/src/OpenGL ES 2.0/compiler/glslang_tab.h b/src/OpenGL ES 2.0/compiler/glslang_tab.h
index fa8480d..5227361 100644
--- a/src/OpenGL ES 2.0/compiler/glslang_tab.h
+++ b/src/OpenGL ES 2.0/compiler/glslang_tab.h
@@ -1,24 +1,22 @@
-/* A Bison parser, made by GNU Bison 2.3. */
+/* A Bison parser, made by GNU Bison 2.4.2. */
/* Skeleton interface for Bison's Yacc-like parsers in C
-
- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
- Free Software Foundation, Inc.
-
- This program is free software; you can redistribute it and/or modify
+
+ Copyright (C) 1984, 1989-1990, 2000-2006, 2009-2010 Free Software
+ Foundation, Inc.
+
+ This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* As a special exception, you may create a larger work that contains
part or all of the Bison parser skeleton and distribute that work
@@ -29,10 +27,11 @@
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
-
+
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
+
/* Tokens. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
@@ -132,106 +131,14 @@
QUESTION = 348
};
#endif
-/* Tokens. */
-#define INVARIANT 258
-#define HIGH_PRECISION 259
-#define MEDIUM_PRECISION 260
-#define LOW_PRECISION 261
-#define PRECISION 262
-#define ATTRIBUTE 263
-#define CONST_QUAL 264
-#define BOOL_TYPE 265
-#define FLOAT_TYPE 266
-#define INT_TYPE 267
-#define BREAK 268
-#define CONTINUE 269
-#define DO 270
-#define ELSE 271
-#define FOR 272
-#define IF 273
-#define DISCARD 274
-#define RETURN 275
-#define BVEC2 276
-#define BVEC3 277
-#define BVEC4 278
-#define IVEC2 279
-#define IVEC3 280
-#define IVEC4 281
-#define VEC2 282
-#define VEC3 283
-#define VEC4 284
-#define MATRIX2 285
-#define MATRIX3 286
-#define MATRIX4 287
-#define IN_QUAL 288
-#define OUT_QUAL 289
-#define INOUT_QUAL 290
-#define UNIFORM 291
-#define VARYING 292
-#define STRUCT 293
-#define VOID_TYPE 294
-#define WHILE 295
-#define SAMPLER2D 296
-#define SAMPLERCUBE 297
-#define IDENTIFIER 298
-#define TYPE_NAME 299
-#define FLOATCONSTANT 300
-#define INTCONSTANT 301
-#define BOOLCONSTANT 302
-#define FIELD_SELECTION 303
-#define LEFT_OP 304
-#define RIGHT_OP 305
-#define INC_OP 306
-#define DEC_OP 307
-#define LE_OP 308
-#define GE_OP 309
-#define EQ_OP 310
-#define NE_OP 311
-#define AND_OP 312
-#define OR_OP 313
-#define XOR_OP 314
-#define MUL_ASSIGN 315
-#define DIV_ASSIGN 316
-#define ADD_ASSIGN 317
-#define MOD_ASSIGN 318
-#define LEFT_ASSIGN 319
-#define RIGHT_ASSIGN 320
-#define AND_ASSIGN 321
-#define XOR_ASSIGN 322
-#define OR_ASSIGN 323
-#define SUB_ASSIGN 324
-#define LEFT_PAREN 325
-#define RIGHT_PAREN 326
-#define LEFT_BRACKET 327
-#define RIGHT_BRACKET 328
-#define LEFT_BRACE 329
-#define RIGHT_BRACE 330
-#define DOT 331
-#define COMMA 332
-#define COLON 333
-#define EQUAL 334
-#define SEMICOLON 335
-#define BANG 336
-#define DASH 337
-#define TILDE 338
-#define PLUS 339
-#define STAR 340
-#define SLASH 341
-#define PERCENT 342
-#define LEFT_ANGLE 343
-#define RIGHT_ANGLE 344
-#define VERTICAL_BAR 345
-#define CARET 346
-#define AMPERSAND 347
-#define QUESTION 348
-
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef union YYSTYPE
-
{
+
+
struct {
TSourceLoc line;
union {
@@ -261,14 +168,15 @@
TTypeList* typeList;
};
} interm;
-}
-/* Line 1529 of yacc.c. */
- YYSTYPE;
+
+
+} YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1
-# define YYSTYPE_IS_TRIVIAL 1
#endif
+
diff --git a/src/OpenGL ES 2.0/compiler/intermediate.h b/src/OpenGL ES 2.0/compiler/intermediate.h
index a8af5ab..70ea8db 100644
--- a/src/OpenGL ES 2.0/compiler/intermediate.h
+++ b/src/OpenGL ES 2.0/compiler/intermediate.h
@@ -1,5 +1,5 @@
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
@@ -195,6 +195,7 @@
class TIntermTyped;
class TIntermSymbol;
class TIntermLoop;
+class TIntermBranch;
class TInfoSink;
//
@@ -218,6 +219,7 @@
virtual TIntermSelection* getAsSelectionNode() { return 0; }
virtual TIntermSymbol* getAsSymbolNode() { return 0; }
virtual TIntermLoop* getAsLoopNode() { return 0; }
+ virtual TIntermBranch* getAsBranchNode() { return 0; }
virtual ~TIntermNode() { }
protected:
@@ -253,10 +255,16 @@
bool isArray() const { return type.isArray(); }
bool isVector() const { return type.isVector(); }
bool isScalar() const { return type.isScalar(); }
+ bool isRegister() const { return type.isRegister(); } // Fits in a 4-element register
+ bool isStruct() const { return type.isStruct(); }
const char* getBasicString() const { return type.getBasicString(); }
const char* getQualifierString() const { return type.getQualifierString(); }
TString getCompleteString() const { return type.getCompleteString(); }
+ int totalRegisterCount() const { return type.totalRegisterCount(); }
+ int elementRegisterCount() const { return type.elementRegisterCount(); }
+ int getArraySize() const { return type.getArraySize(); }
+
protected:
TType type;
};
@@ -313,6 +321,7 @@
flowOp(op),
expression(e) { }
+ virtual TIntermBranch* getAsBranchNode() { return this; }
virtual void traverse(TIntermTraverser*);
TOperator getFlowOp() { return flowOp; }
@@ -332,23 +341,19 @@
// per process globalpoolallocator, then it causes increased memory usage per compile
// it is essential to use "symbol = sym" to assign to symbol
TIntermSymbol(int i, const TString& sym, const TType& t) :
- TIntermTyped(t), id(i) { symbol = sym; originalSymbol = sym; }
+ TIntermTyped(t), id(i) { symbol = sym; }
int getId() const { return id; }
const TString& getSymbol() const { return symbol; }
void setId(int newId) { id = newId; }
- void setSymbol(const TString& sym) { symbol = sym; }
-
- const TString& getOriginalSymbol() const { return originalSymbol; }
-
+
virtual void traverse(TIntermTraverser*);
virtual TIntermSymbol* getAsSymbolNode() { return this; }
protected:
int id;
TString symbol;
- TString originalSymbol;
};
class TIntermConstantUnion : public TIntermTyped {
@@ -477,12 +482,15 @@
TIntermSelection(TIntermTyped* cond, TIntermNode* trueB, TIntermNode* falseB) :
TIntermTyped(TType(EbtVoid, EbpUndefined)), condition(cond), trueBlock(trueB), falseBlock(falseB) {}
TIntermSelection(TIntermTyped* cond, TIntermNode* trueB, TIntermNode* falseB, const TType& type) :
- TIntermTyped(type), condition(cond), trueBlock(trueB), falseBlock(falseB) {}
+ TIntermTyped(type), condition(cond), trueBlock(trueB), falseBlock(falseB)
+ {
+ this->type.setQualifier(EvqTemporary);
+ }
virtual void traverse(TIntermTraverser*);
bool usesTernaryOperator() const { return getBasicType() != EbtVoid; }
- TIntermNode* getCondition() const { return condition; }
+ TIntermTyped* getCondition() const { return condition; }
TIntermNode* getTrueBlock() const { return trueBlock; }
TIntermNode* getFalseBlock() const { return falseBlock; }
TIntermSelection* getAsSelectionNode() { return this; }
diff --git a/src/OpenGL ES 2.0/compiler/osinclude.h b/src/OpenGL ES 2.0/compiler/osinclude.h
index 6ce4df9..e22da63 100644
--- a/src/OpenGL ES 2.0/compiler/osinclude.h
+++ b/src/OpenGL ES 2.0/compiler/osinclude.h
@@ -35,7 +35,7 @@
#endif // ANGLE_USE_NSPR
-#include "compiler/debug.h"
+#include "common/debug.h"
//
// Thread Local Storage Operations
diff --git a/src/OpenGL ES 2.0/compiler/preprocessor/atom.c b/src/OpenGL ES 2.0/compiler/preprocessor/atom.c
index a17c319..b252f6c 100644
--- a/src/OpenGL ES 2.0/compiler/preprocessor/atom.c
+++ b/src/OpenGL ES 2.0/compiler/preprocessor/atom.c
@@ -49,8 +49,8 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
+#include <assert.h>
-#include "compiler/debug.h"
#include "compiler/preprocessor/slglobals.h"
#undef malloc
diff --git a/src/OpenGL ES 2.0/compiler/preprocessor/tokens.c b/src/OpenGL ES 2.0/compiler/preprocessor/tokens.c
index aa83d2f..8455a88 100644
--- a/src/OpenGL ES 2.0/compiler/preprocessor/tokens.c
+++ b/src/OpenGL ES 2.0/compiler/preprocessor/tokens.c
@@ -49,11 +49,16 @@
#include <stdio.h>
#include <string.h>
#include <ctype.h>
+#include <assert.h>
-#include "compiler/debug.h"
#include "compiler/preprocessor/slglobals.h"
#include "compiler/util.h"
+#if defined(_MSC_VER)
+#pragma warning(disable: 4054)
+#pragma warning(disable: 4152)
+#endif
+
///////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////// Preprocessor and Token Recorder and Playback: ////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
@@ -260,6 +265,8 @@
char string_val[MAX_STRING_LEN + 1];
int ltoken, len;
char ch;
+ int base, accum;
+ char ch_val;
ltoken = lReadByte(pTok);
if (ltoken >= 0) {
@@ -310,18 +317,41 @@
break;
case CPP_INTCONSTANT:
len = 0;
+ accum = 0;
ch = lReadByte(pTok);
- while ((ch >= '0' && ch <= '9'))
- {
- if (len < MAX_SYMBOL_NAME_LEN) {
+ if (ch == '0') {
+ symbol_name[len++] = ch;
+ ch = lReadByte(pTok);
+ if (ch == 'x' || ch == 'X') {
symbol_name[len++] = ch;
+ base = 16;
ch = lReadByte(pTok);
+ } else {
+ base = 8;
}
+ } else {
+ base = 10;
+ }
+
+ while (len < MAX_SYMBOL_NAME_LEN)
+ {
+ ch_val = -1;
+ if (isdigit(ch))
+ ch_val = ch - '0';
+ else if (isxdigit(ch))
+ ch_val = tolower(ch) - 'a' + 10;
+
+ if (ch_val < 0 || ch_val >= base)
+ break;
+
+ symbol_name[len++] = ch;
+ accum = accum * base + ch_val;
+ ch = lReadByte(pTok);
}
symbol_name[len] = '\0';
assert(ch == '\0');
- strcpy(yylvalpp->symbol_name,symbol_name);
- yylvalpp->sc_int=atoi(yylvalpp->symbol_name);
+ strcpy(yylvalpp->symbol_name, symbol_name);
+ yylvalpp->sc_int = accum;
break;
case '(':
yylvalpp->sc_int = lReadByte(pTok);
diff --git a/src/OpenGL ES 2.0/compiler/translator_common.vcproj b/src/OpenGL ES 2.0/compiler/translator_common.vcproj
deleted file mode 100644
index b269ae9..0000000
--- a/src/OpenGL ES 2.0/compiler/translator_common.vcproj
+++ /dev/null
@@ -1,584 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
- ProjectType="Visual C++"
- Version="9.00"
- Name="translator_common"
- ProjectGUID="{5B3A6DB8-1E7E-40D7-92B9-DA8AAE619FAD}"
- RootNamespace="compiler"
- Keyword="Win32Proj"
- TargetFrameworkVersion="131072"
- >
- <Platforms>
- <Platform
- Name="Win32"
- />
- </Platforms>
- <ToolFiles>
- </ToolFiles>
- <Configurations>
- <Configuration
- Name="Debug|Win32"
- OutputDirectory="$(SolutionDir)$(ConfigurationName)"
- IntermediateDirectory="$(ConfigurationName)\common"
- ConfigurationType="4"
- CharacterSet="0"
- >
- <Tool
- Name="VCPreBuildEventTool"
- />
- <Tool
- Name="VCCustomBuildTool"
- />
- <Tool
- Name="VCXMLDataGeneratorTool"
- />
- <Tool
- Name="VCWebServiceProxyGeneratorTool"
- />
- <Tool
- Name="VCMIDLTool"
- />
- <Tool
- Name="VCCLCompilerTool"
- Optimization="0"
- AdditionalIncludeDirectories="$(ProjectDir);$(ProjectDir)../;$(ProjectDir)../include"
- PreprocessorDefinitions="WIN32;_DEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;NOMINMAX"
- MinimalRebuild="true"
- ExceptionHandling="1"
- BasicRuntimeChecks="3"
- RuntimeLibrary="1"
- UsePrecompiledHeader="0"
- WarningLevel="3"
- Detect64BitPortabilityProblems="false"
- DebugInformationFormat="4"
- />
- <Tool
- Name="VCManagedResourceCompilerTool"
- />
- <Tool
- Name="VCResourceCompilerTool"
- />
- <Tool
- Name="VCPreLinkEventTool"
- />
- <Tool
- Name="VCLibrarianTool"
- />
- <Tool
- Name="VCALinkTool"
- />
- <Tool
- Name="VCXDCMakeTool"
- />
- <Tool
- Name="VCBscMakeTool"
- />
- <Tool
- Name="VCFxCopTool"
- />
- <Tool
- Name="VCPostBuildEventTool"
- />
- </Configuration>
- <Configuration
- Name="Release|Win32"
- OutputDirectory="$(SolutionDir)$(ConfigurationName)"
- IntermediateDirectory="$(ConfigurationName)\common"
- ConfigurationType="4"
- CharacterSet="0"
- WholeProgramOptimization="1"
- >
- <Tool
- Name="VCPreBuildEventTool"
- />
- <Tool
- Name="VCCustomBuildTool"
- />
- <Tool
- Name="VCXMLDataGeneratorTool"
- />
- <Tool
- Name="VCWebServiceProxyGeneratorTool"
- />
- <Tool
- Name="VCMIDLTool"
- />
- <Tool
- Name="VCCLCompilerTool"
- Optimization="2"
- InlineFunctionExpansion="2"
- AdditionalIncludeDirectories="$(ProjectDir);$(ProjectDir)../;$(ProjectDir)../include"
- PreprocessorDefinitions="WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;NOMINMAX;_SECURE_SCL=0"
- ExceptionHandling="1"
- RuntimeLibrary="0"
- UsePrecompiledHeader="0"
- WarningLevel="3"
- Detect64BitPortabilityProblems="false"
- DebugInformationFormat="3"
- />
- <Tool
- Name="VCManagedResourceCompilerTool"
- />
- <Tool
- Name="VCResourceCompilerTool"
- />
- <Tool
- Name="VCPreLinkEventTool"
- />
- <Tool
- Name="VCLibrarianTool"
- />
- <Tool
- Name="VCALinkTool"
- />
- <Tool
- Name="VCXDCMakeTool"
- />
- <Tool
- Name="VCBscMakeTool"
- />
- <Tool
- Name="VCFxCopTool"
- />
- <Tool
- Name="VCPostBuildEventTool"
- />
- </Configuration>
- </Configurations>
- <References>
- </References>
- <Files>
- <Filter
- Name="Source Files"
- Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
- UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
- >
- <File
- RelativePath=".\CodeGenGLSL.cpp"
- >
- </File>
- <File
- RelativePath=".\CodeGenHLSL.cpp"
- >
- </File>
- <File
- RelativePath=".\Compiler.cpp"
- >
- </File>
- <File
- RelativePath=".\debug.cpp"
- >
- </File>
- <File
- RelativePath=".\DetectRecursion.cpp"
- >
- </File>
- <File
- RelativePath=".\ForLoopUnroll.cpp"
- >
- </File>
- <File
- RelativePath=".\glslang.l"
- >
- <FileConfiguration
- Name="Debug|Win32"
- >
- <Tool
- Name="VCCustomBuildTool"
- Description=""
- CommandLine=""
- AdditionalDependencies=""
- Outputs=""
- />
- </FileConfiguration>
- <FileConfiguration
- Name="Release|Win32"
- >
- <Tool
- Name="VCCustomBuildTool"
- Description=""
- CommandLine=""
- AdditionalDependencies=""
- Outputs=""
- />
- </FileConfiguration>
- </File>
- <File
- RelativePath=".\glslang.y"
- >
- <FileConfiguration
- Name="Debug|Win32"
- >
- <Tool
- Name="VCCustomBuildTool"
- Description=""
- CommandLine=""
- Outputs=""
- />
- </FileConfiguration>
- <FileConfiguration
- Name="Release|Win32"
- >
- <Tool
- Name="VCCustomBuildTool"
- Description=""
- CommandLine=""
- Outputs=""
- />
- </FileConfiguration>
- </File>
- <File
- RelativePath=".\InfoSink.cpp"
- >
- </File>
- <File
- RelativePath=".\Initialize.cpp"
- >
- </File>
- <File
- RelativePath=".\InitializeDll.cpp"
- >
- </File>
- <File
- RelativePath=".\Intermediate.cpp"
- >
- </File>
- <File
- RelativePath=".\intermOut.cpp"
- >
- </File>
- <File
- RelativePath=".\IntermTraverse.cpp"
- >
- </File>
- <File
- RelativePath=".\MapLongVariableNames.cpp"
- >
- </File>
- <File
- RelativePath=".\ossource_win.cpp"
- >
- </File>
- <File
- RelativePath=".\OutputGLSL.cpp"
- >
- </File>
- <File
- RelativePath=".\OutputHLSL.cpp"
- >
- </File>
- <File
- RelativePath=".\parseConst.cpp"
- >
- </File>
- <File
- RelativePath=".\ParseHelper.cpp"
- >
- </File>
- <File
- RelativePath=".\PoolAlloc.cpp"
- >
- </File>
- <File
- RelativePath=".\QualifierAlive.cpp"
- >
- </File>
- <File
- RelativePath=".\RemoveTree.cpp"
- >
- </File>
- <File
- RelativePath=".\SearchSymbol.cpp"
- >
- </File>
- <File
- RelativePath=".\ShaderLang.cpp"
- >
- </File>
- <File
- RelativePath=".\SymbolTable.cpp"
- >
- </File>
- <File
- RelativePath=".\TranslatorGLSL.cpp"
- >
- </File>
- <File
- RelativePath=".\TranslatorHLSL.cpp"
- >
- </File>
- <File
- RelativePath=".\UnfoldSelect.cpp"
- >
- </File>
- <File
- RelativePath=".\util.cpp"
- >
- </File>
- <File
- RelativePath=".\ValidateLimitations.cpp"
- >
- </File>
- <File
- RelativePath=".\VariableInfo.cpp"
- >
- </File>
- <File
- RelativePath=".\VersionGLSL.cpp"
- >
- </File>
- <Filter
- Name="preprocessor"
- >
- <File
- RelativePath=".\preprocessor\atom.c"
- >
- </File>
- <File
- RelativePath=".\preprocessor\cpp.c"
- >
- </File>
- <File
- RelativePath=".\preprocessor\cppstruct.c"
- >
- </File>
- <File
- RelativePath=".\preprocessor\memory.c"
- >
- </File>
- <File
- RelativePath=".\preprocessor\scanner.c"
- >
- </File>
- <File
- RelativePath=".\preprocessor\symbols.c"
- >
- </File>
- <File
- RelativePath=".\preprocessor\tokens.c"
- >
- </File>
- </Filter>
- <Filter
- Name="generated"
- >
- <File
- RelativePath=".\glslang_lex.cpp"
- >
- </File>
- <File
- RelativePath=".\glslang_tab.cpp"
- >
- </File>
- </Filter>
- </Filter>
- <Filter
- Name="Header Files"
- Filter="h;hpp;hxx;hm;inl;inc;xsd"
- UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
- >
- <File
- RelativePath=".\BaseTypes.h"
- >
- </File>
- <File
- RelativePath=".\Common.h"
- >
- </File>
- <File
- RelativePath=".\ConstantUnion.h"
- >
- </File>
- <File
- RelativePath=".\debug.h"
- >
- </File>
- <File
- RelativePath=".\DetectRecursion.h"
- >
- </File>
- <File
- RelativePath=".\ExtensionBehavior.h"
- >
- </File>
- <File
- RelativePath=".\ForLoopUnroll.h"
- >
- </File>
- <File
- RelativePath=".\glslang.h"
- >
- </File>
- <File
- RelativePath=".\InfoSink.h"
- >
- </File>
- <File
- RelativePath=".\Initialize.h"
- >
- </File>
- <File
- RelativePath=".\InitializeDll.h"
- >
- </File>
- <File
- RelativePath=".\InitializeGlobals.h"
- >
- </File>
- <File
- RelativePath=".\InitializeParseContext.h"
- >
- </File>
- <File
- RelativePath=".\intermediate.h"
- >
- </File>
- <File
- RelativePath=".\localintermediate.h"
- >
- </File>
- <File
- RelativePath=".\MapLongVariableNames.h"
- >
- </File>
- <File
- RelativePath=".\MMap.h"
- >
- </File>
- <File
- RelativePath=".\osinclude.h"
- >
- </File>
- <File
- RelativePath=".\OutputGLSL.h"
- >
- </File>
- <File
- RelativePath=".\OutputHLSL.h"
- >
- </File>
- <File
- RelativePath=".\ParseHelper.h"
- >
- </File>
- <File
- RelativePath=".\PoolAlloc.h"
- >
- </File>
- <File
- RelativePath=".\QualifierAlive.h"
- >
- </File>
- <File
- RelativePath=".\RemoveTree.h"
- >
- </File>
- <File
- RelativePath="..\..\include\GLSLANG\ResourceLimits.h"
- >
- </File>
- <File
- RelativePath=".\SearchSymbol.h"
- >
- </File>
- <File
- RelativePath="..\..\include\GLSLANG\ShaderLang.h"
- >
- </File>
- <File
- RelativePath=".\ShHandle.h"
- >
- </File>
- <File
- RelativePath=".\SymbolTable.h"
- >
- </File>
- <File
- RelativePath=".\TranslatorGLSL.h"
- >
- </File>
- <File
- RelativePath=".\TranslatorHLSL.h"
- >
- </File>
- <File
- RelativePath=".\Types.h"
- >
- </File>
- <File
- RelativePath=".\UnfoldSelect.h"
- >
- </File>
- <File
- RelativePath=".\util.h"
- >
- </File>
- <File
- RelativePath=".\ValidateLimitations.h"
- >
- </File>
- <File
- RelativePath=".\VariableInfo.h"
- >
- </File>
- <File
- RelativePath=".\VersionGLSL.h"
- >
- </File>
- <Filter
- Name="preprocessor"
- >
- <File
- RelativePath=".\preprocessor\atom.h"
- >
- </File>
- <File
- RelativePath=".\preprocessor\compile.h"
- >
- </File>
- <File
- RelativePath=".\preprocessor\cpp.h"
- >
- </File>
- <File
- RelativePath=".\preprocessor\memory.h"
- >
- </File>
- <File
- RelativePath=".\preprocessor\parser.h"
- >
- </File>
- <File
- RelativePath=".\preprocessor\preprocess.h"
- >
- </File>
- <File
- RelativePath=".\preprocessor\scanner.h"
- >
- </File>
- <File
- RelativePath=".\preprocessor\slglobals.h"
- >
- </File>
- <File
- RelativePath=".\preprocessor\symbols.h"
- >
- </File>
- <File
- RelativePath=".\preprocessor\tokens.h"
- >
- </File>
- </Filter>
- <Filter
- Name="generated"
- >
- <File
- RelativePath=".\glslang_tab.h"
- >
- </File>
- </Filter>
- </Filter>
- </Files>
- <Globals>
- </Globals>
-</VisualStudioProject>
diff --git a/src/OpenGL ES 2.0/compiler/translator_common.vcxproj.user b/src/OpenGL ES 2.0/compiler/translator_common.vcxproj.user
deleted file mode 100644
index 695b5c7..0000000
--- a/src/OpenGL ES 2.0/compiler/translator_common.vcxproj.user
+++ /dev/null
@@ -1,3 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-</Project>
\ No newline at end of file
diff --git a/src/OpenGL ES 2.0/compiler/translator_hlsl.vcproj b/src/OpenGL ES 2.0/compiler/translator_hlsl.vcproj
deleted file mode 100644
index 405a812..0000000
--- a/src/OpenGL ES 2.0/compiler/translator_hlsl.vcproj
+++ /dev/null
@@ -1,202 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
- ProjectType="Visual C++"
- Version="9.00"
- Name="translator_hlsl"
- ProjectGUID="{5620F0E4-6C43-49BC-A178-B804E1A0C3A7}"
- RootNamespace="CrossCompilerHLSL"
- Keyword="Win32Proj"
- TargetFrameworkVersion="196613"
- >
- <Platforms>
- <Platform
- Name="Win32"
- />
- </Platforms>
- <ToolFiles>
- </ToolFiles>
- <Configurations>
- <Configuration
- Name="Debug|Win32"
- OutputDirectory="$(SolutionDir)$(ConfigurationName)"
- IntermediateDirectory="$(ConfigurationName)\hlsl"
- ConfigurationType="4"
- CharacterSet="0"
- >
- <Tool
- Name="VCPreBuildEventTool"
- />
- <Tool
- Name="VCCustomBuildTool"
- />
- <Tool
- Name="VCXMLDataGeneratorTool"
- />
- <Tool
- Name="VCWebServiceProxyGeneratorTool"
- />
- <Tool
- Name="VCMIDLTool"
- />
- <Tool
- Name="VCCLCompilerTool"
- Optimization="0"
- AdditionalIncludeDirectories="$(ProjectDir)../;$(ProjectDir)../include"
- PreprocessorDefinitions="WIN32;_DEBUG;_LIB;_CRT_SECURE_NO_WARNINGS;NOMINMAX"
- MinimalRebuild="true"
- ExceptionHandling="1"
- BasicRuntimeChecks="3"
- RuntimeLibrary="1"
- UsePrecompiledHeader="0"
- WarningLevel="3"
- DebugInformationFormat="4"
- />
- <Tool
- Name="VCManagedResourceCompilerTool"
- />
- <Tool
- Name="VCResourceCompilerTool"
- />
- <Tool
- Name="VCPreLinkEventTool"
- />
- <Tool
- Name="VCLibrarianTool"
- />
- <Tool
- Name="VCALinkTool"
- />
- <Tool
- Name="VCXDCMakeTool"
- />
- <Tool
- Name="VCBscMakeTool"
- />
- <Tool
- Name="VCFxCopTool"
- />
- <Tool
- Name="VCPostBuildEventTool"
- />
- </Configuration>
- <Configuration
- Name="Release|Win32"
- OutputDirectory="$(SolutionDir)$(ConfigurationName)"
- IntermediateDirectory="$(ConfigurationName)\hlsl"
- ConfigurationType="4"
- CharacterSet="0"
- WholeProgramOptimization="1"
- >
- <Tool
- Name="VCPreBuildEventTool"
- />
- <Tool
- Name="VCCustomBuildTool"
- />
- <Tool
- Name="VCXMLDataGeneratorTool"
- />
- <Tool
- Name="VCWebServiceProxyGeneratorTool"
- />
- <Tool
- Name="VCMIDLTool"
- />
- <Tool
- Name="VCCLCompilerTool"
- Optimization="2"
- InlineFunctionExpansion="2"
- EnableIntrinsicFunctions="true"
- AdditionalIncludeDirectories="$(ProjectDir)../;$(ProjectDir)../include"
- PreprocessorDefinitions="WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_WARNINGS;NOMINMAX;_SECURE_SCL=0"
- ExceptionHandling="1"
- RuntimeLibrary="0"
- EnableFunctionLevelLinking="true"
- UsePrecompiledHeader="0"
- WarningLevel="3"
- DebugInformationFormat="3"
- />
- <Tool
- Name="VCManagedResourceCompilerTool"
- />
- <Tool
- Name="VCResourceCompilerTool"
- />
- <Tool
- Name="VCPreLinkEventTool"
- />
- <Tool
- Name="VCLibrarianTool"
- />
- <Tool
- Name="VCALinkTool"
- />
- <Tool
- Name="VCXDCMakeTool"
- />
- <Tool
- Name="VCBscMakeTool"
- />
- <Tool
- Name="VCFxCopTool"
- />
- <Tool
- Name="VCPostBuildEventTool"
- />
- </Configuration>
- </Configurations>
- <References>
- </References>
- <Files>
- <Filter
- Name="Source Files"
- Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
- UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
- >
- <File
- RelativePath=".\CodeGenHLSL.cpp"
- >
- </File>
- <File
- RelativePath=".\OutputHLSL.cpp"
- >
- </File>
- <File
- RelativePath=".\SearchSymbol.cpp"
- >
- </File>
- <File
- RelativePath=".\TranslatorHLSL.cpp"
- >
- </File>
- <File
- RelativePath=".\UnfoldSelect.cpp"
- >
- </File>
- </Filter>
- <Filter
- Name="Header Files"
- Filter="h;hpp;hxx;hm;inl;inc;xsd"
- UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
- >
- <File
- RelativePath=".\OutputHLSL.h"
- >
- </File>
- <File
- RelativePath=".\SearchSymbol.h"
- >
- </File>
- <File
- RelativePath=".\TranslatorHLSL.h"
- >
- </File>
- <File
- RelativePath=".\UnfoldSelect.h"
- >
- </File>
- </Filter>
- </Files>
- <Globals>
- </Globals>
-</VisualStudioProject>
diff --git a/src/OpenGL ES 2.0/compiler/translator_hlsl.vcxproj.user b/src/OpenGL ES 2.0/compiler/translator_hlsl.vcxproj.user
deleted file mode 100644
index 695b5c7..0000000
--- a/src/OpenGL ES 2.0/compiler/translator_hlsl.vcxproj.user
+++ /dev/null
@@ -1,3 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-</Project>
\ No newline at end of file
diff --git a/src/OpenGL ES 2.0/include/EGL/eglext.h b/src/OpenGL ES 2.0/include/EGL/eglext.h
index b650a50..b670840 100644
--- a/src/OpenGL ES 2.0/include/EGL/eglext.h
+++ b/src/OpenGL ES 2.0/include/EGL/eglext.h
@@ -6,7 +6,7 @@
#endif
/*
-** Copyright (c) 2007-2009 The Khronos Group Inc.
+** Copyright (c) 2007-2012 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
@@ -34,8 +34,8 @@
/* Header file version number */
/* Current version at http://www.khronos.org/registry/egl/ */
-/* $Revision: 10795 $ on $Date: 2010-03-19 17:04:17 -0700 (Fri, 19 Mar 2010) $ */
-#define EGL_EGLEXT_VERSION 5
+/* $Revision: 16473 $ on $Date: 2012-01-04 02:20:48 -0800 (Wed, 04 Jan 2012) $ */
+#define EGL_EGLEXT_VERSION 11
#ifndef EGL_KHR_config_attribs
#define EGL_KHR_config_attribs 1
@@ -120,6 +120,7 @@
#define EGL_GL_RENDERBUFFER_KHR 0x30B9 /* eglCreateImageKHR target */
#endif
+#if KHRONOS_SUPPORT_INT64 /* EGLTimeKHR requires 64-bit uint support */
#ifndef EGL_KHR_reusable_sync
#define EGL_KHR_reusable_sync 1
@@ -149,6 +150,7 @@
typedef EGLBoolean (EGLAPIENTRYP PFNEGLSIGNALSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value);
#endif
+#endif
#ifndef EGL_KHR_image_base
#define EGL_KHR_image_base 1
@@ -169,19 +171,25 @@
#define EGL_CONTEXT_PRIORITY_LOW_IMG 0x3103
#endif
+#ifndef EGL_KHR_lock_surface2
+#define EGL_KHR_lock_surface2 1
+#define EGL_BITMAP_PIXEL_SIZE_KHR 0x3110
+#endif
+
#ifndef EGL_NV_coverage_sample
#define EGL_NV_coverage_sample 1
-#define EGL_COVERAGE_BUFFERS_NV 0x30E0
-#define EGL_COVERAGE_SAMPLES_NV 0x30E1
+#define EGL_COVERAGE_BUFFERS_NV 0x30E0
+#define EGL_COVERAGE_SAMPLES_NV 0x30E1
#endif
#ifndef EGL_NV_depth_nonlinear
#define EGL_NV_depth_nonlinear 1
-#define EGL_DEPTH_ENCODING_NV 0x30E2
+#define EGL_DEPTH_ENCODING_NV 0x30E2
#define EGL_DEPTH_ENCODING_NONE_NV 0
-#define EGL_DEPTH_ENCODING_NONLINEAR_NV 0x30E3
+#define EGL_DEPTH_ENCODING_NONLINEAR_NV 0x30E3
#endif
+#if KHRONOS_SUPPORT_INT64 /* EGLTimeNV requires 64-bit uint support */
#ifndef EGL_NV_sync
#define EGL_NV_sync 1
#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_NV 0x30E6
@@ -198,7 +206,7 @@
#define EGL_SYNC_FENCE_NV 0x30EF
#define EGL_NO_SYNC_NV ((EGLSyncNV)0)
typedef void* EGLSyncNV;
-typedef unsigned long long EGLTimeNV;
+typedef khronos_utime_nanoseconds_t EGLTimeNV;
#ifdef EGL_EGLEXT_PROTOTYPES
EGLSyncNV eglCreateFenceSyncNV (EGLDisplay dpy, EGLenum condition, const EGLint *attrib_list);
EGLBoolean eglDestroySyncNV (EGLSyncNV sync);
@@ -214,6 +222,76 @@
typedef EGLBoolean (EGLAPIENTRYP PFNEGLSIGNALSYNCNVPROC) (EGLSyncNV sync, EGLenum mode);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBNVPROC) (EGLSyncNV sync, EGLint attribute, EGLint *value);
#endif
+#endif
+
+#if KHRONOS_SUPPORT_INT64 /* Dependent on EGL_KHR_reusable_sync which requires 64-bit uint support */
+#ifndef EGL_KHR_fence_sync
+#define EGL_KHR_fence_sync 1
+/* Reuses most tokens and entry points from EGL_KHR_reusable_sync */
+#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR 0x30F0
+#define EGL_SYNC_CONDITION_KHR 0x30F8
+#define EGL_SYNC_FENCE_KHR 0x30F9
+#endif
+#endif
+
+#ifndef EGL_HI_clientpixmap
+#define EGL_HI_clientpixmap 1
+
+/* Surface Attribute */
+#define EGL_CLIENT_PIXMAP_POINTER_HI 0x8F74
+/*
+ * Structure representing a client pixmap
+ * (pixmap's data is in client-space memory).
+ */
+struct EGLClientPixmapHI
+{
+ void* pData;
+ EGLint iWidth;
+ EGLint iHeight;
+ EGLint iStride;
+};
+
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurfaceHI(EGLDisplay dpy, EGLConfig config, struct EGLClientPixmapHI* pixmap);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPIXMAPSURFACEHIPROC) (EGLDisplay dpy, EGLConfig config, struct EGLClientPixmapHI* pixmap);
+#endif /* EGL_HI_clientpixmap */
+
+#ifndef EGL_HI_colorformats
+#define EGL_HI_colorformats 1
+/* Config Attribute */
+#define EGL_COLOR_FORMAT_HI 0x8F70
+/* Color Formats */
+#define EGL_COLOR_RGB_HI 0x8F71
+#define EGL_COLOR_RGBA_HI 0x8F72
+#define EGL_COLOR_ARGB_HI 0x8F73
+#endif /* EGL_HI_colorformats */
+
+#ifndef EGL_MESA_drm_image
+#define EGL_MESA_drm_image 1
+#define EGL_DRM_BUFFER_FORMAT_MESA 0x31D0 /* CreateDRMImageMESA attribute */
+#define EGL_DRM_BUFFER_USE_MESA 0x31D1 /* CreateDRMImageMESA attribute */
+#define EGL_DRM_BUFFER_FORMAT_ARGB32_MESA 0x31D2 /* EGL_IMAGE_FORMAT_MESA attribute value */
+#define EGL_DRM_BUFFER_MESA 0x31D3 /* eglCreateImageKHR target */
+#define EGL_DRM_BUFFER_STRIDE_MESA 0x31D4
+#define EGL_DRM_BUFFER_USE_SCANOUT_MESA 0x00000001 /* EGL_DRM_BUFFER_USE_MESA bits */
+#define EGL_DRM_BUFFER_USE_SHARE_MESA 0x00000002 /* EGL_DRM_BUFFER_USE_MESA bits */
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLImageKHR EGLAPIENTRY eglCreateDRMImageMESA (EGLDisplay dpy, const EGLint *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglExportDRMImageMESA (EGLDisplay dpy, EGLImageKHR image, EGLint *name, EGLint *handle, EGLint *stride);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLImageKHR (EGLAPIENTRYP PFNEGLCREATEDRMIMAGEMESAPROC) (EGLDisplay dpy, const EGLint *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLEXPORTDRMIMAGEMESAPROC) (EGLDisplay dpy, EGLImageKHR image, EGLint *name, EGLint *handle, EGLint *stride);
+#endif
+
+#ifndef EGL_NV_post_sub_buffer
+#define EGL_NV_post_sub_buffer 1
+#define EGL_POST_SUB_BUFFER_SUPPORTED_NV 0x30BE
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglPostSubBufferNV (EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLPOSTSUBBUFFERNVPROC) (EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height);
+#endif
#ifndef EGL_ANGLE_query_surface_pointer
#define EGL_ANGLE_query_surface_pointer 1
@@ -223,9 +301,44 @@
typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSURFACEPOINTERANGLEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint attribute, void **value);
#endif
+#ifndef EGL_ANGLE_software_display
+#define EGL_ANGLE_software_display 1
+#define EGL_SOFTWARE_DISPLAY_ANGLE ((EGLNativeDisplayType)-1)
+#endif
+
#ifndef EGL_ANGLE_surface_d3d_texture_2d_share_handle
-#define EGL_ANGLE_surface_d3d_texture_2d_share_handle
-#define EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE 0x3200
+#define EGL_ANGLE_surface_d3d_texture_2d_share_handle 1
+#define EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE 0x3200
+#endif
+
+#ifndef EGL_NV_coverage_sample_resolve
+#define EGL_NV_coverage_sample_resolve 1
+#define EGL_COVERAGE_SAMPLE_RESOLVE_NV 0x3131
+#define EGL_COVERAGE_SAMPLE_RESOLVE_DEFAULT_NV 0x3132
+#define EGL_COVERAGE_SAMPLE_RESOLVE_NONE_NV 0x3133
+#endif
+
+#if KHRONOS_SUPPORT_INT64 /* EGLTimeKHR requires 64-bit uint support */
+#ifndef EGL_NV_system_time
+#define EGL_NV_system_time 1
+
+typedef khronos_utime_nanoseconds_t EGLuint64NV;
+
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLuint64NV EGLAPIENTRY eglGetSystemTimeFrequencyNV(void);
+EGLAPI EGLuint64NV EGLAPIENTRY eglGetSystemTimeNV(void);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLuint64NV (EGLAPIENTRYP PFNEGLGETSYSTEMTIMEFREQUENCYNVPROC) (void);
+typedef EGLuint64NV (EGLAPIENTRYP PFNEGLGETSYSTEMTIMENVPROC) (void);
+#endif
+#endif
+
+#ifndef EGL_EXT_create_context_robustness
+#define EGL_EXT_create_context_robustness 1
+#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT 0x30BF
+#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT 0x3138
+#define EGL_NO_RESET_NOTIFICATION_EXT 0x31BE
+#define EGL_LOSE_CONTEXT_ON_RESET_EXT 0x31BF
#endif
#ifdef __cplusplus
diff --git a/src/OpenGL ES 2.0/include/EGL/eglplatform.h b/src/OpenGL ES 2.0/include/EGL/eglplatform.h
index 22e855f..34283f2 100644
--- a/src/OpenGL ES 2.0/include/EGL/eglplatform.h
+++ b/src/OpenGL ES 2.0/include/EGL/eglplatform.h
@@ -25,7 +25,7 @@
*/
/* Platform-specific types and definitions for egl.h
- * $Revision: 9724 $ on $Date: 2009-12-02 02:05:33 -0800 (Wed, 02 Dec 2009) $
+ * $Revision: 12306 $ on $Date: 2010-08-25 09:51:28 -0700 (Wed, 25 Aug 2010) $
*
* Adopters may modify khrplatform.h and this file to suit their platform.
* You are encouraged to submit all modifications to the Khronos group so that
@@ -60,6 +60,11 @@
* Windows Device Context. They must be defined in platform-specific
* code below. The EGL-prefixed versions of Native*Type are the same
* types, renamed in EGL 1.3 so all types in the API start with "EGL".
+ *
+ * Khronos STRONGLY RECOMMENDS that you use the default definitions
+ * provided below, since these changes affect both binary and source
+ * portability of applications using EGL running on different EGL
+ * implementations.
*/
#if defined(_WIN32) || defined(__VC32__) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) /* Win32 and WinCE */
@@ -78,7 +83,13 @@
typedef void *EGLNativeWindowType;
typedef void *EGLNativePixmapType;
-#elif defined(__unix__)
+#elif defined(WL_EGL_PLATFORM)
+
+typedef struct wl_display *EGLNativeDisplayType;
+typedef struct wl_egl_pixmap *EGLNativePixmapType;
+typedef struct wl_egl_window *EGLNativeWindowType;
+
+#elif defined(__unix__) && !defined(ANDROID)
/* X11 (tentative) */
#include <X11/Xlib.h>
@@ -88,6 +99,14 @@
typedef Pixmap EGLNativePixmapType;
typedef Window EGLNativeWindowType;
+#elif defined(ANDROID)
+
+struct egl_native_pixmap_t;
+
+typedef struct ANativeWindow* EGLNativeWindowType;
+typedef struct egl_native_pixmap_t* EGLNativePixmapType;
+typedef void* EGLNativeDisplayType;
+
#else
#error "Platform not recognized"
#endif
diff --git a/src/OpenGL ES 2.0/include/GLES2/gl2ext.h b/src/OpenGL ES 2.0/include/GLES2/gl2ext.h
index 01844de..a124014 100644
--- a/src/OpenGL ES 2.0/include/GLES2/gl2ext.h
+++ b/src/OpenGL ES 2.0/include/GLES2/gl2ext.h
@@ -1,7 +1,7 @@
#ifndef __gl2ext_h_
#define __gl2ext_h_
-/* $Revision: 10798 $ on $Date:: 2010-03-19 17:34:30 -0700 #$ */
+/* $Revision: 16482 $ on $Date:: 2012-01-04 13:44:55 -0500 #$ */
#ifdef __cplusplus
extern "C" {
@@ -57,6 +57,15 @@
typedef void* GLeglImageOES;
#endif
+/* GL_OES_EGL_image_external */
+#ifndef GL_OES_EGL_image_external
+/* GLeglImageOES defined in GL_OES_EGL_image already. */
+#define GL_TEXTURE_EXTERNAL_OES 0x8D65
+#define GL_SAMPLER_EXTERNAL_OES 0x8D66
+#define GL_TEXTURE_BINDING_EXTERNAL_OES 0x8D67
+#define GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES 0x8D68
+#endif
+
/* GL_OES_element_index_uint */
#ifndef GL_OES_element_index_uint
#define GL_UNSIGNED_INT 0x1405
@@ -180,6 +189,100 @@
#endif
/*------------------------------------------------------------------------*
+ * ANGLE extension tokens
+ *------------------------------------------------------------------------*/
+
+/* GL_ANGLE_framebuffer_blit */
+#ifndef GL_ANGLE_framebuffer_blit
+#define GL_READ_FRAMEBUFFER_ANGLE 0x8CA8
+#define GL_DRAW_FRAMEBUFFER_ANGLE 0x8CA9
+#define GL_DRAW_FRAMEBUFFER_BINDING_ANGLE 0x8CA6
+#define GL_READ_FRAMEBUFFER_BINDING_ANGLE 0x8CAA
+#endif
+
+/* GL_ANGLE_framebuffer_multisample */
+#ifndef GL_ANGLE_framebuffer_multisample
+#define GL_RENDERBUFFER_SAMPLES_ANGLE 0x8CAB
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE 0x8D56
+#define GL_MAX_SAMPLES_ANGLE 0x8D57
+#endif
+
+/* GL_ANGLE_pack_reverse_row_order */
+#ifndef GL_ANGLE_pack_reverse_row_order
+#define GL_PACK_REVERSE_ROW_ORDER_ANGLE 0x93A4
+#endif
+
+/* GL_ANGLE_texture_compression_dxt3 */
+#ifndef GL_ANGLE_texture_compression_dxt3
+#define GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE 0x83F2
+#endif
+
+/* GL_ANGLE_texture_compression_dxt5 */
+#ifndef GL_ANGLE_texture_compression_dxt5
+#define GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE 0x83F3
+#endif
+
+/* GL_ANGLE_translated_shader_source */
+#ifndef GL_ANGLE_translated_shader_source
+#define GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE 0x93A0
+#endif
+
+/* GL_ANGLE_texture_usage */
+#ifndef GL_ANGLE_texture_usage
+#define GL_TEXTURE_USAGE_ANGLE 0x93A2
+#define GL_FRAMEBUFFER_ATTACHMENT_ANGLE 0x93A3
+#endif
+
+/* GL_ANGLE_instanced_arrays */
+#ifndef GL_ANGLE_instanced_arrays
+#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE 0x88FE
+#endif
+
+/*------------------------------------------------------------------------*
+ * APPLE extension tokens
+ *------------------------------------------------------------------------*/
+
+/* GL_APPLE_rgb_422 */
+#ifndef GL_APPLE_rgb_422
+#define GL_RGB_422_APPLE 0x8A1F
+#define GL_UNSIGNED_SHORT_8_8_APPLE 0x85BA
+#define GL_UNSIGNED_SHORT_8_8_REV_APPLE 0x85BB
+#endif
+
+/* GL_APPLE_framebuffer_multisample */
+#ifndef GL_APPLE_framebuffer_multisample
+#define GL_RENDERBUFFER_SAMPLES_APPLE 0x8CAB
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE 0x8D56
+#define GL_MAX_SAMPLES_APPLE 0x8D57
+#define GL_READ_FRAMEBUFFER_APPLE 0x8CA8
+#define GL_DRAW_FRAMEBUFFER_APPLE 0x8CA9
+#define GL_DRAW_FRAMEBUFFER_BINDING_APPLE 0x8CA6
+#define GL_READ_FRAMEBUFFER_BINDING_APPLE 0x8CAA
+#endif
+
+/* GL_APPLE_texture_format_BGRA8888 */
+#ifndef GL_APPLE_texture_format_BGRA8888
+#define GL_BGRA_EXT 0x80E1
+#endif
+
+/* GL_APPLE_texture_max_level */
+#ifndef GL_APPLE_texture_max_level
+#define GL_TEXTURE_MAX_LEVEL_APPLE 0x813D
+#endif
+
+/*------------------------------------------------------------------------*
+ * ARM extension tokens
+ *------------------------------------------------------------------------*/
+
+/* GL_ARM_mali_shader_binary */
+#ifndef GL_ARM_mali_shader_binary
+#define GL_MALI_SHADER_BINARY_ARM 0x8F60
+#endif
+
+/* GL_ARM_rgba8 */
+/* No new tokens introduced by this extension. */
+
+/*------------------------------------------------------------------------*
* EXT extension tokens
*------------------------------------------------------------------------*/
@@ -189,6 +292,29 @@
#define GL_MAX_EXT 0x8008
#endif
+/* GL_EXT_color_buffer_half_float */
+#ifndef GL_EXT_color_buffer_half_float
+#define GL_RGBA16F_EXT 0x881A
+#define GL_RGB16F_EXT 0x881B
+#define GL_RG16F_EXT 0x822F
+#define GL_R16F_EXT 0x822D
+#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT 0x8211
+#define GL_UNSIGNED_NORMALIZED_EXT 0x8C17
+#endif
+
+/* GL_EXT_debug_label */
+#ifndef GL_EXT_debug_label
+#define GL_PROGRAM_PIPELINE_OBJECT_EXT 0x8A4F
+#define GL_PROGRAM_OBJECT_EXT 0x8B40
+#define GL_SHADER_OBJECT_EXT 0x8B48
+#define GL_BUFFER_OBJECT_EXT 0x9151
+#define GL_QUERY_OBJECT_EXT 0x9153
+#define GL_VERTEX_ARRAY_OBJECT_EXT 0x9154
+#endif
+
+/* GL_EXT_debug_marker */
+/* No new tokens introduced by this extension. */
+
/* GL_EXT_discard_framebuffer */
#ifndef GL_EXT_discard_framebuffer
#define GL_COLOR_EXT 0x1800
@@ -196,9 +322,26 @@
#define GL_STENCIL_EXT 0x1802
#endif
+/* GL_EXT_multisampled_render_to_texture */
+#ifndef GL_EXT_multisampled_render_to_texture
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT 0x8D6C
+#define GL_RENDERBUFFER_SAMPLES_EXT 0x9133
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT 0x9134
+#define GL_MAX_SAMPLES_EXT 0x9135
+#endif
+
/* GL_EXT_multi_draw_arrays */
/* No new tokens introduced by this extension. */
+/* GL_EXT_occlusion_query_boolean */
+#ifndef GL_EXT_occlusion_query_boolean
+#define GL_ANY_SAMPLES_PASSED_EXT 0x8C2F
+#define GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT 0x8D6A
+#define GL_CURRENT_QUERY_EXT 0x8865
+#define GL_QUERY_RESULT_EXT 0x8866
+#define GL_QUERY_RESULT_AVAILABLE_EXT 0x8867
+#endif
+
/* GL_EXT_read_format_bgra */
#ifndef GL_EXT_read_format_bgra
#define GL_BGRA_EXT 0x80E1
@@ -206,6 +349,52 @@
#define GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT 0x8366
#endif
+/* GL_EXT_robustness */
+#ifndef GL_EXT_robustness
+/* reuse GL_NO_ERROR */
+#define GL_GUILTY_CONTEXT_RESET_EXT 0x8253
+#define GL_INNOCENT_CONTEXT_RESET_EXT 0x8254
+#define GL_UNKNOWN_CONTEXT_RESET_EXT 0x8255
+#define GL_CONTEXT_ROBUST_ACCESS_EXT 0x90F3
+#define GL_RESET_NOTIFICATION_STRATEGY_EXT 0x8256
+#define GL_LOSE_CONTEXT_ON_RESET_EXT 0x8252
+#define GL_NO_RESET_NOTIFICATION_EXT 0x8261
+#endif
+
+/* GL_EXT_separate_shader_objects */
+#ifndef GL_EXT_separate_shader_objects
+#define GL_VERTEX_SHADER_BIT_EXT 0x00000001
+#define GL_FRAGMENT_SHADER_BIT_EXT 0x00000002
+#define GL_ALL_SHADER_BITS_EXT 0xFFFFFFFF
+#define GL_PROGRAM_SEPARABLE_EXT 0x8258
+#define GL_ACTIVE_PROGRAM_EXT 0x8259
+#define GL_PROGRAM_PIPELINE_BINDING_EXT 0x825A
+#endif
+
+/* GL_EXT_shader_texture_lod */
+/* No new tokens introduced by this extension. */
+
+/* GL_EXT_shadow_samplers */
+#ifndef GL_EXT_shadow_samplers
+#define GL_TEXTURE_COMPARE_MODE_EXT 0x884C
+#define GL_TEXTURE_COMPARE_FUNC_EXT 0x884D
+#define GL_COMPARE_REF_TO_TEXTURE_EXT 0x884E
+#endif
+
+/* GL_EXT_sRGB */
+#ifndef GL_EXT_sRGB
+#define GL_SRGB_EXT 0x8C40
+#define GL_SRGB_ALPHA_EXT 0x8C42
+#define GL_SRGB8_ALPHA8_EXT 0x8C43
+#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT 0x8210
+#endif
+
+/* GL_EXT_texture_compression_dxt1 */
+#ifndef GL_EXT_texture_compression_dxt1
+#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0
+#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1
+#endif
+
/* GL_EXT_texture_filter_anisotropic */
#ifndef GL_EXT_texture_filter_anisotropic
#define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE
@@ -217,15 +406,54 @@
#define GL_BGRA_EXT 0x80E1
#endif
+/* GL_EXT_texture_rg */
+#ifndef GL_EXT_texture_rg
+#define GL_RED_EXT 0x1903
+#define GL_RG_EXT 0x8227
+#define GL_R8_EXT 0x8229
+#define GL_RG8_EXT 0x822B
+#endif
+
+/* GL_EXT_texture_storage */
+#ifndef GL_EXT_texture_storage
+#define GL_TEXTURE_IMMUTABLE_FORMAT_EXT 0x912F
+#define GL_ALPHA8_EXT 0x803C
+#define GL_LUMINANCE8_EXT 0x8040
+#define GL_LUMINANCE8_ALPHA8_EXT 0x8045
+#define GL_RGBA32F_EXT 0x8814
+#define GL_RGB32F_EXT 0x8815
+#define GL_ALPHA32F_EXT 0x8816
+#define GL_LUMINANCE32F_EXT 0x8818
+#define GL_LUMINANCE_ALPHA32F_EXT 0x8819
+/* reuse GL_RGBA16F_EXT */
+#define GL_RGB16F_EXT 0x881B
+#define GL_ALPHA16F_EXT 0x881C
+#define GL_LUMINANCE16F_EXT 0x881E
+#define GL_LUMINANCE_ALPHA16F_EXT 0x881F
+#define GL_RGB10_A2_EXT 0x8059
+#define GL_RGB10_EXT 0x8052
+#define GL_BGRA8_EXT 0x93A1
+#endif
+
/* GL_EXT_texture_type_2_10_10_10_REV */
#ifndef GL_EXT_texture_type_2_10_10_10_REV
#define GL_UNSIGNED_INT_2_10_10_10_REV_EXT 0x8368
#endif
-/* GL_EXT_texture_compression_dxt1 */
-#ifndef GL_EXT_texture_compression_dxt1
-#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0
-#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1
+/* GL_EXT_unpack_subimage */
+#ifndef GL_EXT_unpack_subimage
+#define GL_UNPACK_ROW_LENGTH 0x0CF2
+#define GL_UNPACK_SKIP_ROWS 0x0CF3
+#define GL_UNPACK_SKIP_PIXELS 0x0CF4
+#endif
+
+/*------------------------------------------------------------------------*
+ * DMP extension tokens
+ *------------------------------------------------------------------------*/
+
+/* GL_DMP_shader_binary */
+#ifndef GL_DMP_shader_binary
+#define GL_SHADER_BINARY_DMP 0x9250
#endif
/*------------------------------------------------------------------------*
@@ -256,17 +484,18 @@
#define GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG 0x8C03
#endif
+/* GL_IMG_multisampled_render_to_texture */
+#ifndef GL_IMG_multisampled_render_to_texture
+#define GL_RENDERBUFFER_SAMPLES_IMG 0x9133
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG 0x9134
+#define GL_MAX_SAMPLES_IMG 0x9135
+#define GL_TEXTURE_SAMPLES_IMG 0x9136
+#endif
+
/*------------------------------------------------------------------------*
* NV extension tokens
*------------------------------------------------------------------------*/
-/* GL_NV_fence */
-#ifndef GL_NV_fence
-#define GL_ALL_COMPLETED_NV 0x84F2
-#define GL_FENCE_STATUS_NV 0x84F3
-#define GL_FENCE_CONDITION_NV 0x84F4
-#endif
-
/* GL_NV_coverage_sample */
#ifndef GL_NV_coverage_sample
#define GL_COVERAGE_COMPONENT_NV 0x8ED0
@@ -285,10 +514,90 @@
#define GL_DEPTH_COMPONENT16_NONLINEAR_NV 0x8E2C
#endif
+/* GL_NV_draw_buffers */
+#ifndef GL_NV_draw_buffers
+#define GL_MAX_DRAW_BUFFERS_NV 0x8824
+#define GL_DRAW_BUFFER0_NV 0x8825
+#define GL_DRAW_BUFFER1_NV 0x8826
+#define GL_DRAW_BUFFER2_NV 0x8827
+#define GL_DRAW_BUFFER3_NV 0x8828
+#define GL_DRAW_BUFFER4_NV 0x8829
+#define GL_DRAW_BUFFER5_NV 0x882A
+#define GL_DRAW_BUFFER6_NV 0x882B
+#define GL_DRAW_BUFFER7_NV 0x882C
+#define GL_DRAW_BUFFER8_NV 0x882D
+#define GL_DRAW_BUFFER9_NV 0x882E
+#define GL_DRAW_BUFFER10_NV 0x882F
+#define GL_DRAW_BUFFER11_NV 0x8830
+#define GL_DRAW_BUFFER12_NV 0x8831
+#define GL_DRAW_BUFFER13_NV 0x8832
+#define GL_DRAW_BUFFER14_NV 0x8833
+#define GL_DRAW_BUFFER15_NV 0x8834
+#define GL_COLOR_ATTACHMENT0_NV 0x8CE0
+#define GL_COLOR_ATTACHMENT1_NV 0x8CE1
+#define GL_COLOR_ATTACHMENT2_NV 0x8CE2
+#define GL_COLOR_ATTACHMENT3_NV 0x8CE3
+#define GL_COLOR_ATTACHMENT4_NV 0x8CE4
+#define GL_COLOR_ATTACHMENT5_NV 0x8CE5
+#define GL_COLOR_ATTACHMENT6_NV 0x8CE6
+#define GL_COLOR_ATTACHMENT7_NV 0x8CE7
+#define GL_COLOR_ATTACHMENT8_NV 0x8CE8
+#define GL_COLOR_ATTACHMENT9_NV 0x8CE9
+#define GL_COLOR_ATTACHMENT10_NV 0x8CEA
+#define GL_COLOR_ATTACHMENT11_NV 0x8CEB
+#define GL_COLOR_ATTACHMENT12_NV 0x8CEC
+#define GL_COLOR_ATTACHMENT13_NV 0x8CED
+#define GL_COLOR_ATTACHMENT14_NV 0x8CEE
+#define GL_COLOR_ATTACHMENT15_NV 0x8CEF
+#endif
+
+/* GL_NV_fbo_color_attachments */
+#ifndef GL_NV_fbo_color_attachments
+#define GL_MAX_COLOR_ATTACHMENTS_NV 0x8CDF
+/* GL_COLOR_ATTACHMENT{0-15}_NV defined in GL_NV_draw_buffers already. */
+#endif
+
+/* GL_NV_fence */
+#ifndef GL_NV_fence
+#define GL_ALL_COMPLETED_NV 0x84F2
+#define GL_FENCE_STATUS_NV 0x84F3
+#define GL_FENCE_CONDITION_NV 0x84F4
+#endif
+
+/* GL_NV_read_buffer */
+#ifndef GL_NV_read_buffer
+#define GL_READ_BUFFER_NV 0x0C02
+#endif
+
+/* GL_NV_read_buffer_front */
+/* No new tokens introduced by this extension. */
+
+/* GL_NV_read_depth */
+/* No new tokens introduced by this extension. */
+
+/* GL_NV_read_depth_stencil */
+/* No new tokens introduced by this extension. */
+
+/* GL_NV_read_stencil */
+/* No new tokens introduced by this extension. */
+
+/* GL_NV_texture_compression_s3tc_update */
+/* No new tokens introduced by this extension. */
+
+/* GL_NV_texture_npot_2D_mipmap */
+/* No new tokens introduced by this extension. */
+
/*------------------------------------------------------------------------*
* QCOM extension tokens
*------------------------------------------------------------------------*/
+/* GL_QCOM_alpha_test */
+#ifndef GL_QCOM_alpha_test
+#define GL_ALPHA_TEST_QCOM 0x0BC0
+#define GL_ALPHA_TEST_FUNC_QCOM 0x0BC1
+#define GL_ALPHA_TEST_REF_QCOM 0x0BC2
+#endif
+
/* GL_QCOM_driver_control */
/* No new tokens introduced by this extension. */
@@ -357,22 +666,12 @@
#endif
/*------------------------------------------------------------------------*
- * ANGLE extension tokens
+ * VIV extension tokens
*------------------------------------------------------------------------*/
-/* GL_ANGLE_framebuffer_blit */
-#ifndef GL_ANGLE_framebuffer_blit
-#define GL_READ_FRAMEBUFFER_ANGLE 0x8CA8
-#define GL_DRAW_FRAMEBUFFER_ANGLE 0x8CA9
-#define GL_DRAW_FRAMEBUFFER_BINDING_ANGLE 0x8CA6 // alias GL_FRAMEBUFFER_BINDING
-#define GL_READ_FRAMEBUFFER_BINDING_ANGLE 0x8CAA
-#endif
-
-/* GL_ANGLE_framebuffer_multisample */
-#ifndef GL_ANGLE_framebuffer_multisample
-#define GL_RENDERBUFFER_SAMPLES_ANGLE 0x8CAB
-#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE 0x8D56
-#define GL_MAX_SAMPLES_ANGLE 0x8D57
+/* GL_VIV_shader_binary */
+#ifndef GL_VIV_shader_binary
+#define GL_SHADER_BINARY_VIV 0x8FC4
#endif
/*------------------------------------------------------------------------*
@@ -419,6 +718,12 @@
typedef void (GL_APIENTRYP PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC) (GLenum target, GLeglImageOES image);
#endif
+/* GL_OES_EGL_image_external */
+#ifndef GL_OES_EGL_image_external
+#define GL_OES_EGL_image_external 1
+/* glEGLImageTargetTexture2DOES defined in GL_OES_EGL_image already. */
+#endif
+
/* GL_OES_element_index_uint */
#ifndef GL_OES_element_index_uint
#define GL_OES_element_index_uint 1
@@ -601,6 +906,114 @@
#endif
/*------------------------------------------------------------------------*
+ * ANGLE extension functions
+ *------------------------------------------------------------------------*/
+
+/* GL_ANGLE_framebuffer_blit */
+#ifndef GL_ANGLE_framebuffer_blit
+#define GL_ANGLE_framebuffer_blit 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glBlitFramebufferANGLE (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+#endif
+typedef void (GL_APIENTRYP PFNGLBLITFRAMEBUFFERANGLEPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+#endif
+
+/* GL_ANGLE_framebuffer_multisample */
+#ifndef GL_ANGLE_framebuffer_multisample
+#define GL_ANGLE_framebuffer_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glRenderbufferStorageMultisampleANGLE (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+#endif
+typedef void (GL_APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLEPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+#endif
+
+/* GL_ANGLE_pack_reverse_row_order */
+#ifndef GL_ANGLE_pack_reverse_row_order
+#define GL_ANGLE_pack_reverse_row_order 1
+#endif
+
+/* GL_ANGLE_texture_compression_dxt3 */
+#ifndef GL_ANGLE_texture_compression_dxt3
+#define GL_ANGLE_texture_compression_dxt3 1
+#endif
+
+/* GL_ANGLE_texture_compression_dxt5 */
+#ifndef GL_ANGLE_texture_compression_dxt5
+#define GL_ANGLE_texture_compression_dxt5 1
+#endif
+
+/* GL_ANGLE_translated_shader_source */
+#ifndef GL_ANGLE_translated_shader_source
+#define GL_ANGLE_translated_shader_source 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glGetTranslatedShaderSourceANGLE (GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source);
+#endif
+typedef void (GL_APIENTRYP PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC) (GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source);
+#endif
+
+/* GL_ANGLE_texture_usage */
+#ifndef GL_ANGLE_texture_usage
+#define GL_ANGLE_texture_usage 1
+#endif
+
+/* GL_ANGLE_instanced_arrays */
+#ifndef GL_ANGLE_instanced_arrays
+#define GL_ANGLE_instanced_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glVertexAttribDivisorANGLE(GLuint index, GLuint divisor);
+GL_APICALL void GL_APIENTRY glDrawArraysInstancedANGLE(GLenum mode, GLint first, GLsizei count, GLsizei primcount);
+GL_APICALL void GL_APIENTRY glDrawElementsInstancedANGLE(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount);
+#endif
+typedef void (GL_APIENTRYP PFNGLVERTEXATTRIBDIVISORANGLEPROC) (GLuint index, GLuint divisor);
+typedef void (GL_APIENTRYP PFNGLDRAWARRAYSINSTANCEDANGLEPROC) (GLenum mode, GLint first, GLsizei count, GLsizei primcount);
+typedef void (GL_APIENTRYP PFNGLDRAWELEMENTSINSTANCEDANGLEPROC) (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount);
+#endif
+
+/*------------------------------------------------------------------------*
+ * APPLE extension functions
+ *------------------------------------------------------------------------*/
+
+/* GL_APPLE_rgb_422 */
+#ifndef GL_APPLE_rgb_422
+#define GL_APPLE_rgb_422 1
+#endif
+
+/* GL_APPLE_framebuffer_multisample */
+#ifndef GL_APPLE_framebuffer_multisample
+#define GL_APPLE_framebuffer_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glRenderbufferStorageMultisampleAPPLE (GLenum, GLsizei, GLenum, GLsizei, GLsizei);
+GL_APICALL void GL_APIENTRY glResolveMultisampleFramebufferAPPLE (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (GL_APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEAPPLEPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GL_APIENTRYP PFNGLRESOLVEMULTISAMPLEFRAMEBUFFERAPPLEPROC) (void);
+#endif
+
+/* GL_APPLE_texture_format_BGRA8888 */
+#ifndef GL_APPLE_texture_format_BGRA8888
+#define GL_APPLE_texture_format_BGRA8888 1
+#endif
+
+/* GL_APPLE_texture_max_level */
+#ifndef GL_APPLE_texture_max_level
+#define GL_APPLE_texture_max_level 1
+#endif
+
+/*------------------------------------------------------------------------*
+ * ARM extension functions
+ *------------------------------------------------------------------------*/
+
+/* GL_ARM_mali_shader_binary */
+#ifndef GL_ARM_mali_shader_binary
+#define GL_ARM_mali_shader_binary 1
+#endif
+
+/* GL_ARM_rgba8 */
+#ifndef GL_ARM_rgba8
+#define GL_ARM_rgba8 1
+#endif
+
+/*------------------------------------------------------------------------*
* EXT extension functions
*------------------------------------------------------------------------*/
@@ -609,6 +1022,35 @@
#define GL_EXT_blend_minmax 1
#endif
+/* GL_EXT_color_buffer_half_float */
+#ifndef GL_EXT_color_buffer_half_float
+#define GL_EXT_color_buffer_half_float 1
+#endif
+
+/* GL_EXT_debug_label */
+#ifndef GL_EXT_debug_label
+#define GL_EXT_debug_label 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glLabelObjectEXT (GLenum type, GLuint object, GLsizei length, const GLchar *label);
+GL_APICALL void GL_APIENTRY glGetObjectLabelEXT (GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label);
+#endif
+typedef void (GL_APIENTRYP PFNGLLABELOBJECTEXTPROC) (GLenum type, GLuint object, GLsizei length, const GLchar *label);
+typedef void (GL_APIENTRYP PFNGLGETOBJECTLABELEXTPROC) (GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label);
+#endif
+
+/* GL_EXT_debug_marker */
+#ifndef GL_EXT_debug_marker
+#define GL_EXT_debug_marker 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glInsertEventMarkerEXT (GLsizei length, const GLchar *marker);
+GL_APICALL void GL_APIENTRY glPushGroupMarkerEXT (GLsizei length, const GLchar *marker);
+GL_APICALL void GL_APIENTRY glPopGroupMarkerEXT (void);
+#endif
+typedef void (GL_APIENTRYP PFNGLINSERTEVENTMARKEREXTPROC) (GLsizei length, const GLchar *marker);
+typedef void (GL_APIENTRYP PFNGLPUSHGROUPMARKEREXTPROC) (GLsizei length, const GLchar *marker);
+typedef void (GL_APIENTRYP PFNGLPOPGROUPMARKEREXTPROC) (void);
+#endif
+
/* GL_EXT_discard_framebuffer */
#ifndef GL_EXT_discard_framebuffer
#define GL_EXT_discard_framebuffer 1
@@ -618,6 +1060,17 @@
typedef void (GL_APIENTRYP PFNGLDISCARDFRAMEBUFFEREXTPROC) (GLenum target, GLsizei numAttachments, const GLenum *attachments);
#endif
+/* GL_EXT_multisampled_render_to_texture */
+#ifndef GL_EXT_multisampled_render_to_texture
+#define GL_EXT_multisampled_render_to_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glRenderbufferStorageMultisampleEXT (GLenum, GLsizei, GLenum, GLsizei, GLsizei);
+GL_APICALL void GL_APIENTRY glFramebufferTexture2DMultisampleEXT (GLenum, GLenum, GLenum, GLuint, GLint, GLsizei);
+#endif
+typedef void (GL_APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GL_APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples);
+#endif
+
#ifndef GL_EXT_multi_draw_arrays
#define GL_EXT_multi_draw_arrays 1
#ifdef GL_GLEXT_PROTOTYPES
@@ -628,11 +1081,134 @@
typedef void (GL_APIENTRYP PFNGLMULTIDRAWELEMENTSEXTPROC) (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount);
#endif
+/* GL_EXT_occlusion_query_boolean */
+#ifndef GL_EXT_occlusion_query_boolean
+#define GL_EXT_occlusion_query_boolean 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glGenQueriesEXT (GLsizei n, GLuint *ids);
+GL_APICALL void GL_APIENTRY glDeleteQueriesEXT (GLsizei n, const GLuint *ids);
+GL_APICALL GLboolean GL_APIENTRY glIsQueryEXT (GLuint id);
+GL_APICALL void GL_APIENTRY glBeginQueryEXT (GLenum target, GLuint id);
+GL_APICALL void GL_APIENTRY glEndQueryEXT (GLenum target);
+GL_APICALL void GL_APIENTRY glGetQueryivEXT (GLenum target, GLenum pname, GLint *params);
+GL_APICALL void GL_APIENTRY glGetQueryObjectuivEXT (GLuint id, GLenum pname, GLuint *params);
+#endif
+typedef void (GL_APIENTRYP PFNGLGENQUERIESEXTPROC) (GLsizei n, GLuint *ids);
+typedef void (GL_APIENTRYP PFNGLDELETEQUERIESEXTPROC) (GLsizei n, const GLuint *ids);
+typedef GLboolean (GL_APIENTRYP PFNGLISQUERYEXTPROC) (GLuint id);
+typedef void (GL_APIENTRYP PFNGLBEGINQUERYEXTPROC) (GLenum target, GLuint id);
+typedef void (GL_APIENTRYP PFNGLENDQUERYEXTPROC) (GLenum target);
+typedef void (GL_APIENTRYP PFNGLGETQUERYIVEXTPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (GL_APIENTRYP PFNGLGETQUERYOBJECTUIVEXTPROC) (GLuint id, GLenum pname, GLuint *params);
+#endif
+
/* GL_EXT_read_format_bgra */
#ifndef GL_EXT_read_format_bgra
#define GL_EXT_read_format_bgra 1
#endif
+/* GL_EXT_robustness */
+#ifndef GL_EXT_robustness
+#define GL_EXT_robustness 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL GLenum GL_APIENTRY glGetGraphicsResetStatusEXT (void);
+GL_APICALL void GL_APIENTRY glReadnPixelsEXT (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data);
+GL_APICALL void GL_APIENTRY glGetnUniformfvEXT (GLuint program, GLint location, GLsizei bufSize, float *params);
+GL_APICALL void GL_APIENTRY glGetnUniformivEXT (GLuint program, GLint location, GLsizei bufSize, GLint *params);
+#endif
+typedef GLenum (GL_APIENTRYP PFNGLGETGRAPHICSRESETSTATUSEXTPROC) (void);
+typedef void (GL_APIENTRYP PFNGLREADNPIXELSEXTPROC) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data);
+typedef void (GL_APIENTRYP PFNGLGETNUNIFORMFVEXTPROC) (GLuint program, GLint location, GLsizei bufSize, float *params);
+typedef void (GL_APIENTRYP PFNGLGETNUNIFORMIVEXTPROC) (GLuint program, GLint location, GLsizei bufSize, GLint *params);
+#endif
+
+/* GL_EXT_separate_shader_objects */
+#ifndef GL_EXT_separate_shader_objects
+#define GL_EXT_separate_shader_objects 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glUseProgramStagesEXT (GLuint pipeline, GLbitfield stages, GLuint program);
+GL_APICALL void GL_APIENTRY glActiveShaderProgramEXT (GLuint pipeline, GLuint program);
+GL_APICALL GLuint GL_APIENTRY glCreateShaderProgramvEXT (GLenum type, GLsizei count, const GLchar **strings);
+GL_APICALL void GL_APIENTRY glBindProgramPipelineEXT (GLuint pipeline);
+GL_APICALL void GL_APIENTRY glDeleteProgramPipelinesEXT (GLsizei n, const GLuint *pipelines);
+GL_APICALL void GL_APIENTRY glGenProgramPipelinesEXT (GLsizei n, GLuint *pipelines);
+GL_APICALL GLboolean GL_APIENTRY glIsProgramPipelineEXT (GLuint pipeline);
+GL_APICALL void GL_APIENTRY glProgramParameteriEXT (GLuint program, GLenum pname, GLint value);
+GL_APICALL void GL_APIENTRY glGetProgramPipelineivEXT (GLuint pipeline, GLenum pname, GLint *params);
+GL_APICALL void GL_APIENTRY glProgramUniform1iEXT (GLuint program, GLint location, GLint x);
+GL_APICALL void GL_APIENTRY glProgramUniform2iEXT (GLuint program, GLint location, GLint x, GLint y);
+GL_APICALL void GL_APIENTRY glProgramUniform3iEXT (GLuint program, GLint location, GLint x, GLint y, GLint z);
+GL_APICALL void GL_APIENTRY glProgramUniform4iEXT (GLuint program, GLint location, GLint x, GLint y, GLint z, GLint w);
+GL_APICALL void GL_APIENTRY glProgramUniform1fEXT (GLuint program, GLint location, GLfloat x);
+GL_APICALL void GL_APIENTRY glProgramUniform2fEXT (GLuint program, GLint location, GLfloat x, GLfloat y);
+GL_APICALL void GL_APIENTRY glProgramUniform3fEXT (GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z);
+GL_APICALL void GL_APIENTRY glProgramUniform4fEXT (GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GL_APICALL void GL_APIENTRY glProgramUniform1ivEXT (GLuint program, GLint location, GLsizei count, const GLint *value);
+GL_APICALL void GL_APIENTRY glProgramUniform2ivEXT (GLuint program, GLint location, GLsizei count, const GLint *value);
+GL_APICALL void GL_APIENTRY glProgramUniform3ivEXT (GLuint program, GLint location, GLsizei count, const GLint *value);
+GL_APICALL void GL_APIENTRY glProgramUniform4ivEXT (GLuint program, GLint location, GLsizei count, const GLint *value);
+GL_APICALL void GL_APIENTRY glProgramUniform1fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GL_APICALL void GL_APIENTRY glProgramUniform2fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GL_APICALL void GL_APIENTRY glProgramUniform3fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GL_APICALL void GL_APIENTRY glProgramUniform4fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GL_APICALL void GL_APIENTRY glProgramUniformMatrix2fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GL_APICALL void GL_APIENTRY glProgramUniformMatrix3fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GL_APICALL void GL_APIENTRY glProgramUniformMatrix4fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GL_APICALL void GL_APIENTRY glValidateProgramPipelineEXT (GLuint pipeline);
+GL_APICALL void GL_APIENTRY glGetProgramPipelineInfoLogEXT (GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+#endif
+typedef void (GL_APIENTRYP PFNGLUSEPROGRAMSTAGESEXTPROC) (GLuint pipeline, GLbitfield stages, GLuint program);
+typedef void (GL_APIENTRYP PFNGLACTIVESHADERPROGRAMEXTPROC) (GLuint pipeline, GLuint program);
+typedef GLuint (GL_APIENTRYP PFNGLCREATESHADERPROGRAMVEXTPROC) (GLenum type, GLsizei count, const GLchar **strings);
+typedef void (GL_APIENTRYP PFNGLBINDPROGRAMPIPELINEEXTPROC) (GLuint pipeline);
+typedef void (GL_APIENTRYP PFNGLDELETEPROGRAMPIPELINESEXTPROC) (GLsizei n, const GLuint *pipelines);
+typedef void (GL_APIENTRYP PFNGLGENPROGRAMPIPELINESEXTPROC) (GLsizei n, GLuint *pipelines);
+typedef GLboolean (GL_APIENTRYP PFNGLISPROGRAMPIPELINEEXTPROC) (GLuint pipeline);
+typedef void (GL_APIENTRYP PFNGLPROGRAMPARAMETERIEXTPROC) (GLuint program, GLenum pname, GLint value);
+typedef void (GL_APIENTRYP PFNGLGETPROGRAMPIPELINEIVEXTPROC) (GLuint pipeline, GLenum pname, GLint *params);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM1IEXTPROC) (GLuint program, GLint location, GLint x);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM2IEXTPROC) (GLuint program, GLint location, GLint x, GLint y);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM3IEXTPROC) (GLuint program, GLint location, GLint x, GLint y, GLint z);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM4IEXTPROC) (GLuint program, GLint location, GLint x, GLint y, GLint z, GLint w);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM1FEXTPROC) (GLuint program, GLint location, GLfloat x);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM2FEXTPROC) (GLuint program, GLint location, GLfloat x, GLfloat y);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM3FEXTPROC) (GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM4FEXTPROC) (GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM1IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM2IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM3IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM4IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM1FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM2FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM3FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM4FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (GL_APIENTRYP PFNGLVALIDATEPROGRAMPIPELINEEXTPROC) (GLuint pipeline);
+typedef void (GL_APIENTRYP PFNGLGETPROGRAMPIPELINEINFOLOGEXTPROC) (GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+#endif
+
+/* GL_EXT_shader_texture_lod */
+#ifndef GL_EXT_shader_texture_lod
+#define GL_EXT_shader_texture_lod 1
+#endif
+
+/* GL_EXT_shadow_samplers */
+#ifndef GL_EXT_shadow_samplers
+#define GL_EXT_shadow_samplers 1
+#endif
+
+/* GL_EXT_sRGB */
+#ifndef GL_EXT_sRGB
+#define GL_EXT_sRGB 1
+#endif
+
+/* GL_EXT_texture_compression_dxt1 */
+#ifndef GL_EXT_texture_compression_dxt1
+#define GL_EXT_texture_compression_dxt1 1
+#endif
+
/* GL_EXT_texture_filter_anisotropic */
#ifndef GL_EXT_texture_filter_anisotropic
#define GL_EXT_texture_filter_anisotropic 1
@@ -643,14 +1219,47 @@
#define GL_EXT_texture_format_BGRA8888 1
#endif
+/* GL_EXT_texture_rg */
+#ifndef GL_EXT_texture_rg
+#define GL_EXT_texture_rg 1
+#endif
+
+/* GL_EXT_texture_storage */
+#ifndef GL_EXT_texture_storage
+#define GL_EXT_texture_storage 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glTexStorage1DEXT (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
+GL_APICALL void GL_APIENTRY glTexStorage2DEXT (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+GL_APICALL void GL_APIENTRY glTexStorage3DEXT (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+GL_APICALL void GL_APIENTRY glTextureStorage1DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
+GL_APICALL void GL_APIENTRY glTextureStorage2DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+GL_APICALL void GL_APIENTRY glTextureStorage3DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+#endif
+typedef void (GL_APIENTRYP PFNGLTEXSTORAGE1DEXTPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
+typedef void (GL_APIENTRYP PFNGLTEXSTORAGE2DEXTPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GL_APIENTRYP PFNGLTEXSTORAGE3DEXTPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+typedef void (GL_APIENTRYP PFNGLTEXTURESTORAGE1DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
+typedef void (GL_APIENTRYP PFNGLTEXTURESTORAGE2DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GL_APIENTRYP PFNGLTEXTURESTORAGE3DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+#endif
+
/* GL_EXT_texture_type_2_10_10_10_REV */
#ifndef GL_EXT_texture_type_2_10_10_10_REV
#define GL_EXT_texture_type_2_10_10_10_REV 1
#endif
-/* GL_EXT_texture_compression_dxt1 */
-#ifndef GL_EXT_texture_compression_dxt1
-#define GL_EXT_texture_compression_dxt1 1
+/* GL_EXT_unpack_subimage */
+#ifndef GL_EXT_unpack_subimage
+#define GL_EXT_unpack_subimage 1
+#endif
+
+/*------------------------------------------------------------------------*
+ * DMP extension functions
+ *------------------------------------------------------------------------*/
+
+/* GL_DMP_shader_binary */
+#ifndef GL_DMP_shader_binary
+#define GL_DMP_shader_binary 1
#endif
/*------------------------------------------------------------------------*
@@ -677,10 +1286,51 @@
#define GL_IMG_texture_compression_pvrtc 1
#endif
+/* GL_IMG_multisampled_render_to_texture */
+#ifndef GL_IMG_multisampled_render_to_texture
+#define GL_IMG_multisampled_render_to_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glRenderbufferStorageMultisampleIMG (GLenum, GLsizei, GLenum, GLsizei, GLsizei);
+GL_APICALL void GL_APIENTRY glFramebufferTexture2DMultisampleIMG (GLenum, GLenum, GLenum, GLuint, GLint, GLsizei);
+#endif
+typedef void (GL_APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMG) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GL_APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMG) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples);
+#endif
+
/*------------------------------------------------------------------------*
* NV extension functions
*------------------------------------------------------------------------*/
+/* GL_NV_coverage_sample */
+#ifndef GL_NV_coverage_sample
+#define GL_NV_coverage_sample 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glCoverageMaskNV (GLboolean mask);
+GL_APICALL void GL_APIENTRY glCoverageOperationNV (GLenum operation);
+#endif
+typedef void (GL_APIENTRYP PFNGLCOVERAGEMASKNVPROC) (GLboolean mask);
+typedef void (GL_APIENTRYP PFNGLCOVERAGEOPERATIONNVPROC) (GLenum operation);
+#endif
+
+/* GL_NV_depth_nonlinear */
+#ifndef GL_NV_depth_nonlinear
+#define GL_NV_depth_nonlinear 1
+#endif
+
+/* GL_NV_draw_buffers */
+#ifndef GL_NV_draw_buffers
+#define GL_NV_draw_buffers 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glDrawBuffersNV (GLsizei n, const GLenum *bufs);
+#endif
+typedef void (GL_APIENTRYP PFNGLDRAWBUFFERSNVPROC) (GLsizei n, const GLenum *bufs);
+#endif
+
+/* GL_NV_fbo_color_attachments */
+#ifndef GL_NV_fbo_color_attachments
+#define GL_NV_fbo_color_attachments 1
+#endif
+
/* GL_NV_fence */
#ifndef GL_NV_fence
#define GL_NV_fence 1
@@ -702,26 +1352,58 @@
typedef void (GL_APIENTRYP PFNGLSETFENCENVPROC) (GLuint fence, GLenum condition);
#endif
-/* GL_NV_coverage_sample */
-#ifndef GL_NV_coverage_sample
-#define GL_NV_coverage_sample 1
+/* GL_NV_read_buffer */
+#ifndef GL_NV_read_buffer
+#define GL_NV_read_buffer 1
#ifdef GL_GLEXT_PROTOTYPES
-GL_APICALL void GL_APIENTRY glCoverageMaskNV (GLboolean mask);
-GL_APICALL void GL_APIENTRY glCoverageOperationNV (GLenum operation);
+GL_APICALL void GL_APIENTRY glReadBufferNV (GLenum mode);
#endif
-typedef void (GL_APIENTRYP PFNGLCOVERAGEMASKNVPROC) (GLboolean mask);
-typedef void (GL_APIENTRYP PFNGLCOVERAGEOPERATIONNVPROC) (GLenum operation);
+typedef void (GL_APIENTRYP PFNGLREADBUFFERNVPROC) (GLenum mode);
#endif
-/* GL_NV_depth_nonlinear */
-#ifndef GL_NV_depth_nonlinear
-#define GL_NV_depth_nonlinear 1
+/* GL_NV_read_buffer_front */
+#ifndef GL_NV_read_buffer_front
+#define GL_NV_read_buffer_front 1
+#endif
+
+/* GL_NV_read_depth */
+#ifndef GL_NV_read_depth
+#define GL_NV_read_depth 1
+#endif
+
+/* GL_NV_read_depth_stencil */
+#ifndef GL_NV_read_depth_stencil
+#define GL_NV_read_depth_stencil 1
+#endif
+
+/* GL_NV_read_stencil */
+#ifndef GL_NV_read_stencil
+#define GL_NV_read_stencil 1
+#endif
+
+/* GL_NV_texture_compression_s3tc_update */
+#ifndef GL_NV_texture_compression_s3tc_update
+#define GL_NV_texture_compression_s3tc_update 1
+#endif
+
+/* GL_NV_texture_npot_2D_mipmap */
+#ifndef GL_NV_texture_npot_2D_mipmap
+#define GL_NV_texture_npot_2D_mipmap 1
#endif
/*------------------------------------------------------------------------*
* QCOM extension functions
*------------------------------------------------------------------------*/
+/* GL_QCOM_alpha_test */
+#ifndef GL_QCOM_alpha_test
+#define GL_QCOM_alpha_test 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glAlphaFuncQCOM (GLenum func, GLclampf ref);
+#endif
+typedef void (GL_APIENTRYP PFNGLALPHAFUNCQCOMPROC) (GLenum func, GLclampf ref);
+#endif
+
/* GL_QCOM_driver_control */
#ifndef GL_QCOM_driver_control
#define GL_QCOM_driver_control 1
@@ -797,31 +1479,12 @@
#endif
/*------------------------------------------------------------------------*
- * ANGLE extension functions
+ * VIV extension tokens
*------------------------------------------------------------------------*/
-/* GL_ANGLE_framebuffer_blit */
-#ifndef GL_ANGLE_framebuffer_blit
-#define GL_ANGLE_framebuffer_blit 1
-#ifdef GL_GLEXT_PROTOTYPES
-GL_APICALL void GL_APIENTRY glBlitFramebufferANGLE (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
- GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
- GLbitfield mask, GLenum filter);
-#endif
-typedef void (GL_APIENTRYP PFNGLBLITFRAMEBUFFERANGLEPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
- GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
- GLbitfield mask, GLenum filter);
-#endif
-
-/* GL_ANGLE_framebuffer_multisample */
-#ifndef GL_ANGLE_framebuffer_multisample
-#define GL_ANGLE_framebuffer_multisample 1
-#ifdef GL_GLEXT_PROTOTYPES
-GL_APICALL void GL_APIENTRY glRenderbufferStorageMultisampleANGLE (GLenum target, GLsizei samples, GLenum internalformat,
- GLsizei width, GLsizei height);
-#endif
-typedef void (GL_APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLEPROC) (GLenum target, GLsizei samples, GLenum internalformat,
- GLsizei width, GLsizei height);
+/* GL_VIV_shader_binary */
+#ifndef GL_VIV_shader_binary
+#define GL_VIV_shader_binary 1
#endif
#ifdef __cplusplus
diff --git a/src/OpenGL ES 2.0/include/GLSLANG/ShaderLang.h b/src/OpenGL ES 2.0/include/GLSLANG/ShaderLang.h
index 6795a87..0d78834 100644
--- a/src/OpenGL ES 2.0/include/GLSLANG/ShaderLang.h
+++ b/src/OpenGL ES 2.0/include/GLSLANG/ShaderLang.h
@@ -62,8 +62,7 @@
SH_ACTIVE_UNIFORMS = 0x8B86,
SH_ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87,
SH_ACTIVE_ATTRIBUTES = 0x8B89,
- SH_ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A,
- SH_MAPPED_NAME_MAX_LENGTH = 0x8B8B
+ SH_ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A
} ShShaderInfo;
// Compile options.
@@ -74,8 +73,7 @@
SH_OBJECT_CODE = 0x0004,
SH_ATTRIBUTES_UNIFORMS = 0x0008,
SH_LINE_DIRECTIVES = 0x0010,
- SH_SOURCE_PATH = 0x0020,
- SH_MAP_LONG_VARIABLE_NAMES = 0x0040
+ SH_SOURCE_PATH = 0x0020
} ShCompileOptions;
//
diff --git a/src/OpenGL ES 2.0/libEGL/Config.cpp b/src/OpenGL ES 2.0/libEGL/Config.cpp
index 4851edb..f675bb1 100644
--- a/src/OpenGL ES 2.0/libEGL/Config.cpp
+++ b/src/OpenGL ES 2.0/libEGL/Config.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Config.cpp: Implements the egl::Config class, describing the format, type
diff --git a/src/OpenGL ES 2.0/libEGL/Config.h b/src/OpenGL ES 2.0/libEGL/Config.h
index 1dc260d..ae0bbcc 100644
--- a/src/OpenGL ES 2.0/libEGL/Config.h
+++ b/src/OpenGL ES 2.0/libEGL/Config.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Config.h: Defines the egl::Config class, describing the format, type
diff --git a/src/OpenGL ES 2.0/libEGL/Display.cpp b/src/OpenGL ES 2.0/libEGL/Display.cpp
index c4273c4..07bf868 100644
--- a/src/OpenGL ES 2.0/libEGL/Display.cpp
+++ b/src/OpenGL ES 2.0/libEGL/Display.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2011 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.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Display.cpp: Implements the egl::Display class, representing the abstract
@@ -63,12 +68,28 @@
displays.erase(displayId);
}
+static bool detectSSE()
+{
+ #if defined(_WIN32) && _M_IX86 >= 500
+ int registers[4];
+ __cpuid(registers, 1);
+ return (registers[3] & 0x02000000) != 0;
+ #else
+ #error Unimplemented platform
+ #endif
+}
+
bool Display::initialize()
{
if(isInitialized())
{
return true;
}
+
+ if(!detectSSE())
+ {
+ return false;
+ }
mMinSwapInterval = 0;
mMaxSwapInterval = 4;
@@ -482,7 +503,7 @@
std::string::size_type end = mExtensionString.find_last_not_of(' ');
if(end != std::string::npos)
{
- mExtensionString.resize(end+1);
+ mExtensionString.resize(end + 1);
}
}
diff --git a/src/OpenGL ES 2.0/libEGL/Display.h b/src/OpenGL ES 2.0/libEGL/Display.h
index 4449a28..1ce295e 100644
--- a/src/OpenGL ES 2.0/libEGL/Display.h
+++ b/src/OpenGL ES 2.0/libEGL/Display.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2011 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.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Display.h: Defines the egl::Display class, representing the abstract
@@ -22,11 +27,6 @@
#include <windows.h>
#include <set>
-namespace sw
-{
- class Context;
-}
-
namespace egl
{
class Display
@@ -39,8 +39,8 @@
bool initialize();
void terminate();
- virtual void startScene() {}; // FIXME: Remove when Chrome no longer calls getDevice() directly
- virtual void endScene() {}; // FIXME: Remove when Chrome no longer calls getDevice() directly
+ virtual void startScene() {ASSERT(!"Stop calling internal ANGLE methods!");}; // FIXME: Remove when Chrome no longer calls getDevice() directly
+ virtual void endScene() {ASSERT(!"Stop calling internal ANGLE methods!");}; // FIXME: Remove when Chrome no longer calls getDevice() directly
bool getConfigs(EGLConfig *configs, const EGLint *attribList, EGLint configSize, EGLint *numConfig);
bool getConfigAttrib(EGLConfig config, EGLint attribute, EGLint *value);
@@ -61,7 +61,7 @@
EGLint getMinSwapInterval();
EGLint getMaxSwapInterval();
- virtual gl::Device *getDeviceChrome() {return 0;}; // FIXME: Remove when Chrome no longer calls getDevice() directly
+ virtual gl::Device *getDeviceChrome() {ASSERT(!"Stop calling internal ANGLE methods!"); return 0;}; // FIXME: Remove when Chrome no longer calls getDevice() directly
virtual gl::Device *getDevice();
const char *getExtensionString() const;
diff --git a/src/OpenGL ES 2.0/libEGL/Surface.cpp b/src/OpenGL ES 2.0/libEGL/Surface.cpp
index 456bf01..d31ed14 100644
--- a/src/OpenGL ES 2.0/libEGL/Surface.cpp
+++ b/src/OpenGL ES 2.0/libEGL/Surface.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Surface.cpp: Implements the egl::Surface class, representing a drawing surface
@@ -23,22 +28,6 @@
namespace egl
{
-namespace
-{
-const int versionWindowsVista = MAKEWORD(0x00, 0x06);
-const int versionWindows7 = MAKEWORD(0x01, 0x06);
-
-// Return the version of the operating system in a format suitable for ordering
-// comparison.
-int getComparableOSVersion()
-{
- DWORD version = GetVersion();
- int majorVersion = LOBYTE(LOWORD(version));
- int minorVersion = HIBYTE(LOWORD(version));
- return MAKEWORD(minorVersion, majorVersion);
-}
-}
-
Surface::Surface(Display *display, const Config *config, HWND window)
: mDisplay(display), mConfig(config), mWindow(window)
{
@@ -96,7 +85,7 @@
// Modify present parameters for this window, if we are composited,
// to minimize the amount of queuing done by DWM between our calls to
// present and the actual screen.
- if (mWindow && (getComparableOSVersion() >= versionWindowsVista))
+ if(mWindow && (LOWORD(GetVersion()) >= 0x60))
{
BOOL isComposited;
HRESULT result = DwmIsCompositionEnabled(&isComposited);
@@ -175,7 +164,7 @@
if(mWindow)
{
- frameBuffer = createFrameBuffer(0, backBufferWidth, backBufferHeight, false);
+ frameBuffer = createFrameBuffer(0, backBufferWidth, backBufferHeight, false, false);
if(!frameBuffer)
{
diff --git a/src/OpenGL ES 2.0/libEGL/Surface.h b/src/OpenGL ES 2.0/libEGL/Surface.h
index 7cff1bc..934b059 100644
--- a/src/OpenGL ES 2.0/libEGL/Surface.h
+++ b/src/OpenGL ES 2.0/libEGL/Surface.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Surface.h: Defines the egl::Surface class, representing a drawing surface
diff --git a/src/OpenGL ES 2.0/libEGL/libEGL.cpp b/src/OpenGL ES 2.0/libEGL/libEGL.cpp
index d91e5e7..3d29a8c 100644
--- a/src/OpenGL ES 2.0/libEGL/libEGL.cpp
+++ b/src/OpenGL ES 2.0/libEGL/libEGL.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// libEGL.cpp: Implements the exported EGL functions.
@@ -186,7 +191,7 @@
case EGL_VENDOR:
return success("TransGaming Inc.");
case EGL_VERSION:
- return success("1.4 (ANGLE "VERSION_STRING")");
+ return success("1.4 (SwiftShader "VERSION_STRING")");
}
return error(EGL_BAD_PARAMETER, (const char*)NULL);
@@ -436,7 +441,7 @@
return error(EGL_BAD_SURFACE, EGL_FALSE);
}
- switch (attribute)
+ switch(attribute)
{
case EGL_VG_ALPHA_FORMAT:
UNIMPLEMENTED(); // FIXME
@@ -846,7 +851,7 @@
}
if((draw != EGL_NO_SURFACE && !validateSurface(display, static_cast<egl::Surface*>(draw))) ||
- (read != EGL_NO_SURFACE && !validateSurface(display, static_cast<egl::Surface*>(read))))
+ (read != EGL_NO_SURFACE && !validateSurface(display, static_cast<egl::Surface*>(read))))
{
return EGL_FALSE;
}
diff --git a/src/OpenGL ES 2.0/libEGL/libEGL.rc b/src/OpenGL ES 2.0/libEGL/libEGL.rc
index a8487df..d426063 100644
--- a/src/OpenGL ES 2.0/libEGL/libEGL.rc
+++ b/src/OpenGL ES 2.0/libEGL/libEGL.rc
@@ -73,7 +73,7 @@
VALUE "FileDescription", "SwiftShader libEGL Dynamic Link Library"
VALUE "FileVersion", VERSION_STRING
VALUE "InternalName", "libEGL"
- VALUE "LegalCopyright", "Copyright (C) 2011 TransGaming Inc."
+ VALUE "LegalCopyright", "Copyright (C) 2012 TransGaming Inc."
VALUE "OriginalFilename", "libEGL.dll"
VALUE "PrivateBuild", VERSION_STRING
VALUE "ProductName", "SwiftShader libEGL Dynamic Link Library"
diff --git a/src/OpenGL ES 2.0/libEGL/libEGL.vcproj b/src/OpenGL ES 2.0/libEGL/libEGL.vcproj
deleted file mode 100644
index 68b041f..0000000
--- a/src/OpenGL ES 2.0/libEGL/libEGL.vcproj
+++ /dev/null
@@ -1,268 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
- ProjectType="Visual C++"
- Version="9.00"
- Name="libEGL"
- ProjectGUID="{E746FCA9-64C3-433E-85E8-9A5A67AB7ED6}"
- RootNamespace="libEGL"
- Keyword="Win32Proj"
- TargetFrameworkVersion="131072"
- >
- <Platforms>
- <Platform
- Name="Win32"
- />
- </Platforms>
- <ToolFiles>
- </ToolFiles>
- <Configurations>
- <Configuration
- Name="Debug|Win32"
- OutputDirectory="$(SolutionDir)$(ConfigurationName)"
- IntermediateDirectory="$(ConfigurationName)"
- ConfigurationType="2"
- CharacterSet="0"
- >
- <Tool
- Name="VCPreBuildEventTool"
- />
- <Tool
- Name="VCCustomBuildTool"
- />
- <Tool
- Name="VCXMLDataGeneratorTool"
- />
- <Tool
- Name="VCWebServiceProxyGeneratorTool"
- />
- <Tool
- Name="VCMIDLTool"
- />
- <Tool
- Name="VCCLCompilerTool"
- Optimization="0"
- AdditionalIncludeDirectories="$(ProjectDir)/..;$(ProjectDir)/../..; $(ProjectDir)/../include"
- PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBEGL_EXPORTS;_CRT_SECURE_NO_DEPRECATE;NOMINMAX"
- MinimalRebuild="true"
- ExceptionHandling="1"
- BasicRuntimeChecks="3"
- RuntimeLibrary="1"
- UsePrecompiledHeader="0"
- WarningLevel="3"
- Detect64BitPortabilityProblems="false"
- DebugInformationFormat="4"
- />
- <Tool
- Name="VCManagedResourceCompilerTool"
- />
- <Tool
- Name="VCResourceCompilerTool"
- />
- <Tool
- Name="VCPreLinkEventTool"
- />
- <Tool
- Name="VCLinkerTool"
- AdditionalDependencies="d3d9.lib dxguid.lib dwmapi.lib"
- LinkIncremental="2"
- ModuleDefinitionFile="libEGL.def"
- DelayLoadDLLs="dwmapi.dll"
- GenerateDebugInformation="true"
- SubSystem="2"
- RandomizedBaseAddress="1"
- DataExecutionPrevention="0"
- TargetMachine="1"
- />
- <Tool
- Name="VCALinkTool"
- />
- <Tool
- Name="VCManifestTool"
- />
- <Tool
- Name="VCXDCMakeTool"
- />
- <Tool
- Name="VCBscMakeTool"
- />
- <Tool
- Name="VCFxCopTool"
- />
- <Tool
- Name="VCAppVerifierTool"
- />
- <Tool
- Name="VCPostBuildEventTool"
- CommandLine="@echo on
mkdir "$(ProjectDir)..\..\lib\$(ConfigurationName)\"
copy "$(OutDir)\libEGL.dll" "$(ProjectDir)..\..\lib\$(ConfigurationName)\"
copy "$(OutDir)\libEGL.lib" "$(ProjectDir)..\..\lib\$(ConfigurationName)\"
@echo off
"
- />
- </Configuration>
- <Configuration
- Name="Release|Win32"
- OutputDirectory="$(SolutionDir)$(ConfigurationName)"
- IntermediateDirectory="$(ConfigurationName)"
- ConfigurationType="2"
- CharacterSet="0"
- WholeProgramOptimization="1"
- >
- <Tool
- Name="VCPreBuildEventTool"
- />
- <Tool
- Name="VCCustomBuildTool"
- />
- <Tool
- Name="VCXMLDataGeneratorTool"
- />
- <Tool
- Name="VCWebServiceProxyGeneratorTool"
- />
- <Tool
- Name="VCMIDLTool"
- />
- <Tool
- Name="VCCLCompilerTool"
- Optimization="2"
- InlineFunctionExpansion="2"
- AdditionalIncludeDirectories="$(ProjectDir)/..;$(ProjectDir)/../..; $(ProjectDir)/../include"
- PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBEGL_EXPORTS;_CRT_SECURE_NO_DEPRECATE;NOMINMAX;_SECURE_SCL=0"
- ExceptionHandling="1"
- RuntimeLibrary="0"
- UsePrecompiledHeader="0"
- WarningLevel="3"
- Detect64BitPortabilityProblems="false"
- DebugInformationFormat="3"
- />
- <Tool
- Name="VCManagedResourceCompilerTool"
- />
- <Tool
- Name="VCResourceCompilerTool"
- />
- <Tool
- Name="VCPreLinkEventTool"
- />
- <Tool
- Name="VCLinkerTool"
- AdditionalDependencies="d3d9.lib dxguid.lib dwmapi.lib"
- LinkIncremental="1"
- ModuleDefinitionFile="libEGL.def"
- DelayLoadDLLs="dwmapi.dll"
- GenerateDebugInformation="true"
- SubSystem="2"
- OptimizeReferences="2"
- EnableCOMDATFolding="2"
- RandomizedBaseAddress="1"
- DataExecutionPrevention="0"
- TargetMachine="1"
- />
- <Tool
- Name="VCALinkTool"
- />
- <Tool
- Name="VCManifestTool"
- />
- <Tool
- Name="VCXDCMakeTool"
- />
- <Tool
- Name="VCBscMakeTool"
- />
- <Tool
- Name="VCFxCopTool"
- />
- <Tool
- Name="VCAppVerifierTool"
- />
- <Tool
- Name="VCPostBuildEventTool"
- CommandLine="@echo on
mkdir "$(ProjectDir)..\..\lib\$(ConfigurationName)\"
copy "$(OutDir)\libEGL.dll" "$(ProjectDir)..\..\lib\$(ConfigurationName)\"
copy "$(OutDir)\libEGL.lib" "$(ProjectDir)..\..\lib\$(ConfigurationName)\"
@echo off
"
- />
- </Configuration>
- </Configurations>
- <References>
- </References>
- <Files>
- <Filter
- Name="Source Files"
- Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
- UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
- >
- <File
- RelativePath=".\Config.cpp"
- >
- </File>
- <File
- RelativePath="..\Common\debug.cpp"
- >
- </File>
- <File
- RelativePath=".\Display.cpp"
- >
- </File>
- <File
- RelativePath=".\libEGL.cpp"
- >
- </File>
- <File
- RelativePath=".\main.cpp"
- >
- </File>
- <File
- RelativePath=".\Surface.cpp"
- >
- </File>
- </Filter>
- <Filter
- Name="Header Files"
- Filter="h;hpp;hxx;hm;inl;inc;xsd"
- UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
- >
- <File
- RelativePath=".\Config.h"
- >
- </File>
- <File
- RelativePath=".\Display.h"
- >
- </File>
- <File
- RelativePath="..\..\include\EGL\egl.h"
- >
- </File>
- <File
- RelativePath="..\..\include\EGL\eglext.h"
- >
- </File>
- <File
- RelativePath="..\..\include\EGL\eglplatform.h"
- >
- </File>
- <File
- RelativePath=".\main.h"
- >
- </File>
- <File
- RelativePath=".\resource.h"
- >
- </File>
- <File
- RelativePath=".\Surface.h"
- >
- </File>
- <File
- RelativePath="..\common\version.h"
- >
- </File>
- </Filter>
- <File
- RelativePath=".\libEGL.def"
- >
- </File>
- <File
- RelativePath=".\libEGL.rc"
- >
- </File>
- </Files>
- <Globals>
- </Globals>
-</VisualStudioProject>
diff --git a/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj b/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj
index 4eca5e1..0b0dc8a 100644
--- a/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj
+++ b/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj
@@ -75,7 +75,6 @@
<WarningLevel>Level3</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<BrowseInformation>true</BrowseInformation>
- <ExceptionHandling>Sync</ExceptionHandling>
</ClCompile>
<Link>
<AdditionalDependencies>dwmapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
@@ -106,7 +105,6 @@
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
- <ExceptionHandling>Sync</ExceptionHandling>
</ClCompile>
<Link>
<AdditionalDependencies>dwmapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
@@ -139,6 +137,7 @@
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+ <OmitFramePointers>false</OmitFramePointers>
</ClCompile>
<Link>
<AdditionalDependencies>dwmapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
@@ -169,15 +168,14 @@
<ClCompile Include="Surface.cpp" />
</ItemGroup>
<ItemGroup>
+ <ClInclude Include="..\include\EGL\egl.h" />
+ <ClInclude Include="..\include\EGL\eglext.h" />
+ <ClInclude Include="..\include\EGL\eglplatform.h" />
<ClInclude Include="Config.h" />
<ClInclude Include="Display.h" />
- <ClInclude Include="..\..\include\EGL\egl.h" />
- <ClInclude Include="..\..\include\EGL\eglext.h" />
- <ClInclude Include="..\..\include\EGL\eglplatform.h" />
<ClInclude Include="main.h" />
<ClInclude Include="resource.h" />
<ClInclude Include="Surface.h" />
- <ClInclude Include="..\common\version.h" />
</ItemGroup>
<ItemGroup>
<None Include="libEGL.def" />
diff --git a/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj.filters b/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj.filters
index 860e169..0ee6b4b 100644
--- a/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj.filters
+++ b/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj.filters
@@ -37,15 +37,6 @@
<ClInclude Include="Display.h">
<Filter>Header Files</Filter>
</ClInclude>
- <ClInclude Include="..\..\include\EGL\egl.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\..\include\EGL\eglext.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\..\include\EGL\eglplatform.h">
- <Filter>Header Files</Filter>
- </ClInclude>
<ClInclude Include="main.h">
<Filter>Header Files</Filter>
</ClInclude>
@@ -55,7 +46,13 @@
<ClInclude Include="Surface.h">
<Filter>Header Files</Filter>
</ClInclude>
- <ClInclude Include="..\common\version.h">
+ <ClInclude Include="..\include\EGL\egl.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="..\include\EGL\eglext.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="..\include\EGL\eglplatform.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
diff --git a/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj.user b/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj.user
deleted file mode 100644
index 695b5c7..0000000
--- a/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj.user
+++ /dev/null
@@ -1,3 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-</Project>
\ No newline at end of file
diff --git a/src/OpenGL ES 2.0/libEGL/main.cpp b/src/OpenGL ES 2.0/libEGL/main.cpp
index 7c6f44b..6661a1a 100644
--- a/src/OpenGL ES 2.0/libEGL/main.cpp
+++ b/src/OpenGL ES 2.0/libEGL/main.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// main.cpp: DLL entry point and management of thread-local data.
diff --git a/src/OpenGL ES 2.0/libEGL/main.h b/src/OpenGL ES 2.0/libEGL/main.h
index d09d9e6..7ba67a9 100644
--- a/src/OpenGL ES 2.0/libEGL/main.h
+++ b/src/OpenGL ES 2.0/libEGL/main.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// main.h: Management of thread-local data.
diff --git a/src/OpenGL ES 2.0/libGLESv2/Buffer.cpp b/src/OpenGL ES 2.0/libGLESv2/Buffer.cpp
index 0edb0e7..8869800 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Buffer.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Buffer.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Buffer.cpp: Implements the Buffer class, representing storage of vertex and/or
diff --git a/src/OpenGL ES 2.0/libGLESv2/Buffer.h b/src/OpenGL ES 2.0/libGLESv2/Buffer.h
index bdc5244..2b3d2fc 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Buffer.h
+++ b/src/OpenGL ES 2.0/libGLESv2/Buffer.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Buffer.h: Defines the Buffer class, representing storage of vertex and/or
@@ -40,8 +45,6 @@
sw::Resource *getResource();
private:
- DISALLOW_COPY_AND_ASSIGN(Buffer);
-
sw::Resource *mContents;
size_t mSize;
GLenum mUsage;
diff --git a/src/OpenGL ES 2.0/libGLESv2/Context.cpp b/src/OpenGL ES 2.0/libGLESv2/Context.cpp
index 0ab375d..e674e20 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Context.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Context.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2011 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.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Context.cpp: Implements the gl::Context class, managing all GL state and performing
@@ -17,6 +22,7 @@
#include "Fence.h"
#include "FrameBuffer.h"
#include "Program.h"
+#include "Query.h"
#include "RenderBuffer.h"
#include "Shader.h"
#include "Texture.h"
@@ -173,6 +179,11 @@
deleteFence(mFenceMap.begin()->first);
}
+ while(!mQueryMap.empty())
+ {
+ deleteQuery(mQueryMap.begin()->first);
+ }
+
while(!mMultiSampleSupport.empty())
{
delete [] mMultiSampleSupport.begin()->second;
@@ -192,6 +203,11 @@
mState.vertexAttribute[i].mBoundBuffer.set(NULL);
}
+ for(int i = 0; i < QUERY_TYPE_COUNT; i++)
+ {
+ mState.activeQuery[i].set(NULL);
+ }
+
mState.arrayBuffer.set(NULL);
mState.elementArrayBuffer.set(NULL);
mState.renderbuffer.set(NULL);
@@ -211,8 +227,8 @@
if(!mHasBeenCurrent)
{
- mVertexDataManager = new VertexDataManager(this, device);
- mIndexDataManager = new IndexDataManager(this, device);
+ mVertexDataManager = new VertexDataManager(this);
+ mIndexDataManager = new IndexDataManager();
const sw::Format renderBufferFormats[] =
{
@@ -264,19 +280,12 @@
void Context::markAllStateDirty()
{
mAppliedProgramSerial = 0;
- mAppliedRenderTargetSerial = 0;
- mAppliedDepthbufferSerial = 0;
- mAppliedStencilbufferSerial = 0;
- mDepthStencilInitialized = false;
- mClearStateDirty = true;
- mCullStateDirty = true;
mDepthStateDirty = true;
mMaskStateDirty = true;
mBlendStateDirty = true;
mStencilStateDirty = true;
mPolygonOffsetStateDirty = true;
- mScissorStateDirty = true;
mSampleStateDirty = true;
mDitherStateDirty = true;
mFrontFaceDirty = true;
@@ -302,11 +311,7 @@
void Context::setCullFace(bool enabled)
{
- if(mState.cullFace != enabled)
- {
- mState.cullFace = enabled;
- mCullStateDirty = true;
- }
+ mState.cullFace = enabled;
}
bool Context::isCullFaceEnabled() const
@@ -316,11 +321,7 @@
void Context::setCullMode(GLenum mode)
{
- if(mState.cullMode != mode)
- {
- mState.cullMode = mode;
- mCullStateDirty = true;
- }
+ mState.cullMode = mode;
}
void Context::setFrontFace(GLenum front)
@@ -567,11 +568,7 @@
void Context::setScissorTest(bool enabled)
{
- if(mState.scissorTest != enabled)
- {
- mState.scissorTest = enabled;
- mScissorStateDirty = true;
- }
+ mState.scissorTest = enabled;
}
bool Context::isScissorTestEnabled() const
@@ -621,21 +618,16 @@
void Context::setScissorParams(GLint x, GLint y, GLsizei width, GLsizei height)
{
- if(mState.scissorX != x || mState.scissorY != y ||
- mState.scissorWidth != width || mState.scissorHeight != height)
- {
- mState.scissorX = x;
- mState.scissorY = y;
- mState.scissorWidth = width;
- mState.scissorHeight = height;
- mScissorStateDirty = true;
- }
+ mState.scissorX = x;
+ mState.scissorY = y;
+ mState.scissorWidth = width;
+ mState.scissorHeight = height;
}
void Context::setColorMask(bool red, bool green, bool blue, bool alpha)
{
if(mState.colorMaskRed != red || mState.colorMaskGreen != green ||
- mState.colorMaskBlue != blue || mState.colorMaskAlpha != alpha)
+ mState.colorMaskBlue != blue || mState.colorMaskAlpha != alpha)
{
mState.colorMaskRed = red;
mState.colorMaskGreen = green;
@@ -679,6 +671,30 @@
return mState.arrayBuffer.id();
}
+GLuint Context::getActiveQuery(GLenum target) const
+{
+ Query *queryObject = NULL;
+
+ switch(target)
+ {
+ case GL_ANY_SAMPLES_PASSED_EXT:
+ queryObject = mState.activeQuery[QUERY_ANY_SAMPLES_PASSED].get();
+ break;
+ case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
+ queryObject = mState.activeQuery[QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE].get();
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ if(queryObject)
+ {
+ return queryObject->id();
+ }
+
+ return 0;
+}
+
void Context::setEnableVertexAttribArray(unsigned int attribNum, bool enabled)
{
mState.vertexAttribute[attribNum].mArrayEnabled = enabled;
@@ -774,6 +790,16 @@
return handle;
}
+// Returns an unused query name
+GLuint Context::createQuery()
+{
+ GLuint handle = mQueryHandleAllocator.allocate();
+
+ mQueryMap[handle] = NULL;
+
+ return handle;
+}
+
void Context::deleteBuffer(GLuint buffer)
{
if(mResourceManager->getBuffer(buffer))
@@ -840,6 +866,23 @@
}
}
+void Context::deleteQuery(GLuint query)
+{
+ QueryMap::iterator queryObject = mQueryMap.find(query);
+
+ if(queryObject != mQueryMap.end())
+ {
+ mQueryHandleAllocator.release(queryObject->first);
+
+ if(queryObject->second)
+ {
+ queryObject->second->release();
+ }
+
+ mQueryMap.erase(queryObject);
+ }
+}
+
Buffer *Context::getBuffer(GLuint handle)
{
return mResourceManager->getBuffer(handle);
@@ -952,6 +995,93 @@
}
}
+void Context::beginQuery(GLenum target, GLuint query)
+{
+ // From EXT_occlusion_query_boolean: If BeginQueryEXT is called with an <id>
+ // of zero, if the active query object name for <target> is non-zero (for the
+ // targets ANY_SAMPLES_PASSED_EXT and ANY_SAMPLES_PASSED_CONSERVATIVE_EXT, if
+ // the active query for either target is non-zero), if <id> is the name of an
+ // existing query object whose type does not match <target>, or if <id> is the
+ // active query object name for any query type, the error INVALID_OPERATION is
+ // generated.
+
+ // Ensure no other queries are active
+ // NOTE: If other queries than occlusion are supported, we will need to check
+ // separately that:
+ // a) The query ID passed is not the current active query for any target/type
+ // b) There are no active queries for the requested target (and in the case
+ // of GL_ANY_SAMPLES_PASSED_EXT and GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT,
+ // no query may be active for either if glBeginQuery targets either.
+ for(int i = 0; i < QUERY_TYPE_COUNT; i++)
+ {
+ if(mState.activeQuery[i].get() != NULL)
+ {
+ return error(GL_INVALID_OPERATION);
+ }
+ }
+
+ QueryType qType;
+ switch(target)
+ {
+ case GL_ANY_SAMPLES_PASSED_EXT:
+ qType = QUERY_ANY_SAMPLES_PASSED;
+ break;
+ case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
+ qType = QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE;
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ Query *queryObject = getQuery(query, true, target);
+
+ // Check that name was obtained with glGenQueries
+ if(!queryObject)
+ {
+ return error(GL_INVALID_OPERATION);
+ }
+
+ // Check for type mismatch
+ if(queryObject->getType() != target)
+ {
+ return error(GL_INVALID_OPERATION);
+ }
+
+ // Set query as active for specified target
+ mState.activeQuery[qType].set(queryObject);
+
+ // Begin query
+ queryObject->begin();
+}
+
+void Context::endQuery(GLenum target)
+{
+ QueryType qType;
+
+ switch(target)
+ {
+ case GL_ANY_SAMPLES_PASSED_EXT:
+ qType = QUERY_ANY_SAMPLES_PASSED;
+ break;
+ case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
+ qType = QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE;
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ Query *queryObject = mState.activeQuery[qType].get();
+
+ if(queryObject == NULL)
+ {
+ return error(GL_INVALID_OPERATION);
+ }
+
+ queryObject->end();
+
+ mState.activeQuery[qType].set(NULL);
+}
+
void Context::setFramebufferZero(Framebuffer *buffer)
{
delete mFramebufferMap[0];
@@ -992,6 +1122,26 @@
}
}
+Query *Context::getQuery(unsigned int handle, bool create, GLenum type)
+{
+ QueryMap::iterator query = mQueryMap.find(handle);
+
+ if(query == mQueryMap.end())
+ {
+ return NULL;
+ }
+ else
+ {
+ if(!query->second && create)
+ {
+ query->second = new Query(handle, type);
+ query->second->addRef();
+ }
+
+ return query->second;
+ }
+}
+
Buffer *Context::getArrayBuffer()
{
return mState.arrayBuffer.get();
@@ -1167,9 +1317,11 @@
{
if(S3TC_SUPPORT)
{
- // at current, only GL_COMPRESSED_RGB_S3TC_DXT1_EXT and
- // GL_COMPRESSED_RGBA_S3TC_DXT1_EXT are supported
- *params = 2;
+ // GL_COMPRESSED_RGB_S3TC_DXT1_EXT
+ // GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
+ // GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE
+ // GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE
+ *params = 4;
}
else
{
@@ -1222,6 +1374,8 @@
{
params[0] = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
params[1] = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+ params[2] = GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE;
+ params[3] = GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE;
}
}
break;
@@ -1333,7 +1487,12 @@
// application.
switch (pname)
{
- case GL_COMPRESSED_TEXTURE_FORMATS: /* no compressed texture formats are supported */
+ case GL_COMPRESSED_TEXTURE_FORMATS:
+ {
+ *type = GL_INT;
+ *numParams = S3TC_SUPPORT ? 4 : 0;
+ }
+ break;
case GL_SHADER_BINARY_FORMATS:
{
*type = GL_INT;
@@ -1479,7 +1638,7 @@
}
// Applies the render target surface, depth stencil surface, viewport rectangle and scissor rectangle
-bool Context::applyRenderTarget(bool ignoreViewport)
+bool Context::applyRenderTarget()
{
Device *device = getDevice();
@@ -1494,16 +1653,14 @@
if(!renderTarget)
{
- return false; // Context must be lost
+ return false;
}
+ device->setRenderTarget(renderTarget);
+ renderTarget->release();
+
Image *depthStencil = NULL;
- device->setRenderTarget(renderTarget);
- mScissorStateDirty = true; // Scissor area must be clamped to render target's size - this is different for different render targets.
-
- unsigned int depthbufferSerial = 0;
- unsigned int stencilbufferSerial = 0;
if(framebufferObject->getDepthbufferType() != GL_NONE)
{
depthStencil = framebufferObject->getDepthbuffer()->getDepthStencil();
@@ -1512,8 +1669,6 @@
ERR("Depth stencil pointer unexpectedly null.");
return false;
}
-
- depthbufferSerial = framebufferObject->getDepthbuffer()->getSerial();
}
else if(framebufferObject->getStencilbufferType() != GL_NONE)
{
@@ -1523,93 +1678,44 @@
ERR("Depth stencil pointer unexpectedly null.");
return false;
}
-
- stencilbufferSerial = framebufferObject->getStencilbuffer()->getSerial();
}
- if(depthbufferSerial != mAppliedDepthbufferSerial ||
- stencilbufferSerial != mAppliedStencilbufferSerial ||
- !mDepthStencilInitialized)
- {
- device->setDepthStencilSurface(depthStencil);
- mAppliedDepthbufferSerial = depthbufferSerial;
- mAppliedStencilbufferSerial = stencilbufferSerial;
- mDepthStencilInitialized = true;
- }
+ device->setDepthStencilSurface(depthStencil);
Viewport viewport;
-
float zNear = clamp01(mState.zNear);
float zFar = clamp01(mState.zFar);
- if(ignoreViewport)
- {
- viewport.x = 0;
- viewport.y = 0;
- viewport.width = renderTarget->getWidth();
- viewport.height = renderTarget->getHeight();
- viewport.minZ = 0.0f;
- viewport.maxZ = 1.0f;
- }
- else
- {
- sw::Rect rect = transformPixelRect(mState.viewportX, mState.viewportY, mState.viewportWidth, mState.viewportHeight, renderTarget->getHeight());
- viewport.x = clamp(rect.left, 0L, static_cast<LONG>(renderTarget->getWidth()));
- viewport.y = clamp(rect.top, 0L, static_cast<LONG>(renderTarget->getHeight()));
- viewport.width = clamp(rect.right - rect.left, 0L, static_cast<LONG>(renderTarget->getWidth()) - static_cast<LONG>(viewport.x));
- viewport.height = clamp(rect.bottom - rect.top, 0L, static_cast<LONG>(renderTarget->getHeight()) - static_cast<LONG>(viewport.y));
- viewport.minZ = zNear;
- viewport.maxZ = zFar;
- }
-
- if(viewport.width <= 0 || viewport.height <= 0)
- {
- return false; // Nothing to render
- }
+ viewport.x0 = mState.viewportX;
+ viewport.y0 = mState.viewportY;
+ viewport.width = mState.viewportWidth;
+ viewport.height = mState.viewportHeight;
+ viewport.minZ = zNear;
+ viewport.maxZ = zFar;
device->setViewport(viewport);
- if(mScissorStateDirty)
+ if(mState.scissorTest)
{
- if(mState.scissorTest)
- {
- sw::Rect rect = transformPixelRect(mState.scissorX, mState.scissorY, mState.scissorWidth, mState.scissorHeight, renderTarget->getHeight());
- rect.left = clamp(rect.left, 0L, static_cast<LONG>(renderTarget->getWidth()));
- rect.top = clamp(rect.top, 0L, static_cast<LONG>(renderTarget->getHeight()));
- rect.right = clamp(rect.right, 0L, static_cast<LONG>(renderTarget->getWidth()));
- rect.bottom = clamp(rect.bottom, 0L, static_cast<LONG>(renderTarget->getHeight()));
- device->setScissorRect(rect);
- device->setScissorEnable(true);
- }
- else
- {
- device->setScissorEnable(false);
- }
-
- mScissorStateDirty = false;
+ sw::Rect scissor = {mState.scissorX, mState.scissorY, mState.scissorX + mState.scissorWidth, mState.scissorY + mState.scissorHeight};
+ scissor.clip(0, 0, renderTarget->getWidth(), renderTarget->getHeight());
+
+ device->setScissorRect(scissor);
+ device->setScissorEnable(true);
+ }
+ else
+ {
+ device->setScissorEnable(false);
}
- if(mState.currentProgram)
- {
- Program *programObject = getCurrentProgram();
+ Program *program = getCurrentProgram();
- GLint halfPixelSize = programObject->getDxHalfPixelSizeLocation();
- GLfloat xy[2] = {1.0f / viewport.width, -1.0f / viewport.height};
- programObject->setUniform2fv(halfPixelSize, 1, xy);
-
- GLint viewport = programObject->getDxViewportLocation();
- GLfloat whxy[4] = {mState.viewportWidth / 2.0f, mState.viewportHeight / 2.0f,
- (float)mState.viewportX + mState.viewportWidth / 2.0f,
- (float)mState.viewportY + mState.viewportHeight / 2.0f};
- programObject->setUniform4fv(viewport, 1, whxy);
-
- GLint depth = programObject->getDxDepthLocation();
- GLfloat dz[2] = {(zFar - zNear) / 2.0f, (zNear + zFar) / 2.0f};
- programObject->setUniform2fv(depth, 1, dz);
-
- GLint depthRange = programObject->getDxDepthRangeLocation();
- GLfloat nearFarDiff[3] = {zNear, zFar, zFar - zNear};
- programObject->setUniform3fv(depthRange, 1, nearFarDiff);
+ if(program)
+ {
+ GLfloat nearFarDiff[3] = {zNear, zFar, zFar - zNear};
+ program->setUniform1fv(program->getUniformLocation("gl_DepthRange.near"), 1, &nearFarDiff[0]);
+ program->setUniform1fv(program->getUniformLocation("gl_DepthRange.far"), 1, &nearFarDiff[1]);
+ program->setUniform1fv(program->getUniformLocation("gl_DepthRange.diff"), 1, &nearFarDiff[2]);
}
return true;
@@ -1623,28 +1729,13 @@
Framebuffer *framebufferObject = getDrawFramebuffer();
- GLenum adjustedFrontFace = adjustWinding(mState.frontFace);
-
- GLint frontCCW = programObject->getDxFrontCCWLocation();
- GLint ccw = (adjustedFrontFace == GL_CCW);
- programObject->setUniform1iv(frontCCW, 1, &ccw);
-
- GLint pointsOrLines = programObject->getDxPointsOrLinesLocation();
- GLint alwaysFront = !isTriangleMode(drawMode);
- programObject->setUniform1iv(pointsOrLines, 1, &alwaysFront);
-
- if(mCullStateDirty || mFrontFaceDirty)
+ if(mState.cullFace)
{
- if(mState.cullFace)
- {
- device->setCullMode(es2sw::ConvertCullMode(mState.cullMode, adjustedFrontFace));
- }
- else
- {
- device->setCullMode(sw::Context::CULL_NONE);
- }
-
- mCullStateDirty = false;
+ device->setCullMode(es2sw::ConvertCullMode(mState.cullMode, mState.frontFace));
+ }
+ else
+ {
+ device->setCullMode(sw::Context::CULL_NONE);
}
if(mDepthStateDirty)
@@ -1706,7 +1797,7 @@
DepthStencilbuffer *stencilbuffer = framebufferObject->getStencilbuffer();
GLuint maxStencil = (1 << stencilbuffer->getStencilSize()) - 1;
- if(adjustedFrontFace == GL_CCW)
+ if(mState.frontFace == GL_CCW)
{
device->setStencilWriteMask(mState.stencilWritemask);
device->setStencilCompare(es2sw::ConvertStencilComparison(mState.stencilFunc));
@@ -1854,8 +1945,8 @@
device->resetInputStreams(false);
for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
- {
- if(!attributes[i].active)
+ {
+ if(program->getAttributeStream(i) == -1)
{
continue;
}
@@ -1873,16 +1964,8 @@
attribute.count = attributes[i].count;
attribute.normalized = attributes[i].normalized;
- for(int stream = 0; stream < 16; stream++)
- {
- if(program->getVertexShader()->input[stream].usage == sw::ShaderOperation::USAGE_TEXCOORD &&
- program->getVertexShader()->input[stream].index == program->getSemanticIndex(i))
- {
- device->setInputStream(stream, attribute);
-
- break;
- }
- }
+ int stream = program->getAttributeStream(i);
+ device->setInputStream(stream, attribute);
}
return GL_NO_ERROR;
@@ -1908,7 +1991,7 @@
Device *device = getDevice();
Program *programObject = getCurrentProgram();
sw::VertexShader *vertexShader = programObject->getVertexShader();
- sw::PixelShader *pixelShader = programObject->getPixelShader();
+ sw::PixelShader *pixelShader = programObject->getPixelShader();
device->setVertexShader(vertexShader);
device->setPixelShader(pixelShader);
@@ -1922,16 +2005,12 @@
programObject->applyUniforms();
}
-// Applies the textures and sampler states
void Context::applyTextures()
{
applyTextures(sw::SAMPLER_PIXEL);
applyTextures(sw::SAMPLER_VERTEX);
}
-// For each Direct3D 9 sampler of either the pixel or vertex stage,
-// looks up the corresponding OpenGL texture image unit and texture type,
-// and sets the texture and its addressing/filtering state (or NULL when inactive).
void Context::applyTextures(sw::SamplerType samplerType)
{
Device *device = getDevice();
@@ -1949,7 +2028,7 @@
Texture *texture = getSamplerTexture(textureUnit, textureType);
- if(texture->isComplete())
+ if(texture->isSamplerComplete())
{
GLenum wrapS = texture->getWrapS();
GLenum wrapT = texture->getWrapT();
@@ -1995,7 +2074,7 @@
}
else if(type == sw::SAMPLER_VERTEX)
{
- textureUsed = program->getPixelShader()->usesSampler(index);
+ textureUsed = program->getVertexShader()->usesSampler(index);
}
else
{
@@ -2068,7 +2147,8 @@
}
}
-void Context::readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
+void Context::readPixels(GLint x, GLint y, GLsizei width, GLsizei height,
+ GLenum format, GLenum type, GLsizei *bufSize, void* pixels)
{
Framebuffer *framebuffer = getReadFramebuffer();
@@ -2082,75 +2162,45 @@
return error(GL_INVALID_OPERATION);
}
+ GLsizei outputPitch = ComputePitch(width, format, type, mState.packAlignment);
+
+ // Sized query sanity check
+ if(bufSize)
+ {
+ int requiredSize = outputPitch * height;
+ if(requiredSize > *bufSize)
+ {
+ return error(GL_INVALID_OPERATION);
+ }
+ }
+
Image *renderTarget = framebuffer->getRenderTarget();
if(!renderTarget)
{
- return; // Context must be lost, return silently
- }
-
- Device *device = getDevice();
-
- Image *systemSurface = device->createOffscreenPlainSurface(renderTarget->getWidth(), renderTarget->getHeight(), renderTarget->getInternalFormat());
-
- if(!systemSurface)
- {
return error(GL_OUT_OF_MEMORY);
}
- if(renderTarget->getMultiSampleDepth() > 1)
- {
- UNIMPLEMENTED(); // FIXME: Requires resolve using StretchRect into non-multisampled render target
- }
+ sw::Rect rect = {x, y, x + width, y + height};
+ rect.clip(0, 0, renderTarget->getWidth(), renderTarget->getHeight());
- bool success = device->getRenderTargetData(renderTarget, systemSurface);
-
- if(!success)
- {
- UNREACHABLE();
- systemSurface->release();
-
- return; // No sensible error to generate
- }
-
- sw::Rect rect = transformPixelRect(x, y, width, height, renderTarget->getHeight());
- rect.left = clamp(rect.left, 0L, static_cast<LONG>(renderTarget->getWidth()));
- rect.top = clamp(rect.top, 0L, static_cast<LONG>(renderTarget->getHeight()));
- rect.right = clamp(rect.right, 0L, static_cast<LONG>(renderTarget->getWidth()));
- rect.bottom = clamp(rect.bottom, 0L, static_cast<LONG>(renderTarget->getHeight()));
-
- void *buffer = systemSurface->lock(rect.left, rect.top, sw::LOCK_READONLY);
-
- if(!buffer)
- {
- UNREACHABLE();
- systemSurface->release();
-
- return; // No sensible error to generate
- }
-
- unsigned char *source = ((unsigned char*)buffer) + systemSurface->getPitch() * (rect.bottom - rect.top - 1);
+ unsigned char *source = (unsigned char*)renderTarget->lock(rect.x0, rect.y0, sw::LOCK_READONLY);
unsigned char *dest = (unsigned char*)pixels;
unsigned short *dest16 = (unsigned short*)pixels;
- int inputPitch = -(int)systemSurface->getPitch();
- GLsizei outputPitch = ComputePitch(width, format, type, mState.packAlignment);
+ int inputPitch = (int)renderTarget->getPitch();
- for(int j = 0; j < rect.bottom - rect.top; j++)
+ for(int j = 0; j < rect.y1 - rect.y0; j++)
{
if(renderTarget->getInternalFormat() == sw::FORMAT_A8R8G8B8 &&
- format == GL_BGRA_EXT &&
- type == GL_UNSIGNED_BYTE)
+ format == GL_BGRA_EXT && type == GL_UNSIGNED_BYTE)
{
- // Fast path for EXT_read_format_bgra, given
- // an RGBA source buffer. Note that buffers with no
- // alpha go through the slow path below.
- memcpy(dest + j * outputPitch,
- source + j * inputPitch,
- (rect.right - rect.left) * 4);
+ // Fast path for EXT_read_format_bgra, given an RGBA source buffer
+ // Note that buffers with no alpha go through the slow path below
+ memcpy(dest + j * outputPitch, source + j * inputPitch, (rect.x1 - rect.x0) * 4);
}
else
{
- for(int i = 0; i < rect.right - rect.left; i++)
+ for(int i = 0; i < rect.x1 - rect.x0; i++)
{
float r;
float g;
@@ -2230,10 +2280,10 @@
UNREACHABLE();
}
- switch (format)
+ switch(format)
{
case GL_RGBA:
- switch (type)
+ switch(type)
{
case GL_UNSIGNED_BYTE:
dest[4 * i + j * outputPitch + 0] = (unsigned char)(255 * r + 0.5f);
@@ -2245,7 +2295,7 @@
}
break;
case GL_BGRA_EXT:
- switch (type)
+ switch(type)
{
case GL_UNSIGNED_BYTE:
dest[4 * i + j * outputPitch + 0] = (unsigned char)(255 * b + 0.5f);
@@ -2285,7 +2335,7 @@
}
break;
case GL_RGB: // IMPLEMENTATION_COLOR_READ_FORMAT
- switch (type)
+ switch(type)
{
case GL_UNSIGNED_SHORT_5_6_5: // IMPLEMENTATION_COLOR_READ_TYPE
dest16[i + j * outputPitch / sizeof(unsigned short)] =
@@ -2302,9 +2352,8 @@
}
}
- systemSurface->unlock();
-
- systemSurface->release();
+ renderTarget->unlock();
+ renderTarget->release();
}
void Context::clear(GLbitfield mask)
@@ -2316,14 +2365,13 @@
return error(GL_INVALID_FRAMEBUFFER_OPERATION);
}
- egl::Display *display = getDisplay();
- Device *device = getDevice();
-
- if(!applyRenderTarget(true)) // Clips the clear to the scissor rectangle but not the viewport
+ if(!applyRenderTarget())
{
return;
}
+ Device *device = getDevice();
+
unsigned int color = (unorm<8>(mState.colorClearValue.alpha) << 24) |
(unorm<8>(mState.colorClearValue.red) << 16) |
(unorm<8>(mState.colorClearValue.green) << 8) |
@@ -2361,7 +2409,6 @@
return error(GL_INVALID_OPERATION);
}
- egl::Display *display = getDisplay();
Device *device = getDevice();
PrimitiveType primitiveType;
int primitiveCount;
@@ -2374,7 +2421,7 @@
return;
}
- if(!applyRenderTarget(false))
+ if(!applyRenderTarget())
{
return;
}
@@ -2413,7 +2460,6 @@
return error(GL_INVALID_OPERATION);
}
- egl::Display *display = getDisplay();
Device *device = getDevice();
PrimitiveType primitiveType;
int primitiveCount;
@@ -2426,7 +2472,7 @@
return;
}
- if(!applyRenderTarget(false))
+ if(!applyRenderTarget())
{
return;
}
@@ -2701,32 +2747,40 @@
void Context::initExtensionString()
{
- mExtensionString += "GL_OES_packed_depth_stencil ";
- mExtensionString += "GL_EXT_texture_format_BGRA8888 ";
- mExtensionString += "GL_EXT_read_format_bgra ";
- mExtensionString += "GL_ANGLE_framebuffer_blit ";
- mExtensionString += "GL_OES_rgb8_rgba8 ";
- mExtensionString += "GL_OES_standard_derivatives ";
- mExtensionString += "GL_NV_fence ";
+ // Keep list sorted in following order:
+ // OES extensions
+ // EXT extensions
+ // Vendor extensions
- if(S3TC_SUPPORT)
- {
- mExtensionString += "GL_EXT_texture_compression_dxt1 ";
- }
+ mExtensionString += "GL_OES_element_index_uint ";
+ mExtensionString += "GL_OES_packed_depth_stencil ";
+ mExtensionString += "GL_OES_rgb8_rgba8 ";
+ mExtensionString += "GL_OES_standard_derivatives ";
+ mExtensionString += "GL_OES_texture_float ";
+ mExtensionString += "GL_OES_texture_float_linear ";
+ mExtensionString += "GL_OES_texture_half_float ";
+ mExtensionString += "GL_OES_texture_half_float_linear ";
+ mExtensionString += "GL_OES_texture_npot ";
+ mExtensionString += "GL_EXT_occlusion_query_boolean ";
+ mExtensionString += "GL_EXT_read_format_bgra ";
+
+ if(S3TC_SUPPORT)
+ {
+ mExtensionString += "GL_EXT_texture_compression_dxt1 ";
+ mExtensionString += "GL_ANGLE_texture_compression_dxt3 ";
+ mExtensionString += "GL_ANGLE_texture_compression_dxt5 ";
+ }
- mExtensionString += "GL_OES_texture_float ";
- mExtensionString += "GL_OES_texture_half_float ";
- mExtensionString += "GL_OES_texture_float_linear ";
- mExtensionString += "GL_OES_texture_half_float_linear ";
- mExtensionString += "GL_ANGLE_framebuffer_multisample ";
- mExtensionString += "GL_OES_element_index_uint ";
- mExtensionString += "GL_OES_texture_npot ";
+ mExtensionString += "GL_EXT_texture_format_BGRA8888 ";
+ mExtensionString += "GL_ANGLE_framebuffer_blit ";
+ mExtensionString += "GL_ANGLE_framebuffer_multisample ";
+ mExtensionString += "GL_NV_fence ";
- std::string::size_type end = mExtensionString.find_last_not_of(' ');
- if(end != std::string::npos)
- {
- mExtensionString.resize(end+1);
- }
+ std::string::size_type end = mExtensionString.find_last_not_of(' ');
+ if(end != std::string::npos)
+ {
+ mExtensionString.resize(end + 1);
+ }
}
const char *Context::getExtensionString() const
@@ -2744,7 +2798,7 @@
Framebuffer *drawFramebuffer = getDrawFramebuffer();
if(!readFramebuffer || readFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE ||
- !drawFramebuffer || drawFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
+ !drawFramebuffer || drawFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
{
return error(GL_INVALID_FRAMEBUFFER_OPERATION);
}
@@ -2764,68 +2818,65 @@
if(srcX0 < srcX1)
{
- sourceRect.left = srcX0;
- sourceRect.right = srcX1;
- destRect.left = dstX0;
- destRect.right = dstX1;
+ sourceRect.x0 = srcX0;
+ sourceRect.x1 = srcX1;
+ destRect.x0 = dstX0;
+ destRect.x1 = dstX1;
}
else
{
- sourceRect.left = srcX1;
- destRect.left = dstX1;
- sourceRect.right = srcX0;
- destRect.right = dstX0;
+ sourceRect.x0 = srcX1;
+ destRect.x0 = dstX1;
+ sourceRect.x1 = srcX0;
+ destRect.x1 = dstX0;
}
if(srcY0 < srcY1)
{
- sourceRect.top = readBufferHeight - srcY1;
- destRect.top = drawBufferHeight - dstY1;
- sourceRect.bottom = readBufferHeight - srcY0;
- destRect.bottom = drawBufferHeight - dstY0;
+ sourceRect.y0 = srcY0;
+ destRect.y0 = dstY0;
+ sourceRect.y1 = srcY1;
+ destRect.y1 = dstY1;
}
else
{
- sourceRect.top = readBufferHeight - srcY0;
- destRect.top = drawBufferHeight - dstY0;
- sourceRect.bottom = readBufferHeight - srcY1;
- destRect.bottom = drawBufferHeight - dstY1;
+ sourceRect.y0 = srcY1;
+ destRect.y0 = dstY1;
+ sourceRect.y1 = srcY0;
+ destRect.y1 = dstY0;
}
sw::Rect sourceScissoredRect = sourceRect;
sw::Rect destScissoredRect = destRect;
- if(mState.scissorTest)
+ if(mState.scissorTest) // Only write to parts of the destination framebuffer which pass the scissor test
{
- // Only write to parts of the destination framebuffer which pass the scissor test
- // Please note: the destRect is now in Y-down coordinates, so the *top* of the
- // rect will be checked against scissorY, rather than the bottom.
- if(destRect.left < mState.scissorX)
+ if(destRect.x0 < mState.scissorX)
{
- int xDiff = mState.scissorX - destRect.left;
- destScissoredRect.left = mState.scissorX;
- sourceScissoredRect.left += xDiff;
+ int xDiff = mState.scissorX - destRect.x0;
+ destScissoredRect.x0 = mState.scissorX;
+ sourceScissoredRect.x0 += xDiff;
}
- if(destRect.right > mState.scissorX + mState.scissorWidth)
+ if(destRect.x1 > mState.scissorX + mState.scissorWidth)
{
- int xDiff = destRect.right - (mState.scissorX + mState.scissorWidth);
- destScissoredRect.right = mState.scissorX + mState.scissorWidth;
- sourceScissoredRect.right -= xDiff;
+ int xDiff = destRect.x1 - (mState.scissorX + mState.scissorWidth);
+ destScissoredRect.x1 = mState.scissorX + mState.scissorWidth;
+ sourceScissoredRect.x1 -= xDiff;
}
- if(destRect.top < mState.scissorY)
+ if(destRect.y0 < mState.scissorY)
{
- int yDiff = mState.scissorY - destRect.top;
- destScissoredRect.top = mState.scissorY;
- sourceScissoredRect.top += yDiff;
+ int yDiff = mState.scissorY - destRect.y0;
+ destScissoredRect.y0 = mState.scissorY;
+ sourceScissoredRect.y0 += yDiff;
}
- if(destRect.bottom > mState.scissorY + mState.scissorHeight)
+ if(destRect.y1 > mState.scissorY + mState.scissorHeight)
{
- int yDiff = destRect.bottom - (mState.scissorY + mState.scissorHeight);
- destScissoredRect.bottom = mState.scissorY + mState.scissorHeight;
- sourceScissoredRect.bottom -= yDiff;
+ int yDiff = destRect.y1 - (mState.scissorY + mState.scissorHeight);
+ destScissoredRect.y1 = mState.scissorY + mState.scissorHeight;
+ sourceScissoredRect.y1 -= yDiff;
}
}
@@ -2837,68 +2888,68 @@
// The source & destination rectangles also may need to be trimmed if they fall out of the bounds of
// the actual draw and read surfaces.
- if(sourceTrimmedRect.left < 0)
+ if(sourceTrimmedRect.x0 < 0)
{
- int xDiff = 0 - sourceTrimmedRect.left;
- sourceTrimmedRect.left = 0;
- destTrimmedRect.left += xDiff;
+ int xDiff = 0 - sourceTrimmedRect.x0;
+ sourceTrimmedRect.x0 = 0;
+ destTrimmedRect.x0 += xDiff;
}
- if(sourceTrimmedRect.right > readBufferWidth)
+ if(sourceTrimmedRect.x1 > readBufferWidth)
{
- int xDiff = sourceTrimmedRect.right - readBufferWidth;
- sourceTrimmedRect.right = readBufferWidth;
- destTrimmedRect.right -= xDiff;
+ int xDiff = sourceTrimmedRect.x1 - readBufferWidth;
+ sourceTrimmedRect.x1 = readBufferWidth;
+ destTrimmedRect.x1 -= xDiff;
}
- if(sourceTrimmedRect.top < 0)
+ if(sourceTrimmedRect.y0 < 0)
{
- int yDiff = 0 - sourceTrimmedRect.top;
- sourceTrimmedRect.top = 0;
- destTrimmedRect.top += yDiff;
+ int yDiff = 0 - sourceTrimmedRect.y0;
+ sourceTrimmedRect.y0 = 0;
+ destTrimmedRect.y0 += yDiff;
}
- if(sourceTrimmedRect.bottom > readBufferHeight)
+ if(sourceTrimmedRect.y1 > readBufferHeight)
{
- int yDiff = sourceTrimmedRect.bottom - readBufferHeight;
- sourceTrimmedRect.bottom = readBufferHeight;
- destTrimmedRect.bottom -= yDiff;
+ int yDiff = sourceTrimmedRect.y1 - readBufferHeight;
+ sourceTrimmedRect.y1 = readBufferHeight;
+ destTrimmedRect.y1 -= yDiff;
}
- if(destTrimmedRect.left < 0)
+ if(destTrimmedRect.x0 < 0)
{
- int xDiff = 0 - destTrimmedRect.left;
- destTrimmedRect.left = 0;
- sourceTrimmedRect.left += xDiff;
+ int xDiff = 0 - destTrimmedRect.x0;
+ destTrimmedRect.x0 = 0;
+ sourceTrimmedRect.x0 += xDiff;
}
- if(destTrimmedRect.right > drawBufferWidth)
+ if(destTrimmedRect.x1 > drawBufferWidth)
{
- int xDiff = destTrimmedRect.right - drawBufferWidth;
- destTrimmedRect.right = drawBufferWidth;
- sourceTrimmedRect.right -= xDiff;
+ int xDiff = destTrimmedRect.x1 - drawBufferWidth;
+ destTrimmedRect.x1 = drawBufferWidth;
+ sourceTrimmedRect.x1 -= xDiff;
}
- if(destTrimmedRect.top < 0)
+ if(destTrimmedRect.y0 < 0)
{
- int yDiff = 0 - destTrimmedRect.top;
- destTrimmedRect.top = 0;
- sourceTrimmedRect.top += yDiff;
+ int yDiff = 0 - destTrimmedRect.y0;
+ destTrimmedRect.y0 = 0;
+ sourceTrimmedRect.y0 += yDiff;
}
- if(destTrimmedRect.bottom > drawBufferHeight)
+ if(destTrimmedRect.y1 > drawBufferHeight)
{
- int yDiff = destTrimmedRect.bottom - drawBufferHeight;
- destTrimmedRect.bottom = drawBufferHeight;
- sourceTrimmedRect.bottom -= yDiff;
+ int yDiff = destTrimmedRect.y1 - drawBufferHeight;
+ destTrimmedRect.y1 = drawBufferHeight;
+ sourceTrimmedRect.y1 -= yDiff;
}
bool partialBufferCopy = false;
- if(sourceTrimmedRect.bottom - sourceTrimmedRect.top < readBufferHeight ||
- sourceTrimmedRect.right - sourceTrimmedRect.left < readBufferWidth ||
- destTrimmedRect.bottom - destTrimmedRect.top < drawBufferHeight ||
- destTrimmedRect.right - destTrimmedRect.left < drawBufferWidth ||
- sourceTrimmedRect.top != 0 || destTrimmedRect.top != 0 || sourceTrimmedRect.left != 0 || destTrimmedRect.left != 0)
+ if(sourceTrimmedRect.y1 - sourceTrimmedRect.y0 < readBufferHeight ||
+ sourceTrimmedRect.x1 - sourceTrimmedRect.x0 < readBufferWidth ||
+ destTrimmedRect.y1 - destTrimmedRect.y0 < drawBufferHeight ||
+ destTrimmedRect.x1 - destTrimmedRect.x0 < drawBufferWidth ||
+ sourceTrimmedRect.y0 != 0 || destTrimmedRect.y0 != 0 || sourceTrimmedRect.x0 != 0 || destTrimmedRect.x0 != 0)
{
partialBufferCopy = true;
}
@@ -2922,7 +2973,6 @@
}
blitRenderTarget = true;
-
}
if(mask & (GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT))
@@ -2968,7 +3018,7 @@
if(partialBufferCopy)
{
ERR("Only whole-buffer depth and stencil blits are supported by this implementation.");
- return error(GL_INVALID_OPERATION); // only whole-buffer copies are permitted
+ return error(GL_INVALID_OPERATION); // Only whole-buffer copies are permitted
}
if((drawDSBuffer && drawDSBuffer->getSamples() != 0) ||
@@ -2984,8 +3034,13 @@
if(blitRenderTarget)
{
- bool success = device->stretchRect(readFramebuffer->getRenderTarget(), &sourceTrimmedRect,
- drawFramebuffer->getRenderTarget(), &destTrimmedRect, false);
+ Image *readRenderTarget = readFramebuffer->getRenderTarget();
+ Image *drawRenderTarget = drawFramebuffer->getRenderTarget();
+
+ bool success = device->stretchRect(readRenderTarget, &sourceRect, drawRenderTarget, &destRect, false);
+
+ readRenderTarget->release();
+ drawRenderTarget->release();
if(!success)
{
diff --git a/src/OpenGL ES 2.0/libGLESv2/Context.h b/src/OpenGL ES 2.0/libGLESv2/Context.h
index 4b533bd..0086ba7 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Context.h
+++ b/src/OpenGL ES 2.0/libGLESv2/Context.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2011 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.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Context.h: Defines the Context class, managing all GL state and performing
@@ -13,8 +18,8 @@
#include "ResourceManager.h"
#include "HandleAllocator.h"
#include "RefCountObject.h"
-#include "common/angleutils.h"
#include "Image.hpp"
+#include "common/angleutils.h"
#include "Renderer/Sampler.hpp"
#define GL_APICALL
@@ -55,26 +60,36 @@
class VertexDataManager;
class IndexDataManager;
class Fence;
+class Query;
enum
{
MAX_VERTEX_ATTRIBS = 16,
- MAX_VERTEX_UNIFORM_VECTORS = 256 - 2, // 256 is the minimum for SM2, and in practice the maximum for DX9. Reserve space for dx_HalfPixelSize and dx_DepthRange.
+ 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 = 16,
- MAX_VERTEX_TEXTURE_IMAGE_UNITS = 4, // For devices supporting vertex texture fetch
+ 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 dx_Viewport, dx_Depth, and dx_DepthRange. dx_PointOrLines and dx_FrontCCW use separate bool registers.
+ MAX_FRAGMENT_UNIFORM_VECTORS = 224 - 3, // Reserve space for gl_DepthRange
MAX_DRAW_BUFFERS = 1,
IMPLEMENTATION_COLOR_READ_FORMAT = GL_RGB,
IMPLEMENTATION_COLOR_READ_TYPE = GL_UNSIGNED_SHORT_5_6_5
};
+enum QueryType
+{
+ QUERY_ANY_SAMPLES_PASSED,
+ QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE,
+
+ QUERY_TYPE_COUNT
+};
+
const float ALIASED_LINE_WIDTH_RANGE_MIN = 1.0f;
const float ALIASED_LINE_WIDTH_RANGE_MAX = 1.0f;
-const float ALIASED_POINT_SIZE_RANGE_MIN = 1.0f;
-const float ALIASED_POINT_SIZE_RANGE_MAX = 64.0f;
+const float ALIASED_POINT_SIZE_RANGE_MIN = 0.125f;
+const float ALIASED_POINT_SIZE_RANGE_MAX = 8192.0f;
struct Color
{
@@ -213,6 +228,7 @@
VertexAttribute vertexAttribute[MAX_VERTEX_ATTRIBS];
BindingPointer<Texture> samplerTexture[TEXTURE_TYPE_COUNT][MAX_COMBINED_TEXTURE_IMAGE_UNITS];
+ BindingPointer<Query> activeQuery[QUERY_TYPE_COUNT];
GLint unpackAlignment;
GLint packAlignment;
@@ -292,6 +308,8 @@
GLuint getDrawFramebufferHandle() const;
GLuint getRenderbufferHandle() const;
+ GLuint getActiveQuery(GLenum target) const;
+
GLuint getArrayBufferHandle() const;
void setEnableVertexAttribArray(unsigned int attribNum, bool enabled);
@@ -326,10 +344,14 @@
GLuint createFramebuffer();
void deleteFramebuffer(GLuint framebuffer);
- // Fences are owned by the Context.
+ // Fences are owned by the Context
GLuint createFence();
void deleteFence(GLuint fence);
+ // Queries are owned by the Context
+ GLuint createQuery();
+ void deleteQuery(GLuint query);
+
void bindArrayBuffer(GLuint buffer);
void bindElementArrayBuffer(GLuint buffer);
void bindTexture2D(GLuint texture);
@@ -339,6 +361,9 @@
void bindRenderbuffer(GLuint renderbuffer);
void useProgram(GLuint program);
+ void beginQuery(GLenum target, GLuint query);
+ void endQuery(GLenum target);
+
void setFramebufferZero(Framebuffer *framebuffer);
void setRenderbufferStorage(RenderbufferStorage *renderbuffer);
@@ -352,6 +377,7 @@
Texture *getTexture(GLuint handle);
Framebuffer *getFramebuffer(GLuint handle);
Renderbuffer *getRenderbuffer(GLuint handle);
+ Query *getQuery(GLuint handle, bool create, GLenum type);
Buffer *getArrayBuffer();
Buffer *getElementArrayBuffer();
@@ -368,7 +394,7 @@
bool getQueryParameterInfo(GLenum pname, GLenum *type, unsigned int *numParams);
- void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels);
+ void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei *bufSize, void* pixels);
void clear(GLbitfield mask);
void drawArrays(GLenum mode, GLint first, GLsizei count);
void drawElements(GLenum mode, GLsizei count, GLenum type, const void *indices);
@@ -393,7 +419,7 @@
private:
DISALLOW_COPY_AND_ASSIGN(Context);
- bool applyRenderTarget(bool ignoreViewport);
+ bool applyRenderTarget();
void applyState(GLenum drawMode);
GLenum applyVertexBuffer(GLint base, GLint first, GLsizei count);
GLenum applyIndexBuffer(const void *indices, GLsizei count, GLenum mode, GLenum type, TranslatedIndexData *indexInfo);
@@ -425,6 +451,10 @@
FenceMap mFenceMap;
HandleAllocator mFenceHandleAllocator;
+ typedef stdext::hash_map<GLuint, Query*> QueryMap;
+ QueryMap mQueryMap;
+ HandleAllocator mQueryHandleAllocator;
+
void initExtensionString();
std::string mExtensionString;
@@ -441,23 +471,16 @@
bool mHasBeenCurrent;
unsigned int mAppliedProgramSerial;
- unsigned int mAppliedRenderTargetSerial;
- unsigned int mAppliedDepthbufferSerial;
- unsigned int mAppliedStencilbufferSerial;
- bool mDepthStencilInitialized;
std::map<sw::Format, bool*> mMultiSampleSupport;
// state caching flags
- bool mClearStateDirty;
- bool mCullStateDirty;
bool mDepthStateDirty;
bool mMaskStateDirty;
bool mPixelPackingStateDirty;
bool mBlendStateDirty;
bool mStencilStateDirty;
bool mPolygonOffsetStateDirty;
- bool mScissorStateDirty;
bool mSampleStateDirty;
bool mFrontFaceDirty;
bool mDitherStateDirty;
diff --git a/src/OpenGL ES 2.0/libGLESv2/Device.cpp b/src/OpenGL ES 2.0/libGLESv2/Device.cpp
index 68e293f..359588f 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Device.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Device.cpp
@@ -1,6 +1,6 @@
// SwiftShader Software Renderer
//
-// Copyright(c) 2005-2011 TransGaming Inc.
+// Copyright(c) 2005-2012 TransGaming Inc.
//
// All rights reserved. No part of this software may be copied, distributed, transmitted,
// transcribed, stored in a retrieval system, translated into any human or computer
@@ -25,13 +25,13 @@
#include "Common/Timer.hpp"
#include "../common/debug.h"
-bool localShaderConstants = true;
+bool localShaderConstants = false;
namespace gl
{
using namespace sw;
- Device::Device(Context *context) : Renderer(context), context(context)
+ Device::Device(Context *context) : Renderer(context, true, true, true, true, true), context(context)
{
depthStencil = 0;
renderTarget = 0;
@@ -67,9 +67,9 @@
setVertexFogMode(Context::FOG_NONE);
setClipFlags(0);
setPointSize(1.0f);
- setPointSizeMin(1.0f);
+ setPointSizeMin(0.125f);
setPointSpriteEnable(false);
- setPointSizeMax(64.0f);
+ setPointSizeMax(8192.0f);
setColorWriteMask(0, 0x0000000F);
setBlendOperation(Context::BLENDOP_ADD);
scissorEnable = false;
@@ -163,75 +163,73 @@
{
TRACE("unsigned long color = 0x%0.8X", color);
- int x = viewport.x;
- int y = viewport.y;
- int width = viewport.width;
- int height = viewport.height;
+ int x0 = 0;
+ int y0 = 0;
+ int width = renderTarget->getExternalWidth();
+ int height = renderTarget->getExternalHeight();
- // Clamp against scissor rectangle
- if(scissorEnable)
+ if(scissorEnable) // Clamp against scissor rectangle
{
- if(x < scissorRect.left) x = scissorRect.left;
- if(y < scissorRect.top) y = scissorRect.top;
- if(width > scissorRect.right - scissorRect.left) width = scissorRect.right - scissorRect.left;
- if(height > scissorRect.bottom - scissorRect.top) height = scissorRect.bottom - scissorRect.top;
+ if(x0 < scissorRect.x0) x0 = scissorRect.x0;
+ if(y0 < scissorRect.y0) y0 = scissorRect.y0;
+ if(width > scissorRect.x1 - scissorRect.x0) width = scissorRect.x1 - scissorRect.x0;
+ if(height > scissorRect.y1 - scissorRect.y0) height = scissorRect.y1 - scissorRect.y0;
}
- if(renderTarget)
- {
- renderTarget->clearColorBuffer(color, rgbaMask, x, y, width, height);
- }
+ renderTarget->clearColorBuffer(color, rgbaMask, x0, y0, width, height);
}
void Device::clearDepth(float z)
{
TRACE("float z = %f", z);
+ if(!depthStencil)
+ {
+ return;
+ }
+
if(z > 1) z = 1;
if(z < 0) z = 0;
- int x = viewport.x;
- int y = viewport.y;
- int width = viewport.width;
- int height = viewport.height;
+ int x0 = 0;
+ int y0 = 0;
+ int width = depthStencil->getExternalWidth();
+ int height = depthStencil->getExternalHeight();
- // Clamp against scissor rectangle
- if(scissorEnable)
+ if(scissorEnable) // Clamp against scissor rectangle
{
- if(x < scissorRect.left) x = scissorRect.left;
- if(y < scissorRect.top) y = scissorRect.top;
- if(width > scissorRect.right - scissorRect.left) width = scissorRect.right - scissorRect.left;
- if(height > scissorRect.bottom - scissorRect.top) height = scissorRect.bottom - scissorRect.top;
+ if(x0 < scissorRect.x0) x0 = scissorRect.x0;
+ if(y0 < scissorRect.y0) y0 = scissorRect.y0;
+ if(width > scissorRect.x1 - scissorRect.x0) width = scissorRect.x1 - scissorRect.x0;
+ if(height > scissorRect.y1 - scissorRect.y0) height = scissorRect.y1 - scissorRect.y0;
}
-
- if(depthStencil)
- {
- depthStencil->clearDepthBuffer(z, x, y, width, height);
- }
+
+ depthStencil->clearDepthBuffer(z, x0, y0, width, height);
}
void Device::clearStencil(unsigned int stencil, unsigned int mask)
{
TRACE("unsigned long stencil = %d", stencil);
- int x = viewport.x;
- int y = viewport.y;
- int width = viewport.width;
- int height = viewport.height;
-
- // Clamp against scissor rectangle
- if(scissorEnable)
+ if(!depthStencil)
{
- if(x < scissorRect.left) x = scissorRect.left;
- if(y < scissorRect.top) y = scissorRect.top;
- if(width > scissorRect.right - scissorRect.left) width = scissorRect.right - scissorRect.left;
- if(height > scissorRect.bottom - scissorRect.top) height = scissorRect.bottom - scissorRect.top;
+ return;
}
- if(depthStencil)
+ int x0 = 0;
+ int y0 = 0;
+ int width = renderTarget->getExternalWidth();
+ int height = renderTarget->getExternalHeight();
+
+ if(scissorEnable) // Clamp against scissor rectangle
{
- depthStencil->clearStencilBuffer(stencil, mask, x, y, width, height);
+ if(x0 < scissorRect.x0) x0 = scissorRect.x0;
+ if(y0 < scissorRect.y0) y0 = scissorRect.y0;
+ if(width > scissorRect.x1 - scissorRect.x0) width = scissorRect.x1 - scissorRect.x0;
+ if(height > scissorRect.y1 - scissorRect.y0) height = scissorRect.y1 - scissorRect.y0;
}
+
+ depthStencil->clearStencilBuffer(stencil, mask, x0, y0, width, height);
}
Image *Device::createDepthStencilSurface(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard)
@@ -420,57 +418,6 @@
return depthStencil;
}
- bool Device::getRenderTargetData(Image *renderTarget, Image *destSurface)
- {
- TRACE("Image *renderTarget = 0x%0.8p, Image *destSurface = 0x%0.8p", renderTarget, destSurface);
-
- if(!renderTarget || !destSurface)
- {
- ERR("Invalid parameters");
- return false;
- }
-
- if(renderTarget->getWidth() != destSurface->getWidth() ||
- renderTarget->getHeight() != destSurface->getHeight() ||
- renderTarget->getInternalFormat() != destSurface->getInternalFormat())
- {
- ERR("Invalid parameters");
- return false;
- }
-
- static void (__cdecl *blitFunction)(void *dst, void *src);
- static Routine *blitRoutine;
- static BlitState blitState = {0};
-
- BlitState update;
- update.width = renderTarget->getInternalWidth();
- update.height = renderTarget->getInternalHeight();
- update.depth = 32;
- update.stride = destSurface->getInternalPitchB();
- update.HDR = false;
- update.cursorHeight = 0;
- update.cursorWidth = 0;
-
- if(memcmp(&blitState, &update, sizeof(BlitState)) != 0)
- {
- blitState = update;
- delete blitRoutine;
-
- blitRoutine = FrameBuffer::copyRoutine(blitState);
- blitFunction = (void(__cdecl*)(void*, void*))blitRoutine->getEntry();
- }
-
- void *dst = destSurface->lockInternal(0, 0, 0, LOCK_WRITEONLY, PUBLIC);
- void *src = renderTarget->lockInternal(0, 0, 0, LOCK_WRITEONLY, PUBLIC);
-
- blitFunction(dst, src);
-
- destSurface->unlockInternal();
- renderTarget->unlockInternal();
-
- return true;
- }
-
void Device::setDepthStencilSurface(Image *depthStencil)
{
TRACE("Image *newDepthStencil = 0x%0.8p", depthStencil);
@@ -542,23 +489,6 @@
this->renderTarget = renderTarget;
- if(renderTarget)
- {
- // Reset viewport to size of current render target
- viewport.x = 0;
- viewport.y = 0;
- viewport.width = renderTarget->getWidth();
- viewport.height = renderTarget->getHeight();
- viewport.minZ = 0;
- viewport.maxZ = 1;
-
- // Reset scissor rectangle to size of current render target
- scissorRect.left = 0;
- scissorRect.top = 0;
- scissorRect.right = renderTarget->getWidth();
- scissorRect.bottom = renderTarget->getHeight();
- }
-
Renderer::setRenderTarget(0, renderTarget);
}
@@ -627,10 +557,10 @@
}
else
{
- sRect.top = 0;
- sRect.left = 0;
- sRect.bottom = sHeight;
- sRect.right = sWidth;
+ sRect.y0 = 0;
+ sRect.x0 = 0;
+ sRect.y1 = sHeight;
+ sRect.x1 = sWidth;
}
if(destRect)
@@ -639,13 +569,13 @@
}
else
{
- dRect.top = 0;
- dRect.left = 0;
- dRect.bottom = dHeight;
- dRect.right = dWidth;
+ dRect.y0 = 0;
+ dRect.x0 = 0;
+ dRect.y1 = dHeight;
+ dRect.x1 = dWidth;
}
- bool scaling = (sRect.right - sRect.left != dRect.right - dRect.left) || (sRect.bottom - sRect.top != dRect.bottom - dRect.top);
+ bool scaling = (sRect.x1 - sRect.x0 != dRect.x1 - dRect.x0) || (sRect.y1 - sRect.y0 != dRect.y1 - dRect.y0);
bool equalFormats = source->getInternalFormat() == dest->getInternalFormat();
bool depthStencil = Image::isDepth(source->getInternalFormat()) || Image::isStencil(source->getInternalFormat());
bool alpha0xFF = false;
@@ -703,13 +633,13 @@
}
else if(!scaling && equalFormats)
{
- unsigned char *sourceBytes = (unsigned char*)source->lockInternal(sRect.left, sRect.top, 0, LOCK_READONLY, PUBLIC);
- unsigned char *destBytes = (unsigned char*)dest->lockInternal(dRect.left, dRect.top, 0, LOCK_READWRITE, PUBLIC);
+ unsigned char *sourceBytes = (unsigned char*)source->lockInternal(sRect.x0, sRect.y0, 0, LOCK_READONLY, PUBLIC);
+ unsigned char *destBytes = (unsigned char*)dest->lockInternal(dRect.x0, dRect.y0, 0, LOCK_READWRITE, PUBLIC);
unsigned int sourcePitch = source->getInternalPitchB();
unsigned int destPitch = dest->getInternalPitchB();
- unsigned int width = dRect.right - dRect.left;
- unsigned int height = dRect.bottom - dRect.top;
+ unsigned int width = dRect.x1 - dRect.x0;
+ unsigned int height = dRect.y1 - dRect.y0;
unsigned int bytes = width * Image::bytes(source->getInternalFormat());
for(unsigned int y = 0; y < height; y++)
@@ -754,32 +684,32 @@
if(sourceRect)
{
- sRect.left = sourceRect->left;
- sRect.top = sourceRect->top;
- sRect.right = sourceRect->right;
- sRect.bottom = sourceRect->bottom;
+ sRect.x0 = sourceRect->x0;
+ sRect.y0 = sourceRect->y0;
+ sRect.x1 = sourceRect->x1;
+ sRect.y1 = sourceRect->y1;
}
else
{
- sRect.left = 0;
- sRect.top = 0;
- sRect.right = sourceSurface->getWidth();
- sRect.bottom = sourceSurface->getHeight();
+ sRect.x0 = 0;
+ sRect.y0 = 0;
+ sRect.x1 = sourceSurface->getWidth();
+ sRect.y1 = sourceSurface->getHeight();
}
if(destPoint)
{
- dRect.left = destPoint->x;
- dRect.top = destPoint->y;
- dRect.right = destPoint->x + sRect.right - sRect.left;
- dRect.bottom = destPoint->y + sRect.bottom - sRect.top;
+ dRect.x0 = destPoint->x;
+ dRect.y0 = destPoint->y;
+ dRect.x1 = destPoint->x + sRect.x1 - sRect.x0;
+ dRect.y1 = destPoint->y + sRect.y1 - sRect.y0;
}
else
{
- dRect.left = 0;
- dRect.top = 0;
- dRect.right = sRect.right - sRect.left;
- dRect.bottom = sRect.bottom - sRect.top;
+ dRect.x0 = 0;
+ dRect.y0 = 0;
+ dRect.x1 = sRect.x1 - sRect.x0;
+ dRect.y1 = sRect.y1 - sRect.y0;
}
if(!validRectangle(&sRect, sourceSurface) || !validRectangle(&dRect, destinationSurface))
@@ -788,11 +718,11 @@
return false;
}
- int sWidth = sRect.right - sRect.left;
- int sHeight = sRect.bottom - sRect.top;
+ int sWidth = sRect.x1 - sRect.x0;
+ int sHeight = sRect.y1 - sRect.y0;
- int dWidth = dRect.right - dRect.left;
- int dHeight = dRect.bottom - dRect.top;
+ int dWidth = dRect.x1 - dRect.x0;
+ int dHeight = dRect.y1 - dRect.y0;
if(sourceSurface->getMultiSampleDepth() > 1 ||
destinationSurface->getMultiSampleDepth() > 1 ||
@@ -802,8 +732,8 @@
return false;
}
- unsigned char *sourceBuffer = (unsigned char*)sourceSurface->lock(sRect.left, sRect.top, LOCK_READONLY);
- unsigned char *destinationBuffer = (unsigned char*)destinationSurface->lock(dRect.left, dRect.top, LOCK_WRITEONLY);
+ unsigned char *sourceBuffer = (unsigned char*)sourceSurface->lock(sRect.x0, sRect.y0, LOCK_READONLY);
+ unsigned char *destinationBuffer = (unsigned char*)destinationSurface->lock(dRect.x0, dRect.y0, LOCK_WRITEONLY);
unsigned int width;
unsigned int height;
@@ -924,70 +854,40 @@
if(scissorEnable)
{
- Rect scissor = scissorRect;
-
- long viewportLeft = viewport.x;
- long viewportRight = viewport.x + viewport.width;
- long viewportTop = viewport.y;
- long viewportBottom = viewport.y + viewport.height;
-
- // Intersection of scissor rectangle and viewport
- if(viewportLeft > scissor.left) scissor.left = viewportLeft;
- if(viewportTop > scissor.top) scissor.top = viewportTop;
- if(viewportRight < scissor.right) scissor.right = viewportRight;
- if(viewportBottom < scissor.bottom) scissor.bottom = viewportBottom;
-
- if(scissor.left == scissor.right ||
- scissor.top == scissor.bottom)
+ if(scissorRect.x0 >= scissorRect.x1 || scissorRect.y0 >= scissorRect.y1)
{
return false;
}
- // Dimensions of scissor rectangle relative to viewport
- float relativeLeft = (float)(scissor.left - viewportLeft) / viewport.width;
- float relativeRight = (float)(scissor.right - viewportLeft) / viewport.width;
- float relativeTop = (float)(scissor.top - viewportTop) / viewport.height;
- float relativeBottom = (float)(scissor.bottom - viewportTop) / viewport.height;
-
- // Transformation of clip space coordinates
- float sX = 1.0f / (relativeRight - relativeLeft); // Scale
- float tX = sX * ((0.5f - relativeLeft) - (relativeRight - 0.5f)); // Translate
- float sY = 1.0f / (relativeBottom - relativeTop); // Scale
- float tY = sY * ((0.5f - relativeTop) - (relativeBottom - 0.5f)); // Translate
-
- // Set the new viewport
- sw::Viewport view;
-
- view.setLeft((float)scissor.left);
- view.setTop((float)scissor.top);
- view.setWidth((float)(scissor.right - scissor.left));
- view.setHeight((float)(scissor.bottom - scissor.top));
-
- view.setNear(viewport.minZ);
- view.setFar(viewport.maxZ);
-
- Renderer::setViewport(view);
- setPostTransformEnable(true);
- setPosScale(sX, sY);
- setPosOffset(tX, -tY);
+ sw::Rect scissor;
+ scissor.x0 = scissorRect.x0;
+ scissor.x1 = scissorRect.x1;
+ scissor.y0 = scissorRect.y0;
+ scissor.y1 = scissorRect.y1;
+
+ setScissor(scissor);
}
else
{
- // Set viewport
- sw::Viewport view;
-
- view.setLeft((float)viewport.x);
- view.setTop((float)viewport.y);
- view.setWidth((float)viewport.width);
- view.setHeight((float)viewport.height);
-
- view.setNear(viewport.minZ);
- view.setFar(viewport.maxZ);
-
- Renderer::setViewport(view);
- setPostTransformEnable(false);
+ sw::Rect scissor;
+ scissor.x0 = max(viewport.x0, 0);
+ scissor.x1 = min(viewport.x0 + viewport.width, renderTarget->getExternalWidth());
+ scissor.y0 = max(viewport.y0, 0);
+ scissor.y1 = min(viewport.y0 + viewport.height, renderTarget->getExternalHeight());
+
+ setScissor(scissor);
}
+ sw::Viewport view;
+ view.x0 = (float)viewport.x0;
+ view.y0 = (float)viewport.y0;
+ view.width = (float)viewport.width;
+ view.height = (float)viewport.height;
+ view.minZ = viewport.minZ;
+ view.maxZ = viewport.maxZ;
+
+ Renderer::setViewport(view);
+
return true;
}
@@ -998,17 +898,17 @@
return true;
}
- if(rect->right <= rect->left || rect->bottom <= rect->top)
+ if(rect->x1 <= rect->x0 || rect->y1 <= rect->y0)
{
return false;
}
- if(rect->left < 0 || rect->top < 0)
+ if(rect->x0 < 0 || rect->y0 < 0)
{
return false;
}
- if(rect->right > (int)surface->getWidth() || rect->bottom > (int)surface->getHeight())
+ if(rect->x1 > (int)surface->getWidth() || rect->y1 > (int)surface->getHeight())
{
return false;
}
@@ -1018,11 +918,7 @@
void Device::finish()
{
- if(renderTarget)
- {
- renderTarget->lock(0, 0, sw::LOCK_READWRITE);
- renderTarget->unlock();
- }
+ synchronize();
}
}
diff --git a/src/OpenGL ES 2.0/libGLESv2/Device.hpp b/src/OpenGL ES 2.0/libGLESv2/Device.hpp
index ae39446..167fb1b 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Device.hpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Device.hpp
@@ -1,6 +1,6 @@
// SwiftShader Software Renderer
//
-// Copyright(c) 2005-2011 TransGaming Inc.
+// Copyright(c) 2005-2012 TransGaming Inc.
//
// All rights reserved. No part of this software may be copied, distributed, transmitted,
// transcribed, stored in a retrieval system, translated into any human or computer
@@ -37,8 +37,8 @@
struct Viewport
{
- unsigned int x;
- unsigned int y;
+ int x0;
+ int y0;
unsigned int width;
unsigned int height;
float minZ;
@@ -61,7 +61,6 @@
virtual void drawIndexedPrimitive(PrimitiveType type, unsigned int indexOffset, unsigned int primitiveCount, int indexSize);
virtual void drawPrimitive(PrimitiveType primitiveType, unsigned int primiveCount);
virtual Image *getDepthStencilSurface();
- virtual bool getRenderTargetData(Image *renderTarget, Image *destSurface);
virtual void setDepthStencilSurface(Image *newDepthStencil);
virtual void setPixelShader(sw::PixelShader *shader);
virtual void setPixelShaderConstantF(unsigned int startRegister, const float *constantData, unsigned int count);
diff --git a/src/OpenGL ES 2.0/libGLESv2/Fence.cpp b/src/OpenGL ES 2.0/libGLESv2/Fence.cpp
index 688940b..4b0c6ac 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Fence.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Fence.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Fence.cpp: Implements the Fence class, which supports the GL_NV_fence extension.
diff --git a/src/OpenGL ES 2.0/libGLESv2/Fence.h b/src/OpenGL ES 2.0/libGLESv2/Fence.h
index c7c0d3d..5f68353 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Fence.h
+++ b/src/OpenGL ES 2.0/libGLESv2/Fence.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Fence.h: Defines the Fence class, which supports the GL_NV_fence extension.
diff --git a/src/OpenGL ES 2.0/libGLESv2/Framebuffer.cpp b/src/OpenGL ES 2.0/libGLESv2/Framebuffer.cpp
index e7ee0fe..dba29ee 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Framebuffer.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Framebuffer.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Framebuffer.cpp: Implements the Framebuffer class. Implements GL framebuffer
@@ -116,18 +121,6 @@
}
}
-unsigned int Framebuffer::getRenderTargetSerial()
-{
- Renderbuffer *colorbuffer = mColorbufferPointer.get();
-
- if(colorbuffer)
- {
- return colorbuffer->getSerial();
- }
-
- return 0;
-}
-
Image *Framebuffer::getRenderTarget()
{
Renderbuffer *colorbuffer = mColorbufferPointer.get();
@@ -157,70 +150,40 @@
return NULL;
}
-unsigned int Framebuffer::getDepthbufferSerial()
-{
- Renderbuffer *depthbuffer = mDepthbufferPointer.get();
-
- if(depthbuffer)
- {
- return depthbuffer->getSerial();
- }
-
- return 0;
-}
-
-unsigned int Framebuffer::getStencilbufferSerial()
-{
- Renderbuffer *stencilbuffer = mStencilbufferPointer.get();
-
- if(stencilbuffer)
- {
- return stencilbuffer->getSerial();
- }
-
- return 0;
-}
-
Colorbuffer *Framebuffer::getColorbuffer()
{
- Renderbuffer *rb = mColorbufferPointer.get();
+ Renderbuffer *renderbuffer = mColorbufferPointer.get();
- if(rb != NULL && rb->isColorbuffer())
+ if (renderbuffer)
{
- return static_cast<Colorbuffer*>(rb->getStorage());
+ return renderbuffer->getColorbuffer();
}
- else
- {
- return NULL;
- }
+
+ return NULL;
}
DepthStencilbuffer *Framebuffer::getDepthbuffer()
{
- Renderbuffer *rb = mDepthbufferPointer.get();
+ Renderbuffer *renderbuffer = mDepthbufferPointer.get();
- if(rb != NULL && rb->isDepthbuffer())
+ if (renderbuffer)
{
- return static_cast<DepthStencilbuffer*>(rb->getStorage());
+ return renderbuffer->getDepthbuffer();
}
- else
- {
- return NULL;
- }
+
+ return NULL;
}
DepthStencilbuffer *Framebuffer::getStencilbuffer()
{
- Renderbuffer *rb = mStencilbufferPointer.get();
+ Renderbuffer *renderbuffer = mStencilbufferPointer.get();
- if(rb != NULL && rb->isStencilbuffer())
+ if (renderbuffer)
{
- return static_cast<DepthStencilbuffer*>(rb->getStorage());
+ return renderbuffer->getStencilbuffer();
}
- else
- {
- return NULL;
- }
+
+ return NULL;
}
GLenum Framebuffer::getColorbufferType()
diff --git a/src/OpenGL ES 2.0/libGLESv2/Framebuffer.h b/src/OpenGL ES 2.0/libGLESv2/Framebuffer.h
index b9fcc7a..378de0b 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Framebuffer.h
+++ b/src/OpenGL ES 2.0/libGLESv2/Framebuffer.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Framebuffer.h: Defines the Framebuffer class. Implements GL framebuffer
@@ -42,10 +47,6 @@
Image *getRenderTarget();
Image *getDepthStencil();
- unsigned int getRenderTargetSerial();
- unsigned int getDepthbufferSerial();
- unsigned int getStencilbufferSerial();
-
Colorbuffer *getColorbuffer();
DepthStencilbuffer *getDepthbuffer();
DepthStencilbuffer *getStencilbuffer();
diff --git a/src/OpenGL ES 2.0/libGLESv2/HandleAllocator.cpp b/src/OpenGL ES 2.0/libGLESv2/HandleAllocator.cpp
index e06baa9..7db672a 100644
--- a/src/OpenGL ES 2.0/libGLESv2/HandleAllocator.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/HandleAllocator.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2011 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.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// HandleAllocator.cpp: Implements the HandleAllocator class, which is used
diff --git a/src/OpenGL ES 2.0/libGLESv2/HandleAllocator.h b/src/OpenGL ES 2.0/libGLESv2/HandleAllocator.h
index 76ea0f9..6bc0057 100644
--- a/src/OpenGL ES 2.0/libGLESv2/HandleAllocator.h
+++ b/src/OpenGL ES 2.0/libGLESv2/HandleAllocator.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2011 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.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// HandleAllocator.h: Defines the HandleAllocator class, which is used to
diff --git a/src/OpenGL ES 2.0/libGLESv2/IndexDataManager.cpp b/src/OpenGL ES 2.0/libGLESv2/IndexDataManager.cpp
index 55688a3..a83078f 100644
--- a/src/OpenGL ES 2.0/libGLESv2/IndexDataManager.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/IndexDataManager.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// IndexDataManager.cpp: Defines the IndexDataManager, a class that
@@ -10,8 +15,6 @@
#include "IndexDataManager.h"
#include "Buffer.h"
-#include "mathutil.h"
-#include "main.h"
#include "common/debug.h"
namespace
@@ -22,9 +25,9 @@
namespace gl
{
-IndexDataManager::IndexDataManager(Context *context, Device *device) : mDevice(device)
+IndexDataManager::IndexDataManager()
{
- mStreamingBuffer = new StreamingIndexBuffer(mDevice, INITIAL_INDEX_BUFFER_SIZE);
+ mStreamingBuffer = new StreamingIndexBuffer(INITIAL_INDEX_BUFFER_SIZE);
if(!mStreamingBuffer)
{
@@ -96,7 +99,7 @@
if(buffer != NULL)
{
- switch (type)
+ switch(type)
{
case GL_UNSIGNED_BYTE: alignedOffset = (offset % sizeof(GLubyte) == 0); break;
case GL_UNSIGNED_SHORT: alignedOffset = (offset % sizeof(GLushort) == 0); break;
@@ -151,7 +154,7 @@
std::size_t IndexDataManager::typeSize(GLenum type)
{
- switch (type)
+ switch(type)
{
case GL_UNSIGNED_INT: return sizeof(GLuint);
case GL_UNSIGNED_SHORT: return sizeof(GLushort);
@@ -160,7 +163,7 @@
}
}
-StreamingIndexBuffer::StreamingIndexBuffer(Device *device, UINT initialSize) : mDevice(device), mBufferSize(initialSize), mIndexBuffer(NULL)
+StreamingIndexBuffer::StreamingIndexBuffer(UINT initialSize) : mBufferSize(initialSize), mIndexBuffer(NULL)
{
if(initialSize > 0)
{
@@ -228,7 +231,7 @@
if(!mIndexBuffer)
{
- ERR("Out of memory allocating a vertex buffer of size %lu.", mBufferSize);
+ ERR("Out of memory allocating an index buffer of size %lu.", mBufferSize);
}
mWritePosition = 0;
diff --git a/src/OpenGL ES 2.0/libGLESv2/IndexDataManager.h b/src/OpenGL ES 2.0/libGLESv2/IndexDataManager.h
index 65efb85..9fab0a1 100644
--- a/src/OpenGL ES 2.0/libGLESv2/IndexDataManager.h
+++ b/src/OpenGL ES 2.0/libGLESv2/IndexDataManager.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// IndexDataManager.h: Defines the IndexDataManager, a class that
@@ -11,14 +16,10 @@
#define LIBGLESV2_INDEXDATAMANAGER_H_
#include "Context.h"
-#include "Device.hpp"
#define GL_APICALL
#include <GLES2/gl2.h>
-#include <vector>
-#include <cstddef>
-
namespace gl
{
@@ -34,19 +35,16 @@
class StreamingIndexBuffer
{
public:
- StreamingIndexBuffer(Device *device, UINT initialSize);
+ StreamingIndexBuffer(UINT initialSize);
virtual ~StreamingIndexBuffer();
void *map(UINT requiredSpace, UINT *offset);
void unmap();
void reserveSpace(UINT requiredSpace, GLenum type);
- UINT size() const {return mBufferSize;}
sw::Resource *getResource() const;
private:
- Device *const mDevice;
-
sw::Resource *mIndexBuffer;
UINT mBufferSize;
UINT mWritePosition;
@@ -55,7 +53,7 @@
class IndexDataManager
{
public:
- IndexDataManager(Context *context, Device *evice);
+ IndexDataManager();
virtual ~IndexDataManager();
GLenum prepareIndexData(GLenum type, GLsizei count, Buffer *arrayElementBuffer, const void *indices, TranslatedIndexData *translated);
@@ -63,10 +61,6 @@
static std::size_t typeSize(GLenum type);
private:
- DISALLOW_COPY_AND_ASSIGN(IndexDataManager);
-
- Device *const mDevice;
-
StreamingIndexBuffer *mStreamingBuffer;
};
diff --git a/src/OpenGL ES 2.0/libGLESv2/Program.cpp b/src/OpenGL ES 2.0/libGLESv2/Program.cpp
index 8b0d85f..20f80e5 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Program.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Program.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2011 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.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Program.cpp: Implements the Program class. Implements GL program objects
@@ -18,3100 +23,2221 @@
#include <string>
-#if !defined(ANGLE_COMPILE_OPTIMIZATION_LEVEL)
-#define ANGLE_COMPILE_OPTIMIZATION_LEVEL D3DCOMPILE_OPTIMIZATION_LEVEL3
-#endif
-
namespace gl
{
-unsigned int Program::mCurrentSerial = 1;
-const char *fakepath = "C:\\fakepath";
+ unsigned int Program::currentSerial = 1;
-std::string str(int i)
-{
- char buffer[20];
- sprintf(buffer, "%d", i);
- return buffer;
-}
+ std::string str(int i)
+ {
+ char buffer[20];
+ sprintf(buffer, "%d", i);
+ return buffer;
+ }
-Uniform::Uniform(GLenum type, const std::string &_name, unsigned int arraySize) : type(type), _name(_name), name(Program::undecorateUniform(_name)), arraySize(arraySize)
-{
- int bytes = UniformTypeSize(type) * arraySize;
- data = new unsigned char[bytes];
- memset(data, 0, bytes);
- dirty = true;
- handlesSet = false;
-}
+ Uniform::Uniform(GLenum type, const std::string &name, unsigned int arraySize) : type(type), name(name), arraySize(arraySize)
+ {
+ int bytes = UniformTypeSize(type) * size();
+ data = new unsigned char[bytes];
+ memset(data, 0, bytes);
+ dirty = true;
-Uniform::~Uniform()
-{
- delete[] data;
-}
+ psRegisterIndex = -1;
+ vsRegisterIndex = -1;
+ }
-bool Uniform::isArray()
-{
- return _name.compare(0, 3, "ar_") == 0;
-}
+ Uniform::~Uniform()
+ {
+ delete[] data;
+ }
-UniformLocation::UniformLocation(const std::string &_name, unsigned int element, unsigned int index)
- : name(Program::undecorateUniform(_name)), element(element), index(index)
-{
-}
+ bool Uniform::isArray() const
+ {
+ return arraySize >= 1;
+ }
-Program::Program(ResourceManager *manager, GLuint handle) : mResourceManager(manager), mHandle(handle), mSerial(issueSerial())
-{
- mFragmentShader = NULL;
- mVertexShader = NULL;
+ int Uniform::size() const
+ {
+ return arraySize > 0 ? arraySize : 1;
+ }
- mPixelExecutable = NULL;
- mVertexExecutable = NULL;
- mConstantTablePS = NULL;
- mConstantTableVS = NULL;
+ int Uniform::registerCount() const
+ {
+ return size() * VariableRowCount(type);
+ }
- mInfoLog = NULL;
- mValidated = false;
+ UniformLocation::UniformLocation(const std::string &name, unsigned int element, unsigned int index) : name(name), element(element), index(index)
+ {
+ }
- unlink();
+ Program::Program(ResourceManager *manager, GLuint handle) : resourceManager(manager), handle(handle), serial(issueSerial())
+ {
+ device = getDevice();
- mDeleteStatus = false;
+ fragmentShader = 0;
+ vertexShader = 0;
+ pixelBinary = 0;
+ vertexBinary = 0;
- mRefCount = 0;
-}
+ infoLog = 0;
+ validated = false;
-Program::~Program()
-{
- unlink(true);
+ unlink();
- if(mVertexShader != NULL)
- {
- mVertexShader->release();
- }
+ orphaned = false;
+ referenceCount = 0;
+ }
- if(mFragmentShader != NULL)
- {
- mFragmentShader->release();
- }
-}
+ Program::~Program()
+ {
+ unlink();
-bool Program::attachShader(Shader *shader)
-{
- if(shader->getType() == GL_VERTEX_SHADER)
- {
- if(mVertexShader)
- {
- return false;
- }
-
- mVertexShader = (VertexShader*)shader;
- mVertexShader->addRef();
- }
- else if(shader->getType() == GL_FRAGMENT_SHADER)
- {
- if(mFragmentShader)
- {
- return false;
- }
-
- mFragmentShader = (FragmentShader*)shader;
- mFragmentShader->addRef();
- }
- else UNREACHABLE();
-
- return true;
-}
-
-bool Program::detachShader(Shader *shader)
-{
- if(shader->getType() == GL_VERTEX_SHADER)
- {
- if(mVertexShader != shader)
- {
- return false;
- }
-
- mVertexShader->release();
- mVertexShader = NULL;
- }
- else if(shader->getType() == GL_FRAGMENT_SHADER)
- {
- if(mFragmentShader != shader)
- {
- return false;
- }
-
- mFragmentShader->release();
- mFragmentShader = NULL;
- }
- else UNREACHABLE();
-
- return true;
-}
-
-int Program::getAttachedShadersCount() const
-{
- return (mVertexShader ? 1 : 0) + (mFragmentShader ? 1 : 0);
-}
-
-sw::PixelShader *Program::getPixelShader()
-{
- return mPixelExecutable;
-}
-
-sw::VertexShader *Program::getVertexShader()
-{
- return mVertexExecutable;
-}
-
-void Program::bindAttributeLocation(GLuint index, const char *name)
-{
- if(index < MAX_VERTEX_ATTRIBS)
- {
- for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
- {
- mAttributeBinding[i].erase(name);
- }
-
- mAttributeBinding[index].insert(name);
- }
-}
-
-GLuint Program::getAttributeLocation(const char *name)
-{
- if(name)
- {
- for(int index = 0; index < MAX_VERTEX_ATTRIBS; index++)
- {
- if(mLinkedAttribute[index].name == std::string(name))
- {
- return index;
- }
- }
- }
-
- return -1;
-}
-
-int Program::getSemanticIndex(int attributeIndex)
-{
- ASSERT(attributeIndex >= 0 && attributeIndex < MAX_VERTEX_ATTRIBS);
-
- return mSemanticIndex[attributeIndex];
-}
-
-// Returns the index of the texture image unit (0-19) corresponding to a Direct3D 9 sampler
-// index (0-15 for the pixel shader and 0-3 for the vertex shader).
-GLint Program::getSamplerMapping(sw::SamplerType type, unsigned int samplerIndex)
-{
- GLuint logicalTextureUnit = -1;
-
- switch(type)
- {
- case sw::SAMPLER_PIXEL:
- ASSERT(samplerIndex < sizeof(mSamplersPS)/sizeof(mSamplersPS[0]));
-
- if(mSamplersPS[samplerIndex].active)
- {
- logicalTextureUnit = mSamplersPS[samplerIndex].logicalTextureUnit;
- }
- break;
- case sw::SAMPLER_VERTEX:
- ASSERT(samplerIndex < sizeof(mSamplersVS)/sizeof(mSamplersVS[0]));
-
- if(mSamplersVS[samplerIndex].active)
- {
- logicalTextureUnit = mSamplersVS[samplerIndex].logicalTextureUnit;
- }
- break;
- default: UNREACHABLE();
- }
-
- if(logicalTextureUnit >= 0 && logicalTextureUnit < MAX_COMBINED_TEXTURE_IMAGE_UNITS)
- {
- return logicalTextureUnit;
- }
-
- return -1;
-}
-
-// Returns the texture type for a given Direct3D 9 sampler type and
-// index (0-15 for the pixel shader and 0-3 for the vertex shader).
-TextureType Program::getSamplerTextureType(sw::SamplerType type, unsigned int samplerIndex)
-{
- switch(type)
- {
- case sw::SAMPLER_PIXEL:
- ASSERT(samplerIndex < sizeof(mSamplersPS)/sizeof(mSamplersPS[0]));
- ASSERT(mSamplersPS[samplerIndex].active);
- return mSamplersPS[samplerIndex].textureType;
- case sw::SAMPLER_VERTEX:
- ASSERT(samplerIndex < sizeof(mSamplersVS)/sizeof(mSamplersVS[0]));
- ASSERT(mSamplersVS[samplerIndex].active);
- return mSamplersVS[samplerIndex].textureType;
- default: UNREACHABLE();
- }
-
- return TEXTURE_2D;
-}
-
-GLint Program::getUniformLocation(std::string name)
-{
- int subscript = 0;
-
- // Strip any trailing array operator and retrieve the subscript
- size_t open = name.find_last_of('[');
- size_t close = name.find_last_of(']');
- if(open != std::string::npos && close == name.length() - 1)
- {
- subscript = atoi(name.substr(open + 1).c_str());
- name.erase(open);
- }
-
- unsigned int numUniforms = mUniformIndex.size();
- for(unsigned int location = 0; location < numUniforms; location++)
- {
- if(mUniformIndex[location].name == name &&
- mUniformIndex[location].element == subscript)
- {
- return location;
- }
- }
-
- return -1;
-}
-
-bool Program::setUniform1fv(GLint location, GLsizei count, const GLfloat* v)
-{
- if(location < 0 || location >= (int)mUniformIndex.size())
- {
- return false;
- }
-
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
- targetUniform->dirty = true;
-
- if(targetUniform->type == GL_FLOAT)
- {
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLfloat),
- v, sizeof(GLfloat) * count);
- }
- else if(targetUniform->type == GL_BOOL)
- {
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
- GLboolean *boolParams = new GLboolean[count];
-
- for(int i = 0; i < count; ++i)
- {
- if(v[i] == 0.0f)
- {
- boolParams[i] = GL_FALSE;
- }
- else
- {
- boolParams[i] = GL_TRUE;
- }
- }
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLboolean),
- boolParams, sizeof(GLboolean) * count);
-
- delete [] boolParams;
- }
- else
- {
- return false;
- }
-
- return true;
-}
-
-bool Program::setUniform2fv(GLint location, GLsizei count, const GLfloat *v)
-{
- if(location < 0 || location >= (int)mUniformIndex.size())
- {
- return false;
- }
-
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
- targetUniform->dirty = true;
-
- if(targetUniform->type == GL_FLOAT_VEC2)
- {
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLfloat) * 2,
- v, 2 * sizeof(GLfloat) * count);
- }
- else if(targetUniform->type == GL_BOOL_VEC2)
- {
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
- GLboolean *boolParams = new GLboolean[count * 2];
-
- for(int i = 0; i < count * 2; ++i)
- {
- if(v[i] == 0.0f)
- {
- boolParams[i] = GL_FALSE;
- }
- else
- {
- boolParams[i] = GL_TRUE;
- }
- }
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLboolean) * 2,
- boolParams, 2 * sizeof(GLboolean) * count);
-
- delete [] boolParams;
- }
- else
- {
- return false;
- }
-
- return true;
-}
-
-bool Program::setUniform3fv(GLint location, GLsizei count, const GLfloat *v)
-{
- if(location < 0 || location >= (int)mUniformIndex.size())
- {
- return false;
- }
-
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
- targetUniform->dirty = true;
-
- if(targetUniform->type == GL_FLOAT_VEC3)
- {
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLfloat) * 3,
- v, 3 * sizeof(GLfloat) * count);
- }
- else if(targetUniform->type == GL_BOOL_VEC3)
- {
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
- GLboolean *boolParams = new GLboolean[count * 3];
-
- for(int i = 0; i < count * 3; ++i)
- {
- if(v[i] == 0.0f)
- {
- boolParams[i] = GL_FALSE;
- }
- else
- {
- boolParams[i] = GL_TRUE;
- }
- }
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLboolean) * 3,
- boolParams, 3 * sizeof(GLboolean) * count);
-
- delete [] boolParams;
- }
- else
- {
- return false;
- }
-
- return true;
-}
-
-bool Program::setUniform4fv(GLint location, GLsizei count, const GLfloat *v)
-{
- if(location < 0 || location >= (int)mUniformIndex.size())
- {
- return false;
- }
-
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
- targetUniform->dirty = true;
-
- if(targetUniform->type == GL_FLOAT_VEC4)
- {
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLfloat) * 4,
- v, 4 * sizeof(GLfloat) * count);
- }
- else if(targetUniform->type == GL_BOOL_VEC4)
- {
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
- GLboolean *boolParams = new GLboolean[count * 4];
-
- for(int i = 0; i < count * 4; ++i)
- {
- if(v[i] == 0.0f)
- {
- boolParams[i] = GL_FALSE;
- }
- else
- {
- boolParams[i] = GL_TRUE;
- }
- }
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLboolean) * 4,
- boolParams, 4 * sizeof(GLboolean) * count);
-
- delete [] boolParams;
- }
- else
- {
- return false;
- }
-
- return true;
-}
-
-bool Program::setUniformMatrix2fv(GLint location, GLsizei count, const GLfloat *value)
-{
- if(location < 0 || location >= (int)mUniformIndex.size())
- {
- return false;
- }
-
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
- targetUniform->dirty = true;
-
- if(targetUniform->type != GL_FLOAT_MAT2)
- {
- return false;
- }
-
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLfloat) * 4,
- value, 4 * sizeof(GLfloat) * count);
-
- return true;
-}
-
-bool Program::setUniformMatrix3fv(GLint location, GLsizei count, const GLfloat *value)
-{
- if(location < 0 || location >= (int)mUniformIndex.size())
- {
- return false;
- }
-
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
- targetUniform->dirty = true;
-
- if(targetUniform->type != GL_FLOAT_MAT3)
- {
- return false;
- }
-
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLfloat) * 9,
- value, 9 * sizeof(GLfloat) * count);
-
- return true;
-}
-
-bool Program::setUniformMatrix4fv(GLint location, GLsizei count, const GLfloat *value)
-{
- if(location < 0 || location >= (int)mUniformIndex.size())
- {
- return false;
- }
-
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
- targetUniform->dirty = true;
-
- if(targetUniform->type != GL_FLOAT_MAT4)
- {
- return false;
- }
-
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLfloat) * 16,
- value, 16 * sizeof(GLfloat) * count);
-
- return true;
-}
-
-bool Program::setUniform1iv(GLint location, GLsizei count, const GLint *v)
-{
- if(location < 0 || location >= (int)mUniformIndex.size())
- {
- return false;
- }
-
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
- targetUniform->dirty = true;
-
- if(targetUniform->type == GL_INT ||
- targetUniform->type == GL_SAMPLER_2D ||
- targetUniform->type == GL_SAMPLER_CUBE)
- {
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLint),
- v, sizeof(GLint) * count);
- }
- else if(targetUniform->type == GL_BOOL)
- {
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
- GLboolean *boolParams = new GLboolean[count];
-
- for(int i = 0; i < count; ++i)
- {
- if(v[i] == 0)
- {
- boolParams[i] = GL_FALSE;
- }
- else
- {
- boolParams[i] = GL_TRUE;
- }
- }
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLboolean),
- boolParams, sizeof(GLboolean) * count);
-
- delete [] boolParams;
- }
- else
- {
- return false;
- }
-
- return true;
-}
-
-bool Program::setUniform2iv(GLint location, GLsizei count, const GLint *v)
-{
- if(location < 0 || location >= (int)mUniformIndex.size())
- {
- return false;
- }
-
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
- targetUniform->dirty = true;
-
- if(targetUniform->type == GL_INT_VEC2)
- {
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLint) * 2,
- v, 2 * sizeof(GLint) * count);
- }
- else if(targetUniform->type == GL_BOOL_VEC2)
- {
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
- GLboolean *boolParams = new GLboolean[count * 2];
-
- for(int i = 0; i < count * 2; ++i)
- {
- if(v[i] == 0)
- {
- boolParams[i] = GL_FALSE;
- }
- else
- {
- boolParams[i] = GL_TRUE;
- }
- }
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLboolean) * 2,
- boolParams, 2 * sizeof(GLboolean) * count);
-
- delete [] boolParams;
- }
- else
- {
- return false;
- }
-
- return true;
-}
-
-bool Program::setUniform3iv(GLint location, GLsizei count, const GLint *v)
-{
- if(location < 0 || location >= (int)mUniformIndex.size())
- {
- return false;
- }
-
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
- targetUniform->dirty = true;
-
- if(targetUniform->type == GL_INT_VEC3)
- {
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLint) * 3,
- v, 3 * sizeof(GLint) * count);
- }
- else if(targetUniform->type == GL_BOOL_VEC3)
- {
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
- GLboolean *boolParams = new GLboolean[count * 3];
-
- for(int i = 0; i < count * 3; ++i)
- {
- if(v[i] == 0)
- {
- boolParams[i] = GL_FALSE;
- }
- else
- {
- boolParams[i] = GL_TRUE;
- }
- }
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLboolean) * 3,
- boolParams, 3 * sizeof(GLboolean) * count);
-
- delete [] boolParams;
- }
- else
- {
- return false;
- }
-
- return true;
-}
-
-bool Program::setUniform4iv(GLint location, GLsizei count, const GLint *v)
-{
- if(location < 0 || location >= (int)mUniformIndex.size())
- {
- return false;
- }
-
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
- targetUniform->dirty = true;
-
- if(targetUniform->type == GL_INT_VEC4)
- {
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLint) * 4,
- v, 4 * sizeof(GLint) * count);
- }
- else if(targetUniform->type == GL_BOOL_VEC4)
- {
- int arraySize = targetUniform->arraySize;
-
- if(arraySize == 1 && count > 1)
- return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
- count = std::min(arraySize - (int)mUniformIndex[location].element, count);
- GLboolean *boolParams = new GLboolean[count * 4];
-
- for(int i = 0; i < count * 4; ++i)
- {
- if(v[i] == 0)
- {
- boolParams[i] = GL_FALSE;
- }
- else
- {
- boolParams[i] = GL_TRUE;
- }
- }
-
- memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLboolean) * 4,
- boolParams, 4 * sizeof(GLboolean) * count);
-
- delete [] boolParams;
- }
- else
- {
- return false;
- }
-
- return true;
-}
-
-bool Program::getUniformfv(GLint location, GLfloat *params)
-{
- if(location < 0 || location >= (int)mUniformIndex.size())
- {
- return false;
- }
-
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-
- unsigned int count = UniformComponentCount(targetUniform->type);
-
- switch (UniformComponentType(targetUniform->type))
- {
- case GL_BOOL:
- {
- GLboolean *boolParams = (GLboolean*)targetUniform->data + mUniformIndex[location].element * count;
-
- for(unsigned int i = 0; i < count; ++i)
- {
- params[i] = (boolParams[i] == GL_FALSE) ? 0.0f : 1.0f;
- }
- }
- break;
- case GL_FLOAT:
- memcpy(params, targetUniform->data + mUniformIndex[location].element * count * sizeof(GLfloat),
- count * sizeof(GLfloat));
- break;
- case GL_INT:
- {
- GLint *intParams = (GLint*)targetUniform->data + mUniformIndex[location].element * count;
-
- for(unsigned int i = 0; i < count; ++i)
- {
- params[i] = (float)intParams[i];
- }
- }
- break;
- default: UNREACHABLE();
- }
-
- return true;
-}
-
-bool Program::getUniformiv(GLint location, GLint *params)
-{
- if(location < 0 || location >= (int)mUniformIndex.size())
- {
- return false;
- }
-
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-
- unsigned int count = UniformComponentCount(targetUniform->type);
-
- switch (UniformComponentType(targetUniform->type))
- {
- case GL_BOOL:
- {
- GLboolean *boolParams = targetUniform->data + mUniformIndex[location].element * count;
-
- for(unsigned int i = 0; i < count; ++i)
- {
- params[i] = (GLint)boolParams[i];
- }
- }
- break;
- case GL_FLOAT:
- {
- GLfloat *floatParams = (GLfloat*)targetUniform->data + mUniformIndex[location].element * count;
-
- for(unsigned int i = 0; i < count; ++i)
- {
- params[i] = (GLint)floatParams[i];
- }
- }
- break;
- case GL_INT:
- memcpy(params, targetUniform->data + mUniformIndex[location].element * count * sizeof(GLint),
- count * sizeof(GLint));
- break;
- default: UNREACHABLE();
- }
-
- return true;
-}
-
-void Program::dirtyAllUniforms()
-{
- unsigned int numUniforms = mUniforms.size();
- for(unsigned int index = 0; index < numUniforms; index++)
- {
- mUniforms[index]->dirty = true;
- }
-}
-
-// Applies all the uniforms set for this program object to the Direct3D 9 device
-void Program::applyUniforms()
-{
- unsigned int numUniforms = mUniformIndex.size();
- for(unsigned int location = 0; location < numUniforms; location++)
- {
- if(mUniformIndex[location].element != 0)
- {
- continue;
- }
-
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-
- if(targetUniform->dirty)
- {
- int arraySize = targetUniform->arraySize;
- GLfloat *f = (GLfloat*)targetUniform->data;
- GLint *i = (GLint*)targetUniform->data;
- GLboolean *b = (GLboolean*)targetUniform->data;
-
- switch (targetUniform->type)
- {
- case GL_BOOL: applyUniform1bv(location, arraySize, b); break;
- case GL_BOOL_VEC2: applyUniform2bv(location, arraySize, b); break;
- case GL_BOOL_VEC3: applyUniform3bv(location, arraySize, b); break;
- case GL_BOOL_VEC4: applyUniform4bv(location, arraySize, b); break;
- case GL_FLOAT: applyUniform1fv(location, arraySize, f); break;
- case GL_FLOAT_VEC2: applyUniform2fv(location, arraySize, f); break;
- case GL_FLOAT_VEC3: applyUniform3fv(location, arraySize, f); break;
- case GL_FLOAT_VEC4: applyUniform4fv(location, arraySize, f); break;
- case GL_FLOAT_MAT2: applyUniformMatrix2fv(location, arraySize, f); break;
- case GL_FLOAT_MAT3: applyUniformMatrix3fv(location, arraySize, f); break;
- case GL_FLOAT_MAT4: applyUniformMatrix4fv(location, arraySize, f); break;
- case GL_SAMPLER_2D:
- case GL_SAMPLER_CUBE:
- case GL_INT: applyUniform1iv(location, arraySize, i); break;
- case GL_INT_VEC2: applyUniform2iv(location, arraySize, i); break;
- case GL_INT_VEC3: applyUniform3iv(location, arraySize, i); break;
- case GL_INT_VEC4: applyUniform4iv(location, arraySize, i); break;
- default:
- UNREACHABLE();
- }
-
- targetUniform->dirty = false;
- }
- }
-}
-
-// Compiles the HLSL code of the attached shaders into executable binaries
-ID3D10Blob *Program::compileToBinary(const char *hlsl, const char *profile, ID3DXConstantTable **constantTable)
-{
- if(!hlsl)
- {
- return NULL;
- }
-
- UINT flags = ANGLE_COMPILE_OPTIMIZATION_LEVEL;
-
- ID3D10Blob *binary = NULL;
- ID3D10Blob *errorMessage = NULL;
- HRESULT result = D3DCompile(hlsl, strlen(hlsl), fakepath, NULL, NULL, "main", profile, flags, 0, &binary, &errorMessage);
-
- if(errorMessage)
- {
- const char *message = (const char*)errorMessage->GetBufferPointer();
-
- appendToInfoLogSanitized(message);
- TRACE("\n%s", hlsl);
- TRACE("\n%s", message);
-
- errorMessage->Release();
- errorMessage = NULL;
- }
-
- if(FAILED(result))
- {
- if(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
- {
- error(GL_OUT_OF_MEMORY);
- }
-
- return NULL;
- }
-
- result = D3DXGetShaderConstantTable(static_cast<const DWORD*>(binary->GetBufferPointer()), constantTable);
-
- if(FAILED(result))
- {
- if(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
- {
- error(GL_OUT_OF_MEMORY);
- }
-
- binary->Release();
-
- return NULL;
- }
-
- return binary;
-}
-
-// Packs varyings into generic varying registers, using the algorithm from [OpenGL ES Shading Language 1.00 rev. 17] appendix A section 7 page 111
-// Returns the number of used varying registers, or -1 if unsuccesful
-int Program::packVaryings(const Varying *packing[][4])
-{
- Context *context = getContext();
-
- for(VaryingList::iterator varying = mFragmentShader->varyings.begin(); varying != mFragmentShader->varyings.end(); varying++)
- {
- int n = VariableRowCount(varying->type) * varying->size;
- int m = VariableColumnCount(varying->type);
- bool success = false;
-
- if(m == 2 || m == 3 || m == 4)
- {
- for(int r = 0; r <= MAX_VARYING_VECTORS - n && !success; r++)
- {
- bool available = true;
-
- for(int y = 0; y < n && available; y++)
- {
- for(int x = 0; x < m && available; x++)
- {
- if(packing[r + y][x])
- {
- available = false;
- }
- }
- }
-
- if(available)
- {
- varying->reg = r;
- varying->col = 0;
-
- for(int y = 0; y < n; y++)
- {
- for(int x = 0; x < m; x++)
- {
- packing[r + y][x] = &*varying;
- }
- }
-
- success = true;
- }
- }
-
- if(!success && m == 2)
- {
- for(int r = MAX_VARYING_VECTORS - n; r >= 0 && !success; r--)
- {
- bool available = true;
-
- for(int y = 0; y < n && available; y++)
- {
- for(int x = 2; x < 4 && available; x++)
- {
- if(packing[r + y][x])
- {
- available = false;
- }
- }
- }
-
- if(available)
- {
- varying->reg = r;
- varying->col = 2;
-
- for(int y = 0; y < n; y++)
- {
- for(int x = 2; x < 4; x++)
- {
- packing[r + y][x] = &*varying;
- }
- }
-
- success = true;
- }
- }
- }
- }
- else if(m == 1)
- {
- int space[4] = {0};
-
- for(int y = 0; y < MAX_VARYING_VECTORS; y++)
- {
- for(int x = 0; x < 4; x++)
- {
- space[x] += packing[y][x] ? 0 : 1;
- }
- }
-
- int column = 0;
-
- for(int x = 0; x < 4; x++)
- {
- if(space[x] >= n && space[x] < space[column])
- {
- column = x;
- }
- }
-
- if(space[column] >= n)
- {
- for(int r = 0; r < MAX_VARYING_VECTORS; r++)
- {
- if(!packing[r][column])
- {
- varying->reg = r;
-
- for(int y = r; y < r + n; y++)
- {
- packing[y][column] = &*varying;
- }
-
- break;
- }
- }
-
- varying->col = column;
-
- success = true;
- }
- }
- else UNREACHABLE();
-
- if(!success)
- {
- appendToInfoLog("Could not pack varying %s", varying->name.c_str());
-
- return -1;
- }
- }
-
- // Return the number of used registers
- int registers = 0;
-
- for(int r = 0; r < MAX_VARYING_VECTORS; r++)
- {
- if(packing[r][0] || packing[r][1] || packing[r][2] || packing[r][3])
- {
- registers++;
- }
- }
-
- return registers;
-}
-
-bool Program::linkVaryings()
-{
- if(mPixelHLSL.empty() || mVertexHLSL.empty())
- {
- return false;
- }
-
- // Reset the varying register assignments
- for(VaryingList::iterator fragVar = mFragmentShader->varyings.begin(); fragVar != mFragmentShader->varyings.end(); fragVar++)
- {
- fragVar->reg = -1;
- fragVar->col = -1;
- }
-
- for(VaryingList::iterator vtxVar = mVertexShader->varyings.begin(); vtxVar != mVertexShader->varyings.end(); vtxVar++)
- {
- vtxVar->reg = -1;
- vtxVar->col = -1;
- }
-
- // Map the varyings to the register file
- const Varying *packing[MAX_VARYING_VECTORS][4] = {NULL};
- int registers = packVaryings(packing);
-
- if(registers < 0)
- {
- return false;
- }
-
- // Write the HLSL input/output declarations
- Context *context = getContext();
-
- if(registers == MAX_VARYING_VECTORS && mFragmentShader->mUsesFragCoord)
- {
- appendToInfoLog("No varying registers left to support gl_FragCoord");
-
- return false;
- }
-
- for(VaryingList::iterator input = mFragmentShader->varyings.begin(); input != mFragmentShader->varyings.end(); input++)
- {
- bool matched = false;
-
- for(VaryingList::iterator output = mVertexShader->varyings.begin(); output != mVertexShader->varyings.end(); output++)
- {
- if(output->name == input->name)
- {
- if(output->type != input->type || output->size != input->size)
- {
- appendToInfoLog("Type of vertex varying %s does not match that of the fragment varying", output->name.c_str());
-
- return false;
- }
-
- output->reg = input->reg;
- output->col = input->col;
-
- matched = true;
- break;
- }
- }
-
- if(!matched)
- {
- appendToInfoLog("Fragment varying %s does not match any vertex varying", input->name.c_str());
-
- return false;
- }
- }
-
- mVertexHLSL += "struct VS_INPUT\n"
- "{\n";
-
- int semanticIndex = 0;
- for(AttributeArray::iterator attribute = mVertexShader->mAttributes.begin(); attribute != mVertexShader->mAttributes.end(); attribute++)
- {
- switch (attribute->type)
- {
- case GL_FLOAT: mVertexHLSL += " float "; break;
- case GL_FLOAT_VEC2: mVertexHLSL += " float2 "; break;
- case GL_FLOAT_VEC3: mVertexHLSL += " float3 "; break;
- case GL_FLOAT_VEC4: mVertexHLSL += " float4 "; break;
- case GL_FLOAT_MAT2: mVertexHLSL += " float2x2 "; break;
- case GL_FLOAT_MAT3: mVertexHLSL += " float3x3 "; break;
- case GL_FLOAT_MAT4: mVertexHLSL += " float4x4 "; break;
- default: UNREACHABLE();
- }
-
- mVertexHLSL += decorateAttribute(attribute->name) + " : TEXCOORD" + str(semanticIndex) + ";\n";
-
- semanticIndex += VariableRowCount(attribute->type);
- }
-
- mVertexHLSL += "};\n"
- "\n"
- "struct VS_OUTPUT\n"
- "{\n"
- " float4 gl_Position : POSITION;\n";
-
- for(int r = 0; r < registers; r++)
- {
- int registerSize = packing[r][3] ? 4 : (packing[r][2] ? 3 : (packing[r][1] ? 2 : 1));
-
- mVertexHLSL += " float" + str(registerSize) + " v" + str(r) + " : COLOR" + str(r) + ";\n";
- }
-
- if(mFragmentShader->mUsesFragCoord)
- {
- mVertexHLSL += " float4 gl_FragCoord : COLOR" + str(registers) + ";\n";
- }
-
- if(mVertexShader->mUsesPointSize)
- {
- mVertexHLSL += " float gl_PointSize : PSIZE;\n";
- }
-
- mVertexHLSL += "};\n"
- "\n"
- "VS_OUTPUT main(VS_INPUT input)\n"
- "{\n";
-
- for(AttributeArray::iterator attribute = mVertexShader->mAttributes.begin(); attribute != mVertexShader->mAttributes.end(); attribute++)
- {
- mVertexHLSL += " " + decorateAttribute(attribute->name) + " = ";
-
- if(VariableRowCount(attribute->type) > 1) // Matrix
- {
- mVertexHLSL += "transpose";
- }
-
- mVertexHLSL += "(input." + decorateAttribute(attribute->name) + ");\n";
- }
-
- mVertexHLSL += "\n"
- " gl_main();\n"
- "\n"
- " VS_OUTPUT output;\n"
- " output.gl_Position.x = gl_Position.x - dx_HalfPixelSize.x * gl_Position.w;\n"
- " output.gl_Position.y = gl_Position.y - dx_HalfPixelSize.y * gl_Position.w;\n"
- " output.gl_Position.z = (gl_Position.z + gl_Position.w) * 0.5;\n"
- " output.gl_Position.w = gl_Position.w;\n";
-
- if(mVertexShader->mUsesPointSize)
- {
- mVertexHLSL += " output.gl_PointSize = clamp(gl_PointSize, 1.0, " + str((int)ALIASED_POINT_SIZE_RANGE_MAX) + ");\n";
- }
-
- if(mFragmentShader->mUsesFragCoord)
- {
- mVertexHLSL += " output.gl_FragCoord = gl_Position;\n";
- }
-
- for(VaryingList::iterator varying = mVertexShader->varyings.begin(); varying != mVertexShader->varyings.end(); varying++)
- {
- if(varying->reg >= 0)
- {
- for(int i = 0; i < varying->size; i++)
- {
- int rows = VariableRowCount(varying->type);
-
- for(int j = 0; j < rows; j++)
- {
- int r = varying->reg + i * rows + j;
- mVertexHLSL += " output.v" + str(r);
-
- bool sharedRegister = false; // Register used by multiple varyings
-
- for(int x = 0; x < 4; x++)
- {
- if(packing[r][x] && packing[r][x] != packing[r][0])
- {
- sharedRegister = true;
- break;
- }
- }
-
- if(sharedRegister)
- {
- mVertexHLSL += ".";
-
- for(int x = 0; x < 4; x++)
- {
- if(packing[r][x] == &*varying)
- {
- switch(x)
- {
- case 0: mVertexHLSL += "x"; break;
- case 1: mVertexHLSL += "y"; break;
- case 2: mVertexHLSL += "z"; break;
- case 3: mVertexHLSL += "w"; break;
- }
- }
- }
- }
-
- mVertexHLSL += " = " + varying->name;
-
- if(varying->array)
- {
- mVertexHLSL += "[" + str(i) + "]";
- }
-
- if(rows > 1)
- {
- mVertexHLSL += "[" + str(j) + "]";
- }
-
- mVertexHLSL += ";\n";
- }
- }
- }
- }
-
- mVertexHLSL += "\n"
- " return output;\n"
- "}\n";
-
- mPixelHLSL += "struct PS_INPUT\n"
- "{\n";
-
- for(VaryingList::iterator varying = mFragmentShader->varyings.begin(); varying != mFragmentShader->varyings.end(); varying++)
- {
- if(varying->reg >= 0)
- {
- for(int i = 0; i < varying->size; i++)
- {
- int rows = VariableRowCount(varying->type);
- for(int j = 0; j < rows; j++)
- {
- std::string n = str(varying->reg + i * rows + j);
- mPixelHLSL += " float4 v" + n + " : COLOR" + n + ";\n";
- }
- }
- }
- else UNREACHABLE();
- }
-
- if(mFragmentShader->mUsesFragCoord)
- {
- mPixelHLSL += " float4 gl_FragCoord : COLOR" + str(registers) + ";\n";
- mPixelHLSL += " float2 dx_VPos : VPOS;\n";
- }
-
- if(mFragmentShader->mUsesPointCoord)
- {
- mPixelHLSL += " float2 gl_PointCoord : TEXCOORD0;\n";
- }
-
- if(mFragmentShader->mUsesFrontFacing)
- {
- mPixelHLSL += " float vFace : VFACE;\n";
- }
-
- mPixelHLSL += "};\n"
- "\n"
- "struct PS_OUTPUT\n"
- "{\n"
- " float4 gl_Color[1] : COLOR;\n"
- "};\n"
- "\n"
- "PS_OUTPUT main(PS_INPUT input)\n"
- "{\n";
-
- if(mFragmentShader->mUsesFragCoord)
- {
- mPixelHLSL += " float rhw = 1.0 / input.gl_FragCoord.w;\n";
- mPixelHLSL += " gl_FragCoord.x = input.dx_VPos.x + 0.5;\n"
- " gl_FragCoord.y = 2.0 * dx_Viewport.y - input.dx_VPos.y - 0.5;\n";
- mPixelHLSL += " gl_FragCoord.z = (input.gl_FragCoord.z * rhw) * dx_Depth.x + dx_Depth.y;\n"
- " gl_FragCoord.w = rhw;\n";
- }
-
- if(mFragmentShader->mUsesPointCoord)
- {
- mPixelHLSL += " gl_PointCoord = input.gl_PointCoord;\n";
- }
-
- if(mFragmentShader->mUsesFrontFacing)
- {
- mPixelHLSL += " gl_FrontFacing = dx_PointsOrLines || (dx_FrontCCW ? (input.vFace >= 0.0) : (input.vFace <= 0.0));\n";
- }
-
- for(VaryingList::iterator varying = mFragmentShader->varyings.begin(); varying != mFragmentShader->varyings.end(); varying++)
- {
- if(varying->reg >= 0)
- {
- for(int i = 0; i < varying->size; i++)
- {
- int rows = VariableRowCount(varying->type);
- for(int j = 0; j < rows; j++)
- {
- std::string n = str(varying->reg + i * rows + j);
- mPixelHLSL += " " + varying->name;
-
- if(varying->array)
- {
- mPixelHLSL += "[" + str(i) + "]";
- }
-
- if(rows > 1)
- {
- mPixelHLSL += "[" + str(j) + "]";
- }
-
- mPixelHLSL += " = input.v" + n + ";\n";
- }
- }
- }
- else UNREACHABLE();
- }
-
- mPixelHLSL += "\n"
- " gl_main();\n"
- "\n"
- " PS_OUTPUT output;\n"
- " output.gl_Color[0] = gl_Color[0];\n"
- "\n"
- " return output;\n"
- "}\n";
-
- return true;
-}
-
-// Links the HLSL code of the vertex and pixel shader by matching up their varyings,
-// compiling them into binaries, determining the attribute mappings, and collecting
-// a list of uniforms
-void Program::link()
-{
- unlink();
-
- if(!mFragmentShader || !mFragmentShader->isCompiled())
- {
- return;
- }
-
- if(!mVertexShader || !mVertexShader->isCompiled())
- {
- return;
- }
-
- mPixelHLSL = mFragmentShader->getHLSL();
- mVertexHLSL = mVertexShader->getHLSL();
-
- if(!linkVaryings())
- {
- return;
- }
-
- Context *context = getContext();
-
- ID3D10Blob *vertexBinary = compileToBinary(mVertexHLSL.c_str(), "vs_3_0", &mConstantTableVS);
- ID3D10Blob *pixelBinary = compileToBinary(mPixelHLSL.c_str(), "ps_3_0", &mConstantTablePS);
-
- if(vertexBinary && pixelBinary)
- {
- Device *device = getDevice();
- mVertexExecutable = new sw::VertexShader((unsigned long*)vertexBinary->GetBufferPointer());
- mPixelExecutable = new sw::PixelShader((unsigned long*)pixelBinary->GetBufferPointer());
-
- if(!mVertexExecutable || !mPixelExecutable)
- {
- return error(GL_OUT_OF_MEMORY);
- }
-
- vertexBinary->Release();
- pixelBinary->Release();
- vertexBinary = NULL;
- pixelBinary = NULL;
-
- if(mVertexExecutable && mPixelExecutable)
- {
- if(!linkAttributes())
- {
- return;
- }
-
- if(!linkUniforms(mConstantTablePS))
- {
- return;
- }
-
- if(!linkUniforms(mConstantTableVS))
- {
- return;
- }
-
- // these uniforms are searched as already-decorated because gl_ and dx_
- // are reserved prefixes, and do not receive additional decoration
- mDxDepthRangeLocation = getUniformLocation("dx_DepthRange");
- mDxDepthLocation = getUniformLocation("dx_Depth");
- mDxViewportLocation = getUniformLocation("dx_Viewport");
- mDxHalfPixelSizeLocation = getUniformLocation("dx_HalfPixelSize");
- mDxFrontCCWLocation = getUniformLocation("dx_FrontCCW");
- mDxPointsOrLinesLocation = getUniformLocation("dx_PointsOrLines");
-
- mLinked = true; // Success
- }
- }
-}
-
-// Determines the mapping between GL attributes and Direct3D 9 vertex stream usage indices
-bool Program::linkAttributes()
-{
- unsigned int usedLocations = 0;
-
- // Link attributes that have a binding location
- for(AttributeArray::iterator attribute = mVertexShader->mAttributes.begin(); attribute != mVertexShader->mAttributes.end(); attribute++)
- {
- int location = getAttributeBinding(attribute->name);
-
- if(location != -1) // Set by glBindAttribLocation
- {
- if(!mLinkedAttribute[location].name.empty())
- {
- // Multiple active attributes bound to the same location; not an error
- }
-
- mLinkedAttribute[location] = *attribute;
-
- int rows = VariableRowCount(attribute->type);
-
- if(rows + location > MAX_VERTEX_ATTRIBS)
- {
- appendToInfoLog("Active attribute (%s) at location %d is too big to fit", attribute->name.c_str(), location);
-
- return false;
- }
-
- for(int i = 0; i < rows; i++)
- {
- usedLocations |= 1 << (location + i);
- }
- }
- }
-
- // Link attributes that don't have a binding location
- for(AttributeArray::iterator attribute = mVertexShader->mAttributes.begin(); attribute != mVertexShader->mAttributes.end(); attribute++)
- {
- int location = getAttributeBinding(attribute->name);
-
- if(location == -1) // Not set by glBindAttribLocation
- {
- int rows = VariableRowCount(attribute->type);
- int availableIndex = AllocateFirstFreeBits(&usedLocations, rows, MAX_VERTEX_ATTRIBS);
-
- if(availableIndex == -1 || availableIndex + rows > MAX_VERTEX_ATTRIBS)
- {
- appendToInfoLog("Too many active attributes (%s)", attribute->name.c_str());
-
- return false; // Fail to link
- }
-
- mLinkedAttribute[availableIndex] = *attribute;
- }
- }
-
- for(int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; )
- {
- int index = mVertexShader->getSemanticIndex(mLinkedAttribute[attributeIndex].name);
- int rows = std::max(VariableRowCount(mLinkedAttribute[attributeIndex].type), 1);
-
- for(int r = 0; r < rows; r++)
- {
- mSemanticIndex[attributeIndex++] = index++;
- }
- }
-
- return true;
-}
-
-int Program::getAttributeBinding(const std::string &name)
-{
- for(int location = 0; location < MAX_VERTEX_ATTRIBS; location++)
- {
- if(mAttributeBinding[location].find(name) != mAttributeBinding[location].end())
- {
- return location;
- }
- }
-
- return -1;
-}
-
-bool Program::linkUniforms(ID3DXConstantTable *constantTable)
-{
- D3DXCONSTANTTABLE_DESC constantTableDescription;
- D3DXCONSTANT_DESC constantDescription;
- UINT descriptionCount = 1;
-
- constantTable->GetDesc(&constantTableDescription);
-
- for(unsigned int constantIndex = 0; constantIndex < constantTableDescription.Constants; constantIndex++)
- {
- D3DXHANDLE constantHandle = constantTable->GetConstant(0, constantIndex);
- HRESULT result = constantTable->GetConstantDesc(constantHandle, &constantDescription, &descriptionCount);
- ASSERT(SUCCEEDED(result));
-
- if(!defineUniform(constantHandle, constantDescription))
- {
- return false;
- }
- }
-
- return true;
-}
-
-// Adds the description of a constant found in the binary shader to the list of uniforms
-// Returns true if succesful (uniform not already defined)
-bool Program::defineUniform(const D3DXHANDLE &constantHandle, const D3DXCONSTANT_DESC &constantDescription, std::string name)
-{
- if(constantDescription.RegisterSet == D3DXRS_SAMPLER)
- {
- for(unsigned int samplerIndex = constantDescription.RegisterIndex; samplerIndex < constantDescription.RegisterIndex + constantDescription.RegisterCount; samplerIndex++)
- {
- if(mConstantTablePS->GetConstantByName(NULL, constantDescription.Name) != NULL)
- {
- if(samplerIndex < MAX_TEXTURE_IMAGE_UNITS)
- {
- mSamplersPS[samplerIndex].active = true;
- mSamplersPS[samplerIndex].textureType = (constantDescription.Type == D3DXPT_SAMPLERCUBE) ? TEXTURE_CUBE : TEXTURE_2D;
- mSamplersPS[samplerIndex].logicalTextureUnit = 0;
- }
- else
- {
- appendToInfoLog("Pixel shader sampler count exceeds MAX_TEXTURE_IMAGE_UNITS (%d).", MAX_TEXTURE_IMAGE_UNITS);
- return false;
- }
- }
-
- if(mConstantTableVS->GetConstantByName(NULL, constantDescription.Name) != NULL)
- {
- if(samplerIndex < MAX_VERTEX_TEXTURE_IMAGE_UNITS)
- {
- mSamplersVS[samplerIndex].active = true;
- mSamplersVS[samplerIndex].textureType = (constantDescription.Type == D3DXPT_SAMPLERCUBE) ? TEXTURE_CUBE : TEXTURE_2D;
- mSamplersVS[samplerIndex].logicalTextureUnit = 0;
- }
- else
- {
- appendToInfoLog("Vertex shader sampler count exceeds MAX_VERTEX_TEXTURE_IMAGE_UNITS (%d).", MAX_VERTEX_TEXTURE_IMAGE_UNITS);
- return false;
- }
- }
- }
- }
-
- switch(constantDescription.Class)
- {
- case D3DXPC_STRUCT:
- {
- for(unsigned int arrayIndex = 0; arrayIndex < constantDescription.Elements; arrayIndex++)
- {
- for(unsigned int field = 0; field < constantDescription.StructMembers; field++)
- {
- D3DXHANDLE fieldHandle = mConstantTablePS->GetConstant(constantHandle, field);
-
- D3DXCONSTANT_DESC fieldDescription;
- UINT descriptionCount = 1;
-
- HRESULT result = mConstantTablePS->GetConstantDesc(fieldHandle, &fieldDescription, &descriptionCount);
- ASSERT(SUCCEEDED(result));
-
- std::string structIndex = (constantDescription.Elements > 1) ? ("[" + str(arrayIndex) + "]") : "";
-
- if(!defineUniform(fieldHandle, fieldDescription, name + constantDescription.Name + structIndex + "."))
- {
- return false;
- }
- }
- }
-
- return true;
- }
- case D3DXPC_SCALAR:
- case D3DXPC_VECTOR:
- case D3DXPC_MATRIX_COLUMNS:
- case D3DXPC_OBJECT:
- return defineUniform(constantDescription, name + constantDescription.Name);
- default:
- UNREACHABLE();
- return false;
- }
-}
-
-bool Program::defineUniform(const D3DXCONSTANT_DESC &constantDescription, std::string &_name)
-{
- Uniform *uniform = createUniform(constantDescription, _name);
-
- if(!uniform)
- {
- return false;
- }
-
- // Check if already defined
- GLint location = getUniformLocation(uniform->name);
- GLenum type = uniform->type;
-
- if(location >= 0)
- {
- delete uniform;
-
- if(mUniforms[mUniformIndex[location].index]->type != type)
- {
- return false;
- }
- else
- {
- return true;
- }
- }
-
- mUniforms.push_back(uniform);
- unsigned int uniformIndex = mUniforms.size() - 1;
-
- for(unsigned int i = 0; i < uniform->arraySize; ++i)
- {
- mUniformIndex.push_back(UniformLocation(_name, i, uniformIndex));
- }
-
- return true;
-}
-
-Uniform *Program::createUniform(const D3DXCONSTANT_DESC &constantDescription, std::string &_name)
-{
- if(constantDescription.Rows == 1) // Vectors and scalars
- {
- switch (constantDescription.Type)
- {
- case D3DXPT_SAMPLER2D:
- switch (constantDescription.Columns)
- {
- case 1: return new Uniform(GL_SAMPLER_2D, _name, constantDescription.Elements);
- default: UNREACHABLE();
- }
- break;
- case D3DXPT_SAMPLERCUBE:
- switch (constantDescription.Columns)
- {
- case 1: return new Uniform(GL_SAMPLER_CUBE, _name, constantDescription.Elements);
- default: UNREACHABLE();
- }
- break;
- case D3DXPT_BOOL:
- switch (constantDescription.Columns)
- {
- case 1: return new Uniform(GL_BOOL, _name, constantDescription.Elements);
- case 2: return new Uniform(GL_BOOL_VEC2, _name, constantDescription.Elements);
- case 3: return new Uniform(GL_BOOL_VEC3, _name, constantDescription.Elements);
- case 4: return new Uniform(GL_BOOL_VEC4, _name, constantDescription.Elements);
- default: UNREACHABLE();
- }
- break;
- case D3DXPT_INT:
- switch (constantDescription.Columns)
- {
- case 1: return new Uniform(GL_INT, _name, constantDescription.Elements);
- case 2: return new Uniform(GL_INT_VEC2, _name, constantDescription.Elements);
- case 3: return new Uniform(GL_INT_VEC3, _name, constantDescription.Elements);
- case 4: return new Uniform(GL_INT_VEC4, _name, constantDescription.Elements);
- default: UNREACHABLE();
- }
- break;
- case D3DXPT_FLOAT:
- switch (constantDescription.Columns)
- {
- case 1: return new Uniform(GL_FLOAT, _name, constantDescription.Elements);
- case 2: return new Uniform(GL_FLOAT_VEC2, _name, constantDescription.Elements);
- case 3: return new Uniform(GL_FLOAT_VEC3, _name, constantDescription.Elements);
- case 4: return new Uniform(GL_FLOAT_VEC4, _name, constantDescription.Elements);
- default: UNREACHABLE();
- }
- break;
- default:
- UNREACHABLE();
- }
- }
- else if(constantDescription.Rows == constantDescription.Columns) // Square matrices
- {
- switch (constantDescription.Type)
- {
- case D3DXPT_FLOAT:
- switch (constantDescription.Rows)
- {
- case 2: return new Uniform(GL_FLOAT_MAT2, _name, constantDescription.Elements);
- case 3: return new Uniform(GL_FLOAT_MAT3, _name, constantDescription.Elements);
- case 4: return new Uniform(GL_FLOAT_MAT4, _name, constantDescription.Elements);
- default: UNREACHABLE();
- }
- break;
- default: UNREACHABLE();
- }
- }
- else UNREACHABLE();
-
- return 0;
-}
-
-// This method needs to match OutputHLSL::decorate
-std::string Program::decorateAttribute(const std::string &name)
-{
- if(name.compare(0, 3, "gl_") != 0 && name.compare(0, 3, "dx_") != 0)
- {
- return "_" + name;
- }
-
- return name;
-}
-
-std::string Program::undecorateUniform(const std::string &_name)
-{
- if(_name[0] == '_')
- {
- return _name.substr(1);
- }
- else if(_name.compare(0, 3, "ar_") == 0)
- {
- return _name.substr(3);
- }
-
- return _name;
-}
-
-bool Program::applyUniform1bv(GLint location, GLsizei count, const GLboolean *v)
-{
- float (*vector)[4] = new float[count][4];
-
- for(int i = 0; i < count; i++)
- {
- vector[i][0] = (v[0] == GL_FALSE ? 0.0f : 1.0f);
- vector[i][1] = 0;
- vector[i][2] = 0;
- vector[i][3] = 0;
-
- v += 1;
- }
-
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-
- D3DXHANDLE constantPS;
- D3DXHANDLE constantVS;
- getConstantHandles(targetUniform, &constantPS, &constantVS);
-
- Device *device = getDevice();
- D3DXCONSTANT_DESC constantDescription;
- UINT descriptionCount = 1;
-
- if(constantPS)
- {
- mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
-
- if(constantDescription.RegisterSet == D3DXRS_FLOAT4)
+ if(vertexShader)
{
- device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
+ vertexShader->release();
}
- else if(constantDescription.RegisterSet == D3DXRS_BOOL)
+
+ if(fragmentShader)
{
- device->setPixelShaderConstantB(constantDescription.RegisterIndex, (int*)vector, constantDescription.RegisterCount);
+ fragmentShader->release();
+ }
+ }
+
+ bool Program::attachShader(Shader *shader)
+ {
+ if(shader->getType() == GL_VERTEX_SHADER)
+ {
+ if(vertexShader)
+ {
+ return false;
+ }
+
+ vertexShader = (VertexShader*)shader;
+ vertexShader->addRef();
+ }
+ else if(shader->getType() == GL_FRAGMENT_SHADER)
+ {
+ if(fragmentShader)
+ {
+ return false;
+ }
+
+ fragmentShader = (FragmentShader*)shader;
+ fragmentShader->addRef();
}
else UNREACHABLE();
- }
- if(constantVS)
- {
- mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
-
- if(constantDescription.RegisterSet == D3DXRS_FLOAT4)
+ return true;
+ }
+
+ bool Program::detachShader(Shader *shader)
+ {
+ if(shader->getType() == GL_VERTEX_SHADER)
{
- device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
+ if(vertexShader != shader)
+ {
+ return false;
+ }
+
+ vertexShader->release();
+ vertexShader = 0;
}
- else if(constantDescription.RegisterSet == D3DXRS_BOOL)
+ else if(shader->getType() == GL_FRAGMENT_SHADER)
{
- device->setVertexShaderConstantB(constantDescription.RegisterIndex, (int*)vector, constantDescription.RegisterCount);
+ if(fragmentShader != shader)
+ {
+ return false;
+ }
+
+ fragmentShader->release();
+ fragmentShader = 0;
}
else UNREACHABLE();
- }
- delete [] vector;
+ return true;
+ }
- return true;
-}
+ int Program::getAttachedShadersCount() const
+ {
+ return (vertexShader ? 1 : 0) + (fragmentShader ? 1 : 0);
+ }
-bool Program::applyUniform2bv(GLint location, GLsizei count, const GLboolean *v)
-{
- float (*vector)[4] = new float[count][4];
+ sw::PixelShader *Program::getPixelShader()
+ {
+ return pixelBinary;
+ }
- for(int i = 0; i < count; i++)
- {
- vector[i][0] = (v[0] == GL_FALSE ? 0.0f : 1.0f);
- vector[i][1] = (v[1] == GL_FALSE ? 0.0f : 1.0f);
- vector[i][2] = 0;
- vector[i][3] = 0;
+ sw::VertexShader *Program::getVertexShader()
+ {
+ return vertexBinary;
+ }
- v += 2;
- }
+ void Program::bindAttributeLocation(GLuint index, const char *name)
+ {
+ if(index < MAX_VERTEX_ATTRIBS)
+ {
+ for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
+ {
+ attributeBinding[i].erase(name);
+ }
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+ attributeBinding[index].insert(name);
+ }
+ }
- D3DXHANDLE constantPS;
- D3DXHANDLE constantVS;
- getConstantHandles(targetUniform, &constantPS, &constantVS);
+ GLuint Program::getAttributeLocation(const char *name)
+ {
+ if(name)
+ {
+ for(int index = 0; index < MAX_VERTEX_ATTRIBS; index++)
+ {
+ if(linkedAttribute[index].name == std::string(name))
+ {
+ return index;
+ }
+ }
+ }
- Device *device = getDevice();
- D3DXCONSTANT_DESC constantDescription;
- UINT descriptionCount = 1;
+ return -1;
+ }
- if(constantPS)
- {
- mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
- ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
- device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
-
- if(constantVS)
- {
- mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
- ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
- device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
-
- delete[] vector;
-
- return true;
-}
-
-bool Program::applyUniform3bv(GLint location, GLsizei count, const GLboolean *v)
-{
- float (*vector)[4] = new float[count][4];
-
- for(int i = 0; i < count; i++)
- {
- vector[i][0] = (v[0] == GL_FALSE ? 0.0f : 1.0f);
- vector[i][1] = (v[1] == GL_FALSE ? 0.0f : 1.0f);
- vector[i][2] = (v[2] == GL_FALSE ? 0.0f : 1.0f);
- vector[i][3] = 0;
-
- v += 3;
- }
-
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-
- D3DXHANDLE constantPS;
- D3DXHANDLE constantVS;
- getConstantHandles(targetUniform, &constantPS, &constantVS);
+ int Program::getAttributeStream(int attributeIndex)
+ {
+ ASSERT(attributeIndex >= 0 && attributeIndex < MAX_VERTEX_ATTRIBS);
- Device *device = getDevice();
- D3DXCONSTANT_DESC constantDescription;
- UINT descriptionCount = 1;
+ return attributeStream[attributeIndex];
+ }
- if(constantPS)
- {
- mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
- ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
- device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
+ // Returns the index of the texture image unit (0-19) corresponding to a sampler index (0-15 for the pixel shader and 0-3 for the vertex shader)
+ GLint Program::getSamplerMapping(sw::SamplerType type, unsigned int samplerIndex)
+ {
+ GLuint logicalTextureUnit = -1;
- if(constantVS)
- {
- mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
- ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
- device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
+ switch(type)
+ {
+ case sw::SAMPLER_PIXEL:
+ ASSERT(samplerIndex < sizeof(samplersPS) / sizeof(samplersPS[0]));
- delete[] vector;
+ if(samplersPS[samplerIndex].active)
+ {
+ logicalTextureUnit = samplersPS[samplerIndex].logicalTextureUnit;
+ }
+ break;
+ case sw::SAMPLER_VERTEX:
+ ASSERT(samplerIndex < sizeof(samplersVS) / sizeof(samplersVS[0]));
- return true;
-}
+ if(samplersVS[samplerIndex].active)
+ {
+ logicalTextureUnit = samplersVS[samplerIndex].logicalTextureUnit;
+ }
+ break;
+ default: UNREACHABLE();
+ }
-bool Program::applyUniform4bv(GLint location, GLsizei count, const GLboolean *v)
-{
- float (*vector)[4] = new float[count][4];
+ if(logicalTextureUnit >= 0 && logicalTextureUnit < MAX_COMBINED_TEXTURE_IMAGE_UNITS)
+ {
+ return logicalTextureUnit;
+ }
- for(int i = 0; i < count; i++)
- {
- vector[i][0] = (v[0] == GL_FALSE ? 0.0f : 1.0f);
- vector[i][1] = (v[1] == GL_FALSE ? 0.0f : 1.0f);
- vector[i][2] = (v[2] == GL_FALSE ? 0.0f : 1.0f);
- vector[i][3] = (v[3] == GL_FALSE ? 0.0f : 1.0f);
+ return -1;
+ }
- v += 4;
- }
+ // Returns the texture type for a given sampler type and index (0-15 for the pixel shader and 0-3 for the vertex shader)
+ TextureType Program::getSamplerTextureType(sw::SamplerType type, unsigned int samplerIndex)
+ {
+ switch(type)
+ {
+ case sw::SAMPLER_PIXEL:
+ ASSERT(samplerIndex < sizeof(samplersPS)/sizeof(samplersPS[0]));
+ ASSERT(samplersPS[samplerIndex].active);
+ return samplersPS[samplerIndex].textureType;
+ case sw::SAMPLER_VERTEX:
+ ASSERT(samplerIndex < sizeof(samplersVS)/sizeof(samplersVS[0]));
+ ASSERT(samplersVS[samplerIndex].active);
+ return samplersVS[samplerIndex].textureType;
+ default: UNREACHABLE();
+ }
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+ return TEXTURE_2D;
+ }
- D3DXHANDLE constantPS;
- D3DXHANDLE constantVS;
- getConstantHandles(targetUniform, &constantPS, &constantVS);
-
- Device *device = getDevice();
- D3DXCONSTANT_DESC constantDescription;
- UINT descriptionCount = 1;
+ GLint Program::getUniformLocation(std::string name)
+ {
+ int subscript = 0;
- if(constantPS)
- {
- mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
- ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
- device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
+ // Strip any trailing array operator and retrieve the subscript
+ size_t open = name.find_last_of('[');
+ size_t close = name.find_last_of(']');
+ if(open != std::string::npos && close == name.length() - 1)
+ {
+ subscript = atoi(name.substr(open + 1).c_str());
+ name.erase(open);
+ }
- if(constantVS)
- {
- mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
- ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
- device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
+ unsigned int numUniforms = uniformIndex.size();
+ for(unsigned int location = 0; location < numUniforms; location++)
+ {
+ if(uniformIndex[location].name == name &&
+ uniformIndex[location].element == subscript)
+ {
+ return location;
+ }
+ }
- delete [] vector;
+ return -1;
+ }
- return true;
-}
+ bool Program::setUniform1fv(GLint location, GLsizei count, const GLfloat* v)
+ {
+ if(location < 0 || location >= (int)uniformIndex.size())
+ {
+ return false;
+ }
-bool Program::applyUniform1fv(GLint location, GLsizei count, const GLfloat *v)
-{
- float (*vector)[4] = new float[count][4];
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
+ targetUniform->dirty = true;
- for(int i = 0; i < count; i++)
- {
- vector[i][0] = v[0];
- vector[i][1] = 0;
- vector[i][2] = 0;
- vector[i][3] = 0;
+ int size = targetUniform->size();
- v += 1;
- }
+ if(size == 1 && count > 1)
+ {
+ return false; // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+ }
+
+ count = std::min(size - (int)uniformIndex[location].element, count);
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+ if(targetUniform->type == GL_FLOAT)
+ {
+ memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLfloat),
+ v, sizeof(GLfloat) * count);
+ }
+ else if(targetUniform->type == GL_BOOL)
+ {
+ GLboolean *boolParams = (GLboolean*)targetUniform->data + uniformIndex[location].element;
- D3DXHANDLE constantPS;
- D3DXHANDLE constantVS;
- getConstantHandles(targetUniform, &constantPS, &constantVS);
-
- Device *device = getDevice();
- D3DXCONSTANT_DESC constantDescription;
- UINT descriptionCount = 1;
+ for(int i = 0; i < count; i++)
+ {
+ if(v[i] == 0.0f)
+ {
+ boolParams[i] = GL_FALSE;
+ }
+ else
+ {
+ boolParams[i] = GL_TRUE;
+ }
+ }
+ }
+ else
+ {
+ return false;
+ }
- if(constantPS)
- {
- mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
- device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
+ return true;
+ }
- if(constantVS)
- {
- mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
- device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
+ bool Program::setUniform2fv(GLint location, GLsizei count, const GLfloat *v)
+ {
+ if(location < 0 || location >= (int)uniformIndex.size())
+ {
+ return false;
+ }
- delete[] vector;
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
+ targetUniform->dirty = true;
- return true;
-}
+ int size = targetUniform->size();
-bool Program::applyUniform2fv(GLint location, GLsizei count, const GLfloat *v)
-{
- float (*vector)[4] = new float[count][4];
+ if(size == 1 && count > 1)
+ {
+ return false; // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+ }
+
+ count = std::min(size - (int)uniformIndex[location].element, count);
- for(int i = 0; i < count; i++)
- {
- vector[i][0] = v[0];
- vector[i][1] = v[1];
- vector[i][2] = 0;
- vector[i][3] = 0;
+ if(targetUniform->type == GL_FLOAT_VEC2)
+ {
+ memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLfloat) * 2,
+ v, 2 * sizeof(GLfloat) * count);
+ }
+ else if(targetUniform->type == GL_BOOL_VEC2)
+ {
+ GLboolean *boolParams = (GLboolean*)targetUniform->data + uniformIndex[location].element * 2;
- v += 2;
- }
+ for(int i = 0; i < count * 2; i++)
+ {
+ if(v[i] == 0.0f)
+ {
+ boolParams[i] = GL_FALSE;
+ }
+ else
+ {
+ boolParams[i] = GL_TRUE;
+ }
+ }
+ }
+ else
+ {
+ return false;
+ }
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+ return true;
+ }
- D3DXHANDLE constantPS;
- D3DXHANDLE constantVS;
- getConstantHandles(targetUniform, &constantPS, &constantVS);
-
- Device *device = getDevice();
- D3DXCONSTANT_DESC constantDescription;
- UINT descriptionCount = 1;
+ bool Program::setUniform3fv(GLint location, GLsizei count, const GLfloat *v)
+ {
+ if(location < 0 || location >= (int)uniformIndex.size())
+ {
+ return false;
+ }
- if(constantPS)
- {
- mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
- device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
+ targetUniform->dirty = true;
- if(constantVS)
- {
- mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
- device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
+ int size = targetUniform->size();
- delete[] vector;
+ if(size == 1 && count > 1)
+ {
+ return false; // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+ }
+
+ count = std::min(size - (int)uniformIndex[location].element, count);
- return true;
-}
+ if(targetUniform->type == GL_FLOAT_VEC3)
+ {
+ memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLfloat) * 3,
+ v, 3 * sizeof(GLfloat) * count);
+ }
+ else if(targetUniform->type == GL_BOOL_VEC3)
+ {
+ GLboolean *boolParams = (GLboolean*)targetUniform->data + uniformIndex[location].element * 3;
-bool Program::applyUniform3fv(GLint location, GLsizei count, const GLfloat *v)
-{
- float (*vector)[4] = new float[count][4];
+ for(int i = 0; i < count * 3; i++)
+ {
+ if(v[i] == 0.0f)
+ {
+ boolParams[i] = GL_FALSE;
+ }
+ else
+ {
+ boolParams[i] = GL_TRUE;
+ }
+ }
+ }
+ else
+ {
+ return false;
+ }
- for(int i = 0; i < count; i++)
- {
- vector[i][0] = v[0];
- vector[i][1] = v[1];
- vector[i][2] = v[2];
- vector[i][3] = 0;
+ return true;
+ }
- v += 3;
- }
+ bool Program::setUniform4fv(GLint location, GLsizei count, const GLfloat *v)
+ {
+ if(location < 0 || location >= (int)uniformIndex.size())
+ {
+ return false;
+ }
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
+ targetUniform->dirty = true;
- D3DXHANDLE constantPS;
- D3DXHANDLE constantVS;
- getConstantHandles(targetUniform, &constantPS, &constantVS);
-
- Device *device = getDevice();
- D3DXCONSTANT_DESC constantDescription;
- UINT descriptionCount = 1;
+ int size = targetUniform->size();
+
+ if(size == 1 && count > 1)
+ {
+ return false; // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+ }
+
+ count = std::min(size - (int)uniformIndex[location].element, count);
+
+ if(targetUniform->type == GL_FLOAT_VEC4)
+ {
+ memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLfloat) * 4,
+ v, 4 * sizeof(GLfloat) * count);
+ }
+ else if(targetUniform->type == GL_BOOL_VEC4)
+ {
+ GLboolean *boolParams = (GLboolean*)targetUniform->data + uniformIndex[location].element * 4;
+
+ for(int i = 0; i < count * 4; i++)
+ {
+ if(v[i] == 0.0f)
+ {
+ boolParams[i] = GL_FALSE;
+ }
+ else
+ {
+ boolParams[i] = GL_TRUE;
+ }
+ }
+ }
+ else
+ {
+ return false;
+ }
+
+ return true;
+ }
+
+ bool Program::setUniformMatrix2fv(GLint location, GLsizei count, const GLfloat *value)
+ {
+ if(location < 0 || location >= (int)uniformIndex.size())
+ {
+ return false;
+ }
+
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
+ targetUniform->dirty = true;
+
+ if(targetUniform->type != GL_FLOAT_MAT2)
+ {
+ return false;
+ }
+
+ int size = targetUniform->size();
+
+ if(size == 1 && count > 1)
+ {
+ return false; // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+ }
+
+ count = std::min(size - (int)uniformIndex[location].element, count);
+
+ memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLfloat) * 4,
+ value, 4 * sizeof(GLfloat) * count);
+
+ return true;
+ }
+
+ bool Program::setUniformMatrix3fv(GLint location, GLsizei count, const GLfloat *value)
+ {
+ if(location < 0 || location >= (int)uniformIndex.size())
+ {
+ return false;
+ }
+
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
+ targetUniform->dirty = true;
+
+ if(targetUniform->type != GL_FLOAT_MAT3)
+ {
+ return false;
+ }
+
+ int size = targetUniform->size();
+
+ if(size == 1 && count > 1)
+ {
+ return false; // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+ }
+
+ count = std::min(size - (int)uniformIndex[location].element, count);
+
+ memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLfloat) * 9,
+ value, 9 * sizeof(GLfloat) * count);
+
+ return true;
+ }
+
+ bool Program::setUniformMatrix4fv(GLint location, GLsizei count, const GLfloat *value)
+ {
+ if(location < 0 || location >= (int)uniformIndex.size())
+ {
+ return false;
+ }
+
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
+ targetUniform->dirty = true;
+
+ if(targetUniform->type != GL_FLOAT_MAT4)
+ {
+ return false;
+ }
+
+ int size = targetUniform->size();
+
+ if(size == 1 && count > 1)
+ {
+ return false; // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+ }
+
+ count = std::min(size - (int)uniformIndex[location].element, count);
+
+ memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLfloat) * 16,
+ value, 16 * sizeof(GLfloat) * count);
+
+ return true;
+ }
+
+ bool Program::setUniform1iv(GLint location, GLsizei count, const GLint *v)
+ {
+ if(location < 0 || location >= (int)uniformIndex.size())
+ {
+ return false;
+ }
+
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
+ targetUniform->dirty = true;
+
+ int size = targetUniform->size();
+
+ if(size == 1 && count > 1)
+ {
+ return false; // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+ }
+
+ count = std::min(size - (int)uniformIndex[location].element, count);
+
+ if(targetUniform->type == GL_INT ||
+ targetUniform->type == GL_SAMPLER_2D ||
+ targetUniform->type == GL_SAMPLER_CUBE)
+ {
+ memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLint),
+ v, sizeof(GLint) * count);
+ }
+ else if(targetUniform->type == GL_BOOL)
+ {
+ GLboolean *boolParams = new GLboolean[count];
+
+ for(int i = 0; i < count; i++)
+ {
+ if(v[i] == 0)
+ {
+ boolParams[i] = GL_FALSE;
+ }
+ else
+ {
+ boolParams[i] = GL_TRUE;
+ }
+ }
+
+ memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLboolean),
+ boolParams, sizeof(GLboolean) * count);
+
+ delete[] boolParams;
+ }
+ else
+ {
+ return false;
+ }
+
+ return true;
+ }
+
+ bool Program::setUniform2iv(GLint location, GLsizei count, const GLint *v)
+ {
+ if(location < 0 || location >= (int)uniformIndex.size())
+ {
+ return false;
+ }
+
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
+ targetUniform->dirty = true;
+
+ int size = targetUniform->size();
+
+ if(size == 1 && count > 1)
+ {
+ return false; // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+ }
+
+ count = std::min(size - (int)uniformIndex[location].element, count);
+
+ if(targetUniform->type == GL_INT_VEC2)
+ {
+ memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLint) * 2,
+ v, 2 * sizeof(GLint) * count);
+ }
+ else if(targetUniform->type == GL_BOOL_VEC2)
+ {
+ GLboolean *boolParams = new GLboolean[count * 2];
+
+ for(int i = 0; i < count * 2; i++)
+ {
+ if(v[i] == 0)
+ {
+ boolParams[i] = GL_FALSE;
+ }
+ else
+ {
+ boolParams[i] = GL_TRUE;
+ }
+ }
+
+ memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLboolean) * 2,
+ boolParams, 2 * sizeof(GLboolean) * count);
+
+ delete[] boolParams;
+ }
+ else
+ {
+ return false;
+ }
+
+ return true;
+ }
+
+ bool Program::setUniform3iv(GLint location, GLsizei count, const GLint *v)
+ {
+ if(location < 0 || location >= (int)uniformIndex.size())
+ {
+ return false;
+ }
+
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
+ targetUniform->dirty = true;
+
+ int size = targetUniform->size();
+
+ if(size == 1 && count > 1)
+ {
+ return false; // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+ }
+
+ count = std::min(size - (int)uniformIndex[location].element, count);
+
+ if(targetUniform->type == GL_INT_VEC3)
+ {
+ memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLint) * 3,
+ v, 3 * sizeof(GLint) * count);
+ }
+ else if(targetUniform->type == GL_BOOL_VEC3)
+ {
+ GLboolean *boolParams = new GLboolean[count * 3];
+
+ for(int i = 0; i < count * 3; i++)
+ {
+ if(v[i] == 0)
+ {
+ boolParams[i] = GL_FALSE;
+ }
+ else
+ {
+ boolParams[i] = GL_TRUE;
+ }
+ }
+
+ memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLboolean) * 3,
+ boolParams, 3 * sizeof(GLboolean) * count);
+
+ delete[] boolParams;
+ }
+ else
+ {
+ return false;
+ }
+
+ return true;
+ }
+
+ bool Program::setUniform4iv(GLint location, GLsizei count, const GLint *v)
+ {
+ if(location < 0 || location >= (int)uniformIndex.size())
+ {
+ return false;
+ }
+
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
+ targetUniform->dirty = true;
+
+ int size = targetUniform->size();
+
+ if(size == 1 && count > 1)
+ {
+ return false; // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+ }
+
+ count = std::min(size - (int)uniformIndex[location].element, count);
+
+ if(targetUniform->type == GL_INT_VEC4)
+ {
+ memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLint) * 4,
+ v, 4 * sizeof(GLint) * count);
+ }
+ else if(targetUniform->type == GL_BOOL_VEC4)
+ {
+ GLboolean *boolParams = new GLboolean[count * 4];
+
+ for(int i = 0; i < count * 4; i++)
+ {
+ if(v[i] == 0)
+ {
+ boolParams[i] = GL_FALSE;
+ }
+ else
+ {
+ boolParams[i] = GL_TRUE;
+ }
+ }
+
+ memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLboolean) * 4,
+ boolParams, 4 * sizeof(GLboolean) * count);
+
+ delete[] boolParams;
+ }
+ else
+ {
+ return false;
+ }
+
+ return true;
+ }
+
+ bool Program::getUniformfv(GLint location, GLsizei *bufSize, GLfloat *params)
+ {
+ if(location < 0 || location >= (int)uniformIndex.size())
+ {
+ return false;
+ }
+
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
+ unsigned int count = UniformComponentCount(targetUniform->type);
+
+ // Sized query - ensure the provided buffer is large enough
+ if(bufSize && *bufSize < count * sizeof(GLfloat))
+ {
+ return false;
+ }
+
+ switch (UniformComponentType(targetUniform->type))
+ {
+ case GL_BOOL:
+ {
+ GLboolean *boolParams = (GLboolean*)targetUniform->data + uniformIndex[location].element * count;
+
+ for(unsigned int i = 0; i < count; i++)
+ {
+ params[i] = (boolParams[i] == GL_FALSE) ? 0.0f : 1.0f;
+ }
+ }
+ break;
+ case GL_FLOAT:
+ memcpy(params, targetUniform->data + uniformIndex[location].element * count * sizeof(GLfloat),
+ count * sizeof(GLfloat));
+ break;
+ case GL_INT:
+ {
+ GLint *intParams = (GLint*)targetUniform->data + uniformIndex[location].element * count;
+
+ for(unsigned int i = 0; i < count; i++)
+ {
+ params[i] = (float)intParams[i];
+ }
+ }
+ break;
+ default: UNREACHABLE();
+ }
+
+ return true;
+ }
+
+ bool Program::getUniformiv(GLint location, GLsizei *bufSize, GLint *params)
+ {
+ if(location < 0 || location >= (int)uniformIndex.size())
+ {
+ return false;
+ }
+
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
+ unsigned int count = UniformComponentCount(targetUniform->type);
+
+ // Sized query - ensure the provided buffer is large enough
+ if(bufSize && *bufSize < count * sizeof(GLint))
+ {
+ return false;
+ }
+
+ switch (UniformComponentType(targetUniform->type))
+ {
+ case GL_BOOL:
+ {
+ GLboolean *boolParams = targetUniform->data + uniformIndex[location].element * count;
+
+ for(unsigned int i = 0; i < count; i++)
+ {
+ params[i] = (GLint)boolParams[i];
+ }
+ }
+ break;
+ case GL_FLOAT:
+ {
+ GLfloat *floatParams = (GLfloat*)targetUniform->data + uniformIndex[location].element * count;
+
+ for(unsigned int i = 0; i < count; i++)
+ {
+ params[i] = (GLint)floatParams[i];
+ }
+ }
+ break;
+ case GL_INT:
+ memcpy(params, targetUniform->data + uniformIndex[location].element * count * sizeof(GLint),
+ count * sizeof(GLint));
+ break;
+ default: UNREACHABLE();
+ }
+
+ return true;
+ }
+
+ void Program::dirtyAllUniforms()
+ {
+ unsigned int numUniforms = uniforms.size();
+ for(unsigned int index = 0; index < numUniforms; index++)
+ {
+ uniforms[index]->dirty = true;
+ }
+ }
+
+ // Applies all the uniforms set for this program object to the device
+ void Program::applyUniforms()
+ {
+ unsigned int numUniforms = uniformIndex.size();
+ for(unsigned int location = 0; location < numUniforms; location++)
+ {
+ if(uniformIndex[location].element != 0)
+ {
+ continue;
+ }
+
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
+
+ if(targetUniform->dirty)
+ {
+ int size = targetUniform->size();
+ GLfloat *f = (GLfloat*)targetUniform->data;
+ GLint *i = (GLint*)targetUniform->data;
+ GLboolean *b = (GLboolean*)targetUniform->data;
+
+ switch(targetUniform->type)
+ {
+ case GL_BOOL: applyUniform1bv(location, size, b); break;
+ case GL_BOOL_VEC2: applyUniform2bv(location, size, b); break;
+ case GL_BOOL_VEC3: applyUniform3bv(location, size, b); break;
+ case GL_BOOL_VEC4: applyUniform4bv(location, size, b); break;
+ case GL_FLOAT: applyUniform1fv(location, size, f); break;
+ case GL_FLOAT_VEC2: applyUniform2fv(location, size, f); break;
+ case GL_FLOAT_VEC3: applyUniform3fv(location, size, f); break;
+ case GL_FLOAT_VEC4: applyUniform4fv(location, size, f); break;
+ case GL_FLOAT_MAT2: applyUniformMatrix2fv(location, size, f); break;
+ case GL_FLOAT_MAT3: applyUniformMatrix3fv(location, size, f); break;
+ case GL_FLOAT_MAT4: applyUniformMatrix4fv(location, size, f); break;
+ case GL_SAMPLER_2D:
+ case GL_SAMPLER_CUBE:
+ case GL_INT: applyUniform1iv(location, size, i); break;
+ case GL_INT_VEC2: applyUniform2iv(location, size, i); break;
+ case GL_INT_VEC3: applyUniform3iv(location, size, i); break;
+ case GL_INT_VEC4: applyUniform4iv(location, size, i); break;
+ default:
+ UNREACHABLE();
+ }
+
+ targetUniform->dirty = false;
+ }
+ }
+ }
+
+ // Packs varyings into generic varying registers, using the algorithm from [OpenGL ES Shading Language 1.00 rev. 17] appendix A section 7 page 111
+ // Returns the number of used varying registers, or -1 if unsuccesful
+ int Program::packVaryings(const Varying *packing[][4])
+ {
+ Context *context = getContext();
+
+ for(VaryingList::iterator varying = fragmentShader->varyings.begin(); varying != fragmentShader->varyings.end(); varying++)
+ {
+ int n = VariableRowCount(varying->type) * varying->size();
+ int m = VariableColumnCount(varying->type);
+ bool success = false;
+
+ if(m == 2 || m == 3 || m == 4)
+ {
+ for(int r = 0; r <= MAX_VARYING_VECTORS - n && !success; r++)
+ {
+ bool available = true;
+
+ for(int y = 0; y < n && available; y++)
+ {
+ for(int x = 0; x < m && available; x++)
+ {
+ if(packing[r + y][x])
+ {
+ available = false;
+ }
+ }
+ }
+
+ if(available)
+ {
+ varying->reg = r;
+ varying->col = 0;
+
+ for(int y = 0; y < n; y++)
+ {
+ for(int x = 0; x < m; x++)
+ {
+ packing[r + y][x] = &*varying;
+ }
+ }
+
+ success = true;
+ }
+ }
+
+ if(!success && m == 2)
+ {
+ for(int r = MAX_VARYING_VECTORS - n; r >= 0 && !success; r--)
+ {
+ bool available = true;
+
+ for(int y = 0; y < n && available; y++)
+ {
+ for(int x = 2; x < 4 && available; x++)
+ {
+ if(packing[r + y][x])
+ {
+ available = false;
+ }
+ }
+ }
+
+ if(available)
+ {
+ varying->reg = r;
+ varying->col = 2;
+
+ for(int y = 0; y < n; y++)
+ {
+ for(int x = 2; x < 4; x++)
+ {
+ packing[r + y][x] = &*varying;
+ }
+ }
+
+ success = true;
+ }
+ }
+ }
+ }
+ else if(m == 1)
+ {
+ int space[4] = {0};
+
+ for(int y = 0; y < MAX_VARYING_VECTORS; y++)
+ {
+ for(int x = 0; x < 4; x++)
+ {
+ space[x] += packing[y][x] ? 0 : 1;
+ }
+ }
+
+ int column = 0;
+
+ for(int x = 0; x < 4; x++)
+ {
+ if(space[x] >= n && space[x] < space[column])
+ {
+ column = x;
+ }
+ }
+
+ if(space[column] >= n)
+ {
+ for(int r = 0; r < MAX_VARYING_VECTORS; r++)
+ {
+ if(!packing[r][column])
+ {
+ varying->reg = r;
+
+ for(int y = r; y < r + n; y++)
+ {
+ packing[y][column] = &*varying;
+ }
+
+ break;
+ }
+ }
+
+ varying->col = column;
+
+ success = true;
+ }
+ }
+ else UNREACHABLE();
+
+ if(!success)
+ {
+ appendToInfoLog("Could not pack varying %s", varying->name.c_str());
+
+ return -1;
+ }
+ }
+
+ // Return the number of used registers
+ int registers = 0;
+
+ for(int r = 0; r < MAX_VARYING_VECTORS; r++)
+ {
+ if(packing[r][0] || packing[r][1] || packing[r][2] || packing[r][3])
+ {
+ registers++;
+ }
+ }
+
+ return registers;
+ }
+
+ bool Program::linkVaryings()
+ {
+ Context *context = getContext();
+
+ for(VaryingList::iterator input = fragmentShader->varyings.begin(); input != fragmentShader->varyings.end(); input++)
+ {
+ bool matched = false;
+
+ for(VaryingList::iterator output = vertexShader->varyings.begin(); output != vertexShader->varyings.end(); output++)
+ {
+ if(output->name == input->name)
+ {
+ if(output->type != input->type || output->size() != input->size())
+ {
+ appendToInfoLog("Type of vertex varying %s does not match that of the fragment varying", output->name.c_str());
+
+ return false;
+ }
+
+ matched = true;
+ break;
+ }
+ }
+
+ if(!matched)
+ {
+ appendToInfoLog("Fragment varying %s does not match any vertex varying", input->name.c_str());
+
+ return false;
+ }
+ }
+
+ VaryingList &psVaryings = fragmentShader->varyings;
+ VaryingList &vsVaryings = vertexShader->varyings;
+
+ for(VaryingList::iterator output = vsVaryings.begin(); output != vsVaryings.end(); output++)
+ {
+ for(VaryingList::iterator input = psVaryings.begin(); input != psVaryings.end(); input++)
+ {
+ if(output->name == input->name)
+ {
+ int in = input->reg;
+ int out = output->reg;
+ int components = VariableColumnCount(output->type);
+ int registers = VariableRowCount(output->type) * output->size();
+
+ ASSERT(in >= 0 && out >= 0);
+
+ for(int i = 0; i < registers; i++)
+ {
+ if(components >= 1) vertexBinary->output[out + i][0] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, in + i);
+ if(components >= 2) vertexBinary->output[out + i][1] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, in + i);
+ if(components >= 3) vertexBinary->output[out + i][2] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, in + i);
+ if(components >= 4) vertexBinary->output[out + i][3] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, in + i);
+ }
+
+ break;
+ }
+ }
+ }
+
+ return true;
+ }
+
+ // Links the code of the vertex and pixel shader by matching up their varyings,
+ // compiling them into binaries, determining the attribute mappings, and collecting
+ // a list of uniforms
+ void Program::link()
+ {
+ unlink();
+
+ if(!fragmentShader || !fragmentShader->isCompiled())
+ {
+ return;
+ }
+
+ if(!vertexShader || !vertexShader->isCompiled())
+ {
+ return;
+ }
+
+ vertexBinary = new sw::VertexShader(vertexShader->getVertexShader());
+ pixelBinary = new sw::PixelShader(fragmentShader->getPixelShader());
+
+ if(!linkVaryings())
+ {
+ return;
+ }
+
+ if(!linkAttributes())
+ {
+ return;
+ }
+
+ if(!linkUniforms(fragmentShader))
+ {
+ return;
+ }
+
+ if(!linkUniforms(vertexShader))
+ {
+ return;
+ }
+
+ linked = true; // Success
+ }
+
+ // Determines the mapping between GL attributes and vertex stream usage indices
+ bool Program::linkAttributes()
+ {
+ unsigned int usedLocations = 0;
+
+ // Link attributes that have a binding location
+ for(sh::ActiveAttributes::iterator attribute = vertexShader->activeAttributes.begin(); attribute != vertexShader->activeAttributes.end(); attribute++)
+ {
+ int location = getAttributeBinding(attribute->name);
+
+ if(location != -1) // Set by glBindAttribLocation
+ {
+ if(!linkedAttribute[location].name.empty())
+ {
+ // Multiple active attributes bound to the same location; not an error
+ }
+
+ linkedAttribute[location] = *attribute;
+
+ int rows = VariableRowCount(attribute->type);
+
+ if(rows + location > MAX_VERTEX_ATTRIBS)
+ {
+ appendToInfoLog("Active attribute (%s) at location %d is too big to fit", attribute->name.c_str(), location);
+
+ return false;
+ }
+
+ for(int i = 0; i < rows; i++)
+ {
+ usedLocations |= 1 << (location + i);
+ }
+ }
+ }
+
+ // Link attributes that don't have a binding location
+ for(sh::ActiveAttributes::iterator attribute = vertexShader->activeAttributes.begin(); attribute != vertexShader->activeAttributes.end(); attribute++)
+ {
+ int location = getAttributeBinding(attribute->name);
+
+ if(location == -1) // Not set by glBindAttribLocation
+ {
+ int rows = VariableRowCount(attribute->type);
+ int availableIndex = AllocateFirstFreeBits(&usedLocations, rows, MAX_VERTEX_ATTRIBS);
+
+ if(availableIndex == -1 || availableIndex + rows > MAX_VERTEX_ATTRIBS)
+ {
+ appendToInfoLog("Too many active attributes (%s)", attribute->name.c_str());
+
+ return false; // Fail to link
+ }
+
+ linkedAttribute[availableIndex] = *attribute;
+ }
+ }
+
+ for(int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; )
+ {
+ int index = vertexShader->getSemanticIndex(linkedAttribute[attributeIndex].name);
+ int rows = std::max(VariableRowCount(linkedAttribute[attributeIndex].type), 1);
+
+ for(int r = 0; r < rows; r++)
+ {
+ attributeStream[attributeIndex++] = index++;
+ }
+ }
+
+ return true;
+ }
+
+ int Program::getAttributeBinding(const std::string &name)
+ {
+ for(int location = 0; location < MAX_VERTEX_ATTRIBS; location++)
+ {
+ if(attributeBinding[location].find(name) != attributeBinding[location].end())
+ {
+ return location;
+ }
+ }
+
+ return -1;
+ }
+
+ bool Program::linkUniforms(Shader *shader)
+ {
+ const sh::ActiveUniforms &activeUniforms = shader->activeUniforms;
+
+ for(unsigned int uniformIndex = 0; uniformIndex < activeUniforms.size(); uniformIndex++)
+ {
+ const sh::Uniform &uniform = activeUniforms[uniformIndex];
+
+ if(!defineUniform(shader->getType(), uniform.type, uniform.name, uniform.arraySize, uniform.registerIndex))
+ {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ bool Program::defineUniform(GLenum shader, GLenum type, const std::string &name, unsigned int arraySize, int registerIndex)
+ {
+ if(type == GL_SAMPLER_2D || type == GL_SAMPLER_CUBE)
+ {
+ int index = registerIndex;
+
+ do
+ {
+ if(shader == GL_VERTEX_SHADER)
+ {
+ if(index < MAX_VERTEX_TEXTURE_IMAGE_UNITS)
+ {
+ samplersVS[index].active = true;
+ samplersVS[index].textureType = (type == GL_SAMPLER_CUBE) ? TEXTURE_CUBE : TEXTURE_2D;
+ samplersVS[index].logicalTextureUnit = 0;
+ }
+ else
+ {
+ appendToInfoLog("Vertex shader sampler count exceeds MAX_VERTEX_TEXTURE_IMAGE_UNITS (%d).", MAX_VERTEX_TEXTURE_IMAGE_UNITS);
+ return false;
+ }
+ }
+ else if(shader == GL_FRAGMENT_SHADER)
+ {
+ if(index < MAX_TEXTURE_IMAGE_UNITS)
+ {
+ samplersPS[index].active = true;
+ samplersPS[index].textureType = (type == GL_SAMPLER_CUBE) ? TEXTURE_CUBE : TEXTURE_2D;
+ samplersPS[index].logicalTextureUnit = 0;
+ }
+ else
+ {
+ appendToInfoLog("Pixel shader sampler count exceeds MAX_TEXTURE_IMAGE_UNITS (%d).", MAX_TEXTURE_IMAGE_UNITS);
+ return false;
+ }
+ }
+ else UNREACHABLE();
+
+ index++;
+ }
+ while(index < registerIndex + arraySize);
+ }
+
+ Uniform *uniform = 0;
+ GLint location = getUniformLocation(name);
+
+ if(location >= 0) // Previously defined, types must match
+ {
+ uniform = uniforms[uniformIndex[location].index];
+
+ if(uniform->type != type)
+ {
+ return false;
+ }
+ }
+ else
+ {
+ uniform = new Uniform(type, name, arraySize);
+ }
+
+ if(!uniform)
+ {
+ return false;
+ }
+
+ if(shader == GL_VERTEX_SHADER)
+ {
+ uniform->vsRegisterIndex = registerIndex;
+ }
+ else if(shader == GL_FRAGMENT_SHADER)
+ {
+ uniform->psRegisterIndex = registerIndex;
+ }
+ else UNREACHABLE();
+
+ if(location == -1) // Not previously defined
+ {
+ uniforms.push_back(uniform);
+ unsigned int index = uniforms.size() - 1;
+
+ for(unsigned int i = 0; i < uniform->size(); i++)
+ {
+ uniformIndex.push_back(UniformLocation(name, i, index));
+ }
+ }
+
+ return true;
+ }
+
+ bool Program::applyUniform1bv(GLint location, GLsizei count, const GLboolean *v)
+ {
+ int vector[MAX_UNIFORM_VECTORS][4];
+
+ for(int i = 0; i < count; i++)
+ {
+ vector[i][0] = (v[0] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+ vector[i][1] = 0;
+ vector[i][2] = 0;
+ vector[i][3] = 0;
+
+ v += 1;
+ }
+
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
+
+ if(targetUniform->psRegisterIndex != -1)
+ {
+ device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- if(constantPS)
- {
- mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
- device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
+ if(targetUniform->vsRegisterIndex != -1)
+ {
+ device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- if(constantVS)
- {
- mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
- device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
+ return true;
+ }
- delete[] vector;
+ bool Program::applyUniform2bv(GLint location, GLsizei count, const GLboolean *v)
+ {
+ int vector[MAX_UNIFORM_VECTORS][4];
- return true;
-}
+ for(int i = 0; i < count; i++)
+ {
+ vector[i][0] = (v[0] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+ vector[i][1] = (v[1] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+ vector[i][2] = 0;
+ vector[i][3] = 0;
-bool Program::applyUniform4fv(GLint location, GLsizei count, const GLfloat *v)
-{
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+ v += 2;
+ }
- D3DXHANDLE constantPS;
- D3DXHANDLE constantVS;
- getConstantHandles(targetUniform, &constantPS, &constantVS);
-
- Device *device = getDevice();
- D3DXCONSTANT_DESC constantDescription;
- UINT descriptionCount = 1;
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
- if(constantPS)
- {
- mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
- device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)v, constantDescription.RegisterCount);
- }
+ if(targetUniform->psRegisterIndex != -1)
+ {
+ device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- if(constantVS)
- {
- mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
- device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)v, constantDescription.RegisterCount);
- }
+ if(targetUniform->vsRegisterIndex != -1)
+ {
+ device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- return true;
-}
+ return true;
+ }
-bool Program::applyUniformMatrix2fv(GLint location, GLsizei count, const GLfloat *value)
-{
- float (*matrix)[2][4] = new float[count][2][4];
+ bool Program::applyUniform3bv(GLint location, GLsizei count, const GLboolean *v)
+ {
+ int vector[MAX_UNIFORM_VECTORS][4];
- for(int i = 0; i < count; i++)
- {
- matrix[i][0][0] = value[0]; matrix[i][0][1] = value[2]; matrix[i][0][2] = 0; matrix[i][0][3] = 0;
- matrix[i][1][0] = value[1]; matrix[i][1][1] = value[3]; matrix[i][1][2] = 0; matrix[i][1][3] = 0;
+ for(int i = 0; i < count; i++)
+ {
+ vector[i][0] = (v[0] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+ vector[i][1] = (v[1] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+ vector[i][2] = (v[2] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+ vector[i][3] = 0;
- value += 4;
- }
+ v += 3;
+ }
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
- D3DXHANDLE constantPS;
- D3DXHANDLE constantVS;
- getConstantHandles(targetUniform, &constantPS, &constantVS);
-
- Device *device = getDevice();
- D3DXCONSTANT_DESC constantDescription;
- UINT descriptionCount = 1;
+ if(targetUniform->psRegisterIndex != -1)
+ {
+ device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- if(constantPS)
- {
- mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
- device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)matrix, constantDescription.RegisterCount);
- }
+ if(targetUniform->vsRegisterIndex != -1)
+ {
+ device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- if(constantVS)
- {
- mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
- device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)matrix, constantDescription.RegisterCount);
- }
+ return true;
+ }
- delete[] matrix;
+ bool Program::applyUniform4bv(GLint location, GLsizei count, const GLboolean *v)
+ {
+ int vector[MAX_UNIFORM_VECTORS][4];
- return true;
-}
+ for(int i = 0; i < count; i++)
+ {
+ vector[i][0] = (v[0] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+ vector[i][1] = (v[1] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+ vector[i][2] = (v[2] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+ vector[i][3] = (v[3] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
-bool Program::applyUniformMatrix3fv(GLint location, GLsizei count, const GLfloat *value)
-{
- float (*matrix)[3][4] = new float[count][3][4];
+ v += 4;
+ }
- for(int i = 0; i < count; i++)
- {
- matrix[i][0][0] = value[0]; matrix[i][0][1] = value[3]; matrix[i][0][2] = value[6]; matrix[i][0][3] = 0;
- matrix[i][1][0] = value[1]; matrix[i][1][1] = value[4]; matrix[i][1][2] = value[7]; matrix[i][1][3] = 0;
- matrix[i][2][0] = value[2]; matrix[i][2][1] = value[5]; matrix[i][2][2] = value[8]; matrix[i][2][3] = 0;
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
- value += 9;
- }
+ if(targetUniform->psRegisterIndex != -1)
+ {
+ device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+ if(targetUniform->vsRegisterIndex != -1)
+ {
+ device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- D3DXHANDLE constantPS;
- D3DXHANDLE constantVS;
- getConstantHandles(targetUniform, &constantPS, &constantVS);
-
- Device *device = getDevice();
- D3DXCONSTANT_DESC constantDescription;
- UINT descriptionCount = 1;
+ return true;
+ }
- if(constantPS)
- {
- mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
- device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)matrix, constantDescription.RegisterCount);
- }
+ bool Program::applyUniform1fv(GLint location, GLsizei count, const GLfloat *v)
+ {
+ float vector[MAX_UNIFORM_VECTORS][4];
- if(constantVS)
- {
- mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
- device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)matrix, constantDescription.RegisterCount);
- }
+ for(int i = 0; i < count; i++)
+ {
+ vector[i][0] = v[0];
+ vector[i][1] = 0;
+ vector[i][2] = 0;
+ vector[i][3] = 0;
- delete[] matrix;
+ v += 1;
+ }
- return true;
-}
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
-bool Program::applyUniformMatrix4fv(GLint location, GLsizei count, const GLfloat *value)
-{
- float (*matrix)[4][4] = new float[count][4][4];
+ if(targetUniform->psRegisterIndex != -1)
+ {
+ device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- for(int i = 0; i < count; i++)
- {
- matrix[i][0][0] = value[0]; matrix[i][0][1] = value[4]; matrix[i][0][2] = value[8]; matrix[i][0][3] = value[12];
- matrix[i][1][0] = value[1]; matrix[i][1][1] = value[5]; matrix[i][1][2] = value[9]; matrix[i][1][3] = value[13];
- matrix[i][2][0] = value[2]; matrix[i][2][1] = value[6]; matrix[i][2][2] = value[10]; matrix[i][2][3] = value[14];
- matrix[i][3][0] = value[3]; matrix[i][3][1] = value[7]; matrix[i][3][2] = value[11]; matrix[i][3][3] = value[15];
+ if(targetUniform->vsRegisterIndex != -1)
+ {
+ device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- value += 16;
- }
+ return true;
+ }
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+ bool Program::applyUniform2fv(GLint location, GLsizei count, const GLfloat *v)
+ {
+ float vector[MAX_UNIFORM_VECTORS][4];
- D3DXHANDLE constantPS;
- D3DXHANDLE constantVS;
- getConstantHandles(targetUniform, &constantPS, &constantVS);
-
- Device *device = getDevice();
- D3DXCONSTANT_DESC constantDescription;
- UINT descriptionCount = 1;
+ for(int i = 0; i < count; i++)
+ {
+ vector[i][0] = v[0];
+ vector[i][1] = v[1];
+ vector[i][2] = 0;
+ vector[i][3] = 0;
- if(constantPS)
- {
- mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
- device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)matrix, constantDescription.RegisterCount);
- }
+ v += 2;
+ }
- if(constantVS)
- {
- mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
- device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)matrix, constantDescription.RegisterCount);
- }
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
- delete[] matrix;
+ if(targetUniform->psRegisterIndex != -1)
+ {
+ device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- return true;
-}
+ if(targetUniform->vsRegisterIndex != -1)
+ {
+ device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
-bool Program::applyUniform1iv(GLint location, GLsizei count, const GLint *v)
-{
- float (*vector)[4] = new float[count][4];
+ return true;
+ }
- for(int i = 0; i < count; i++)
- {
- vector[i][0] = (float)v[i];
- vector[i][1] = 0;
- vector[i][2] = 0;
- vector[i][3] = 0;
- }
+ bool Program::applyUniform3fv(GLint location, GLsizei count, const GLfloat *v)
+ {
+ float vector[MAX_UNIFORM_VECTORS][4];
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+ for(int i = 0; i < count; i++)
+ {
+ vector[i][0] = v[0];
+ vector[i][1] = v[1];
+ vector[i][2] = v[2];
+ vector[i][3] = 0;
- D3DXHANDLE constantPS;
- D3DXHANDLE constantVS;
- getConstantHandles(targetUniform, &constantPS, &constantVS);
- Device *device = getDevice();
+ v += 3;
+ }
- if(constantPS)
- {
- D3DXCONSTANT_DESC constantDescription;
- UINT descriptionCount = 1;
- HRESULT result = mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
- ASSERT(SUCCEEDED(result));
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
- if(constantDescription.RegisterSet == D3DXRS_SAMPLER)
- {
- unsigned int firstIndex = mConstantTablePS->GetSamplerIndex(constantPS);
+ if(targetUniform->psRegisterIndex != -1)
+ {
+ device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- for(int i = 0; i < count; i++)
- {
- unsigned int samplerIndex = firstIndex + i;
+ if(targetUniform->vsRegisterIndex != -1)
+ {
+ device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- if(samplerIndex < MAX_TEXTURE_IMAGE_UNITS)
- {
- ASSERT(mSamplersPS[samplerIndex].active);
- mSamplersPS[samplerIndex].logicalTextureUnit = v[i];
- }
- }
- }
- else
- {
- ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
- device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
- }
+ return true;
+ }
- if(constantVS)
- {
- D3DXCONSTANT_DESC constantDescription;
- UINT descriptionCount = 1;
- HRESULT result = mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
- ASSERT(SUCCEEDED(result));
+ bool Program::applyUniform4fv(GLint location, GLsizei count, const GLfloat *v)
+ {
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
- if(constantDescription.RegisterSet == D3DXRS_SAMPLER)
- {
- unsigned int firstIndex = mConstantTableVS->GetSamplerIndex(constantVS);
+ if(targetUniform->psRegisterIndex != -1)
+ {
+ device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)v, targetUniform->registerCount());
+ }
- for(int i = 0; i < count; i++)
- {
- unsigned int samplerIndex = firstIndex + i;
+ if(targetUniform->vsRegisterIndex != -1)
+ {
+ device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)v, targetUniform->registerCount());
+ }
- if(samplerIndex < MAX_VERTEX_TEXTURE_IMAGE_UNITS)
- {
- ASSERT(mSamplersVS[samplerIndex].active);
- mSamplersVS[samplerIndex].logicalTextureUnit = v[i];
- }
- }
- }
- else
- {
- ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
- device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
- }
+ return true;
+ }
- delete[] vector;
+ bool Program::applyUniformMatrix2fv(GLint location, GLsizei count, const GLfloat *value)
+ {
+ float matrix[(MAX_UNIFORM_VECTORS + 1) / 2][2][4];
- return true;
-}
+ for(int i = 0; i < count; i++)
+ {
+ matrix[i][0][0] = value[0]; matrix[i][0][1] = value[1]; matrix[i][0][2] = 0; matrix[i][0][3] = 0;
+ matrix[i][1][0] = value[2]; matrix[i][1][1] = value[3]; matrix[i][1][2] = 0; matrix[i][1][3] = 0;
-bool Program::applyUniform2iv(GLint location, GLsizei count, const GLint *v)
-{
- float (*vector)[4] = new float[count][4];
+ value += 4;
+ }
- for(int i = 0; i < count; i++)
- {
- vector[i][0] = (float)v[0];
- vector[i][1] = (float)v[1];
- vector[i][2] = 0;
- vector[i][3] = 0;
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
- v += 2;
- }
+ if(targetUniform->psRegisterIndex != -1)
+ {
+ device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)matrix, targetUniform->registerCount());
+ }
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+ if(targetUniform->vsRegisterIndex != -1)
+ {
+ device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)matrix, targetUniform->registerCount());
+ }
- D3DXHANDLE constantPS;
- D3DXHANDLE constantVS;
- getConstantHandles(targetUniform, &constantPS, &constantVS);
-
- Device *device = getDevice();
- D3DXCONSTANT_DESC constantDescription;
- UINT descriptionCount = 1;
+ return true;
+ }
- if(constantPS)
- {
- mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
- ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
- device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
+ bool Program::applyUniformMatrix3fv(GLint location, GLsizei count, const GLfloat *value)
+ {
+ float matrix[(MAX_UNIFORM_VECTORS + 2) / 3][3][4];
- if(constantVS)
- {
- mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
- ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
- device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
+ for(int i = 0; i < count; i++)
+ {
+ matrix[i][0][0] = value[0]; matrix[i][0][1] = value[1]; matrix[i][0][2] = value[2]; matrix[i][0][3] = 0;
+ matrix[i][1][0] = value[3]; matrix[i][1][1] = value[4]; matrix[i][1][2] = value[5]; matrix[i][1][3] = 0;
+ matrix[i][2][0] = value[6]; matrix[i][2][1] = value[7]; matrix[i][2][2] = value[8]; matrix[i][2][3] = 0;
- delete[] vector;
+ value += 9;
+ }
- return true;
-}
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
-bool Program::applyUniform3iv(GLint location, GLsizei count, const GLint *v)
-{
- float (*vector)[4] = new float[count][4];
+ if(targetUniform->psRegisterIndex != -1)
+ {
+ device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)matrix, targetUniform->registerCount());
+ }
- for(int i = 0; i < count; i++)
- {
- vector[i][0] = (float)v[0];
- vector[i][1] = (float)v[1];
- vector[i][2] = (float)v[2];
- vector[i][3] = 0;
+ if(targetUniform->vsRegisterIndex != -1)
+ {
+ device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)matrix, targetUniform->registerCount());
+ }
- v += 3;
- }
+ return true;
+ }
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+ bool Program::applyUniformMatrix4fv(GLint location, GLsizei count, const GLfloat *value)
+ {
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
+
+ if(targetUniform->psRegisterIndex != -1)
+ {
+ device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)value, targetUniform->registerCount());
+ }
- D3DXHANDLE constantPS;
- D3DXHANDLE constantVS;
- getConstantHandles(targetUniform, &constantPS, &constantVS);
-
- Device *device = getDevice();
- D3DXCONSTANT_DESC constantDescription;
- UINT descriptionCount = 1;
+ if(targetUniform->vsRegisterIndex != -1)
+ {
+ device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)value, targetUniform->registerCount());
+ }
- if(constantPS)
- {
- mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
- ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
- device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
+ return true;
+ }
- if(constantVS)
- {
- mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
- ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
- device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
+ bool Program::applyUniform1iv(GLint location, GLsizei count, const GLint *v)
+ {
+ float vector[MAX_UNIFORM_VECTORS][4];
- delete[] vector;
+ for(int i = 0; i < count; i++)
+ {
+ vector[i][0] = (float)v[i];
+ vector[i][1] = 0;
+ vector[i][2] = 0;
+ vector[i][3] = 0;
+ }
- return true;
-}
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
-bool Program::applyUniform4iv(GLint location, GLsizei count, const GLint *v)
-{
- float (*vector)[4] = new float[count][4];
+ if(targetUniform->psRegisterIndex != -1)
+ {
+ if(targetUniform->type == GL_SAMPLER_2D ||
+ targetUniform->type == GL_SAMPLER_CUBE)
+ {
+ for(int i = 0; i < count; i++)
+ {
+ unsigned int samplerIndex = targetUniform->psRegisterIndex + i;
- for(int i = 0; i < count; i++)
- {
- vector[i][0] = (float)v[0];
- vector[i][1] = (float)v[1];
- vector[i][2] = (float)v[2];
- vector[i][3] = (float)v[3];
+ if(samplerIndex < MAX_TEXTURE_IMAGE_UNITS)
+ {
+ ASSERT(samplersPS[samplerIndex].active);
+ samplersPS[samplerIndex].logicalTextureUnit = v[i];
+ }
+ }
+ }
+ else
+ {
+ device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
+ }
- v += 4;
- }
+ if(targetUniform->vsRegisterIndex != -1)
+ {
+ if(targetUniform->type == GL_SAMPLER_2D ||
+ targetUniform->type == GL_SAMPLER_CUBE)
+ {
+ for(int i = 0; i < count; i++)
+ {
+ unsigned int samplerIndex = targetUniform->vsRegisterIndex + i;
- Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+ if(samplerIndex < MAX_VERTEX_TEXTURE_IMAGE_UNITS)
+ {
+ ASSERT(samplersVS[samplerIndex].active);
+ samplersVS[samplerIndex].logicalTextureUnit = v[i];
+ }
+ }
+ }
+ else
+ {
+ device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
+ }
- D3DXHANDLE constantPS;
- D3DXHANDLE constantVS;
- getConstantHandles(targetUniform, &constantPS, &constantVS);
-
- Device *device = getDevice();
- D3DXCONSTANT_DESC constantDescription;
- UINT descriptionCount = 1;
+ return true;
+ }
- if(constantPS)
- {
- mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
- device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
+ bool Program::applyUniform2iv(GLint location, GLsizei count, const GLint *v)
+ {
+ float vector[MAX_UNIFORM_VECTORS][4];
- if(constantVS)
- {
- mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
- device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
- }
+ for(int i = 0; i < count; i++)
+ {
+ vector[i][0] = (float)v[0];
+ vector[i][1] = (float)v[1];
+ vector[i][2] = 0;
+ vector[i][3] = 0;
- delete [] vector;
+ v += 2;
+ }
- return true;
-}
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
+ if(targetUniform->psRegisterIndex != -1)
+ {
+ device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
-// append a santized message to the program info log.
-// The D3D compiler includes a fake file path in some of the warning or error
-// messages, so lets remove all occurrences of this fake file path from the log.
-void Program::appendToInfoLogSanitized(const char *message)
-{
- std::string msg(message);
+ if(targetUniform->vsRegisterIndex != -1)
+ {
+ device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- size_t found;
- do
- {
- found = msg.find(fakepath);
- if(found != std::string::npos)
- {
- msg.erase(found, strlen(fakepath));
- }
- }
- while(found != std::string::npos);
+ return true;
+ }
- appendToInfoLog("%s\n", msg.c_str());
-}
+ bool Program::applyUniform3iv(GLint location, GLsizei count, const GLint *v)
+ {
+ float vector[MAX_UNIFORM_VECTORS][4];
-void Program::appendToInfoLog(const char *format, ...)
-{
- if(!format)
- {
- return;
- }
+ for(int i = 0; i < count; i++)
+ {
+ vector[i][0] = (float)v[0];
+ vector[i][1] = (float)v[1];
+ vector[i][2] = (float)v[2];
+ vector[i][3] = 0;
- char info[1024];
+ v += 3;
+ }
- va_list vararg;
- va_start(vararg, format);
- vsnprintf(info, sizeof(info), format, vararg);
- va_end(vararg);
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
- size_t infoLength = strlen(info);
+ if(targetUniform->psRegisterIndex != -1)
+ {
+ device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- if(!mInfoLog)
- {
- mInfoLog = new char[infoLength + 1];
- strcpy(mInfoLog, info);
- }
- else
- {
- size_t logLength = strlen(mInfoLog);
- char *newLog = new char[logLength + infoLength + 1];
- strcpy(newLog, mInfoLog);
- strcpy(newLog + logLength, info);
+ if(targetUniform->vsRegisterIndex != -1)
+ {
+ device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- delete[] mInfoLog;
- mInfoLog = newLog;
- }
-}
+ return true;
+ }
-void Program::resetInfoLog()
-{
- if(mInfoLog)
- {
- delete [] mInfoLog;
- mInfoLog = NULL;
- }
-}
+ bool Program::applyUniform4iv(GLint location, GLsizei count, const GLint *v)
+ {
+ float vector[MAX_UNIFORM_VECTORS][4];
-// Returns the program object to an unlinked state, before re-linking, or at destruction
-void Program::unlink(bool destroy)
-{
- if(destroy) // Object being destructed
- {
- if(mFragmentShader)
- {
- mFragmentShader->release();
- mFragmentShader = NULL;
- }
+ for(int i = 0; i < count; i++)
+ {
+ vector[i][0] = (float)v[0];
+ vector[i][1] = (float)v[1];
+ vector[i][2] = (float)v[2];
+ vector[i][3] = (float)v[3];
- if(mVertexShader)
- {
- mVertexShader->release();
- mVertexShader = NULL;
- }
- }
+ v += 4;
+ }
- delete mPixelExecutable;
- mPixelExecutable = NULL;
+ Uniform *targetUniform = uniforms[uniformIndex[location].index];
- delete mVertexExecutable;
- mVertexExecutable = NULL;
+ if(targetUniform->psRegisterIndex != -1)
+ {
+ device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- if(mConstantTablePS)
- {
- mConstantTablePS->Release();
- mConstantTablePS = NULL;
- }
+ if(targetUniform->vsRegisterIndex != -1)
+ {
+ device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+ }
- if(mConstantTableVS)
- {
- mConstantTableVS->Release();
- mConstantTableVS = NULL;
- }
+ return true;
+ }
- for(int index = 0; index < MAX_VERTEX_ATTRIBS; index++)
- {
- mLinkedAttribute[index].name.clear();
- mSemanticIndex[index] = -1;
- }
+ void Program::appendToInfoLog(const char *format, ...)
+ {
+ if(!format)
+ {
+ return;
+ }
- for(int index = 0; index < MAX_TEXTURE_IMAGE_UNITS; index++)
- {
- mSamplersPS[index].active = false;
- }
+ char info[1024];
- for(int index = 0; index < MAX_VERTEX_TEXTURE_IMAGE_UNITS; index++)
- {
- mSamplersVS[index].active = false;
- }
+ va_list vararg;
+ va_start(vararg, format);
+ vsnprintf(info, sizeof(info), format, vararg);
+ va_end(vararg);
- while(!mUniforms.empty())
- {
- delete mUniforms.back();
- mUniforms.pop_back();
- }
+ size_t infoLength = strlen(info);
- mDxDepthRangeLocation = -1;
- mDxDepthLocation = -1;
- mDxViewportLocation = -1;
- mDxHalfPixelSizeLocation = -1;
- mDxFrontCCWLocation = -1;
- mDxPointsOrLinesLocation = -1;
+ if(!infoLog)
+ {
+ infoLog = new char[infoLength + 1];
+ strcpy(infoLog, info);
+ }
+ else
+ {
+ size_t logLength = strlen(infoLog);
+ char *newLog = new char[logLength + infoLength + 1];
+ strcpy(newLog, infoLog);
+ strcpy(newLog + logLength, info);
- mUniformIndex.clear();
+ delete[] infoLog;
+ infoLog = newLog;
+ }
+ }
- mPixelHLSL.clear();
- mVertexHLSL.clear();
+ void Program::resetInfoLog()
+ {
+ if(infoLog)
+ {
+ delete[] infoLog;
+ infoLog = 0;
+ }
+ }
- delete[] mInfoLog;
- mInfoLog = NULL;
+ // Returns the program object to an unlinked state, before re-linking, or at destruction
+ void Program::unlink()
+ {
+ delete vertexBinary;
+ vertexBinary = 0;
+ delete pixelBinary;
+ pixelBinary = 0;
- mLinked = false;
-}
+ for(int index = 0; index < MAX_VERTEX_ATTRIBS; index++)
+ {
+ linkedAttribute[index].name.clear();
+ attributeStream[index] = -1;
+ }
-bool Program::isLinked()
-{
- return mLinked;
-}
+ for(int index = 0; index < MAX_TEXTURE_IMAGE_UNITS; index++)
+ {
+ samplersPS[index].active = false;
+ }
-bool Program::isValidated() const
-{
- return mValidated;
-}
+ for(int index = 0; index < MAX_VERTEX_TEXTURE_IMAGE_UNITS; index++)
+ {
+ samplersVS[index].active = false;
+ }
-void Program::release()
-{
- mRefCount--;
+ while(!uniforms.empty())
+ {
+ delete uniforms.back();
+ uniforms.pop_back();
+ }
- if(mRefCount == 0 && mDeleteStatus)
- {
- mResourceManager->deleteProgram(mHandle);
- }
-}
+ uniformIndex.clear();
-void Program::addRef()
-{
- mRefCount++;
-}
+ delete[] infoLog;
+ infoLog = 0;
-unsigned int Program::getRefCount() const
-{
- return mRefCount;
-}
+ linked = false;
+ }
-unsigned int Program::getSerial() const
-{
- return mSerial;
-}
+ bool Program::isLinked()
+ {
+ return linked;
+ }
-unsigned int Program::issueSerial()
-{
- return mCurrentSerial++;
-}
+ bool Program::isValidated() const
+ {
+ return validated;
+ }
-int Program::getInfoLogLength() const
-{
- if(!mInfoLog)
- {
- return 0;
- }
- else
- {
- return strlen(mInfoLog) + 1;
- }
-}
+ void Program::release()
+ {
+ referenceCount--;
-void Program::getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog)
-{
- int index = 0;
+ if(referenceCount == 0 && orphaned)
+ {
+ resourceManager->deleteProgram(handle);
+ }
+ }
- if(mInfoLog)
- {
- while(index < bufSize - 1 && index < (int)strlen(mInfoLog))
- {
- infoLog[index] = mInfoLog[index];
- index++;
- }
- }
+ void Program::addRef()
+ {
+ referenceCount++;
+ }
- if(bufSize)
- {
- infoLog[index] = '\0';
- }
+ unsigned int Program::getRefCount() const
+ {
+ return referenceCount;
+ }
- if(length)
- {
- *length = index;
- }
-}
+ unsigned int Program::getSerial() const
+ {
+ return serial;
+ }
-void Program::getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders)
-{
- int total = 0;
+ unsigned int Program::issueSerial()
+ {
+ return currentSerial++;
+ }
- if(mVertexShader)
- {
- if(total < maxCount)
- {
- shaders[total] = mVertexShader->getHandle();
- }
+ int Program::getInfoLogLength() const
+ {
+ if(!infoLog)
+ {
+ return 0;
+ }
+ else
+ {
+ return strlen(infoLog) + 1;
+ }
+ }
- total++;
- }
+ void Program::getInfoLog(GLsizei bufSize, GLsizei *length, char *buffer)
+ {
+ int index = 0;
- if(mFragmentShader)
- {
- if(total < maxCount)
- {
- shaders[total] = mFragmentShader->getHandle();
- }
+ if(bufSize > 0)
+ {
+ if(infoLog)
+ {
+ index = std::min(bufSize - 1, (int)strlen(infoLog));
+ memcpy(buffer, infoLog, index);
+ }
- total++;
- }
+ buffer[index] = '\0';
+ }
- if(count)
- {
- *count = total;
- }
-}
+ if(length)
+ {
+ *length = index;
+ }
+ }
-void Program::getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
- // Skip over inactive attributes
- unsigned int activeAttribute = 0;
- unsigned int attribute;
- for(attribute = 0; attribute < MAX_VERTEX_ATTRIBS; attribute++)
- {
- if(mLinkedAttribute[attribute].name.empty())
- {
- continue;
- }
+ void Program::getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders)
+ {
+ int total = 0;
- if(activeAttribute == index)
- {
- break;
- }
+ if(vertexShader)
+ {
+ if(total < maxCount)
+ {
+ shaders[total] = vertexShader->getHandle();
+ }
- activeAttribute++;
- }
+ total++;
+ }
- if(bufsize > 0)
- {
- const char *string = mLinkedAttribute[attribute].name.c_str();
+ if(fragmentShader)
+ {
+ if(total < maxCount)
+ {
+ shaders[total] = fragmentShader->getHandle();
+ }
- strncpy(name, string, bufsize);
- name[bufsize - 1] = '\0';
+ total++;
+ }
- if(length)
- {
- *length = strlen(name);
- }
- }
+ if(count)
+ {
+ *count = total;
+ }
+ }
- *size = 1; // Always a single 'type' instance
+ void Program::getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
+ {
+ // Skip over inactive attributes
+ unsigned int activeAttribute = 0;
+ unsigned int attribute;
+ for(attribute = 0; attribute < MAX_VERTEX_ATTRIBS; attribute++)
+ {
+ if(linkedAttribute[attribute].name.empty())
+ {
+ continue;
+ }
- *type = mLinkedAttribute[attribute].type;
-}
+ if(activeAttribute == index)
+ {
+ break;
+ }
-GLint Program::getActiveAttributeCount()
-{
- int count = 0;
+ activeAttribute++;
+ }
- for(int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
- {
- if(!mLinkedAttribute[attributeIndex].name.empty())
- {
- count++;
- }
- }
+ if(bufsize > 0)
+ {
+ const char *string = linkedAttribute[attribute].name.c_str();
- return count;
-}
+ strncpy(name, string, bufsize);
+ name[bufsize - 1] = '\0';
-GLint Program::getActiveAttributeMaxLength()
-{
- int maxLength = 0;
+ if(length)
+ {
+ *length = strlen(name);
+ }
+ }
- for(int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
- {
- if(!mLinkedAttribute[attributeIndex].name.empty())
- {
- maxLength = std::max((int)(mLinkedAttribute[attributeIndex].name.length() + 1), maxLength);
- }
- }
+ *size = 1; // Always a single 'type' instance
- return maxLength;
-}
+ *type = linkedAttribute[attribute].type;
+ }
-void Program::getActiveUniform(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
- // Skip over internal uniforms
- unsigned int activeUniform = 0;
- unsigned int uniform;
- for(uniform = 0; uniform < mUniforms.size(); uniform++)
- {
- if(mUniforms[uniform]->name.compare(0, 3, "dx_") == 0)
- {
- continue;
- }
+ GLint Program::getActiveAttributeCount()
+ {
+ int count = 0;
- if(activeUniform == index)
- {
- break;
- }
+ for(int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
+ {
+ if(!linkedAttribute[attributeIndex].name.empty())
+ {
+ count++;
+ }
+ }
- activeUniform++;
- }
+ return count;
+ }
- ASSERT(uniform < mUniforms.size()); // index must be smaller than getActiveUniformCount()
+ GLint Program::getActiveAttributeMaxLength()
+ {
+ int maxLength = 0;
- if(bufsize > 0)
- {
- std::string string = mUniforms[uniform]->name;
+ for(int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
+ {
+ if(!linkedAttribute[attributeIndex].name.empty())
+ {
+ maxLength = std::max((int)(linkedAttribute[attributeIndex].name.length() + 1), maxLength);
+ }
+ }
- if(mUniforms[uniform]->isArray())
- {
- string += "[0]";
- }
+ return maxLength;
+ }
- strncpy(name, string.c_str(), bufsize);
- name[bufsize - 1] = '\0';
+ void Program::getActiveUniform(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
+ {
+ if(bufsize > 0)
+ {
+ std::string string = uniforms[index]->name;
- if(length)
- {
- *length = strlen(name);
- }
- }
+ if(uniforms[index]->isArray())
+ {
+ string += "[0]";
+ }
- *size = mUniforms[uniform]->arraySize;
+ strncpy(name, string.c_str(), bufsize);
+ name[bufsize - 1] = '\0';
- *type = mUniforms[uniform]->type;
-}
+ if(length)
+ {
+ *length = strlen(name);
+ }
+ }
-GLint Program::getActiveUniformCount()
-{
- int count = 0;
+ *size = uniforms[index]->size();
- unsigned int numUniforms = mUniforms.size();
- for(unsigned int uniformIndex = 0; uniformIndex < numUniforms; uniformIndex++)
- {
- if(mUniforms[uniformIndex]->name.compare(0, 3, "dx_") != 0)
- {
- count++;
- }
- }
+ *type = uniforms[index]->type;
+ }
- return count;
-}
+ GLint Program::getActiveUniformCount()
+ {
+ return uniforms.size();
+ }
-GLint Program::getActiveUniformMaxLength()
-{
- int maxLength = 0;
+ GLint Program::getActiveUniformMaxLength()
+ {
+ int maxLength = 0;
- unsigned int numUniforms = mUniforms.size();
- for(unsigned int uniformIndex = 0; uniformIndex < numUniforms; uniformIndex++)
- {
- if(!mUniforms[uniformIndex]->name.empty() && mUniforms[uniformIndex]->name.compare(0, 3, "dx_") != 0)
- {
- int length = (int)(mUniforms[uniformIndex]->name.length() + 1);
- if(mUniforms[uniformIndex]->isArray())
- {
- length += 3; // Counting in "[0]".
- }
- maxLength = std::max(length, maxLength);
- }
- }
+ unsigned int numUniforms = uniforms.size();
+ for(unsigned int uniformIndex = 0; uniformIndex < numUniforms; uniformIndex++)
+ {
+ if(!uniforms[uniformIndex]->name.empty())
+ {
+ int length = (int)(uniforms[uniformIndex]->name.length() + 1);
+ if(uniforms[uniformIndex]->isArray())
+ {
+ length += 3; // Counting in "[0]".
+ }
+ maxLength = std::max(length, maxLength);
+ }
+ }
- return maxLength;
-}
+ return maxLength;
+ }
-void Program::flagForDeletion()
-{
- mDeleteStatus = true;
-}
+ void Program::flagForDeletion()
+ {
+ orphaned = true;
+ }
-bool Program::isFlaggedForDeletion() const
-{
- return mDeleteStatus;
-}
+ bool Program::isFlaggedForDeletion() const
+ {
+ return orphaned;
+ }
-void Program::validate()
-{
- resetInfoLog();
+ void Program::validate()
+ {
+ resetInfoLog();
- if(!isLinked())
- {
- appendToInfoLog("Program has not been successfully linked.");
- mValidated = false;
- }
- else
- {
- applyUniforms();
- if(!validateSamplers(true))
- {
- mValidated = false;
- }
- else
- {
- mValidated = true;
- }
- }
-}
+ if(!isLinked())
+ {
+ appendToInfoLog("Program has not been successfully linked.");
+ validated = false;
+ }
+ else
+ {
+ applyUniforms();
+ if(!validateSamplers(true))
+ {
+ validated = false;
+ }
+ else
+ {
+ validated = true;
+ }
+ }
+ }
-bool Program::validateSamplers(bool logErrors)
-{
- // if any two active samplers in a program are of different types, but refer to the same
- // texture image unit, and this is the current program, then ValidateProgram will fail, and
- // DrawArrays and DrawElements will issue the INVALID_OPERATION error.
+ bool Program::validateSamplers(bool logErrors)
+ {
+ // if any two active samplers in a program are of different types, but refer to the same
+ // texture image unit, and this is the current program, then ValidateProgram will fail, and
+ // DrawArrays and DrawElements will issue the INVALID_OPERATION error.
- TextureType textureUnitType[MAX_COMBINED_TEXTURE_IMAGE_UNITS];
+ TextureType textureUnitType[MAX_COMBINED_TEXTURE_IMAGE_UNITS];
- for(unsigned int i = 0; i < MAX_COMBINED_TEXTURE_IMAGE_UNITS; ++i)
- {
- textureUnitType[i] = TEXTURE_UNKNOWN;
- }
+ for(unsigned int i = 0; i < MAX_COMBINED_TEXTURE_IMAGE_UNITS; i++)
+ {
+ textureUnitType[i] = TEXTURE_UNKNOWN;
+ }
- for(unsigned int i = 0; i < MAX_TEXTURE_IMAGE_UNITS; ++i)
- {
- if(mSamplersPS[i].active)
- {
- unsigned int unit = mSamplersPS[i].logicalTextureUnit;
+ for(unsigned int i = 0; i < MAX_TEXTURE_IMAGE_UNITS; i++)
+ {
+ if(samplersPS[i].active)
+ {
+ unsigned int unit = samplersPS[i].logicalTextureUnit;
- if(unit >= MAX_COMBINED_TEXTURE_IMAGE_UNITS)
- {
- if(logErrors)
- {
- appendToInfoLog("Sampler uniform (%d) exceeds MAX_COMBINED_TEXTURE_IMAGE_UNITS (%d)", unit, MAX_COMBINED_TEXTURE_IMAGE_UNITS);
- }
+ if(unit >= MAX_COMBINED_TEXTURE_IMAGE_UNITS)
+ {
+ if(logErrors)
+ {
+ appendToInfoLog("Sampler uniform (%d) exceeds MAX_COMBINED_TEXTURE_IMAGE_UNITS (%d)", unit, MAX_COMBINED_TEXTURE_IMAGE_UNITS);
+ }
- return false;
- }
+ return false;
+ }
- if(textureUnitType[unit] != TEXTURE_UNKNOWN)
- {
- if(mSamplersPS[i].textureType != textureUnitType[unit])
- {
- if(logErrors)
- {
- appendToInfoLog("Samplers of conflicting types refer to the same texture image unit (%d).", unit);
- }
+ if(textureUnitType[unit] != TEXTURE_UNKNOWN)
+ {
+ if(samplersPS[i].textureType != textureUnitType[unit])
+ {
+ if(logErrors)
+ {
+ appendToInfoLog("Samplers of conflicting types refer to the same texture image unit (%d).", unit);
+ }
- return false;
- }
- }
- else
- {
- textureUnitType[unit] = mSamplersPS[i].textureType;
- }
- }
- }
+ return false;
+ }
+ }
+ else
+ {
+ textureUnitType[unit] = samplersPS[i].textureType;
+ }
+ }
+ }
- for(unsigned int i = 0; i < MAX_VERTEX_TEXTURE_IMAGE_UNITS; ++i)
- {
- if(mSamplersVS[i].active)
- {
- unsigned int unit = mSamplersVS[i].logicalTextureUnit;
+ for(unsigned int i = 0; i < MAX_VERTEX_TEXTURE_IMAGE_UNITS; i++)
+ {
+ if(samplersVS[i].active)
+ {
+ unsigned int unit = samplersVS[i].logicalTextureUnit;
- if(unit >= MAX_COMBINED_TEXTURE_IMAGE_UNITS)
- {
- if(logErrors)
- {
- appendToInfoLog("Sampler uniform (%d) exceeds MAX_COMBINED_TEXTURE_IMAGE_UNITS (%d)", unit, MAX_COMBINED_TEXTURE_IMAGE_UNITS);
- }
+ if(unit >= MAX_COMBINED_TEXTURE_IMAGE_UNITS)
+ {
+ if(logErrors)
+ {
+ appendToInfoLog("Sampler uniform (%d) exceeds MAX_COMBINED_TEXTURE_IMAGE_UNITS (%d)", unit, MAX_COMBINED_TEXTURE_IMAGE_UNITS);
+ }
- return false;
- }
+ return false;
+ }
- if(textureUnitType[unit] != TEXTURE_UNKNOWN)
- {
- if(mSamplersVS[i].textureType != textureUnitType[unit])
- {
- if(logErrors)
- {
- appendToInfoLog("Samplers of conflicting types refer to the same texture image unit (%d).", unit);
- }
+ if(textureUnitType[unit] != TEXTURE_UNKNOWN)
+ {
+ if(samplersVS[i].textureType != textureUnitType[unit])
+ {
+ if(logErrors)
+ {
+ appendToInfoLog("Samplers of conflicting types refer to the same texture image unit (%d).", unit);
+ }
- return false;
- }
- }
- else
- {
- textureUnitType[unit] = mSamplersVS[i].textureType;
- }
- }
- }
+ return false;
+ }
+ }
+ else
+ {
+ textureUnitType[unit] = samplersVS[i].textureType;
+ }
+ }
+ }
- return true;
-}
-
-void Program::getConstantHandles(Uniform *targetUniform, D3DXHANDLE *constantPS, D3DXHANDLE *constantVS)
-{
- if(!targetUniform->handlesSet)
- {
- targetUniform->psHandle = mConstantTablePS->GetConstantByName(0, targetUniform->_name.c_str());
- targetUniform->vsHandle = mConstantTableVS->GetConstantByName(0, targetUniform->_name.c_str());
- targetUniform->handlesSet = true;
- }
-
- *constantPS = targetUniform->psHandle;
- *constantVS = targetUniform->vsHandle;
-}
-
-GLint Program::getDxDepthRangeLocation() const
-{
- return mDxDepthRangeLocation;
-}
-
-GLint Program::getDxDepthLocation() const
-{
- return mDxDepthLocation;
-}
-
-GLint Program::getDxViewportLocation() const
-{
- return mDxViewportLocation;
-}
-
-GLint Program::getDxHalfPixelSizeLocation() const
-{
- return mDxHalfPixelSizeLocation;
-}
-
-GLint Program::getDxFrontCCWLocation() const
-{
- return mDxFrontCCWLocation;
-}
-
-GLint Program::getDxPointsOrLinesLocation() const
-{
- return mDxPointsOrLinesLocation;
-}
-
+ return true;
+ }
}
diff --git a/src/OpenGL ES 2.0/libGLESv2/Program.h b/src/OpenGL ES 2.0/libGLESv2/Program.h
index 6bfd41d..8501e5e 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Program.h
+++ b/src/OpenGL ES 2.0/libGLESv2/Program.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2011 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.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Program.h: Defines the Program class. Implements GL program objects
@@ -15,217 +20,189 @@
#include "Shader/PixelShader.hpp"
#include "Shader/VertexShader.hpp"
-#include <d3dx9.h>
-#include <d3dcompiler.h>
#include <string>
#include <vector>
#include <set>
namespace gl
{
-class ResourceManager;
-class FragmentShader;
-class VertexShader;
+ class Device;
+ class ResourceManager;
+ class FragmentShader;
+ class VertexShader;
-// Helper struct representing a single shader uniform
-struct Uniform
-{
- Uniform(GLenum type, const std::string &_name, unsigned int arraySize);
+ // Helper struct representing a single shader uniform
+ struct Uniform
+ {
+ Uniform(GLenum type, const std::string &name, unsigned int arraySize);
- ~Uniform();
+ ~Uniform();
- bool isArray();
+ bool isArray() const;
+ int size() const;
+ int registerCount() const;
- const GLenum type;
- const std::string _name; // Decorated name
- const std::string name; // Undecorated name
- const unsigned int arraySize;
+ const GLenum type;
+ const std::string name;
+ const unsigned int arraySize;
- unsigned char *data;
- bool dirty;
+ unsigned char *data;
+ bool dirty;
- D3DXHANDLE vsHandle;
- D3DXHANDLE psHandle;
- bool handlesSet;
-};
+ short psRegisterIndex;
+ short vsRegisterIndex;
+ };
-// Struct used for correlating uniforms/elements of uniform arrays to handles
-struct UniformLocation
-{
- UniformLocation(const std::string &_name, unsigned int element, unsigned int index);
+ // Struct used for correlating uniforms/elements of uniform arrays to handles
+ struct UniformLocation
+ {
+ UniformLocation(const std::string &name, unsigned int element, unsigned int index);
- std::string name;
- unsigned int element;
- unsigned int index;
-};
+ std::string name;
+ unsigned int element;
+ unsigned int index;
+ };
-class Program
-{
- public:
- Program(ResourceManager *manager, GLuint handle);
+ class Program
+ {
+ public:
+ Program(ResourceManager *manager, GLuint handle);
- ~Program();
+ ~Program();
- bool attachShader(Shader *shader);
- bool detachShader(Shader *shader);
- int getAttachedShadersCount() const;
+ bool attachShader(Shader *shader);
+ bool detachShader(Shader *shader);
+ int getAttachedShadersCount() const;
- sw::PixelShader *getPixelShader();
- sw::VertexShader *getVertexShader();
+ sw::PixelShader *getPixelShader();
+ sw::VertexShader *getVertexShader();
- void bindAttributeLocation(GLuint index, const char *name);
- GLuint getAttributeLocation(const char *name);
- int getSemanticIndex(int attributeIndex);
+ void bindAttributeLocation(GLuint index, const char *name);
+ GLuint getAttributeLocation(const char *name);
+ int getAttributeStream(int attributeIndex);
- GLint getSamplerMapping(sw::SamplerType type, unsigned int samplerIndex);
- TextureType getSamplerTextureType(sw::SamplerType type, unsigned int samplerIndex);
+ GLint getSamplerMapping(sw::SamplerType type, unsigned int samplerIndex);
+ TextureType getSamplerTextureType(sw::SamplerType type, unsigned int samplerIndex);
- GLint getUniformLocation(std::string name);
- bool setUniform1fv(GLint location, GLsizei count, const GLfloat *v);
- bool setUniform2fv(GLint location, GLsizei count, const GLfloat *v);
- bool setUniform3fv(GLint location, GLsizei count, const GLfloat *v);
- bool setUniform4fv(GLint location, GLsizei count, const GLfloat *v);
- bool setUniformMatrix2fv(GLint location, GLsizei count, const GLfloat *value);
- bool setUniformMatrix3fv(GLint location, GLsizei count, const GLfloat *value);
- bool setUniformMatrix4fv(GLint location, GLsizei count, const GLfloat *value);
- bool setUniform1iv(GLint location, GLsizei count, const GLint *v);
- bool setUniform2iv(GLint location, GLsizei count, const GLint *v);
- bool setUniform3iv(GLint location, GLsizei count, const GLint *v);
- bool setUniform4iv(GLint location, GLsizei count, const GLint *v);
+ GLint getUniformLocation(std::string name);
+ bool setUniform1fv(GLint location, GLsizei count, const GLfloat *v);
+ bool setUniform2fv(GLint location, GLsizei count, const GLfloat *v);
+ bool setUniform3fv(GLint location, GLsizei count, const GLfloat *v);
+ bool setUniform4fv(GLint location, GLsizei count, const GLfloat *v);
+ bool setUniformMatrix2fv(GLint location, GLsizei count, const GLfloat *value);
+ bool setUniformMatrix3fv(GLint location, GLsizei count, const GLfloat *value);
+ bool setUniformMatrix4fv(GLint location, GLsizei count, const GLfloat *value);
+ bool setUniform1iv(GLint location, GLsizei count, const GLint *v);
+ bool setUniform2iv(GLint location, GLsizei count, const GLint *v);
+ bool setUniform3iv(GLint location, GLsizei count, const GLint *v);
+ bool setUniform4iv(GLint location, GLsizei count, const GLint *v);
- bool getUniformfv(GLint location, GLfloat *params);
- bool getUniformiv(GLint location, GLint *params);
+ bool getUniformfv(GLint location, GLsizei *bufSize, GLfloat *params);
+ bool getUniformiv(GLint location, GLsizei *bufSize, GLint *params);
- GLint getDxDepthRangeLocation() const;
- GLint getDxDepthLocation() const;
- GLint getDxViewportLocation() const;
- GLint getDxHalfPixelSizeLocation() const;
- GLint getDxFrontCCWLocation() const;
- GLint getDxPointsOrLinesLocation() const;
+ void dirtyAllUniforms();
+ void applyUniforms();
- void dirtyAllUniforms();
- void applyUniforms();
+ void link();
+ bool isLinked();
+ int getInfoLogLength() const;
+ void getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog);
+ void getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders);
- void link();
- bool isLinked();
- int getInfoLogLength() const;
- void getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog);
- void getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders);
+ void getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+ GLint getActiveAttributeCount();
+ GLint getActiveAttributeMaxLength();
- void getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
- GLint getActiveAttributeCount();
- GLint getActiveAttributeMaxLength();
+ void getActiveUniform(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+ GLint getActiveUniformCount();
+ GLint getActiveUniformMaxLength();
- void getActiveUniform(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
- GLint getActiveUniformCount();
- GLint getActiveUniformMaxLength();
+ void addRef();
+ void release();
+ unsigned int getRefCount() const;
+ void flagForDeletion();
+ bool isFlaggedForDeletion() const;
- void addRef();
- void release();
- unsigned int getRefCount() const;
- void flagForDeletion();
- bool isFlaggedForDeletion() const;
+ void validate();
+ bool validateSamplers(bool logErrors);
+ bool isValidated() const;
- void validate();
- bool validateSamplers(bool logErrors);
- bool isValidated() const;
+ unsigned int getSerial() const;
- unsigned int getSerial() const;
+ private:
+ DISALLOW_COPY_AND_ASSIGN(Program);
- static std::string decorateAttribute(const std::string &name); // Prepend an underscore
- static std::string undecorateUniform(const std::string &_name); // Remove leading underscore
+ void unlink();
- private:
- DISALLOW_COPY_AND_ASSIGN(Program);
+ int packVaryings(const Varying *packing[][4]);
+ bool linkVaryings();
- ID3D10Blob *compileToBinary(const char *hlsl, const char *profile, ID3DXConstantTable **constantTable);
- void unlink(bool destroy = false);
+ bool linkAttributes();
+ int getAttributeBinding(const std::string &name);
- int packVaryings(const Varying *packing[][4]);
- bool linkVaryings();
+ bool linkUniforms(Shader *shader);
+ bool defineUniform(GLenum shader, GLenum type, const std::string &_name, unsigned int arraySize, int registerIndex);
+ bool applyUniform1bv(GLint location, GLsizei count, const GLboolean *v);
+ bool applyUniform2bv(GLint location, GLsizei count, const GLboolean *v);
+ bool applyUniform3bv(GLint location, GLsizei count, const GLboolean *v);
+ bool applyUniform4bv(GLint location, GLsizei count, const GLboolean *v);
+ bool applyUniform1fv(GLint location, GLsizei count, const GLfloat *v);
+ bool applyUniform2fv(GLint location, GLsizei count, const GLfloat *v);
+ bool applyUniform3fv(GLint location, GLsizei count, const GLfloat *v);
+ bool applyUniform4fv(GLint location, GLsizei count, const GLfloat *v);
+ bool applyUniformMatrix2fv(GLint location, GLsizei count, const GLfloat *value);
+ bool applyUniformMatrix3fv(GLint location, GLsizei count, const GLfloat *value);
+ bool applyUniformMatrix4fv(GLint location, GLsizei count, const GLfloat *value);
+ bool applyUniform1iv(GLint location, GLsizei count, const GLint *v);
+ bool applyUniform2iv(GLint location, GLsizei count, const GLint *v);
+ bool applyUniform3iv(GLint location, GLsizei count, const GLint *v);
+ bool applyUniform4iv(GLint location, GLsizei count, const GLint *v);
- bool linkAttributes();
- int getAttributeBinding(const std::string &name);
+ void appendToInfoLog(const char *info, ...);
+ void resetInfoLog();
- bool linkUniforms(ID3DXConstantTable *constantTable);
- bool defineUniform(const D3DXHANDLE &constantHandle, const D3DXCONSTANT_DESC &constantDescription, std::string name = "");
- bool defineUniform(const D3DXCONSTANT_DESC &constantDescription, std::string &name);
- Uniform *createUniform(const D3DXCONSTANT_DESC &constantDescription, std::string &name);
- bool applyUniform1bv(GLint location, GLsizei count, const GLboolean *v);
- bool applyUniform2bv(GLint location, GLsizei count, const GLboolean *v);
- bool applyUniform3bv(GLint location, GLsizei count, const GLboolean *v);
- bool applyUniform4bv(GLint location, GLsizei count, const GLboolean *v);
- bool applyUniform1fv(GLint location, GLsizei count, const GLfloat *v);
- bool applyUniform2fv(GLint location, GLsizei count, const GLfloat *v);
- bool applyUniform3fv(GLint location, GLsizei count, const GLfloat *v);
- bool applyUniform4fv(GLint location, GLsizei count, const GLfloat *v);
- bool applyUniformMatrix2fv(GLint location, GLsizei count, const GLfloat *value);
- bool applyUniformMatrix3fv(GLint location, GLsizei count, const GLfloat *value);
- bool applyUniformMatrix4fv(GLint location, GLsizei count, const GLfloat *value);
- bool applyUniform1iv(GLint location, GLsizei count, const GLint *v);
- bool applyUniform2iv(GLint location, GLsizei count, const GLint *v);
- bool applyUniform3iv(GLint location, GLsizei count, const GLint *v);
- bool applyUniform4iv(GLint location, GLsizei count, const GLint *v);
+ static unsigned int issueSerial();
- void getConstantHandles(Uniform *targetUniform, D3DXHANDLE *constantPS, D3DXHANDLE *constantVS);
+ private:
+ gl::Device *device;
+ FragmentShader *fragmentShader;
+ VertexShader *vertexShader;
- void appendToInfoLogSanitized(const char *message);
- void appendToInfoLog(const char *info, ...);
- void resetInfoLog();
+ sw::PixelShader *pixelBinary;
+ sw::VertexShader *vertexBinary;
+
+ std::set<std::string> attributeBinding[MAX_VERTEX_ATTRIBS];
+ sh::Attribute linkedAttribute[MAX_VERTEX_ATTRIBS];
+ int attributeStream[MAX_VERTEX_ATTRIBS];
- static unsigned int issueSerial();
+ struct Sampler
+ {
+ bool active;
+ GLint logicalTextureUnit;
+ TextureType textureType;
+ };
- FragmentShader *mFragmentShader;
- VertexShader *mVertexShader;
+ Sampler samplersPS[MAX_TEXTURE_IMAGE_UNITS];
+ Sampler samplersVS[MAX_VERTEX_TEXTURE_IMAGE_UNITS];
- std::string mPixelHLSL;
- std::string mVertexHLSL;
+ typedef std::vector<Uniform*> UniformArray;
+ UniformArray uniforms;
+ typedef std::vector<UniformLocation> UniformIndex;
+ UniformIndex uniformIndex;
- sw::PixelShader *mPixelExecutable;
- sw::VertexShader *mVertexExecutable;
- ID3DXConstantTable *mConstantTablePS;
- ID3DXConstantTable *mConstantTableVS;
+ bool linked;
+ bool orphaned; // Flag to indicate that the program can be deleted when no longer in use
+ char *infoLog;
+ bool validated;
- std::set<std::string> mAttributeBinding[MAX_VERTEX_ATTRIBS];
- Attribute mLinkedAttribute[MAX_VERTEX_ATTRIBS];
- int mSemanticIndex[MAX_VERTEX_ATTRIBS];
+ unsigned int referenceCount;
+ const unsigned int serial;
- struct Sampler
- {
- bool active;
- GLint logicalTextureUnit;
- TextureType textureType;
- };
+ static unsigned int currentSerial;
- Sampler mSamplersPS[MAX_TEXTURE_IMAGE_UNITS];
- Sampler mSamplersVS[MAX_VERTEX_TEXTURE_IMAGE_UNITS];
-
- typedef std::vector<Uniform*> UniformArray;
- UniformArray mUniforms;
- typedef std::vector<UniformLocation> UniformIndex;
- UniformIndex mUniformIndex;
-
- GLint mDxDepthRangeLocation;
- GLint mDxDepthLocation;
- GLint mDxViewportLocation;
- GLint mDxHalfPixelSizeLocation;
- GLint mDxFrontCCWLocation;
- GLint mDxPointsOrLinesLocation;
-
- bool mLinked;
- bool mDeleteStatus; // Flag to indicate that the program can be deleted when no longer in use
- char *mInfoLog;
- bool mValidated;
-
- unsigned int mRefCount;
-
- const unsigned int mSerial;
-
- static unsigned int mCurrentSerial;
-
- ResourceManager *mResourceManager;
- const GLuint mHandle;
-};
+ ResourceManager *resourceManager;
+ const GLuint handle;
+ };
}
#endif // LIBGLESV2_PROGRAM_H_
diff --git a/src/OpenGL ES 2.0/libGLESv2/Query.cpp b/src/OpenGL ES 2.0/libGLESv2/Query.cpp
new file mode 100644
index 0000000..7334d08
--- /dev/null
+++ b/src/OpenGL ES 2.0/libGLESv2/Query.cpp
@@ -0,0 +1,125 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+// Query.cpp: Implements the gl::Query class
+
+#include "Query.h"
+#include "main.h"
+
+namespace gl
+{
+
+Query::Query(GLuint id, GLenum type) : RefCountObject(id)
+{
+ mQuery = NULL;
+ mStatus = GL_FALSE;
+ mResult = GL_FALSE;
+ mType = type;
+}
+
+Query::~Query()
+{
+ if(mQuery != NULL)
+ {
+ delete mQuery;
+ }
+}
+
+void Query::begin()
+{
+ if(mQuery == NULL)
+ {
+ mQuery = new sw::Query();
+
+ if(!mQuery)
+ {
+ return error(GL_OUT_OF_MEMORY);
+ }
+ }
+
+ Device *device = getDevice();
+
+ mQuery->begin();
+ device->addQuery(mQuery);
+ device->setOcclusionEnabled(true);
+}
+
+void Query::end()
+{
+ if(mQuery == NULL)
+ {
+ return error(GL_INVALID_OPERATION);
+ }
+
+ Device *device = getDevice();
+
+ mQuery->end();
+ device->removeQuery(mQuery);
+ device->setOcclusionEnabled(false);
+
+ mStatus = GL_FALSE;
+ mResult = GL_FALSE;
+}
+
+GLuint Query::getResult()
+{
+ if(mQuery != NULL)
+ {
+ while(!testQuery())
+ {
+ Sleep(0);
+ }
+ }
+
+ return (GLuint)mResult;
+}
+
+GLboolean Query::isResultAvailable()
+{
+ if(mQuery != NULL)
+ {
+ testQuery();
+ }
+
+ return mStatus;
+}
+
+GLenum Query::getType() const
+{
+ return mType;
+}
+
+GLboolean Query::testQuery()
+{
+ if(mQuery != NULL && mStatus != GL_TRUE)
+ {
+ if(!mQuery->building && mQuery->reference == 0)
+ {
+ DWORD numPixels = mQuery->data;
+ mStatus = GL_TRUE;
+
+ switch(mType)
+ {
+ case GL_ANY_SAMPLES_PASSED_EXT:
+ case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
+ mResult = (numPixels > 0) ? GL_TRUE : GL_FALSE;
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ return mStatus;
+ }
+
+ return GL_TRUE; // Prevent blocking when query is null
+}
+}
diff --git a/src/OpenGL ES 2.0/libGLESv2/Query.h b/src/OpenGL ES 2.0/libGLESv2/Query.h
new file mode 100644
index 0000000..e2e05c8
--- /dev/null
+++ b/src/OpenGL ES 2.0/libGLESv2/Query.h
@@ -0,0 +1,53 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+// Query.h: Defines the gl::Query class
+
+#ifndef LIBGLESV2_QUERY_H_
+#define LIBGLESV2_QUERY_H_
+
+#include "RefCountObject.h"
+#include "common/angleutils.h"
+#include "Renderer/Renderer.hpp"
+
+#define GL_APICALL
+#include <GLES2/gl2.h>
+
+namespace gl
+{
+
+class Query : public RefCountObject
+{
+ public:
+ Query(GLuint id, GLenum type);
+ virtual ~Query();
+
+ void begin();
+ void end();
+ GLuint getResult();
+ GLboolean isResultAvailable();
+
+ GLenum getType() const;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(Query);
+
+ GLboolean testQuery();
+
+ sw::Query* mQuery;
+ GLenum mType;
+ GLboolean mStatus;
+ GLint mResult;
+};
+
+}
+
+#endif // LIBGLESV2_QUERY_H_
diff --git a/src/OpenGL ES 2.0/libGLESv2/RefCountObject.cpp b/src/OpenGL ES 2.0/libGLESv2/RefCountObject.cpp
index efa57a4..d9d88ac 100644
--- a/src/OpenGL ES 2.0/libGLESv2/RefCountObject.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/RefCountObject.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// RefCountObject.cpp: Defines the RefCountObject base class that provides
diff --git a/src/OpenGL ES 2.0/libGLESv2/RefCountObject.h b/src/OpenGL ES 2.0/libGLESv2/RefCountObject.h
index c6940e0..31264c2 100644
--- a/src/OpenGL ES 2.0/libGLESv2/RefCountObject.h
+++ b/src/OpenGL ES 2.0/libGLESv2/RefCountObject.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2011 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.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// RefCountObject.h: Defines the RefCountObject base class that provides
diff --git a/src/OpenGL ES 2.0/libGLESv2/Renderbuffer.cpp b/src/OpenGL ES 2.0/libGLESv2/Renderbuffer.cpp
index 3bdca1f..1ab1f61 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Renderbuffer.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Renderbuffer.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Renderbuffer.cpp: the Renderbuffer class and its derived classes
@@ -29,19 +34,19 @@
delete mStorage;
}
-bool Renderbuffer::isColorbuffer() const
+Colorbuffer *Renderbuffer::getColorbuffer()
{
- return mStorage->isColorbuffer();
+ return mStorage->getColorbuffer();
}
-bool Renderbuffer::isDepthbuffer() const
+DepthStencilbuffer *Renderbuffer::getDepthbuffer()
{
- return mStorage->isDepthbuffer();
+ return mStorage->getDepthbuffer();
}
-bool Renderbuffer::isStencilbuffer() const
+DepthStencilbuffer *Renderbuffer::getStencilbuffer()
{
- return mStorage->isStencilbuffer();
+ return mStorage->getStencilbuffer();
}
Image *Renderbuffer::getRenderTarget()
@@ -135,19 +140,19 @@
{
}
-bool RenderbufferStorage::isColorbuffer() const
+Colorbuffer *RenderbufferStorage::getColorbuffer()
{
- return false;
+ return NULL;
}
-bool RenderbufferStorage::isDepthbuffer() const
+DepthStencilbuffer *RenderbufferStorage::getDepthbuffer()
{
- return false;
+ return NULL;
}
-bool RenderbufferStorage::isStencilbuffer() const
+DepthStencilbuffer *RenderbufferStorage::getStencilbuffer()
{
- return false;
+ return NULL;
}
Image *RenderbufferStorage::getRenderTarget()
@@ -343,21 +348,28 @@
return format;
}
-bool Colorbuffer::isColorbuffer() const
+Colorbuffer *Colorbuffer::getColorbuffer()
{
- return true;
+ return this;
}
Image *Colorbuffer::getRenderTarget()
{
if(mTexture)
{
- if(mRenderTarget)
+ Image *newRenderTarget = mTexture->getRenderTarget(mTarget);
+
+ if(mRenderTarget)
{
mRenderTarget->release();
}
- mRenderTarget = mTexture->getRenderTarget(mTarget);
+ mRenderTarget = newRenderTarget;
+ }
+
+ if(mRenderTarget)
+ {
+ mRenderTarget->addRef();
}
return mRenderTarget;
@@ -418,14 +430,14 @@
}
}
-bool DepthStencilbuffer::isDepthbuffer() const
+DepthStencilbuffer *DepthStencilbuffer::getDepthbuffer()
{
- return true;
+ return this;
}
-bool DepthStencilbuffer::isStencilbuffer() const
+DepthStencilbuffer *DepthStencilbuffer::getStencilbuffer()
{
- return true;
+ return this;
}
Image *DepthStencilbuffer::getDepthStencil()
@@ -457,14 +469,14 @@
{
}
-bool Depthbuffer::isDepthbuffer() const
+DepthStencilbuffer *Depthbuffer::getDepthbuffer()
{
- return true;
+ return this;
}
-bool Depthbuffer::isStencilbuffer() const
+DepthStencilbuffer *Depthbuffer::getStencilbuffer()
{
- return false;
+ return NULL;
}
Stencilbuffer::Stencilbuffer(Image *depthStencil) : DepthStencilbuffer(depthStencil)
@@ -491,13 +503,13 @@
{
}
-bool Stencilbuffer::isDepthbuffer() const
+DepthStencilbuffer *Stencilbuffer::getDepthbuffer()
{
- return false;
+ return NULL;
}
-bool Stencilbuffer::isStencilbuffer() const
+DepthStencilbuffer *Stencilbuffer::getStencilbuffer()
{
- return true;
+ return this;
}
}
diff --git a/src/OpenGL ES 2.0/libGLESv2/Renderbuffer.h b/src/OpenGL ES 2.0/libGLESv2/Renderbuffer.h
index da339a8..5248194 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Renderbuffer.h
+++ b/src/OpenGL ES 2.0/libGLESv2/Renderbuffer.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Renderbuffer.h: Defines the wrapper class Renderbuffer, as well as the
@@ -22,6 +27,8 @@
namespace gl
{
class Texture;
+class Colorbuffer;
+class DepthStencilbuffer;
// A class derived from RenderbufferStorage is created whenever glRenderbufferStorage
// is called. The specific concrete type depends on whether the internal format is
@@ -33,9 +40,9 @@
virtual ~RenderbufferStorage() = 0;
- virtual bool isColorbuffer() const;
- virtual bool isDepthbuffer() const;
- virtual bool isStencilbuffer() const;
+ virtual Colorbuffer *getColorbuffer();
+ virtual DepthStencilbuffer *getDepthbuffer();
+ virtual DepthStencilbuffer *getStencilbuffer();
virtual Image *getRenderTarget();
virtual Image *getDepthStencil();
@@ -82,9 +89,9 @@
~Renderbuffer();
- bool isColorbuffer() const;
- bool isDepthbuffer() const;
- bool isStencilbuffer() const;
+ Colorbuffer *getColorbuffer();
+ DepthStencilbuffer *getDepthbuffer();
+ DepthStencilbuffer *getStencilbuffer();
Image *getRenderTarget();
Image *getDepthStencil();
@@ -121,7 +128,7 @@
virtual ~Colorbuffer();
- virtual bool isColorbuffer() const;
+ virtual Colorbuffer *getColorbuffer();
virtual Image *getRenderTarget();
@@ -148,8 +155,8 @@
~DepthStencilbuffer();
- virtual bool isDepthbuffer() const;
- virtual bool isStencilbuffer() const;
+ virtual DepthStencilbuffer *getDepthbuffer();
+ virtual DepthStencilbuffer *getStencilbuffer();
virtual Image *getDepthStencil();
@@ -166,8 +173,8 @@
virtual ~Depthbuffer();
- virtual bool isDepthbuffer() const;
- virtual bool isStencilbuffer() const;
+ virtual DepthStencilbuffer *getDepthbuffer();
+ virtual DepthStencilbuffer *getStencilbuffer();
private:
DISALLOW_COPY_AND_ASSIGN(Depthbuffer);
@@ -181,8 +188,8 @@
virtual ~Stencilbuffer();
- virtual bool isDepthbuffer() const;
- virtual bool isStencilbuffer() const;
+ virtual DepthStencilbuffer *getDepthbuffer();
+ virtual DepthStencilbuffer *getStencilbuffer();
private:
DISALLOW_COPY_AND_ASSIGN(Stencilbuffer);
diff --git a/src/OpenGL ES 2.0/libGLESv2/ResourceManager.cpp b/src/OpenGL ES 2.0/libGLESv2/ResourceManager.cpp
index 9318d8c..c7cf33f 100644
--- a/src/OpenGL ES 2.0/libGLESv2/ResourceManager.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/ResourceManager.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// ResourceManager.cpp: Implements the ResourceManager class, which tracks and
diff --git a/src/OpenGL ES 2.0/libGLESv2/ResourceManager.h b/src/OpenGL ES 2.0/libGLESv2/ResourceManager.h
index e8f41c4..3cc0633 100644
--- a/src/OpenGL ES 2.0/libGLESv2/ResourceManager.h
+++ b/src/OpenGL ES 2.0/libGLESv2/ResourceManager.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// ResourceManager.h : Defines the ResourceManager class, which tracks objects
diff --git a/src/OpenGL ES 2.0/libGLESv2/Shader.cpp b/src/OpenGL ES 2.0/libGLESv2/Shader.cpp
index d32eae6..6c55db9 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Shader.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Shader.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Shader.cpp: Implements the Shader class and its derived classes
@@ -25,34 +30,10 @@
Shader::Shader(ResourceManager *manager, GLuint handle) : mHandle(handle), mResourceManager(manager)
{
mSource = NULL;
- mHlsl = NULL;
mInfoLog = NULL;
- // Perform a one-time initialization of the shader compiler (or after being destructed by releaseCompiler)
- if(!mFragmentCompiler)
- {
- int result = ShInitialize();
-
- if(result)
- {
- ShBuiltInResources resources;
- ShInitBuiltInResources(&resources);
- Context *context = getContext();
-
- resources.MaxVertexAttribs = MAX_VERTEX_ATTRIBS;
- resources.MaxVertexUniformVectors = MAX_VERTEX_UNIFORM_VECTORS;
- resources.MaxVaryingVectors = MAX_VARYING_VECTORS;
- resources.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
- resources.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
- resources.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
- resources.MaxFragmentUniformVectors = MAX_FRAGMENT_UNIFORM_VECTORS;
- resources.MaxDrawBuffers = MAX_DRAW_BUFFERS;
- resources.OES_standard_derivatives = 1;
-
- mFragmentCompiler = ShConstructCompiler(SH_FRAGMENT_SHADER, SH_GLES2_SPEC, &resources);
- mVertexCompiler = ShConstructCompiler(SH_VERTEX_SHADER, SH_GLES2_SPEC, &resources);
- }
- }
+ clear();
+ initializeCompiler();
mRefCount = 0;
mDeleteStatus = false;
@@ -61,7 +42,6 @@
Shader::~Shader()
{
delete[] mSource;
- delete[] mHlsl;
delete[] mInfoLog;
}
@@ -126,17 +106,14 @@
{
int index = 0;
- if(mInfoLog)
- {
- while(index < bufSize - 1 && index < (int)strlen(mInfoLog))
- {
- infoLog[index] = mInfoLog[index];
- index++;
- }
- }
+ if(bufSize > 0)
+ {
+ if(mInfoLog)
+ {
+ index = std::min(bufSize - 1, (int)strlen(mInfoLog));
+ memcpy(infoLog, mInfoLog, index);
+ }
- if(bufSize)
- {
infoLog[index] = '\0';
}
@@ -162,17 +139,14 @@
{
int index = 0;
- if(mSource)
- {
- while(index < bufSize - 1 && index < (int)strlen(mSource))
- {
- source[index] = mSource[index];
- index++;
- }
- }
+ if(bufSize > 0)
+ {
+ if(mSource)
+ {
+ index = std::min(bufSize - 1, (int)strlen(mSource));
+ memcpy(source, mSource, index);
+ }
- if(bufSize)
- {
source[index] = '\0';
}
@@ -182,14 +156,28 @@
}
}
-bool Shader::isCompiled()
+void Shader::clear()
{
- return mHlsl != NULL;
+ delete[] mInfoLog;
+ mInfoLog = NULL;
+
+ varyings.clear();
+ activeAttributes.clear();
}
-const char *Shader::getHLSL()
+bool Shader::isCompiled()
{
- return mHlsl;
+ return getShader() != 0;
+}
+
+sw::PixelShader *Shader::getPixelShader() const
+{
+ return 0;
+}
+
+sw::VertexShader *Shader::getVertexShader() const
+{
+ return 0;
}
void Shader::addRef()
@@ -222,6 +210,35 @@
mDeleteStatus = true;
}
+// Perform a one-time initialization of the shader compiler (or after being destructed by releaseCompiler)
+void Shader::initializeCompiler()
+{
+ if(!mFragmentCompiler)
+ {
+ int result = ShInitialize();
+
+ if(result)
+ {
+ ShBuiltInResources resources;
+ ShInitBuiltInResources(&resources);
+ Context *context = getContext();
+
+ resources.MaxVertexAttribs = MAX_VERTEX_ATTRIBS;
+ resources.MaxVertexUniformVectors = MAX_VERTEX_UNIFORM_VECTORS;
+ resources.MaxVaryingVectors = MAX_VARYING_VECTORS;
+ resources.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
+ resources.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
+ resources.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
+ resources.MaxFragmentUniformVectors = MAX_FRAGMENT_UNIFORM_VECTORS;
+ resources.MaxDrawBuffers = MAX_DRAW_BUFFERS;
+ resources.OES_standard_derivatives = 1;
+
+ mFragmentCompiler = ShConstructCompiler(SH_FRAGMENT_SHADER, SH_GLES2_SPEC, &resources);
+ mVertexCompiler = ShConstructCompiler(SH_VERTEX_SHADER, SH_GLES2_SPEC, &resources);
+ }
+ }
+}
+
void Shader::releaseCompiler()
{
ShDestruct(mFragmentCompiler);
@@ -233,92 +250,6 @@
ShFinalize();
}
-void Shader::parseVaryings()
-{
- if(mHlsl)
- {
- const char *input = strstr(mHlsl, "// Varyings") + 12;
-
- while(true)
- {
- char varyingType[256];
- char varyingName[256];
-
- int matches = sscanf(input, "static %255s %255s", varyingType, varyingName);
-
- if(matches != 2)
- {
- break;
- }
-
- char *array = strstr(varyingName, "[");
- int size = 1;
-
- if(array)
- {
- size = atoi(array + 1);
- *array = '\0';
- }
-
- varyings.push_back(Varying(parseType(varyingType), varyingName, size, array != NULL));
-
- input = strstr(input, ";") + 2;
- }
-
- mUsesFragCoord = strstr(mHlsl, "GL_USES_FRAG_COORD") != NULL;
- mUsesFrontFacing = strstr(mHlsl, "GL_USES_FRONT_FACING") != NULL;
- mUsesPointSize = strstr(mHlsl, "GL_USES_POINT_SIZE") != NULL;
- mUsesPointCoord = strstr(mHlsl, "GL_USES_POINT_COORD") != NULL;
- }
-}
-
-void Shader::compileToHLSL(void *compiler)
-{
- if(isCompiled() || !mSource)
- {
- return;
- }
-
- delete[] mInfoLog;
- mInfoLog = NULL;
-
- int compileOptions = SH_OBJECT_CODE;
- std::string sourcePath;
-
- int result;
- if(sourcePath.empty())
- {
- result = ShCompile(compiler, &mSource, 1, compileOptions);
- }
- else
- {
- const char* sourceStrings[2] =
- {
- sourcePath.c_str(),
- mSource
- };
-
- result = ShCompile(compiler, sourceStrings, 2, compileOptions | SH_SOURCE_PATH);
- }
-
- if(result)
- {
- int objCodeLen = 0;
- ShGetInfo(compiler, SH_OBJECT_CODE_LENGTH, &objCodeLen);
- mHlsl = new char[objCodeLen];
- ShGetObjectCode(compiler, mHlsl);
- }
- else
- {
- int infoLogLen = 0;
- ShGetInfo(compiler, SH_INFO_LOG_LENGTH, &infoLogLen);
- mInfoLog = new char[infoLogLen];
- ShGetInfoLog(compiler, mInfoLog);
-
- TRACE("\n%s", mInfoLog);
- }
-}
-
GLenum Shader::parseType(const std::string &type)
{
if(type == "float")
@@ -359,7 +290,7 @@
{
if(x.type == y.type)
{
- return x.size > y.size;
+ return x.size() > y.size();
}
switch (x.type)
@@ -439,10 +370,12 @@
VertexShader::VertexShader(ResourceManager *manager, GLuint handle) : Shader(manager, handle)
{
+ vertexShader = 0;
}
VertexShader::~VertexShader()
{
+ delete vertexShader;
}
GLenum VertexShader::getType()
@@ -452,61 +385,97 @@
void VertexShader::compile()
{
- compileToHLSL(mVertexCompiler);
- parseAttributes();
- parseVaryings();
+ clear();
+ initializeCompiler();
+
+ delete vertexShader;
+ vertexShader = new sw::VertexShader();
+
+ TranslatorASM *assembler = new TranslatorASM(this, SH_VERTEX_SHADER, SH_GLES2_SPEC);
+
+ ShBuiltInResources resources;
+ ShInitBuiltInResources(&resources);
+ resources.MaxVertexAttribs = MAX_VERTEX_ATTRIBS;
+ resources.MaxVertexUniformVectors = MAX_VERTEX_UNIFORM_VECTORS;
+ resources.MaxVaryingVectors = MAX_VARYING_VECTORS;
+ resources.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
+ resources.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
+ resources.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
+ resources.MaxFragmentUniformVectors = MAX_FRAGMENT_UNIFORM_VECTORS;
+ resources.MaxDrawBuffers = MAX_DRAW_BUFFERS;
+ resources.OES_standard_derivatives = 1;
+ assembler->Init(resources);
+
+ // Ensure we don't pass a NULL source to the compiler
+ char *source = "\0";
+ if(mSource)
+ {
+ source = mSource;
+ }
+
+ int success = ShCompile(assembler, &source, 1, SH_OBJECT_CODE);
+
+ if(false)
+ {
+ static int serial = 1;
+ char buffer[256];
+ sprintf(buffer, "vertex-input-%d-%d.txt", getHandle(), serial);
+ FILE *file = fopen(buffer, "wt");
+ fprintf(file, mSource);
+ fclose(file);
+ vertexShader->print("vertex-output-%d-%d.txt", getHandle(), serial);
+ serial++;
+ }
+
+ if(!success)
+ {
+ delete vertexShader;
+ vertexShader = 0;
+
+ int infoLogLen = 0;
+ ShGetInfo(assembler, SH_INFO_LOG_LENGTH, &infoLogLen);
+ mInfoLog = new char[infoLogLen];
+ ShGetInfoLog(assembler, mInfoLog);
+ TRACE("\n%s", mInfoLog);
+ }
+
+ delete assembler;
}
int VertexShader::getSemanticIndex(const std::string &attributeName)
{
if(!attributeName.empty())
{
- int semanticIndex = 0;
- for(AttributeArray::iterator attribute = mAttributes.begin(); attribute != mAttributes.end(); attribute++)
+ for(sh::ActiveAttributes::iterator attribute = activeAttributes.begin(); attribute != activeAttributes.end(); attribute++)
{
if(attribute->name == attributeName)
{
- return semanticIndex;
+ return attribute->registerIndex;
}
-
- semanticIndex += VariableRowCount(attribute->type);
}
}
return -1;
}
-void VertexShader::parseAttributes()
+sw::Shader *VertexShader::getShader() const
{
- if(mHlsl)
- {
- const char *input = strstr(mHlsl, "// Attributes") + 14;
+ return vertexShader;
+}
- while(true)
- {
- char attributeType[256];
- char attributeName[256];
-
- int matches = sscanf(input, "static %255s _%255s", attributeType, attributeName);
-
- if(matches != 2)
- {
- break;
- }
-
- mAttributes.push_back(Attribute(parseType(attributeType), attributeName));
-
- input = strstr(input, ";") + 2;
- }
- }
+sw::VertexShader *VertexShader::getVertexShader() const
+{
+ return vertexShader;
}
FragmentShader::FragmentShader(ResourceManager *manager, GLuint handle) : Shader(manager, handle)
{
+ pixelShader = 0;
}
FragmentShader::~FragmentShader()
{
+ delete pixelShader;
}
GLenum FragmentShader::getType()
@@ -516,8 +485,70 @@
void FragmentShader::compile()
{
- compileToHLSL(mFragmentCompiler);
- parseVaryings();
- varyings.sort(compareVarying);
+ clear();
+ initializeCompiler();
+
+ delete pixelShader;
+ pixelShader = new sw::PixelShader();
+
+ TranslatorASM *assembler = new TranslatorASM(this, SH_FRAGMENT_SHADER, SH_GLES2_SPEC);
+
+ ShBuiltInResources resources;
+ ShInitBuiltInResources(&resources);
+ resources.MaxVertexAttribs = MAX_VERTEX_ATTRIBS;
+ resources.MaxVertexUniformVectors = MAX_VERTEX_UNIFORM_VECTORS;
+ resources.MaxVaryingVectors = MAX_VARYING_VECTORS;
+ resources.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
+ resources.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
+ resources.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
+ resources.MaxFragmentUniformVectors = MAX_FRAGMENT_UNIFORM_VECTORS;
+ resources.MaxDrawBuffers = MAX_DRAW_BUFFERS;
+ resources.OES_standard_derivatives = 1;
+ assembler->Init(resources);
+
+ // Ensure we don't pass a NULL source to the compiler
+ char *source = "\0";
+ if(mSource)
+ {
+ source = mSource;
+ }
+
+ int success = ShCompile(assembler, &source, 1, SH_OBJECT_CODE);
+
+ if(false)
+ {
+ static int serial = 1;
+ char buffer[256];
+ sprintf(buffer, "pixel-input-%d-%d.txt", getHandle(), serial);
+ FILE *file = fopen(buffer, "wt");
+ fprintf(file, mSource);
+ fclose(file);
+ pixelShader->print("pixel-output-%d-%d.txt", getHandle(), serial);
+ serial++;
+ }
+
+ if(!success)
+ {
+ delete pixelShader;
+ pixelShader = 0;
+
+ int infoLogLen = 0;
+ ShGetInfo(assembler, SH_INFO_LOG_LENGTH, &infoLogLen);
+ mInfoLog = new char[infoLogLen];
+ ShGetInfoLog(assembler, mInfoLog);
+ TRACE("\n%s", mInfoLog);
+ }
+
+ delete assembler;
+}
+
+sw::Shader *FragmentShader::getShader() const
+{
+ return pixelShader;
+}
+
+sw::PixelShader *FragmentShader::getPixelShader() const
+{
+ return pixelShader;
}
}
diff --git a/src/OpenGL ES 2.0/libGLESv2/Shader.h b/src/OpenGL ES 2.0/libGLESv2/Shader.h
index 52474ca..eaad0da 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Shader.h
+++ b/src/OpenGL ES 2.0/libGLESv2/Shader.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Shader.h: Defines the abstract Shader class and its concrete derived
@@ -14,26 +19,41 @@
#include "ResourceManager.h"
+#include "compiler/TranslatorASM.h"
+
#define GL_APICALL
#include <GLES2/gl2.h>
-#include <d3dx9.h>
#include <list>
#include <vector>
+namespace sh
+{
+ class OutputASM;
+}
+
namespace gl
{
struct Varying
{
- Varying(GLenum type, const std::string &name, int size, bool array)
- : type(type), name(name), size(size), array(array), reg(-1), col(-1)
+ Varying(GLenum type, const std::string &name, int arraySize, int reg = -1, int col = -1)
+ : type(type), name(name), arraySize(arraySize), reg(reg), col(col)
{
}
+ bool isArray() const
+ {
+ return arraySize >= 1;
+ }
+
+ int size() const // Unify with gl::Uniform?
+ {
+ return arraySize > 0 ? arraySize : 1;
+ }
+
GLenum type;
std::string name;
- int size; // Number of 'type' elements
- bool array;
+ int arraySize;
int reg; // First varying register, assigned during link
int col; // First register element, assigned during link
@@ -44,8 +64,9 @@
class Shader
{
friend Program;
+ friend sh::OutputASM;
- public:
+public:
Shader(ResourceManager *manager, GLuint handle);
virtual ~Shader();
@@ -62,7 +83,10 @@
virtual void compile() = 0;
bool isCompiled();
- const char *getHLSL();
+
+ virtual sw::Shader *getShader() const = 0;
+ virtual sw::PixelShader *getPixelShader() const;
+ virtual sw::VertexShader *getVertexShader() const;
void addRef();
void release();
@@ -72,58 +96,38 @@
static void releaseCompiler();
- protected:
- DISALLOW_COPY_AND_ASSIGN(Shader);
-
- void parseVaryings();
-
- void compileToHLSL(void *compiler);
+protected:
+ void clear();
+ void initializeCompiler();
static GLenum parseType(const std::string &type);
static bool compareVarying(const Varying &x, const Varying &y);
- const GLuint mHandle;
+ char *mSource;
+ char *mInfoLog;
+
+ VaryingList varyings;
+ sh::ActiveUniforms activeUniforms;
+ sh::ActiveAttributes activeAttributes;
+
+private:
+ DISALLOW_COPY_AND_ASSIGN(Shader);
+
+ const GLuint mHandle;
unsigned int mRefCount; // Number of program objects this shader is attached to
bool mDeleteStatus; // Flag to indicate that the shader can be deleted when no longer in use
- char *mSource;
- char *mHlsl;
- char *mInfoLog;
+ ResourceManager *mResourceManager;
- VaryingList varyings;
-
- bool mUsesFragCoord;
- bool mUsesFrontFacing;
- bool mUsesPointSize;
- bool mUsesPointCoord;
-
- ResourceManager *mResourceManager;
-
- static void *mFragmentCompiler;
- static void *mVertexCompiler;
+ static void *mFragmentCompiler;
+ static void *mVertexCompiler;
};
-struct Attribute
-{
- Attribute() : type(GL_NONE), name("")
- {
- }
-
- Attribute(GLenum type, const std::string &name) : type(type), name(name)
- {
- }
-
- GLenum type;
- std::string name;
-};
-
-typedef std::vector<Attribute> AttributeArray;
-
class VertexShader : public Shader
{
friend Program;
- public:
+public:
VertexShader(ResourceManager *manager, GLuint handle);
~VertexShader();
@@ -132,17 +136,18 @@
virtual void compile();
int getSemanticIndex(const std::string &attributeName);
- private:
+ virtual sw::Shader *getShader() const;
+ virtual sw::VertexShader *getVertexShader() const;
+
+private:
DISALLOW_COPY_AND_ASSIGN(VertexShader);
- void parseAttributes();
-
- AttributeArray mAttributes;
+ sw::VertexShader *vertexShader;
};
class FragmentShader : public Shader
{
- public:
+public:
FragmentShader(ResourceManager *manager, GLuint handle);
~FragmentShader();
@@ -150,8 +155,13 @@
virtual GLenum getType();
virtual void compile();
- private:
+ virtual sw::Shader *getShader() const;
+ virtual sw::PixelShader *getPixelShader() const;
+
+private:
DISALLOW_COPY_AND_ASSIGN(FragmentShader);
+
+ sw::PixelShader *pixelShader;
};
}
diff --git a/src/OpenGL ES 2.0/libGLESv2/Texture.cpp b/src/OpenGL ES 2.0/libGLESv2/Texture.cpp
index 7656ab4..b537581 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Texture.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Texture.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Texture.cpp: Implements the Texture class and its derived classes
@@ -32,6 +37,14 @@
{
return sw::FORMAT_DXT1;
}
+ else if(type == GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE)
+ {
+ return sw::FORMAT_DXT3;
+ }
+ else if(type == GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE)
+ {
+ return sw::FORMAT_DXT5;
+ }
else
#endif
if(type == GL_FLOAT)
@@ -180,9 +193,8 @@
void Texture::loadImageData(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type,
GLint unpackAlignment, const void *input, size_t outputPitch, void *output, Image *image) const
{
- GLsizei inputPitch = -ComputePitch(width, format, type, unpackAlignment);
- input = ((char*)input) - inputPitch * (height - 1);
-
+ GLsizei inputPitch = ComputePitch(width, format, type, unpackAlignment);
+
switch (type)
{
case GL_UNSIGNED_BYTE:
@@ -714,67 +726,6 @@
}
}
-void Texture::loadCompressedImageData(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
- int inputPitch, const void *input, size_t outputPitch, void *output) const
-{
- ASSERT(xoffset % 4 == 0);
- ASSERT(yoffset % 4 == 0);
- ASSERT(width % 4 == 0 || width == 2 || width == 1);
- ASSERT(inputPitch % 8 == 0);
- ASSERT(outputPitch % 8 == 0);
-
- const unsigned int *source = reinterpret_cast<const unsigned int*>(input);
- unsigned int *dest = reinterpret_cast<unsigned int*>(output);
-
- switch (height)
- {
- case 1:
- // Round width up in case it is 1.
- for(int x = 0; x < (width + 1) / 2; x += 2)
- {
- // First 32-bits is two RGB565 colors shared by tile and does not need to be modified.
- dest[x] = source[x];
-
- // Second 32-bits contains 4 rows of 4 2-bit interpolants between the colors, the last 3 rows being unused. No flipping should occur.
- dest[x + 1] = source[x + 1];
- }
- break;
- case 2:
- // Round width up in case it is 1.
- for(int x = 0; x < (width + 1) / 2; x += 2)
- {
- // First 32-bits is two RGB565 colors shared by tile and does not need to be modified.
- dest[x] = source[x];
-
- // Second 32-bits contains 4 rows of 4 2-bit interpolants between the colors, the last 2 rows being unused. Only the top 2 rows should be flipped.
- dest[x + 1] = ((source[x + 1] << 8) & 0x0000FF00) |
- ((source[x + 1] >> 8) & 0x000000FF);
- }
- break;
- default:
- ASSERT(height % 4 == 0);
- for(int y = 0; y < height / 4; ++y)
- {
- const unsigned int *source = reinterpret_cast<const unsigned int*>(static_cast<const unsigned char*>(input) + y * inputPitch);
- unsigned int *dest = reinterpret_cast<unsigned int*>(static_cast<unsigned char*>(output) + (y + yoffset) * outputPitch + xoffset * 8);
-
- // Round width up in case it is 1.
- for(int x = 0; x < (width + 1) / 2; x += 2)
- {
- // First 32-bits is two RGB565 colors shared by tile and does not need to be modified.
- dest[x] = source[x];
-
- // Second 32-bits contains 4 rows of 4 2-bit interpolants between the colors. All rows should be flipped.
- dest[x + 1] = (source[x + 1] >> 24) |
- ((source[x + 1] << 8) & 0x00FF0000) |
- ((source[x + 1] >> 8) & 0x0000FF00) |
- (source[x + 1] << 24);
- }
- }
- break;
- }
-}
-
void Texture::setImage(GLint unpackAlignment, const void *pixels, Image *image)
{
if(pixels && image)
@@ -797,9 +748,7 @@
if(buffer)
{
- int inputPitch = ComputeCompressedPitch(image->getWidth(), image->getFormat());
- int inputSize = ComputeCompressedSize(image->getWidth(), image->getHeight(), image->getFormat());
- loadCompressedImageData(0, 0, image->getWidth(), image->getHeight(), -inputPitch, static_cast<const char*>(pixels) + inputSize - inputPitch, image->getPitch(), buffer);
+ memcpy(buffer, pixels, imageSize);
image->unlock();
}
}
@@ -830,7 +779,7 @@
if(pixels)
{
void *buffer = image->lock(0, 0, sw::LOCK_WRITEONLY);
- loadImageData(xoffset, transformPixelYOffset(yoffset, height, image->getHeight()), width, height, format, type, unpackAlignment, pixels, image->getPitch(), buffer, image);
+ loadImageData(xoffset, yoffset, width, height, format, type, unpackAlignment, pixels, image->getPitch(), buffer, image);
image->unlock();
}
}
@@ -856,8 +805,13 @@
{
void *buffer = image->lock(xoffset, yoffset, sw::LOCK_WRITEONLY);
int inputPitch = ComputeCompressedPitch(width, format);
- int inputSize = ComputeCompressedSize(width, height, format);
- loadCompressedImageData(xoffset, transformPixelYOffset(yoffset, height, image->getHeight()), width, height, -inputPitch, static_cast<const char*>(pixels) + inputSize - inputPitch, image->getPitch(), buffer);
+ int rows = imageSize / inputPitch;
+
+ for(int i = 0; i < rows; i++)
+ {
+ memcpy((void*)((BYTE*)buffer + i * image->getPitch()), (void*)((BYTE*)pixels + i * inputPitch), inputPitch);
+ }
+
image->unlock();
}
}
@@ -866,7 +820,7 @@
{
Device *device = getDevice();
- sw::Rect destRect = {xoffset, yoffset, xoffset + (sourceRect.right - sourceRect.left), yoffset + (sourceRect.bottom - sourceRect.top)};
+ sw::Rect destRect = {xoffset, yoffset, xoffset + (sourceRect.x1 - sourceRect.x0), yoffset + (sourceRect.y1 - sourceRect.y0)};
bool success = device->stretchRect(source, &sourceRect, dest, &destRect, false);
if(!success)
@@ -921,14 +875,14 @@
return GL_TEXTURE_2D;
}
-GLsizei Texture2D::getWidth() const
+GLsizei Texture2D::getWidth(GLint level) const
{
- return image[0] ? image[0]->getWidth() : 0;
+ return image[level] ? image[level]->getWidth() : 0;
}
-GLsizei Texture2D::getHeight() const
+GLsizei Texture2D::getHeight(GLint level) const
{
- return image[0] ? image[0]->getHeight() : 0;
+ return image[level] ? image[level]->getHeight() : 0;
}
GLenum Texture2D::getFormat() const
@@ -965,7 +919,7 @@
image[level]->unbind();
}
- image[level] = new Image(getResource(), width, height, format, type);
+ image[level] = new Image(resource, width, height, format, type);
if(!image[level])
{
@@ -1005,6 +959,7 @@
image[0] = surface->getRenderTarget();
image[0]->bind();
+ image[0]->release();
mSurface = surface;
mSurface->setBoundTexture(this);
@@ -1024,6 +979,20 @@
void Texture2D::setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels)
{
+ if(image[level])
+ {
+ image[level]->unbind();
+ }
+
+ image[level] = new Image(resource, width, height, format, GL_UNSIGNED_BYTE);
+
+ if(!image[level])
+ {
+ return error(GL_OUT_OF_MEMORY);
+ }
+
+ image[level]->bind();
+
Texture::setCompressedImage(imageSize, pixels, image[level]);
}
@@ -1052,7 +1021,7 @@
image[level]->unbind();
}
- image[level] = new Image(getResource(), width, height, format, GL_UNSIGNED_BYTE);
+ image[level] = new Image(resource, width, height, format, GL_UNSIGNED_BYTE);
if(!image[level])
{
@@ -1063,16 +1032,13 @@
if(width != 0 && height != 0)
{
- sw::Rect sourceRect = transformPixelRect(x, y, width, height, source->getColorbuffer()->getHeight());
- sourceRect.left = clamp(sourceRect.left, 0, source->getColorbuffer()->getWidth());
- sourceRect.top = clamp(sourceRect.top, 0, source->getColorbuffer()->getHeight());
- sourceRect.right = clamp(sourceRect.right, 0, source->getColorbuffer()->getWidth());
- sourceRect.bottom = clamp(sourceRect.bottom, 0, source->getColorbuffer()->getHeight());
+ sw::Rect sourceRect = {x, y, x + width, y + height};
+ sourceRect.clip(0, 0, source->getColorbuffer()->getWidth(), source->getColorbuffer()->getHeight());
- GLint destYOffset = transformPixelYOffset(0, height, image[level]->getHeight());
-
- copy(source->getRenderTarget(), sourceRect, format, 0, destYOffset, image[level]);
+ copy(renderTarget, sourceRect, format, 0, 0, image[level]);
}
+
+ renderTarget->release();
}
void Texture2D::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source)
@@ -1095,19 +1061,16 @@
return error(GL_OUT_OF_MEMORY);
}
- sw::Rect sourceRect = transformPixelRect(x, y, width, height, source->getColorbuffer()->getHeight());
- sourceRect.left = clamp(sourceRect.left, 0, source->getColorbuffer()->getWidth());
- sourceRect.top = clamp(sourceRect.top, 0, source->getColorbuffer()->getHeight());
- sourceRect.right = clamp(sourceRect.right, 0, source->getColorbuffer()->getWidth());
- sourceRect.bottom = clamp(sourceRect.bottom, 0, source->getColorbuffer()->getHeight());
+ sw::Rect sourceRect = {x, y, x + width, y + height};
+ sourceRect.clip(0, 0, source->getColorbuffer()->getWidth(), source->getColorbuffer()->getHeight());
- GLint destYOffset = transformPixelYOffset(yoffset, height, image[level]->getHeight());
+ copy(renderTarget, sourceRect, image[level]->getFormat(), xoffset, yoffset, image[level]);
- copy(source->getRenderTarget(), sourceRect, image[level]->getFormat(), xoffset, destYOffset, image[level]);
+ renderTarget->release();
}
-// Tests for GL texture object completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81.
-bool Texture2D::isComplete() const
+// Tests for 2D texture sampling completeness. [OpenGL ES 2.0.24] section 3.8.2 page 85.
+bool Texture2D::isSamplerComplete() const
{
if(!image[0])
{
@@ -1141,34 +1104,48 @@
if(mipmapping)
{
- int q = log2(std::max(width, height));
-
- for(int level = 1; level <= q; level++)
+ if(!isMipmapComplete())
{
- if(!image[level])
- {
- return false;
- }
+ return false;
+ }
+ }
- if(image[level]->getFormat() != image[0]->getFormat())
- {
- return false;
- }
+ return true;
+}
- if(image[level]->getType() != image[0]->getType())
- {
- return false;
- }
+// Tests for 2D texture (mipmap) completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81.
+bool Texture2D::isMipmapComplete() const
+{
+ GLsizei width = image[0]->getWidth();
+ GLsizei height = image[0]->getHeight();
- if(image[level]->getWidth() != std::max(1, width >> level))
- {
- return false;
- }
+ int q = log2(std::max(width, height));
- if(image[level]->getHeight() != std::max(1, height >> level))
- {
- return false;
- }
+ for(int level = 1; level <= q; level++)
+ {
+ if(!image[level])
+ {
+ return false;
+ }
+
+ if(image[level]->getFormat() != image[0]->getFormat())
+ {
+ return false;
+ }
+
+ if(image[level]->getType() != image[0]->getType())
+ {
+ return false;
+ }
+
+ if(image[level]->getWidth() != std::max(1, width >> level))
+ {
+ return false;
+ }
+
+ if(image[level]->getHeight() != std::max(1, height >> level))
+ {
+ return false;
}
}
@@ -1196,7 +1173,7 @@
image[i]->unbind();
}
- image[i] = new Image(getResource(), std::max(image[0]->getWidth() >> i, 1), std::max(image[0]->getHeight() >> i, 1), image[0]->getFormat(), image[0]->getType());
+ image[i] = new Image(resource, std::max(image[0]->getWidth() >> i, 1), std::max(image[0]->getHeight() >> i, 1), image[0]->getFormat(), image[0]->getType());
if(!image[i])
{
@@ -1286,14 +1263,14 @@
return GL_TEXTURE_CUBE_MAP;
}
-GLsizei TextureCubeMap::getWidth() const
+GLsizei TextureCubeMap::getWidth(GLint level) const
{
- return image[0][0] ? image[0][0]->getWidth() : 0;
+ return image[0][level] ? image[0][level]->getWidth() : 0;
}
-GLsizei TextureCubeMap::getHeight() const
+GLsizei TextureCubeMap::getHeight(GLint level) const
{
- return image[0][0] ? image[0][0]->getHeight() : 0;
+ return image[0][level] ? image[0][level]->getHeight() : 0;
}
GLenum TextureCubeMap::getFormat() const
@@ -1354,8 +1331,8 @@
Texture::subImageCompressed(xoffset, yoffset, width, height, format, imageSize, pixels, image[ConvertCubeFace(target)][level]);
}
-// Tests for GL texture object completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81.
-bool TextureCubeMap::isComplete() const
+// Tests for cube map sampling completeness. [OpenGL ES 2.0.24] section 3.8.2 page 86.
+bool TextureCubeMap::isSamplerComplete() const
{
for(int face = 0; face < 6; face++)
{
@@ -1374,7 +1351,7 @@
bool mipmapping;
- switch (mMinFilter)
+ switch(mMinFilter)
{
case GL_NEAREST:
case GL_LINEAR:
@@ -1389,43 +1366,78 @@
default: UNREACHABLE();
}
- for(int face = 0; face < 6; face++)
+ if(!mipmapping)
{
- if(image[face][0]->getWidth() != size || image[face][0]->getHeight() != size)
+ if(!isCubeComplete())
+ {
+ return false;
+ }
+ }
+ else
+ {
+ if(!isMipmapCubeComplete()) // Also tests for isCubeComplete()
{
return false;
}
}
- if(mipmapping)
+ return true;
+}
+
+// Tests for cube texture completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81.
+bool TextureCubeMap::isCubeComplete() const
+{
+ if(image[0][0]->getWidth() <= 0 || image[0][0]->getHeight() != image[0][0]->getWidth())
{
- int q = log2(size);
+ return false;
+ }
- for(int face = 0; face < 6; face++)
+ for(unsigned int face = 1; face < 6; face++)
+ {
+ if(image[face][0]->getWidth() != image[0][0]->getWidth() ||
+ image[face][0]->getWidth() != image[0][0]->getHeight() ||
+ image[face][0]->getFormat() != image[0][0]->getFormat() ||
+ image[face][0]->getType() != image[0][0]->getType())
{
- for(int level = 1; level <= q; level++)
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool TextureCubeMap::isMipmapCubeComplete() const
+{
+ if(!isCubeComplete())
+ {
+ return false;
+ }
+
+ GLsizei size = image[0][0]->getWidth();
+ int q = log2(size);
+
+ for(int face = 0; face < 6; face++)
+ {
+ for(int level = 1; level <= q; level++)
+ {
+ if(!image[face][level])
+ {
+ return false;
+ }
+
+ if(image[face][level]->getFormat() != image[0][0]->getFormat())
{
- if(!image[face][level])
- {
- return false;
- }
+ return false;
+ }
- if(image[face][level]->getFormat() != image[0][0]->getFormat())
- {
- return false;
- }
+ if(image[face][level]->getType() != image[0][0]->getType())
+ {
+ return false;
+ }
- if(image[face][level]->getType() != image[0][0]->getType())
- {
- return false;
- }
-
- if(image[face][level]->getWidth() != std::max(1, size >> level))
- {
- return false;
- }
-
- ASSERT(image[face][level]->getHeight() == image[face][level]->getWidth());
+ if(image[face][level]->getWidth() != std::max(1, size >> level))
+ {
+ return false;
}
}
}
@@ -1487,16 +1499,13 @@
if(width != 0 && height != 0)
{
- sw::Rect sourceRect = transformPixelRect(x, y, width, height, source->getColorbuffer()->getHeight());
- sourceRect.left = clamp(sourceRect.left, 0, source->getColorbuffer()->getWidth());
- sourceRect.top = clamp(sourceRect.top, 0, source->getColorbuffer()->getHeight());
- sourceRect.right = clamp(sourceRect.right, 0, source->getColorbuffer()->getWidth());
- sourceRect.bottom = clamp(sourceRect.bottom, 0, source->getColorbuffer()->getHeight());
-
- GLint destYOffset = transformPixelYOffset(0, height, image[face][level]->getHeight());
+ sw::Rect sourceRect = {x, y, x + width, y + height};
+ sourceRect.clip(0, 0, source->getColorbuffer()->getWidth(), source->getColorbuffer()->getHeight());
- copy(source->getRenderTarget(), sourceRect, format, 0, destYOffset, image[face][level]);
+ copy(renderTarget, sourceRect, format, 0, 0, image[face][level]);
}
+
+ renderTarget->release();
}
Image *TextureCubeMap::getImage(CubeFace face, unsigned int level)
@@ -1525,7 +1534,7 @@
return error(GL_INVALID_VALUE);
}
- Image *renderTarget = source->getRenderTarget();
+ Image *renderTarget = source->getRenderTarget();
if(!renderTarget)
{
@@ -1533,41 +1542,12 @@
return error(GL_OUT_OF_MEMORY);
}
- sw::Rect sourceRect = transformPixelRect(x, y, width, height, source->getColorbuffer()->getHeight());
- sourceRect.left = clamp(sourceRect.left, 0, source->getColorbuffer()->getWidth());
- sourceRect.top = clamp(sourceRect.top, 0, source->getColorbuffer()->getHeight());
- sourceRect.right = clamp(sourceRect.right, 0, source->getColorbuffer()->getWidth());
- sourceRect.bottom = clamp(sourceRect.bottom, 0, source->getColorbuffer()->getHeight());
+ sw::Rect sourceRect = {x, y, x + width, y + height};
+ sourceRect.clip(0, 0, source->getColorbuffer()->getWidth(), source->getColorbuffer()->getHeight());
- GLint destYOffset = transformPixelYOffset(yoffset, height, image[face][level]->getHeight());
+ copy(renderTarget, sourceRect, image[face][level]->getFormat(), xoffset, yoffset, image[face][level]);
- copy(source->getRenderTarget(), sourceRect, image[face][level]->getFormat(), xoffset, destYOffset, image[face][level]);
-}
-
-bool TextureCubeMap::isCubeComplete() const
-{
- for(unsigned int f = 1; f < 6; f++)
- {
- if(!image[f][0])
- {
- return false;
- }
- }
-
- if(image[0][0]->getWidth() == 0)
- {
- return false;
- }
-
- for(unsigned int f = 1; f < 6; f++)
- {
- if(image[f][0]->getWidth() != image[0][0]->getWidth() || image[f][0]->getFormat() != image[0][0]->getFormat())
- {
- return false;
- }
- }
-
- return true;
+ renderTarget->release();
}
void TextureCubeMap::generateMipmaps()
diff --git a/src/OpenGL ES 2.0/libGLESv2/Texture.h b/src/OpenGL ES 2.0/libGLESv2/Texture.h
index 6ccb1d4..f5c46b0 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Texture.h
+++ b/src/OpenGL ES 2.0/libGLESv2/Texture.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// Texture.h: Defines the abstract Texture class and its concrete derived
@@ -64,14 +69,14 @@
GLenum getWrapS() const;
GLenum getWrapT() const;
- virtual GLsizei getWidth() const = 0;
- virtual GLsizei getHeight() const = 0;
+ virtual GLsizei getWidth(GLint level = 0) const = 0;
+ virtual GLsizei getHeight(GLint level = 0) const = 0;
virtual GLenum getFormat() const = 0;
virtual GLenum getType() const = 0;
virtual sw::Format getInternalFormat() const = 0;
virtual int getLevelCount() const = 0;
- virtual bool isComplete() const = 0;
+ virtual bool isSamplerComplete() const = 0;
virtual bool isCompressed() const = 0;
virtual Renderbuffer *getRenderbuffer(GLenum target) = 0;
@@ -143,8 +148,6 @@
int inputPitch, const void *input, size_t outputPitch, void *output) const;
void loadBGRAImageData(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
int inputPitch, const void *input, size_t outputPitch, void *output) const;
- void loadCompressedImageData(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
- int inputPitch, const void *input, size_t outputPitch, void *output) const;
};
class Texture2D : public Texture
@@ -158,8 +161,8 @@
virtual GLenum getTarget() const;
- virtual GLsizei getWidth() const;
- virtual GLsizei getHeight() const;
+ virtual GLsizei getWidth(GLint level = 0) const;
+ virtual GLsizei getHeight(GLint level = 0) const;
virtual GLenum getFormat() const;
virtual GLenum getType() const;
virtual sw::Format getInternalFormat() const;
@@ -172,7 +175,7 @@
void copyImage(GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source);
void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source);
- virtual bool isComplete() const;
+ virtual bool isSamplerComplete() const;
virtual bool isCompressed() const;
virtual void bindTexImage(egl::Surface *surface);
virtual void releaseTexImage();
@@ -184,7 +187,9 @@
Image *getRenderTarget(GLenum target);
private:
- Image *image[MIPMAP_LEVELS];
+ bool isMipmapComplete() const;
+
+ Image *image[IMPLEMENTATION_MAX_TEXTURE_LEVELS];
egl::Surface *mSurface;
BindingPointer<Renderbuffer> mColorbufferProxy;
@@ -201,8 +206,8 @@
virtual GLenum getTarget() const;
- virtual GLsizei getWidth() const;
- virtual GLsizei getHeight() const;
+ virtual GLsizei getWidth(GLint level = 0) const;
+ virtual GLsizei getHeight(GLint level = 0) const;
virtual GLenum getFormat() const;
virtual GLenum getType() const;
virtual sw::Format getInternalFormat() const;
@@ -216,7 +221,7 @@
void copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source);
virtual void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source);
- virtual bool isComplete() const;
+ virtual bool isSamplerComplete() const;
virtual bool isCompressed() const;
virtual void generateMipmaps();
@@ -227,6 +232,7 @@
private:
bool isCubeComplete() const;
+ bool isMipmapCubeComplete() const;
virtual Image *getRenderTarget(GLenum target);
diff --git a/src/OpenGL ES 2.0/libGLESv2/VertexDataManager.cpp b/src/OpenGL ES 2.0/libGLESv2/VertexDataManager.cpp
index 44abf4e..52e0e42 100644
--- a/src/OpenGL ES 2.0/libGLESv2/VertexDataManager.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/VertexDataManager.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// VertexDataManager.h: Defines the VertexDataManager, a class that
@@ -11,7 +16,6 @@
#include "Buffer.h"
#include "Program.h"
-#include "main.h"
#include "IndexDataManager.h"
#include "common/debug.h"
@@ -23,7 +27,7 @@
namespace gl
{
-VertexDataManager::VertexDataManager(Context *context, Device *device) : mContext(context), mDevice(device)
+VertexDataManager::VertexDataManager(Context *context) : mContext(context)
{
for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
{
@@ -31,7 +35,7 @@
mCurrentValueBuffer[i] = NULL;
}
- mStreamingBuffer = new StreamingVertexBuffer(mDevice, INITIAL_STREAM_BUFFER_SIZE);
+ mStreamingBuffer = new StreamingVertexBuffer(INITIAL_STREAM_BUFFER_SIZE);
if(!mStreamingBuffer)
{
@@ -49,7 +53,7 @@
}
}
-UINT VertexDataManager::writeAttributeData(ArrayVertexBuffer *vertexBuffer, GLint start, GLsizei count, const VertexAttribute &attribute)
+UINT VertexDataManager::writeAttributeData(StreamingVertexBuffer *vertexBuffer, GLint start, GLsizei count, const VertexAttribute &attribute)
{
Buffer *buffer = attribute.mBoundBuffer.get();
@@ -61,7 +65,7 @@
if(vertexBuffer)
{
- output = (char*)vertexBuffer->map(attribute, spaceRequired(attribute, count), &streamOffset);
+ output = (char*)vertexBuffer->map(attribute, attribute.typeSize() * count, &streamOffset);
}
if(output == NULL)
@@ -114,19 +118,14 @@
const VertexAttributeArray &attribs = mContext->getVertexAttributes();
Program *program = mContext->getCurrentProgram();
- for(int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
- {
- translated[attributeIndex].active = (program->getSemanticIndex(attributeIndex) != -1);
- }
-
- // Determine the required storage size per used buffer, and invalidate static buffers that don't contain matching attributes
+ // Determine the required storage size per used buffer
for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
{
- if(translated[i].active && attribs[i].mArrayEnabled)
+ if(program->getAttributeStream(i) != -1 && attribs[i].mArrayEnabled)
{
if(!attribs[i].mBoundBuffer)
{
- mStreamingBuffer->addRequiredSpace(spaceRequired(attribs[i], count));
+ mStreamingBuffer->addRequiredSpace(attribs[i].typeSize() * count);
}
}
}
@@ -136,7 +135,7 @@
// Perform the vertex data translations
for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
{
- if(translated[i].active)
+ if(program->getAttributeStream(i) != -1)
{
if(attribs[i].mArrayEnabled)
{
@@ -190,7 +189,7 @@
if(mDirtyCurrentValue[i])
{
delete mCurrentValueBuffer[i];
- mCurrentValueBuffer[i] = new ConstantVertexBuffer(mDevice, attribs[i].mCurrentValue[0], attribs[i].mCurrentValue[1], attribs[i].mCurrentValue[2], attribs[i].mCurrentValue[3]);
+ mCurrentValueBuffer[i] = new ConstantVertexBuffer(attribs[i].mCurrentValue[0], attribs[i].mCurrentValue[1], attribs[i].mCurrentValue[2], attribs[i].mCurrentValue[3]);
mDirtyCurrentValue[i] = false;
}
@@ -207,12 +206,7 @@
return GL_NO_ERROR;
}
-std::size_t VertexDataManager::spaceRequired(const VertexAttribute &attrib, std::size_t count) const
-{
- return attrib.typeSize() * count;
-}
-
-VertexBuffer::VertexBuffer(Device *device, std::size_t size) : mDevice(device), mVertexBuffer(NULL)
+VertexBuffer::VertexBuffer(std::size_t size) : mVertexBuffer(NULL)
{
if(size > 0)
{
@@ -246,24 +240,12 @@
return mVertexBuffer;
}
-ConstantVertexBuffer::ConstantVertexBuffer(Device *device, float x, float y, float z, float w) : VertexBuffer(device, 4 * sizeof(float))
+ConstantVertexBuffer::ConstantVertexBuffer(float x, float y, float z, float w) : VertexBuffer(4 * sizeof(float))
{
- void *buffer = NULL;
-
if(mVertexBuffer)
{
- buffer = mVertexBuffer->lock(sw::PUBLIC);
+ float *vector = (float*)mVertexBuffer->lock(sw::PUBLIC);
- if(!buffer)
- {
- ERR("Lock failed");
- }
- }
-
- if(buffer)
- {
- float *vector = (float*)buffer;
-
vector[0] = x;
vector[1] = y;
vector[2] = z;
@@ -277,30 +259,22 @@
{
}
-ArrayVertexBuffer::ArrayVertexBuffer(Device *device, std::size_t size) : VertexBuffer(device, size)
+StreamingVertexBuffer::StreamingVertexBuffer(std::size_t size) : VertexBuffer(size)
{
mBufferSize = size;
mWritePosition = 0;
mRequiredSpace = 0;
}
-ArrayVertexBuffer::~ArrayVertexBuffer()
-{
-}
-
-void ArrayVertexBuffer::addRequiredSpace(UINT requiredSpace)
-{
- mRequiredSpace += requiredSpace;
-}
-
-StreamingVertexBuffer::StreamingVertexBuffer(Device *device, std::size_t initialSize) : ArrayVertexBuffer(device, initialSize)
-{
-}
-
StreamingVertexBuffer::~StreamingVertexBuffer()
{
}
+void StreamingVertexBuffer::addRequiredSpace(UINT requiredSpace)
+{
+ mRequiredSpace += requiredSpace;
+}
+
void *StreamingVertexBuffer::map(const VertexAttribute &attribute, std::size_t requiredSpace, std::size_t *offset)
{
void *mapPtr = NULL;
diff --git a/src/OpenGL ES 2.0/libGLESv2/VertexDataManager.h b/src/OpenGL ES 2.0/libGLESv2/VertexDataManager.h
index 2febc37..09f0e48 100644
--- a/src/OpenGL ES 2.0/libGLESv2/VertexDataManager.h
+++ b/src/OpenGL ES 2.0/libGLESv2/VertexDataManager.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// VertexDataManager.h: Defines the VertexDataManager, a class that
@@ -16,16 +21,11 @@
#define GL_APICALL
#include <GLES2/gl2.h>
-#include <vector>
-#include <cstddef>
-
namespace gl
{
struct TranslatedAttribute
{
- bool active;
-
sw::StreamType type;
int count;
bool normalized;
@@ -39,7 +39,7 @@
class VertexBuffer
{
public:
- VertexBuffer(Device *device, UINT size);
+ VertexBuffer(UINT size);
virtual ~VertexBuffer();
void unmap();
@@ -47,29 +47,24 @@
sw::Resource *getResource() const;
protected:
- Device *const mDevice;
sw::Resource *mVertexBuffer;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(VertexBuffer);
};
class ConstantVertexBuffer : public VertexBuffer
{
public:
- ConstantVertexBuffer(Device *device, float x, float y, float z, float w);
+ ConstantVertexBuffer(float x, float y, float z, float w);
~ConstantVertexBuffer();
};
-class ArrayVertexBuffer : public VertexBuffer
+class StreamingVertexBuffer : public VertexBuffer
{
public:
- ArrayVertexBuffer(Device *device, UINT size);
- ~ArrayVertexBuffer();
+ StreamingVertexBuffer(UINT size);
+ ~StreamingVertexBuffer();
- UINT size() const { return mBufferSize; }
- virtual void *map(const VertexAttribute &attribute, UINT requiredSpace, UINT *streamOffset) = 0;
- virtual void reserveRequiredSpace() = 0;
+ void *map(const VertexAttribute &attribute, UINT requiredSpace, UINT *streamOffset);
+ void reserveRequiredSpace();
void addRequiredSpace(UINT requiredSpace);
protected:
@@ -78,20 +73,10 @@
UINT mRequiredSpace;
};
-class StreamingVertexBuffer : public ArrayVertexBuffer
-{
- public:
- StreamingVertexBuffer(Device *device, UINT initialSize);
- ~StreamingVertexBuffer();
-
- void *map(const VertexAttribute &attribute, UINT requiredSpace, UINT *streamOffset);
- void reserveRequiredSpace();
-};
-
class VertexDataManager
{
public:
- VertexDataManager(Context *context, Device *backend);
+ VertexDataManager(Context *context);
virtual ~VertexDataManager();
void dirtyCurrentValue(int index) { mDirtyCurrentValue[index] = true; }
@@ -99,13 +84,9 @@
GLenum prepareVertexData(GLint start, GLsizei count, TranslatedAttribute *outAttribs);
private:
- DISALLOW_COPY_AND_ASSIGN(VertexDataManager);
-
- UINT spaceRequired(const VertexAttribute &attrib, std::size_t count) const;
- UINT writeAttributeData(ArrayVertexBuffer *vertexBuffer, GLint start, GLsizei count, const VertexAttribute &attribute);
+ UINT writeAttributeData(StreamingVertexBuffer *vertexBuffer, GLint start, GLsizei count, const VertexAttribute &attribute);
Context *const mContext;
- Device *const mDevice;
StreamingVertexBuffer *mStreamingBuffer;
diff --git a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.cpp b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.cpp
index ce9fb0a..ed23496 100644
--- a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.cpp
@@ -1,9 +1,13 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2011 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.
+// Copyright(c) 2005-2012 TransGaming Inc.
//
-
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
// libGLESv2.cpp: Implements the exported OpenGL ES 2.0 functions.
#include "main.h"
@@ -17,6 +21,7 @@
#include "Renderbuffer.h"
#include "Shader.h"
#include "Texture.h"
+#include "Query.h"
#include "common/debug.h"
#include "common/version.h"
@@ -29,7 +34,7 @@
bool validImageSize(GLint level, GLsizei width, GLsizei height)
{
- if(level < 0 || width < 0 || height < 0)
+ if(level < 0 || level >= gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS || width < 0 || height < 0)
{
return false;
}
@@ -37,6 +42,82 @@
return true;
}
+bool validateSubImageParams(bool compressed, GLsizei width, GLsizei height, GLint xoffset, GLint yoffset, GLint level, GLenum format, gl::Texture *texture)
+{
+ if(!texture)
+ {
+ return error(GL_INVALID_OPERATION, false);
+ }
+
+ if(compressed != texture->isCompressed())
+ {
+ return error(GL_INVALID_OPERATION, false);
+ }
+
+ if(format != GL_NONE && format != texture->getFormat())
+ {
+ return error(GL_INVALID_OPERATION, false);
+ }
+
+ if(compressed)
+ {
+ if((width % 4 != 0 && width != texture->getWidth(0)) ||
+ (height % 4 != 0 && height != texture->getHeight(0)))
+ {
+ return error(GL_INVALID_OPERATION, false);
+ }
+ }
+
+ if(xoffset + width > texture->getWidth(level) ||
+ yoffset + height > texture->getHeight(level))
+ {
+ return error(GL_INVALID_VALUE, false);
+ }
+
+ return true;
+}
+
+// Check for combinations of format and type that are valid for ReadPixels
+bool validReadFormatType(GLenum format, GLenum type)
+{
+ switch(format)
+ {
+ case GL_RGBA:
+ switch (type)
+ {
+ case GL_UNSIGNED_BYTE:
+ break;
+ default:
+ return false;
+ }
+ break;
+ case GL_BGRA_EXT:
+ switch (type)
+ {
+ case GL_UNSIGNED_BYTE:
+ case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT:
+ case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT:
+ break;
+ default:
+ return false;
+ }
+ break;
+ case gl::IMPLEMENTATION_COLOR_READ_FORMAT:
+ switch (type)
+ {
+ case gl::IMPLEMENTATION_COLOR_READ_TYPE:
+ break;
+ default:
+ return false;
+ }
+ break;
+ default:
+ return false;
+ }
+
+ return true;
+}
+
extern "C"
{
@@ -113,6 +194,39 @@
}
}
+void __stdcall glBeginQueryEXT(GLenum target, GLuint id)
+{
+ TRACE("(GLenum target = 0x%X, GLuint %d)", target, id);
+
+ try
+ {
+ switch(target)
+ {
+ case GL_ANY_SAMPLES_PASSED_EXT:
+ case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
+ break;
+ default:
+ return error(GL_INVALID_ENUM);
+ }
+
+ if(id == 0)
+ {
+ return error(GL_INVALID_OPERATION);
+ }
+
+ gl::Context *context = gl::getContext();
+
+ if(context)
+ {
+ context->beginQuery(target, id);
+ }
+ }
+ catch(std::bad_alloc&)
+ {
+ return error(GL_OUT_OF_MEMORY);
+ }
+}
+
void __stdcall glBindAttribLocation(GLuint program, GLuint index, const GLchar* name)
{
TRACE("(GLuint program = %d, GLuint index = %d, const GLchar* name = 0x%0.8p)", program, index, name);
@@ -166,7 +280,7 @@
if(context)
{
- switch (target)
+ switch(target)
{
case GL_ARRAY_BUFFER:
context->bindArrayBuffer(buffer);
@@ -258,7 +372,7 @@
return error(GL_INVALID_OPERATION);
}
- switch (target)
+ switch(target)
{
case GL_TEXTURE_2D:
context->bindTexture2D(texture);
@@ -308,7 +422,7 @@
try
{
- switch (modeRGB)
+ switch(modeRGB)
{
case GL_FUNC_ADD:
case GL_FUNC_SUBTRACT:
@@ -318,7 +432,7 @@
return error(GL_INVALID_ENUM);
}
- switch (modeAlpha)
+ switch(modeAlpha)
{
case GL_FUNC_ADD:
case GL_FUNC_SUBTRACT:
@@ -353,7 +467,7 @@
try
{
- switch (srcRGB)
+ switch(srcRGB)
{
case GL_ZERO:
case GL_ONE:
@@ -375,7 +489,7 @@
return error(GL_INVALID_ENUM);
}
- switch (dstRGB)
+ switch(dstRGB)
{
case GL_ZERO:
case GL_ONE:
@@ -396,7 +510,7 @@
return error(GL_INVALID_ENUM);
}
- switch (srcAlpha)
+ switch(srcAlpha)
{
case GL_ZERO:
case GL_ONE:
@@ -418,7 +532,7 @@
return error(GL_INVALID_ENUM);
}
- switch (dstAlpha)
+ switch(dstAlpha)
{
case GL_ZERO:
case GL_ONE:
@@ -464,7 +578,7 @@
return error(GL_INVALID_VALUE);
}
- switch (usage)
+ switch(usage)
{
case GL_STREAM_DRAW:
case GL_STATIC_DRAW:
@@ -480,7 +594,7 @@
{
gl::Buffer *buffer;
- switch (target)
+ switch(target)
{
case GL_ARRAY_BUFFER:
buffer = context->getArrayBuffer();
@@ -529,7 +643,7 @@
{
gl::Buffer *buffer;
- switch (target)
+ switch(target)
{
case GL_ARRAY_BUFFER:
buffer = context->getArrayBuffer();
@@ -745,12 +859,18 @@
return error(GL_INVALID_VALUE);
}
- switch (internalformat)
+ switch(internalformat)
{
- case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
- case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
+ case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
+ if(!S3TC_SUPPORT)
+ {
+ return error(GL_INVALID_ENUM);
+ }
break;
- default:
+ default:
return error(GL_INVALID_ENUM);
}
@@ -768,7 +888,7 @@
return error(GL_INVALID_VALUE);
}
- switch (target)
+ switch(target)
{
case GL_TEXTURE_2D:
if(width > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level) ||
@@ -789,7 +909,7 @@
}
if(width > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level) ||
- height > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level))
+ height > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level))
{
return error(GL_INVALID_VALUE);
}
@@ -798,11 +918,6 @@
return error(GL_INVALID_ENUM);
}
- if(!S3TC_SUPPORT)
- {
- return error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
- }
-
if(imageSize != gl::ComputeCompressedSize(width, height, internalformat))
{
return error(GL_INVALID_VALUE);
@@ -828,7 +943,7 @@
return error(GL_INVALID_OPERATION);
}
- switch (target)
+ switch(target)
{
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
@@ -870,12 +985,18 @@
return error(GL_INVALID_VALUE);
}
- switch (format)
+ switch(format)
{
- case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
- case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
+ case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
+ if(!S3TC_SUPPORT)
+ {
+ return error(GL_INVALID_ENUM);
+ }
break;
- default:
+ default:
return error(GL_INVALID_ENUM);
}
@@ -893,11 +1014,6 @@
return error(GL_INVALID_VALUE);
}
- if(!S3TC_SUPPORT)
- {
- return error(GL_INVALID_ENUM); // in this case, it's as though the format switch has failed.
- }
-
if(imageSize != gl::ComputeCompressedSize(width, height, format))
{
return error(GL_INVALID_VALUE);
@@ -905,53 +1021,27 @@
if(xoffset % 4 != 0 || yoffset % 4 != 0)
{
- return error(GL_INVALID_OPERATION); // we wait to check the offsets until this point, because the multiple-of-four restriction
- // does not exist unless DXT1 textures are supported.
+ // We wait to check the offsets until this point, because the multiple-of-four restriction does not exist unless DXT1 textures are supported
+ return error(GL_INVALID_OPERATION);
}
if(target == GL_TEXTURE_2D)
{
gl::Texture2D *texture = context->getTexture2D();
- if(!texture)
- {
- return error(GL_INVALID_OPERATION);
- }
-
- if(!texture->isCompressed())
- {
- return error(GL_INVALID_OPERATION);
- }
-
- if((width % 4 != 0 && width != texture->getWidth()) ||
- (height % 4 != 0 && height != texture->getHeight()))
- {
- return error(GL_INVALID_OPERATION);
- }
-
- texture->subImageCompressed(level, xoffset, yoffset, width, height, format, imageSize, data);
+ if(validateSubImageParams(true, width, height, xoffset, yoffset, level, format, texture))
+ {
+ texture->subImageCompressed(level, xoffset, yoffset, width, height, format, imageSize, data);
+ }
}
else if(gl::IsCubemapTextureTarget(target))
{
gl::TextureCubeMap *texture = context->getTextureCubeMap();
- if(!texture)
- {
- return error(GL_INVALID_OPERATION);
- }
-
- if(!texture->isCompressed())
- {
- return error(GL_INVALID_OPERATION);
- }
-
- if((width % 4 != 0 && width != texture->getWidth()) ||
- (height % 4 != 0 && height != texture->getHeight()))
- {
- return error(GL_INVALID_OPERATION);
- }
-
- texture->subImageCompressed(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+ if(validateSubImageParams(true, width, height, xoffset, yoffset, level, format, texture))
+ {
+ texture->subImageCompressed(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+ }
}
else
{
@@ -987,7 +1077,7 @@
if(context)
{
- switch (target)
+ switch(target)
{
case GL_TEXTURE_2D:
if(width > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level) ||
@@ -1070,6 +1160,8 @@
break;
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
+ case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
if(S3TC_SUPPORT)
{
return error(GL_INVALID_OPERATION);
@@ -1177,53 +1269,55 @@
}
else UNREACHABLE();
- if(!texture)
- {
- return error(GL_INVALID_OPERATION);
- }
+ if(!validateSubImageParams(false, width, height, xoffset, yoffset, level, GL_NONE, texture))
+ {
+ return;
+ }
GLenum textureFormat = texture->getFormat();
// [OpenGL ES 2.0.24] table 3.9
- switch (textureFormat)
+ switch(textureFormat)
{
- case GL_ALPHA:
+ case GL_ALPHA:
if(colorbufferFormat != GL_ALPHA &&
- colorbufferFormat != GL_RGBA &&
- colorbufferFormat != GL_RGBA4 &&
- colorbufferFormat != GL_RGB5_A1 &&
- colorbufferFormat != GL_RGBA8_OES)
+ colorbufferFormat != GL_RGBA &&
+ colorbufferFormat != GL_RGBA4 &&
+ colorbufferFormat != GL_RGB5_A1 &&
+ colorbufferFormat != GL_RGBA8_OES)
{
return error(GL_INVALID_OPERATION);
}
break;
- case GL_LUMINANCE:
- case GL_RGB:
+ case GL_LUMINANCE:
+ case GL_RGB:
if(colorbufferFormat != GL_RGB &&
- colorbufferFormat != GL_RGB565 &&
- colorbufferFormat != GL_RGB8_OES &&
- colorbufferFormat != GL_RGBA &&
- colorbufferFormat != GL_RGBA4 &&
- colorbufferFormat != GL_RGB5_A1 &&
- colorbufferFormat != GL_RGBA8_OES)
+ colorbufferFormat != GL_RGB565 &&
+ colorbufferFormat != GL_RGB8_OES &&
+ colorbufferFormat != GL_RGBA &&
+ colorbufferFormat != GL_RGBA4 &&
+ colorbufferFormat != GL_RGB5_A1 &&
+ colorbufferFormat != GL_RGBA8_OES)
{
return error(GL_INVALID_OPERATION);
}
break;
- case GL_LUMINANCE_ALPHA:
- case GL_RGBA:
+ case GL_LUMINANCE_ALPHA:
+ case GL_RGBA:
if(colorbufferFormat != GL_RGBA &&
- colorbufferFormat != GL_RGBA4 &&
- colorbufferFormat != GL_RGB5_A1 &&
- colorbufferFormat != GL_RGBA8_OES)
+ colorbufferFormat != GL_RGBA4 &&
+ colorbufferFormat != GL_RGB5_A1 &&
+ colorbufferFormat != GL_RGBA8_OES)
{
return error(GL_INVALID_OPERATION);
}
break;
- case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
- case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
+ case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
return error(GL_INVALID_OPERATION);
- default:
+ default:
return error(GL_INVALID_OPERATION);
}
@@ -1268,7 +1362,7 @@
if(context)
{
- switch (type)
+ switch(type)
{
case GL_FRAGMENT_SHADER:
case GL_VERTEX_SHADER:
@@ -1292,7 +1386,7 @@
try
{
- switch (mode)
+ switch(mode)
{
case GL_FRONT:
case GL_BACK:
@@ -1436,6 +1530,33 @@
}
}
+void __stdcall glDeleteQueriesEXT(GLsizei n, const GLuint *ids)
+{
+ TRACE("(GLsizei n = %d, const GLuint *ids = 0x%0.8p)", n, ids);
+
+ try
+ {
+ if(n < 0)
+ {
+ return error(GL_INVALID_VALUE);
+ }
+
+ gl::Context *context = gl::getContext();
+
+ if(context)
+ {
+ for(int i = 0; i < n; i++)
+ {
+ context->deleteQuery(ids[i]);
+ }
+ }
+ }
+ catch(std::bad_alloc&)
+ {
+ return error(GL_OUT_OF_MEMORY);
+ }
+}
+
void __stdcall glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
{
TRACE("(GLsizei n = %d, const GLuint* renderbuffers = 0x%0.8p)", n, renderbuffers);
@@ -1535,7 +1656,7 @@
try
{
- switch (func)
+ switch(func)
{
case GL_NEVER:
case GL_ALWAYS:
@@ -1664,7 +1785,7 @@
if(context)
{
- switch (cap)
+ switch(cap)
{
case GL_CULL_FACE: context->setCullFace(false); break;
case GL_POLYGON_OFFSET_FILL: context->setPolygonOffsetFill(false); break;
@@ -1750,7 +1871,7 @@
if(context)
{
- switch (type)
+ switch(type)
{
case GL_UNSIGNED_BYTE:
case GL_UNSIGNED_SHORT:
@@ -1779,7 +1900,7 @@
if(context)
{
- switch (cap)
+ switch(cap)
{
case GL_CULL_FACE: context->setCullFace(true); break;
case GL_POLYGON_OFFSET_FILL: context->setPolygonOffsetFill(true); break;
@@ -1825,6 +1946,34 @@
}
}
+void __stdcall glEndQueryEXT(GLenum target)
+{
+ TRACE("GLenum target = 0x%X)", target);
+
+ try
+ {
+ switch(target)
+ {
+ case GL_ANY_SAMPLES_PASSED_EXT:
+ case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
+ break;
+ default:
+ return error(GL_INVALID_ENUM);
+ }
+
+ gl::Context *context = gl::getContext();
+
+ if(context)
+ {
+ context->endQuery(target);
+ }
+ }
+ catch(std::bad_alloc&)
+ {
+ return error(GL_OUT_OF_MEMORY);
+ }
+}
+
void __stdcall glFinishFenceNV(GLuint fence)
{
TRACE("(GLuint fence = %d)", fence);
@@ -1924,7 +2073,7 @@
return error(GL_INVALID_OPERATION);
}
- switch (attachment)
+ switch(attachment)
{
case GL_COLOR_ATTACHMENT0:
framebuffer->setColorbuffer(GL_RENDERBUFFER, renderbuffer);
@@ -1958,7 +2107,7 @@
return error(GL_INVALID_ENUM);
}
- switch (attachment)
+ switch(attachment)
{
case GL_COLOR_ATTACHMENT0:
case GL_DEPTH_ATTACHMENT:
@@ -1990,7 +2139,7 @@
return error(GL_INVALID_OPERATION);
}
- switch (textarget)
+ switch(textarget)
{
case GL_TEXTURE_2D:
if(tex->getTarget() != GL_TEXTURE_2D)
@@ -2039,7 +2188,7 @@
return error(GL_INVALID_OPERATION);
}
- switch (attachment)
+ switch(attachment)
{
case GL_COLOR_ATTACHMENT0: framebuffer->setColorbuffer(textarget, texture); break;
case GL_DEPTH_ATTACHMENT: framebuffer->setDepthbuffer(textarget, texture); break;
@@ -2059,7 +2208,7 @@
try
{
- switch (mode)
+ switch(mode)
{
case GL_CW:
case GL_CCW:
@@ -2121,7 +2270,7 @@
{
gl::Texture *texture;
- switch (target)
+ switch(target)
{
case GL_TEXTURE_2D:
texture = context->getTexture2D();
@@ -2203,6 +2352,33 @@
}
}
+void __stdcall glGenQueriesEXT(GLsizei n, GLuint* ids)
+{
+ TRACE("(GLsizei n = %d, GLuint* ids = 0x%0.8p)", n, ids);
+
+ try
+ {
+ if(n < 0)
+ {
+ return error(GL_INVALID_VALUE);
+ }
+
+ gl::Context *context = gl::getContext();
+
+ if(context)
+ {
+ for(int i = 0; i < n; i++)
+ {
+ ids[i] = context->createQuery();
+ }
+ }
+ }
+ catch(std::bad_alloc&)
+ {
+ return error(GL_OUT_OF_MEMORY);
+ }
+}
+
void __stdcall glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
{
TRACE("(GLsizei n = %d, GLuint* renderbuffers = 0x%0.8p)", n, renderbuffers);
@@ -2502,7 +2678,7 @@
{
gl::Buffer *buffer;
- switch (target)
+ switch(target)
{
case GL_ARRAY_BUFFER:
buffer = context->getArrayBuffer();
@@ -2519,7 +2695,7 @@
return error(GL_INVALID_OPERATION);
}
- switch (pname)
+ switch(pname)
{
case GL_BUFFER_USAGE:
*params = buffer->usage();
@@ -2676,7 +2852,7 @@
GLenum attachmentType;
GLuint attachmentHandle;
- switch (attachment)
+ switch(attachment)
{
case GL_COLOR_ATTACHMENT0:
attachmentType = framebuffer->getColorbufferType();
@@ -2704,7 +2880,7 @@
}
else UNREACHABLE();
- switch (pname)
+ switch(pname)
{
case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
*params = attachmentObjectType;
@@ -2757,6 +2933,13 @@
}
}
+GLenum __stdcall glGetGraphicsResetStatusEXT(void)
+{
+ TRACE("()");
+
+ return GL_NO_ERROR;
+}
+
void __stdcall glGetIntegerv(GLenum pname, GLint* params)
{
TRACE("(GLenum pname = 0x%X, GLint* params = 0x%0.8p)", pname, params);
@@ -2839,7 +3022,7 @@
return error(GL_INVALID_VALUE);
}
- switch (pname)
+ switch(pname)
{
case GL_DELETE_STATUS:
*params = programObject->isFlaggedForDeletion();
@@ -2911,6 +3094,83 @@
}
}
+void __stdcall glGetQueryivEXT(GLenum target, GLenum pname, GLint *params)
+{
+ TRACE("GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", target, pname, params);
+
+ try
+ {
+ switch(pname)
+ {
+ case GL_CURRENT_QUERY_EXT:
+ break;
+ default:
+ return error(GL_INVALID_ENUM);
+ }
+
+ gl::Context *context = gl::getContext();
+
+ if(context)
+ {
+ params[0] = context->getActiveQuery(target);
+ }
+ }
+ catch(std::bad_alloc&)
+ {
+ return error(GL_OUT_OF_MEMORY);
+ }
+}
+
+void __stdcall glGetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params)
+{
+ TRACE("(GLuint id = %d, GLenum pname = 0x%X, GLuint *params = 0x%0.8p)", id, pname, params);
+
+ try
+ {
+ switch(pname)
+ {
+ case GL_QUERY_RESULT_EXT:
+ case GL_QUERY_RESULT_AVAILABLE_EXT:
+ break;
+ default:
+ return error(GL_INVALID_ENUM);
+ }
+
+ gl::Context *context = gl::getContext();
+
+ if(context)
+ {
+ gl::Query *queryObject = context->getQuery(id, false, GL_NONE);
+
+ if(!queryObject)
+ {
+ return error(GL_INVALID_OPERATION);
+ }
+
+ if(context->getActiveQuery(queryObject->getType()) == id)
+ {
+ return error(GL_INVALID_OPERATION);
+ }
+
+ switch(pname)
+ {
+ case GL_QUERY_RESULT_EXT:
+ params[0] = queryObject->getResult();
+ break;
+ case GL_QUERY_RESULT_AVAILABLE_EXT:
+ params[0] = queryObject->isResultAvailable();
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+ }
+ catch(std::bad_alloc&)
+ {
+ return error(GL_OUT_OF_MEMORY);
+ }
+}
+
void __stdcall glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
{
TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", target, pname, params);
@@ -2982,7 +3242,7 @@
return error(GL_INVALID_VALUE);
}
- switch (pname)
+ switch(pname)
{
case GL_SHADER_TYPE:
*params = shaderObject->getType();
@@ -3049,7 +3309,7 @@
try
{
- switch (shadertype)
+ switch(shadertype)
{
case GL_VERTEX_SHADER:
case GL_FRAGMENT_SHADER:
@@ -3058,12 +3318,12 @@
return error(GL_INVALID_ENUM);
}
- switch (precisiontype)
+ switch(precisiontype)
{
case GL_LOW_FLOAT:
case GL_MEDIUM_FLOAT:
case GL_HIGH_FLOAT:
- // Assume IEEE 754 precision
+ // IEEE 754 single-precision
range[0] = 127;
range[1] = 127;
*precision = 23;
@@ -3071,8 +3331,7 @@
case GL_LOW_INT:
case GL_MEDIUM_INT:
case GL_HIGH_INT:
- // Some (most) hardware only supports single-precision floating-point numbers,
- // which can accurately represent integers up to +/-16777216
+ // Single-precision floating-point numbers can accurately represent integers up to +/-16777216
range[0] = 24;
range[1] = 24;
*precision = 0;
@@ -3127,7 +3386,7 @@
{
gl::Context *context = gl::getContext();
- switch (name)
+ switch(name)
{
case GL_VENDOR:
return (GLubyte*)"TransGaming Inc.";
@@ -3163,7 +3422,7 @@
{
gl::Texture *texture;
- switch (target)
+ switch(target)
{
case GL_TEXTURE_2D:
texture = context->getTexture2D();
@@ -3175,7 +3434,7 @@
return error(GL_INVALID_ENUM);
}
- switch (pname)
+ switch(pname)
{
case GL_TEXTURE_MAG_FILTER:
*params = (GLfloat)texture->getMagFilter();
@@ -3212,7 +3471,7 @@
{
gl::Texture *texture;
- switch (target)
+ switch(target)
{
case GL_TEXTURE_2D:
texture = context->getTexture2D();
@@ -3224,7 +3483,7 @@
return error(GL_INVALID_ENUM);
}
- switch (pname)
+ switch(pname)
{
case GL_TEXTURE_MAG_FILTER:
*params = texture->getMagFilter();
@@ -3249,6 +3508,46 @@
}
}
+void __stdcall glGetnUniformfvEXT(GLuint program, GLint location, GLsizei bufSize, GLfloat* params)
+{
+ TRACE("(GLuint program = %d, GLint location = %d, GLsizei bufSize = %d, GLfloat* params = 0x%0.8p)",
+ program, location, bufSize, params);
+
+ try
+ {
+ if(bufSize < 0)
+ {
+ return error(GL_INVALID_VALUE);
+ }
+
+ gl::Context *context = gl::getContext();
+
+ if(context)
+ {
+ if(program == 0)
+ {
+ return error(GL_INVALID_VALUE);
+ }
+
+ gl::Program *programObject = context->getProgram(program);
+
+ if(!programObject || !programObject->isLinked())
+ {
+ return error(GL_INVALID_OPERATION);
+ }
+
+ if(!programObject->getUniformfv(location, &bufSize, params))
+ {
+ return error(GL_INVALID_OPERATION);
+ }
+ }
+ }
+ catch(std::bad_alloc&)
+ {
+ return error(GL_OUT_OF_MEMORY);
+ }
+}
+
void __stdcall glGetUniformfv(GLuint program, GLint location, GLfloat* params)
{
TRACE("(GLuint program = %d, GLint location = %d, GLfloat* params = 0x%0.8p)", program, location, params);
@@ -3271,7 +3570,52 @@
return error(GL_INVALID_OPERATION);
}
- if(!programObject->getUniformfv(location, params))
+ if(!programObject->getUniformfv(location, NULL, params))
+ {
+ return error(GL_INVALID_OPERATION);
+ }
+ }
+ }
+ catch(std::bad_alloc&)
+ {
+ return error(GL_OUT_OF_MEMORY);
+ }
+}
+
+void __stdcall glGetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint* params)
+{
+ TRACE("(GLuint program = %d, GLint location = %d, GLsizei bufSize = %d, GLint* params = 0x%0.8p)",
+ program, location, bufSize, params);
+
+ try
+ {
+ if(bufSize < 0)
+ {
+ return error(GL_INVALID_VALUE);
+ }
+
+ gl::Context *context = gl::getContext();
+
+ if(context)
+ {
+ if(program == 0)
+ {
+ return error(GL_INVALID_VALUE);
+ }
+
+ gl::Program *programObject = context->getProgram(program);
+
+ if(!programObject || !programObject->isLinked())
+ {
+ return error(GL_INVALID_OPERATION);
+ }
+
+ if(!programObject)
+ {
+ return error(GL_INVALID_OPERATION);
+ }
+
+ if(!programObject->getUniformiv(location, &bufSize, params))
{
return error(GL_INVALID_OPERATION);
}
@@ -3310,7 +3654,7 @@
return error(GL_INVALID_OPERATION);
}
- if(!programObject->getUniformiv(location, params))
+ if(!programObject->getUniformiv(location, NULL, params))
{
return error(GL_INVALID_OPERATION);
}
@@ -3384,7 +3728,7 @@
const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
- switch (pname)
+ switch(pname)
{
case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
*params = (GLfloat)(attribState.mArrayEnabled ? GL_TRUE : GL_FALSE);
@@ -3437,7 +3781,7 @@
const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
- switch (pname)
+ switch(pname)
{
case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
*params = (attribState.mArrayEnabled ? GL_TRUE : GL_FALSE);
@@ -3509,7 +3853,7 @@
try
{
- switch (mode)
+ switch(mode)
{
case GL_FASTEST:
case GL_NICEST:
@@ -3520,7 +3864,7 @@
}
gl::Context *context = gl::getContext();
- switch (target)
+ switch(target)
{
case GL_GENERATE_MIPMAP_HINT:
if(context) context->setGenerateMipmapHint(mode);
@@ -3574,7 +3918,7 @@
if(context)
{
- switch (cap)
+ switch(cap)
{
case GL_CULL_FACE: return context->isCullFaceEnabled();
case GL_POLYGON_OFFSET_FILL: return context->isPolygonOffsetFillEnabled();
@@ -3678,6 +4022,37 @@
return GL_FALSE;
}
+GLboolean __stdcall glIsQueryEXT(GLuint id)
+{
+ TRACE("(GLuint id = %d)", id);
+
+ try
+ {
+ if(id == 0)
+ {
+ return GL_FALSE;
+ }
+
+ gl::Context *context = gl::getContext();
+
+ if(context)
+ {
+ gl::Query *queryObject = context->getQuery(id, false, GL_NONE);
+
+ if(queryObject)
+ {
+ return GL_TRUE;
+ }
+ }
+ }
+ catch(std::bad_alloc&)
+ {
+ return error(GL_OUT_OF_MEMORY, GL_FALSE);
+ }
+
+ return GL_FALSE;
+}
+
GLboolean __stdcall glIsRenderbuffer(GLuint renderbuffer)
{
TRACE("(GLuint renderbuffer = %d)", renderbuffer);
@@ -3823,7 +4198,7 @@
if(context)
{
- switch (pname)
+ switch(pname)
{
case GL_UNPACK_ALIGNMENT:
if(param != 1 && param != 2 && param != 4 && param != 8)
@@ -3873,6 +4248,39 @@
}
}
+void __stdcall glReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height,
+ GLenum format, GLenum type, GLsizei bufSize,
+ GLvoid *data)
+{
+ TRACE("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
+ "GLenum format = 0x%X, GLenum type = 0x%X, GLsizei bufSize = 0x%d, GLvoid *data = 0x%0.8p)",
+ x, y, width, height, format, type, bufSize, data);
+
+ try
+ {
+ if(width < 0 || height < 0 || bufSize < 0)
+ {
+ return error(GL_INVALID_VALUE);
+ }
+
+ if(!validReadFormatType(format, type))
+ {
+ return error(GL_INVALID_OPERATION);
+ }
+
+ gl::Context *context = gl::getContext();
+
+ if(context)
+ {
+ context->readPixels(x, y, width, height, format, type, &bufSize, data);
+ }
+ }
+ catch(std::bad_alloc&)
+ {
+ return error(GL_OUT_OF_MEMORY);
+ }
+}
+
void __stdcall glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
{
TRACE("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
@@ -3886,38 +4294,8 @@
return error(GL_INVALID_VALUE);
}
- switch (format)
+ if(!validReadFormatType(format, type))
{
- case GL_RGBA:
- switch (type)
- {
- case GL_UNSIGNED_BYTE:
- break;
- default:
- return error(GL_INVALID_OPERATION);
- }
- break;
- case GL_BGRA_EXT:
- switch (type)
- {
- case GL_UNSIGNED_BYTE:
- case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT:
- case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT:
- break;
- default:
- return error(GL_INVALID_OPERATION);
- }
- break;
- case gl::IMPLEMENTATION_COLOR_READ_FORMAT:
- switch (type)
- {
- case gl::IMPLEMENTATION_COLOR_READ_TYPE:
- break;
- default:
- return error(GL_INVALID_OPERATION);
- }
- break;
- default:
return error(GL_INVALID_OPERATION);
}
@@ -3925,7 +4303,7 @@
if(context)
{
- context->readPixels(x, y, width, height, format, type, pixels);
+ context->readPixels(x, y, width, height, format, type, NULL, pixels);
}
}
catch(std::bad_alloc&)
@@ -3955,7 +4333,7 @@
try
{
- switch (target)
+ switch(target)
{
case GL_RENDERBUFFER:
break;
@@ -3978,8 +4356,8 @@
if(context)
{
if(width > gl::IMPLEMENTATION_MAX_RENDERBUFFER_SIZE ||
- height > gl::IMPLEMENTATION_MAX_RENDERBUFFER_SIZE ||
- samples > gl::IMPLEMENTATION_MAX_SAMPLES)
+ height > gl::IMPLEMENTATION_MAX_RENDERBUFFER_SIZE ||
+ samples > gl::IMPLEMENTATION_MAX_SAMPLES)
{
return error(GL_INVALID_VALUE);
}
@@ -3990,7 +4368,7 @@
return error(GL_INVALID_OPERATION);
}
- switch (internalformat)
+ switch(internalformat)
{
case GL_DEPTH_COMPONENT16:
context->setRenderbufferStorage(new gl::Depthbuffer(width, height, samples));
@@ -4165,7 +4543,7 @@
try
{
- switch (face)
+ switch(face)
{
case GL_FRONT:
case GL_BACK:
@@ -4175,7 +4553,7 @@
return error(GL_INVALID_ENUM);
}
- switch (func)
+ switch(func)
{
case GL_NEVER:
case GL_ALWAYS:
@@ -4222,7 +4600,7 @@
try
{
- switch (face)
+ switch(face)
{
case GL_FRONT:
case GL_BACK:
@@ -4265,7 +4643,7 @@
try
{
- switch (face)
+ switch(face)
{
case GL_FRONT:
case GL_BACK:
@@ -4275,7 +4653,7 @@
return error(GL_INVALID_ENUM);
}
- switch (fail)
+ switch(fail)
{
case GL_ZERO:
case GL_KEEP:
@@ -4290,7 +4668,7 @@
return error(GL_INVALID_ENUM);
}
- switch (zfail)
+ switch(zfail)
{
case GL_ZERO:
case GL_KEEP:
@@ -4305,7 +4683,7 @@
return error(GL_INVALID_ENUM);
}
- switch (zpass)
+ switch(zpass)
{
case GL_ZERO:
case GL_KEEP:
@@ -4388,59 +4766,61 @@
return error(GL_INVALID_OPERATION);
}
- switch (format)
+ switch(format)
{
- case GL_ALPHA:
- case GL_LUMINANCE:
- case GL_LUMINANCE_ALPHA:
- switch (type)
+ case GL_ALPHA:
+ case GL_LUMINANCE:
+ case GL_LUMINANCE_ALPHA:
+ switch(type)
{
- case GL_UNSIGNED_BYTE:
- case GL_FLOAT:
- case GL_HALF_FLOAT_OES:
+ case GL_UNSIGNED_BYTE:
+ case GL_FLOAT:
+ case GL_HALF_FLOAT_OES:
break;
- default:
+ default:
return error(GL_INVALID_ENUM);
}
break;
- case GL_RGB:
- switch (type)
+ case GL_RGB:
+ switch(type)
{
- case GL_UNSIGNED_BYTE:
- case GL_UNSIGNED_SHORT_5_6_5:
- case GL_FLOAT:
- case GL_HALF_FLOAT_OES:
+ case GL_UNSIGNED_BYTE:
+ case GL_UNSIGNED_SHORT_5_6_5:
+ case GL_FLOAT:
+ case GL_HALF_FLOAT_OES:
break;
- default:
+ default:
return error(GL_INVALID_ENUM);
}
break;
- case GL_RGBA:
- switch (type)
+ case GL_RGBA:
+ switch(type)
{
- case GL_UNSIGNED_BYTE:
- case GL_UNSIGNED_SHORT_4_4_4_4:
- case GL_UNSIGNED_SHORT_5_5_5_1:
- case GL_FLOAT:
- case GL_HALF_FLOAT_OES:
+ case GL_UNSIGNED_BYTE:
+ case GL_UNSIGNED_SHORT_4_4_4_4:
+ case GL_UNSIGNED_SHORT_5_5_5_1:
+ case GL_FLOAT:
+ case GL_HALF_FLOAT_OES:
break;
- default:
+ default:
return error(GL_INVALID_ENUM);
}
break;
- case GL_BGRA_EXT:
- switch (type)
+ case GL_BGRA_EXT:
+ switch(type)
{
- case GL_UNSIGNED_BYTE:
+ case GL_UNSIGNED_BYTE:
break;
- default:
+ default:
return error(GL_INVALID_ENUM);
}
break;
- case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: // error cases for compressed textures are handled below
- case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: // error cases for compressed textures are handled below
+ case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
+ case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
break;
- default:
+ default:
return error(GL_INVALID_VALUE);
}
@@ -4453,7 +4833,7 @@
if(context)
{
- switch (target)
+ switch(target)
{
case GL_TEXTURE_2D:
if(width > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level) ||
@@ -4484,7 +4864,9 @@
}
if(format == GL_COMPRESSED_RGB_S3TC_DXT1_EXT ||
- format == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT)
+ format == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ||
+ format == GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE ||
+ format == GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE)
{
if(S3TC_SUPPORT)
{
@@ -4548,7 +4930,7 @@
{
gl::Texture *texture;
- switch (target)
+ switch(target)
{
case GL_TEXTURE_2D:
texture = context->getTexture2D();
@@ -4560,7 +4942,7 @@
return error(GL_INVALID_ENUM);
}
- switch (pname)
+ switch(pname)
{
case GL_TEXTURE_WRAP_S:
if(!texture->setWrapS((GLenum)param))
@@ -4650,23 +5032,19 @@
{
gl::Texture2D *texture = context->getTexture2D();
- if(!texture)
- {
- return error(GL_INVALID_OPERATION);
- }
-
- texture->subImage(level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);
+ if(validateSubImageParams(false, width, height, xoffset, yoffset, level, format, texture))
+ {
+ texture->subImage(level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);
+ }
}
else if(gl::IsCubemapTextureTarget(target))
{
gl::TextureCubeMap *texture = context->getTextureCubeMap();
-
- if(!texture)
- {
- return error(GL_INVALID_OPERATION);
- }
-
- texture->subImage(target, level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);
+
+ if(validateSubImageParams(false, width, height, xoffset, yoffset, level, format, texture))
+ {
+ texture->subImage(target, level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);
+ }
}
else
{
@@ -5452,7 +5830,7 @@
return error(GL_INVALID_VALUE);
}
- switch (type)
+ switch(type)
{
case GL_BYTE:
case GL_UNSIGNED_BYTE:
@@ -5517,7 +5895,7 @@
try
{
- switch (filter)
+ switch(filter)
{
case GL_NEAREST:
break;
@@ -5593,6 +5971,17 @@
{"glGetFenceivNV", (__eglMustCastToProperFunctionPointerType)glGetFenceivNV},
{"glFinishFenceNV", (__eglMustCastToProperFunctionPointerType)glFinishFenceNV},
{"glSetFenceNV", (__eglMustCastToProperFunctionPointerType)glSetFenceNV},
+ {"glGetGraphicsResetStatusEXT", (__eglMustCastToProperFunctionPointerType)glGetGraphicsResetStatusEXT},
+ {"glReadnPixelsEXT", (__eglMustCastToProperFunctionPointerType)glReadnPixelsEXT},
+ {"glGetnUniformfvEXT", (__eglMustCastToProperFunctionPointerType)glGetnUniformfvEXT},
+ {"glGetnUniformivEXT", (__eglMustCastToProperFunctionPointerType)glGetnUniformivEXT},
+ {"glGenQueriesEXT", (__eglMustCastToProperFunctionPointerType)glGenQueriesEXT},
+ {"glDeleteQueriesEXT", (__eglMustCastToProperFunctionPointerType)glDeleteQueriesEXT},
+ {"glIsQueryEXT", (__eglMustCastToProperFunctionPointerType)glIsQueryEXT},
+ {"glBeginQueryEXT", (__eglMustCastToProperFunctionPointerType)glBeginQueryEXT},
+ {"glEndQueryEXT", (__eglMustCastToProperFunctionPointerType)glEndQueryEXT},
+ {"glGetQueryivEXT", (__eglMustCastToProperFunctionPointerType)glGetQueryivEXT},
+ {"glGetQueryObjectuivEXT", (__eglMustCastToProperFunctionPointerType)glGetQueryObjectuivEXT},
};
for(int ext = 0; ext < sizeof(glExtensions) / sizeof(Extension); ext++)
diff --git a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.def b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.def
index b78672f..fb7d171 100644
--- a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.def
+++ b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.def
@@ -154,6 +154,19 @@
glIsFenceNV @155
glSetFenceNV @156
glTestFenceNV @157
+ ;glGetTranslatedShaderSourceANGLE @159
+ ;glTexStorage2DEXT @160
+ glGetGraphicsResetStatusEXT @161
+ glReadnPixelsEXT @162
+ glGetnUniformfvEXT @163
+ glGetnUniformivEXT @164
+ glGenQueriesEXT @165
+ glDeleteQueriesEXT @166
+ glIsQueryEXT @167
+ glBeginQueryEXT @168
+ glEndQueryEXT @169
+ glGetQueryivEXT @170
+ glGetQueryObjectuivEXT @171
; EGL dependencies
glCreateContext @144 NONAME
@@ -163,8 +176,8 @@
glGetProcAddress @148 NONAME
glBindTexImage @158 NONAME
- createFrameBuffer @159 NONAME
- createBackBuffer @160 NONAME
- createDevice @161 NONAME
+ createFrameBuffer @172 NONAME
+ createBackBuffer @173 NONAME
+ createDevice @174 NONAME
Register
\ No newline at end of file
diff --git a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.rc b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.rc
index 5284f2e..919c7ed 100644
--- a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.rc
+++ b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.rc
@@ -73,7 +73,7 @@
VALUE "FileDescription", "SwiftShader libGLESv2 Dynamic Link Library"
VALUE "FileVersion", VERSION_STRING
VALUE "InternalName", "libGLESv2"
- VALUE "LegalCopyright", "Copyright (C) 2011 TransGaming Inc."
+ VALUE "LegalCopyright", "Copyright (C) 2012 TransGaming Inc."
VALUE "OriginalFilename", "libGLESv2.dll"
VALUE "PrivateBuild", VERSION_STRING
VALUE "ProductName", "SwiftShader libGLESv2 Dynamic Link Library"
diff --git a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcproj b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcproj
deleted file mode 100644
index a71bc26..0000000
--- a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcproj
+++ /dev/null
@@ -1,387 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
- ProjectType="Visual C++"
- Version="9.00"
- Name="libGLESv2"
- ProjectGUID="{B5871A7A-968C-42E3-A33B-981E6F448E78}"
- RootNamespace="libGLESv2"
- Keyword="Win32Proj"
- TargetFrameworkVersion="131072"
- >
- <Platforms>
- <Platform
- Name="Win32"
- />
- </Platforms>
- <ToolFiles>
- </ToolFiles>
- <Configurations>
- <Configuration
- Name="Debug|Win32"
- OutputDirectory="$(SolutionDir)$(ConfigurationName)"
- IntermediateDirectory="$(ConfigurationName)"
- ConfigurationType="2"
- CharacterSet="0"
- >
- <Tool
- Name="VCPreBuildEventTool"
- />
- <Tool
- Name="VCCustomBuildTool"
- />
- <Tool
- Name="VCXMLDataGeneratorTool"
- />
- <Tool
- Name="VCWebServiceProxyGeneratorTool"
- />
- <Tool
- Name="VCMIDLTool"
- />
- <Tool
- Name="VCCLCompilerTool"
- Optimization="0"
- AdditionalIncludeDirectories="$(ProjectDir)/..;$(ProjectDir)/../..; $(ProjectDir)/../include"
- PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBGLESV2_EXPORTS;_CRT_SECURE_NO_DEPRECATE;NOMINMAX"
- MinimalRebuild="true"
- ExceptionHandling="1"
- BasicRuntimeChecks="3"
- RuntimeLibrary="1"
- UsePrecompiledHeader="0"
- WarningLevel="3"
- Detect64BitPortabilityProblems="false"
- DebugInformationFormat="4"
- />
- <Tool
- Name="VCManagedResourceCompilerTool"
- />
- <Tool
- Name="VCResourceCompilerTool"
- />
- <Tool
- Name="VCPreLinkEventTool"
- />
- <Tool
- Name="VCLinkerTool"
- AdditionalDependencies="dxguid.lib d3d9.lib D3dx9.lib d3dcompiler.lib"
- LinkIncremental="2"
- ModuleDefinitionFile="libGLESv2.def"
- GenerateDebugInformation="true"
- SubSystem="2"
- RandomizedBaseAddress="1"
- DataExecutionPrevention="0"
- TargetMachine="1"
- />
- <Tool
- Name="VCALinkTool"
- />
- <Tool
- Name="VCManifestTool"
- />
- <Tool
- Name="VCXDCMakeTool"
- />
- <Tool
- Name="VCBscMakeTool"
- />
- <Tool
- Name="VCFxCopTool"
- />
- <Tool
- Name="VCAppVerifierTool"
- />
- <Tool
- Name="VCPostBuildEventTool"
- CommandLine="@echo on
mkdir "$(ProjectDir)..\..\lib\$(ConfigurationName)\"
copy "$(OutDir)\libGLESv2.dll" "$(ProjectDir)..\..\lib\$(ConfigurationName)\"
copy "$(OutDir)\libGLESv2.lib" "$(ProjectDir)..\..\lib\$(ConfigurationName)\"
@echo off
"
- />
- </Configuration>
- <Configuration
- Name="Release|Win32"
- OutputDirectory="$(SolutionDir)$(ConfigurationName)"
- IntermediateDirectory="$(ConfigurationName)"
- ConfigurationType="2"
- CharacterSet="0"
- WholeProgramOptimization="1"
- >
- <Tool
- Name="VCPreBuildEventTool"
- />
- <Tool
- Name="VCCustomBuildTool"
- />
- <Tool
- Name="VCXMLDataGeneratorTool"
- />
- <Tool
- Name="VCWebServiceProxyGeneratorTool"
- />
- <Tool
- Name="VCMIDLTool"
- />
- <Tool
- Name="VCCLCompilerTool"
- Optimization="2"
- InlineFunctionExpansion="2"
- AdditionalIncludeDirectories="$(ProjectDir)/..;$(ProjectDir)/../..; $(ProjectDir)/../include"
- PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBGLESV2_EXPORTS;_CRT_SECURE_NO_DEPRECATE;NOMINMAX;_SECURE_SCL=0"
- ExceptionHandling="1"
- RuntimeLibrary="0"
- UsePrecompiledHeader="0"
- WarningLevel="3"
- Detect64BitPortabilityProblems="false"
- DebugInformationFormat="3"
- />
- <Tool
- Name="VCManagedResourceCompilerTool"
- />
- <Tool
- Name="VCResourceCompilerTool"
- />
- <Tool
- Name="VCPreLinkEventTool"
- />
- <Tool
- Name="VCLinkerTool"
- AdditionalDependencies="dxguid.lib d3d9.lib D3dx9.lib d3dcompiler.lib"
- LinkIncremental="1"
- IgnoreAllDefaultLibraries="false"
- ModuleDefinitionFile="libGLESv2.def"
- GenerateDebugInformation="true"
- SubSystem="2"
- OptimizeReferences="2"
- EnableCOMDATFolding="2"
- RandomizedBaseAddress="1"
- DataExecutionPrevention="0"
- TargetMachine="1"
- />
- <Tool
- Name="VCALinkTool"
- />
- <Tool
- Name="VCManifestTool"
- />
- <Tool
- Name="VCXDCMakeTool"
- />
- <Tool
- Name="VCBscMakeTool"
- />
- <Tool
- Name="VCFxCopTool"
- />
- <Tool
- Name="VCAppVerifierTool"
- />
- <Tool
- Name="VCPostBuildEventTool"
- CommandLine="@echo on
mkdir "$(ProjectDir)..\..\lib\$(ConfigurationName)\"
copy "$(OutDir)\libGLESv2.dll" "$(ProjectDir)..\..\lib\$(ConfigurationName)\"
copy "$(OutDir)\libGLESv2.lib" "$(ProjectDir)..\..\lib\$(ConfigurationName)\"
@echo off
"
- />
- </Configuration>
- </Configurations>
- <References>
- </References>
- <Files>
- <Filter
- Name="Source Files"
- Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
- UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
- >
- <File
- RelativePath=".\Buffer.cpp"
- >
- </File>
- <File
- RelativePath=".\Context.cpp"
- >
- </File>
- <File
- RelativePath="..\common\debug.cpp"
- >
- </File>
- <File
- RelativePath=".\Device.cpp"
- >
- </File>
- <File
- RelativePath=".\Fence.cpp"
- >
- </File>
- <File
- RelativePath=".\Framebuffer.cpp"
- >
- </File>
- <File
- RelativePath=".\HandleAllocator.cpp"
- >
- </File>
- <File
- RelativePath=".\Image.cpp"
- >
- </File>
- <File
- RelativePath=".\IndexDataManager.cpp"
- >
- </File>
- <File
- RelativePath=".\libGLESv2.cpp"
- >
- </File>
- <File
- RelativePath=".\main.cpp"
- >
- </File>
- <File
- RelativePath=".\Program.cpp"
- >
- </File>
- <File
- RelativePath=".\RefCountObject.cpp"
- >
- </File>
- <File
- RelativePath=".\Renderbuffer.cpp"
- >
- </File>
- <File
- RelativePath=".\ResourceManager.cpp"
- >
- </File>
- <File
- RelativePath=".\Shader.cpp"
- >
- </File>
- <File
- RelativePath=".\Texture.cpp"
- >
- </File>
- <File
- RelativePath=".\Unknown.cpp"
- >
- </File>
- <File
- RelativePath=".\utilities.cpp"
- >
- </File>
- <File
- RelativePath=".\VertexDataManager.cpp"
- >
- </File>
- </Filter>
- <Filter
- Name="Header Files"
- Filter="h;hpp;hxx;hm;inl;inc;xsd"
- UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
- >
- <File
- RelativePath=".\Buffer.h"
- >
- </File>
- <File
- RelativePath=".\Context.h"
- >
- </File>
- <File
- RelativePath=".\Device.hpp"
- >
- </File>
- <File
- RelativePath=".\Fence.h"
- >
- </File>
- <File
- RelativePath=".\Framebuffer.h"
- >
- </File>
- <File
- RelativePath="..\..\include\GLES2\gl2.h"
- >
- </File>
- <File
- RelativePath="..\..\include\GLES2\gl2ext.h"
- >
- </File>
- <File
- RelativePath="..\..\include\GLES2\gl2platform.h"
- >
- </File>
- <File
- RelativePath=".\HandleAllocator.h"
- >
- </File>
- <File
- RelativePath=".\Image.hpp"
- >
- </File>
- <File
- RelativePath=".\IndexDataManager.h"
- >
- </File>
- <File
- RelativePath=".\main.h"
- >
- </File>
- <File
- RelativePath=".\mathutil.h"
- >
- </File>
- <File
- RelativePath=".\Program.h"
- >
- </File>
- <File
- RelativePath=".\RefCountObject.h"
- >
- </File>
- <File
- RelativePath=".\Renderbuffer.h"
- >
- </File>
- <File
- RelativePath=".\resource.h"
- >
- </File>
- <File
- RelativePath=".\ResourceManager.h"
- >
- </File>
- <File
- RelativePath=".\Shader.h"
- >
- </File>
- <File
- RelativePath=".\Texture.h"
- >
- </File>
- <File
- RelativePath=".\Unknown.hpp"
- >
- </File>
- <File
- RelativePath=".\utilities.h"
- >
- </File>
- <File
- RelativePath="..\common\version.h"
- >
- </File>
- <File
- RelativePath=".\vertexconversion.h"
- >
- </File>
- <File
- RelativePath=".\VertexDataManager.h"
- >
- </File>
- </Filter>
- <File
- RelativePath=".\libGLESv2.def"
- >
- </File>
- <File
- RelativePath=".\libGLESv2.rc"
- >
- </File>
- </Files>
- <Globals>
- </Globals>
-</VisualStudioProject>
diff --git a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj
index e49c518..5391f71 100644
--- a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj
+++ b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj
@@ -78,10 +78,9 @@
<WarningLevel>Level3</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<BrowseInformation>true</BrowseInformation>
- <ExceptionHandling>Sync</ExceptionHandling>
</ClCompile>
<Link>
- <AdditionalDependencies>dwmapi.lib;dxguid.lib;WS2_32.lib;D3dx9.lib;d3dcompiler.lib;%(AdditionalDependencies)</AdditionalDependencies>
+ <AdditionalDependencies>dxguid.lib;dwmapi.lib;WS2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<ModuleDefinitionFile>libGLESv2.def</ModuleDefinitionFile>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Windows</SubSystem>
@@ -114,10 +113,9 @@
<EnableFiberSafeOptimizations>true</EnableFiberSafeOptimizations>
<WholeProgramOptimization>true</WholeProgramOptimization>
<IntrinsicFunctions>false</IntrinsicFunctions>
- <ExceptionHandling>Sync</ExceptionHandling>
</ClCompile>
<Link>
- <AdditionalDependencies>dwmapi.lib;dxguid.lib;WS2_32.lib;D3dx9.lib;d3dcompiler.lib;%(AdditionalDependencies)</AdditionalDependencies>
+ <AdditionalDependencies>dxguid.lib;dwmapi.lib;WS2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
<ModuleDefinitionFile>libGLESv2.def</ModuleDefinitionFile>
<GenerateDebugInformation>true</GenerateDebugInformation>
@@ -146,16 +144,15 @@
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
- <DebugInformationFormat>
- </DebugInformationFormat>
+ <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<FavorSizeOrSpeed>Size</FavorSizeOrSpeed>
- <OmitFramePointers>true</OmitFramePointers>
+ <OmitFramePointers>false</OmitFramePointers>
<EnableFiberSafeOptimizations>true</EnableFiberSafeOptimizations>
<WholeProgramOptimization>true</WholeProgramOptimization>
<IntrinsicFunctions>false</IntrinsicFunctions>
</ClCompile>
<Link>
- <AdditionalDependencies>dwmapi.lib;dxguid.lib;WS2_32.lib;D3dx9.lib;d3dcompiler.lib;%(AdditionalDependencies)</AdditionalDependencies>
+ <AdditionalDependencies>dxguid.lib;dwmapi.lib;WS2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
<ModuleDefinitionFile>libGLESv2.def</ModuleDefinitionFile>
<GenerateDebugInformation>true</GenerateDebugInformation>
@@ -187,6 +184,7 @@
<ClCompile Include="libGLESv2.cpp" />
<ClCompile Include="main.cpp" />
<ClCompile Include="Program.cpp" />
+ <ClCompile Include="Query.cpp" />
<ClCompile Include="RefCountObject.cpp" />
<ClCompile Include="Renderbuffer.cpp" />
<ClCompile Include="ResourceManager.cpp" />
@@ -197,20 +195,21 @@
<ClCompile Include="VertexDataManager.cpp" />
</ItemGroup>
<ItemGroup>
+ <ClInclude Include="..\include\GLES2\gl2.h" />
+ <ClInclude Include="..\include\GLES2\gl2ext.h" />
+ <ClInclude Include="..\include\GLES2\gl2platform.h" />
<ClInclude Include="Buffer.h" />
<ClInclude Include="Context.h" />
<ClInclude Include="Device.hpp" />
<ClInclude Include="Fence.h" />
<ClInclude Include="Framebuffer.h" />
- <ClInclude Include="..\..\include\GLES2\gl2.h" />
- <ClInclude Include="..\..\include\GLES2\gl2ext.h" />
- <ClInclude Include="..\..\include\GLES2\gl2platform.h" />
<ClInclude Include="HandleAllocator.h" />
<ClInclude Include="Image.hpp" />
<ClInclude Include="IndexDataManager.h" />
<ClInclude Include="main.h" />
<ClInclude Include="mathutil.h" />
<ClInclude Include="Program.h" />
+ <ClInclude Include="Query.h" />
<ClInclude Include="RefCountObject.h" />
<ClInclude Include="Renderbuffer.h" />
<ClInclude Include="resource.h" />
@@ -219,7 +218,6 @@
<ClInclude Include="Texture.h" />
<ClInclude Include="Unknown.hpp" />
<ClInclude Include="utilities.h" />
- <ClInclude Include="..\common\version.h" />
<ClInclude Include="VertexDataManager.h" />
</ItemGroup>
<ItemGroup>
@@ -229,56 +227,17 @@
<ResourceCompile Include="libGLESv2.rc" />
</ItemGroup>
<ItemGroup>
- <ProjectReference Include="..\..\LLVM\win32\Analysis\Analysis.vcxproj">
- <Project>{0622e827-8464-489d-8b1c-b0b496f35c08}</Project>
- </ProjectReference>
- <ProjectReference Include="..\..\LLVM\win32\CodeGen\CodeGen.vcxproj">
- <Project>{08ceb1bb-c2a4-4587-b9a9-aedb8fb44897}</Project>
- </ProjectReference>
- <ProjectReference Include="..\..\LLVM\win32\ExecutionEngine\ExecutionEngine.vcxproj">
- <Project>{76295ae8-a083-460e-9f80-6f2b8923264a}</Project>
- </ProjectReference>
- <ProjectReference Include="..\..\LLVM\win32\MC\MC.vcxproj">
- <Project>{12d00cfa-e393-4857-a436-c7324849de51}</Project>
- </ProjectReference>
- <ProjectReference Include="..\..\LLVM\win32\Support\Support.vcxproj">
- <Project>{28aa9146-3482-4f41-9cc6-407b1d258508}</Project>
- </ProjectReference>
- <ProjectReference Include="..\..\LLVM\win32\System\System.vcxproj">
- <Project>{0f8407f3-fa23-4cf1-83a9-dcbe0b361489}</Project>
- </ProjectReference>
- <ProjectReference Include="..\..\LLVM\win32\TableGen\TableGen.vcxproj">
- <Project>{339c2249-26b6-4172-b484-85653029af57}</Project>
- </ProjectReference>
- <ProjectReference Include="..\..\LLVM\win32\Target\Target.vcxproj">
- <Project>{059fbab8-c76d-48a0-aa75-3c57bd3eafe4}</Project>
- </ProjectReference>
- <ProjectReference Include="..\..\LLVM\win32\Transforms\Transforms.vcxproj">
- <Project>{c59374c1-9fc0-4147-b836-327dfdc52d99}</Project>
- </ProjectReference>
- <ProjectReference Include="..\..\LLVM\win32\VMCore\VMCore.vcxproj">
- <Project>{45cd78d7-c5d9-47fe-ad12-f3251eedaffb}</Project>
- </ProjectReference>
- <ProjectReference Include="..\..\LLVM\win32\x86\x86.vcxproj">
- <Project>{144eebf6-8c9b-4473-b715-2c821666af6c}</Project>
- </ProjectReference>
- <ProjectReference Include="..\..\Reactor\Reactor.vcxproj">
- <Project>{28fd076d-10b5-4bd8-a4cf-f44c7002a803}</Project>
- </ProjectReference>
<ProjectReference Include="..\..\SwiftShader\SwiftShader.vcxproj">
<Project>{7b02cb19-4cdf-4f79-bc9b-7f3f6164a003}</Project>
<Private>true</Private>
<ReferenceOutputAssembly>true</ReferenceOutputAssembly>
<CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
<LinkLibraryDependencies>true</LinkLibraryDependencies>
- <UseLibraryDependencyInputs>false</UseLibraryDependencyInputs>
+ <UseLibraryDependencyInputs>true</UseLibraryDependencyInputs>
</ProjectReference>
- <ProjectReference Include="..\compiler\translator_common.vcxproj">
+ <ProjectReference Include="..\compiler\Compiler.vcxproj">
<Project>{5b3a6db8-1e7e-40d7-92b9-da8aae619fad}</Project>
</ProjectReference>
- <ProjectReference Include="..\compiler\translator_hlsl.vcxproj">
- <Project>{5620f0e4-6c43-49bc-a178-b804e1a0c3a7}</Project>
- </ProjectReference>
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
diff --git a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj.filters b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj.filters
index 84bc665..89355a8 100644
--- a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj.filters
+++ b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj.filters
@@ -71,6 +71,9 @@
<ClCompile Include="Unknown.cpp">
<Filter>Source Files</Filter>
</ClCompile>
+ <ClCompile Include="Query.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="Buffer.h">
@@ -85,15 +88,6 @@
<ClInclude Include="Framebuffer.h">
<Filter>Header Files</Filter>
</ClInclude>
- <ClInclude Include="..\..\include\GLES2\gl2.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\..\include\GLES2\gl2ext.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\..\include\GLES2\gl2platform.h">
- <Filter>Header Files</Filter>
- </ClInclude>
<ClInclude Include="HandleAllocator.h">
<Filter>Header Files</Filter>
</ClInclude>
@@ -130,9 +124,6 @@
<ClInclude Include="utilities.h">
<Filter>Header Files</Filter>
</ClInclude>
- <ClInclude Include="..\common\version.h">
- <Filter>Header Files</Filter>
- </ClInclude>
<ClInclude Include="VertexDataManager.h">
<Filter>Header Files</Filter>
</ClInclude>
@@ -145,6 +136,18 @@
<ClInclude Include="Unknown.hpp">
<Filter>Header Files</Filter>
</ClInclude>
+ <ClInclude Include="..\include\GLES2\gl2.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="..\include\GLES2\gl2ext.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="..\include\GLES2\gl2platform.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="Query.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="libGLESv2.rc" />
diff --git a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj.user b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj.user
deleted file mode 100644
index 695b5c7..0000000
--- a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj.user
+++ /dev/null
@@ -1,3 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-</Project>
\ No newline at end of file
diff --git a/src/OpenGL ES 2.0/libGLESv2/main.cpp b/src/OpenGL ES 2.0/libGLESv2/main.cpp
index f698a63..ab5be46 100644
--- a/src/OpenGL ES 2.0/libGLESv2/main.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/main.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// main.cpp: DLL entry point and management of thread-local data.
diff --git a/src/OpenGL ES 2.0/libGLESv2/main.h b/src/OpenGL ES 2.0/libGLESv2/main.h
index 248381d..fdb0dc0 100644
--- a/src/OpenGL ES 2.0/libGLESv2/main.h
+++ b/src/OpenGL ES 2.0/libGLESv2/main.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// main.h: Management of thread-local data.
diff --git a/src/OpenGL ES 2.0/libGLESv2/mathutil.h b/src/OpenGL ES 2.0/libGLESv2/mathutil.h
index 5cc08d7..c44cd6a 100644
--- a/src/OpenGL ES 2.0/libGLESv2/mathutil.h
+++ b/src/OpenGL ES 2.0/libGLESv2/mathutil.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// mathutil.h: Math and bit manipulation functions.
@@ -72,27 +77,6 @@
}
}
-inline sw::Rect transformPixelRect(GLint x, GLint y, GLint w, GLint h, GLint surfaceHeight)
-{
- sw::Rect rect = {x,
- surfaceHeight - y - h,
- x + w,
- surfaceHeight - y};
-
- return rect;
-}
-
-inline int transformPixelYOffset(GLint yoffset, GLint h, GLint surfaceHeight)
-{
- return surfaceHeight - yoffset - h;
-}
-
-inline GLenum adjustWinding(GLenum winding)
-{
- ASSERT(winding == GL_CW || winding == GL_CCW);
- return winding == GL_CW ? GL_CCW : GL_CW;
-}
-
inline bool supportsSSE2()
{
static bool checked = false;
diff --git a/src/OpenGL ES 2.0/libGLESv2/utilities.cpp b/src/OpenGL ES 2.0/libGLESv2/utilities.cpp
index fde83d1..8c795f6 100644
--- a/src/OpenGL ES 2.0/libGLESv2/utilities.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/utilities.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// utilities.cpp: Conversion functions and other utility routines.
@@ -198,18 +203,21 @@
{
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
- break;
+ return 8 * (GLsizei)ceil((float)width / 4.0f) * (GLsizei)ceil((float)height / 4.0f);
+ case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
+ case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
+ return 16 * (GLsizei)ceil((float)width / 4.0f) * (GLsizei)ceil((float)height / 4.0f);
default:
return 0;
}
-
- return 8 * (GLsizei)ceil((float)width / 4.0f) * (GLsizei)ceil((float)height / 4.0f);
}
bool IsCompressed(GLenum format)
{
if(format == GL_COMPRESSED_RGB_S3TC_DXT1_EXT ||
- format == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT)
+ format == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ||
+ format == GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE ||
+ format == GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE)
{
return true;
}
@@ -275,35 +283,16 @@
CubeFace ConvertCubeFace(GLenum cubeFace)
{
- CubeFace face = CUBEMAP_FACE_POSITIVE_X;
-
- // Map a cube map texture target to the corresponding Device surface index. Note that the
- // Y faces are swapped because the Y coordinate to the texture lookup intrinsic functions
- // are negated in the pixel shader.
switch(cubeFace)
{
- case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
- face = CUBEMAP_FACE_POSITIVE_X;
- break;
- case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
- face = CUBEMAP_FACE_NEGATIVE_X;
- break;
- case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
- face = CUBEMAP_FACE_NEGATIVE_Y;
- break;
- case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
- face = CUBEMAP_FACE_POSITIVE_Y;
- break;
- case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
- face = CUBEMAP_FACE_POSITIVE_Z;
- break;
- case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
- face = CUBEMAP_FACE_NEGATIVE_Z;
- break;
- default: UNREACHABLE();
+ case GL_TEXTURE_CUBE_MAP_POSITIVE_X: return CUBEMAP_FACE_POSITIVE_X;
+ case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: return CUBEMAP_FACE_NEGATIVE_X;
+ case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: return CUBEMAP_FACE_POSITIVE_Y;
+ case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: return CUBEMAP_FACE_NEGATIVE_Y;
+ case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: return CUBEMAP_FACE_POSITIVE_Z;
+ case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: return CUBEMAP_FACE_NEGATIVE_Z;
+ default: UNREACHABLE(); return CUBEMAP_FACE_POSITIVE_X;
}
-
- return face;
}
bool IsTextureTarget(GLenum target)
@@ -674,8 +663,8 @@
case sw::FORMAT_D32F_LOCKABLE:
case sw::FORMAT_D16:
return 0;
- // case sw::FORMAT_D32_LOCKABLE: return 0; // DirectX 9Ex only
- // case sw::FORMAT_S8_LOCKABLE: return 8; // DirectX 9Ex only
+ // case sw::FORMAT_D32_LOCKABLE: return 0;
+ // case sw::FORMAT_S8_LOCKABLE: return 8;
default:
return 0;
}
diff --git a/src/OpenGL ES 2.0/libGLESv2/utilities.h b/src/OpenGL ES 2.0/libGLESv2/utilities.h
index 08fd676..ae258c5 100644
--- a/src/OpenGL ES 2.0/libGLESv2/utilities.h
+++ b/src/OpenGL ES 2.0/libGLESv2/utilities.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
//
// utilities.h: Conversion functions and other utility routines.
