Added latest BGFX (nw)

3rdparty/bgfx/3rdparty/.editorconfig

@@ -1,5 +1,9 @@
 root = true
 
+[fcpp/*]
+indent_style = space
+indent_size  = 2
+
 [ocornut-imgui/*]
-indent_style             = space
-indent_size              = 4
+indent_style = space
+indent_size  = 4

3rdparty/bgfx/3rdparty/dxsdk/directx-sdk-eula.txt

@@ -0,0 +1,77 @@
+MICROSOFT SOFTWARE LICENSE TERMS
+MICROSOFT DIRECTX SOFTWARE DEVELOPMENT KIT (SDK)
+These license terms are an agreement between Microsoft Corporation (or based on where you live, one of its affiliates) and you.  Please read them.  They apply to the software named above, which includes the media on which you received it, if any.  The terms also apply to any Microsoft
+•	updates,
+•	supplements,
+•	Internet-based services, and 
+•	support services
+for this software, unless other terms accompany those items.  If so, those terms apply.
+BY USING THE SOFTWARE, YOU ACCEPT THESE TERMS.  IF YOU DO NOT ACCEPT THEM, DO NOT USE THE SOFTWARE.
+If you comply with these license terms, you have the rights below.
+1.	INSTALLATION AND USE RIGHTS.  
+a.	Installation and Use.  You may install and use any number of copies of the software on your devices.
+b.	Included Microsoft Programs.  The software contains other Microsoft programs.  The license terms with those programs apply to your use of them.
+2.	ADDITIONAL LICENSING REQUIREMENTS AND/OR USE RIGHTS.
+a.	Media Elements and Templates.  You may copy and use images, clip art, animations, sounds, music, shapes, video clips and templates provided with the software and identified for such use in documents and projects that you create.  You may distribute those documents and projects non-commercially.  If you wish to use these media elements or templates for any other purpose, go to www.microsoft.com/permission to learn whether that use is allowed.
+b.	Distributable Code.  The software contains code that you are permitted to distribute in programs you develop if you comply with the terms below.
+i.	Right to Use and Distribute.  The code and text files listed below are “Distributable Code.”
+•	DIRECTX REDIST.TXT Files.  You may copy and distribute the object code form of code listed in DIRECTX REDIST.TXT files.
+•	Sample Code.  You may modify, copy, and distribute the source and object code form of code marked as “sample”, as well as those marked as follows:
+\Utilities\bin\x86\dxerr
+\Utilities\bin\x64\dxerr
+\Utilities\bin\x86\dxtex
+\Utilities\bin\x64\dxtex
+\Utilities\bin\x86\DxViewer
+\Utilities\bin\x64\DxViewer
+\Utilities\bin\x86\GDFTrace
+\Utilities\bin\x64\GDFTrace
+\Utilities\bin\x86\MeshConvert
+\Utilities\bin\x64\MeshConvert
+\Utilities\Source\Sas
+\Utilities\Source\Effects11
+•	Third Party Distribution.  You may permit distributors of your programs to copy and distribute the Distributable Code as part of those programs.
+ii.	Distribution Requirements.  For any Distributable Code you distribute, you must
+•	add significant primary functionality to it in your programs;
+•	require distributors and external end users to agree to terms that protect it at least as much as this agreement; 
+•	display your valid copyright notice on your programs; and
+•	indemnify, defend, and hold harmless Microsoft from any claims, including attorneys’ fees, related to the distribution or use of your programs.
+iii.	Distribution Restrictions.  You may not
+•	alter any copyright, trademark or patent notice in the Distributable Code; 
+•	use Microsoft’s trademarks in your programs’ names or in a way that suggests your programs come from or are endorsed by Microsoft; 
+•	distribute Distributable Code to run on a platform other than the Windows, Xbox and Windows Mobile platforms;
+•	include Distributable Code in malicious, deceptive or unlawful programs; or
+•	modify or distribute the source code of any Distributable Code so that any part of it becomes subject to an Excluded License.  An Excluded License is one that requires, as a condition of use, modification or distribution, that
+•	the code be disclosed or distributed in source code form; or 
+•	others have the right to modify it.
+3.	SCOPE OF LICENSE.  The software is licensed, not sold. This agreement only gives you some rights to use the software.  Microsoft reserves all other rights.  Unless applicable law gives you more rights despite this limitation, you may use the software only as expressly permitted in this agreement.  In doing so, you must comply with any technical limitations in the software that only allow you to use it in certain ways.    You may not
+•	disclose the results of any benchmark tests of the software to any third party without Microsoft’s prior written approval;
+•	work around any technical limitations in the software;
+•	reverse engineer, decompile or disassemble the software, except and only to the extent that applicable law expressly permits, despite this limitation;
+•	make more copies of the software than specified in this agreement or allowed by applicable law, despite this limitation;
+•	publish the software for others to copy;
+•	rent, lease or lend the software; or
+•	use the software for commercial software hosting services.
+4.	BACKUP COPY.  You may make one backup copy of the software.  You may use it only to reinstall the software.
+5.	DOCUMENTATION.  Any person that has valid access to your computer or internal network may copy and use the documentation for your internal, reference purposes.
+6.	EXPORT RESTRICTIONS.  The software is subject to United States export laws and regulations.  You must comply with all domestic and international export laws and regulations that apply to the software.  These laws include restrictions on destinations, end users and end use.  For additional information, see www.microsoft.com/exporting.
+7.	SUPPORT SERVICES. Because this software is “as is,” we may not provide support services for it.
+8.	ENTIRE AGREEMENT.  This agreement, and the terms for supplements, updates, Internet-based services and support services that you use, are the entire agreement for the software and support services.
+9.	APPLICABLE LAW.
+a.	United States.  If you acquired the software in the United States, Washington state law governs the interpretation of this agreement and applies to claims for breach of it, regardless of conflict of laws principles.  The laws of the state where you live govern all other claims, including claims under state consumer protection laws, unfair competition laws, and in tort.
+b.	Outside the United States.  If you acquired the software in any other country, the laws of that country apply.
+10.	LEGAL EFFECT.  This agreement describes certain legal rights.  You may have other rights under the laws of your country.  You may also have rights with respect to the party from whom you acquired the software.  This agreement does not change your rights under the laws of your country if the laws of your country do not permit it to do so.
+11.	DISCLAIMER OF WARRANTY.   THE SOFTWARE IS LICENSED “AS-IS.”  YOU BEAR THE RISK OF USING IT.  MICROSOFT GIVES NO EXPRESS WARRANTIES, GUARANTEES OR CONDITIONS.  YOU MAY HAVE ADDITIONAL CONSUMER RIGHTS UNDER YOUR LOCAL LAWS WHICH THIS AGREEMENT CANNOT CHANGE.  TO THE EXTENT PERMITTED UNDER YOUR LOCAL LAWS, MICROSOFT EXCLUDES THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+12.	LIMITATION ON AND EXCLUSION OF REMEDIES AND DAMAGES.  YOU CAN RECOVER FROM MICROSOFT AND ITS SUPPLIERS ONLY DIRECT DAMAGES UP TO U.S. $5.00.  YOU CANNOT RECOVER ANY OTHER DAMAGES, INCLUDING CONSEQUENTIAL, LOST PROFITS, SPECIAL, INDIRECT OR INCIDENTAL DAMAGES.
+This limitation applies to
+•	anything related to the software, services, content (including code) on third party Internet sites, or third party programs; and
+•	claims for breach of contract, breach of warranty, guarantee or condition, strict liability, negligence, or other tort to the extent permitted by applicable law.
+It also applies even if Microsoft knew or should have known about the possibility of the damages.  The above limitation or exclusion may not apply to you because your country may not allow the exclusion or limitation of incidental, consequential or other damages.
+Please note: As this software is distributed in Quebec, Canada, some of the clauses in this agreement are provided below in French.
+Remarque : Ce logiciel étant distribué au Québec, Canada, certaines des clauses dans ce contrat sont fournies ci-dessous en français.
+EXONÉRATION DE GARANTIE. Le logiciel visé par une licence est offert « tel quel ». Toute utilisation de ce logiciel est à votre seule risque et péril. Microsoft n’accorde aucune autre garantie expresse. Vous pouvez bénéficier de droits additionnels en vertu du droit local sur la protection des consommateurs, que ce contrat ne peut modifier. La ou elles sont permises par le droit locale, les garanties implicites de qualité marchande, d’adéquation à un usage particulier et d’absence de contrefaçon sont exclues.
+LIMITATION DES DOMMAGES-INTÉRÊTS ET EXCLUSION DE RESPONSABILITÉ POUR LES DOMMAGES.  Vous pouvez obtenir de Microsoft et de ses fournisseurs une indemnisation en cas de dommages directs uniquement à hauteur de 5,00 $ US. Vous ne pouvez prétendre à aucune indemnisation pour les autres dommages, y compris les dommages spéciaux, indirects ou accessoires et pertes de bénéfices.
+Cette limitation concerne :
+•	tout  ce qui est relié au logiciel, aux services ou au contenu (y compris le code) figurant sur des sites Internet tiers ou dans des programmes tiers ; et
+•	les réclamations au titre de violation de contrat ou de garantie, ou au titre de responsabilité stricte, de négligence ou d’une autre faute dans la limite autorisée par la loi en vigueur.
+Elle s’applique également, même si Microsoft connaissait ou devrait connaître l’éventualité d’un tel dommage.  Si votre pays n’autorise pas l’exclusion ou la limitation de responsabilité pour les dommages indirects, accessoires ou de quelque nature que ce soit, il se peut que la limitation ou l’exclusion ci-dessus ne s’appliquera pas à votre égard.
+EFFET JURIDIQUE.  Le présent contrat décrit certains droits juridiques. Vous pourriez avoir d’autres droits prévus par les lois de votre pays.  Le présent contrat ne modifie pas les droits que vous confèrent les lois de votre pays si celles-ci ne le permettent pas.

3rdparty/bgfx/3rdparty/dxsdk/include/d3d10_1shader.h

@@ -0,0 +1,305 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+//  File:       D3D10_1Shader.h
+//  Content:    D3D10.1 Shader Types and APIs
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef __D3D10_1SHADER_H__
+#define __D3D10_1SHADER_H__
+
+#include "d3d10shader.h"
+
+
+
+
+//----------------------------------------------------------------------------
+// Shader debugging structures
+//----------------------------------------------------------------------------
+
+typedef enum _D3D10_SHADER_DEBUG_REGTYPE
+{
+    D3D10_SHADER_DEBUG_REG_INPUT,
+    D3D10_SHADER_DEBUG_REG_OUTPUT,
+    D3D10_SHADER_DEBUG_REG_CBUFFER,
+    D3D10_SHADER_DEBUG_REG_TBUFFER,
+    D3D10_SHADER_DEBUG_REG_TEMP,
+    D3D10_SHADER_DEBUG_REG_TEMPARRAY,
+    D3D10_SHADER_DEBUG_REG_TEXTURE,
+    D3D10_SHADER_DEBUG_REG_SAMPLER,
+    D3D10_SHADER_DEBUG_REG_IMMEDIATECBUFFER,
+    D3D10_SHADER_DEBUG_REG_LITERAL,
+    D3D10_SHADER_DEBUG_REG_UNUSED,
+    D3D11_SHADER_DEBUG_REG_INTERFACE_POINTERS,
+    D3D11_SHADER_DEBUG_REG_UAV,
+    D3D10_SHADER_DEBUG_REG_FORCE_DWORD = 0x7fffffff,
+} D3D10_SHADER_DEBUG_REGTYPE;
+
+typedef enum _D3D10_SHADER_DEBUG_SCOPETYPE
+{
+    D3D10_SHADER_DEBUG_SCOPE_GLOBAL,
+    D3D10_SHADER_DEBUG_SCOPE_BLOCK,
+    D3D10_SHADER_DEBUG_SCOPE_FORLOOP,
+    D3D10_SHADER_DEBUG_SCOPE_STRUCT,
+    D3D10_SHADER_DEBUG_SCOPE_FUNC_PARAMS,
+    D3D10_SHADER_DEBUG_SCOPE_STATEBLOCK,
+    D3D10_SHADER_DEBUG_SCOPE_NAMESPACE,
+    D3D10_SHADER_DEBUG_SCOPE_ANNOTATION,
+    D3D10_SHADER_DEBUG_SCOPE_FORCE_DWORD = 0x7fffffff,
+} D3D10_SHADER_DEBUG_SCOPETYPE;
+
+typedef enum _D3D10_SHADER_DEBUG_VARTYPE
+{
+    D3D10_SHADER_DEBUG_VAR_VARIABLE,
+    D3D10_SHADER_DEBUG_VAR_FUNCTION,
+    D3D10_SHADER_DEBUG_VAR_FORCE_DWORD = 0x7fffffff,
+} D3D10_SHADER_DEBUG_VARTYPE;
+
+/////////////////////////////////////////////////////////////////////
+// These are the serialized structures that get written to the file
+/////////////////////////////////////////////////////////////////////
+
+typedef struct _D3D10_SHADER_DEBUG_TOKEN_INFO
+{
+    UINT File;    // offset into file list
+    UINT Line;    // line #
+    UINT Column;  // column #
+
+    UINT TokenLength;
+    UINT TokenId; // offset to LPCSTR of length TokenLength in string datastore
+} D3D10_SHADER_DEBUG_TOKEN_INFO;
+
+// Variable list
+typedef struct _D3D10_SHADER_DEBUG_VAR_INFO
+{
+    // Index into token list for declaring identifier
+    UINT TokenId;
+    D3D10_SHADER_VARIABLE_TYPE Type;
+    // register and component for this variable, only valid/necessary for arrays
+    UINT Register;
+    UINT Component;
+    // gives the original variable that declared this variable
+    UINT ScopeVar;
+    // this variable's offset in its ScopeVar
+    UINT ScopeVarOffset;
+} D3D10_SHADER_DEBUG_VAR_INFO;
+
+typedef struct _D3D10_SHADER_DEBUG_INPUT_INFO
+{
+    // index into array of variables of variable to initialize
+    UINT Var;
+    // input, cbuffer, tbuffer
+    D3D10_SHADER_DEBUG_REGTYPE InitialRegisterSet;
+    // set to cbuffer or tbuffer slot, geometry shader input primitive #,
+    // identifying register for indexable temp, or -1
+    UINT InitialBank;
+    // -1 if temp, otherwise gives register in register set
+    UINT InitialRegister;
+    // -1 if temp, otherwise gives component
+    UINT InitialComponent;
+    // initial value if literal
+    UINT InitialValue;
+} D3D10_SHADER_DEBUG_INPUT_INFO;
+
+typedef struct _D3D10_SHADER_DEBUG_SCOPEVAR_INFO
+{
+    // Index into variable token
+    UINT TokenId;
+
+    D3D10_SHADER_DEBUG_VARTYPE VarType; // variable or function (different namespaces)
+    D3D10_SHADER_VARIABLE_CLASS Class;
+    UINT Rows;          // number of rows (matrices)
+    UINT Columns;       // number of columns (vectors and matrices)
+
+    // In an array of structures, one struct member scope is provided, and
+    // you'll have to add the array stride times the index to the variable
+    // index you find, then find that variable in this structure's list of
+    // variables.
+
+    // gives a scope to look up struct members. -1 if not a struct
+    UINT StructMemberScope;
+
+    // number of array indices
+    UINT uArrayIndices;    // a[3][2][1] has 3 indices
+    // maximum array index for each index
+    // offset to UINT[uArrayIndices] in UINT datastore
+    UINT ArrayElements; // a[3][2][1] has {3, 2, 1}
+    // how many variables each array index moves
+    // offset to UINT[uArrayIndices] in UINT datastore
+    UINT ArrayStrides;  // a[3][2][1] has {2, 1, 1}
+
+    UINT uVariables;
+    // index of the first variable, later variables are offsets from this one
+    UINT uFirstVariable;
+} D3D10_SHADER_DEBUG_SCOPEVAR_INFO;
+
+// scope data, this maps variable names to debug variables (useful for the watch window)
+typedef struct _D3D10_SHADER_DEBUG_SCOPE_INFO
+{
+    D3D10_SHADER_DEBUG_SCOPETYPE ScopeType;
+    UINT Name;         // offset to name of scope in strings list
+    UINT uNameLen;     // length of name string
+    UINT uVariables;
+    UINT VariableData; // Offset to UINT[uVariables] indexing the Scope Variable list
+} D3D10_SHADER_DEBUG_SCOPE_INFO;
+
+// instruction outputs
+typedef struct _D3D10_SHADER_DEBUG_OUTPUTVAR
+{
+    // index variable being written to, if -1 it's not going to a variable
+    UINT Var;
+    // range data that the compiler expects to be true
+    UINT  uValueMin, uValueMax;
+    INT   iValueMin, iValueMax;
+    FLOAT fValueMin, fValueMax;
+
+    BOOL  bNaNPossible, bInfPossible;
+} D3D10_SHADER_DEBUG_OUTPUTVAR;
+
+typedef struct _D3D10_SHADER_DEBUG_OUTPUTREG_INFO
+{
+    // Only temp, indexable temp, and output are valid here
+    D3D10_SHADER_DEBUG_REGTYPE OutputRegisterSet;
+    // -1 means no output
+    UINT OutputReg;
+    // if a temp array, identifier for which one
+    UINT TempArrayReg;
+    // -1 means masked out
+    UINT OutputComponents[4];
+    D3D10_SHADER_DEBUG_OUTPUTVAR OutputVars[4];
+    // when indexing the output, get the value of this register, then add
+    // that to uOutputReg. If uIndexReg is -1, then there is no index.
+    // find the variable whose register is the sum (by looking in the ScopeVar)
+    // and component matches, then set it. This should only happen for indexable
+    // temps and outputs.
+    UINT IndexReg;
+    UINT IndexComp;
+} D3D10_SHADER_DEBUG_OUTPUTREG_INFO;
+
+// per instruction data
+typedef struct _D3D10_SHADER_DEBUG_INST_INFO
+{
+    UINT Id; // Which instruction this is in the bytecode
+    UINT Opcode; // instruction type
+
+    // 0, 1, or 2
+    UINT uOutputs;
+
+    // up to two outputs per instruction
+    D3D10_SHADER_DEBUG_OUTPUTREG_INFO pOutputs[2];
+    
+    // index into the list of tokens for this instruction's token
+    UINT TokenId;
+
+    // how many function calls deep this instruction is
+    UINT NestingLevel;
+
+    // list of scopes from outer-most to inner-most
+    // Number of scopes
+    UINT Scopes;
+    UINT ScopeInfo; // Offset to UINT[uScopes] specifying indices of the ScopeInfo Array
+
+    // list of variables accessed by this instruction
+    // Number of variables
+    UINT AccessedVars;
+    UINT AccessedVarsInfo; // Offset to UINT[AccessedVars] specifying indices of the ScopeVariableInfo Array
+} D3D10_SHADER_DEBUG_INST_INFO;
+
+typedef struct _D3D10_SHADER_DEBUG_FILE_INFO
+{
+    UINT FileName;    // Offset to LPCSTR for file name
+    UINT FileNameLen; // Length of file name
+    UINT FileData;    // Offset to LPCSTR of length FileLen
+    UINT FileLen;     // Length of file
+} D3D10_SHADER_DEBUG_FILE_INFO;
+
+typedef struct _D3D10_SHADER_DEBUG_INFO
+{
+    UINT Size;                             // sizeof(D3D10_SHADER_DEBUG_INFO)
+    UINT Creator;                          // Offset to LPCSTR for compiler version
+    UINT EntrypointName;                   // Offset to LPCSTR for Entry point name
+    UINT ShaderTarget;                     // Offset to LPCSTR for shader target
+    UINT CompileFlags;                     // flags used to compile
+    UINT Files;                            // number of included files
+    UINT FileInfo;                         // Offset to D3D10_SHADER_DEBUG_FILE_INFO[Files]
+    UINT Instructions;                     // number of instructions
+    UINT InstructionInfo;                  // Offset to D3D10_SHADER_DEBUG_INST_INFO[Instructions]
+    UINT Variables;                        // number of variables
+    UINT VariableInfo;                     // Offset to D3D10_SHADER_DEBUG_VAR_INFO[Variables]
+    UINT InputVariables;                   // number of variables to initialize before running
+    UINT InputVariableInfo;                // Offset to D3D10_SHADER_DEBUG_INPUT_INFO[InputVariables]
+    UINT Tokens;                           // number of tokens to initialize
+    UINT TokenInfo;                        // Offset to D3D10_SHADER_DEBUG_TOKEN_INFO[Tokens]
+    UINT Scopes;                           // number of scopes
+    UINT ScopeInfo;                        // Offset to D3D10_SHADER_DEBUG_SCOPE_INFO[Scopes]
+    UINT ScopeVariables;                   // number of variables declared
+    UINT ScopeVariableInfo;                // Offset to D3D10_SHADER_DEBUG_SCOPEVAR_INFO[Scopes]
+    UINT UintOffset;                       // Offset to the UINT datastore, all UINT offsets are from this offset
+    UINT StringOffset;                     // Offset to the string datastore, all string offsets are from this offset
+} D3D10_SHADER_DEBUG_INFO;
+
+//----------------------------------------------------------------------------
+// ID3D10ShaderReflection1:
+//----------------------------------------------------------------------------
+
+//
+// Interface definitions
+//
+
+
+typedef interface ID3D10ShaderReflection1 ID3D10ShaderReflection1;
+typedef interface ID3D10ShaderReflection1 *LPD3D10SHADERREFLECTION1;
+
+// {C3457783-A846-47CE-9520-CEA6F66E7447}
+DEFINE_GUID(IID_ID3D10ShaderReflection1, 
+0xc3457783, 0xa846, 0x47ce, 0x95, 0x20, 0xce, 0xa6, 0xf6, 0x6e, 0x74, 0x47);
+
+#undef INTERFACE
+#define INTERFACE ID3D10ShaderReflection1
+
+DECLARE_INTERFACE_(ID3D10ShaderReflection1, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D10_SHADER_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D10ShaderReflectionConstantBuffer*, GetConstantBufferByIndex)(THIS_ UINT Index) PURE;
+    STDMETHOD_(ID3D10ShaderReflectionConstantBuffer*, GetConstantBufferByName)(THIS_ LPCSTR Name) PURE;
+    
+    STDMETHOD(GetResourceBindingDesc)(THIS_ UINT ResourceIndex, _Out_ D3D10_SHADER_INPUT_BIND_DESC *pDesc) PURE;
+    
+    STDMETHOD(GetInputParameterDesc)(THIS_ UINT ParameterIndex, _Out_ D3D10_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+    STDMETHOD(GetOutputParameterDesc)(THIS_ UINT ParameterIndex, _Out_ D3D10_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+
+    STDMETHOD_(ID3D10ShaderReflectionVariable*, GetVariableByName)(THIS_ LPCSTR Name) PURE;
+
+    STDMETHOD(GetResourceBindingDescByName)(THIS_ LPCSTR Name, _Out_ D3D10_SHADER_INPUT_BIND_DESC *pDesc) PURE;
+
+    STDMETHOD(GetMovInstructionCount)(THIS_ _Out_ UINT* pCount) PURE;
+    STDMETHOD(GetMovcInstructionCount)(THIS_ _Out_ UINT* pCount) PURE;
+    STDMETHOD(GetConversionInstructionCount)(THIS_ _Out_ UINT* pCount) PURE;
+    STDMETHOD(GetBitwiseInstructionCount)(THIS_ _Out_ UINT* pCount) PURE;
+    
+    STDMETHOD(GetGSInputPrimitive)(THIS_ _Out_ D3D10_PRIMITIVE* pPrim) PURE;
+    STDMETHOD(IsLevel9Shader)(THIS_ _Out_ BOOL* pbLevel9Shader) PURE;
+    STDMETHOD(IsSampleFrequencyShader)(THIS_ _Out_ BOOL* pbSampleFrequency) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// APIs //////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+    
+#endif //__D3D10_1SHADER_H__
+

3rdparty/bgfx/3rdparty/dxsdk/include/d3d10misc.h

@@ -0,0 +1,146 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+//  File:       D3D10Misc.h
+//  Content:    D3D10 Device Creation APIs
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef __D3D10MISC_H__
+#define __D3D10MISC_H__
+
+#include "d3d10.h"
+
+// ID3D10Blob has been made version-neutral and moved to d3dcommon.h.
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+
+
+///////////////////////////////////////////////////////////////////////////
+// D3D10_DRIVER_TYPE
+// ----------------
+//
+// This identifier is used to determine the implementation of Direct3D10
+// to be used.
+//
+// Pass one of these values to D3D10CreateDevice
+//
+///////////////////////////////////////////////////////////////////////////
+typedef enum D3D10_DRIVER_TYPE
+{
+    D3D10_DRIVER_TYPE_HARDWARE  = 0,
+    D3D10_DRIVER_TYPE_REFERENCE = 1,
+    D3D10_DRIVER_TYPE_NULL      = 2,
+    D3D10_DRIVER_TYPE_SOFTWARE  = 3,
+    D3D10_DRIVER_TYPE_WARP      = 5,
+} D3D10_DRIVER_TYPE;
+
+DEFINE_GUID(GUID_DeviceType, 
+0xd722fb4d, 0x7a68, 0x437a, 0xb2, 0x0c, 0x58, 0x04, 0xee, 0x24, 0x94, 0xa6);
+
+///////////////////////////////////////////////////////////////////////////
+// D3D10CreateDevice
+// ------------------
+//
+// pAdapter
+//      If NULL, D3D10CreateDevice will choose the primary adapter and 
+//      create a new instance from a temporarily created IDXGIFactory.
+//      If non-NULL, D3D10CreateDevice will register the appropriate 
+//      device, if necessary (via IDXGIAdapter::RegisterDrver), before 
+//      creating the device.
+// DriverType
+//      Specifies the driver type to be created: hardware, reference or 
+//      null.
+// Software
+//      HMODULE of a DLL implementing a software rasterizer. Must be NULL for
+//      non-Software driver types.
+// Flags
+//      Any of those documented for D3D10CreateDevice.
+// SDKVersion
+//      SDK version. Use the D3D10_SDK_VERSION macro.
+// ppDevice
+//      Pointer to returned interface.
+//
+// Return Values
+//  Any of those documented for 
+//          CreateDXGIFactory
+//          IDXGIFactory::EnumAdapters
+//          IDXGIAdapter::RegisterDriver
+//          D3D10CreateDevice
+//      
+///////////////////////////////////////////////////////////////////////////
+HRESULT WINAPI D3D10CreateDevice(
+    _In_opt_ IDXGIAdapter *pAdapter,
+    D3D10_DRIVER_TYPE DriverType,
+    HMODULE Software,
+    UINT Flags,
+    UINT SDKVersion,
+    _Out_opt_ ID3D10Device **ppDevice);
+
+///////////////////////////////////////////////////////////////////////////
+// D3D10CreateDeviceAndSwapChain
+// ------------------------------
+//
+// ppAdapter
+//      If NULL, D3D10CreateDevice will choose the primary adapter and 
+//      create a new instance from a temporarily created IDXGIFactory.
+//      If non-NULL, D3D10CreateDevice will register the appropriate 
+//      device, if necessary (via IDXGIAdapter::RegisterDrver), before 
+//      creating the device.
+// DriverType
+//      Specifies the driver type to be created: hardware, reference or 
+//      null.
+// Software
+//      HMODULE of a DLL implementing a software rasterizer. Must be NULL for
+//      non-Software driver types.
+// Flags
+//      Any of those documented for D3D10CreateDevice.
+// SDKVersion
+//      SDK version. Use the D3D10_SDK_VERSION macro.
+// pSwapChainDesc
+//      Swap chain description, may be NULL.
+// ppSwapChain
+//      Pointer to returned interface. May be NULL.
+// ppDevice
+//      Pointer to returned interface.
+//
+// Return Values
+//  Any of those documented for 
+//          CreateDXGIFactory
+//          IDXGIFactory::EnumAdapters
+//          IDXGIAdapter::RegisterDriver
+//          D3D10CreateDevice
+//          IDXGIFactory::CreateSwapChain
+//      
+///////////////////////////////////////////////////////////////////////////
+HRESULT WINAPI D3D10CreateDeviceAndSwapChain(
+    _In_opt_ IDXGIAdapter *pAdapter,
+    D3D10_DRIVER_TYPE DriverType,
+    HMODULE Software,
+    UINT Flags,
+    UINT SDKVersion,
+    _In_opt_ DXGI_SWAP_CHAIN_DESC *pSwapChainDesc,
+    _Out_opt_ IDXGISwapChain **ppSwapChain,    
+    _Out_opt_ ID3D10Device **ppDevice);
+
+
+///////////////////////////////////////////////////////////////////////////
+// D3D10CreateBlob:
+// -----------------
+// Creates a Buffer of n Bytes
+//////////////////////////////////////////////////////////////////////////
+
+HRESULT WINAPI D3D10CreateBlob(SIZE_T NumBytes, _Out_ LPD3D10BLOB *ppBuffer);
+
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+
+#endif //__D3D10EFFECT_H__
+
+

3rdparty/bgfx/3rdparty/dxsdk/include/d3d10shader.h

@@ -0,0 +1,547 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+//  File:       D3D10Shader.h
+//  Content:    D3D10 Shader Types and APIs
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef __D3D10SHADER_H__
+#define __D3D10SHADER_H__
+
+
+#include "d3d10.h"
+
+
+
+
+//---------------------------------------------------------------------------
+// D3D10_TX_VERSION:
+// --------------
+// Version token used to create a procedural texture filler in effects
+// Used by D3D10Fill[]TX functions
+//---------------------------------------------------------------------------
+#define D3D10_TX_VERSION(_Major,_Minor) (('T' << 24) | ('X' << 16) | ((_Major) << 8) | (_Minor))
+
+
+//----------------------------------------------------------------------------
+// D3D10SHADER flags:
+// -----------------
+// D3D10_SHADER_DEBUG
+//   Insert debug file/line/type/symbol information.
+//
+// D3D10_SHADER_SKIP_VALIDATION
+//   Do not validate the generated code against known capabilities and
+//   constraints.  This option is only recommended when compiling shaders
+//   you KNOW will work.  (ie. have compiled before without this option.)
+//   Shaders are always validated by D3D before they are set to the device.
+//
+// D3D10_SHADER_SKIP_OPTIMIZATION 
+//   Instructs the compiler to skip optimization steps during code generation.
+//   Unless you are trying to isolate a problem in your code using this option 
+//   is not recommended.
+//
+// D3D10_SHADER_PACK_MATRIX_ROW_MAJOR
+//   Unless explicitly specified, matrices will be packed in row-major order
+//   on input and output from the shader.
+//
+// D3D10_SHADER_PACK_MATRIX_COLUMN_MAJOR
+//   Unless explicitly specified, matrices will be packed in column-major 
+//   order on input and output from the shader.  This is generally more 
+//   efficient, since it allows vector-matrix multiplication to be performed
+//   using a series of dot-products.
+//
+// D3D10_SHADER_PARTIAL_PRECISION
+//   Force all computations in resulting shader to occur at partial precision.
+//   This may result in faster evaluation of shaders on some hardware.
+//
+// D3D10_SHADER_FORCE_VS_SOFTWARE_NO_OPT
+//   Force compiler to compile against the next highest available software
+//   target for vertex shaders.  This flag also turns optimizations off, 
+//   and debugging on.  
+//
+// D3D10_SHADER_FORCE_PS_SOFTWARE_NO_OPT
+//   Force compiler to compile against the next highest available software
+//   target for pixel shaders.  This flag also turns optimizations off, 
+//   and debugging on.
+//
+// D3D10_SHADER_NO_PRESHADER
+//   Disables Preshaders. Using this flag will cause the compiler to not 
+//   pull out static expression for evaluation on the host cpu
+//
+// D3D10_SHADER_AVOID_FLOW_CONTROL
+//   Hint compiler to avoid flow-control constructs where possible.
+//
+// D3D10_SHADER_PREFER_FLOW_CONTROL
+//   Hint compiler to prefer flow-control constructs where possible.
+//
+// D3D10_SHADER_ENABLE_STRICTNESS
+//   By default, the HLSL/Effect compilers are not strict on deprecated syntax.
+//   Specifying this flag enables the strict mode. Deprecated syntax may be
+//   removed in a future release, and enabling syntax is a good way to make sure
+//   your shaders comply to the latest spec.
+//
+// D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY
+//   This enables older shaders to compile to 4_0 targets.
+//
+//----------------------------------------------------------------------------
+
+#define D3D10_SHADER_DEBUG                          (1 << 0)
+#define D3D10_SHADER_SKIP_VALIDATION                (1 << 1)
+#define D3D10_SHADER_SKIP_OPTIMIZATION              (1 << 2)
+#define D3D10_SHADER_PACK_MATRIX_ROW_MAJOR          (1 << 3)
+#define D3D10_SHADER_PACK_MATRIX_COLUMN_MAJOR       (1 << 4)
+#define D3D10_SHADER_PARTIAL_PRECISION              (1 << 5)
+#define D3D10_SHADER_FORCE_VS_SOFTWARE_NO_OPT       (1 << 6)
+#define D3D10_SHADER_FORCE_PS_SOFTWARE_NO_OPT       (1 << 7)
+#define D3D10_SHADER_NO_PRESHADER                   (1 << 8)
+#define D3D10_SHADER_AVOID_FLOW_CONTROL             (1 << 9)
+#define D3D10_SHADER_PREFER_FLOW_CONTROL            (1 << 10)
+#define D3D10_SHADER_ENABLE_STRICTNESS              (1 << 11)
+#define D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY (1 << 12)
+#define D3D10_SHADER_IEEE_STRICTNESS                (1 << 13)
+#define D3D10_SHADER_WARNINGS_ARE_ERRORS            (1 << 18)
+#define D3D10_SHADER_RESOURCES_MAY_ALIAS            (1 << 19)
+#define D3D10_ENABLE_UNBOUNDED_DESCRIPTOR_TABLES    (1 << 20)
+#define D3D10_ALL_RESOURCES_BOUND                   (1 << 21)
+
+
+// optimization level flags
+#define D3D10_SHADER_OPTIMIZATION_LEVEL0            (1 << 14)
+#define D3D10_SHADER_OPTIMIZATION_LEVEL1            0
+#define D3D10_SHADER_OPTIMIZATION_LEVEL2            ((1 << 14) | (1 << 15))
+#define D3D10_SHADER_OPTIMIZATION_LEVEL3            (1 << 15)
+
+
+
+
+typedef D3D_SHADER_MACRO D3D10_SHADER_MACRO;
+typedef D3D10_SHADER_MACRO* LPD3D10_SHADER_MACRO;
+
+
+typedef D3D_SHADER_VARIABLE_CLASS D3D10_SHADER_VARIABLE_CLASS;
+typedef D3D10_SHADER_VARIABLE_CLASS* LPD3D10_SHADER_VARIABLE_CLASS;
+
+typedef D3D_SHADER_VARIABLE_FLAGS D3D10_SHADER_VARIABLE_FLAGS;
+typedef D3D10_SHADER_VARIABLE_FLAGS* LPD3D10_SHADER_VARIABLE_FLAGS;
+
+typedef D3D_SHADER_VARIABLE_TYPE D3D10_SHADER_VARIABLE_TYPE;
+typedef D3D10_SHADER_VARIABLE_TYPE* LPD3D10_SHADER_VARIABLE_TYPE;
+
+typedef D3D_SHADER_INPUT_FLAGS D3D10_SHADER_INPUT_FLAGS;
+typedef D3D10_SHADER_INPUT_FLAGS* LPD3D10_SHADER_INPUT_FLAGS;
+
+typedef D3D_SHADER_INPUT_TYPE D3D10_SHADER_INPUT_TYPE;
+typedef D3D10_SHADER_INPUT_TYPE* LPD3D10_SHADER_INPUT_TYPE;
+
+typedef D3D_SHADER_CBUFFER_FLAGS D3D10_SHADER_CBUFFER_FLAGS;
+typedef D3D10_SHADER_CBUFFER_FLAGS* LPD3D10_SHADER_CBUFFER_FLAGS;
+
+typedef D3D_CBUFFER_TYPE D3D10_CBUFFER_TYPE;
+typedef D3D10_CBUFFER_TYPE* LPD3D10_CBUFFER_TYPE;
+
+typedef D3D_NAME D3D10_NAME;
+
+typedef D3D_RESOURCE_RETURN_TYPE D3D10_RESOURCE_RETURN_TYPE;
+
+typedef D3D_REGISTER_COMPONENT_TYPE D3D10_REGISTER_COMPONENT_TYPE;
+
+typedef D3D_INCLUDE_TYPE D3D10_INCLUDE_TYPE;
+
+// ID3D10Include has been made version-neutral and moved to d3dcommon.h.
+typedef interface ID3DInclude ID3D10Include;
+typedef interface ID3DInclude* LPD3D10INCLUDE;
+#define IID_ID3D10Include IID_ID3DInclude
+
+
+//----------------------------------------------------------------------------
+// ID3D10ShaderReflection:
+//----------------------------------------------------------------------------
+
+//
+// Structure definitions
+//
+
+typedef struct _D3D10_SHADER_DESC
+{
+    UINT                    Version;                     // Shader version
+    LPCSTR                  Creator;                     // Creator string
+    UINT                    Flags;                       // Shader compilation/parse flags
+    
+    UINT                    ConstantBuffers;             // Number of constant buffers
+    UINT                    BoundResources;              // Number of bound resources
+    UINT                    InputParameters;             // Number of parameters in the input signature
+    UINT                    OutputParameters;            // Number of parameters in the output signature
+
+    UINT                    InstructionCount;            // Number of emitted instructions
+    UINT                    TempRegisterCount;           // Number of temporary registers used 
+    UINT                    TempArrayCount;              // Number of temporary arrays used
+    UINT                    DefCount;                    // Number of constant defines 
+    UINT                    DclCount;                    // Number of declarations (input + output)
+    UINT                    TextureNormalInstructions;   // Number of non-categorized texture instructions
+    UINT                    TextureLoadInstructions;     // Number of texture load instructions
+    UINT                    TextureCompInstructions;     // Number of texture comparison instructions
+    UINT                    TextureBiasInstructions;     // Number of texture bias instructions
+    UINT                    TextureGradientInstructions; // Number of texture gradient instructions
+    UINT                    FloatInstructionCount;       // Number of floating point arithmetic instructions used
+    UINT                    IntInstructionCount;         // Number of signed integer arithmetic instructions used
+    UINT                    UintInstructionCount;        // Number of unsigned integer arithmetic instructions used
+    UINT                    StaticFlowControlCount;      // Number of static flow control instructions used
+    UINT                    DynamicFlowControlCount;     // Number of dynamic flow control instructions used
+    UINT                    MacroInstructionCount;       // Number of macro instructions used
+    UINT                    ArrayInstructionCount;       // Number of array instructions used
+    UINT                    CutInstructionCount;         // Number of cut instructions used
+    UINT                    EmitInstructionCount;        // Number of emit instructions used
+    D3D10_PRIMITIVE_TOPOLOGY GSOutputTopology;           // Geometry shader output topology
+    UINT                    GSMaxOutputVertexCount;      // Geometry shader maximum output vertex count
+} D3D10_SHADER_DESC;
+
+typedef struct _D3D10_SHADER_BUFFER_DESC
+{
+    LPCSTR                  Name;           // Name of the constant buffer
+    D3D10_CBUFFER_TYPE      Type;           // Indicates that this is a CBuffer or TBuffer
+    UINT                    Variables;      // Number of member variables
+    UINT                    Size;           // Size of CB (in bytes)
+    UINT                    uFlags;         // Buffer description flags
+} D3D10_SHADER_BUFFER_DESC;
+
+typedef struct _D3D10_SHADER_VARIABLE_DESC
+{
+    LPCSTR                  Name;           // Name of the variable
+    UINT                    StartOffset;    // Offset in constant buffer's backing store
+    UINT                    Size;           // Size of variable (in bytes)
+    UINT                    uFlags;         // Variable flags
+    LPVOID                  DefaultValue;   // Raw pointer to default value
+} D3D10_SHADER_VARIABLE_DESC;
+
+typedef struct _D3D10_SHADER_TYPE_DESC
+{
+    D3D10_SHADER_VARIABLE_CLASS Class;          // Variable class (e.g. object, matrix, etc.)
+    D3D10_SHADER_VARIABLE_TYPE  Type;           // Variable type (e.g. float, sampler, etc.)
+    UINT                        Rows;           // Number of rows (for matrices, 1 for other numeric, 0 if not applicable)
+    UINT                        Columns;        // Number of columns (for vectors & matrices, 1 for other numeric, 0 if not applicable)
+    UINT                        Elements;       // Number of elements (0 if not an array)
+    UINT                        Members;        // Number of members (0 if not a structure)
+    UINT                        Offset;         // Offset from the start of structure (0 if not a structure member) 
+} D3D10_SHADER_TYPE_DESC;
+
+typedef struct _D3D10_SHADER_INPUT_BIND_DESC
+{
+    LPCSTR                      Name;           // Name of the resource
+    D3D10_SHADER_INPUT_TYPE     Type;           // Type of resource (e.g. texture, cbuffer, etc.)
+    UINT                        BindPoint;      // Starting bind point
+    UINT                        BindCount;      // Number of contiguous bind points (for arrays)
+    
+    UINT                        uFlags;         // Input binding flags
+    D3D10_RESOURCE_RETURN_TYPE  ReturnType;     // Return type (if texture)
+    D3D10_SRV_DIMENSION         Dimension;      // Dimension (if texture)
+    UINT                        NumSamples;     // Number of samples (0 if not MS texture)
+} D3D10_SHADER_INPUT_BIND_DESC;
+
+typedef struct _D3D10_SIGNATURE_PARAMETER_DESC
+{
+    LPCSTR                      SemanticName;   // Name of the semantic
+    UINT                        SemanticIndex;  // Index of the semantic
+    UINT                        Register;       // Number of member variables
+    D3D10_NAME                  SystemValueType;// A predefined system value, or D3D10_NAME_UNDEFINED if not applicable
+    D3D10_REGISTER_COMPONENT_TYPE ComponentType;// Scalar type (e.g. uint, float, etc.)
+    BYTE                        Mask;           // Mask to indicate which components of the register
+                                                // are used (combination of D3D10_COMPONENT_MASK values)
+    BYTE                        ReadWriteMask;  // Mask to indicate whether a given component is 
+                                                // never written (if this is an output signature) or
+                                                // always read (if this is an input signature).
+                                                // (combination of D3D10_COMPONENT_MASK values)
+    
+} D3D10_SIGNATURE_PARAMETER_DESC;
+
+
+//
+// Interface definitions
+//
+
+
+
+
+typedef interface ID3D10ShaderReflectionType ID3D10ShaderReflectionType;
+typedef interface ID3D10ShaderReflectionType *LPD3D10SHADERREFLECTIONTYPE;
+
+// {C530AD7D-9B16-4395-A979-BA2ECFF83ADD}
+interface DECLSPEC_UUID("C530AD7D-9B16-4395-A979-BA2ECFF83ADD") ID3D10ShaderReflectionType;
+DEFINE_GUID(IID_ID3D10ShaderReflectionType, 
+0xc530ad7d, 0x9b16, 0x4395, 0xa9, 0x79, 0xba, 0x2e, 0xcf, 0xf8, 0x3a, 0xdd);
+
+#undef INTERFACE
+#define INTERFACE ID3D10ShaderReflectionType
+
+DECLARE_INTERFACE(ID3D10ShaderReflectionType)
+{
+    STDMETHOD(GetDesc)(THIS_ D3D10_SHADER_TYPE_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D10ShaderReflectionType*, GetMemberTypeByIndex)(THIS_ UINT Index) PURE;
+    STDMETHOD_(ID3D10ShaderReflectionType*, GetMemberTypeByName)(THIS_ LPCSTR Name) PURE;
+    STDMETHOD_(LPCSTR, GetMemberTypeName)(THIS_ UINT Index) PURE;
+};
+
+typedef interface ID3D10ShaderReflectionVariable ID3D10ShaderReflectionVariable;
+typedef interface ID3D10ShaderReflectionVariable *LPD3D10SHADERREFLECTIONVARIABLE;
+
+// {1BF63C95-2650-405d-99C1-3636BD1DA0A1}
+interface DECLSPEC_UUID("1BF63C95-2650-405d-99C1-3636BD1DA0A1") ID3D10ShaderReflectionVariable;
+DEFINE_GUID(IID_ID3D10ShaderReflectionVariable, 
+0x1bf63c95, 0x2650, 0x405d, 0x99, 0xc1, 0x36, 0x36, 0xbd, 0x1d, 0xa0, 0xa1);
+
+#undef INTERFACE
+#define INTERFACE ID3D10ShaderReflectionVariable
+
+DECLARE_INTERFACE(ID3D10ShaderReflectionVariable)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D10_SHADER_VARIABLE_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D10ShaderReflectionType*, GetType)(THIS) PURE;
+};
+
+typedef interface ID3D10ShaderReflectionConstantBuffer ID3D10ShaderReflectionConstantBuffer;
+typedef interface ID3D10ShaderReflectionConstantBuffer *LPD3D10SHADERREFLECTIONCONSTANTBUFFER;
+
+// {66C66A94-DDDD-4b62-A66A-F0DA33C2B4D0}
+interface DECLSPEC_UUID("66C66A94-DDDD-4b62-A66A-F0DA33C2B4D0") ID3D10ShaderReflectionConstantBuffer;
+DEFINE_GUID(IID_ID3D10ShaderReflectionConstantBuffer, 
+0x66c66a94, 0xdddd, 0x4b62, 0xa6, 0x6a, 0xf0, 0xda, 0x33, 0xc2, 0xb4, 0xd0);
+
+#undef INTERFACE
+#define INTERFACE ID3D10ShaderReflectionConstantBuffer
+
+DECLARE_INTERFACE(ID3D10ShaderReflectionConstantBuffer)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D10_SHADER_BUFFER_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D10ShaderReflectionVariable*, GetVariableByIndex)(THIS_ UINT Index) PURE;
+    STDMETHOD_(ID3D10ShaderReflectionVariable*, GetVariableByName)(THIS_ LPCSTR Name) PURE;
+};
+
+typedef interface ID3D10ShaderReflection ID3D10ShaderReflection;
+typedef interface ID3D10ShaderReflection *LPD3D10SHADERREFLECTION;
+
+// {D40E20B6-F8F7-42ad-AB20-4BAF8F15DFAA}
+interface DECLSPEC_UUID("D40E20B6-F8F7-42ad-AB20-4BAF8F15DFAA") ID3D10ShaderReflection;
+DEFINE_GUID(IID_ID3D10ShaderReflection, 
+0xd40e20b6, 0xf8f7, 0x42ad, 0xab, 0x20, 0x4b, 0xaf, 0x8f, 0x15, 0xdf, 0xaa);
+
+#undef INTERFACE
+#define INTERFACE ID3D10ShaderReflection
+
+DECLARE_INTERFACE_(ID3D10ShaderReflection, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D10_SHADER_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D10ShaderReflectionConstantBuffer*, GetConstantBufferByIndex)(THIS_ UINT Index) PURE;
+    STDMETHOD_(ID3D10ShaderReflectionConstantBuffer*, GetConstantBufferByName)(THIS_ LPCSTR Name) PURE;
+    
+    STDMETHOD(GetResourceBindingDesc)(THIS_ UINT ResourceIndex, _Out_ D3D10_SHADER_INPUT_BIND_DESC *pDesc) PURE;
+    
+    STDMETHOD(GetInputParameterDesc)(THIS_ UINT ParameterIndex, _Out_ D3D10_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+    STDMETHOD(GetOutputParameterDesc)(THIS_ UINT ParameterIndex, _Out_ D3D10_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+    
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// APIs //////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+//----------------------------------------------------------------------------
+// D3D10CompileShader:
+// ------------------
+// Compiles a shader.
+//
+// Parameters:
+//  pSrcFile
+//      Source file name.
+//  hSrcModule
+//      Module handle. if NULL, current module will be used.
+//  pSrcResource
+//      Resource name in module.
+//  pSrcData
+//      Pointer to source code.
+//  SrcDataSize
+//      Size of source code, in bytes.
+//  pDefines
+//      Optional NULL-terminated array of preprocessor macro definitions.
+//  pInclude
+//      Optional interface pointer to use for handling #include directives.
+//      If this parameter is NULL, #includes will be honored when compiling
+//      from file, and will error when compiling from resource or memory.
+//  pFunctionName
+//      Name of the entrypoint function where execution should begin.
+//  pProfile
+//      Instruction set to be used when generating code.  The D3D10 entry
+//      point currently supports only "vs_4_0", "ps_4_0", and "gs_4_0".
+//  Flags
+//      See D3D10_SHADER_xxx flags.
+//  ppShader
+//      Returns a buffer containing the created shader.  This buffer contains
+//      the compiled shader code, as well as any embedded debug and symbol
+//      table info.  (See D3D10GetShaderConstantTable)
+//  ppErrorMsgs
+//      Returns a buffer containing a listing of errors and warnings that were
+//      encountered during the compile.  If you are running in a debugger,
+//      these are the same messages you will see in your debug output.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI D3D10CompileShader(_In_reads_bytes_(SrcDataSize) LPCSTR pSrcData, SIZE_T SrcDataSize, _In_opt_ LPCSTR pFileName, _In_opt_ CONST D3D10_SHADER_MACRO* pDefines, _In_opt_ LPD3D10INCLUDE pInclude, 
+    LPCSTR pFunctionName, LPCSTR pProfile, UINT Flags, _Out_ ID3D10Blob** ppShader, _Out_opt_ ID3D10Blob** ppErrorMsgs);
+
+//----------------------------------------------------------------------------
+// D3D10DisassembleShader:
+// ----------------------
+// Takes a binary shader, and returns a buffer containing text assembly.
+//
+// Parameters:
+//  pShader
+//      Pointer to the shader byte code.
+//  BytecodeLength
+//      Size of the shader byte code in bytes.
+//  EnableColorCode
+//      Emit HTML tags for color coding the output?
+//  pComments
+//      Pointer to a comment string to include at the top of the shader.
+//  ppDisassembly
+//      Returns a buffer containing the disassembled shader.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI D3D10DisassembleShader(_In_reads_bytes_(BytecodeLength) CONST void *pShader, SIZE_T BytecodeLength, BOOL EnableColorCode, _In_opt_ LPCSTR pComments, _Out_ ID3D10Blob** ppDisassembly);
+
+
+//----------------------------------------------------------------------------
+// D3D10GetPixelShaderProfile/D3D10GetVertexShaderProfile/D3D10GetGeometryShaderProfile:
+// -----------------------------------------------------
+// Returns the name of the HLSL profile best suited to a given device.
+//
+// Parameters:
+//  pDevice
+//      Pointer to the device in question
+//----------------------------------------------------------------------------
+
+LPCSTR WINAPI D3D10GetPixelShaderProfile(_In_ ID3D10Device *pDevice);
+
+LPCSTR WINAPI D3D10GetVertexShaderProfile(_In_ ID3D10Device *pDevice);
+
+LPCSTR WINAPI D3D10GetGeometryShaderProfile(_In_ ID3D10Device *pDevice);
+
+//----------------------------------------------------------------------------
+// D3D10ReflectShader:
+// ------------------
+// Creates a shader reflection object that can be used to retrieve information
+// about a compiled shader
+//
+// Parameters:
+//  pShaderBytecode
+//      Pointer to a compiled shader (same pointer that is passed into
+//      ID3D10Device::CreateShader)
+//  BytecodeLength
+//      Length of the shader bytecode buffer
+//  ppReflector
+//      [out] Returns a ID3D10ShaderReflection object that can be used to 
+//      retrieve shader resource and constant buffer information
+//
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI D3D10ReflectShader(_In_reads_bytes_(BytecodeLength) CONST void *pShaderBytecode, SIZE_T BytecodeLength, _Out_ ID3D10ShaderReflection **ppReflector);
+
+//----------------------------------------------------------------------------
+// D3D10PreprocessShader
+// ---------------------
+// Creates a shader reflection object that can be used to retrieve information
+// about a compiled shader
+//
+// Parameters:
+//  pSrcData
+//      Pointer to source code
+//  SrcDataSize
+//      Size of source code, in bytes
+//  pFileName
+//      Source file name (used for error output)
+//  pDefines
+//      Optional NULL-terminated array of preprocessor macro definitions.
+//  pInclude
+//      Optional interface pointer to use for handling #include directives.
+//      If this parameter is NULL, #includes will be honored when assembling
+//      from file, and will error when assembling from resource or memory.
+//  ppShaderText
+//      Returns a buffer containing a single large string that represents
+//      the resulting formatted token stream
+//  ppErrorMsgs
+//      Returns a buffer containing a listing of errors and warnings that were
+//      encountered during assembly.  If you are running in a debugger,
+//      these are the same messages you will see in your debug output.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI D3D10PreprocessShader(_In_reads_bytes_(SrcDataSize) LPCSTR pSrcData, SIZE_T SrcDataSize, _In_opt_ LPCSTR pFileName, _In_opt_ CONST D3D10_SHADER_MACRO* pDefines, 
+    _In_opt_ LPD3D10INCLUDE pInclude, _Out_ ID3D10Blob** ppShaderText, _Out_opt_ ID3D10Blob** ppErrorMsgs);
+
+//////////////////////////////////////////////////////////////////////////
+//
+// Shader blob manipulation routines
+// ---------------------------------
+//
+// void *pShaderBytecode - a buffer containing the result of an HLSL
+//  compilation.  Typically this opaque buffer contains several 
+//  discrete sections including the shader executable code, the input
+//  signature, and the output signature.  This can typically be retrieved 
+//  by calling ID3D10Blob::GetBufferPointer() on the returned blob
+//  from HLSL's compile APIs.
+//
+// UINT BytecodeLength - the length of pShaderBytecode.  This can 
+//  typically be retrieved by calling ID3D10Blob::GetBufferSize() 
+//  on the returned blob from HLSL's compile APIs.
+//
+// ID3D10Blob **ppSignatureBlob(s) - a newly created buffer that
+//  contains only the signature portions of the original bytecode.
+//  This is a copy; the original bytecode is not modified.  You may
+//  specify NULL for this parameter to have the bytecode validated
+//  for the presence of the corresponding signatures without actually
+//  copying them and creating a new blob.
+//
+// Returns E_INVALIDARG if any required parameters are NULL
+// Returns E_FAIL is the bytecode is corrupt or missing signatures
+// Returns S_OK on success
+//
+//////////////////////////////////////////////////////////////////////////
+
+HRESULT WINAPI D3D10GetInputSignatureBlob(_In_reads_bytes_(BytecodeLength) CONST void *pShaderBytecode, SIZE_T BytecodeLength, _Out_ ID3D10Blob **ppSignatureBlob);
+HRESULT WINAPI D3D10GetOutputSignatureBlob(_In_reads_bytes_(BytecodeLength) CONST void *pShaderBytecode, SIZE_T BytecodeLength, _Out_ ID3D10Blob **ppSignatureBlob);
+HRESULT WINAPI D3D10GetInputAndOutputSignatureBlob(_In_reads_bytes_(BytecodeLength) CONST void *pShaderBytecode, SIZE_T BytecodeLength, _Out_ ID3D10Blob **ppSignatureBlob);
+
+//----------------------------------------------------------------------------
+// D3D10GetShaderDebugInfo:
+// -----------------------
+// Gets shader debug info.  Debug info is generated by D3D10CompileShader and is
+// embedded in the body of the shader.
+//
+// Parameters:
+//  pShaderBytecode
+//      Pointer to the function bytecode
+//  BytecodeLength
+//      Length of the shader bytecode buffer
+//  ppDebugInfo
+//      Buffer used to return debug info.  For information about the layout
+//      of this buffer, see definition of D3D10_SHADER_DEBUG_INFO above.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI D3D10GetShaderDebugInfo(_In_reads_bytes_(BytecodeLength) CONST void *pShaderBytecode, SIZE_T BytecodeLength, _Out_ ID3D10Blob** ppDebugInfo);
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+
+    
+#endif //__D3D10SHADER_H__
+

3rdparty/bgfx/3rdparty/dxsdk/include/d3d11shader.h

@@ -0,0 +1,601 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+//  File:       D3D11Shader.h
+//  Content:    D3D11 Shader Types and APIs
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef __D3D11SHADER_H__
+#define __D3D11SHADER_H__
+
+#include "d3dcommon.h"
+
+
+typedef enum D3D11_SHADER_VERSION_TYPE
+{
+    D3D11_SHVER_PIXEL_SHADER    = 0,
+    D3D11_SHVER_VERTEX_SHADER   = 1,
+    D3D11_SHVER_GEOMETRY_SHADER = 2,
+    
+    // D3D11 Shaders
+    D3D11_SHVER_HULL_SHADER     = 3,
+    D3D11_SHVER_DOMAIN_SHADER   = 4,
+    D3D11_SHVER_COMPUTE_SHADER  = 5,
+
+    D3D11_SHVER_RESERVED0       = 0xFFF0,
+} D3D11_SHADER_VERSION_TYPE;
+
+#define D3D11_SHVER_GET_TYPE(_Version) \
+    (((_Version) >> 16) & 0xffff)
+#define D3D11_SHVER_GET_MAJOR(_Version) \
+    (((_Version) >> 4) & 0xf)
+#define D3D11_SHVER_GET_MINOR(_Version) \
+    (((_Version) >> 0) & 0xf)
+
+// Slot ID for library function return
+#define D3D_RETURN_PARAMETER_INDEX (-1)
+
+typedef D3D_RESOURCE_RETURN_TYPE D3D11_RESOURCE_RETURN_TYPE;
+
+typedef D3D_CBUFFER_TYPE D3D11_CBUFFER_TYPE;
+
+
+typedef struct _D3D11_SIGNATURE_PARAMETER_DESC
+{
+    LPCSTR                      SemanticName;   // Name of the semantic
+    UINT                        SemanticIndex;  // Index of the semantic
+    UINT                        Register;       // Number of member variables
+    D3D_NAME                    SystemValueType;// A predefined system value, or D3D_NAME_UNDEFINED if not applicable
+    D3D_REGISTER_COMPONENT_TYPE ComponentType;  // Scalar type (e.g. uint, float, etc.)
+    BYTE                        Mask;           // Mask to indicate which components of the register
+                                                // are used (combination of D3D10_COMPONENT_MASK values)
+    BYTE                        ReadWriteMask;  // Mask to indicate whether a given component is 
+                                                // never written (if this is an output signature) or
+                                                // always read (if this is an input signature).
+                                                // (combination of D3D_MASK_* values)
+    UINT                        Stream;         // Stream index
+    D3D_MIN_PRECISION           MinPrecision;   // Minimum desired interpolation precision
+} D3D11_SIGNATURE_PARAMETER_DESC;
+
+typedef struct _D3D11_SHADER_BUFFER_DESC
+{
+    LPCSTR                  Name;           // Name of the constant buffer
+    D3D_CBUFFER_TYPE        Type;           // Indicates type of buffer content
+    UINT                    Variables;      // Number of member variables
+    UINT                    Size;           // Size of CB (in bytes)
+    UINT                    uFlags;         // Buffer description flags
+} D3D11_SHADER_BUFFER_DESC;
+
+typedef struct _D3D11_SHADER_VARIABLE_DESC
+{
+    LPCSTR                  Name;           // Name of the variable
+    UINT                    StartOffset;    // Offset in constant buffer's backing store
+    UINT                    Size;           // Size of variable (in bytes)
+    UINT                    uFlags;         // Variable flags
+    LPVOID                  DefaultValue;   // Raw pointer to default value
+    UINT                    StartTexture;   // First texture index (or -1 if no textures used)
+    UINT                    TextureSize;    // Number of texture slots possibly used.
+    UINT                    StartSampler;   // First sampler index (or -1 if no textures used)
+    UINT                    SamplerSize;    // Number of sampler slots possibly used.
+} D3D11_SHADER_VARIABLE_DESC;
+
+typedef struct _D3D11_SHADER_TYPE_DESC
+{
+    D3D_SHADER_VARIABLE_CLASS   Class;          // Variable class (e.g. object, matrix, etc.)
+    D3D_SHADER_VARIABLE_TYPE    Type;           // Variable type (e.g. float, sampler, etc.)
+    UINT                        Rows;           // Number of rows (for matrices, 1 for other numeric, 0 if not applicable)
+    UINT                        Columns;        // Number of columns (for vectors & matrices, 1 for other numeric, 0 if not applicable)
+    UINT                        Elements;       // Number of elements (0 if not an array)
+    UINT                        Members;        // Number of members (0 if not a structure)
+    UINT                        Offset;         // Offset from the start of structure (0 if not a structure member)
+    LPCSTR                      Name;           // Name of type, can be NULL
+} D3D11_SHADER_TYPE_DESC;
+
+typedef D3D_TESSELLATOR_DOMAIN D3D11_TESSELLATOR_DOMAIN;
+
+typedef D3D_TESSELLATOR_PARTITIONING D3D11_TESSELLATOR_PARTITIONING;
+
+typedef D3D_TESSELLATOR_OUTPUT_PRIMITIVE D3D11_TESSELLATOR_OUTPUT_PRIMITIVE;
+
+typedef struct _D3D11_SHADER_DESC
+{
+    UINT                    Version;                     // Shader version
+    LPCSTR                  Creator;                     // Creator string
+    UINT                    Flags;                       // Shader compilation/parse flags
+    
+    UINT                    ConstantBuffers;             // Number of constant buffers
+    UINT                    BoundResources;              // Number of bound resources
+    UINT                    InputParameters;             // Number of parameters in the input signature
+    UINT                    OutputParameters;            // Number of parameters in the output signature
+
+    UINT                    InstructionCount;            // Number of emitted instructions
+    UINT                    TempRegisterCount;           // Number of temporary registers used 
+    UINT                    TempArrayCount;              // Number of temporary arrays used
+    UINT                    DefCount;                    // Number of constant defines 
+    UINT                    DclCount;                    // Number of declarations (input + output)
+    UINT                    TextureNormalInstructions;   // Number of non-categorized texture instructions
+    UINT                    TextureLoadInstructions;     // Number of texture load instructions
+    UINT                    TextureCompInstructions;     // Number of texture comparison instructions
+    UINT                    TextureBiasInstructions;     // Number of texture bias instructions
+    UINT                    TextureGradientInstructions; // Number of texture gradient instructions
+    UINT                    FloatInstructionCount;       // Number of floating point arithmetic instructions used
+    UINT                    IntInstructionCount;         // Number of signed integer arithmetic instructions used
+    UINT                    UintInstructionCount;        // Number of unsigned integer arithmetic instructions used
+    UINT                    StaticFlowControlCount;      // Number of static flow control instructions used
+    UINT                    DynamicFlowControlCount;     // Number of dynamic flow control instructions used
+    UINT                    MacroInstructionCount;       // Number of macro instructions used
+    UINT                    ArrayInstructionCount;       // Number of array instructions used
+    UINT                    CutInstructionCount;         // Number of cut instructions used
+    UINT                    EmitInstructionCount;        // Number of emit instructions used
+    D3D_PRIMITIVE_TOPOLOGY  GSOutputTopology;            // Geometry shader output topology
+    UINT                    GSMaxOutputVertexCount;      // Geometry shader maximum output vertex count
+    D3D_PRIMITIVE           InputPrimitive;              // GS/HS input primitive
+    UINT                    PatchConstantParameters;     // Number of parameters in the patch constant signature
+    UINT                    cGSInstanceCount;            // Number of Geometry shader instances
+    UINT                    cControlPoints;              // Number of control points in the HS->DS stage
+    D3D_TESSELLATOR_OUTPUT_PRIMITIVE HSOutputPrimitive;  // Primitive output by the tessellator
+    D3D_TESSELLATOR_PARTITIONING HSPartitioning;         // Partitioning mode of the tessellator
+    D3D_TESSELLATOR_DOMAIN  TessellatorDomain;           // Domain of the tessellator (quad, tri, isoline)
+    // instruction counts
+    UINT cBarrierInstructions;                           // Number of barrier instructions in a compute shader
+    UINT cInterlockedInstructions;                       // Number of interlocked instructions
+    UINT cTextureStoreInstructions;                      // Number of texture writes
+} D3D11_SHADER_DESC;
+
+typedef struct _D3D11_SHADER_INPUT_BIND_DESC
+{
+    LPCSTR                      Name;           // Name of the resource
+    D3D_SHADER_INPUT_TYPE       Type;           // Type of resource (e.g. texture, cbuffer, etc.)
+    UINT                        BindPoint;      // Starting bind point
+    UINT                        BindCount;      // Number of contiguous bind points (for arrays)
+    
+    UINT                        uFlags;         // Input binding flags
+    D3D_RESOURCE_RETURN_TYPE    ReturnType;     // Return type (if texture)
+    D3D_SRV_DIMENSION           Dimension;      // Dimension (if texture)
+    UINT                        NumSamples;     // Number of samples (0 if not MS texture)
+} D3D11_SHADER_INPUT_BIND_DESC;
+
+#define D3D_SHADER_REQUIRES_DOUBLES                         0x00000001
+#define D3D_SHADER_REQUIRES_EARLY_DEPTH_STENCIL             0x00000002
+#define D3D_SHADER_REQUIRES_UAVS_AT_EVERY_STAGE             0x00000004
+#define D3D_SHADER_REQUIRES_64_UAVS                         0x00000008
+#define D3D_SHADER_REQUIRES_MINIMUM_PRECISION               0x00000010
+#define D3D_SHADER_REQUIRES_11_1_DOUBLE_EXTENSIONS          0x00000020
+#define D3D_SHADER_REQUIRES_11_1_SHADER_EXTENSIONS          0x00000040
+#define D3D_SHADER_REQUIRES_LEVEL_9_COMPARISON_FILTERING    0x00000080
+#define D3D_SHADER_REQUIRES_TILED_RESOURCES                 0x00000100
+
+
+typedef struct _D3D11_LIBRARY_DESC
+{
+    LPCSTR    Creator;           // The name of the originator of the library.
+    UINT      Flags;             // Compilation flags.
+    UINT      FunctionCount;     // Number of functions exported from the library.
+} D3D11_LIBRARY_DESC;
+
+typedef struct _D3D11_FUNCTION_DESC
+{
+    UINT                    Version;                     // Shader version
+    LPCSTR                  Creator;                     // Creator string
+    UINT                    Flags;                       // Shader compilation/parse flags
+    
+    UINT                    ConstantBuffers;             // Number of constant buffers
+    UINT                    BoundResources;              // Number of bound resources
+
+    UINT                    InstructionCount;            // Number of emitted instructions
+    UINT                    TempRegisterCount;           // Number of temporary registers used 
+    UINT                    TempArrayCount;              // Number of temporary arrays used
+    UINT                    DefCount;                    // Number of constant defines 
+    UINT                    DclCount;                    // Number of declarations (input + output)
+    UINT                    TextureNormalInstructions;   // Number of non-categorized texture instructions
+    UINT                    TextureLoadInstructions;     // Number of texture load instructions
+    UINT                    TextureCompInstructions;     // Number of texture comparison instructions
+    UINT                    TextureBiasInstructions;     // Number of texture bias instructions
+    UINT                    TextureGradientInstructions; // Number of texture gradient instructions
+    UINT                    FloatInstructionCount;       // Number of floating point arithmetic instructions used
+    UINT                    IntInstructionCount;         // Number of signed integer arithmetic instructions used
+    UINT                    UintInstructionCount;        // Number of unsigned integer arithmetic instructions used
+    UINT                    StaticFlowControlCount;      // Number of static flow control instructions used
+    UINT                    DynamicFlowControlCount;     // Number of dynamic flow control instructions used
+    UINT                    MacroInstructionCount;       // Number of macro instructions used
+    UINT                    ArrayInstructionCount;       // Number of array instructions used
+    UINT                    MovInstructionCount;         // Number of mov instructions used
+    UINT                    MovcInstructionCount;        // Number of movc instructions used
+    UINT                    ConversionInstructionCount;  // Number of type conversion instructions used
+    UINT                    BitwiseInstructionCount;     // Number of bitwise arithmetic instructions used
+    D3D_FEATURE_LEVEL       MinFeatureLevel;             // Min target of the function byte code
+    UINT64                  RequiredFeatureFlags;        // Required feature flags
+
+    LPCSTR                  Name;                        // Function name
+    INT                     FunctionParameterCount;      // Number of logical parameters in the function signature (not including return)
+    BOOL                    HasReturn;                   // TRUE, if function returns a value, false - it is a subroutine
+    BOOL                    Has10Level9VertexShader;     // TRUE, if there is a 10L9 VS blob
+    BOOL                    Has10Level9PixelShader;      // TRUE, if there is a 10L9 PS blob
+} D3D11_FUNCTION_DESC;
+
+typedef struct _D3D11_PARAMETER_DESC
+{
+    LPCSTR                      Name;               // Parameter name.
+    LPCSTR                      SemanticName;       // Parameter semantic name (+index).
+    D3D_SHADER_VARIABLE_TYPE    Type;               // Element type.
+    D3D_SHADER_VARIABLE_CLASS   Class;              // Scalar/Vector/Matrix.
+    UINT                        Rows;               // Rows are for matrix parameters.
+    UINT                        Columns;            // Components or Columns in matrix.
+    D3D_INTERPOLATION_MODE      InterpolationMode;  // Interpolation mode.
+    D3D_PARAMETER_FLAGS         Flags;              // Parameter modifiers.
+
+    UINT                        FirstInRegister;    // The first input register for this parameter.
+    UINT                        FirstInComponent;   // The first input register component for this parameter.
+    UINT                        FirstOutRegister;   // The first output register for this parameter.
+    UINT                        FirstOutComponent;  // The first output register component for this parameter.
+} D3D11_PARAMETER_DESC;
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Interfaces ////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3D11ShaderReflectionType ID3D11ShaderReflectionType;
+typedef interface ID3D11ShaderReflectionType *LPD3D11SHADERREFLECTIONTYPE;
+
+typedef interface ID3D11ShaderReflectionVariable ID3D11ShaderReflectionVariable;
+typedef interface ID3D11ShaderReflectionVariable *LPD3D11SHADERREFLECTIONVARIABLE;
+
+typedef interface ID3D11ShaderReflectionConstantBuffer ID3D11ShaderReflectionConstantBuffer;
+typedef interface ID3D11ShaderReflectionConstantBuffer *LPD3D11SHADERREFLECTIONCONSTANTBUFFER;
+
+typedef interface ID3D11ShaderReflection ID3D11ShaderReflection;
+typedef interface ID3D11ShaderReflection *LPD3D11SHADERREFLECTION;
+
+typedef interface ID3D11LibraryReflection ID3D11LibraryReflection;
+typedef interface ID3D11LibraryReflection *LPD3D11LIBRARYREFLECTION;
+
+typedef interface ID3D11FunctionReflection ID3D11FunctionReflection;
+typedef interface ID3D11FunctionReflection *LPD3D11FUNCTIONREFLECTION;
+
+typedef interface ID3D11FunctionParameterReflection ID3D11FunctionParameterReflection;
+typedef interface ID3D11FunctionParameterReflection *LPD3D11FUNCTIONPARAMETERREFLECTION;
+
+// {6E6FFA6A-9BAE-4613-A51E-91652D508C21}
+interface DECLSPEC_UUID("6E6FFA6A-9BAE-4613-A51E-91652D508C21") ID3D11ShaderReflectionType;
+DEFINE_GUID(IID_ID3D11ShaderReflectionType, 
+0x6e6ffa6a, 0x9bae, 0x4613, 0xa5, 0x1e, 0x91, 0x65, 0x2d, 0x50, 0x8c, 0x21);
+
+#undef INTERFACE
+#define INTERFACE ID3D11ShaderReflectionType
+
+DECLARE_INTERFACE(ID3D11ShaderReflectionType)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D11_SHADER_TYPE_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D11ShaderReflectionType*, GetMemberTypeByIndex)(THIS_ _In_ UINT Index) PURE;
+    STDMETHOD_(ID3D11ShaderReflectionType*, GetMemberTypeByName)(THIS_ _In_ LPCSTR Name) PURE;
+    STDMETHOD_(LPCSTR, GetMemberTypeName)(THIS_ _In_ UINT Index) PURE;
+
+    STDMETHOD(IsEqual)(THIS_ _In_ ID3D11ShaderReflectionType* pType) PURE;
+    STDMETHOD_(ID3D11ShaderReflectionType*, GetSubType)(THIS) PURE;
+    STDMETHOD_(ID3D11ShaderReflectionType*, GetBaseClass)(THIS) PURE;
+    STDMETHOD_(UINT, GetNumInterfaces)(THIS) PURE;
+    STDMETHOD_(ID3D11ShaderReflectionType*, GetInterfaceByIndex)(THIS_ _In_ UINT uIndex) PURE;
+    STDMETHOD(IsOfType)(THIS_ _In_ ID3D11ShaderReflectionType* pType) PURE;
+    STDMETHOD(ImplementsInterface)(THIS_ _In_ ID3D11ShaderReflectionType* pBase) PURE;
+};
+
+// {51F23923-F3E5-4BD1-91CB-606177D8DB4C}
+interface DECLSPEC_UUID("51F23923-F3E5-4BD1-91CB-606177D8DB4C") ID3D11ShaderReflectionVariable;
+DEFINE_GUID(IID_ID3D11ShaderReflectionVariable, 
+0x51f23923, 0xf3e5, 0x4bd1, 0x91, 0xcb, 0x60, 0x61, 0x77, 0xd8, 0xdb, 0x4c);
+
+#undef INTERFACE
+#define INTERFACE ID3D11ShaderReflectionVariable
+
+DECLARE_INTERFACE(ID3D11ShaderReflectionVariable)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D11_SHADER_VARIABLE_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D11ShaderReflectionType*, GetType)(THIS) PURE;
+    STDMETHOD_(ID3D11ShaderReflectionConstantBuffer*, GetBuffer)(THIS) PURE;
+
+    STDMETHOD_(UINT, GetInterfaceSlot)(THIS_ _In_ UINT uArrayIndex) PURE;
+};
+
+// {EB62D63D-93DD-4318-8AE8-C6F83AD371B8}
+interface DECLSPEC_UUID("EB62D63D-93DD-4318-8AE8-C6F83AD371B8") ID3D11ShaderReflectionConstantBuffer;
+DEFINE_GUID(IID_ID3D11ShaderReflectionConstantBuffer, 
+0xeb62d63d, 0x93dd, 0x4318, 0x8a, 0xe8, 0xc6, 0xf8, 0x3a, 0xd3, 0x71, 0xb8);
+
+#undef INTERFACE
+#define INTERFACE ID3D11ShaderReflectionConstantBuffer
+
+DECLARE_INTERFACE(ID3D11ShaderReflectionConstantBuffer)
+{
+    STDMETHOD(GetDesc)(THIS_ D3D11_SHADER_BUFFER_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D11ShaderReflectionVariable*, GetVariableByIndex)(THIS_ _In_ UINT Index) PURE;
+    STDMETHOD_(ID3D11ShaderReflectionVariable*, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;
+};
+
+// The ID3D11ShaderReflection IID may change from SDK version to SDK version
+// if the reflection API changes.  This prevents new code with the new API
+// from working with an old binary.  Recompiling with the new header
+// will pick up the new IID.
+
+// 8d536ca1-0cca-4956-a837-786963755584
+interface DECLSPEC_UUID("8d536ca1-0cca-4956-a837-786963755584") ID3D11ShaderReflection;
+DEFINE_GUID(IID_ID3D11ShaderReflection,
+0x8d536ca1, 0x0cca, 0x4956, 0xa8, 0x37, 0x78, 0x69, 0x63, 0x75, 0x55, 0x84);
+
+#undef INTERFACE
+#define INTERFACE ID3D11ShaderReflection
+
+DECLARE_INTERFACE_(ID3D11ShaderReflection, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ _In_ REFIID iid,
+                              _Out_ LPVOID *ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D11_SHADER_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D11ShaderReflectionConstantBuffer*, GetConstantBufferByIndex)(THIS_ _In_ UINT Index) PURE;
+    STDMETHOD_(ID3D11ShaderReflectionConstantBuffer*, GetConstantBufferByName)(THIS_ _In_ LPCSTR Name) PURE;
+    
+    STDMETHOD(GetResourceBindingDesc)(THIS_ _In_ UINT ResourceIndex,
+                                      _Out_ D3D11_SHADER_INPUT_BIND_DESC *pDesc) PURE;
+    
+    STDMETHOD(GetInputParameterDesc)(THIS_ _In_ UINT ParameterIndex,
+                                     _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+    STDMETHOD(GetOutputParameterDesc)(THIS_ _In_ UINT ParameterIndex,
+                                      _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+    STDMETHOD(GetPatchConstantParameterDesc)(THIS_ _In_ UINT ParameterIndex,
+                                             _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+
+    STDMETHOD_(ID3D11ShaderReflectionVariable*, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;
+
+    STDMETHOD(GetResourceBindingDescByName)(THIS_ _In_ LPCSTR Name,
+                                            _Out_ D3D11_SHADER_INPUT_BIND_DESC *pDesc) PURE;
+
+    STDMETHOD_(UINT, GetMovInstructionCount)(THIS) PURE;
+    STDMETHOD_(UINT, GetMovcInstructionCount)(THIS) PURE;
+    STDMETHOD_(UINT, GetConversionInstructionCount)(THIS) PURE;
+    STDMETHOD_(UINT, GetBitwiseInstructionCount)(THIS) PURE;
+    
+    STDMETHOD_(D3D_PRIMITIVE, GetGSInputPrimitive)(THIS) PURE;
+    STDMETHOD_(BOOL, IsSampleFrequencyShader)(THIS) PURE;
+
+    STDMETHOD_(UINT, GetNumInterfaceSlots)(THIS) PURE;
+    STDMETHOD(GetMinFeatureLevel)(THIS_ _Out_ enum D3D_FEATURE_LEVEL* pLevel) PURE;
+
+    STDMETHOD_(UINT, GetThreadGroupSize)(THIS_
+                                         _Out_opt_ UINT* pSizeX,
+                                         _Out_opt_ UINT* pSizeY,
+                                         _Out_opt_ UINT* pSizeZ) PURE;
+
+    STDMETHOD_(UINT64, GetRequiresFlags)(THIS) PURE;
+};
+
+// {54384F1B-5B3E-4BB7-AE01-60BA3097CBB6}
+interface DECLSPEC_UUID("54384F1B-5B3E-4BB7-AE01-60BA3097CBB6") ID3D11LibraryReflection;
+DEFINE_GUID(IID_ID3D11LibraryReflection, 
+0x54384f1b, 0x5b3e, 0x4bb7, 0xae, 0x1, 0x60, 0xba, 0x30, 0x97, 0xcb, 0xb6);
+
+#undef INTERFACE
+#define INTERFACE ID3D11LibraryReflection
+
+DECLARE_INTERFACE_(ID3D11LibraryReflection, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ _In_ REFIID iid, _Out_ LPVOID * ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D11_LIBRARY_DESC * pDesc) PURE;
+    
+    STDMETHOD_(ID3D11FunctionReflection *, GetFunctionByIndex)(THIS_ _In_ INT FunctionIndex) PURE;
+};
+
+// {207BCECB-D683-4A06-A8A3-9B149B9F73A4}
+interface DECLSPEC_UUID("207BCECB-D683-4A06-A8A3-9B149B9F73A4") ID3D11FunctionReflection;
+DEFINE_GUID(IID_ID3D11FunctionReflection, 
+0x207bcecb, 0xd683, 0x4a06, 0xa8, 0xa3, 0x9b, 0x14, 0x9b, 0x9f, 0x73, 0xa4);
+
+#undef INTERFACE
+#define INTERFACE ID3D11FunctionReflection
+
+DECLARE_INTERFACE(ID3D11FunctionReflection)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D11_FUNCTION_DESC * pDesc) PURE;
+    
+    STDMETHOD_(ID3D11ShaderReflectionConstantBuffer *, GetConstantBufferByIndex)(THIS_ _In_ UINT BufferIndex) PURE;
+    STDMETHOD_(ID3D11ShaderReflectionConstantBuffer *, GetConstantBufferByName)(THIS_ _In_ LPCSTR Name) PURE;
+    
+    STDMETHOD(GetResourceBindingDesc)(THIS_ _In_ UINT ResourceIndex,
+                                      _Out_ D3D11_SHADER_INPUT_BIND_DESC * pDesc) PURE;
+    
+    STDMETHOD_(ID3D11ShaderReflectionVariable *, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;
+
+    STDMETHOD(GetResourceBindingDescByName)(THIS_ _In_ LPCSTR Name,
+                                            _Out_ D3D11_SHADER_INPUT_BIND_DESC * pDesc) PURE;
+
+    // Use D3D_RETURN_PARAMETER_INDEX to get description of the return value.
+    STDMETHOD_(ID3D11FunctionParameterReflection *, GetFunctionParameter)(THIS_ _In_ INT ParameterIndex) PURE;
+};
+
+// {42757488-334F-47FE-982E-1A65D08CC462}
+interface DECLSPEC_UUID("42757488-334F-47FE-982E-1A65D08CC462") ID3D11FunctionParameterReflection;
+DEFINE_GUID(IID_ID3D11FunctionParameterReflection, 
+0x42757488, 0x334f, 0x47fe, 0x98, 0x2e, 0x1a, 0x65, 0xd0, 0x8c, 0xc4, 0x62);
+
+#undef INTERFACE
+#define INTERFACE ID3D11FunctionParameterReflection
+
+DECLARE_INTERFACE(ID3D11FunctionParameterReflection)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D11_PARAMETER_DESC * pDesc) PURE;
+};
+
+// {CAC701EE-80FC-4122-8242-10B39C8CEC34}
+interface DECLSPEC_UUID("CAC701EE-80FC-4122-8242-10B39C8CEC34") ID3D11Module;
+DEFINE_GUID(IID_ID3D11Module, 
+0xcac701ee, 0x80fc, 0x4122, 0x82, 0x42, 0x10, 0xb3, 0x9c, 0x8c, 0xec, 0x34);
+
+#undef INTERFACE
+#define INTERFACE ID3D11Module
+
+DECLARE_INTERFACE_(ID3D11Module, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ _In_ REFIID iid, _Out_ LPVOID * ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+    // Create an instance of a module for resource re-binding.
+    STDMETHOD(CreateInstance)(THIS_ _In_opt_ LPCSTR pNamespace,
+                                    _COM_Outptr_ interface ID3D11ModuleInstance ** ppModuleInstance) PURE;
+};
+
+
+// {469E07F7-045A-48D5-AA12-68A478CDF75D}
+interface DECLSPEC_UUID("469E07F7-045A-48D5-AA12-68A478CDF75D") ID3D11ModuleInstance;
+DEFINE_GUID(IID_ID3D11ModuleInstance, 
+0x469e07f7, 0x45a, 0x48d5, 0xaa, 0x12, 0x68, 0xa4, 0x78, 0xcd, 0xf7, 0x5d);
+
+#undef INTERFACE
+#define INTERFACE ID3D11ModuleInstance
+
+DECLARE_INTERFACE_(ID3D11ModuleInstance, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ _In_ REFIID iid, _Out_ LPVOID * ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+    //
+    // Resource binding API.
+    //
+    STDMETHOD(BindConstantBuffer)(THIS_ _In_ UINT uSrcSlot, _In_ UINT uDstSlot, _In_ UINT cbDstOffset) PURE;
+    STDMETHOD(BindConstantBufferByName)(THIS_ _In_ LPCSTR pName, _In_ UINT uDstSlot, _In_ UINT cbDstOffset) PURE;
+
+    STDMETHOD(BindResource)(THIS_ _In_ UINT uSrcSlot, _In_ UINT uDstSlot, _In_ UINT uCount) PURE;
+    STDMETHOD(BindResourceByName)(THIS_ _In_ LPCSTR pName, _In_ UINT uDstSlot, _In_ UINT uCount) PURE;
+
+    STDMETHOD(BindSampler)(THIS_ _In_ UINT uSrcSlot, _In_ UINT uDstSlot, _In_ UINT uCount) PURE;
+    STDMETHOD(BindSamplerByName)(THIS_ _In_ LPCSTR pName, _In_ UINT uDstSlot, _In_ UINT uCount) PURE;
+
+    STDMETHOD(BindUnorderedAccessView)(THIS_ _In_ UINT uSrcSlot, _In_ UINT uDstSlot, _In_ UINT uCount) PURE;
+    STDMETHOD(BindUnorderedAccessViewByName)(THIS_ _In_ LPCSTR pName, _In_ UINT uDstSlot, _In_ UINT uCount) PURE;
+
+    STDMETHOD(BindResourceAsUnorderedAccessView)(THIS_ _In_ UINT uSrcSrvSlot, _In_ UINT uDstUavSlot, _In_ UINT uCount) PURE;
+    STDMETHOD(BindResourceAsUnorderedAccessViewByName)(THIS_ _In_ LPCSTR pSrvName, _In_ UINT uDstUavSlot, _In_ UINT uCount) PURE;
+};
+
+
+// {59A6CD0E-E10D-4C1F-88C0-63ABA1DAF30E}
+interface DECLSPEC_UUID("59A6CD0E-E10D-4C1F-88C0-63ABA1DAF30E") ID3D11Linker;
+DEFINE_GUID(IID_ID3D11Linker, 
+0x59a6cd0e, 0xe10d, 0x4c1f, 0x88, 0xc0, 0x63, 0xab, 0xa1, 0xda, 0xf3, 0xe);
+
+#undef INTERFACE
+#define INTERFACE ID3D11Linker
+
+DECLARE_INTERFACE_(ID3D11Linker, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ _In_ REFIID iid, _Out_ LPVOID * ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+    // Link the shader and produce a shader blob suitable to D3D runtime.
+    STDMETHOD(Link)(THIS_ _In_ interface ID3D11ModuleInstance * pEntry,
+                          _In_ LPCSTR pEntryName,
+                          _In_ LPCSTR pTargetName,
+                          _In_ UINT uFlags,
+                          _COM_Outptr_ ID3DBlob ** ppShaderBlob,
+                          _Always_(_Outptr_opt_result_maybenull_) ID3DBlob ** ppErrorBuffer) PURE;
+
+    // Add an instance of a library module to be used for linking.
+    STDMETHOD(UseLibrary)(THIS_ _In_ interface ID3D11ModuleInstance * pLibraryMI) PURE;
+
+    // Add a clip plane with the plane coefficients taken from a cbuffer entry for 10L9 shaders.
+    STDMETHOD(AddClipPlaneFromCBuffer)(THIS_ _In_ UINT uCBufferSlot, _In_ UINT uCBufferEntry) PURE;
+};
+
+
+// {D80DD70C-8D2F-4751-94A1-03C79B3556DB}
+interface DECLSPEC_UUID("D80DD70C-8D2F-4751-94A1-03C79B3556DB") ID3D11LinkingNode;
+DEFINE_GUID(IID_ID3D11LinkingNode, 
+0xd80dd70c, 0x8d2f, 0x4751, 0x94, 0xa1, 0x3, 0xc7, 0x9b, 0x35, 0x56, 0xdb);
+
+#undef INTERFACE
+#define INTERFACE ID3D11LinkingNode
+
+DECLARE_INTERFACE_(ID3D11LinkingNode, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ _In_ REFIID iid, _Out_ LPVOID * ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+};
+
+
+// {54133220-1CE8-43D3-8236-9855C5CEECFF}
+interface DECLSPEC_UUID("54133220-1CE8-43D3-8236-9855C5CEECFF") ID3D11FunctionLinkingGraph;
+DEFINE_GUID(IID_ID3D11FunctionLinkingGraph, 
+0x54133220, 0x1ce8, 0x43d3, 0x82, 0x36, 0x98, 0x55, 0xc5, 0xce, 0xec, 0xff);
+
+#undef INTERFACE
+#define INTERFACE ID3D11FunctionLinkingGraph
+
+DECLARE_INTERFACE_(ID3D11FunctionLinkingGraph, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ _In_ REFIID iid, _Out_ LPVOID * ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+    // Create a shader module out of FLG description.
+    STDMETHOD(CreateModuleInstance)(THIS_ _COM_Outptr_ interface ID3D11ModuleInstance ** ppModuleInstance, 
+                                          _Always_(_Outptr_opt_result_maybenull_) ID3DBlob ** ppErrorBuffer) PURE;
+
+    STDMETHOD(SetInputSignature)(THIS_ __in_ecount(cInputParameters) const D3D11_PARAMETER_DESC * pInputParameters,
+                                       _In_ UINT cInputParameters,
+                                       _COM_Outptr_ interface ID3D11LinkingNode ** ppInputNode) PURE;
+
+    STDMETHOD(SetOutputSignature)(THIS_ __in_ecount(cOutputParameters) const D3D11_PARAMETER_DESC * pOutputParameters,
+                                        _In_ UINT cOutputParameters,
+                                        _COM_Outptr_ interface ID3D11LinkingNode ** ppOutputNode) PURE;
+
+    STDMETHOD(CallFunction)(THIS_ _In_opt_ LPCSTR pModuleInstanceNamespace,
+                                  _In_ interface ID3D11Module * pModuleWithFunctionPrototype,
+                                  _In_ LPCSTR pFunctionName,
+                                  _COM_Outptr_ interface ID3D11LinkingNode ** ppCallNode) PURE;
+
+    STDMETHOD(PassValue)(THIS_ _In_ interface ID3D11LinkingNode * pSrcNode,
+                               _In_ INT SrcParameterIndex,
+                               _In_ interface ID3D11LinkingNode * pDstNode,
+                               _In_ INT DstParameterIndex) PURE;
+
+    STDMETHOD(PassValueWithSwizzle)(THIS_ _In_ interface ID3D11LinkingNode * pSrcNode,
+                                          _In_ INT SrcParameterIndex,
+                                          _In_ LPCSTR pSrcSwizzle,
+                                          _In_ interface ID3D11LinkingNode * pDstNode,
+                                          _In_ INT DstParameterIndex,
+                                          _In_ LPCSTR pDstSwizzle) PURE;
+
+    STDMETHOD(GetLastError)(THIS_ _Always_(_Outptr_opt_result_maybenull_) ID3DBlob ** ppErrorBuffer) PURE;
+
+    STDMETHOD(GenerateHlsl)(THIS_ _In_ UINT uFlags,                 // uFlags is reserved for future use.
+                                  _COM_Outptr_ ID3DBlob ** ppBuffer) PURE;
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+// APIs //////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+    
+#endif //__D3D11SHADER_H__
+

3rdparty/bgfx/3rdparty/dxsdk/include/d3d11shadertracing.h

@@ -0,0 +1,570 @@
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 8.00.0613 */
+/* @@MIDL_FILE_HEADING(  ) */
+
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif /* __RPCNDR_H_VERSION__ */
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#ifndef __d3d11ShaderTracing_h__
+#define __d3d11ShaderTracing_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+/* Forward Declarations */ 
+
+#ifndef __ID3D11ShaderTrace_FWD_DEFINED__
+#define __ID3D11ShaderTrace_FWD_DEFINED__
+typedef interface ID3D11ShaderTrace ID3D11ShaderTrace;
+
+#endif 	/* __ID3D11ShaderTrace_FWD_DEFINED__ */
+
+
+#ifndef __ID3D11ShaderTraceFactory_FWD_DEFINED__
+#define __ID3D11ShaderTraceFactory_FWD_DEFINED__
+typedef interface ID3D11ShaderTraceFactory ID3D11ShaderTraceFactory;
+
+#endif 	/* __ID3D11ShaderTraceFactory_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_d3d11ShaderTracing_0000_0000 */
+/* [local] */ 
+
+typedef 
+enum D3D11_SHADER_TYPE
+    {
+        D3D11_VERTEX_SHADER	= 1,
+        D3D11_HULL_SHADER	= 2,
+        D3D11_DOMAIN_SHADER	= 3,
+        D3D11_GEOMETRY_SHADER	= 4,
+        D3D11_PIXEL_SHADER	= 5,
+        D3D11_COMPUTE_SHADER	= 6
+    } 	D3D11_SHADER_TYPE;
+
+#define D3D11_TRACE_COMPONENT_X 0x1
+#define D3D11_TRACE_COMPONENT_Y 0x2
+#define D3D11_TRACE_COMPONENT_Z 0x4
+#define D3D11_TRACE_COMPONENT_W 0x8
+typedef UINT8 D3D11_TRACE_COMPONENT_MASK;
+
+typedef struct D3D11_VERTEX_SHADER_TRACE_DESC
+    {
+    UINT64 Invocation;
+    } 	D3D11_VERTEX_SHADER_TRACE_DESC;
+
+typedef struct D3D11_HULL_SHADER_TRACE_DESC
+    {
+    UINT64 Invocation;
+    } 	D3D11_HULL_SHADER_TRACE_DESC;
+
+typedef struct D3D11_DOMAIN_SHADER_TRACE_DESC
+    {
+    UINT64 Invocation;
+    } 	D3D11_DOMAIN_SHADER_TRACE_DESC;
+
+typedef struct D3D11_GEOMETRY_SHADER_TRACE_DESC
+    {
+    UINT64 Invocation;
+    } 	D3D11_GEOMETRY_SHADER_TRACE_DESC;
+
+typedef struct D3D11_PIXEL_SHADER_TRACE_DESC
+    {
+    UINT64 Invocation;
+    INT X;
+    INT Y;
+    UINT64 SampleMask;
+    } 	D3D11_PIXEL_SHADER_TRACE_DESC;
+
+typedef struct D3D11_COMPUTE_SHADER_TRACE_DESC
+    {
+    UINT64 Invocation;
+    UINT ThreadIDInGroup[ 3 ];
+    UINT ThreadGroupID[ 3 ];
+    } 	D3D11_COMPUTE_SHADER_TRACE_DESC;
+
+#define D3D11_SHADER_TRACE_FLAG_RECORD_REGISTER_WRITES  0x1
+#define D3D11_SHADER_TRACE_FLAG_RECORD_REGISTER_READS   0x2
+typedef struct D3D11_SHADER_TRACE_DESC
+    {
+    D3D11_SHADER_TYPE Type;
+    UINT Flags;
+    union 
+        {
+        D3D11_VERTEX_SHADER_TRACE_DESC VertexShaderTraceDesc;
+        D3D11_HULL_SHADER_TRACE_DESC HullShaderTraceDesc;
+        D3D11_DOMAIN_SHADER_TRACE_DESC DomainShaderTraceDesc;
+        D3D11_GEOMETRY_SHADER_TRACE_DESC GeometryShaderTraceDesc;
+        D3D11_PIXEL_SHADER_TRACE_DESC PixelShaderTraceDesc;
+        D3D11_COMPUTE_SHADER_TRACE_DESC ComputeShaderTraceDesc;
+        } 	;
+    } 	D3D11_SHADER_TRACE_DESC;
+
+typedef 
+enum D3D11_TRACE_GS_INPUT_PRIMITIVE
+    {
+        D3D11_TRACE_GS_INPUT_PRIMITIVE_UNDEFINED	= 0,
+        D3D11_TRACE_GS_INPUT_PRIMITIVE_POINT	= 1,
+        D3D11_TRACE_GS_INPUT_PRIMITIVE_LINE	= 2,
+        D3D11_TRACE_GS_INPUT_PRIMITIVE_TRIANGLE	= 3,
+        D3D11_TRACE_GS_INPUT_PRIMITIVE_LINE_ADJ	= 6,
+        D3D11_TRACE_GS_INPUT_PRIMITIVE_TRIANGLE_ADJ	= 7
+    } 	D3D11_TRACE_GS_INPUT_PRIMITIVE;
+
+typedef struct D3D11_TRACE_STATS
+    {
+    D3D11_SHADER_TRACE_DESC TraceDesc;
+    UINT8 NumInvocationsInStamp;
+    UINT8 TargetStampIndex;
+    UINT NumTraceSteps;
+    D3D11_TRACE_COMPONENT_MASK InputMask[ 32 ];
+    D3D11_TRACE_COMPONENT_MASK OutputMask[ 32 ];
+    UINT16 NumTemps;
+    UINT16 MaxIndexableTempIndex;
+    UINT16 IndexableTempSize[ 4096 ];
+    UINT16 ImmediateConstantBufferSize;
+    UINT PixelPosition[ 4 ][ 2 ];
+    UINT64 PixelCoverageMask[ 4 ];
+    UINT64 PixelDiscardedMask[ 4 ];
+    UINT64 PixelCoverageMaskAfterShader[ 4 ];
+    UINT64 PixelCoverageMaskAfterA2CSampleMask[ 4 ];
+    UINT64 PixelCoverageMaskAfterA2CSampleMaskDepth[ 4 ];
+    UINT64 PixelCoverageMaskAfterA2CSampleMaskDepthStencil[ 4 ];
+    BOOL PSOutputsDepth;
+    BOOL PSOutputsMask;
+    D3D11_TRACE_GS_INPUT_PRIMITIVE GSInputPrimitive;
+    BOOL GSInputsPrimitiveID;
+    D3D11_TRACE_COMPONENT_MASK HSOutputPatchConstantMask[ 32 ];
+    D3D11_TRACE_COMPONENT_MASK DSInputPatchConstantMask[ 32 ];
+    } 	D3D11_TRACE_STATS;
+
+typedef struct D3D11_TRACE_VALUE
+    {
+    UINT Bits[ 4 ];
+    D3D11_TRACE_COMPONENT_MASK ValidMask;
+    } 	D3D11_TRACE_VALUE;
+
+typedef 
+enum D3D11_TRACE_REGISTER_TYPE
+    {
+        D3D11_TRACE_OUTPUT_NULL_REGISTER	= 0,
+        D3D11_TRACE_INPUT_REGISTER	= ( D3D11_TRACE_OUTPUT_NULL_REGISTER + 1 ) ,
+        D3D11_TRACE_INPUT_PRIMITIVE_ID_REGISTER	= ( D3D11_TRACE_INPUT_REGISTER + 1 ) ,
+        D3D11_TRACE_IMMEDIATE_CONSTANT_BUFFER	= ( D3D11_TRACE_INPUT_PRIMITIVE_ID_REGISTER + 1 ) ,
+        D3D11_TRACE_TEMP_REGISTER	= ( D3D11_TRACE_IMMEDIATE_CONSTANT_BUFFER + 1 ) ,
+        D3D11_TRACE_INDEXABLE_TEMP_REGISTER	= ( D3D11_TRACE_TEMP_REGISTER + 1 ) ,
+        D3D11_TRACE_OUTPUT_REGISTER	= ( D3D11_TRACE_INDEXABLE_TEMP_REGISTER + 1 ) ,
+        D3D11_TRACE_OUTPUT_DEPTH_REGISTER	= ( D3D11_TRACE_OUTPUT_REGISTER + 1 ) ,
+        D3D11_TRACE_CONSTANT_BUFFER	= ( D3D11_TRACE_OUTPUT_DEPTH_REGISTER + 1 ) ,
+        D3D11_TRACE_IMMEDIATE32	= ( D3D11_TRACE_CONSTANT_BUFFER + 1 ) ,
+        D3D11_TRACE_SAMPLER	= ( D3D11_TRACE_IMMEDIATE32 + 1 ) ,
+        D3D11_TRACE_RESOURCE	= ( D3D11_TRACE_SAMPLER + 1 ) ,
+        D3D11_TRACE_RASTERIZER	= ( D3D11_TRACE_RESOURCE + 1 ) ,
+        D3D11_TRACE_OUTPUT_COVERAGE_MASK	= ( D3D11_TRACE_RASTERIZER + 1 ) ,
+        D3D11_TRACE_STREAM	= ( D3D11_TRACE_OUTPUT_COVERAGE_MASK + 1 ) ,
+        D3D11_TRACE_THIS_POINTER	= ( D3D11_TRACE_STREAM + 1 ) ,
+        D3D11_TRACE_OUTPUT_CONTROL_POINT_ID_REGISTER	= ( D3D11_TRACE_THIS_POINTER + 1 ) ,
+        D3D11_TRACE_INPUT_FORK_INSTANCE_ID_REGISTER	= ( D3D11_TRACE_OUTPUT_CONTROL_POINT_ID_REGISTER + 1 ) ,
+        D3D11_TRACE_INPUT_JOIN_INSTANCE_ID_REGISTER	= ( D3D11_TRACE_INPUT_FORK_INSTANCE_ID_REGISTER + 1 ) ,
+        D3D11_TRACE_INPUT_CONTROL_POINT_REGISTER	= ( D3D11_TRACE_INPUT_JOIN_INSTANCE_ID_REGISTER + 1 ) ,
+        D3D11_TRACE_OUTPUT_CONTROL_POINT_REGISTER	= ( D3D11_TRACE_INPUT_CONTROL_POINT_REGISTER + 1 ) ,
+        D3D11_TRACE_INPUT_PATCH_CONSTANT_REGISTER	= ( D3D11_TRACE_OUTPUT_CONTROL_POINT_REGISTER + 1 ) ,
+        D3D11_TRACE_INPUT_DOMAIN_POINT_REGISTER	= ( D3D11_TRACE_INPUT_PATCH_CONSTANT_REGISTER + 1 ) ,
+        D3D11_TRACE_UNORDERED_ACCESS_VIEW	= ( D3D11_TRACE_INPUT_DOMAIN_POINT_REGISTER + 1 ) ,
+        D3D11_TRACE_THREAD_GROUP_SHARED_MEMORY	= ( D3D11_TRACE_UNORDERED_ACCESS_VIEW + 1 ) ,
+        D3D11_TRACE_INPUT_THREAD_ID_REGISTER	= ( D3D11_TRACE_THREAD_GROUP_SHARED_MEMORY + 1 ) ,
+        D3D11_TRACE_INPUT_THREAD_GROUP_ID_REGISTER	= ( D3D11_TRACE_INPUT_THREAD_ID_REGISTER + 1 ) ,
+        D3D11_TRACE_INPUT_THREAD_ID_IN_GROUP_REGISTER	= ( D3D11_TRACE_INPUT_THREAD_GROUP_ID_REGISTER + 1 ) ,
+        D3D11_TRACE_INPUT_COVERAGE_MASK_REGISTER	= ( D3D11_TRACE_INPUT_THREAD_ID_IN_GROUP_REGISTER + 1 ) ,
+        D3D11_TRACE_INPUT_THREAD_ID_IN_GROUP_FLATTENED_REGISTER	= ( D3D11_TRACE_INPUT_COVERAGE_MASK_REGISTER + 1 ) ,
+        D3D11_TRACE_INPUT_GS_INSTANCE_ID_REGISTER	= ( D3D11_TRACE_INPUT_THREAD_ID_IN_GROUP_FLATTENED_REGISTER + 1 ) ,
+        D3D11_TRACE_OUTPUT_DEPTH_GREATER_EQUAL_REGISTER	= ( D3D11_TRACE_INPUT_GS_INSTANCE_ID_REGISTER + 1 ) ,
+        D3D11_TRACE_OUTPUT_DEPTH_LESS_EQUAL_REGISTER	= ( D3D11_TRACE_OUTPUT_DEPTH_GREATER_EQUAL_REGISTER + 1 ) ,
+        D3D11_TRACE_IMMEDIATE64	= ( D3D11_TRACE_OUTPUT_DEPTH_LESS_EQUAL_REGISTER + 1 ) ,
+        D3D11_TRACE_INPUT_CYCLE_COUNTER_REGISTER	= ( D3D11_TRACE_IMMEDIATE64 + 1 ) ,
+        D3D11_TRACE_INTERFACE_POINTER	= ( D3D11_TRACE_INPUT_CYCLE_COUNTER_REGISTER + 1 ) 
+    } 	D3D11_TRACE_REGISTER_TYPE;
+
+#define D3D11_TRACE_REGISTER_FLAGS_RELATIVE_INDEXING 0x1
+typedef struct D3D11_TRACE_REGISTER
+    {
+    D3D11_TRACE_REGISTER_TYPE RegType;
+    union 
+        {
+        UINT16 Index1D;
+        UINT16 Index2D[ 2 ];
+        } 	;
+    UINT8 OperandIndex;
+    UINT8 Flags;
+    } 	D3D11_TRACE_REGISTER;
+
+#define D3D11_TRACE_MISC_GS_EMIT 0x1
+#define D3D11_TRACE_MISC_GS_CUT  0x2 
+#define D3D11_TRACE_MISC_PS_DISCARD 0x4 
+#define D3D11_TRACE_MISC_GS_EMIT_STREAM 0x8 
+#define D3D11_TRACE_MISC_GS_CUT_STREAM 0x10 
+#define D3D11_TRACE_MISC_HALT 0x20 
+#define D3D11_TRACE_MISC_MESSAGE 0x40 
+typedef UINT16 D3D11_TRACE_MISC_OPERATIONS_MASK;
+
+typedef struct D3D11_TRACE_STEP
+    {
+    UINT ID;
+    BOOL InstructionActive;
+    UINT8 NumRegistersWritten;
+    UINT8 NumRegistersRead;
+    D3D11_TRACE_MISC_OPERATIONS_MASK MiscOperations;
+    UINT OpcodeType;
+    UINT64 CurrentGlobalCycle;
+    } 	D3D11_TRACE_STEP;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d11ShaderTracing_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d11ShaderTracing_0000_0000_v0_0_s_ifspec;
+
+#ifndef __ID3D11ShaderTrace_INTERFACE_DEFINED__
+#define __ID3D11ShaderTrace_INTERFACE_DEFINED__
+
+/* interface ID3D11ShaderTrace */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D11ShaderTrace;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("36b013e6-2811-4845-baa7-d623fe0df104")
+    ID3D11ShaderTrace : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE TraceReady( 
+            /* [annotation] */ 
+            _Out_opt_  UINT64 *pTestCount) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResetTrace( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetTraceStats( 
+            /* [annotation] */ 
+            _Out_  D3D11_TRACE_STATS *pTraceStats) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PSSelectStamp( 
+            /* [annotation] */ 
+            _In_  UINT stampIndex) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetInitialRegisterContents( 
+            /* [annotation] */ 
+            _In_  D3D11_TRACE_REGISTER *pRegister,
+            /* [annotation] */ 
+            _Out_  D3D11_TRACE_VALUE *pValue) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetStep( 
+            /* [annotation] */ 
+            _In_  UINT stepIndex,
+            /* [annotation] */ 
+            _Out_  D3D11_TRACE_STEP *pTraceStep) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetWrittenRegister( 
+            /* [annotation] */ 
+            _In_  UINT stepIndex,
+            /* [annotation] */ 
+            _In_  UINT writtenRegisterIndex,
+            /* [annotation] */ 
+            _Out_  D3D11_TRACE_REGISTER *pRegister,
+            /* [annotation] */ 
+            _Out_  D3D11_TRACE_VALUE *pValue) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetReadRegister( 
+            /* [annotation] */ 
+            _In_  UINT stepIndex,
+            /* [annotation] */ 
+            _In_  UINT readRegisterIndex,
+            /* [annotation] */ 
+            _Out_  D3D11_TRACE_REGISTER *pRegister,
+            /* [annotation] */ 
+            _Out_  D3D11_TRACE_VALUE *pValue) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D11ShaderTraceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D11ShaderTrace * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D11ShaderTrace * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D11ShaderTrace * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *TraceReady )( 
+            ID3D11ShaderTrace * This,
+            /* [annotation] */ 
+            _Out_opt_  UINT64 *pTestCount);
+        
+        void ( STDMETHODCALLTYPE *ResetTrace )( 
+            ID3D11ShaderTrace * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetTraceStats )( 
+            ID3D11ShaderTrace * This,
+            /* [annotation] */ 
+            _Out_  D3D11_TRACE_STATS *pTraceStats);
+        
+        HRESULT ( STDMETHODCALLTYPE *PSSelectStamp )( 
+            ID3D11ShaderTrace * This,
+            /* [annotation] */ 
+            _In_  UINT stampIndex);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetInitialRegisterContents )( 
+            ID3D11ShaderTrace * This,
+            /* [annotation] */ 
+            _In_  D3D11_TRACE_REGISTER *pRegister,
+            /* [annotation] */ 
+            _Out_  D3D11_TRACE_VALUE *pValue);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetStep )( 
+            ID3D11ShaderTrace * This,
+            /* [annotation] */ 
+            _In_  UINT stepIndex,
+            /* [annotation] */ 
+            _Out_  D3D11_TRACE_STEP *pTraceStep);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetWrittenRegister )( 
+            ID3D11ShaderTrace * This,
+            /* [annotation] */ 
+            _In_  UINT stepIndex,
+            /* [annotation] */ 
+            _In_  UINT writtenRegisterIndex,
+            /* [annotation] */ 
+            _Out_  D3D11_TRACE_REGISTER *pRegister,
+            /* [annotation] */ 
+            _Out_  D3D11_TRACE_VALUE *pValue);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetReadRegister )( 
+            ID3D11ShaderTrace * This,
+            /* [annotation] */ 
+            _In_  UINT stepIndex,
+            /* [annotation] */ 
+            _In_  UINT readRegisterIndex,
+            /* [annotation] */ 
+            _Out_  D3D11_TRACE_REGISTER *pRegister,
+            /* [annotation] */ 
+            _Out_  D3D11_TRACE_VALUE *pValue);
+        
+        END_INTERFACE
+    } ID3D11ShaderTraceVtbl;
+
+    interface ID3D11ShaderTrace
+    {
+        CONST_VTBL struct ID3D11ShaderTraceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D11ShaderTrace_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D11ShaderTrace_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D11ShaderTrace_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D11ShaderTrace_TraceReady(This,pTestCount)	\
+    ( (This)->lpVtbl -> TraceReady(This,pTestCount) ) 
+
+#define ID3D11ShaderTrace_ResetTrace(This)	\
+    ( (This)->lpVtbl -> ResetTrace(This) ) 
+
+#define ID3D11ShaderTrace_GetTraceStats(This,pTraceStats)	\
+    ( (This)->lpVtbl -> GetTraceStats(This,pTraceStats) ) 
+
+#define ID3D11ShaderTrace_PSSelectStamp(This,stampIndex)	\
+    ( (This)->lpVtbl -> PSSelectStamp(This,stampIndex) ) 
+
+#define ID3D11ShaderTrace_GetInitialRegisterContents(This,pRegister,pValue)	\
+    ( (This)->lpVtbl -> GetInitialRegisterContents(This,pRegister,pValue) ) 
+
+#define ID3D11ShaderTrace_GetStep(This,stepIndex,pTraceStep)	\
+    ( (This)->lpVtbl -> GetStep(This,stepIndex,pTraceStep) ) 
+
+#define ID3D11ShaderTrace_GetWrittenRegister(This,stepIndex,writtenRegisterIndex,pRegister,pValue)	\
+    ( (This)->lpVtbl -> GetWrittenRegister(This,stepIndex,writtenRegisterIndex,pRegister,pValue) ) 
+
+#define ID3D11ShaderTrace_GetReadRegister(This,stepIndex,readRegisterIndex,pRegister,pValue)	\
+    ( (This)->lpVtbl -> GetReadRegister(This,stepIndex,readRegisterIndex,pRegister,pValue) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D11ShaderTrace_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D11ShaderTraceFactory_INTERFACE_DEFINED__
+#define __ID3D11ShaderTraceFactory_INTERFACE_DEFINED__
+
+/* interface ID3D11ShaderTraceFactory */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D11ShaderTraceFactory;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("1fbad429-66ab-41cc-9617-667ac10e4459")
+    ID3D11ShaderTraceFactory : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateShaderTrace( 
+            /* [annotation] */ 
+            _In_  IUnknown *pShader,
+            /* [annotation] */ 
+            _In_  D3D11_SHADER_TRACE_DESC *pTraceDesc,
+            /* [annotation] */ 
+            _COM_Outptr_  ID3D11ShaderTrace **ppShaderTrace) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D11ShaderTraceFactoryVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D11ShaderTraceFactory * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D11ShaderTraceFactory * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D11ShaderTraceFactory * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *CreateShaderTrace )( 
+            ID3D11ShaderTraceFactory * This,
+            /* [annotation] */ 
+            _In_  IUnknown *pShader,
+            /* [annotation] */ 
+            _In_  D3D11_SHADER_TRACE_DESC *pTraceDesc,
+            /* [annotation] */ 
+            _COM_Outptr_  ID3D11ShaderTrace **ppShaderTrace);
+        
+        END_INTERFACE
+    } ID3D11ShaderTraceFactoryVtbl;
+
+    interface ID3D11ShaderTraceFactory
+    {
+        CONST_VTBL struct ID3D11ShaderTraceFactoryVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D11ShaderTraceFactory_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D11ShaderTraceFactory_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D11ShaderTraceFactory_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D11ShaderTraceFactory_CreateShaderTrace(This,pShader,pTraceDesc,ppShaderTrace)	\
+    ( (This)->lpVtbl -> CreateShaderTrace(This,pShader,pTraceDesc,ppShaderTrace) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D11ShaderTraceFactory_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d11ShaderTracing_0000_0002 */
+/* [local] */ 
+
+HRESULT WINAPI
+D3DDisassemble11Trace(_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
+                      _In_ SIZE_T SrcDataSize,
+                      _In_ ID3D11ShaderTrace* pTrace,
+                      _In_ UINT StartStep,
+                      _In_ UINT NumSteps,
+                      _In_ UINT Flags,
+                      _COM_Outptr_ interface ID3D10Blob** ppDisassembly);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d11ShaderTracing_0000_0002_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d11ShaderTracing_0000_0002_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+

3rdparty/bgfx/3rdparty/dxsdk/include/d3d12shader.h

@@ -0,0 +1,459 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+//  File:       D3D12Shader.h
+//  Content:    D3D12 Shader Types and APIs
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef __D3D12SHADER_H__
+#define __D3D12SHADER_H__
+
+#include "d3dcommon.h"
+
+typedef enum D3D12_SHADER_VERSION_TYPE
+{
+    D3D12_SHVER_PIXEL_SHADER    = 0,
+    D3D12_SHVER_VERTEX_SHADER   = 1,
+    D3D12_SHVER_GEOMETRY_SHADER = 2,
+    
+    // D3D11 Shaders
+    D3D12_SHVER_HULL_SHADER     = 3,
+    D3D12_SHVER_DOMAIN_SHADER   = 4,
+    D3D12_SHVER_COMPUTE_SHADER  = 5,
+
+    D3D12_SHVER_RESERVED0       = 0xFFF0,
+} D3D12_SHADER_VERSION_TYPE;
+
+#define D3D12_SHVER_GET_TYPE(_Version) \
+    (((_Version) >> 16) & 0xffff)
+#define D3D12_SHVER_GET_MAJOR(_Version) \
+    (((_Version) >> 4) & 0xf)
+#define D3D12_SHVER_GET_MINOR(_Version) \
+    (((_Version) >> 0) & 0xf)
+
+// Slot ID for library function return
+#define D3D_RETURN_PARAMETER_INDEX (-1)
+
+typedef D3D_RESOURCE_RETURN_TYPE D3D12_RESOURCE_RETURN_TYPE;
+
+typedef D3D_CBUFFER_TYPE D3D12_CBUFFER_TYPE;
+
+
+typedef struct _D3D12_SIGNATURE_PARAMETER_DESC
+{
+    LPCSTR                      SemanticName;   // Name of the semantic
+    UINT                        SemanticIndex;  // Index of the semantic
+    UINT                        Register;       // Number of member variables
+    D3D_NAME                    SystemValueType;// A predefined system value, or D3D_NAME_UNDEFINED if not applicable
+    D3D_REGISTER_COMPONENT_TYPE ComponentType;  // Scalar type (e.g. uint, float, etc.)
+    BYTE                        Mask;           // Mask to indicate which components of the register
+                                                // are used (combination of D3D10_COMPONENT_MASK values)
+    BYTE                        ReadWriteMask;  // Mask to indicate whether a given component is 
+                                                // never written (if this is an output signature) or
+                                                // always read (if this is an input signature).
+                                                // (combination of D3D_MASK_* values)
+    UINT                        Stream;         // Stream index
+    D3D_MIN_PRECISION           MinPrecision;   // Minimum desired interpolation precision
+} D3D12_SIGNATURE_PARAMETER_DESC;
+
+typedef struct _D3D12_SHADER_BUFFER_DESC
+{
+    LPCSTR                  Name;           // Name of the constant buffer
+    D3D_CBUFFER_TYPE        Type;           // Indicates type of buffer content
+    UINT                    Variables;      // Number of member variables
+    UINT                    Size;           // Size of CB (in bytes)
+    UINT                    uFlags;         // Buffer description flags
+} D3D12_SHADER_BUFFER_DESC;
+
+typedef struct _D3D12_SHADER_VARIABLE_DESC
+{
+    LPCSTR                  Name;           // Name of the variable
+    UINT                    StartOffset;    // Offset in constant buffer's backing store
+    UINT                    Size;           // Size of variable (in bytes)
+    UINT                    uFlags;         // Variable flags
+    LPVOID                  DefaultValue;   // Raw pointer to default value
+    UINT                    StartTexture;   // First texture index (or -1 if no textures used)
+    UINT                    TextureSize;    // Number of texture slots possibly used.
+    UINT                    StartSampler;   // First sampler index (or -1 if no textures used)
+    UINT                    SamplerSize;    // Number of sampler slots possibly used.
+} D3D12_SHADER_VARIABLE_DESC;
+
+typedef struct _D3D12_SHADER_TYPE_DESC
+{
+    D3D_SHADER_VARIABLE_CLASS   Class;          // Variable class (e.g. object, matrix, etc.)
+    D3D_SHADER_VARIABLE_TYPE    Type;           // Variable type (e.g. float, sampler, etc.)
+    UINT                        Rows;           // Number of rows (for matrices, 1 for other numeric, 0 if not applicable)
+    UINT                        Columns;        // Number of columns (for vectors & matrices, 1 for other numeric, 0 if not applicable)
+    UINT                        Elements;       // Number of elements (0 if not an array)
+    UINT                        Members;        // Number of members (0 if not a structure)
+    UINT                        Offset;         // Offset from the start of structure (0 if not a structure member)
+    LPCSTR                      Name;           // Name of type, can be NULL
+} D3D12_SHADER_TYPE_DESC;
+
+typedef D3D_TESSELLATOR_DOMAIN D3D12_TESSELLATOR_DOMAIN;
+
+typedef D3D_TESSELLATOR_PARTITIONING D3D12_TESSELLATOR_PARTITIONING;
+
+typedef D3D_TESSELLATOR_OUTPUT_PRIMITIVE D3D12_TESSELLATOR_OUTPUT_PRIMITIVE;
+
+typedef struct _D3D12_SHADER_DESC
+{
+    UINT                    Version;                     // Shader version
+    LPCSTR                  Creator;                     // Creator string
+    UINT                    Flags;                       // Shader compilation/parse flags
+    
+    UINT                    ConstantBuffers;             // Number of constant buffers
+    UINT                    BoundResources;              // Number of bound resources
+    UINT                    InputParameters;             // Number of parameters in the input signature
+    UINT                    OutputParameters;            // Number of parameters in the output signature
+
+    UINT                    InstructionCount;            // Number of emitted instructions
+    UINT                    TempRegisterCount;           // Number of temporary registers used 
+    UINT                    TempArrayCount;              // Number of temporary arrays used
+    UINT                    DefCount;                    // Number of constant defines 
+    UINT                    DclCount;                    // Number of declarations (input + output)
+    UINT                    TextureNormalInstructions;   // Number of non-categorized texture instructions
+    UINT                    TextureLoadInstructions;     // Number of texture load instructions
+    UINT                    TextureCompInstructions;     // Number of texture comparison instructions
+    UINT                    TextureBiasInstructions;     // Number of texture bias instructions
+    UINT                    TextureGradientInstructions; // Number of texture gradient instructions
+    UINT                    FloatInstructionCount;       // Number of floating point arithmetic instructions used
+    UINT                    IntInstructionCount;         // Number of signed integer arithmetic instructions used
+    UINT                    UintInstructionCount;        // Number of unsigned integer arithmetic instructions used
+    UINT                    StaticFlowControlCount;      // Number of static flow control instructions used
+    UINT                    DynamicFlowControlCount;     // Number of dynamic flow control instructions used
+    UINT                    MacroInstructionCount;       // Number of macro instructions used
+    UINT                    ArrayInstructionCount;       // Number of array instructions used
+    UINT                    CutInstructionCount;         // Number of cut instructions used
+    UINT                    EmitInstructionCount;        // Number of emit instructions used
+    D3D_PRIMITIVE_TOPOLOGY  GSOutputTopology;            // Geometry shader output topology
+    UINT                    GSMaxOutputVertexCount;      // Geometry shader maximum output vertex count
+    D3D_PRIMITIVE           InputPrimitive;              // GS/HS input primitive
+    UINT                    PatchConstantParameters;     // Number of parameters in the patch constant signature
+    UINT                    cGSInstanceCount;            // Number of Geometry shader instances
+    UINT                    cControlPoints;              // Number of control points in the HS->DS stage
+    D3D_TESSELLATOR_OUTPUT_PRIMITIVE HSOutputPrimitive;  // Primitive output by the tessellator
+    D3D_TESSELLATOR_PARTITIONING HSPartitioning;         // Partitioning mode of the tessellator
+    D3D_TESSELLATOR_DOMAIN  TessellatorDomain;           // Domain of the tessellator (quad, tri, isoline)
+    // instruction counts
+    UINT cBarrierInstructions;                           // Number of barrier instructions in a compute shader
+    UINT cInterlockedInstructions;                       // Number of interlocked instructions
+    UINT cTextureStoreInstructions;                      // Number of texture writes
+} D3D12_SHADER_DESC;
+
+typedef struct _D3D12_SHADER_INPUT_BIND_DESC
+{
+    LPCSTR                      Name;           // Name of the resource
+    D3D_SHADER_INPUT_TYPE       Type;           // Type of resource (e.g. texture, cbuffer, etc.)
+    UINT                        BindPoint;      // Starting bind point
+    UINT                        BindCount;      // Number of contiguous bind points (for arrays)
+
+    UINT                        uFlags;         // Input binding flags
+    D3D_RESOURCE_RETURN_TYPE    ReturnType;     // Return type (if texture)
+    D3D_SRV_DIMENSION           Dimension;      // Dimension (if texture)
+    UINT                        NumSamples;     // Number of samples (0 if not MS texture)
+    UINT                        Space;          // Register space
+    UINT uID;                                   // Range ID in the bytecode
+} D3D12_SHADER_INPUT_BIND_DESC;
+
+#define D3D_SHADER_REQUIRES_DOUBLES                                                         0x00000001
+#define D3D_SHADER_REQUIRES_EARLY_DEPTH_STENCIL                                             0x00000002
+#define D3D_SHADER_REQUIRES_UAVS_AT_EVERY_STAGE                                             0x00000004
+#define D3D_SHADER_REQUIRES_64_UAVS                                                         0x00000008
+#define D3D_SHADER_REQUIRES_MINIMUM_PRECISION                                               0x00000010
+#define D3D_SHADER_REQUIRES_11_1_DOUBLE_EXTENSIONS                                          0x00000020
+#define D3D_SHADER_REQUIRES_11_1_SHADER_EXTENSIONS                                          0x00000040
+#define D3D_SHADER_REQUIRES_LEVEL_9_COMPARISON_FILTERING                                    0x00000080
+#define D3D_SHADER_REQUIRES_TILED_RESOURCES                                                 0x00000100
+#define D3D_SHADER_REQUIRES_STENCIL_REF                                                     0x00000200
+#define D3D_SHADER_REQUIRES_INNER_COVERAGE                                                  0x00000400
+#define D3D_SHADER_REQUIRES_TYPED_UAV_LOAD_ADDITIONAL_FORMATS                               0x00000800
+#define D3D_SHADER_REQUIRES_ROVS                                                            0x00001000
+#define D3D_SHADER_REQUIRES_VIEWPORT_AND_RT_ARRAY_INDEX_FROM_ANY_SHADER_FEEDING_RASTERIZER  0x00002000
+
+
+typedef struct _D3D12_LIBRARY_DESC
+{
+    LPCSTR    Creator;           // The name of the originator of the library.
+    UINT      Flags;             // Compilation flags.
+    UINT      FunctionCount;     // Number of functions exported from the library.
+} D3D12_LIBRARY_DESC;
+
+typedef struct _D3D12_FUNCTION_DESC
+{
+    UINT                    Version;                     // Shader version
+    LPCSTR                  Creator;                     // Creator string
+    UINT                    Flags;                       // Shader compilation/parse flags
+    
+    UINT                    ConstantBuffers;             // Number of constant buffers
+    UINT                    BoundResources;              // Number of bound resources
+
+    UINT                    InstructionCount;            // Number of emitted instructions
+    UINT                    TempRegisterCount;           // Number of temporary registers used 
+    UINT                    TempArrayCount;              // Number of temporary arrays used
+    UINT                    DefCount;                    // Number of constant defines 
+    UINT                    DclCount;                    // Number of declarations (input + output)
+    UINT                    TextureNormalInstructions;   // Number of non-categorized texture instructions
+    UINT                    TextureLoadInstructions;     // Number of texture load instructions
+    UINT                    TextureCompInstructions;     // Number of texture comparison instructions
+    UINT                    TextureBiasInstructions;     // Number of texture bias instructions
+    UINT                    TextureGradientInstructions; // Number of texture gradient instructions
+    UINT                    FloatInstructionCount;       // Number of floating point arithmetic instructions used
+    UINT                    IntInstructionCount;         // Number of signed integer arithmetic instructions used
+    UINT                    UintInstructionCount;        // Number of unsigned integer arithmetic instructions used
+    UINT                    StaticFlowControlCount;      // Number of static flow control instructions used
+    UINT                    DynamicFlowControlCount;     // Number of dynamic flow control instructions used
+    UINT                    MacroInstructionCount;       // Number of macro instructions used
+    UINT                    ArrayInstructionCount;       // Number of array instructions used
+    UINT                    MovInstructionCount;         // Number of mov instructions used
+    UINT                    MovcInstructionCount;        // Number of movc instructions used
+    UINT                    ConversionInstructionCount;  // Number of type conversion instructions used
+    UINT                    BitwiseInstructionCount;     // Number of bitwise arithmetic instructions used
+    D3D_FEATURE_LEVEL       MinFeatureLevel;             // Min target of the function byte code
+    UINT64                  RequiredFeatureFlags;        // Required feature flags
+
+    LPCSTR                  Name;                        // Function name
+    INT                     FunctionParameterCount;      // Number of logical parameters in the function signature (not including return)
+    BOOL                    HasReturn;                   // TRUE, if function returns a value, false - it is a subroutine
+    BOOL                    Has10Level9VertexShader;     // TRUE, if there is a 10L9 VS blob
+    BOOL                    Has10Level9PixelShader;      // TRUE, if there is a 10L9 PS blob
+} D3D12_FUNCTION_DESC;
+
+typedef struct _D3D12_PARAMETER_DESC
+{
+    LPCSTR                      Name;               // Parameter name.
+    LPCSTR                      SemanticName;       // Parameter semantic name (+index).
+    D3D_SHADER_VARIABLE_TYPE    Type;               // Element type.
+    D3D_SHADER_VARIABLE_CLASS   Class;              // Scalar/Vector/Matrix.
+    UINT                        Rows;               // Rows are for matrix parameters.
+    UINT                        Columns;            // Components or Columns in matrix.
+    D3D_INTERPOLATION_MODE      InterpolationMode;  // Interpolation mode.
+    D3D_PARAMETER_FLAGS         Flags;              // Parameter modifiers.
+
+    UINT                        FirstInRegister;    // The first input register for this parameter.
+    UINT                        FirstInComponent;   // The first input register component for this parameter.
+    UINT                        FirstOutRegister;   // The first output register for this parameter.
+    UINT                        FirstOutComponent;  // The first output register component for this parameter.
+} D3D12_PARAMETER_DESC;
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Interfaces ////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3D12ShaderReflectionType ID3D12ShaderReflectionType;
+typedef interface ID3D12ShaderReflectionType *LPD3D12SHADERREFLECTIONTYPE;
+
+typedef interface ID3D12ShaderReflectionVariable ID3D12ShaderReflectionVariable;
+typedef interface ID3D12ShaderReflectionVariable *LPD3D12SHADERREFLECTIONVARIABLE;
+
+typedef interface ID3D12ShaderReflectionConstantBuffer ID3D12ShaderReflectionConstantBuffer;
+typedef interface ID3D12ShaderReflectionConstantBuffer *LPD3D12SHADERREFLECTIONCONSTANTBUFFER;
+
+typedef interface ID3D12ShaderReflection ID3D12ShaderReflection;
+typedef interface ID3D12ShaderReflection *LPD3D12SHADERREFLECTION;
+
+typedef interface ID3D12LibraryReflection ID3D12LibraryReflection;
+typedef interface ID3D12LibraryReflection *LPD3D12LIBRARYREFLECTION;
+
+typedef interface ID3D12FunctionReflection ID3D12FunctionReflection;
+typedef interface ID3D12FunctionReflection *LPD3D12FUNCTIONREFLECTION;
+
+typedef interface ID3D12FunctionParameterReflection ID3D12FunctionParameterReflection;
+typedef interface ID3D12FunctionParameterReflection *LPD3D12FUNCTIONPARAMETERREFLECTION;
+
+
+// {E913C351-783D-48CA-A1D1-4F306284AD56}
+interface DECLSPEC_UUID("E913C351-783D-48CA-A1D1-4F306284AD56") ID3D12ShaderReflectionType;
+DEFINE_GUID(IID_ID3D12ShaderReflectionType, 
+0xe913c351, 0x783d, 0x48ca, 0xa1, 0xd1, 0x4f, 0x30, 0x62, 0x84, 0xad, 0x56);
+
+#undef INTERFACE
+#define INTERFACE ID3D12ShaderReflectionType
+
+DECLARE_INTERFACE(ID3D12ShaderReflectionType)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_SHADER_TYPE_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetMemberTypeByIndex)(THIS_ _In_ UINT Index) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetMemberTypeByName)(THIS_ _In_ LPCSTR Name) PURE;
+    STDMETHOD_(LPCSTR, GetMemberTypeName)(THIS_ _In_ UINT Index) PURE;
+
+    STDMETHOD(IsEqual)(THIS_ _In_ ID3D12ShaderReflectionType* pType) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetSubType)(THIS) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetBaseClass)(THIS) PURE;
+    STDMETHOD_(UINT, GetNumInterfaces)(THIS) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetInterfaceByIndex)(THIS_ _In_ UINT uIndex) PURE;
+    STDMETHOD(IsOfType)(THIS_ _In_ ID3D12ShaderReflectionType* pType) PURE;
+    STDMETHOD(ImplementsInterface)(THIS_ _In_ ID3D12ShaderReflectionType* pBase) PURE;
+};
+
+// {8337A8A6-A216-444A-B2F4-314733A73AEA}
+interface DECLSPEC_UUID("8337A8A6-A216-444A-B2F4-314733A73AEA") ID3D12ShaderReflectionVariable;
+DEFINE_GUID(IID_ID3D12ShaderReflectionVariable, 
+0x8337a8a6, 0xa216, 0x444a, 0xb2, 0xf4, 0x31, 0x47, 0x33, 0xa7, 0x3a, 0xea);
+
+#undef INTERFACE
+#define INTERFACE ID3D12ShaderReflectionVariable
+
+DECLARE_INTERFACE(ID3D12ShaderReflectionVariable)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_SHADER_VARIABLE_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetType)(THIS) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer*, GetBuffer)(THIS) PURE;
+
+    STDMETHOD_(UINT, GetInterfaceSlot)(THIS_ _In_ UINT uArrayIndex) PURE;
+};
+
+// {C59598B4-48B3-4869-B9B1-B1618B14A8B7}
+interface DECLSPEC_UUID("C59598B4-48B3-4869-B9B1-B1618B14A8B7") ID3D12ShaderReflectionConstantBuffer;
+DEFINE_GUID(IID_ID3D12ShaderReflectionConstantBuffer, 
+0xc59598b4, 0x48b3, 0x4869, 0xb9, 0xb1, 0xb1, 0x61, 0x8b, 0x14, 0xa8, 0xb7);
+
+#undef INTERFACE
+#define INTERFACE ID3D12ShaderReflectionConstantBuffer
+
+DECLARE_INTERFACE(ID3D12ShaderReflectionConstantBuffer)
+{
+    STDMETHOD(GetDesc)(THIS_ D3D12_SHADER_BUFFER_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionVariable*, GetVariableByIndex)(THIS_ _In_ UINT Index) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionVariable*, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;
+};
+
+// The ID3D12ShaderReflection IID may change from SDK version to SDK version
+// if the reflection API changes.  This prevents new code with the new API
+// from working with an old binary.  Recompiling with the new header
+// will pick up the new IID.
+
+// {5A58797D-A72C-478D-8BA2-EFC6B0EFE88E}
+interface DECLSPEC_UUID("5A58797D-A72C-478D-8BA2-EFC6B0EFE88E") ID3D12ShaderReflection;
+DEFINE_GUID(IID_ID3D12ShaderReflection, 
+0x5a58797d, 0xa72c, 0x478d, 0x8b, 0xa2, 0xef, 0xc6, 0xb0, 0xef, 0xe8, 0x8e);
+
+#undef INTERFACE
+#define INTERFACE ID3D12ShaderReflection
+
+DECLARE_INTERFACE_(ID3D12ShaderReflection, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ _In_ REFIID iid,
+                              _Out_ LPVOID *ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_SHADER_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer*, GetConstantBufferByIndex)(THIS_ _In_ UINT Index) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer*, GetConstantBufferByName)(THIS_ _In_ LPCSTR Name) PURE;
+    
+    STDMETHOD(GetResourceBindingDesc)(THIS_ _In_ UINT ResourceIndex,
+                                      _Out_ D3D12_SHADER_INPUT_BIND_DESC *pDesc) PURE;
+    
+    STDMETHOD(GetInputParameterDesc)(THIS_ _In_ UINT ParameterIndex,
+                                     _Out_ D3D12_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+    STDMETHOD(GetOutputParameterDesc)(THIS_ _In_ UINT ParameterIndex,
+                                      _Out_ D3D12_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+    STDMETHOD(GetPatchConstantParameterDesc)(THIS_ _In_ UINT ParameterIndex,
+                                             _Out_ D3D12_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+
+    STDMETHOD_(ID3D12ShaderReflectionVariable*, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;
+
+    STDMETHOD(GetResourceBindingDescByName)(THIS_ _In_ LPCSTR Name,
+                                            _Out_ D3D12_SHADER_INPUT_BIND_DESC *pDesc) PURE;
+
+    STDMETHOD_(UINT, GetMovInstructionCount)(THIS) PURE;
+    STDMETHOD_(UINT, GetMovcInstructionCount)(THIS) PURE;
+    STDMETHOD_(UINT, GetConversionInstructionCount)(THIS) PURE;
+    STDMETHOD_(UINT, GetBitwiseInstructionCount)(THIS) PURE;
+    
+    STDMETHOD_(D3D_PRIMITIVE, GetGSInputPrimitive)(THIS) PURE;
+    STDMETHOD_(BOOL, IsSampleFrequencyShader)(THIS) PURE;
+
+    STDMETHOD_(UINT, GetNumInterfaceSlots)(THIS) PURE;
+    STDMETHOD(GetMinFeatureLevel)(THIS_ _Out_ enum D3D_FEATURE_LEVEL* pLevel) PURE;
+
+    STDMETHOD_(UINT, GetThreadGroupSize)(THIS_
+                                         _Out_opt_ UINT* pSizeX,
+                                         _Out_opt_ UINT* pSizeY,
+                                         _Out_opt_ UINT* pSizeZ) PURE;
+
+    STDMETHOD_(UINT64, GetRequiresFlags)(THIS) PURE;
+};
+
+// {8E349D19-54DB-4A56-9DC9-119D87BDB804}
+interface DECLSPEC_UUID("8E349D19-54DB-4A56-9DC9-119D87BDB804") ID3D12LibraryReflection;
+DEFINE_GUID(IID_ID3D12LibraryReflection, 
+0x8e349d19, 0x54db, 0x4a56, 0x9d, 0xc9, 0x11, 0x9d, 0x87, 0xbd, 0xb8, 0x4);
+
+#undef INTERFACE
+#define INTERFACE ID3D12LibraryReflection
+
+DECLARE_INTERFACE_(ID3D12LibraryReflection, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ _In_ REFIID iid, _Out_ LPVOID * ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_LIBRARY_DESC * pDesc) PURE;
+    
+    STDMETHOD_(ID3D12FunctionReflection *, GetFunctionByIndex)(THIS_ _In_ INT FunctionIndex) PURE;
+};
+
+// {1108795C-2772-4BA9-B2A8-D464DC7E2799}
+interface DECLSPEC_UUID("1108795C-2772-4BA9-B2A8-D464DC7E2799") ID3D12FunctionReflection;
+DEFINE_GUID(IID_ID3D12FunctionReflection, 
+0x1108795c, 0x2772, 0x4ba9, 0xb2, 0xa8, 0xd4, 0x64, 0xdc, 0x7e, 0x27, 0x99);
+
+#undef INTERFACE
+#define INTERFACE ID3D12FunctionReflection
+
+DECLARE_INTERFACE(ID3D12FunctionReflection)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_FUNCTION_DESC * pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer *, GetConstantBufferByIndex)(THIS_ _In_ UINT BufferIndex) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer *, GetConstantBufferByName)(THIS_ _In_ LPCSTR Name) PURE;
+    
+    STDMETHOD(GetResourceBindingDesc)(THIS_ _In_ UINT ResourceIndex,
+                                      _Out_ D3D12_SHADER_INPUT_BIND_DESC * pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionVariable *, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;
+
+    STDMETHOD(GetResourceBindingDescByName)(THIS_ _In_ LPCSTR Name,
+                                            _Out_ D3D12_SHADER_INPUT_BIND_DESC * pDesc) PURE;
+
+    // Use D3D_RETURN_PARAMETER_INDEX to get description of the return value.
+    STDMETHOD_(ID3D12FunctionParameterReflection *, GetFunctionParameter)(THIS_ _In_ INT ParameterIndex) PURE;
+};
+
+// {EC25F42D-7006-4F2B-B33E-02CC3375733F}
+interface DECLSPEC_UUID("EC25F42D-7006-4F2B-B33E-02CC3375733F") ID3D12FunctionParameterReflection;
+DEFINE_GUID(IID_ID3D12FunctionParameterReflection, 
+0xec25f42d, 0x7006, 0x4f2b, 0xb3, 0x3e, 0x2, 0xcc, 0x33, 0x75, 0x73, 0x3f);
+
+#undef INTERFACE
+#define INTERFACE ID3D12FunctionParameterReflection
+
+DECLARE_INTERFACE(ID3D12FunctionParameterReflection)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_PARAMETER_DESC * pDesc) PURE;
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+// APIs //////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+    
+#endif //__D3D12SHADER_H__
+

3rdparty/bgfx/3rdparty/dxsdk/include/d3d9caps.h

@@ -0,0 +1,571 @@
+/*==========================================================================;
+ *
+ *  Copyright (C) Microsoft Corporation.  All Rights Reserved.
+ *
+ *  File:       d3d9caps.h
+ *  Content:    Direct3D capabilities include file
+ *
+ ***************************************************************************/
+
+#ifndef _d3d9CAPS_H
+#define _d3d9CAPS_H
+
+#ifndef DIRECT3D_VERSION
+#define DIRECT3D_VERSION         0x0900
+#endif  //DIRECT3D_VERSION
+
+// include this file content only if compiling for DX9 interfaces
+#if(DIRECT3D_VERSION >= 0x0900)
+
+
+
+#if defined(_X86_) || defined(_IA64_)
+#pragma pack(4)
+#endif
+
+typedef struct _D3DVSHADERCAPS2_0
+{
+        DWORD Caps;
+        INT DynamicFlowControlDepth;
+        INT NumTemps;
+        INT StaticFlowControlDepth;
+} D3DVSHADERCAPS2_0;
+
+#define D3DVS20CAPS_PREDICATION             (1<<0)
+
+#define D3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH  24
+#define D3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH  0
+#define D3DVS20_MAX_NUMTEMPS    32
+#define D3DVS20_MIN_NUMTEMPS    12
+#define D3DVS20_MAX_STATICFLOWCONTROLDEPTH    4
+#define D3DVS20_MIN_STATICFLOWCONTROLDEPTH    1
+
+typedef struct _D3DPSHADERCAPS2_0
+{
+    DWORD Caps;
+    INT DynamicFlowControlDepth;
+    INT NumTemps;
+    INT StaticFlowControlDepth;
+    INT NumInstructionSlots;
+} D3DPSHADERCAPS2_0;
+
+#define D3DPS20CAPS_ARBITRARYSWIZZLE        (1<<0)
+#define D3DPS20CAPS_GRADIENTINSTRUCTIONS    (1<<1)
+#define D3DPS20CAPS_PREDICATION             (1<<2)
+#define D3DPS20CAPS_NODEPENDENTREADLIMIT    (1<<3)
+#define D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT   (1<<4)
+
+#define D3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH    24
+#define D3DPS20_MIN_DYNAMICFLOWCONTROLDEPTH    0
+#define D3DPS20_MAX_NUMTEMPS    32
+#define D3DPS20_MIN_NUMTEMPS    12
+#define D3DPS20_MAX_STATICFLOWCONTROLDEPTH    4
+#define D3DPS20_MIN_STATICFLOWCONTROLDEPTH    0
+#define D3DPS20_MAX_NUMINSTRUCTIONSLOTS    512
+#define D3DPS20_MIN_NUMINSTRUCTIONSLOTS    96
+
+#define D3DMIN30SHADERINSTRUCTIONS 512
+#define D3DMAX30SHADERINSTRUCTIONS 32768
+
+/* D3D9Ex only -- */
+#if !defined(D3D_DISABLE_9EX)
+
+typedef struct _D3DOVERLAYCAPS
+{
+    UINT   Caps;
+    UINT   MaxOverlayDisplayWidth;
+    UINT   MaxOverlayDisplayHeight;
+} D3DOVERLAYCAPS;
+
+#define D3DOVERLAYCAPS_FULLRANGERGB          0x00000001
+#define D3DOVERLAYCAPS_LIMITEDRANGERGB       0x00000002
+#define D3DOVERLAYCAPS_YCbCr_BT601           0x00000004
+#define D3DOVERLAYCAPS_YCbCr_BT709           0x00000008
+#define D3DOVERLAYCAPS_YCbCr_BT601_xvYCC     0x00000010
+#define D3DOVERLAYCAPS_YCbCr_BT709_xvYCC     0x00000020
+#define D3DOVERLAYCAPS_STRETCHX              0x00000040
+#define D3DOVERLAYCAPS_STRETCHY              0x00000080
+
+
+typedef struct _D3DCONTENTPROTECTIONCAPS
+{
+    DWORD     Caps;
+    GUID      KeyExchangeType;
+    UINT      BufferAlignmentStart;
+    UINT      BlockAlignmentSize;
+    ULONGLONG ProtectedMemorySize;
+} D3DCONTENTPROTECTIONCAPS;
+
+#define D3DCPCAPS_SOFTWARE              0x00000001
+#define D3DCPCAPS_HARDWARE              0x00000002
+#define D3DCPCAPS_PROTECTIONALWAYSON    0x00000004
+#define D3DCPCAPS_PARTIALDECRYPTION     0x00000008
+#define D3DCPCAPS_CONTENTKEY            0x00000010
+#define D3DCPCAPS_FRESHENSESSIONKEY     0x00000020
+#define D3DCPCAPS_ENCRYPTEDREADBACK     0x00000040
+#define D3DCPCAPS_ENCRYPTEDREADBACKKEY  0x00000080
+#define D3DCPCAPS_SEQUENTIAL_CTR_IV     0x00000100
+#define D3DCPCAPS_ENCRYPTSLICEDATAONLY  0x00000200
+
+DEFINE_GUID(D3DCRYPTOTYPE_AES128_CTR, 
+0x9b6bd711, 0x4f74, 0x41c9, 0x9e, 0x7b, 0xb, 0xe2, 0xd7, 0xd9, 0x3b, 0x4f);
+DEFINE_GUID(D3DCRYPTOTYPE_PROPRIETARY, 
+0xab4e9afd, 0x1d1c, 0x46e6, 0xa7, 0x2f, 0x8, 0x69, 0x91, 0x7b, 0xd, 0xe8);
+
+DEFINE_GUID(D3DKEYEXCHANGE_RSAES_OAEP, 
+0xc1949895, 0xd72a, 0x4a1d, 0x8e, 0x5d, 0xed, 0x85, 0x7d, 0x17, 0x15, 0x20);
+DEFINE_GUID(D3DKEYEXCHANGE_DXVA, 
+0x43d3775c, 0x38e5, 0x4924, 0x8d, 0x86, 0xd3, 0xfc, 0xcf, 0x15, 0x3e, 0x9b);
+
+#endif // !D3D_DISABLE_9EX
+/* -- D3D9Ex only */
+
+typedef struct _D3DCAPS9
+{
+    /* Device Info */
+    D3DDEVTYPE  DeviceType;
+    UINT        AdapterOrdinal;
+
+    /* Caps from DX7 Draw */
+    DWORD   Caps;
+    DWORD   Caps2;
+    DWORD   Caps3;
+    DWORD   PresentationIntervals;
+
+    /* Cursor Caps */
+    DWORD   CursorCaps;
+
+    /* 3D Device Caps */
+    DWORD   DevCaps;
+
+    DWORD   PrimitiveMiscCaps;
+    DWORD   RasterCaps;
+    DWORD   ZCmpCaps;
+    DWORD   SrcBlendCaps;
+    DWORD   DestBlendCaps;
+    DWORD   AlphaCmpCaps;
+    DWORD   ShadeCaps;
+    DWORD   TextureCaps;
+    DWORD   TextureFilterCaps;          // D3DPTFILTERCAPS for IDirect3DTexture9's
+    DWORD   CubeTextureFilterCaps;      // D3DPTFILTERCAPS for IDirect3DCubeTexture9's
+    DWORD   VolumeTextureFilterCaps;    // D3DPTFILTERCAPS for IDirect3DVolumeTexture9's
+    DWORD   TextureAddressCaps;         // D3DPTADDRESSCAPS for IDirect3DTexture9's
+    DWORD   VolumeTextureAddressCaps;   // D3DPTADDRESSCAPS for IDirect3DVolumeTexture9's
+
+    DWORD   LineCaps;                   // D3DLINECAPS
+
+    DWORD   MaxTextureWidth, MaxTextureHeight;
+    DWORD   MaxVolumeExtent;
+
+    DWORD   MaxTextureRepeat;
+    DWORD   MaxTextureAspectRatio;
+    DWORD   MaxAnisotropy;
+    float   MaxVertexW;
+
+    float   GuardBandLeft;
+    float   GuardBandTop;
+    float   GuardBandRight;
+    float   GuardBandBottom;
+
+    float   ExtentsAdjust;
+    DWORD   StencilCaps;
+
+    DWORD   FVFCaps;
+    DWORD   TextureOpCaps;
+    DWORD   MaxTextureBlendStages;
+    DWORD   MaxSimultaneousTextures;
+
+    DWORD   VertexProcessingCaps;
+    DWORD   MaxActiveLights;
+    DWORD   MaxUserClipPlanes;
+    DWORD   MaxVertexBlendMatrices;
+    DWORD   MaxVertexBlendMatrixIndex;
+
+    float   MaxPointSize;
+
+    DWORD   MaxPrimitiveCount;          // max number of primitives per DrawPrimitive call
+    DWORD   MaxVertexIndex;
+    DWORD   MaxStreams;
+    DWORD   MaxStreamStride;            // max stride for SetStreamSource
+
+    DWORD   VertexShaderVersion;
+    DWORD   MaxVertexShaderConst;       // number of vertex shader constant registers
+
+    DWORD   PixelShaderVersion;
+    float   PixelShader1xMaxValue;      // max value storable in registers of ps.1.x shaders
+
+    // Here are the DX9 specific ones
+    DWORD   DevCaps2;
+
+    float   MaxNpatchTessellationLevel;
+    DWORD   Reserved5;
+
+    UINT    MasterAdapterOrdinal;       // ordinal of master adaptor for adapter group
+    UINT    AdapterOrdinalInGroup;      // ordinal inside the adapter group
+    UINT    NumberOfAdaptersInGroup;    // number of adapters in this adapter group (only if master)
+    DWORD   DeclTypes;                  // Data types, supported in vertex declarations
+    DWORD   NumSimultaneousRTs;         // Will be at least 1
+    DWORD   StretchRectFilterCaps;      // Filter caps supported by StretchRect
+    D3DVSHADERCAPS2_0 VS20Caps;
+    D3DPSHADERCAPS2_0 PS20Caps;
+    DWORD   VertexTextureFilterCaps;    // D3DPTFILTERCAPS for IDirect3DTexture9's for texture, used in vertex shaders
+    DWORD   MaxVShaderInstructionsExecuted; // maximum number of vertex shader instructions that can be executed
+    DWORD   MaxPShaderInstructionsExecuted; // maximum number of pixel shader instructions that can be executed
+    DWORD   MaxVertexShader30InstructionSlots; 
+    DWORD   MaxPixelShader30InstructionSlots;
+} D3DCAPS9;
+
+//
+// BIT DEFINES FOR D3DCAPS9 DWORD MEMBERS
+//
+
+//
+// Caps
+//
+#define D3DCAPS_OVERLAY                 0x00000800L
+#define D3DCAPS_READ_SCANLINE           0x00020000L
+
+//
+// Caps2
+//
+#define D3DCAPS2_FULLSCREENGAMMA        0x00020000L
+#define D3DCAPS2_CANCALIBRATEGAMMA      0x00100000L
+#define D3DCAPS2_RESERVED               0x02000000L
+#define D3DCAPS2_CANMANAGERESOURCE      0x10000000L
+#define D3DCAPS2_DYNAMICTEXTURES        0x20000000L
+#define D3DCAPS2_CANAUTOGENMIPMAP       0x40000000L
+
+/* D3D9Ex only -- */
+#if !defined(D3D_DISABLE_9EX)
+
+#define D3DCAPS2_CANSHARERESOURCE       0x80000000L
+
+#endif // !D3D_DISABLE_9EX
+/* -- D3D9Ex only */
+
+//
+// Caps3
+//
+#define D3DCAPS3_RESERVED               0x8000001fL
+
+// Indicates that the device can respect the ALPHABLENDENABLE render state
+// when fullscreen while using the FLIP or DISCARD swap effect.
+// COPY and COPYVSYNC swap effects work whether or not this flag is set.
+#define D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD   0x00000020L
+
+// Indicates that the device can perform a gamma correction from 
+// a windowed back buffer containing linear content to the sRGB desktop.
+#define D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION 0x00000080L
+
+#define D3DCAPS3_COPY_TO_VIDMEM         0x00000100L /* Device can acclerate copies from sysmem to local vidmem */
+#define D3DCAPS3_COPY_TO_SYSTEMMEM      0x00000200L /* Device can acclerate copies from local vidmem to sysmem */
+#define D3DCAPS3_DXVAHD                 0x00000400L
+#define D3DCAPS3_DXVAHD_LIMITED         0x00000800L
+
+
+//
+// PresentationIntervals
+//
+#define D3DPRESENT_INTERVAL_DEFAULT     0x00000000L
+#define D3DPRESENT_INTERVAL_ONE         0x00000001L
+#define D3DPRESENT_INTERVAL_TWO         0x00000002L
+#define D3DPRESENT_INTERVAL_THREE       0x00000004L
+#define D3DPRESENT_INTERVAL_FOUR        0x00000008L
+#define D3DPRESENT_INTERVAL_IMMEDIATE   0x80000000L
+
+//
+// CursorCaps
+//
+// Driver supports HW color cursor in at least hi-res modes(height >=400)
+#define D3DCURSORCAPS_COLOR             0x00000001L
+// Driver supports HW cursor also in low-res modes(height < 400)
+#define D3DCURSORCAPS_LOWRES            0x00000002L
+
+//
+// DevCaps
+//
+#define D3DDEVCAPS_EXECUTESYSTEMMEMORY  0x00000010L /* Device can use execute buffers from system memory */
+#define D3DDEVCAPS_EXECUTEVIDEOMEMORY   0x00000020L /* Device can use execute buffers from video memory */
+#define D3DDEVCAPS_TLVERTEXSYSTEMMEMORY 0x00000040L /* Device can use TL buffers from system memory */
+#define D3DDEVCAPS_TLVERTEXVIDEOMEMORY  0x00000080L /* Device can use TL buffers from video memory */
+#define D3DDEVCAPS_TEXTURESYSTEMMEMORY  0x00000100L /* Device can texture from system memory */
+#define D3DDEVCAPS_TEXTUREVIDEOMEMORY   0x00000200L /* Device can texture from device memory */
+#define D3DDEVCAPS_DRAWPRIMTLVERTEX     0x00000400L /* Device can draw TLVERTEX primitives */
+#define D3DDEVCAPS_CANRENDERAFTERFLIP   0x00000800L /* Device can render without waiting for flip to complete */
+#define D3DDEVCAPS_TEXTURENONLOCALVIDMEM 0x00001000L /* Device can texture from nonlocal video memory */
+#define D3DDEVCAPS_DRAWPRIMITIVES2      0x00002000L /* Device can support DrawPrimitives2 */
+#define D3DDEVCAPS_SEPARATETEXTUREMEMORIES 0x00004000L /* Device is texturing from separate memory pools */
+#define D3DDEVCAPS_DRAWPRIMITIVES2EX    0x00008000L /* Device can support Extended DrawPrimitives2 i.e. DX7 compliant driver*/
+#define D3DDEVCAPS_HWTRANSFORMANDLIGHT  0x00010000L /* Device can support transformation and lighting in hardware and DRAWPRIMITIVES2EX must be also */
+#define D3DDEVCAPS_CANBLTSYSTONONLOCAL  0x00020000L /* Device supports a Tex Blt from system memory to non-local vidmem */
+#define D3DDEVCAPS_HWRASTERIZATION      0x00080000L /* Device has HW acceleration for rasterization */
+#define D3DDEVCAPS_PUREDEVICE           0x00100000L /* Device supports D3DCREATE_PUREDEVICE */
+#define D3DDEVCAPS_QUINTICRTPATCHES     0x00200000L /* Device supports quintic Beziers and BSplines */
+#define D3DDEVCAPS_RTPATCHES            0x00400000L /* Device supports Rect and Tri patches */
+#define D3DDEVCAPS_RTPATCHHANDLEZERO    0x00800000L /* Indicates that RT Patches may be drawn efficiently using handle 0 */
+#define D3DDEVCAPS_NPATCHES             0x01000000L /* Device supports N-Patches */
+
+//
+// PrimitiveMiscCaps
+//
+#define D3DPMISCCAPS_MASKZ              0x00000002L
+#define D3DPMISCCAPS_CULLNONE           0x00000010L
+#define D3DPMISCCAPS_CULLCW             0x00000020L
+#define D3DPMISCCAPS_CULLCCW            0x00000040L
+#define D3DPMISCCAPS_COLORWRITEENABLE   0x00000080L
+#define D3DPMISCCAPS_CLIPPLANESCALEDPOINTS 0x00000100L /* Device correctly clips scaled points to clip planes */
+#define D3DPMISCCAPS_CLIPTLVERTS        0x00000200L /* device will clip post-transformed vertex primitives */
+#define D3DPMISCCAPS_TSSARGTEMP         0x00000400L /* device supports D3DTA_TEMP for temporary register */
+#define D3DPMISCCAPS_BLENDOP            0x00000800L /* device supports D3DRS_BLENDOP */
+#define D3DPMISCCAPS_NULLREFERENCE      0x00001000L /* Reference Device that doesnt render */
+#define D3DPMISCCAPS_INDEPENDENTWRITEMASKS     0x00004000L /* Device supports independent write masks for MET or MRT */
+#define D3DPMISCCAPS_PERSTAGECONSTANT   0x00008000L /* Device supports per-stage constants */
+#define D3DPMISCCAPS_FOGANDSPECULARALPHA   0x00010000L /* Device supports separate fog and specular alpha (many devices
+                                                          use the specular alpha channel to store fog factor) */
+#define D3DPMISCCAPS_SEPARATEALPHABLEND         0x00020000L /* Device supports separate blend settings for the alpha channel */
+#define D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS    0x00040000L /* Device supports different bit depths for MRT */
+#define D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING 0x00080000L /* Device supports post-pixel shader operations for MRT */
+#define D3DPMISCCAPS_FOGVERTEXCLAMPED           0x00100000L /* Device clamps fog blend factor per vertex */
+
+/* D3D9Ex only -- */
+#if !defined(D3D_DISABLE_9EX)
+
+#define D3DPMISCCAPS_POSTBLENDSRGBCONVERT       0x00200000L /* Indicates device can perform conversion to sRGB after blending. */
+
+#endif // !D3D_DISABLE_9EX
+/* -- D3D9Ex only */
+
+
+//
+// LineCaps
+//
+#define D3DLINECAPS_TEXTURE             0x00000001L
+#define D3DLINECAPS_ZTEST               0x00000002L
+#define D3DLINECAPS_BLEND               0x00000004L
+#define D3DLINECAPS_ALPHACMP            0x00000008L
+#define D3DLINECAPS_FOG                 0x00000010L
+#define D3DLINECAPS_ANTIALIAS           0x00000020L
+
+//
+// RasterCaps
+//
+#define D3DPRASTERCAPS_DITHER                 0x00000001L
+#define D3DPRASTERCAPS_ZTEST                  0x00000010L
+#define D3DPRASTERCAPS_FOGVERTEX              0x00000080L
+#define D3DPRASTERCAPS_FOGTABLE               0x00000100L
+#define D3DPRASTERCAPS_MIPMAPLODBIAS          0x00002000L
+#define D3DPRASTERCAPS_ZBUFFERLESSHSR         0x00008000L
+#define D3DPRASTERCAPS_FOGRANGE               0x00010000L
+#define D3DPRASTERCAPS_ANISOTROPY             0x00020000L
+#define D3DPRASTERCAPS_WBUFFER                0x00040000L
+#define D3DPRASTERCAPS_WFOG                   0x00100000L
+#define D3DPRASTERCAPS_ZFOG                   0x00200000L
+#define D3DPRASTERCAPS_COLORPERSPECTIVE       0x00400000L /* Device iterates colors perspective correct */
+#define D3DPRASTERCAPS_SCISSORTEST            0x01000000L
+#define D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS    0x02000000L
+#define D3DPRASTERCAPS_DEPTHBIAS              0x04000000L 
+#define D3DPRASTERCAPS_MULTISAMPLE_TOGGLE     0x08000000L
+
+//
+// ZCmpCaps, AlphaCmpCaps
+//
+#define D3DPCMPCAPS_NEVER               0x00000001L
+#define D3DPCMPCAPS_LESS                0x00000002L
+#define D3DPCMPCAPS_EQUAL               0x00000004L
+#define D3DPCMPCAPS_LESSEQUAL           0x00000008L
+#define D3DPCMPCAPS_GREATER             0x00000010L
+#define D3DPCMPCAPS_NOTEQUAL            0x00000020L
+#define D3DPCMPCAPS_GREATEREQUAL        0x00000040L
+#define D3DPCMPCAPS_ALWAYS              0x00000080L
+
+//
+// SourceBlendCaps, DestBlendCaps
+//
+#define D3DPBLENDCAPS_ZERO              0x00000001L
+#define D3DPBLENDCAPS_ONE               0x00000002L
+#define D3DPBLENDCAPS_SRCCOLOR          0x00000004L
+#define D3DPBLENDCAPS_INVSRCCOLOR       0x00000008L
+#define D3DPBLENDCAPS_SRCALPHA          0x00000010L
+#define D3DPBLENDCAPS_INVSRCALPHA       0x00000020L
+#define D3DPBLENDCAPS_DESTALPHA         0x00000040L
+#define D3DPBLENDCAPS_INVDESTALPHA      0x00000080L
+#define D3DPBLENDCAPS_DESTCOLOR         0x00000100L
+#define D3DPBLENDCAPS_INVDESTCOLOR      0x00000200L
+#define D3DPBLENDCAPS_SRCALPHASAT       0x00000400L
+#define D3DPBLENDCAPS_BOTHSRCALPHA      0x00000800L
+#define D3DPBLENDCAPS_BOTHINVSRCALPHA   0x00001000L
+#define D3DPBLENDCAPS_BLENDFACTOR       0x00002000L /* Supports both D3DBLEND_BLENDFACTOR and D3DBLEND_INVBLENDFACTOR */
+
+/* D3D9Ex only -- */
+#if !defined(D3D_DISABLE_9EX)
+
+#define D3DPBLENDCAPS_SRCCOLOR2         0x00004000L
+#define D3DPBLENDCAPS_INVSRCCOLOR2      0x00008000L
+
+#endif // !D3D_DISABLE_9EX
+/* -- D3D9Ex only */
+
+
+//
+// ShadeCaps
+//
+#define D3DPSHADECAPS_COLORGOURAUDRGB       0x00000008L
+#define D3DPSHADECAPS_SPECULARGOURAUDRGB    0x00000200L
+#define D3DPSHADECAPS_ALPHAGOURAUDBLEND     0x00004000L
+#define D3DPSHADECAPS_FOGGOURAUD            0x00080000L
+
+//
+// TextureCaps
+//
+#define D3DPTEXTURECAPS_PERSPECTIVE         0x00000001L /* Perspective-correct texturing is supported */
+#define D3DPTEXTURECAPS_POW2                0x00000002L /* Power-of-2 texture dimensions are required - applies to non-Cube/Volume textures only. */
+#define D3DPTEXTURECAPS_ALPHA               0x00000004L /* Alpha in texture pixels is supported */
+#define D3DPTEXTURECAPS_SQUAREONLY          0x00000020L /* Only square textures are supported */
+#define D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE 0x00000040L /* Texture indices are not scaled by the texture size prior to interpolation */
+#define D3DPTEXTURECAPS_ALPHAPALETTE        0x00000080L /* Device can draw alpha from texture palettes */
+// Device can use non-POW2 textures if:
+//  1) D3DTEXTURE_ADDRESS is set to CLAMP for this texture's stage
+//  2) D3DRS_WRAP(N) is zero for this texture's coordinates
+//  3) mip mapping is not enabled (use magnification filter only)
+#define D3DPTEXTURECAPS_NONPOW2CONDITIONAL  0x00000100L
+#define D3DPTEXTURECAPS_PROJECTED           0x00000400L /* Device can do D3DTTFF_PROJECTED */
+#define D3DPTEXTURECAPS_CUBEMAP             0x00000800L /* Device can do cubemap textures */
+#define D3DPTEXTURECAPS_VOLUMEMAP           0x00002000L /* Device can do volume textures */
+#define D3DPTEXTURECAPS_MIPMAP              0x00004000L /* Device can do mipmapped textures */
+#define D3DPTEXTURECAPS_MIPVOLUMEMAP        0x00008000L /* Device can do mipmapped volume textures */
+#define D3DPTEXTURECAPS_MIPCUBEMAP          0x00010000L /* Device can do mipmapped cube maps */
+#define D3DPTEXTURECAPS_CUBEMAP_POW2        0x00020000L /* Device requires that cubemaps be power-of-2 dimension */
+#define D3DPTEXTURECAPS_VOLUMEMAP_POW2      0x00040000L /* Device requires that volume maps be power-of-2 dimension */
+#define D3DPTEXTURECAPS_NOPROJECTEDBUMPENV  0x00200000L /* Device does not support projected bump env lookup operation 
+                                                           in programmable and fixed function pixel shaders */
+
+//
+// TextureFilterCaps, StretchRectFilterCaps
+//
+#define D3DPTFILTERCAPS_MINFPOINT           0x00000100L /* Min Filter */
+#define D3DPTFILTERCAPS_MINFLINEAR          0x00000200L
+#define D3DPTFILTERCAPS_MINFANISOTROPIC     0x00000400L
+#define D3DPTFILTERCAPS_MINFPYRAMIDALQUAD   0x00000800L
+#define D3DPTFILTERCAPS_MINFGAUSSIANQUAD    0x00001000L
+#define D3DPTFILTERCAPS_MIPFPOINT           0x00010000L /* Mip Filter */
+#define D3DPTFILTERCAPS_MIPFLINEAR          0x00020000L
+
+/* D3D9Ex only -- */
+#if !defined(D3D_DISABLE_9EX)
+
+#define D3DPTFILTERCAPS_CONVOLUTIONMONO     0x00040000L /* Min and Mag for the convolution mono filter */
+
+#endif // !D3D_DISABLE_9EX
+/* -- D3D9Ex only */
+
+#define D3DPTFILTERCAPS_MAGFPOINT           0x01000000L /* Mag Filter */
+#define D3DPTFILTERCAPS_MAGFLINEAR          0x02000000L
+#define D3DPTFILTERCAPS_MAGFANISOTROPIC     0x04000000L
+#define D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD   0x08000000L
+#define D3DPTFILTERCAPS_MAGFGAUSSIANQUAD    0x10000000L
+
+//
+// TextureAddressCaps
+//
+#define D3DPTADDRESSCAPS_WRAP           0x00000001L
+#define D3DPTADDRESSCAPS_MIRROR         0x00000002L
+#define D3DPTADDRESSCAPS_CLAMP          0x00000004L
+#define D3DPTADDRESSCAPS_BORDER         0x00000008L
+#define D3DPTADDRESSCAPS_INDEPENDENTUV  0x00000010L
+#define D3DPTADDRESSCAPS_MIRRORONCE     0x00000020L
+
+//
+// StencilCaps
+//
+#define D3DSTENCILCAPS_KEEP             0x00000001L
+#define D3DSTENCILCAPS_ZERO             0x00000002L
+#define D3DSTENCILCAPS_REPLACE          0x00000004L
+#define D3DSTENCILCAPS_INCRSAT          0x00000008L
+#define D3DSTENCILCAPS_DECRSAT          0x00000010L
+#define D3DSTENCILCAPS_INVERT           0x00000020L
+#define D3DSTENCILCAPS_INCR             0x00000040L
+#define D3DSTENCILCAPS_DECR             0x00000080L
+#define D3DSTENCILCAPS_TWOSIDED         0x00000100L
+
+//
+// TextureOpCaps
+//
+#define D3DTEXOPCAPS_DISABLE                    0x00000001L
+#define D3DTEXOPCAPS_SELECTARG1                 0x00000002L
+#define D3DTEXOPCAPS_SELECTARG2                 0x00000004L
+#define D3DTEXOPCAPS_MODULATE                   0x00000008L
+#define D3DTEXOPCAPS_MODULATE2X                 0x00000010L
+#define D3DTEXOPCAPS_MODULATE4X                 0x00000020L
+#define D3DTEXOPCAPS_ADD                        0x00000040L
+#define D3DTEXOPCAPS_ADDSIGNED                  0x00000080L
+#define D3DTEXOPCAPS_ADDSIGNED2X                0x00000100L
+#define D3DTEXOPCAPS_SUBTRACT                   0x00000200L
+#define D3DTEXOPCAPS_ADDSMOOTH                  0x00000400L
+#define D3DTEXOPCAPS_BLENDDIFFUSEALPHA          0x00000800L
+#define D3DTEXOPCAPS_BLENDTEXTUREALPHA          0x00001000L
+#define D3DTEXOPCAPS_BLENDFACTORALPHA           0x00002000L
+#define D3DTEXOPCAPS_BLENDTEXTUREALPHAPM        0x00004000L
+#define D3DTEXOPCAPS_BLENDCURRENTALPHA          0x00008000L
+#define D3DTEXOPCAPS_PREMODULATE                0x00010000L
+#define D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR     0x00020000L
+#define D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA     0x00040000L
+#define D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR  0x00080000L
+#define D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA  0x00100000L
+#define D3DTEXOPCAPS_BUMPENVMAP                 0x00200000L
+#define D3DTEXOPCAPS_BUMPENVMAPLUMINANCE        0x00400000L
+#define D3DTEXOPCAPS_DOTPRODUCT3                0x00800000L
+#define D3DTEXOPCAPS_MULTIPLYADD                0x01000000L
+#define D3DTEXOPCAPS_LERP                       0x02000000L
+
+//
+// FVFCaps
+//
+#define D3DFVFCAPS_TEXCOORDCOUNTMASK    0x0000ffffL /* mask for texture coordinate count field */
+#define D3DFVFCAPS_DONOTSTRIPELEMENTS   0x00080000L /* Device prefers that vertex elements not be stripped */
+#define D3DFVFCAPS_PSIZE                0x00100000L /* Device can receive point size */
+
+//
+// VertexProcessingCaps
+//
+#define D3DVTXPCAPS_TEXGEN              0x00000001L /* device can do texgen */
+#define D3DVTXPCAPS_MATERIALSOURCE7     0x00000002L /* device can do DX7-level colormaterialsource ops */
+#define D3DVTXPCAPS_DIRECTIONALLIGHTS   0x00000008L /* device can do directional lights */
+#define D3DVTXPCAPS_POSITIONALLIGHTS    0x00000010L /* device can do positional lights (includes point and spot) */
+#define D3DVTXPCAPS_LOCALVIEWER         0x00000020L /* device can do local viewer */
+#define D3DVTXPCAPS_TWEENING            0x00000040L /* device can do vertex tweening */
+#define D3DVTXPCAPS_TEXGEN_SPHEREMAP    0x00000100L /* device supports D3DTSS_TCI_SPHEREMAP */
+#define D3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWER   0x00000200L /* device does not support TexGen in non-local
+                                                            viewer mode */
+
+//
+// DevCaps2
+//
+#define D3DDEVCAPS2_STREAMOFFSET                        0x00000001L /* Device supports offsets in streams. Must be set by DX9 drivers */
+#define D3DDEVCAPS2_DMAPNPATCH                          0x00000002L /* Device supports displacement maps for N-Patches*/
+#define D3DDEVCAPS2_ADAPTIVETESSRTPATCH                 0x00000004L /* Device supports adaptive tesselation of RT-patches*/
+#define D3DDEVCAPS2_ADAPTIVETESSNPATCH                  0x00000008L /* Device supports adaptive tesselation of N-patches*/
+#define D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES       0x00000010L /* Device supports StretchRect calls with a texture as the source*/
+#define D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH                0x00000020L /* Device supports presampled displacement maps for N-Patches */
+#define D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET  0x00000040L /* Vertex elements in a vertex declaration can share the same stream offset */
+
+//
+// DeclTypes
+//
+#define D3DDTCAPS_UBYTE4     0x00000001L
+#define D3DDTCAPS_UBYTE4N    0x00000002L
+#define D3DDTCAPS_SHORT2N    0x00000004L
+#define D3DDTCAPS_SHORT4N    0x00000008L
+#define D3DDTCAPS_USHORT2N   0x00000010L
+#define D3DDTCAPS_USHORT4N   0x00000020L
+#define D3DDTCAPS_UDEC3      0x00000040L
+#define D3DDTCAPS_DEC3N      0x00000080L
+#define D3DDTCAPS_FLOAT16_2  0x00000100L
+#define D3DDTCAPS_FLOAT16_4  0x00000200L
+
+
+#pragma pack()
+
+
+#endif /* (DIRECT3D_VERSION >= 0x0900) */
+#endif /* _d3d9CAPS_H_ */
+

3rdparty/bgfx/3rdparty/dxsdk/include/d3dcommon.h

@@ -0,0 +1,933 @@
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 8.00.0613 */
+/* @@MIDL_FILE_HEADING(  ) */
+
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif /* __RPCNDR_H_VERSION__ */
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#ifndef __d3dcommon_h__
+#define __d3dcommon_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER <= 1600
+#ifndef VS2008_SAL_COMPAT
+#define VS2008_SAL_COMPAT
+// BK - SAL compatibility for VS2008
+
+#define DEFINE_ENUM_FLAG_OPERATORS(ENUMTYPE) \
+			extern "C++" { \
+				inline ENUMTYPE operator |  (ENUMTYPE  _a, ENUMTYPE _b) { return  ENUMTYPE   ( ( (int)  _a) |  ( (int)_b) ); } \
+				inline ENUMTYPE operator |= (ENUMTYPE &_a, ENUMTYPE _b) { return (ENUMTYPE &)( ( (int &)_a) |= ( (int)_b) ); } \
+				inline ENUMTYPE operator &  (ENUMTYPE  _a, ENUMTYPE _b) { return  ENUMTYPE   ( ( (int)  _a) &  ( (int)_b) ); } \
+				inline ENUMTYPE operator &= (ENUMTYPE &_a, ENUMTYPE _b) { return (ENUMTYPE &)( ( (int &)_a) &= ( (int)_b) ); } \
+				inline ENUMTYPE operator ~  (ENUMTYPE  _a)              { return (ENUMTYPE)  (~( (int)  _a) );               } \
+				inline ENUMTYPE operator ^  (ENUMTYPE  _a, ENUMTYPE _b) { return  ENUMTYPE   ( ( (int)  _a) ^  ( (int)_b) ); } \
+				inline ENUMTYPE operator ^= (ENUMTYPE &_a, ENUMTYPE _b) { return (ENUMTYPE &)( ( (int &)_a) ^= ( (int)_b) ); } \
+			}
+
+#undef _Out_
+#define _Out_
+#undef _In_
+#define _In_
+#undef _Always_
+#define _Always_(annos)
+#define _In_reads_(size)
+#define _In_reads_opt_(size)
+#define _In_reads_bytes_(size)
+#define _In_reads_bytes_opt_(size)
+#define _Inout_updates_bytes_(size)
+#define _Out_writes_(size)
+#define _Out_writes_opt_(size)
+#define _Out_writes_to_opt_(size,count)
+#define _Out_writes_bytes_(size)
+#define _Out_writes_bytes_opt_(size)
+#define _Out_writes_bytes_to_(size,count)
+#define _Outptr_
+#define _Outptr_opt_result_maybenull_
+#define _Outptr_opt_result_bytebuffer_(size)
+#define _Outptr_result_maybenull_
+#define _Outptr_result_bytebuffer_(size)
+#define _Out_writes_all_opt_(size)
+#define _COM_Outptr_
+#define _COM_Outptr_opt_
+#define _COM_Outptr_opt_result_maybenull_
+#define _Field_size_(size)
+#define _Field_size_full_(size)
+#define _Field_size_opt_(size)
+#define _Field_size_bytes_full_(size)
+#define nullptr NULL
+
+#endif // BK - VS2008_SAL_COMPAT
+#endif //
+
+/* Forward Declarations */ 
+
+#ifndef __ID3D10Blob_FWD_DEFINED__
+#define __ID3D10Blob_FWD_DEFINED__
+typedef interface ID3D10Blob ID3D10Blob;
+
+#endif 	/* __ID3D10Blob_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_d3dcommon_0000_0000 */
+/* [local] */ 
+
+typedef 
+enum D3D_DRIVER_TYPE
+    {
+        D3D_DRIVER_TYPE_UNKNOWN	= 0,
+        D3D_DRIVER_TYPE_HARDWARE	= ( D3D_DRIVER_TYPE_UNKNOWN + 1 ) ,
+        D3D_DRIVER_TYPE_REFERENCE	= ( D3D_DRIVER_TYPE_HARDWARE + 1 ) ,
+        D3D_DRIVER_TYPE_NULL	= ( D3D_DRIVER_TYPE_REFERENCE + 1 ) ,
+        D3D_DRIVER_TYPE_SOFTWARE	= ( D3D_DRIVER_TYPE_NULL + 1 ) ,
+        D3D_DRIVER_TYPE_WARP	= ( D3D_DRIVER_TYPE_SOFTWARE + 1 ) 
+    } 	D3D_DRIVER_TYPE;
+
+typedef 
+enum D3D_FEATURE_LEVEL
+    {
+        D3D_FEATURE_LEVEL_9_1	= 0x9100,
+        D3D_FEATURE_LEVEL_9_2	= 0x9200,
+        D3D_FEATURE_LEVEL_9_3	= 0x9300,
+        D3D_FEATURE_LEVEL_10_0	= 0xa000,
+        D3D_FEATURE_LEVEL_10_1	= 0xa100,
+        D3D_FEATURE_LEVEL_11_0	= 0xb000,
+        D3D_FEATURE_LEVEL_11_1	= 0xb100,
+        D3D_FEATURE_LEVEL_12_0	= 0xc000,
+        D3D_FEATURE_LEVEL_12_1	= 0xc100
+    } 	D3D_FEATURE_LEVEL;
+
+#define D3D_FL9_1_REQ_TEXTURE1D_U_DIMENSION          2048
+#define D3D_FL9_3_REQ_TEXTURE1D_U_DIMENSION          4096
+#define D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION     2048
+#define D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION     4096
+#define D3D_FL9_1_REQ_TEXTURECUBE_DIMENSION          512
+#define D3D_FL9_3_REQ_TEXTURECUBE_DIMENSION          4096
+#define D3D_FL9_1_REQ_TEXTURE3D_U_V_OR_W_DIMENSION   256
+#define D3D_FL9_1_DEFAULT_MAX_ANISOTROPY             2
+#define D3D_FL9_1_IA_PRIMITIVE_MAX_COUNT             65535
+#define D3D_FL9_2_IA_PRIMITIVE_MAX_COUNT             1048575
+#define D3D_FL9_1_SIMULTANEOUS_RENDER_TARGET_COUNT   1
+#define D3D_FL9_3_SIMULTANEOUS_RENDER_TARGET_COUNT   4
+#define D3D_FL9_1_MAX_TEXTURE_REPEAT                 128
+#define D3D_FL9_2_MAX_TEXTURE_REPEAT                 2048
+#define D3D_FL9_3_MAX_TEXTURE_REPEAT                 8192
+typedef 
+enum D3D_PRIMITIVE_TOPOLOGY
+    {
+        D3D_PRIMITIVE_TOPOLOGY_UNDEFINED	= 0,
+        D3D_PRIMITIVE_TOPOLOGY_POINTLIST	= 1,
+        D3D_PRIMITIVE_TOPOLOGY_LINELIST	= 2,
+        D3D_PRIMITIVE_TOPOLOGY_LINESTRIP	= 3,
+        D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST	= 4,
+        D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP	= 5,
+        D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ	= 10,
+        D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ	= 11,
+        D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ	= 12,
+        D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ	= 13,
+        D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST	= 33,
+        D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST	= 34,
+        D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST	= 35,
+        D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST	= 36,
+        D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST	= 37,
+        D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST	= 38,
+        D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST	= 39,
+        D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST	= 40,
+        D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST	= 41,
+        D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST	= 42,
+        D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST	= 43,
+        D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST	= 44,
+        D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST	= 45,
+        D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST	= 46,
+        D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST	= 47,
+        D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST	= 48,
+        D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST	= 49,
+        D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST	= 50,
+        D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST	= 51,
+        D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST	= 52,
+        D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST	= 53,
+        D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST	= 54,
+        D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST	= 55,
+        D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST	= 56,
+        D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST	= 57,
+        D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST	= 58,
+        D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST	= 59,
+        D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST	= 60,
+        D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST	= 61,
+        D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST	= 62,
+        D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST	= 63,
+        D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST	= 64,
+        D3D10_PRIMITIVE_TOPOLOGY_UNDEFINED	= D3D_PRIMITIVE_TOPOLOGY_UNDEFINED,
+        D3D10_PRIMITIVE_TOPOLOGY_POINTLIST	= D3D_PRIMITIVE_TOPOLOGY_POINTLIST,
+        D3D10_PRIMITIVE_TOPOLOGY_LINELIST	= D3D_PRIMITIVE_TOPOLOGY_LINELIST,
+        D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP	= D3D_PRIMITIVE_TOPOLOGY_LINESTRIP,
+        D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST,
+        D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
+        D3D10_PRIMITIVE_TOPOLOGY_LINELIST_ADJ	= D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ,
+        D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ	= D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ,
+        D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ,
+        D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ,
+        D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED	= D3D_PRIMITIVE_TOPOLOGY_UNDEFINED,
+        D3D11_PRIMITIVE_TOPOLOGY_POINTLIST	= D3D_PRIMITIVE_TOPOLOGY_POINTLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_LINELIST	= D3D_PRIMITIVE_TOPOLOGY_LINELIST,
+        D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP	= D3D_PRIMITIVE_TOPOLOGY_LINESTRIP,
+        D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST,
+        D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
+        D3D11_PRIMITIVE_TOPOLOGY_LINELIST_ADJ	= D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ,
+        D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ	= D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ,
+        D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ,
+        D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ,
+        D3D11_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST,
+        D3D11_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST
+    } 	D3D_PRIMITIVE_TOPOLOGY;
+
+typedef 
+enum D3D_PRIMITIVE
+    {
+        D3D_PRIMITIVE_UNDEFINED	= 0,
+        D3D_PRIMITIVE_POINT	= 1,
+        D3D_PRIMITIVE_LINE	= 2,
+        D3D_PRIMITIVE_TRIANGLE	= 3,
+        D3D_PRIMITIVE_LINE_ADJ	= 6,
+        D3D_PRIMITIVE_TRIANGLE_ADJ	= 7,
+        D3D_PRIMITIVE_1_CONTROL_POINT_PATCH	= 8,
+        D3D_PRIMITIVE_2_CONTROL_POINT_PATCH	= 9,
+        D3D_PRIMITIVE_3_CONTROL_POINT_PATCH	= 10,
+        D3D_PRIMITIVE_4_CONTROL_POINT_PATCH	= 11,
+        D3D_PRIMITIVE_5_CONTROL_POINT_PATCH	= 12,
+        D3D_PRIMITIVE_6_CONTROL_POINT_PATCH	= 13,
+        D3D_PRIMITIVE_7_CONTROL_POINT_PATCH	= 14,
+        D3D_PRIMITIVE_8_CONTROL_POINT_PATCH	= 15,
+        D3D_PRIMITIVE_9_CONTROL_POINT_PATCH	= 16,
+        D3D_PRIMITIVE_10_CONTROL_POINT_PATCH	= 17,
+        D3D_PRIMITIVE_11_CONTROL_POINT_PATCH	= 18,
+        D3D_PRIMITIVE_12_CONTROL_POINT_PATCH	= 19,
+        D3D_PRIMITIVE_13_CONTROL_POINT_PATCH	= 20,
+        D3D_PRIMITIVE_14_CONTROL_POINT_PATCH	= 21,
+        D3D_PRIMITIVE_15_CONTROL_POINT_PATCH	= 22,
+        D3D_PRIMITIVE_16_CONTROL_POINT_PATCH	= 23,
+        D3D_PRIMITIVE_17_CONTROL_POINT_PATCH	= 24,
+        D3D_PRIMITIVE_18_CONTROL_POINT_PATCH	= 25,
+        D3D_PRIMITIVE_19_CONTROL_POINT_PATCH	= 26,
+        D3D_PRIMITIVE_20_CONTROL_POINT_PATCH	= 27,
+        D3D_PRIMITIVE_21_CONTROL_POINT_PATCH	= 28,
+        D3D_PRIMITIVE_22_CONTROL_POINT_PATCH	= 29,
+        D3D_PRIMITIVE_23_CONTROL_POINT_PATCH	= 30,
+        D3D_PRIMITIVE_24_CONTROL_POINT_PATCH	= 31,
+        D3D_PRIMITIVE_25_CONTROL_POINT_PATCH	= 32,
+        D3D_PRIMITIVE_26_CONTROL_POINT_PATCH	= 33,
+        D3D_PRIMITIVE_27_CONTROL_POINT_PATCH	= 34,
+        D3D_PRIMITIVE_28_CONTROL_POINT_PATCH	= 35,
+        D3D_PRIMITIVE_29_CONTROL_POINT_PATCH	= 36,
+        D3D_PRIMITIVE_30_CONTROL_POINT_PATCH	= 37,
+        D3D_PRIMITIVE_31_CONTROL_POINT_PATCH	= 38,
+        D3D_PRIMITIVE_32_CONTROL_POINT_PATCH	= 39,
+        D3D10_PRIMITIVE_UNDEFINED	= D3D_PRIMITIVE_UNDEFINED,
+        D3D10_PRIMITIVE_POINT	= D3D_PRIMITIVE_POINT,
+        D3D10_PRIMITIVE_LINE	= D3D_PRIMITIVE_LINE,
+        D3D10_PRIMITIVE_TRIANGLE	= D3D_PRIMITIVE_TRIANGLE,
+        D3D10_PRIMITIVE_LINE_ADJ	= D3D_PRIMITIVE_LINE_ADJ,
+        D3D10_PRIMITIVE_TRIANGLE_ADJ	= D3D_PRIMITIVE_TRIANGLE_ADJ,
+        D3D11_PRIMITIVE_UNDEFINED	= D3D_PRIMITIVE_UNDEFINED,
+        D3D11_PRIMITIVE_POINT	= D3D_PRIMITIVE_POINT,
+        D3D11_PRIMITIVE_LINE	= D3D_PRIMITIVE_LINE,
+        D3D11_PRIMITIVE_TRIANGLE	= D3D_PRIMITIVE_TRIANGLE,
+        D3D11_PRIMITIVE_LINE_ADJ	= D3D_PRIMITIVE_LINE_ADJ,
+        D3D11_PRIMITIVE_TRIANGLE_ADJ	= D3D_PRIMITIVE_TRIANGLE_ADJ,
+        D3D11_PRIMITIVE_1_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_1_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_2_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_2_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_3_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_3_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_4_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_4_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_5_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_5_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_6_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_6_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_7_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_7_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_8_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_8_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_9_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_9_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_10_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_10_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_11_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_11_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_12_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_12_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_13_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_13_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_14_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_14_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_15_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_15_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_16_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_16_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_17_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_17_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_18_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_18_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_19_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_19_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_20_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_20_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_21_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_21_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_22_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_22_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_23_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_23_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_24_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_24_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_25_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_25_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_26_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_26_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_27_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_27_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_28_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_28_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_29_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_29_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_30_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_30_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_31_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_31_CONTROL_POINT_PATCH,
+        D3D11_PRIMITIVE_32_CONTROL_POINT_PATCH	= D3D_PRIMITIVE_32_CONTROL_POINT_PATCH
+    } 	D3D_PRIMITIVE;
+
+typedef 
+enum D3D_SRV_DIMENSION
+    {
+        D3D_SRV_DIMENSION_UNKNOWN	= 0,
+        D3D_SRV_DIMENSION_BUFFER	= 1,
+        D3D_SRV_DIMENSION_TEXTURE1D	= 2,
+        D3D_SRV_DIMENSION_TEXTURE1DARRAY	= 3,
+        D3D_SRV_DIMENSION_TEXTURE2D	= 4,
+        D3D_SRV_DIMENSION_TEXTURE2DARRAY	= 5,
+        D3D_SRV_DIMENSION_TEXTURE2DMS	= 6,
+        D3D_SRV_DIMENSION_TEXTURE2DMSARRAY	= 7,
+        D3D_SRV_DIMENSION_TEXTURE3D	= 8,
+        D3D_SRV_DIMENSION_TEXTURECUBE	= 9,
+        D3D_SRV_DIMENSION_TEXTURECUBEARRAY	= 10,
+        D3D_SRV_DIMENSION_BUFFEREX	= 11,
+        D3D10_SRV_DIMENSION_UNKNOWN	= D3D_SRV_DIMENSION_UNKNOWN,
+        D3D10_SRV_DIMENSION_BUFFER	= D3D_SRV_DIMENSION_BUFFER,
+        D3D10_SRV_DIMENSION_TEXTURE1D	= D3D_SRV_DIMENSION_TEXTURE1D,
+        D3D10_SRV_DIMENSION_TEXTURE1DARRAY	= D3D_SRV_DIMENSION_TEXTURE1DARRAY,
+        D3D10_SRV_DIMENSION_TEXTURE2D	= D3D_SRV_DIMENSION_TEXTURE2D,
+        D3D10_SRV_DIMENSION_TEXTURE2DARRAY	= D3D_SRV_DIMENSION_TEXTURE2DARRAY,
+        D3D10_SRV_DIMENSION_TEXTURE2DMS	= D3D_SRV_DIMENSION_TEXTURE2DMS,
+        D3D10_SRV_DIMENSION_TEXTURE2DMSARRAY	= D3D_SRV_DIMENSION_TEXTURE2DMSARRAY,
+        D3D10_SRV_DIMENSION_TEXTURE3D	= D3D_SRV_DIMENSION_TEXTURE3D,
+        D3D10_SRV_DIMENSION_TEXTURECUBE	= D3D_SRV_DIMENSION_TEXTURECUBE,
+        D3D10_1_SRV_DIMENSION_UNKNOWN	= D3D_SRV_DIMENSION_UNKNOWN,
+        D3D10_1_SRV_DIMENSION_BUFFER	= D3D_SRV_DIMENSION_BUFFER,
+        D3D10_1_SRV_DIMENSION_TEXTURE1D	= D3D_SRV_DIMENSION_TEXTURE1D,
+        D3D10_1_SRV_DIMENSION_TEXTURE1DARRAY	= D3D_SRV_DIMENSION_TEXTURE1DARRAY,
+        D3D10_1_SRV_DIMENSION_TEXTURE2D	= D3D_SRV_DIMENSION_TEXTURE2D,
+        D3D10_1_SRV_DIMENSION_TEXTURE2DARRAY	= D3D_SRV_DIMENSION_TEXTURE2DARRAY,
+        D3D10_1_SRV_DIMENSION_TEXTURE2DMS	= D3D_SRV_DIMENSION_TEXTURE2DMS,
+        D3D10_1_SRV_DIMENSION_TEXTURE2DMSARRAY	= D3D_SRV_DIMENSION_TEXTURE2DMSARRAY,
+        D3D10_1_SRV_DIMENSION_TEXTURE3D	= D3D_SRV_DIMENSION_TEXTURE3D,
+        D3D10_1_SRV_DIMENSION_TEXTURECUBE	= D3D_SRV_DIMENSION_TEXTURECUBE,
+        D3D10_1_SRV_DIMENSION_TEXTURECUBEARRAY	= D3D_SRV_DIMENSION_TEXTURECUBEARRAY,
+        D3D11_SRV_DIMENSION_UNKNOWN	= D3D_SRV_DIMENSION_UNKNOWN,
+        D3D11_SRV_DIMENSION_BUFFER	= D3D_SRV_DIMENSION_BUFFER,
+        D3D11_SRV_DIMENSION_TEXTURE1D	= D3D_SRV_DIMENSION_TEXTURE1D,
+        D3D11_SRV_DIMENSION_TEXTURE1DARRAY	= D3D_SRV_DIMENSION_TEXTURE1DARRAY,
+        D3D11_SRV_DIMENSION_TEXTURE2D	= D3D_SRV_DIMENSION_TEXTURE2D,
+        D3D11_SRV_DIMENSION_TEXTURE2DARRAY	= D3D_SRV_DIMENSION_TEXTURE2DARRAY,
+        D3D11_SRV_DIMENSION_TEXTURE2DMS	= D3D_SRV_DIMENSION_TEXTURE2DMS,
+        D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY	= D3D_SRV_DIMENSION_TEXTURE2DMSARRAY,
+        D3D11_SRV_DIMENSION_TEXTURE3D	= D3D_SRV_DIMENSION_TEXTURE3D,
+        D3D11_SRV_DIMENSION_TEXTURECUBE	= D3D_SRV_DIMENSION_TEXTURECUBE,
+        D3D11_SRV_DIMENSION_TEXTURECUBEARRAY	= D3D_SRV_DIMENSION_TEXTURECUBEARRAY,
+        D3D11_SRV_DIMENSION_BUFFEREX	= D3D_SRV_DIMENSION_BUFFEREX
+    } 	D3D_SRV_DIMENSION;
+
+typedef struct _D3D_SHADER_MACRO
+    {
+    LPCSTR Name;
+    LPCSTR Definition;
+    } 	D3D_SHADER_MACRO;
+
+typedef struct _D3D_SHADER_MACRO *LPD3D_SHADER_MACRO;
+
+DEFINE_GUID(IID_ID3D10Blob, 0x8ba5fb08, 0x5195, 0x40e2, 0xac, 0x58, 0xd, 0x98, 0x9c, 0x3a, 0x1, 0x2);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0000_v0_0_s_ifspec;
+
+#ifndef __ID3D10Blob_INTERFACE_DEFINED__
+#define __ID3D10Blob_INTERFACE_DEFINED__
+
+/* interface ID3D10Blob */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D10Blob;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8BA5FB08-5195-40e2-AC58-0D989C3A0102")
+    ID3D10Blob : public IUnknown
+    {
+    public:
+        virtual LPVOID STDMETHODCALLTYPE GetBufferPointer( void) = 0;
+        
+        virtual SIZE_T STDMETHODCALLTYPE GetBufferSize( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D10BlobVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D10Blob * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D10Blob * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D10Blob * This);
+        
+        LPVOID ( STDMETHODCALLTYPE *GetBufferPointer )( 
+            ID3D10Blob * This);
+        
+        SIZE_T ( STDMETHODCALLTYPE *GetBufferSize )( 
+            ID3D10Blob * This);
+        
+        END_INTERFACE
+    } ID3D10BlobVtbl;
+
+    interface ID3D10Blob
+    {
+        CONST_VTBL struct ID3D10BlobVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D10Blob_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D10Blob_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D10Blob_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D10Blob_GetBufferPointer(This)	\
+    ( (This)->lpVtbl -> GetBufferPointer(This) ) 
+
+#define ID3D10Blob_GetBufferSize(This)	\
+    ( (This)->lpVtbl -> GetBufferSize(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D10Blob_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3dcommon_0000_0001 */
+/* [local] */ 
+
+typedef interface ID3D10Blob* LPD3D10BLOB;
+typedef ID3D10Blob ID3DBlob;
+
+typedef ID3DBlob* LPD3DBLOB;
+#define IID_ID3DBlob IID_ID3D10Blob
+typedef 
+enum _D3D_INCLUDE_TYPE
+    {
+        D3D_INCLUDE_LOCAL	= 0,
+        D3D_INCLUDE_SYSTEM	= ( D3D_INCLUDE_LOCAL + 1 ) ,
+        D3D10_INCLUDE_LOCAL	= D3D_INCLUDE_LOCAL,
+        D3D10_INCLUDE_SYSTEM	= D3D_INCLUDE_SYSTEM,
+        D3D_INCLUDE_FORCE_DWORD	= 0x7fffffff
+    } 	D3D_INCLUDE_TYPE;
+
+typedef interface ID3DInclude ID3DInclude;
+#undef INTERFACE
+#define INTERFACE ID3DInclude
+DECLARE_INTERFACE(ID3DInclude)
+{
+    STDMETHOD(Open)(THIS_ D3D_INCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes) PURE;
+    STDMETHOD(Close)(THIS_ LPCVOID pData) PURE;
+};
+typedef ID3DInclude* LPD3DINCLUDE;
+typedef 
+enum _D3D_SHADER_VARIABLE_CLASS
+    {
+        D3D_SVC_SCALAR	= 0,
+        D3D_SVC_VECTOR	= ( D3D_SVC_SCALAR + 1 ) ,
+        D3D_SVC_MATRIX_ROWS	= ( D3D_SVC_VECTOR + 1 ) ,
+        D3D_SVC_MATRIX_COLUMNS	= ( D3D_SVC_MATRIX_ROWS + 1 ) ,
+        D3D_SVC_OBJECT	= ( D3D_SVC_MATRIX_COLUMNS + 1 ) ,
+        D3D_SVC_STRUCT	= ( D3D_SVC_OBJECT + 1 ) ,
+        D3D_SVC_INTERFACE_CLASS	= ( D3D_SVC_STRUCT + 1 ) ,
+        D3D_SVC_INTERFACE_POINTER	= ( D3D_SVC_INTERFACE_CLASS + 1 ) ,
+        D3D10_SVC_SCALAR	= D3D_SVC_SCALAR,
+        D3D10_SVC_VECTOR	= D3D_SVC_VECTOR,
+        D3D10_SVC_MATRIX_ROWS	= D3D_SVC_MATRIX_ROWS,
+        D3D10_SVC_MATRIX_COLUMNS	= D3D_SVC_MATRIX_COLUMNS,
+        D3D10_SVC_OBJECT	= D3D_SVC_OBJECT,
+        D3D10_SVC_STRUCT	= D3D_SVC_STRUCT,
+        D3D11_SVC_INTERFACE_CLASS	= D3D_SVC_INTERFACE_CLASS,
+        D3D11_SVC_INTERFACE_POINTER	= D3D_SVC_INTERFACE_POINTER,
+        D3D_SVC_FORCE_DWORD	= 0x7fffffff
+    } 	D3D_SHADER_VARIABLE_CLASS;
+
+typedef 
+enum _D3D_SHADER_VARIABLE_FLAGS
+    {
+        D3D_SVF_USERPACKED	= 1,
+        D3D_SVF_USED	= 2,
+        D3D_SVF_INTERFACE_POINTER	= 4,
+        D3D_SVF_INTERFACE_PARAMETER	= 8,
+        D3D10_SVF_USERPACKED	= D3D_SVF_USERPACKED,
+        D3D10_SVF_USED	= D3D_SVF_USED,
+        D3D11_SVF_INTERFACE_POINTER	= D3D_SVF_INTERFACE_POINTER,
+        D3D11_SVF_INTERFACE_PARAMETER	= D3D_SVF_INTERFACE_PARAMETER,
+        D3D_SVF_FORCE_DWORD	= 0x7fffffff
+    } 	D3D_SHADER_VARIABLE_FLAGS;
+
+typedef 
+enum _D3D_SHADER_VARIABLE_TYPE
+    {
+        D3D_SVT_VOID	= 0,
+        D3D_SVT_BOOL	= 1,
+        D3D_SVT_INT	= 2,
+        D3D_SVT_FLOAT	= 3,
+        D3D_SVT_STRING	= 4,
+        D3D_SVT_TEXTURE	= 5,
+        D3D_SVT_TEXTURE1D	= 6,
+        D3D_SVT_TEXTURE2D	= 7,
+        D3D_SVT_TEXTURE3D	= 8,
+        D3D_SVT_TEXTURECUBE	= 9,
+        D3D_SVT_SAMPLER	= 10,
+        D3D_SVT_SAMPLER1D	= 11,
+        D3D_SVT_SAMPLER2D	= 12,
+        D3D_SVT_SAMPLER3D	= 13,
+        D3D_SVT_SAMPLERCUBE	= 14,
+        D3D_SVT_PIXELSHADER	= 15,
+        D3D_SVT_VERTEXSHADER	= 16,
+        D3D_SVT_PIXELFRAGMENT	= 17,
+        D3D_SVT_VERTEXFRAGMENT	= 18,
+        D3D_SVT_UINT	= 19,
+        D3D_SVT_UINT8	= 20,
+        D3D_SVT_GEOMETRYSHADER	= 21,
+        D3D_SVT_RASTERIZER	= 22,
+        D3D_SVT_DEPTHSTENCIL	= 23,
+        D3D_SVT_BLEND	= 24,
+        D3D_SVT_BUFFER	= 25,
+        D3D_SVT_CBUFFER	= 26,
+        D3D_SVT_TBUFFER	= 27,
+        D3D_SVT_TEXTURE1DARRAY	= 28,
+        D3D_SVT_TEXTURE2DARRAY	= 29,
+        D3D_SVT_RENDERTARGETVIEW	= 30,
+        D3D_SVT_DEPTHSTENCILVIEW	= 31,
+        D3D_SVT_TEXTURE2DMS	= 32,
+        D3D_SVT_TEXTURE2DMSARRAY	= 33,
+        D3D_SVT_TEXTURECUBEARRAY	= 34,
+        D3D_SVT_HULLSHADER	= 35,
+        D3D_SVT_DOMAINSHADER	= 36,
+        D3D_SVT_INTERFACE_POINTER	= 37,
+        D3D_SVT_COMPUTESHADER	= 38,
+        D3D_SVT_DOUBLE	= 39,
+        D3D_SVT_RWTEXTURE1D	= 40,
+        D3D_SVT_RWTEXTURE1DARRAY	= 41,
+        D3D_SVT_RWTEXTURE2D	= 42,
+        D3D_SVT_RWTEXTURE2DARRAY	= 43,
+        D3D_SVT_RWTEXTURE3D	= 44,
+        D3D_SVT_RWBUFFER	= 45,
+        D3D_SVT_BYTEADDRESS_BUFFER	= 46,
+        D3D_SVT_RWBYTEADDRESS_BUFFER	= 47,
+        D3D_SVT_STRUCTURED_BUFFER	= 48,
+        D3D_SVT_RWSTRUCTURED_BUFFER	= 49,
+        D3D_SVT_APPEND_STRUCTURED_BUFFER	= 50,
+        D3D_SVT_CONSUME_STRUCTURED_BUFFER	= 51,
+        D3D_SVT_MIN8FLOAT	= 52,
+        D3D_SVT_MIN10FLOAT	= 53,
+        D3D_SVT_MIN16FLOAT	= 54,
+        D3D_SVT_MIN12INT	= 55,
+        D3D_SVT_MIN16INT	= 56,
+        D3D_SVT_MIN16UINT	= 57,
+        D3D10_SVT_VOID	= D3D_SVT_VOID,
+        D3D10_SVT_BOOL	= D3D_SVT_BOOL,
+        D3D10_SVT_INT	= D3D_SVT_INT,
+        D3D10_SVT_FLOAT	= D3D_SVT_FLOAT,
+        D3D10_SVT_STRING	= D3D_SVT_STRING,
+        D3D10_SVT_TEXTURE	= D3D_SVT_TEXTURE,
+        D3D10_SVT_TEXTURE1D	= D3D_SVT_TEXTURE1D,
+        D3D10_SVT_TEXTURE2D	= D3D_SVT_TEXTURE2D,
+        D3D10_SVT_TEXTURE3D	= D3D_SVT_TEXTURE3D,
+        D3D10_SVT_TEXTURECUBE	= D3D_SVT_TEXTURECUBE,
+        D3D10_SVT_SAMPLER	= D3D_SVT_SAMPLER,
+        D3D10_SVT_SAMPLER1D	= D3D_SVT_SAMPLER1D,
+        D3D10_SVT_SAMPLER2D	= D3D_SVT_SAMPLER2D,
+        D3D10_SVT_SAMPLER3D	= D3D_SVT_SAMPLER3D,
+        D3D10_SVT_SAMPLERCUBE	= D3D_SVT_SAMPLERCUBE,
+        D3D10_SVT_PIXELSHADER	= D3D_SVT_PIXELSHADER,
+        D3D10_SVT_VERTEXSHADER	= D3D_SVT_VERTEXSHADER,
+        D3D10_SVT_PIXELFRAGMENT	= D3D_SVT_PIXELFRAGMENT,
+        D3D10_SVT_VERTEXFRAGMENT	= D3D_SVT_VERTEXFRAGMENT,
+        D3D10_SVT_UINT	= D3D_SVT_UINT,
+        D3D10_SVT_UINT8	= D3D_SVT_UINT8,
+        D3D10_SVT_GEOMETRYSHADER	= D3D_SVT_GEOMETRYSHADER,
+        D3D10_SVT_RASTERIZER	= D3D_SVT_RASTERIZER,
+        D3D10_SVT_DEPTHSTENCIL	= D3D_SVT_DEPTHSTENCIL,
+        D3D10_SVT_BLEND	= D3D_SVT_BLEND,
+        D3D10_SVT_BUFFER	= D3D_SVT_BUFFER,
+        D3D10_SVT_CBUFFER	= D3D_SVT_CBUFFER,
+        D3D10_SVT_TBUFFER	= D3D_SVT_TBUFFER,
+        D3D10_SVT_TEXTURE1DARRAY	= D3D_SVT_TEXTURE1DARRAY,
+        D3D10_SVT_TEXTURE2DARRAY	= D3D_SVT_TEXTURE2DARRAY,
+        D3D10_SVT_RENDERTARGETVIEW	= D3D_SVT_RENDERTARGETVIEW,
+        D3D10_SVT_DEPTHSTENCILVIEW	= D3D_SVT_DEPTHSTENCILVIEW,
+        D3D10_SVT_TEXTURE2DMS	= D3D_SVT_TEXTURE2DMS,
+        D3D10_SVT_TEXTURE2DMSARRAY	= D3D_SVT_TEXTURE2DMSARRAY,
+        D3D10_SVT_TEXTURECUBEARRAY	= D3D_SVT_TEXTURECUBEARRAY,
+        D3D11_SVT_HULLSHADER	= D3D_SVT_HULLSHADER,
+        D3D11_SVT_DOMAINSHADER	= D3D_SVT_DOMAINSHADER,
+        D3D11_SVT_INTERFACE_POINTER	= D3D_SVT_INTERFACE_POINTER,
+        D3D11_SVT_COMPUTESHADER	= D3D_SVT_COMPUTESHADER,
+        D3D11_SVT_DOUBLE	= D3D_SVT_DOUBLE,
+        D3D11_SVT_RWTEXTURE1D	= D3D_SVT_RWTEXTURE1D,
+        D3D11_SVT_RWTEXTURE1DARRAY	= D3D_SVT_RWTEXTURE1DARRAY,
+        D3D11_SVT_RWTEXTURE2D	= D3D_SVT_RWTEXTURE2D,
+        D3D11_SVT_RWTEXTURE2DARRAY	= D3D_SVT_RWTEXTURE2DARRAY,
+        D3D11_SVT_RWTEXTURE3D	= D3D_SVT_RWTEXTURE3D,
+        D3D11_SVT_RWBUFFER	= D3D_SVT_RWBUFFER,
+        D3D11_SVT_BYTEADDRESS_BUFFER	= D3D_SVT_BYTEADDRESS_BUFFER,
+        D3D11_SVT_RWBYTEADDRESS_BUFFER	= D3D_SVT_RWBYTEADDRESS_BUFFER,
+        D3D11_SVT_STRUCTURED_BUFFER	= D3D_SVT_STRUCTURED_BUFFER,
+        D3D11_SVT_RWSTRUCTURED_BUFFER	= D3D_SVT_RWSTRUCTURED_BUFFER,
+        D3D11_SVT_APPEND_STRUCTURED_BUFFER	= D3D_SVT_APPEND_STRUCTURED_BUFFER,
+        D3D11_SVT_CONSUME_STRUCTURED_BUFFER	= D3D_SVT_CONSUME_STRUCTURED_BUFFER,
+        D3D_SVT_FORCE_DWORD	= 0x7fffffff
+    } 	D3D_SHADER_VARIABLE_TYPE;
+
+typedef 
+enum _D3D_SHADER_INPUT_FLAGS
+    {
+        D3D_SIF_USERPACKED	= 0x1,
+        D3D_SIF_COMPARISON_SAMPLER	= 0x2,
+        D3D_SIF_TEXTURE_COMPONENT_0	= 0x4,
+        D3D_SIF_TEXTURE_COMPONENT_1	= 0x8,
+        D3D_SIF_TEXTURE_COMPONENTS	= 0xc,
+        D3D_SIF_UNUSED	= 0x10,
+        D3D10_SIF_USERPACKED	= D3D_SIF_USERPACKED,
+        D3D10_SIF_COMPARISON_SAMPLER	= D3D_SIF_COMPARISON_SAMPLER,
+        D3D10_SIF_TEXTURE_COMPONENT_0	= D3D_SIF_TEXTURE_COMPONENT_0,
+        D3D10_SIF_TEXTURE_COMPONENT_1	= D3D_SIF_TEXTURE_COMPONENT_1,
+        D3D10_SIF_TEXTURE_COMPONENTS	= D3D_SIF_TEXTURE_COMPONENTS,
+        D3D_SIF_FORCE_DWORD	= 0x7fffffff
+    } 	D3D_SHADER_INPUT_FLAGS;
+
+typedef 
+enum _D3D_SHADER_INPUT_TYPE
+    {
+        D3D_SIT_CBUFFER	= 0,
+        D3D_SIT_TBUFFER	= ( D3D_SIT_CBUFFER + 1 ) ,
+        D3D_SIT_TEXTURE	= ( D3D_SIT_TBUFFER + 1 ) ,
+        D3D_SIT_SAMPLER	= ( D3D_SIT_TEXTURE + 1 ) ,
+        D3D_SIT_UAV_RWTYPED	= ( D3D_SIT_SAMPLER + 1 ) ,
+        D3D_SIT_STRUCTURED	= ( D3D_SIT_UAV_RWTYPED + 1 ) ,
+        D3D_SIT_UAV_RWSTRUCTURED	= ( D3D_SIT_STRUCTURED + 1 ) ,
+        D3D_SIT_BYTEADDRESS	= ( D3D_SIT_UAV_RWSTRUCTURED + 1 ) ,
+        D3D_SIT_UAV_RWBYTEADDRESS	= ( D3D_SIT_BYTEADDRESS + 1 ) ,
+        D3D_SIT_UAV_APPEND_STRUCTURED	= ( D3D_SIT_UAV_RWBYTEADDRESS + 1 ) ,
+        D3D_SIT_UAV_CONSUME_STRUCTURED	= ( D3D_SIT_UAV_APPEND_STRUCTURED + 1 ) ,
+        D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER	= ( D3D_SIT_UAV_CONSUME_STRUCTURED + 1 ) ,
+        D3D10_SIT_CBUFFER	= D3D_SIT_CBUFFER,
+        D3D10_SIT_TBUFFER	= D3D_SIT_TBUFFER,
+        D3D10_SIT_TEXTURE	= D3D_SIT_TEXTURE,
+        D3D10_SIT_SAMPLER	= D3D_SIT_SAMPLER,
+        D3D11_SIT_UAV_RWTYPED	= D3D_SIT_UAV_RWTYPED,
+        D3D11_SIT_STRUCTURED	= D3D_SIT_STRUCTURED,
+        D3D11_SIT_UAV_RWSTRUCTURED	= D3D_SIT_UAV_RWSTRUCTURED,
+        D3D11_SIT_BYTEADDRESS	= D3D_SIT_BYTEADDRESS,
+        D3D11_SIT_UAV_RWBYTEADDRESS	= D3D_SIT_UAV_RWBYTEADDRESS,
+        D3D11_SIT_UAV_APPEND_STRUCTURED	= D3D_SIT_UAV_APPEND_STRUCTURED,
+        D3D11_SIT_UAV_CONSUME_STRUCTURED	= D3D_SIT_UAV_CONSUME_STRUCTURED,
+        D3D11_SIT_UAV_RWSTRUCTURED_WITH_COUNTER	= D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER
+    } 	D3D_SHADER_INPUT_TYPE;
+
+typedef 
+enum _D3D_SHADER_CBUFFER_FLAGS
+    {
+        D3D_CBF_USERPACKED	= 1,
+        D3D10_CBF_USERPACKED	= D3D_CBF_USERPACKED,
+        D3D_CBF_FORCE_DWORD	= 0x7fffffff
+    } 	D3D_SHADER_CBUFFER_FLAGS;
+
+typedef 
+enum _D3D_CBUFFER_TYPE
+    {
+        D3D_CT_CBUFFER	= 0,
+        D3D_CT_TBUFFER	= ( D3D_CT_CBUFFER + 1 ) ,
+        D3D_CT_INTERFACE_POINTERS	= ( D3D_CT_TBUFFER + 1 ) ,
+        D3D_CT_RESOURCE_BIND_INFO	= ( D3D_CT_INTERFACE_POINTERS + 1 ) ,
+        D3D10_CT_CBUFFER	= D3D_CT_CBUFFER,
+        D3D10_CT_TBUFFER	= D3D_CT_TBUFFER,
+        D3D11_CT_CBUFFER	= D3D_CT_CBUFFER,
+        D3D11_CT_TBUFFER	= D3D_CT_TBUFFER,
+        D3D11_CT_INTERFACE_POINTERS	= D3D_CT_INTERFACE_POINTERS,
+        D3D11_CT_RESOURCE_BIND_INFO	= D3D_CT_RESOURCE_BIND_INFO
+    } 	D3D_CBUFFER_TYPE;
+
+typedef 
+enum D3D_NAME
+    {
+        D3D_NAME_UNDEFINED	= 0,
+        D3D_NAME_POSITION	= 1,
+        D3D_NAME_CLIP_DISTANCE	= 2,
+        D3D_NAME_CULL_DISTANCE	= 3,
+        D3D_NAME_RENDER_TARGET_ARRAY_INDEX	= 4,
+        D3D_NAME_VIEWPORT_ARRAY_INDEX	= 5,
+        D3D_NAME_VERTEX_ID	= 6,
+        D3D_NAME_PRIMITIVE_ID	= 7,
+        D3D_NAME_INSTANCE_ID	= 8,
+        D3D_NAME_IS_FRONT_FACE	= 9,
+        D3D_NAME_SAMPLE_INDEX	= 10,
+        D3D_NAME_FINAL_QUAD_EDGE_TESSFACTOR	= 11,
+        D3D_NAME_FINAL_QUAD_INSIDE_TESSFACTOR	= 12,
+        D3D_NAME_FINAL_TRI_EDGE_TESSFACTOR	= 13,
+        D3D_NAME_FINAL_TRI_INSIDE_TESSFACTOR	= 14,
+        D3D_NAME_FINAL_LINE_DETAIL_TESSFACTOR	= 15,
+        D3D_NAME_FINAL_LINE_DENSITY_TESSFACTOR	= 16,
+        D3D_NAME_TARGET	= 64,
+        D3D_NAME_DEPTH	= 65,
+        D3D_NAME_COVERAGE	= 66,
+        D3D_NAME_DEPTH_GREATER_EQUAL	= 67,
+        D3D_NAME_DEPTH_LESS_EQUAL	= 68,
+        D3D_NAME_STENCIL_REF	= 69,
+        D3D_NAME_INNER_COVERAGE	= 70,
+        D3D10_NAME_UNDEFINED	= D3D_NAME_UNDEFINED,
+        D3D10_NAME_POSITION	= D3D_NAME_POSITION,
+        D3D10_NAME_CLIP_DISTANCE	= D3D_NAME_CLIP_DISTANCE,
+        D3D10_NAME_CULL_DISTANCE	= D3D_NAME_CULL_DISTANCE,
+        D3D10_NAME_RENDER_TARGET_ARRAY_INDEX	= D3D_NAME_RENDER_TARGET_ARRAY_INDEX,
+        D3D10_NAME_VIEWPORT_ARRAY_INDEX	= D3D_NAME_VIEWPORT_ARRAY_INDEX,
+        D3D10_NAME_VERTEX_ID	= D3D_NAME_VERTEX_ID,
+        D3D10_NAME_PRIMITIVE_ID	= D3D_NAME_PRIMITIVE_ID,
+        D3D10_NAME_INSTANCE_ID	= D3D_NAME_INSTANCE_ID,
+        D3D10_NAME_IS_FRONT_FACE	= D3D_NAME_IS_FRONT_FACE,
+        D3D10_NAME_SAMPLE_INDEX	= D3D_NAME_SAMPLE_INDEX,
+        D3D10_NAME_TARGET	= D3D_NAME_TARGET,
+        D3D10_NAME_DEPTH	= D3D_NAME_DEPTH,
+        D3D10_NAME_COVERAGE	= D3D_NAME_COVERAGE,
+        D3D11_NAME_FINAL_QUAD_EDGE_TESSFACTOR	= D3D_NAME_FINAL_QUAD_EDGE_TESSFACTOR,
+        D3D11_NAME_FINAL_QUAD_INSIDE_TESSFACTOR	= D3D_NAME_FINAL_QUAD_INSIDE_TESSFACTOR,
+        D3D11_NAME_FINAL_TRI_EDGE_TESSFACTOR	= D3D_NAME_FINAL_TRI_EDGE_TESSFACTOR,
+        D3D11_NAME_FINAL_TRI_INSIDE_TESSFACTOR	= D3D_NAME_FINAL_TRI_INSIDE_TESSFACTOR,
+        D3D11_NAME_FINAL_LINE_DETAIL_TESSFACTOR	= D3D_NAME_FINAL_LINE_DETAIL_TESSFACTOR,
+        D3D11_NAME_FINAL_LINE_DENSITY_TESSFACTOR	= D3D_NAME_FINAL_LINE_DENSITY_TESSFACTOR,
+        D3D11_NAME_DEPTH_GREATER_EQUAL	= D3D_NAME_DEPTH_GREATER_EQUAL,
+        D3D11_NAME_DEPTH_LESS_EQUAL	= D3D_NAME_DEPTH_LESS_EQUAL,
+        D3D11_NAME_STENCIL_REF	= D3D_NAME_STENCIL_REF,
+        D3D11_NAME_INNER_COVERAGE	= D3D_NAME_INNER_COVERAGE
+    } 	D3D_NAME;
+
+typedef 
+enum D3D_RESOURCE_RETURN_TYPE
+    {
+        D3D_RETURN_TYPE_UNORM	= 1,
+        D3D_RETURN_TYPE_SNORM	= 2,
+        D3D_RETURN_TYPE_SINT	= 3,
+        D3D_RETURN_TYPE_UINT	= 4,
+        D3D_RETURN_TYPE_FLOAT	= 5,
+        D3D_RETURN_TYPE_MIXED	= 6,
+        D3D_RETURN_TYPE_DOUBLE	= 7,
+        D3D_RETURN_TYPE_CONTINUED	= 8,
+        D3D10_RETURN_TYPE_UNORM	= D3D_RETURN_TYPE_UNORM,
+        D3D10_RETURN_TYPE_SNORM	= D3D_RETURN_TYPE_SNORM,
+        D3D10_RETURN_TYPE_SINT	= D3D_RETURN_TYPE_SINT,
+        D3D10_RETURN_TYPE_UINT	= D3D_RETURN_TYPE_UINT,
+        D3D10_RETURN_TYPE_FLOAT	= D3D_RETURN_TYPE_FLOAT,
+        D3D10_RETURN_TYPE_MIXED	= D3D_RETURN_TYPE_MIXED,
+        D3D11_RETURN_TYPE_UNORM	= D3D_RETURN_TYPE_UNORM,
+        D3D11_RETURN_TYPE_SNORM	= D3D_RETURN_TYPE_SNORM,
+        D3D11_RETURN_TYPE_SINT	= D3D_RETURN_TYPE_SINT,
+        D3D11_RETURN_TYPE_UINT	= D3D_RETURN_TYPE_UINT,
+        D3D11_RETURN_TYPE_FLOAT	= D3D_RETURN_TYPE_FLOAT,
+        D3D11_RETURN_TYPE_MIXED	= D3D_RETURN_TYPE_MIXED,
+        D3D11_RETURN_TYPE_DOUBLE	= D3D_RETURN_TYPE_DOUBLE,
+        D3D11_RETURN_TYPE_CONTINUED	= D3D_RETURN_TYPE_CONTINUED
+    } 	D3D_RESOURCE_RETURN_TYPE;
+
+typedef 
+enum D3D_REGISTER_COMPONENT_TYPE
+    {
+        D3D_REGISTER_COMPONENT_UNKNOWN	= 0,
+        D3D_REGISTER_COMPONENT_UINT32	= 1,
+        D3D_REGISTER_COMPONENT_SINT32	= 2,
+        D3D_REGISTER_COMPONENT_FLOAT32	= 3,
+        D3D10_REGISTER_COMPONENT_UNKNOWN	= D3D_REGISTER_COMPONENT_UNKNOWN,
+        D3D10_REGISTER_COMPONENT_UINT32	= D3D_REGISTER_COMPONENT_UINT32,
+        D3D10_REGISTER_COMPONENT_SINT32	= D3D_REGISTER_COMPONENT_SINT32,
+        D3D10_REGISTER_COMPONENT_FLOAT32	= D3D_REGISTER_COMPONENT_FLOAT32
+    } 	D3D_REGISTER_COMPONENT_TYPE;
+
+typedef 
+enum D3D_TESSELLATOR_DOMAIN
+    {
+        D3D_TESSELLATOR_DOMAIN_UNDEFINED	= 0,
+        D3D_TESSELLATOR_DOMAIN_ISOLINE	= 1,
+        D3D_TESSELLATOR_DOMAIN_TRI	= 2,
+        D3D_TESSELLATOR_DOMAIN_QUAD	= 3,
+        D3D11_TESSELLATOR_DOMAIN_UNDEFINED	= D3D_TESSELLATOR_DOMAIN_UNDEFINED,
+        D3D11_TESSELLATOR_DOMAIN_ISOLINE	= D3D_TESSELLATOR_DOMAIN_ISOLINE,
+        D3D11_TESSELLATOR_DOMAIN_TRI	= D3D_TESSELLATOR_DOMAIN_TRI,
+        D3D11_TESSELLATOR_DOMAIN_QUAD	= D3D_TESSELLATOR_DOMAIN_QUAD
+    } 	D3D_TESSELLATOR_DOMAIN;
+
+typedef 
+enum D3D_TESSELLATOR_PARTITIONING
+    {
+        D3D_TESSELLATOR_PARTITIONING_UNDEFINED	= 0,
+        D3D_TESSELLATOR_PARTITIONING_INTEGER	= 1,
+        D3D_TESSELLATOR_PARTITIONING_POW2	= 2,
+        D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD	= 3,
+        D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN	= 4,
+        D3D11_TESSELLATOR_PARTITIONING_UNDEFINED	= D3D_TESSELLATOR_PARTITIONING_UNDEFINED,
+        D3D11_TESSELLATOR_PARTITIONING_INTEGER	= D3D_TESSELLATOR_PARTITIONING_INTEGER,
+        D3D11_TESSELLATOR_PARTITIONING_POW2	= D3D_TESSELLATOR_PARTITIONING_POW2,
+        D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD	= D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD,
+        D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN	= D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN
+    } 	D3D_TESSELLATOR_PARTITIONING;
+
+typedef 
+enum D3D_TESSELLATOR_OUTPUT_PRIMITIVE
+    {
+        D3D_TESSELLATOR_OUTPUT_UNDEFINED	= 0,
+        D3D_TESSELLATOR_OUTPUT_POINT	= 1,
+        D3D_TESSELLATOR_OUTPUT_LINE	= 2,
+        D3D_TESSELLATOR_OUTPUT_TRIANGLE_CW	= 3,
+        D3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW	= 4,
+        D3D11_TESSELLATOR_OUTPUT_UNDEFINED	= D3D_TESSELLATOR_OUTPUT_UNDEFINED,
+        D3D11_TESSELLATOR_OUTPUT_POINT	= D3D_TESSELLATOR_OUTPUT_POINT,
+        D3D11_TESSELLATOR_OUTPUT_LINE	= D3D_TESSELLATOR_OUTPUT_LINE,
+        D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CW	= D3D_TESSELLATOR_OUTPUT_TRIANGLE_CW,
+        D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CCW	= D3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW
+    } 	D3D_TESSELLATOR_OUTPUT_PRIMITIVE;
+
+typedef 
+enum D3D_MIN_PRECISION
+    {
+        D3D_MIN_PRECISION_DEFAULT	= 0,
+        D3D_MIN_PRECISION_FLOAT_16	= 1,
+        D3D_MIN_PRECISION_FLOAT_2_8	= 2,
+        D3D_MIN_PRECISION_RESERVED	= 3,
+        D3D_MIN_PRECISION_SINT_16	= 4,
+        D3D_MIN_PRECISION_UINT_16	= 5,
+        D3D_MIN_PRECISION_ANY_16	= 0xf0,
+        D3D_MIN_PRECISION_ANY_10	= 0xf1
+    } 	D3D_MIN_PRECISION;
+
+typedef 
+enum D3D_INTERPOLATION_MODE
+    {
+        D3D_INTERPOLATION_UNDEFINED	= 0,
+        D3D_INTERPOLATION_CONSTANT	= 1,
+        D3D_INTERPOLATION_LINEAR	= 2,
+        D3D_INTERPOLATION_LINEAR_CENTROID	= 3,
+        D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE	= 4,
+        D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE_CENTROID	= 5,
+        D3D_INTERPOLATION_LINEAR_SAMPLE	= 6,
+        D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE_SAMPLE	= 7
+    } 	D3D_INTERPOLATION_MODE;
+
+typedef 
+enum _D3D_PARAMETER_FLAGS
+    {
+        D3D_PF_NONE	= 0,
+        D3D_PF_IN	= 0x1,
+        D3D_PF_OUT	= 0x2,
+        D3D_PF_FORCE_DWORD	= 0x7fffffff
+    } 	D3D_PARAMETER_FLAGS;
+
+DEFINE_GUID(WKPDID_D3DDebugObjectName,0x429b8c22,0x9188,0x4b0c,0x87,0x42,0xac,0xb0,0xbf,0x85,0xc2,0x00);
+DEFINE_GUID(WKPDID_D3DDebugObjectNameW,0x4cca5fd8,0x921f,0x42c8,0x85,0x66,0x70,0xca,0xf2,0xa9,0xb7,0x41);
+DEFINE_GUID(WKPDID_CommentStringW,0xd0149dc0,0x90e8,0x4ec8,0x81, 0x44, 0xe9, 0x00, 0xad, 0x26, 0x6b, 0xb2);
+#define D3D_SET_OBJECT_NAME_N_A(pObject, Chars, pName) (pObject)->SetPrivateData(WKPDID_D3DDebugObjectName, Chars, pName)
+#define D3D_SET_OBJECT_NAME_A(pObject, pName) D3D_SET_OBJECT_NAME_N_A(pObject, lstrlenA(pName), pName)
+#define D3D_SET_OBJECT_NAME_N_W(pObject, Chars, pName) (pObject)->SetPrivateData(WKPDID_D3DDebugObjectNameW, Chars*2, pName)
+#define D3D_SET_OBJECT_NAME_W(pObject, pName) D3D_SET_OBJECT_NAME_N_W(pObject, wcslen(pName), pName)
+#define D3D_COMPONENT_MASK_X   1
+#define D3D_COMPONENT_MASK_Y   2
+#define D3D_COMPONENT_MASK_Z   4
+#define D3D_COMPONENT_MASK_W   8
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0001_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0001_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+

3rdparty/bgfx/3rdparty/dxsdk/include/d3dcompiler.h

@@ -0,0 +1,556 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+//  File:       D3DCompiler.h
+//  Content:    D3D Compilation Types and APIs
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef __D3DCOMPILER_H__
+#define __D3DCOMPILER_H__
+
+
+// Current name of the DLL shipped in the same SDK as this header.
+
+
+
+#define D3DCOMPILER_DLL_W L"d3dcompiler_47.dll"
+#define D3DCOMPILER_DLL_A "d3dcompiler_47.dll"
+
+// Current HLSL compiler version.
+
+#define D3D_COMPILER_VERSION 47
+
+#ifdef UNICODE
+    #define D3DCOMPILER_DLL D3DCOMPILER_DLL_W 
+#else
+    #define D3DCOMPILER_DLL D3DCOMPILER_DLL_A
+#endif
+
+#include "d3d11shader.h"
+#include "d3d12shader.h"
+
+//////////////////////////////////////////////////////////////////////////////
+// APIs //////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+
+
+//----------------------------------------------------------------------------
+// D3DReadFileToBlob:
+// -----------------
+// Simple helper routine to read a file on disk into memory
+// for passing to other routines in this API.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+D3DReadFileToBlob(_In_ LPCWSTR pFileName,
+                  _Out_ ID3DBlob** ppContents);
+
+//----------------------------------------------------------------------------
+// D3DWriteBlobToFile:
+// ------------------
+// Simple helper routine to write a memory blob to a file on disk.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+D3DWriteBlobToFile(_In_ ID3DBlob* pBlob,
+                   _In_ LPCWSTR pFileName,
+                   _In_ BOOL bOverwrite);
+
+//----------------------------------------------------------------------------
+// D3DCOMPILE flags:
+// -----------------
+// D3DCOMPILE_DEBUG
+//   Insert debug file/line/type/symbol information.
+//
+// D3DCOMPILE_SKIP_VALIDATION
+//   Do not validate the generated code against known capabilities and
+//   constraints.  This option is only recommended when compiling shaders
+//   you KNOW will work.  (ie. have compiled before without this option.)
+//   Shaders are always validated by D3D before they are set to the device.
+//
+// D3DCOMPILE_SKIP_OPTIMIZATION 
+//   Instructs the compiler to skip optimization steps during code generation.
+//   Unless you are trying to isolate a problem in your code using this option 
+//   is not recommended.
+//
+// D3DCOMPILE_PACK_MATRIX_ROW_MAJOR
+//   Unless explicitly specified, matrices will be packed in row-major order
+//   on input and output from the shader.
+//
+// D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR
+//   Unless explicitly specified, matrices will be packed in column-major 
+//   order on input and output from the shader.  This is generally more 
+//   efficient, since it allows vector-matrix multiplication to be performed
+//   using a series of dot-products.
+//
+// D3DCOMPILE_PARTIAL_PRECISION
+//   Force all computations in resulting shader to occur at partial precision.
+//   This may result in faster evaluation of shaders on some hardware.
+//
+// D3DCOMPILE_FORCE_VS_SOFTWARE_NO_OPT
+//   Force compiler to compile against the next highest available software
+//   target for vertex shaders.  This flag also turns optimizations off, 
+//   and debugging on.  
+//
+// D3DCOMPILE_FORCE_PS_SOFTWARE_NO_OPT
+//   Force compiler to compile against the next highest available software
+//   target for pixel shaders.  This flag also turns optimizations off, 
+//   and debugging on.
+//
+// D3DCOMPILE_NO_PRESHADER
+//   Disables Preshaders. Using this flag will cause the compiler to not 
+//   pull out static expression for evaluation on the host cpu
+//
+// D3DCOMPILE_AVOID_FLOW_CONTROL
+//   Hint compiler to avoid flow-control constructs where possible.
+//
+// D3DCOMPILE_PREFER_FLOW_CONTROL
+//   Hint compiler to prefer flow-control constructs where possible.
+//
+// D3DCOMPILE_ENABLE_STRICTNESS
+//   By default, the HLSL/Effect compilers are not strict on deprecated syntax.
+//   Specifying this flag enables the strict mode. Deprecated syntax may be
+//   removed in a future release, and enabling syntax is a good way to make
+//   sure your shaders comply to the latest spec.
+//
+// D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY
+//   This enables older shaders to compile to 4_0 targets.
+//
+//----------------------------------------------------------------------------
+
+#define D3DCOMPILE_DEBUG                                (1 << 0)
+#define D3DCOMPILE_SKIP_VALIDATION                      (1 << 1)
+#define D3DCOMPILE_SKIP_OPTIMIZATION                    (1 << 2)
+#define D3DCOMPILE_PACK_MATRIX_ROW_MAJOR                (1 << 3)
+#define D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR             (1 << 4)
+#define D3DCOMPILE_PARTIAL_PRECISION                    (1 << 5)
+#define D3DCOMPILE_FORCE_VS_SOFTWARE_NO_OPT             (1 << 6)
+#define D3DCOMPILE_FORCE_PS_SOFTWARE_NO_OPT             (1 << 7)
+#define D3DCOMPILE_NO_PRESHADER                         (1 << 8)
+#define D3DCOMPILE_AVOID_FLOW_CONTROL                   (1 << 9)
+#define D3DCOMPILE_PREFER_FLOW_CONTROL                  (1 << 10)
+#define D3DCOMPILE_ENABLE_STRICTNESS                    (1 << 11)
+#define D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY       (1 << 12)
+#define D3DCOMPILE_IEEE_STRICTNESS                      (1 << 13)
+#define D3DCOMPILE_OPTIMIZATION_LEVEL0                  (1 << 14)
+#define D3DCOMPILE_OPTIMIZATION_LEVEL1                  0
+#define D3DCOMPILE_OPTIMIZATION_LEVEL2                  ((1 << 14) | (1 << 15))
+#define D3DCOMPILE_OPTIMIZATION_LEVEL3                  (1 << 15)
+#define D3DCOMPILE_RESERVED16                           (1 << 16)
+#define D3DCOMPILE_RESERVED17                           (1 << 17)
+#define D3DCOMPILE_WARNINGS_ARE_ERRORS                  (1 << 18)
+#define D3DCOMPILE_RESOURCES_MAY_ALIAS                  (1 << 19)
+#define D3DCOMPILE_ENABLE_UNBOUNDED_DESCRIPTOR_TABLES   (1 << 20)
+#define D3DCOMPILE_ALL_RESOURCES_BOUND                  (1 << 21)
+
+//----------------------------------------------------------------------------
+// D3DCOMPILE_EFFECT flags:
+// -------------------------------------
+// These flags are passed in when creating an effect, and affect
+// either compilation behavior or runtime effect behavior
+//
+// D3DCOMPILE_EFFECT_CHILD_EFFECT
+//   Compile this .fx file to a child effect. Child effects have no
+//   initializers for any shared values as these are initialied in the
+//   master effect (pool).
+//
+// D3DCOMPILE_EFFECT_ALLOW_SLOW_OPS
+//   By default, performance mode is enabled.  Performance mode
+//   disallows mutable state objects by preventing non-literal
+//   expressions from appearing in state object definitions.
+//   Specifying this flag will disable the mode and allow for mutable
+//   state objects.
+//
+//----------------------------------------------------------------------------
+
+#define D3DCOMPILE_EFFECT_CHILD_EFFECT              (1 << 0)
+#define D3DCOMPILE_EFFECT_ALLOW_SLOW_OPS            (1 << 1)
+
+//----------------------------------------------------------------------------
+// D3DCompile:
+// ----------
+// Compile source text into bytecode appropriate for the given target.
+//----------------------------------------------------------------------------
+
+// D3D_COMPILE_STANDARD_FILE_INCLUDE can be passed for pInclude in any
+// API and indicates that a simple default include handler should be
+// used.  The include handler will include files relative to the
+// current directory and files relative to the directory of the initial source
+// file.  When used with APIs like D3DCompile pSourceName must be a
+// file name and the initial relative directory will be derived from it.
+#define D3D_COMPILE_STANDARD_FILE_INCLUDE ((ID3DInclude*)(UINT_PTR)1)
+
+HRESULT WINAPI
+D3DCompile(_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
+           _In_ SIZE_T SrcDataSize,
+           _In_opt_ LPCSTR pSourceName,
+           _In_reads_opt_(_Inexpressible_(pDefines->Name != NULL)) CONST D3D_SHADER_MACRO* pDefines,
+           _In_opt_ ID3DInclude* pInclude,
+           _In_opt_ LPCSTR pEntrypoint,
+           _In_ LPCSTR pTarget,
+           _In_ UINT Flags1,
+           _In_ UINT Flags2,
+           _Out_ ID3DBlob** ppCode,
+           _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorMsgs);
+
+typedef HRESULT (WINAPI *pD3DCompile)
+    (LPCVOID                         pSrcData,
+     SIZE_T                          SrcDataSize,
+     LPCSTR                          pFileName,
+     CONST D3D_SHADER_MACRO*         pDefines,
+     ID3DInclude*                    pInclude,
+     LPCSTR                          pEntrypoint,
+     LPCSTR                          pTarget,
+     UINT                            Flags1,
+     UINT                            Flags2,
+     ID3DBlob**                      ppCode,
+     ID3DBlob**                      ppErrorMsgs);
+
+#define D3DCOMPILE_SECDATA_MERGE_UAV_SLOTS              0x00000001
+#define D3DCOMPILE_SECDATA_PRESERVE_TEMPLATE_SLOTS      0x00000002
+#define D3DCOMPILE_SECDATA_REQUIRE_TEMPLATE_MATCH       0x00000004
+
+HRESULT WINAPI
+D3DCompile2(_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
+            _In_ SIZE_T SrcDataSize,
+            _In_opt_ LPCSTR pSourceName,
+            _In_reads_opt_(_Inexpressible_(pDefines->Name != NULL)) CONST D3D_SHADER_MACRO* pDefines,
+            _In_opt_ ID3DInclude* pInclude,
+            _In_ LPCSTR pEntrypoint,
+            _In_ LPCSTR pTarget,
+            _In_ UINT Flags1,
+            _In_ UINT Flags2,
+            _In_ UINT SecondaryDataFlags,
+            _In_reads_bytes_opt_(SecondaryDataSize) LPCVOID pSecondaryData,
+            _In_ SIZE_T SecondaryDataSize,
+            _Out_ ID3DBlob** ppCode,
+            _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorMsgs);
+
+HRESULT WINAPI
+D3DCompileFromFile(_In_ LPCWSTR pFileName,
+                   _In_reads_opt_(_Inexpressible_(pDefines->Name != NULL)) CONST D3D_SHADER_MACRO* pDefines,
+                   _In_opt_ ID3DInclude* pInclude,
+                   _In_ LPCSTR pEntrypoint,
+                   _In_ LPCSTR pTarget,
+                   _In_ UINT Flags1,
+                   _In_ UINT Flags2,
+                   _Out_ ID3DBlob** ppCode,
+                   _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorMsgs);
+
+//----------------------------------------------------------------------------
+// D3DPreprocess:
+// -------------
+// Process source text with the compiler's preprocessor and return
+// the resulting text.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+D3DPreprocess(_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
+              _In_ SIZE_T SrcDataSize,
+              _In_opt_ LPCSTR pSourceName,
+              _In_opt_ CONST D3D_SHADER_MACRO* pDefines,
+              _In_opt_ ID3DInclude* pInclude,
+              _Out_ ID3DBlob** ppCodeText,
+              _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorMsgs);
+
+typedef HRESULT (WINAPI *pD3DPreprocess)
+    (LPCVOID                      pSrcData,
+     SIZE_T                       SrcDataSize,
+     LPCSTR                       pFileName,
+     CONST D3D_SHADER_MACRO*      pDefines,
+     ID3DInclude*                 pInclude,
+     ID3DBlob**                   ppCodeText,
+     ID3DBlob**                   ppErrorMsgs);
+
+//----------------------------------------------------------------------------
+// D3DGetDebugInfo:
+// -----------------------
+// Gets shader debug info.  Debug info is generated by D3DCompile and is
+// embedded in the body of the shader.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+D3DGetDebugInfo(_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
+                _In_ SIZE_T SrcDataSize,
+                _Out_ ID3DBlob** ppDebugInfo);
+
+//----------------------------------------------------------------------------
+// D3DReflect:
+// ----------
+// Shader code contains metadata that can be inspected via the
+// reflection APIs.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+D3DReflect(_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
+           _In_ SIZE_T SrcDataSize,
+           _In_ REFIID pInterface,
+           _Out_ void** ppReflector);
+
+//----------------------------------------------------------------------------
+// D3DReflectLibrary:
+// ----------
+// Library code contains metadata that can be inspected via the library
+// reflection APIs.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+D3DReflectLibrary(__in_bcount(SrcDataSize) LPCVOID pSrcData,
+                  __in SIZE_T SrcDataSize,
+	              __in REFIID riid,
+                  __out LPVOID * ppReflector);
+
+//----------------------------------------------------------------------------
+// D3DDisassemble:
+// ----------------------
+// Takes a binary shader and returns a buffer containing text assembly.
+//----------------------------------------------------------------------------
+
+#define D3D_DISASM_ENABLE_COLOR_CODE            0x00000001
+#define D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTS  0x00000002
+#define D3D_DISASM_ENABLE_INSTRUCTION_NUMBERING 0x00000004
+#define D3D_DISASM_ENABLE_INSTRUCTION_CYCLE     0x00000008
+#define D3D_DISASM_DISABLE_DEBUG_INFO           0x00000010
+#define D3D_DISASM_ENABLE_INSTRUCTION_OFFSET    0x00000020
+#define D3D_DISASM_INSTRUCTION_ONLY             0x00000040
+#define D3D_DISASM_PRINT_HEX_LITERALS           0x00000080
+
+HRESULT WINAPI
+D3DDisassemble(_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
+               _In_ SIZE_T SrcDataSize,
+               _In_ UINT Flags,
+               _In_opt_ LPCSTR szComments,
+               _Out_ ID3DBlob** ppDisassembly);
+
+typedef HRESULT (WINAPI *pD3DDisassemble)
+    (_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
+     _In_ SIZE_T SrcDataSize,
+     _In_ UINT Flags,
+     _In_opt_ LPCSTR szComments,
+     _Out_ ID3DBlob** ppDisassembly);
+
+HRESULT WINAPI
+D3DDisassembleRegion(_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
+                     _In_ SIZE_T SrcDataSize,
+                     _In_ UINT Flags,
+                     _In_opt_ LPCSTR szComments,
+                     _In_ SIZE_T StartByteOffset,
+                     _In_ SIZE_T NumInsts,
+                     _Out_opt_ SIZE_T* pFinishByteOffset,
+                     _Out_ ID3DBlob** ppDisassembly);
+    
+//----------------------------------------------------------------------------
+// Shader linking and Function Linking Graph (FLG) APIs
+//----------------------------------------------------------------------------
+HRESULT WINAPI
+D3DCreateLinker(__out interface ID3D11Linker ** ppLinker);
+
+HRESULT WINAPI
+D3DLoadModule(_In_ LPCVOID pSrcData,
+              _In_ SIZE_T cbSrcDataSize,
+              _Out_ interface ID3D11Module ** ppModule);
+
+HRESULT WINAPI
+D3DCreateFunctionLinkingGraph(_In_ UINT uFlags,
+                              _Out_ interface ID3D11FunctionLinkingGraph ** ppFunctionLinkingGraph);
+
+//----------------------------------------------------------------------------
+// D3DGetTraceInstructionOffsets:
+// -----------------------
+// Determines byte offsets for instructions within a shader blob.
+// This information is useful for going between trace instruction
+// indices and byte offsets that are used in debug information.
+//----------------------------------------------------------------------------
+
+#define D3D_GET_INST_OFFSETS_INCLUDE_NON_EXECUTABLE 0x00000001
+
+HRESULT WINAPI
+D3DGetTraceInstructionOffsets(_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
+                              _In_ SIZE_T SrcDataSize,
+                              _In_ UINT Flags,
+                              _In_ SIZE_T StartInstIndex,
+                              _In_ SIZE_T NumInsts,
+                              _Out_writes_to_opt_(NumInsts, min(NumInsts, *pTotalInsts)) SIZE_T* pOffsets,
+                              _Out_opt_ SIZE_T* pTotalInsts);
+
+//----------------------------------------------------------------------------
+// D3DGetInputSignatureBlob:
+// -----------------------
+// Retrieve the input signature from a compilation result.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+D3DGetInputSignatureBlob(_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
+                         _In_ SIZE_T SrcDataSize,
+                         _Out_ ID3DBlob** ppSignatureBlob);
+
+//----------------------------------------------------------------------------
+// D3DGetOutputSignatureBlob:
+// -----------------------
+// Retrieve the output signature from a compilation result.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+D3DGetOutputSignatureBlob(_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
+                          _In_ SIZE_T SrcDataSize,
+                          _Out_ ID3DBlob** ppSignatureBlob);
+
+//----------------------------------------------------------------------------
+// D3DGetInputAndOutputSignatureBlob:
+// -----------------------
+// Retrieve the input and output signatures from a compilation result.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+D3DGetInputAndOutputSignatureBlob(_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
+                                  _In_ SIZE_T SrcDataSize,
+                                  _Out_ ID3DBlob** ppSignatureBlob);
+
+//----------------------------------------------------------------------------
+// D3DStripShader:
+// -----------------------
+// Removes unwanted blobs from a compilation result
+//----------------------------------------------------------------------------
+
+typedef enum D3DCOMPILER_STRIP_FLAGS
+{
+    D3DCOMPILER_STRIP_REFLECTION_DATA       = 0x00000001,
+    D3DCOMPILER_STRIP_DEBUG_INFO            = 0x00000002,
+    D3DCOMPILER_STRIP_TEST_BLOBS            = 0x00000004,
+    D3DCOMPILER_STRIP_PRIVATE_DATA          = 0x00000008,
+    D3DCOMPILER_STRIP_ROOT_SIGNATURE        = 0x00000010,
+    D3DCOMPILER_STRIP_FORCE_DWORD           = 0x7fffffff,
+} D3DCOMPILER_STRIP_FLAGS;
+
+HRESULT WINAPI
+D3DStripShader(_In_reads_bytes_(BytecodeLength) LPCVOID pShaderBytecode,
+               _In_ SIZE_T BytecodeLength,
+               _In_ UINT uStripFlags,
+               _Out_ ID3DBlob** ppStrippedBlob);
+
+//----------------------------------------------------------------------------
+// D3DGetBlobPart:
+// -----------------------
+// Extracts information from a compilation result.
+//----------------------------------------------------------------------------
+
+typedef enum D3D_BLOB_PART
+{
+    D3D_BLOB_INPUT_SIGNATURE_BLOB,
+    D3D_BLOB_OUTPUT_SIGNATURE_BLOB,
+    D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB,
+    D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB,
+    D3D_BLOB_ALL_SIGNATURE_BLOB,
+    D3D_BLOB_DEBUG_INFO,
+    D3D_BLOB_LEGACY_SHADER,
+    D3D_BLOB_XNA_PREPASS_SHADER,
+    D3D_BLOB_XNA_SHADER,
+    D3D_BLOB_PDB,
+    D3D_BLOB_PRIVATE_DATA,
+    D3D_BLOB_ROOT_SIGNATURE,
+
+    // Test parts are only produced by special compiler versions and so
+    // are usually not present in shaders.
+    D3D_BLOB_TEST_ALTERNATE_SHADER = 0x8000,
+    D3D_BLOB_TEST_COMPILE_DETAILS,
+    D3D_BLOB_TEST_COMPILE_PERF,
+    D3D_BLOB_TEST_COMPILE_REPORT,
+} D3D_BLOB_PART;
+
+HRESULT WINAPI 
+D3DGetBlobPart(_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
+               _In_ SIZE_T SrcDataSize,
+               _In_ D3D_BLOB_PART Part,
+               _In_ UINT Flags,
+               _Out_ ID3DBlob** ppPart);
+
+//----------------------------------------------------------------------------
+// D3DSetBlobPart:
+// -----------------------
+// Update information in a compilation result.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI 
+D3DSetBlobPart(_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
+               _In_ SIZE_T SrcDataSize,
+               _In_ D3D_BLOB_PART Part,
+               _In_ UINT Flags,
+               _In_reads_bytes_(PartSize) LPCVOID pPart,
+               _In_ SIZE_T PartSize,
+               _Out_ ID3DBlob** ppNewShader);
+
+//----------------------------------------------------------------------------
+// D3DCreateBlob:
+// -----------------------
+// Create an ID3DBlob instance.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+D3DCreateBlob(_In_ SIZE_T Size,
+              _Out_ ID3DBlob** ppBlob);
+
+//----------------------------------------------------------------------------
+// D3DCompressShaders:
+// -----------------------
+// Compresses a set of shaders into a more compact form.
+//----------------------------------------------------------------------------
+
+typedef struct _D3D_SHADER_DATA
+{
+    LPCVOID pBytecode;
+    SIZE_T BytecodeLength;
+} D3D_SHADER_DATA;
+
+#define D3D_COMPRESS_SHADER_KEEP_ALL_PARTS 0x00000001
+
+HRESULT WINAPI
+D3DCompressShaders(_In_ UINT uNumShaders,
+                   _In_reads_(uNumShaders) D3D_SHADER_DATA* pShaderData,
+                   _In_ UINT uFlags,
+                   _Out_ ID3DBlob** ppCompressedData);
+
+//----------------------------------------------------------------------------
+// D3DDecompressShaders:
+// -----------------------
+// Decompresses one or more shaders from a compressed set.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+D3DDecompressShaders(_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
+                     _In_ SIZE_T SrcDataSize,
+                     _In_ UINT uNumShaders,	      
+                     _In_ UINT uStartIndex,
+                     _In_reads_opt_(uNumShaders) UINT* pIndices,
+                     _In_ UINT uFlags,
+                     _Out_writes_(uNumShaders) ID3DBlob** ppShaders,
+                     _Out_opt_ UINT* pTotalShaders);
+
+
+
+
+//----------------------------------------------------------------------------
+// D3DDisassemble10Effect:
+// -----------------------
+// Takes a D3D10 effect interface and returns a
+// buffer containing text assembly.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+D3DDisassemble10Effect(_In_ interface ID3D10Effect *pEffect, 
+                       _In_ UINT Flags,
+                       _Out_ ID3DBlob** ppDisassembly);
+
+
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+    
+#endif // #ifndef __D3DCOMPILER_H__

3rdparty/bgfx/3rdparty/dxsdk/include/dxgidebug.h

@@ -0,0 +1,986 @@
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 8.00.0613 */
+/* @@MIDL_FILE_HEADING(  ) */
+
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif /* __RPCNDR_H_VERSION__ */
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#ifndef __dxgidebug_h__
+#define __dxgidebug_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+/* Forward Declarations */ 
+
+#ifndef __IDXGIInfoQueue_FWD_DEFINED__
+#define __IDXGIInfoQueue_FWD_DEFINED__
+typedef interface IDXGIInfoQueue IDXGIInfoQueue;
+
+#endif 	/* __IDXGIInfoQueue_FWD_DEFINED__ */
+
+
+#ifndef __IDXGIDebug_FWD_DEFINED__
+#define __IDXGIDebug_FWD_DEFINED__
+typedef interface IDXGIDebug IDXGIDebug;
+
+#endif 	/* __IDXGIDebug_FWD_DEFINED__ */
+
+
+#ifndef __IDXGIDebug1_FWD_DEFINED__
+#define __IDXGIDebug1_FWD_DEFINED__
+typedef interface IDXGIDebug1 IDXGIDebug1;
+
+#endif 	/* __IDXGIDebug1_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_dxgidebug_0000_0000 */
+/* [local] */ 
+
+#define	DXGI_DEBUG_BINARY_VERSION	( 1 )
+
+typedef 
+enum DXGI_DEBUG_RLO_FLAGS
+    {
+        DXGI_DEBUG_RLO_SUMMARY	= 0x1,
+        DXGI_DEBUG_RLO_DETAIL	= 0x2,
+        DXGI_DEBUG_RLO_IGNORE_INTERNAL	= 0x4,
+        DXGI_DEBUG_RLO_ALL	= 0x7
+    } 	DXGI_DEBUG_RLO_FLAGS;
+
+typedef GUID DXGI_DEBUG_ID;
+
+DEFINE_GUID(DXGI_DEBUG_ALL, 0xe48ae283, 0xda80, 0x490b, 0x87, 0xe6, 0x43, 0xe9, 0xa9, 0xcf, 0xda, 0x8);
+DEFINE_GUID(DXGI_DEBUG_DX, 0x35cdd7fc, 0x13b2, 0x421d, 0xa5, 0xd7, 0x7e, 0x44, 0x51, 0x28, 0x7d, 0x64);
+DEFINE_GUID(DXGI_DEBUG_DXGI, 0x25cddaa4, 0xb1c6, 0x47e1, 0xac, 0x3e, 0x98, 0x87, 0x5b, 0x5a, 0x2e, 0x2a);
+DEFINE_GUID(DXGI_DEBUG_APP, 0x6cd6e01, 0x4219, 0x4ebd, 0x87, 0x9, 0x27, 0xed, 0x23, 0x36, 0xc, 0x62);
+typedef 
+enum DXGI_INFO_QUEUE_MESSAGE_CATEGORY
+    {
+        DXGI_INFO_QUEUE_MESSAGE_CATEGORY_UNKNOWN	= 0,
+        DXGI_INFO_QUEUE_MESSAGE_CATEGORY_MISCELLANEOUS	= ( DXGI_INFO_QUEUE_MESSAGE_CATEGORY_UNKNOWN + 1 ) ,
+        DXGI_INFO_QUEUE_MESSAGE_CATEGORY_INITIALIZATION	= ( DXGI_INFO_QUEUE_MESSAGE_CATEGORY_MISCELLANEOUS + 1 ) ,
+        DXGI_INFO_QUEUE_MESSAGE_CATEGORY_CLEANUP	= ( DXGI_INFO_QUEUE_MESSAGE_CATEGORY_INITIALIZATION + 1 ) ,
+        DXGI_INFO_QUEUE_MESSAGE_CATEGORY_COMPILATION	= ( DXGI_INFO_QUEUE_MESSAGE_CATEGORY_CLEANUP + 1 ) ,
+        DXGI_INFO_QUEUE_MESSAGE_CATEGORY_STATE_CREATION	= ( DXGI_INFO_QUEUE_MESSAGE_CATEGORY_COMPILATION + 1 ) ,
+        DXGI_INFO_QUEUE_MESSAGE_CATEGORY_STATE_SETTING	= ( DXGI_INFO_QUEUE_MESSAGE_CATEGORY_STATE_CREATION + 1 ) ,
+        DXGI_INFO_QUEUE_MESSAGE_CATEGORY_STATE_GETTING	= ( DXGI_INFO_QUEUE_MESSAGE_CATEGORY_STATE_SETTING + 1 ) ,
+        DXGI_INFO_QUEUE_MESSAGE_CATEGORY_RESOURCE_MANIPULATION	= ( DXGI_INFO_QUEUE_MESSAGE_CATEGORY_STATE_GETTING + 1 ) ,
+        DXGI_INFO_QUEUE_MESSAGE_CATEGORY_EXECUTION	= ( DXGI_INFO_QUEUE_MESSAGE_CATEGORY_RESOURCE_MANIPULATION + 1 ) ,
+        DXGI_INFO_QUEUE_MESSAGE_CATEGORY_SHADER	= ( DXGI_INFO_QUEUE_MESSAGE_CATEGORY_EXECUTION + 1 ) 
+    } 	DXGI_INFO_QUEUE_MESSAGE_CATEGORY;
+
+typedef 
+enum DXGI_INFO_QUEUE_MESSAGE_SEVERITY
+    {
+        DXGI_INFO_QUEUE_MESSAGE_SEVERITY_CORRUPTION	= 0,
+        DXGI_INFO_QUEUE_MESSAGE_SEVERITY_ERROR	= ( DXGI_INFO_QUEUE_MESSAGE_SEVERITY_CORRUPTION + 1 ) ,
+        DXGI_INFO_QUEUE_MESSAGE_SEVERITY_WARNING	= ( DXGI_INFO_QUEUE_MESSAGE_SEVERITY_ERROR + 1 ) ,
+        DXGI_INFO_QUEUE_MESSAGE_SEVERITY_INFO	= ( DXGI_INFO_QUEUE_MESSAGE_SEVERITY_WARNING + 1 ) ,
+        DXGI_INFO_QUEUE_MESSAGE_SEVERITY_MESSAGE	= ( DXGI_INFO_QUEUE_MESSAGE_SEVERITY_INFO + 1 ) 
+    } 	DXGI_INFO_QUEUE_MESSAGE_SEVERITY;
+
+typedef int DXGI_INFO_QUEUE_MESSAGE_ID;
+
+#define DXGI_INFO_QUEUE_MESSAGE_ID_STRING_FROM_APPLICATION 0
+typedef struct DXGI_INFO_QUEUE_MESSAGE
+    {
+    DXGI_DEBUG_ID Producer;
+    DXGI_INFO_QUEUE_MESSAGE_CATEGORY Category;
+    DXGI_INFO_QUEUE_MESSAGE_SEVERITY Severity;
+    DXGI_INFO_QUEUE_MESSAGE_ID ID;
+    /* [annotation] */ 
+    _Field_size_(DescriptionByteLength)  const char *pDescription;
+    SIZE_T DescriptionByteLength;
+    } 	DXGI_INFO_QUEUE_MESSAGE;
+
+typedef struct DXGI_INFO_QUEUE_FILTER_DESC
+    {
+    UINT NumCategories;
+    /* [annotation] */ 
+    _Field_size_(NumCategories)  DXGI_INFO_QUEUE_MESSAGE_CATEGORY *pCategoryList;
+    UINT NumSeverities;
+    /* [annotation] */ 
+    _Field_size_(NumSeverities)  DXGI_INFO_QUEUE_MESSAGE_SEVERITY *pSeverityList;
+    UINT NumIDs;
+    /* [annotation] */ 
+    _Field_size_(NumIDs)  DXGI_INFO_QUEUE_MESSAGE_ID *pIDList;
+    } 	DXGI_INFO_QUEUE_FILTER_DESC;
+
+typedef struct DXGI_INFO_QUEUE_FILTER
+    {
+    DXGI_INFO_QUEUE_FILTER_DESC AllowList;
+    DXGI_INFO_QUEUE_FILTER_DESC DenyList;
+    } 	DXGI_INFO_QUEUE_FILTER;
+
+#define DXGI_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT 1024
+HRESULT WINAPI DXGIGetDebugInterface(REFIID riid, void **ppDebug);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_dxgidebug_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_dxgidebug_0000_0000_v0_0_s_ifspec;
+
+#ifndef __IDXGIInfoQueue_INTERFACE_DEFINED__
+#define __IDXGIInfoQueue_INTERFACE_DEFINED__
+
+/* interface IDXGIInfoQueue */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_IDXGIInfoQueue;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("D67441C7-672A-476f-9E82-CD55B44949CE")
+    IDXGIInfoQueue : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE SetMessageCountLimit( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  UINT64 MessageCountLimit) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearStoredMessages( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetMessage( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  UINT64 MessageIndex,
+            /* [annotation] */ 
+            _Out_writes_bytes_opt_(*pMessageByteLength)  DXGI_INFO_QUEUE_MESSAGE *pMessage,
+            /* [annotation] */ 
+            _Inout_  SIZE_T *pMessageByteLength) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetNumStoredMessagesAllowedByRetrievalFilters( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetNumStoredMessages( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetNumMessagesDiscardedByMessageCountLimit( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetMessageCountLimit( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetNumMessagesAllowedByStorageFilter( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetNumMessagesDeniedByStorageFilter( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE AddStorageFilterEntries( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_FILTER *pFilter) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetStorageFilter( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _Out_writes_bytes_opt_(*pFilterByteLength)  DXGI_INFO_QUEUE_FILTER *pFilter,
+            /* [annotation] */ 
+            _Inout_  SIZE_T *pFilterByteLength) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearStorageFilter( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushEmptyStorageFilter( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushDenyAllStorageFilter( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushCopyOfStorageFilter( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushStorageFilter( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_FILTER *pFilter) = 0;
+        
+        virtual void STDMETHODCALLTYPE PopStorageFilter( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual UINT STDMETHODCALLTYPE GetStorageFilterStackSize( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE AddRetrievalFilterEntries( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_FILTER *pFilter) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetRetrievalFilter( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _Out_writes_bytes_opt_(*pFilterByteLength)  DXGI_INFO_QUEUE_FILTER *pFilter,
+            /* [annotation] */ 
+            _Inout_  SIZE_T *pFilterByteLength) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearRetrievalFilter( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushEmptyRetrievalFilter( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushDenyAllRetrievalFilter( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushCopyOfRetrievalFilter( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushRetrievalFilter( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_FILTER *pFilter) = 0;
+        
+        virtual void STDMETHODCALLTYPE PopRetrievalFilter( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual UINT STDMETHODCALLTYPE GetRetrievalFilterStackSize( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE AddMessage( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_CATEGORY Category,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_SEVERITY Severity,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_ID ID,
+            /* [annotation] */ 
+            _In_  LPCSTR pDescription) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE AddApplicationMessage( 
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_SEVERITY Severity,
+            /* [annotation] */ 
+            _In_  LPCSTR pDescription) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetBreakOnCategory( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_CATEGORY Category,
+            /* [annotation] */ 
+            _In_  BOOL bEnable) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetBreakOnSeverity( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_SEVERITY Severity,
+            /* [annotation] */ 
+            _In_  BOOL bEnable) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetBreakOnID( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_ID ID,
+            /* [annotation] */ 
+            _In_  BOOL bEnable) = 0;
+        
+        virtual BOOL STDMETHODCALLTYPE GetBreakOnCategory( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_CATEGORY Category) = 0;
+        
+        virtual BOOL STDMETHODCALLTYPE GetBreakOnSeverity( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_SEVERITY Severity) = 0;
+        
+        virtual BOOL STDMETHODCALLTYPE GetBreakOnID( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_ID ID) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetMuteDebugOutput( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  BOOL bMute) = 0;
+        
+        virtual BOOL STDMETHODCALLTYPE GetMuteDebugOutput( 
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct IDXGIInfoQueueVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDXGIInfoQueue * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDXGIInfoQueue * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDXGIInfoQueue * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetMessageCountLimit )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  UINT64 MessageCountLimit);
+        
+        void ( STDMETHODCALLTYPE *ClearStoredMessages )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetMessage )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  UINT64 MessageIndex,
+            /* [annotation] */ 
+            _Out_writes_bytes_opt_(*pMessageByteLength)  DXGI_INFO_QUEUE_MESSAGE *pMessage,
+            /* [annotation] */ 
+            _Inout_  SIZE_T *pMessageByteLength);
+        
+        UINT64 ( STDMETHODCALLTYPE *GetNumStoredMessagesAllowedByRetrievalFilters )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        UINT64 ( STDMETHODCALLTYPE *GetNumStoredMessages )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesDiscardedByMessageCountLimit )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        UINT64 ( STDMETHODCALLTYPE *GetMessageCountLimit )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesAllowedByStorageFilter )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesDeniedByStorageFilter )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        HRESULT ( STDMETHODCALLTYPE *AddStorageFilterEntries )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_FILTER *pFilter);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetStorageFilter )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _Out_writes_bytes_opt_(*pFilterByteLength)  DXGI_INFO_QUEUE_FILTER *pFilter,
+            /* [annotation] */ 
+            _Inout_  SIZE_T *pFilterByteLength);
+        
+        void ( STDMETHODCALLTYPE *ClearStorageFilter )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        HRESULT ( STDMETHODCALLTYPE *PushEmptyStorageFilter )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        HRESULT ( STDMETHODCALLTYPE *PushDenyAllStorageFilter )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        HRESULT ( STDMETHODCALLTYPE *PushCopyOfStorageFilter )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        HRESULT ( STDMETHODCALLTYPE *PushStorageFilter )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_FILTER *pFilter);
+        
+        void ( STDMETHODCALLTYPE *PopStorageFilter )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        UINT ( STDMETHODCALLTYPE *GetStorageFilterStackSize )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        HRESULT ( STDMETHODCALLTYPE *AddRetrievalFilterEntries )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_FILTER *pFilter);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetRetrievalFilter )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _Out_writes_bytes_opt_(*pFilterByteLength)  DXGI_INFO_QUEUE_FILTER *pFilter,
+            /* [annotation] */ 
+            _Inout_  SIZE_T *pFilterByteLength);
+        
+        void ( STDMETHODCALLTYPE *ClearRetrievalFilter )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        HRESULT ( STDMETHODCALLTYPE *PushEmptyRetrievalFilter )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        HRESULT ( STDMETHODCALLTYPE *PushDenyAllRetrievalFilter )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        HRESULT ( STDMETHODCALLTYPE *PushCopyOfRetrievalFilter )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        HRESULT ( STDMETHODCALLTYPE *PushRetrievalFilter )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_FILTER *pFilter);
+        
+        void ( STDMETHODCALLTYPE *PopRetrievalFilter )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        UINT ( STDMETHODCALLTYPE *GetRetrievalFilterStackSize )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        HRESULT ( STDMETHODCALLTYPE *AddMessage )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_CATEGORY Category,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_SEVERITY Severity,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_ID ID,
+            /* [annotation] */ 
+            _In_  LPCSTR pDescription);
+        
+        HRESULT ( STDMETHODCALLTYPE *AddApplicationMessage )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_SEVERITY Severity,
+            /* [annotation] */ 
+            _In_  LPCSTR pDescription);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetBreakOnCategory )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_CATEGORY Category,
+            /* [annotation] */ 
+            _In_  BOOL bEnable);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetBreakOnSeverity )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_SEVERITY Severity,
+            /* [annotation] */ 
+            _In_  BOOL bEnable);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetBreakOnID )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_ID ID,
+            /* [annotation] */ 
+            _In_  BOOL bEnable);
+        
+        BOOL ( STDMETHODCALLTYPE *GetBreakOnCategory )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_CATEGORY Category);
+        
+        BOOL ( STDMETHODCALLTYPE *GetBreakOnSeverity )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_SEVERITY Severity);
+        
+        BOOL ( STDMETHODCALLTYPE *GetBreakOnID )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  DXGI_INFO_QUEUE_MESSAGE_ID ID);
+        
+        void ( STDMETHODCALLTYPE *SetMuteDebugOutput )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer,
+            /* [annotation] */ 
+            _In_  BOOL bMute);
+        
+        BOOL ( STDMETHODCALLTYPE *GetMuteDebugOutput )( 
+            IDXGIInfoQueue * This,
+            /* [annotation] */ 
+            _In_  DXGI_DEBUG_ID Producer);
+        
+        END_INTERFACE
+    } IDXGIInfoQueueVtbl;
+
+    interface IDXGIInfoQueue
+    {
+        CONST_VTBL struct IDXGIInfoQueueVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDXGIInfoQueue_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDXGIInfoQueue_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDXGIInfoQueue_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDXGIInfoQueue_SetMessageCountLimit(This,Producer,MessageCountLimit)	\
+    ( (This)->lpVtbl -> SetMessageCountLimit(This,Producer,MessageCountLimit) ) 
+
+#define IDXGIInfoQueue_ClearStoredMessages(This,Producer)	\
+    ( (This)->lpVtbl -> ClearStoredMessages(This,Producer) ) 
+
+#define IDXGIInfoQueue_GetMessage(This,Producer,MessageIndex,pMessage,pMessageByteLength)	\
+    ( (This)->lpVtbl -> GetMessage(This,Producer,MessageIndex,pMessage,pMessageByteLength) ) 
+
+#define IDXGIInfoQueue_GetNumStoredMessagesAllowedByRetrievalFilters(This,Producer)	\
+    ( (This)->lpVtbl -> GetNumStoredMessagesAllowedByRetrievalFilters(This,Producer) ) 
+
+#define IDXGIInfoQueue_GetNumStoredMessages(This,Producer)	\
+    ( (This)->lpVtbl -> GetNumStoredMessages(This,Producer) ) 
+
+#define IDXGIInfoQueue_GetNumMessagesDiscardedByMessageCountLimit(This,Producer)	\
+    ( (This)->lpVtbl -> GetNumMessagesDiscardedByMessageCountLimit(This,Producer) ) 
+
+#define IDXGIInfoQueue_GetMessageCountLimit(This,Producer)	\
+    ( (This)->lpVtbl -> GetMessageCountLimit(This,Producer) ) 
+
+#define IDXGIInfoQueue_GetNumMessagesAllowedByStorageFilter(This,Producer)	\
+    ( (This)->lpVtbl -> GetNumMessagesAllowedByStorageFilter(This,Producer) ) 
+
+#define IDXGIInfoQueue_GetNumMessagesDeniedByStorageFilter(This,Producer)	\
+    ( (This)->lpVtbl -> GetNumMessagesDeniedByStorageFilter(This,Producer) ) 
+
+#define IDXGIInfoQueue_AddStorageFilterEntries(This,Producer,pFilter)	\
+    ( (This)->lpVtbl -> AddStorageFilterEntries(This,Producer,pFilter) ) 
+
+#define IDXGIInfoQueue_GetStorageFilter(This,Producer,pFilter,pFilterByteLength)	\
+    ( (This)->lpVtbl -> GetStorageFilter(This,Producer,pFilter,pFilterByteLength) ) 
+
+#define IDXGIInfoQueue_ClearStorageFilter(This,Producer)	\
+    ( (This)->lpVtbl -> ClearStorageFilter(This,Producer) ) 
+
+#define IDXGIInfoQueue_PushEmptyStorageFilter(This,Producer)	\
+    ( (This)->lpVtbl -> PushEmptyStorageFilter(This,Producer) ) 
+
+#define IDXGIInfoQueue_PushDenyAllStorageFilter(This,Producer)	\
+    ( (This)->lpVtbl -> PushDenyAllStorageFilter(This,Producer) ) 
+
+#define IDXGIInfoQueue_PushCopyOfStorageFilter(This,Producer)	\
+    ( (This)->lpVtbl -> PushCopyOfStorageFilter(This,Producer) ) 
+
+#define IDXGIInfoQueue_PushStorageFilter(This,Producer,pFilter)	\
+    ( (This)->lpVtbl -> PushStorageFilter(This,Producer,pFilter) ) 
+
+#define IDXGIInfoQueue_PopStorageFilter(This,Producer)	\
+    ( (This)->lpVtbl -> PopStorageFilter(This,Producer) ) 
+
+#define IDXGIInfoQueue_GetStorageFilterStackSize(This,Producer)	\
+    ( (This)->lpVtbl -> GetStorageFilterStackSize(This,Producer) ) 
+
+#define IDXGIInfoQueue_AddRetrievalFilterEntries(This,Producer,pFilter)	\
+    ( (This)->lpVtbl -> AddRetrievalFilterEntries(This,Producer,pFilter) ) 
+
+#define IDXGIInfoQueue_GetRetrievalFilter(This,Producer,pFilter,pFilterByteLength)	\
+    ( (This)->lpVtbl -> GetRetrievalFilter(This,Producer,pFilter,pFilterByteLength) ) 
+
+#define IDXGIInfoQueue_ClearRetrievalFilter(This,Producer)	\
+    ( (This)->lpVtbl -> ClearRetrievalFilter(This,Producer) ) 
+
+#define IDXGIInfoQueue_PushEmptyRetrievalFilter(This,Producer)	\
+    ( (This)->lpVtbl -> PushEmptyRetrievalFilter(This,Producer) ) 
+
+#define IDXGIInfoQueue_PushDenyAllRetrievalFilter(This,Producer)	\
+    ( (This)->lpVtbl -> PushDenyAllRetrievalFilter(This,Producer) ) 
+
+#define IDXGIInfoQueue_PushCopyOfRetrievalFilter(This,Producer)	\
+    ( (This)->lpVtbl -> PushCopyOfRetrievalFilter(This,Producer) ) 
+
+#define IDXGIInfoQueue_PushRetrievalFilter(This,Producer,pFilter)	\
+    ( (This)->lpVtbl -> PushRetrievalFilter(This,Producer,pFilter) ) 
+
+#define IDXGIInfoQueue_PopRetrievalFilter(This,Producer)	\
+    ( (This)->lpVtbl -> PopRetrievalFilter(This,Producer) ) 
+
+#define IDXGIInfoQueue_GetRetrievalFilterStackSize(This,Producer)	\
+    ( (This)->lpVtbl -> GetRetrievalFilterStackSize(This,Producer) ) 
+
+#define IDXGIInfoQueue_AddMessage(This,Producer,Category,Severity,ID,pDescription)	\
+    ( (This)->lpVtbl -> AddMessage(This,Producer,Category,Severity,ID,pDescription) ) 
+
+#define IDXGIInfoQueue_AddApplicationMessage(This,Severity,pDescription)	\
+    ( (This)->lpVtbl -> AddApplicationMessage(This,Severity,pDescription) ) 
+
+#define IDXGIInfoQueue_SetBreakOnCategory(This,Producer,Category,bEnable)	\
+    ( (This)->lpVtbl -> SetBreakOnCategory(This,Producer,Category,bEnable) ) 
+
+#define IDXGIInfoQueue_SetBreakOnSeverity(This,Producer,Severity,bEnable)	\
+    ( (This)->lpVtbl -> SetBreakOnSeverity(This,Producer,Severity,bEnable) ) 
+
+#define IDXGIInfoQueue_SetBreakOnID(This,Producer,ID,bEnable)	\
+    ( (This)->lpVtbl -> SetBreakOnID(This,Producer,ID,bEnable) ) 
+
+#define IDXGIInfoQueue_GetBreakOnCategory(This,Producer,Category)	\
+    ( (This)->lpVtbl -> GetBreakOnCategory(This,Producer,Category) ) 
+
+#define IDXGIInfoQueue_GetBreakOnSeverity(This,Producer,Severity)	\
+    ( (This)->lpVtbl -> GetBreakOnSeverity(This,Producer,Severity) ) 
+
+#define IDXGIInfoQueue_GetBreakOnID(This,Producer,ID)	\
+    ( (This)->lpVtbl -> GetBreakOnID(This,Producer,ID) ) 
+
+#define IDXGIInfoQueue_SetMuteDebugOutput(This,Producer,bMute)	\
+    ( (This)->lpVtbl -> SetMuteDebugOutput(This,Producer,bMute) ) 
+
+#define IDXGIInfoQueue_GetMuteDebugOutput(This,Producer)	\
+    ( (This)->lpVtbl -> GetMuteDebugOutput(This,Producer) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDXGIInfoQueue_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDXGIDebug_INTERFACE_DEFINED__
+#define __IDXGIDebug_INTERFACE_DEFINED__
+
+/* interface IDXGIDebug */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_IDXGIDebug;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("119E7452-DE9E-40fe-8806-88F90C12B441")
+    IDXGIDebug : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE ReportLiveObjects( 
+            GUID apiid,
+            DXGI_DEBUG_RLO_FLAGS flags) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct IDXGIDebugVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDXGIDebug * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDXGIDebug * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDXGIDebug * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReportLiveObjects )( 
+            IDXGIDebug * This,
+            GUID apiid,
+            DXGI_DEBUG_RLO_FLAGS flags);
+        
+        END_INTERFACE
+    } IDXGIDebugVtbl;
+
+    interface IDXGIDebug
+    {
+        CONST_VTBL struct IDXGIDebugVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDXGIDebug_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDXGIDebug_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDXGIDebug_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDXGIDebug_ReportLiveObjects(This,apiid,flags)	\
+    ( (This)->lpVtbl -> ReportLiveObjects(This,apiid,flags) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDXGIDebug_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDXGIDebug1_INTERFACE_DEFINED__
+#define __IDXGIDebug1_INTERFACE_DEFINED__
+
+/* interface IDXGIDebug1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_IDXGIDebug1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("c5a05f0c-16f2-4adf-9f4d-a8c4d58ac550")
+    IDXGIDebug1 : public IDXGIDebug
+    {
+    public:
+        virtual void STDMETHODCALLTYPE EnableLeakTrackingForThread( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE DisableLeakTrackingForThread( void) = 0;
+        
+        virtual BOOL STDMETHODCALLTYPE IsLeakTrackingEnabledForThread( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct IDXGIDebug1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDXGIDebug1 * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDXGIDebug1 * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDXGIDebug1 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReportLiveObjects )( 
+            IDXGIDebug1 * This,
+            GUID apiid,
+            DXGI_DEBUG_RLO_FLAGS flags);
+        
+        void ( STDMETHODCALLTYPE *EnableLeakTrackingForThread )( 
+            IDXGIDebug1 * This);
+        
+        void ( STDMETHODCALLTYPE *DisableLeakTrackingForThread )( 
+            IDXGIDebug1 * This);
+        
+        BOOL ( STDMETHODCALLTYPE *IsLeakTrackingEnabledForThread )( 
+            IDXGIDebug1 * This);
+        
+        END_INTERFACE
+    } IDXGIDebug1Vtbl;
+
+    interface IDXGIDebug1
+    {
+        CONST_VTBL struct IDXGIDebug1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDXGIDebug1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDXGIDebug1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDXGIDebug1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDXGIDebug1_ReportLiveObjects(This,apiid,flags)	\
+    ( (This)->lpVtbl -> ReportLiveObjects(This,apiid,flags) ) 
+
+
+#define IDXGIDebug1_EnableLeakTrackingForThread(This)	\
+    ( (This)->lpVtbl -> EnableLeakTrackingForThread(This) ) 
+
+#define IDXGIDebug1_DisableLeakTrackingForThread(This)	\
+    ( (This)->lpVtbl -> DisableLeakTrackingForThread(This) ) 
+
+#define IDXGIDebug1_IsLeakTrackingEnabledForThread(This)	\
+    ( (This)->lpVtbl -> IsLeakTrackingEnabledForThread(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDXGIDebug1_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_dxgidebug_0000_0003 */
+/* [local] */ 
+
+DEFINE_GUID(IID_IDXGIInfoQueue,0xD67441C7,0x672A,0x476f,0x9E,0x82,0xCD,0x55,0xB4,0x49,0x49,0xCE);
+DEFINE_GUID(IID_IDXGIDebug,0x119E7452,0xDE9E,0x40fe,0x88,0x06,0x88,0xF9,0x0C,0x12,0xB4,0x41);
+DEFINE_GUID(IID_IDXGIDebug1,0xc5a05f0c,0x16f2,0x4adf,0x9f,0x4d,0xa8,0xc4,0xd5,0x8a,0xc5,0x50);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_dxgidebug_0000_0003_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_dxgidebug_0000_0003_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+

3rdparty/bgfx/3rdparty/dxsdk/include/dxgiformat.h

@@ -0,0 +1,137 @@
+//
+//    Copyright (C) Microsoft.  All rights reserved.
+//
+
+#ifndef __dxgiformat_h__
+#define __dxgiformat_h__
+
+#define DXGI_FORMAT_DEFINED 1
+
+typedef enum DXGI_FORMAT
+{
+    DXGI_FORMAT_UNKNOWN	                    = 0,
+    DXGI_FORMAT_R32G32B32A32_TYPELESS       = 1,
+    DXGI_FORMAT_R32G32B32A32_FLOAT          = 2,
+    DXGI_FORMAT_R32G32B32A32_UINT           = 3,
+    DXGI_FORMAT_R32G32B32A32_SINT           = 4,
+    DXGI_FORMAT_R32G32B32_TYPELESS          = 5,
+    DXGI_FORMAT_R32G32B32_FLOAT             = 6,
+    DXGI_FORMAT_R32G32B32_UINT              = 7,
+    DXGI_FORMAT_R32G32B32_SINT              = 8,
+    DXGI_FORMAT_R16G16B16A16_TYPELESS       = 9,
+    DXGI_FORMAT_R16G16B16A16_FLOAT          = 10,
+    DXGI_FORMAT_R16G16B16A16_UNORM          = 11,
+    DXGI_FORMAT_R16G16B16A16_UINT           = 12,
+    DXGI_FORMAT_R16G16B16A16_SNORM          = 13,
+    DXGI_FORMAT_R16G16B16A16_SINT           = 14,
+    DXGI_FORMAT_R32G32_TYPELESS             = 15,
+    DXGI_FORMAT_R32G32_FLOAT                = 16,
+    DXGI_FORMAT_R32G32_UINT                 = 17,
+    DXGI_FORMAT_R32G32_SINT                 = 18,
+    DXGI_FORMAT_R32G8X24_TYPELESS           = 19,
+    DXGI_FORMAT_D32_FLOAT_S8X24_UINT        = 20,
+    DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS    = 21,
+    DXGI_FORMAT_X32_TYPELESS_G8X24_UINT     = 22,
+    DXGI_FORMAT_R10G10B10A2_TYPELESS        = 23,
+    DXGI_FORMAT_R10G10B10A2_UNORM           = 24,
+    DXGI_FORMAT_R10G10B10A2_UINT            = 25,
+    DXGI_FORMAT_R11G11B10_FLOAT             = 26,
+    DXGI_FORMAT_R8G8B8A8_TYPELESS           = 27,
+    DXGI_FORMAT_R8G8B8A8_UNORM              = 28,
+    DXGI_FORMAT_R8G8B8A8_UNORM_SRGB         = 29,
+    DXGI_FORMAT_R8G8B8A8_UINT               = 30,
+    DXGI_FORMAT_R8G8B8A8_SNORM              = 31,
+    DXGI_FORMAT_R8G8B8A8_SINT               = 32,
+    DXGI_FORMAT_R16G16_TYPELESS             = 33,
+    DXGI_FORMAT_R16G16_FLOAT                = 34,
+    DXGI_FORMAT_R16G16_UNORM                = 35,
+    DXGI_FORMAT_R16G16_UINT                 = 36,
+    DXGI_FORMAT_R16G16_SNORM                = 37,
+    DXGI_FORMAT_R16G16_SINT                 = 38,
+    DXGI_FORMAT_R32_TYPELESS                = 39,
+    DXGI_FORMAT_D32_FLOAT                   = 40,
+    DXGI_FORMAT_R32_FLOAT                   = 41,
+    DXGI_FORMAT_R32_UINT                    = 42,
+    DXGI_FORMAT_R32_SINT                    = 43,
+    DXGI_FORMAT_R24G8_TYPELESS              = 44,
+    DXGI_FORMAT_D24_UNORM_S8_UINT           = 45,
+    DXGI_FORMAT_R24_UNORM_X8_TYPELESS       = 46,
+    DXGI_FORMAT_X24_TYPELESS_G8_UINT        = 47,
+    DXGI_FORMAT_R8G8_TYPELESS               = 48,
+    DXGI_FORMAT_R8G8_UNORM                  = 49,
+    DXGI_FORMAT_R8G8_UINT                   = 50,
+    DXGI_FORMAT_R8G8_SNORM                  = 51,
+    DXGI_FORMAT_R8G8_SINT                   = 52,
+    DXGI_FORMAT_R16_TYPELESS                = 53,
+    DXGI_FORMAT_R16_FLOAT                   = 54,
+    DXGI_FORMAT_D16_UNORM                   = 55,
+    DXGI_FORMAT_R16_UNORM                   = 56,
+    DXGI_FORMAT_R16_UINT                    = 57,
+    DXGI_FORMAT_R16_SNORM                   = 58,
+    DXGI_FORMAT_R16_SINT                    = 59,
+    DXGI_FORMAT_R8_TYPELESS                 = 60,
+    DXGI_FORMAT_R8_UNORM                    = 61,
+    DXGI_FORMAT_R8_UINT                     = 62,
+    DXGI_FORMAT_R8_SNORM                    = 63,
+    DXGI_FORMAT_R8_SINT                     = 64,
+    DXGI_FORMAT_A8_UNORM                    = 65,
+    DXGI_FORMAT_R1_UNORM                    = 66,
+    DXGI_FORMAT_R9G9B9E5_SHAREDEXP          = 67,
+    DXGI_FORMAT_R8G8_B8G8_UNORM             = 68,
+    DXGI_FORMAT_G8R8_G8B8_UNORM             = 69,
+    DXGI_FORMAT_BC1_TYPELESS                = 70,
+    DXGI_FORMAT_BC1_UNORM                   = 71,
+    DXGI_FORMAT_BC1_UNORM_SRGB              = 72,
+    DXGI_FORMAT_BC2_TYPELESS                = 73,
+    DXGI_FORMAT_BC2_UNORM                   = 74,
+    DXGI_FORMAT_BC2_UNORM_SRGB              = 75,
+    DXGI_FORMAT_BC3_TYPELESS                = 76,
+    DXGI_FORMAT_BC3_UNORM                   = 77,
+    DXGI_FORMAT_BC3_UNORM_SRGB              = 78,
+    DXGI_FORMAT_BC4_TYPELESS                = 79,
+    DXGI_FORMAT_BC4_UNORM                   = 80,
+    DXGI_FORMAT_BC4_SNORM                   = 81,
+    DXGI_FORMAT_BC5_TYPELESS                = 82,
+    DXGI_FORMAT_BC5_UNORM                   = 83,
+    DXGI_FORMAT_BC5_SNORM                   = 84,
+    DXGI_FORMAT_B5G6R5_UNORM                = 85,
+    DXGI_FORMAT_B5G5R5A1_UNORM              = 86,
+    DXGI_FORMAT_B8G8R8A8_UNORM              = 87,
+    DXGI_FORMAT_B8G8R8X8_UNORM              = 88,
+    DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM  = 89,
+    DXGI_FORMAT_B8G8R8A8_TYPELESS           = 90,
+    DXGI_FORMAT_B8G8R8A8_UNORM_SRGB         = 91,
+    DXGI_FORMAT_B8G8R8X8_TYPELESS           = 92,
+    DXGI_FORMAT_B8G8R8X8_UNORM_SRGB         = 93,
+    DXGI_FORMAT_BC6H_TYPELESS               = 94,
+    DXGI_FORMAT_BC6H_UF16                   = 95,
+    DXGI_FORMAT_BC6H_SF16                   = 96,
+    DXGI_FORMAT_BC7_TYPELESS                = 97,
+    DXGI_FORMAT_BC7_UNORM                   = 98,
+    DXGI_FORMAT_BC7_UNORM_SRGB              = 99,
+    DXGI_FORMAT_AYUV                        = 100,
+    DXGI_FORMAT_Y410                        = 101,
+    DXGI_FORMAT_Y416                        = 102,
+    DXGI_FORMAT_NV12                        = 103,
+    DXGI_FORMAT_P010                        = 104,
+    DXGI_FORMAT_P016                        = 105,
+    DXGI_FORMAT_420_OPAQUE                  = 106,
+    DXGI_FORMAT_YUY2                        = 107,
+    DXGI_FORMAT_Y210                        = 108,
+    DXGI_FORMAT_Y216                        = 109,
+    DXGI_FORMAT_NV11                        = 110,
+    DXGI_FORMAT_AI44                        = 111,
+    DXGI_FORMAT_IA44                        = 112,
+    DXGI_FORMAT_P8                          = 113,
+    DXGI_FORMAT_A8P8                        = 114,
+    DXGI_FORMAT_B4G4R4A4_UNORM              = 115,
+
+    DXGI_FORMAT_P208                        = 130,
+    DXGI_FORMAT_V208                        = 131,
+    DXGI_FORMAT_V408                        = 132,
+
+
+    DXGI_FORMAT_FORCE_UINT                  = 0xffffffff
+} DXGI_FORMAT;
+
+#endif // __dxgiformat_h__

3rdparty/bgfx/3rdparty/dxsdk/include/dxgitype.h

@@ -0,0 +1,166 @@
+//
+//    Copyright (C) Microsoft.  All rights reserved.
+//
+#ifndef __dxgitype_h__
+#define __dxgitype_h__
+
+#include "dxgiformat.h"
+
+#define _FACDXGI    0x87a
+#define MAKE_DXGI_HRESULT(code) MAKE_HRESULT(1, _FACDXGI, code)
+#define MAKE_DXGI_STATUS(code)  MAKE_HRESULT(0, _FACDXGI, code)
+
+#if defined(__MINGW32__) || !defined(DXGI_ERROR_INVALID_CALL)
+#	define DXGI_STATUS_OCCLUDED                     MAKE_DXGI_STATUS(1)
+#	define DXGI_STATUS_CLIPPED                      MAKE_DXGI_STATUS(2)
+#	define DXGI_STATUS_NO_REDIRECTION               MAKE_DXGI_STATUS(4)
+#	define DXGI_STATUS_NO_DESKTOP_ACCESS            MAKE_DXGI_STATUS(5)
+#	define DXGI_STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE MAKE_DXGI_STATUS(6)
+#	define DXGI_STATUS_MODE_CHANGED                 MAKE_DXGI_STATUS(7)
+#	define DXGI_STATUS_MODE_CHANGE_IN_PROGRESS      MAKE_DXGI_STATUS(8)
+#	define DXGI_ERROR_INVALID_CALL                  MAKE_DXGI_HRESULT(1)
+#	define DXGI_ERROR_NOT_FOUND                     MAKE_DXGI_HRESULT(2)
+#	define DXGI_ERROR_MORE_DATA                     MAKE_DXGI_HRESULT(3)
+#	define DXGI_ERROR_UNSUPPORTED                   MAKE_DXGI_HRESULT(4)
+#	define DXGI_ERROR_DEVICE_REMOVED                MAKE_DXGI_HRESULT(5)
+#	define DXGI_ERROR_DEVICE_HUNG                   MAKE_DXGI_HRESULT(6)
+#	define DXGI_ERROR_DEVICE_RESET                  MAKE_DXGI_HRESULT(7)
+#	define DXGI_ERROR_WAS_STILL_DRAWING             MAKE_DXGI_HRESULT(10)
+#	define DXGI_ERROR_FRAME_STATISTICS_DISJOINT     MAKE_DXGI_HRESULT(11)
+#	define DXGI_ERROR_GRAPHICS_VIDPN_SOURCE_IN_USE  MAKE_DXGI_HRESULT(12)
+#	define DXGI_ERROR_DRIVER_INTERNAL_ERROR         MAKE_DXGI_HRESULT(32)
+#	define DXGI_ERROR_NONEXCLUSIVE                  MAKE_DXGI_HRESULT(33)
+#	define DXGI_ERROR_NOT_CURRENTLY_AVAILABLE       MAKE_DXGI_HRESULT(34)
+#	define DXGI_ERROR_REMOTE_CLIENT_DISCONNECTED    MAKE_DXGI_HRESULT(35)
+#	define DXGI_ERROR_REMOTE_OUTOFMEMORY            MAKE_DXGI_HRESULT(36)
+#endif // defined(__MINGW32__) || (_WIN32_WINNT < 0x0601)
+
+#define DXGI_CPU_ACCESS_NONE                    ( 0 )
+#define DXGI_CPU_ACCESS_DYNAMIC                 ( 1 )
+#define DXGI_CPU_ACCESS_READ_WRITE              ( 2 )
+#define DXGI_CPU_ACCESS_SCRATCH                 ( 3 )
+#define DXGI_CPU_ACCESS_FIELD                   15
+
+
+typedef struct DXGI_RGB
+{
+    float Red;
+    float Green;
+    float Blue;
+} DXGI_RGB;
+
+#ifndef D3DCOLORVALUE_DEFINED
+typedef struct _D3DCOLORVALUE {
+    float r;
+    float g;
+    float b;
+    float a;
+} D3DCOLORVALUE;
+
+#define D3DCOLORVALUE_DEFINED
+#endif
+
+typedef D3DCOLORVALUE DXGI_RGBA;
+
+typedef struct DXGI_GAMMA_CONTROL
+{
+    DXGI_RGB Scale;
+    DXGI_RGB Offset;
+    DXGI_RGB GammaCurve[ 1025 ];
+} DXGI_GAMMA_CONTROL;
+
+typedef struct DXGI_GAMMA_CONTROL_CAPABILITIES
+{
+    BOOL ScaleAndOffsetSupported;
+    float MaxConvertedValue;
+    float MinConvertedValue;
+    UINT NumGammaControlPoints;
+    float ControlPointPositions[1025];
+} DXGI_GAMMA_CONTROL_CAPABILITIES;
+
+typedef struct DXGI_RATIONAL
+{
+    UINT Numerator;
+    UINT Denominator;
+} DXGI_RATIONAL;
+
+typedef enum DXGI_MODE_SCANLINE_ORDER
+{
+    DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED        = 0,
+    DXGI_MODE_SCANLINE_ORDER_PROGRESSIVE        = 1,
+    DXGI_MODE_SCANLINE_ORDER_UPPER_FIELD_FIRST  = 2,
+    DXGI_MODE_SCANLINE_ORDER_LOWER_FIELD_FIRST  = 3
+} DXGI_MODE_SCANLINE_ORDER;
+
+typedef enum DXGI_MODE_SCALING
+{
+    DXGI_MODE_SCALING_UNSPECIFIED   = 0,
+    DXGI_MODE_SCALING_CENTERED      = 1,
+    DXGI_MODE_SCALING_STRETCHED     = 2
+} DXGI_MODE_SCALING;
+
+typedef enum DXGI_MODE_ROTATION
+{
+    DXGI_MODE_ROTATION_UNSPECIFIED  = 0,
+    DXGI_MODE_ROTATION_IDENTITY     = 1,
+    DXGI_MODE_ROTATION_ROTATE90     = 2,
+    DXGI_MODE_ROTATION_ROTATE180    = 3,
+    DXGI_MODE_ROTATION_ROTATE270    = 4
+} DXGI_MODE_ROTATION;
+
+typedef struct DXGI_MODE_DESC
+{
+    UINT Width;
+    UINT Height;
+    DXGI_RATIONAL RefreshRate;
+    DXGI_FORMAT Format;
+    DXGI_MODE_SCANLINE_ORDER ScanlineOrdering;
+    DXGI_MODE_SCALING Scaling;
+} DXGI_MODE_DESC;
+
+// The following values are used with DXGI_SAMPLE_DESC::Quality:
+#define DXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN 0xffffffff
+#define DXGI_CENTER_MULTISAMPLE_QUALITY_PATTERN 0xfffffffe
+
+typedef struct DXGI_SAMPLE_DESC
+{
+    UINT Count;
+    UINT Quality;
+} DXGI_SAMPLE_DESC;
+
+typedef enum DXGI_COLOR_SPACE_TYPE
+{
+    DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709             = 0,
+    DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709             = 1,
+    DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P709           = 2,
+    DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P2020          = 3,
+    DXGI_COLOR_SPACE_RESERVED                           = 4,
+    DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601      = 5,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601         = 6,
+    DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P601           = 7,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709         = 8,
+    DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P709           = 9,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020        = 10,
+    DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020          = 11,
+    DXGI_COLOR_SPACE_CUSTOM                             = 0xFFFFFFFF
+} DXGI_COLOR_SPACE_TYPE;
+
+typedef struct DXGI_JPEG_DC_HUFFMAN_TABLE
+{
+    BYTE CodeCounts[12];
+    BYTE CodeValues[12];
+} DXGI_JPEG_DC_HUFFMAN_TABLE;
+
+typedef struct DXGI_JPEG_AC_HUFFMAN_TABLE
+{
+    BYTE CodeCounts[16];
+    BYTE CodeValues[162];
+} DXGI_JPEG_AC_HUFFMAN_TABLE;
+
+typedef struct DXGI_JPEG_QUANTIZATION_TABLE
+{
+    BYTE Elements[64];
+} DXGI_JPEG_QUANTIZATION_TABLE;
+
+#endif // __dxgitype_h__
+

3rdparty/bgfx/3rdparty/fcpp/cpp1.c

@@ -143,7 +143,7 @@ int fppPreProcess(struct fppTag *tags)
 #endif
   }
   fflush(stdout);
-  fclose(stdout);
+// BK -  fclose(stdout);
 
   if (global->errors > 0 && !global->eflag)
     return(IO_ERROR);

3rdparty/bgfx/3rdparty/fcpp/cpp4.c

@@ -127,24 +127,24 @@ ReturnCode dodefine(struct Global *global)
      * DEF_NOARGS is needed to distinguish between
      * "#define foo" and "#define foo()".
      */
-    global->nargs = DEF_NOARGS;		/* No () parameters     */
+    global->nargs = DEF_NOARGS;         /* No () parameters     */
   }
   if (type[c] == SPA)                   /* At whitespace?       */
     c = skipws(global);                 /* Not any more.        */
-  global->workp = global->work;		/* Replacement put here */
-  global->inmacro = TRUE;		/* Keep \<newline> now	*/
-  quoting = 0;				/* No # seen yet.	*/
+  global->workp = global->work;         /* Replacement put here */
+  global->inmacro = TRUE;               /* Keep \<newline> now	*/
+  quoting = 0;                          /* No # seen yet.	*/
   while (c != EOF_CHAR && c != '\n') {  /* Compile macro body   */
 #if OK_CONCAT
     if (c == '#') {                     /* Token concatenation? */
       if ((c = get(global)) != '#') {   /* No, not really       */
-	quoting = 1;		        /* Maybe quoting op.	*/
-	continue;
+        quoting = 1;                    /* Maybe quoting op.    */
+        continue;
       }
       while (global->workp > global->work && type[(unsigned)*(global->workp - 1)] == SPA)
-	--global->workp;		/* Erase leading spaces */
-      if((ret=save(global, TOK_SEP)))     /* Stuff a delimiter    */
-	return(ret);
+        --global->workp;                /* Erase leading spaces */
+//       if ((ret=save(global, TOK_SEP)))  /* Stuff a delimiter    */
+//         return(ret);
       c = skipws(global);               /* Eat whitespace       */
       continue;
     }

3rdparty/bgfx/3rdparty/glsl-optimizer/Changelog.md

@@ -1,9 +1,31 @@
 GLSL optimizer Change Log
 =========================
 
+2015 06
+-------
+
+Fixes:
+
+* Fixed some cases of different precision matrix assignments being miscompiled on Metal.
+* Fixed yet more issues with translation of weird loops.
+* Fixed translation of matrix+scalar, matrix-scalar, matrix/scalar operations on Metal.
+
+
+2015 05
+-------
+
+Fixes:
+
+* Fixes some cases of highp/mediump sampler sampling resulting in resulting temporaries wrongly being lowp.
+
+
 2015 04
 -------
 
+Goodies:
+* GLES2: support EXT_draw_instanced / gl_InstanceIDEXT.
+* Support gl_VertexID in GLSL < 1.30 when EXT_gpu_shader4 is used.
+
 Fixes:
 
 * Metal: fixed some bugs with translation of weird loops.

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/ast_function.cpp

@@ -1212,7 +1212,7 @@ emit_inline_matrix_constructor(const glsl_type *type, int ast_precision,
     *
     *  - Construct a matrix from an arbirary combination of vectors and
     *    scalars.  The components of the constructor parameters are assigned
-    *    to the matrix in colum-major order until the matrix is full.
+    *    to the matrix in column-major order until the matrix is full.
     *
     *  - Construct a matrix from a single matrix.  The source matrix is copied
     *    to the upper left portion of the constructed matrix, and the remaining

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/ast_to_hir.cpp

@@ -3136,13 +3136,13 @@ process_initializer(ir_variable *var, ast_declaration *decl,
 
 static void
 apply_precision_to_variable(const struct ast_type_qualifier& qual,
-				 ir_variable *var,
+				 ir_variable *var, bool function_param,
 				 struct _mesa_glsl_parse_state *state)
 {
 	if (!state->es_shader)
 		return;
-	if (var->type->is_sampler() && qual.precision == ast_precision_none)
-		var->data.precision = ast_precision_low; // samplers default to low precision
+	if (var->type->is_sampler() && qual.precision == ast_precision_none && !function_param)
+		var->data.precision = ast_precision_low; // samplers default to low precision (outside of function arguments)
 	else
 		var->data.precision = qual.precision;
 }
@@ -3548,7 +3548,7 @@ ast_declarator_list::hir(exec_list *instructions,
 
       apply_type_qualifier_to_variable(& this->type->qualifier, var, state,
 					   & loc, false);
-	  apply_precision_to_variable(this->type->qualifier, var, state);
+	  apply_precision_to_variable(this->type->qualifier, var, false, state);
 
       if (this->type->qualifier.flags.q.invariant) {
          if (!is_varying_var(var, state->stage)) {
@@ -4005,7 +4005,7 @@ ast_parameter_declarator::hir(exec_list *instructions,
     */
    apply_type_qualifier_to_variable(& this->type->qualifier, var, state, & loc,
                                     true);
-   apply_precision_to_variable(this->type->qualifier, var, state);
+   apply_precision_to_variable(this->type->qualifier, var, true, state);
 
    /* From section 4.1.7 of the GLSL 4.40 spec:
     *

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/builtin_variables.cpp

@@ -830,10 +830,12 @@ void
 builtin_variable_generator::generate_vs_special_vars()
 {
 
-   if (state->is_version(130, 300))
+   if (state->is_version(130, 300) || state->EXT_gpu_shader4_enable)
       add_system_value(SYSTEM_VALUE_VERTEX_ID, state->metal_target ? uint_t : int_t, "gl_VertexID", glsl_precision_high);
    if (state->ARB_draw_instanced_enable)
       add_system_value(SYSTEM_VALUE_INSTANCE_ID, int_t, "gl_InstanceIDARB", glsl_precision_high);
+   if (state->EXT_draw_instanced_enable)
+      add_system_value(SYSTEM_VALUE_INSTANCE_ID, int_t, "gl_InstanceIDEXT", glsl_precision_high);
    if (state->ARB_draw_instanced_enable || state->is_version(140, 300))
 	   add_system_value(SYSTEM_VALUE_INSTANCE_ID, state->metal_target ? uint_t : int_t, "gl_InstanceID", glsl_precision_high);
    if (state->AMD_vertex_shader_layer_enable)

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/glcpp/glcpp-parse.c

@@ -3727,7 +3727,7 @@ _arguments_parse (argument_list_t *arguments,
 		else {
 			if (argument->head == NULL) {
 				/* Don't treat initial whitespace as
-				 * part of the arguement. */
+				 * part of the argument. */
 				if (node->token->type == SPACE)
 					continue;
 			}
@@ -4679,6 +4679,9 @@ _glcpp_parser_handle_version_declaration(glcpp_parser_t *parser, intmax_t versio
 	      if (extensions->ARB_draw_instanced)
 	         add_builtin_define(parser, "GL_ARB_draw_instanced", 1);
 
+	      if (extensions->EXT_draw_instanced)
+	         add_builtin_define(parser, "GL_EXT_draw_instanced", 1);
+
 	      if (extensions->ARB_conservative_depth) {
 	         add_builtin_define(parser, "GL_AMD_conservative_depth", 1);
 	         add_builtin_define(parser, "GL_ARB_conservative_depth", 1);

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/glcpp/glcpp-parse.y

@@ -1462,7 +1462,7 @@ _arguments_parse (argument_list_t *arguments,
 		else {
 			if (argument->head == NULL) {
 				/* Don't treat initial whitespace as
-				 * part of the arguement. */
+				 * part of the argument. */
 				if (node->token->type == SPACE)
 					continue;
 			}
@@ -2414,6 +2414,9 @@ _glcpp_parser_handle_version_declaration(glcpp_parser_t *parser, intmax_t versio
 	      if (extensions->ARB_draw_instanced)
 	         add_builtin_define(parser, "GL_ARB_draw_instanced", 1);
 
+	      if (extensions->EXT_draw_instanced)
+	         add_builtin_define(parser, "GL_EXT_draw_instanced", 1);
+
 	      if (extensions->ARB_conservative_depth) {
 	         add_builtin_define(parser, "GL_AMD_conservative_depth", 1);
 	         add_builtin_define(parser, "GL_ARB_conservative_depth", 1);

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/glsl_optimizer.cpp

@@ -265,6 +265,21 @@ static void propagate_precision_expr(ir_instruction *ir, void *data)
 	
 }
 
+static void propagate_precision_texture(ir_instruction *ir, void *data)
+{
+	ir_texture* tex = ir->as_texture();
+	if (!tex)
+		return;
+
+	glsl_precision sampler_prec = tex->sampler->get_precision();
+	if (tex->get_precision() == sampler_prec || sampler_prec == glsl_precision_undefined)
+		return;
+
+	// set precision of ir_texture node to that of the sampler itself
+	tex->set_precision(sampler_prec);
+	((precision_ctx*)data)->res = true;
+}
+
 struct undefined_ass_ctx
 {
 	ir_variable* var;
@@ -381,8 +396,19 @@ static bool propagate_precision(exec_list* list, bool assign_high_to_undefined)
 		ctx.root_ir = list;
 		foreach_in_list(ir_instruction, ir, list)
 		{
+			visit_tree (ir, propagate_precision_texture, &ctx);
 			visit_tree (ir, propagate_precision_deref, &ctx);
+			bool hadProgress = ctx.res;
+			ctx.res = false;
 			visit_tree (ir, propagate_precision_assign, &ctx);
+			if (ctx.res)
+			{
+				// assignment precision propagation might have added precision
+				// to some variables; need to propagate dereference precision right
+				// after that too.
+				visit_tree (ir, propagate_precision_deref, &ctx);
+			}
+			ctx.res |= hadProgress;
 			visit_tree (ir, propagate_precision_call, &ctx);
 			visit_tree (ir, propagate_precision_expr, &ctx);
 		}

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/glsl_parser_extras.cpp

@@ -562,7 +562,9 @@ static const _mesa_glsl_extension _mesa_glsl_supported_extensions[] = {
    EXT(AMD_vertex_shader_layer,        true,  false,     AMD_vertex_shader_layer),
    EXT(AMD_vertex_shader_viewport_index, true,  false,   AMD_vertex_shader_viewport_index),
    EXT(EXT_draw_buffers,               false,  true,     EXT_draw_buffers),
+   EXT(EXT_draw_instanced,             false,  true,     EXT_draw_instanced),
    EXT(EXT_frag_depth,                 false,  true,     EXT_frag_depth),
+   EXT(EXT_gpu_shader4,				   true,  false,     EXT_gpu_shader4),
    EXT(EXT_separate_shader_objects,    false, true,      dummy_true),
    EXT(EXT_shader_framebuffer_fetch,   false, true,      EXT_shader_framebuffer_fetch),
    EXT(EXT_shader_integer_mix,         true,  true,      EXT_shader_integer_mix),

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/glsl_parser_extras.h

@@ -473,8 +473,12 @@ struct _mesa_glsl_parse_state {
    bool AMD_vertex_shader_viewport_index_warn;
    bool EXT_draw_buffers_enable;
    bool EXT_draw_buffers_warn;
+   bool EXT_draw_instanced_enable;
+   bool EXT_draw_instanced_warn;
    bool EXT_frag_depth_enable;
    bool EXT_frag_depth_warn;
+   bool EXT_gpu_shader4_enable;
+   bool EXT_gpu_shader4_warn;
    bool EXT_separate_shader_objects_enable;
    bool EXT_separate_shader_objects_warn;
    bool EXT_shader_framebuffer_fetch_enable;

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/ir_print_glsl_visitor.cpp

@@ -231,6 +231,10 @@ _mesa_print_ir_glsl(exec_list *instructions,
 		}
 		if (state->ARB_shader_texture_lod_enable)
 			str.asprintf_append ("#extension GL_ARB_shader_texture_lod : enable\n");
+		if (state->ARB_draw_instanced_enable)
+			str.asprintf_append ("#extension GL_ARB_draw_instanced : enable\n");
+		if (state->EXT_gpu_shader4_enable)
+			str.asprintf_append ("#extension GL_EXT_gpu_shader4 : enable\n");
 		if (state->EXT_shader_texture_lod_enable)
 			str.asprintf_append ("#extension GL_EXT_shader_texture_lod : enable\n");
 		if (state->OES_standard_derivatives_enable)
@@ -242,7 +246,9 @@ _mesa_print_ir_glsl(exec_list *instructions,
 		if (state->es_shader && state->language_version < 300)
 		{
 			if (state->EXT_draw_buffers_enable)
-				str.asprintf_append ("#extension GL_EXT_draw_buffers : require\n");
+				str.asprintf_append ("#extension GL_EXT_draw_buffers : enable\n");
+			if (state->EXT_draw_instanced_enable)
+				str.asprintf_append ("#extension GL_EXT_draw_instanced : enable\n");
 		}
 		if (state->EXT_shader_framebuffer_fetch_enable)
 			str.asprintf_append ("#extension GL_EXT_shader_framebuffer_fetch : enable\n");
@@ -823,7 +829,7 @@ void ir_print_glsl_visitor::visit(ir_texture *ir)
 		sampler_uv_dim += 1;
 	const bool is_proj = (uv_dim > sampler_uv_dim);
 	const bool is_lod = (ir->op == ir_txl);
-
+	
 #if 0 // BK - disable LOD workarounds.
 	if (is_lod && state->es_shader && state->language_version < 300 && state->stage == MESA_SHADER_FRAGMENT)
 	{
@@ -855,6 +861,7 @@ void ir_print_glsl_visitor::visit(ir_texture *ir)
 	}
 #endif // 0
 
+	
     // texture function name
     //ACS: shadow lookups and lookups with dimensionality included in the name were deprecated in 130
     if(state->language_version<130) 

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/ir_print_metal_visitor.cpp

@@ -101,6 +101,7 @@ struct metal_print_context
 	, paramsStr(ralloc_strdup(buffer, ""))
 	, writingParams(false)
 	, matrixCastsDone(false)
+	, matrixConstructorsDone(false)
 	, shadowSamplerDone(false)
 	, textureCounter(0)
 	, attributeCounter(0)
@@ -118,6 +119,7 @@ struct metal_print_context
 	string_buffer paramsStr;
 	bool writingParams;
 	bool matrixCastsDone;
+	bool matrixConstructorsDone;
 	bool shadowSamplerDone;
 	int textureCounter;
 	int attributeCounter;
@@ -940,22 +942,57 @@ void ir_print_metal_visitor::visit(ir_expression *ir)
 	bool op0cast = ir->operands[0] && is_different_precision(arg_prec, ir->operands[0]->get_precision());
 	bool op1cast = ir->operands[1] && is_different_precision(arg_prec, ir->operands[1]->get_precision());
 	bool op2cast = ir->operands[2] && is_different_precision(arg_prec, ir->operands[2]->get_precision());
+	const bool op0matrix = ir->operands[0] && ir->operands[0]->type->is_matrix();
+	const bool op1matrix = ir->operands[1] && ir->operands[1]->type->is_matrix();
+	bool op0castTo1 = false;
+	bool op1castTo0 = false;
 
 	// Metal does not support matrix precision casts, so when any of the arguments is a matrix,
 	// take precision from it. This isn't fully robust now, but oh well.
-	if (op0cast && ir->operands[0]->type->is_matrix() && !op1cast)
+	if (op0cast && op0matrix && !op1cast)
 	{
 		op0cast = false;
 		arg_prec = ir->operands[0]->get_precision();
 		op1cast = ir->operands[1] && is_different_precision(arg_prec, ir->operands[1]->get_precision());
 	}
-	if (op1cast && ir->operands[1]->type->is_matrix() && !op0cast)
+	if (op1cast && op1matrix && !op0cast)
 	{
 		op1cast = false;
 		arg_prec = ir->operands[1]->get_precision();
 		op0cast = ir->operands[0] && is_different_precision(arg_prec, ir->operands[0]->get_precision());
 	}
 
+	// Metal does not have matrix+scalar and matrix-scalar operations; we need to create matrices
+	// out of the non-matrix argument.
+	if (ir->operation == ir_binop_add || ir->operation == ir_binop_sub)
+	{
+		if (op0matrix && !op1matrix)
+		{
+			op1cast = true;
+			op1castTo0 = true;
+		}
+		if (op1matrix && !op0matrix)
+		{
+			op0cast = true;
+			op0castTo1 = true;
+		}
+		if (op1castTo0 || op0castTo1)
+		{
+			if (!ctx.matrixConstructorsDone)
+			{
+				ctx.prefixStr.asprintf_append(
+											  "inline float4x4 _xlinit_float4x4(float v) { return float4x4(float4(v), float4(v), float4(v), float4(v)); }\n"
+											  "inline float3x3 _xlinit_float3x3(float v) { return float3x3(float3(v), float3(v), float3(v)); }\n"
+											  "inline float2x2 _xlinit_float2x2(float v) { return float2x2(float2(v), float2(v)); }\n"
+											  "inline half4x4 _xlinit_half4x4(half v) { return half4x4(half4(v), half4(v), half4(v), half4(v)); }\n"
+											  "inline half3x3 _xlinit_half3x3(half v) { return half3x3(half3(v), half3(v), half3(v)); }\n"
+											  "inline half2x2 _xlinit_half2x2(half v) { return half2x2(half2(v), half2(v)); }\n"
+											  );
+				ctx.matrixConstructorsDone = true;
+			}
+		}
+	}
+	
 	const bool rescast = is_different_precision(arg_prec, res_prec) && !ir->type->is_boolean();
 	if (rescast)
 	{
@@ -1000,6 +1037,7 @@ void ir_print_metal_visitor::visit(ir_expression *ir)
 	}
 	else if (is_binop_func_like(ir->operation, ir->type))
 	{
+		// binary operation that must be printed like a function, "foo(a,b)"
 		if (ir->operation == ir_binop_mod)
 		{
 			buffer.asprintf_append ("(");
@@ -1025,23 +1063,58 @@ void ir_print_metal_visitor::visit(ir_expression *ir)
 		if (ir->operation == ir_binop_mod)
             buffer.asprintf_append ("))");
 	}
+	else if (ir->get_num_operands() == 2 && ir->operation == ir_binop_div && op0matrix && !op1matrix)
+	{
+		// "matrix/scalar" - Metal does not have it, so print multiply by inverse instead
+		buffer.asprintf_append ("(");
+		ir->operands[0]->accept(this);
+		const bool halfCast = (arg_prec == glsl_precision_medium || arg_prec == glsl_precision_low);
+		buffer.asprintf_append (halfCast ? " * (1.0h/half(" : " * (1.0/(");
+		ir->operands[1]->accept(this);
+		buffer.asprintf_append (")))");
+	}
 	else if (ir->get_num_operands() == 2)
 	{
+		// regular binary operator
 		buffer.asprintf_append ("(");
 		if (ir->operands[0])
 		{
-			if (op0cast)
+			if (op0castTo1)
+			{
+				buffer.asprintf_append ("_xlinit_");
+				print_type_precision(buffer, ir->operands[1]->type, arg_prec, false);
+				buffer.asprintf_append ("(");
+			}
+			else if (op0cast)
+			{
 				print_cast (buffer, arg_prec, ir->operands[0]);
+			}
 			ir->operands[0]->accept(this);
+			if (op0castTo1)
+			{
+				buffer.asprintf_append (")");
+			}
 		}
 
 		buffer.asprintf_append (" %s ", operator_glsl_strs[ir->operation]);
 
 		if (ir->operands[1])
 		{
-			if (op1cast)
+			if (op1castTo0)
+			{
+				buffer.asprintf_append ("_xlinit_");
+				print_type_precision(buffer, ir->operands[0]->type, arg_prec, false);
+				buffer.asprintf_append ("(");
+			}
+			else if (op1cast)
+			{
 				print_cast (buffer, arg_prec, ir->operands[1]);
+			}
 			ir->operands[1]->accept(this);
+			if (op1castTo0)
+			{
+				buffer.asprintf_append (")");
+			}
 		}
 		buffer.asprintf_append (")");
 	}

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/link_uniforms.cpp

@@ -256,7 +256,7 @@ namespace {
  *
  * As uniforms are added to the active set the number of active uniforms and
  * the storage requirements for those uniforms are accumulated.  The active
- * uniforms are added the the hash table supplied to the constructor.
+ * uniforms are added to the hash table supplied to the constructor.
  *
  * If the same uniform is added multiple times (i.e., once for each shader
  * target), it will only be accounted once.

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/loop_analysis.cpp

@@ -28,6 +28,8 @@
 
 static bool is_loop_terminator(ir_if *ir);
 
+static bool used_outside_loops(exec_node *head, ir_variable *var, bool first_assignment);
+
 static bool all_expression_operands_are_loop_constant(ir_rvalue *,
 						      hash_table *);
 
@@ -121,13 +123,20 @@ loop_state::get_for_inductor(const ir_variable *ir)
 }
 
 void
+loop_state::insert_non_inductor(ir_variable *var)
+{
+	// key doesn't matter, just needs to be non-NULL
+	hash_table_insert(this->ht_non_inductors, this, var);
+}
+
+bool
 loop_state::insert_inductor(loop_variable* loopvar, loop_variable_state* state, ir_loop* loop)
 {
 	ir_variable* var = loopvar->var;
 
 	// Check if this variable is already marked as "sure can't be a private inductor variable"
 	if (hash_table_find(this->ht_non_inductors, var))
-		return;
+		return false;
 
 	// Check if this variable is used after the loop anywhere. If it is, it can't be a
 	// variable that's private to the loop.
@@ -143,7 +152,7 @@ loop_state::insert_inductor(loop_variable* loopvar, loop_variable_state* state,
 			// add to list of "non inductors", so that next loop does not try
 			// to add it as inductor again
 			hash_table_insert(this->ht_non_inductors, state, var);
-			return;
+			return false;
 		}
 	}
 
@@ -166,12 +175,13 @@ loop_state::insert_inductor(loop_variable* loopvar, loop_variable_state* state,
 			// add to list of "non inductors", so that next loop does not try
 			// to add it as inductor again
 			hash_table_insert(this->ht_non_inductors, state, var);
-			return;
+			return false;
 		}
 	}
 	
 	state->private_induction_variable_count++;
 	hash_table_insert(this->ht_inductors, state, var);
+	return true;
 }
 
 
@@ -245,6 +255,8 @@ public:
    virtual ir_visitor_status visit(ir_loop_jump *);
    virtual ir_visitor_status visit(ir_dereference_variable *);
 
+   virtual ir_visitor_status visit(ir_variable *);
+
    virtual ir_visitor_status visit_enter(ir_call *);
 
    virtual ir_visitor_status visit_enter(ir_loop *);
@@ -288,6 +300,28 @@ loop_analysis::visit(ir_loop_jump *ir)
 }
 
 
+ir_visitor_status
+loop_analysis::visit(ir_variable *var)
+{
+	// if inside a loop, simply continue - we're only interested in variables declared
+	// entirely outside of any loops
+	if (!this->state.is_empty())
+		return visit_continue;
+
+	// Check if this variable is used outside a loop anywhere. If it is, it can't be a
+	// variable that's private to the loop, so can't be an inductor.
+	// This doesn't reject all possible non-inductors, notably anything declared in an
+	// outer loop that isn't an inductor in an inner loop, but it can eliminate some
+	// problem cases
+	if (used_outside_loops(var->next, var, false))
+	{
+		// add to list of "non inductors"
+		loops->insert_non_inductor(var);
+	}
+
+	return visit_continue;
+}
+
 ir_visitor_status
 loop_analysis::visit_enter(ir_call *)
 {
@@ -451,11 +485,12 @@ loop_analysis::visit_leave(ir_loop *ir)
       ir_rvalue *const inc =
 	 get_basic_induction_increment(lv->first_assignment, ls->var_hash);
       if (inc != NULL) {
-	 lv->increment = inc;
+         lv->increment = inc;
 
-	 lv->remove();
-	 ls->induction_variables.push_tail(lv);
-	 loops->insert_inductor(lv, ls, ir);
+         if (loops->insert_inductor(lv, ls, ir)) {
+            lv->remove();
+            ls->induction_variables.push_tail(lv);
+         }
       }
    }
 
@@ -699,6 +734,65 @@ is_loop_terminator(ir_if *ir)
 }
 
 
+bool
+used_outside_loops(exec_node *head, ir_variable *var, bool first_assignment)
+{
+	ir_variable_refcount_visitor refs;
+	for (exec_node* node = head;
+		 !node->is_tail_sentinel();
+		 node = node->next)
+	{
+		ir_instruction *ir = (ir_instruction *) node;
+		if (ir->ir_type == ir_type_variable)
+			continue;
+
+		// ignore the first assignment
+		if (!first_assignment && ir->ir_type == ir_type_assignment)
+		{
+			ir_assignment *assign = ir->as_assignment();
+			ir_variable *assignee = assign->lhs->whole_variable_referenced();
+
+			if(assignee == var)
+			{
+				first_assignment = true;
+				continue;
+			}
+		}
+
+		// we don't want to recurse into loops
+		if (ir->ir_type == ir_type_loop)
+			continue;
+
+		// recurse only for if statements, the other case we would need to recurse is
+		// loops, but we are looking for uses outside of loops.
+		if (ir->ir_type == ir_type_if)
+		{
+			ir_if *irif = ir->as_if();
+			if (used_outside_loops(irif->then_instructions.head, var, first_assignment))
+				return true;
+			if (used_outside_loops(irif->else_instructions.head, var, first_assignment))
+				return true;
+
+			// if we didn't find in each branch with our recursion, skip
+			// otherwise the accept (&refs) below will recurse into loops
+			// and may give a false positive.
+			continue;
+		}
+
+		// we know that we're not inside a loop as we haven't recursed inside,
+		// and we started outside of a loop, so any references to this variable
+		// mean it is used outside of any loops
+		ir->accept (&refs);
+		if (refs.find_variable_entry(var))
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
 loop_state *
 analyze_loop_variables(exec_list *instructions)
 {

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/loop_analysis.h

@@ -249,7 +249,8 @@ public:
    loop_variable_state *insert(ir_loop *ir);
 	
    loop_variable_state* get_for_inductor (const ir_variable*);
-   void insert_inductor(loop_variable* loopvar, loop_variable_state* state, ir_loop* loop);
+   bool insert_inductor(loop_variable* loopvar, loop_variable_state* state, ir_loop* loop);
+   void insert_non_inductor(ir_variable *var);
 
    bool loop_found;
 

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/lower_packing_builtins.cpp

@@ -569,8 +569,8 @@ private:
        *     return pack_uvec2_to_uint(uvec2(
        *                round(clamp(VEC2_RVALUE, 0.0f, 1.0f) * 65535.0f)));
        *
-       * Here it is safe to directly convert the vec2 to uvec2 because the the
-       * vec2 has been clamped to a non-negative range.
+       * Here it is safe to directly convert the vec2 to uvec2 because the vec2
+       * has been clamped to a non-negative range.
        */
 
       assert(vec2_rval->type == glsl_type::vec2_type);

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/opt_dead_builtin_varyings.cpp

@@ -35,7 +35,7 @@
  * the built-in varyings have pre-assigned locations. Also, the elimination
  * of unused gl_TexCoord elements requires its own lowering pass anyway.
  *
- * It's implemented by replacing all occurences of dead varyings with
+ * It's implemented by replacing all occurrences of dead varyings with
  * temporary variables, which creates dead code. It is recommended to run
  * a dead-code elimination pass after this.
  *
@@ -280,7 +280,7 @@ public:
        *
        * We're going to break down the gl_TexCoord array into separate
        * variables. First, add declarations of the new variables all
-       * occurences of gl_TexCoord will be replaced with.
+       * occurrences of gl_TexCoord will be replaced with.
        */
       if (info->lower_texcoord_array) {
          prepare_array(ir, this->new_texcoord, ARRAY_SIZE(this->new_texcoord),
@@ -411,7 +411,7 @@ public:
        * variable dereference representing gl_TexCoord[i].
        */
       if (this->info->lower_texcoord_array) {
-         /* gl_TexCoord[i] occurence */
+         /* gl_TexCoord[i] occurrence */
          ir_dereference_array *const da = (*rvalue)->as_dereference_array();
 
          if (da && da->variable_referenced() ==
@@ -425,7 +425,7 @@ public:
 
       /* Same for gl_FragData. */
       if (this->info->lower_fragdata_array) {
-         /* gl_FragData[i] occurence */
+         /* gl_FragData[i] occurrence */
          ir_dereference_array *const da = (*rvalue)->as_dereference_array();
 
          if (da && da->variable_referenced() == this->info->fragdata_array) {

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/opt_function_inlining.cpp

@@ -150,7 +150,7 @@ ir_call::generate_inline(ir_instruction *next_ir)
         parameters[i]->data.precision = param->get_precision();
      prec_params_max = higher_precision (prec_params_max, (glsl_precision)parameters[i]->data.precision);
 
-	 /* Remove the read-only decoration becuase we're going to write
+	 /* Remove the read-only decoration because we're going to write
 	  * directly to this variable.  If the cloned variable is left
 	  * read-only and the inlined function is inside a loop, the loop
 	  * analysis code will get confused.

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/standalone_scaffolding.cpp

@@ -106,6 +106,8 @@ void initialize_context_to_defaults(struct gl_context *ctx, gl_api api)
    ctx->Extensions.OES_EGL_image_external = true;
    ctx->Extensions.OES_standard_derivatives = true;
 
+   ctx->Extensions.EXT_draw_instanced = true;
+   ctx->Extensions.EXT_gpu_shader4 = true;
    ctx->Extensions.EXT_shader_integer_mix = true;
    ctx->Extensions.EXT_texture3D = true;
    ctx->Extensions.EXT_texture_array = true;
@@ -113,6 +115,8 @@ void initialize_context_to_defaults(struct gl_context *ctx, gl_api api)
 
    ctx->Extensions.NV_texture_rectangle = true;
 
+   ctx->Const.AllowGLSLExtensionDirectiveMidShader = true; // makes it easier to run tests
+
    ctx->Const.GLSLVersion = 120;
 
    /* 1.20 minimums. */

3rdparty/bgfx/3rdparty/glsl-optimizer/src/mesa/main/mtypes.h

@@ -1491,6 +1491,7 @@ struct gl_extensions
    GLboolean EXT_depth_bounds_test;
    GLboolean EXT_draw_buffers;
    GLboolean EXT_draw_buffers2;
+   GLboolean EXT_draw_instanced;
    GLboolean EXT_framebuffer_blit;
    GLboolean EXT_framebuffer_multisample;
    GLboolean EXT_framebuffer_multisample_blit_scaled;

3rdparty/bgfx/3rdparty/glsl-optimizer/src/mesa/program/hash_table.h

@@ -116,8 +116,8 @@ extern void hash_table_insert(struct hash_table *ht, void *data,
  * Add an element to a hash table with replacement
  *
  * \return
- * 1 if it did replace the the value (in which case the old key is kept), 0 if
- * it did not replace the value (in which case the new key is kept).
+ * 1 if it did replace the value (in which case the old key is kept), 0 if it
+ * did not replace the value (in which case the new key is kept).
  *
  * \warning
  * If \c key is already in the hash table, \c data will \b replace the most

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/ast-out.txt

@@ -5,7 +5,8 @@ void main ()
     discard;
   };
   a_2 = 4.0;
-  for (int i_1 = 0; i_1 < 10; i_1++, a_2 += 1.0) {
+  for (int i_1 = 0; i_1 < 10; i_1++) {
+    a_2 += 1.0;
   };
   while (true) {
     a_2 += 2.0;

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/ast-outES3.txt

@@ -7,7 +7,8 @@ void main ()
     discard;
   };
   a_2 = 4.0;
-  for (highp int i_1 = 0; i_1 < 10; i_1++, a_2 += 1.0) {
+  for (highp int i_1 = 0; i_1 < 10; i_1++) {
+    a_2 += 1.0;
   };
   while (true) {
     a_2 += 2.0;

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/ast-outES3Metal.txt

@@ -16,7 +16,8 @@ fragment xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]]
     discard_fragment();
   };
   a_2 = 4.0;
-  for (int i_1 = 0; i_1 < 10; i_1++, a_2 += 1.0) {
+  for (int i_1 = 0; i_1 < 10; i_1++) {
+    a_2 += 1.0;
   };
   while (true) {
     a_2 += 2.0;

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/bug-loop-share-index-out.txt

@@ -5,16 +5,24 @@ void main ()
   int myIdx_2;
   r_1 = vec4(0.0, 0.0, 0.0, 0.0);
   myIdx_2 = 1;
-  for (; myIdx_2 < loopNum; myIdx_2++) {
+  while (true) {
+    if ((myIdx_2 >= loopNum)) {
+      break;
+    };
     r_1.x = (r_1.x + 1.0);
     r_1.y = (r_1.y + 2.0);
     r_1.z = (r_1.z + 3.0);
+    myIdx_2++;
   };
   myIdx_2 = 2;
-  for (; myIdx_2 < loopNum; myIdx_2++) {
+  while (true) {
+    if ((myIdx_2 >= loopNum)) {
+      break;
+    };
     r_1.x = (r_1.x + 1.0);
     r_1.y = (r_1.y + 2.0);
     r_1.z = (r_1.z + 3.0);
+    myIdx_2++;
   };
   gl_FragColor = r_1;
 }

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highp-inES3.txt

@@ -0,0 +1,15 @@
+#version 300 es
+
+// There was a bug where due to xll_tex2Dlod sampling of a _CameraDepthTexture (that is a highp sampler)
+// was producing a missing cast between half4 and float4 on Metal output.
+// Shader is a minimal part of Unity's camera motion blur shader that exposes the bug
+
+vec4 xll_tex2Dlod(sampler2D s, vec4 coord) { return textureLod(s, coord.xy, coord.w); }
+uniform highp sampler2D _CameraDepthTexture;
+in highp vec2 varUV;
+out mediump vec4 _fragData;
+void main()
+{
+	highp float z = xll_tex2Dlod(_CameraDepthTexture, vec4(varUV, 0.0, 0.0)).x;
+    _fragData = vec4(z);
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highp-outES3.txt

@@ -0,0 +1,17 @@
+#version 300 es
+uniform highp sampler2D _CameraDepthTexture;
+in highp vec2 varUV;
+out mediump vec4 _fragData;
+void main ()
+{
+  highp vec4 tmpvar_1;
+  tmpvar_1 = textureLod (_CameraDepthTexture, varUV, 0.0).xxxx;
+  _fragData = tmpvar_1;
+}
+
+
+// stats: 0 alu 1 tex 0 flow
+// inputs: 1
+//  #0: varUV (high float) 2x1 [-1]
+// textures: 1
+//  #0: _CameraDepthTexture (high 2d) 0x0 [-1]

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highp-outES3Metal.txt

@@ -0,0 +1,26 @@
+#include <metal_stdlib>
+using namespace metal;
+struct xlatMtlShaderInput {
+  float2 varUV;
+};
+struct xlatMtlShaderOutput {
+  half4 _fragData [[color(0)]];
+};
+struct xlatMtlShaderUniform {
+};
+fragment xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]], constant xlatMtlShaderUniform& _mtl_u [[buffer(0)]]
+  ,   texture2d<float> _CameraDepthTexture [[texture(0)]], sampler _mtlsmp__CameraDepthTexture [[sampler(0)]])
+{
+  xlatMtlShaderOutput _mtl_o;
+  float4 tmpvar_1;
+  tmpvar_1 = _CameraDepthTexture.sample(_mtlsmp__CameraDepthTexture, (float2)(_mtl_i.varUV), level(0.0)).xxxx;
+  _mtl_o._fragData = half4(tmpvar_1);
+  return _mtl_o;
+}
+
+
+// stats: 0 alu 1 tex 0 flow
+// inputs: 1
+//  #0: varUV (high float) 2x1 [-1]
+// textures: 1
+//  #0: _CameraDepthTexture (high 2d) 0x0 [-1] loc 0

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highpfull-inES3.txt

@@ -0,0 +1,118 @@
+#version 300 es
+
+// There was a bug where due to xll_tex2Dlod sampling of a _CameraDepthTexture (that is a highp sampler)
+// was producing a missing cast between half4 and float4 on Metal output.
+// Shader is part of Unity's camera motion blur shader.
+
+vec4 xll_tex2Dlod(sampler2D s, vec4 coord) { return textureLod( s, coord.xy, coord.w); }
+struct v2f {
+    highp vec4 pos;
+    highp vec2 uv;
+};
+uniform highp vec3 _WorldSpaceCameraPos;
+uniform highp vec4 _ProjectionParams;
+uniform highp vec4 _ScreenParams;
+uniform highp vec4 _ZBufferParams;
+uniform highp vec4 _WorldSpaceLightPos0;
+uniform highp mat4 _Object2World;
+uniform highp mat4 _World2Object;
+uniform highp float _MaxRadiusOrKInPaper;
+const highp int SmallDiscKernelSamples = 12;
+const highp vec2[12] SmallDiscKernel = vec2[12]( vec2( -0.326212, -0.40581), vec2( -0.840144, -0.07358), vec2( -0.695914, 0.457137), vec2( -0.203345, 0.620716), vec2( 0.96234, -0.194983), vec2( 0.473434, -0.480026), vec2( 0.519456, 0.767022), vec2( 0.185461, -0.893124), vec2( 0.507431, 0.064425), vec2( 0.89642, 0.412458), vec2( -0.32194, -0.932615), vec2( -0.791559, -0.59771));
+uniform sampler2D _MainTex;
+uniform highp sampler2D _CameraDepthTexture;
+uniform sampler2D _VelTex;
+uniform sampler2D _NeighbourMaxTex;
+uniform sampler2D _NoiseTex;
+uniform sampler2D _TileTexDebug;
+uniform highp vec4 _MainTex_TexelSize;
+uniform highp vec4 _CameraDepthTexture_TexelSize;
+uniform highp vec4 _VelTex_TexelSize;
+uniform highp mat4 _InvViewProj;
+uniform highp mat4 _PrevViewProj;
+uniform highp mat4 _ToPrevViewProjCombined;
+uniform highp float _Jitter;
+uniform highp float _VelocityScale;
+uniform highp float _DisplayVelocityScale;
+uniform highp float _MaxVelocity;
+uniform highp float _MinVelocity;
+uniform highp vec4 _BlurDirectionPacked;
+uniform highp float _SoftZDistance;
+highp float Linear01Depth( in highp float z )
+{
+    return (1.0 / ((_ZBufferParams.x * z) + _ZBufferParams.y));
+}
+highp float cone( in highp vec2 px, in highp vec2 py, in highp vec2 v )
+{
+    return clamp( (1.0 - (length((px - py)) / length(v))), 0.0, 1.0);
+}
+highp float cylinder( in highp vec2 x, in highp vec2 y, in highp vec2 v )
+{
+    highp float lv = length(v);
+    return (1.0 - smoothstep( (0.95 * lv), (1.05 * lv), length((x - y))));
+}
+highp float softDepthCompare( in highp float za, in highp float zb )
+{
+    return clamp( (1.0 - ((za - zb) / _SoftZDistance)), 0.0, 1.0);
+}
+highp vec4 ReconstructionDiscBlur( in v2f i )
+{
+    highp vec2 xf = i.uv;
+    highp vec2 x = i.uv;
+   
+    if ((_MainTex_TexelSize.y < 0.0))
+    {
+        xf.y = (1.0 - xf.y);
+    }
+   
+    highp vec2 x2 = xf;
+    highp vec2 vn = xll_tex2Dlod(_NeighbourMaxTex, vec4(x2, 0.0, 0.0)).xy;
+    highp vec4 cx = xll_tex2Dlod(_MainTex, vec4(x, 0.0, 0.0));
+   
+    highp vec2 vx = xll_tex2Dlod(_VelTex, vec4(xf, 0.0, 0.0)).xy;
+    highp vec4 noise = ((xll_tex2Dlod( _NoiseTex, (vec4(i.uv, 0.0, 0.0) * 11.0)) * 2.0) - 1.0);
+    highp float zx = xll_tex2Dlod(_CameraDepthTexture, vec4(x, 0.0, 0.0)).x;
+   
+    zx = (-Linear01Depth( zx));
+    noise *= (_MainTex_TexelSize.xyxy * _Jitter);
+   
+    highp float weight = 1.0;
+    highp vec4 sum = (cx * weight);
+    highp vec4 jitteredDir = (vn.xyxy + noise.xyyz);
+   
+    jitteredDir = ((max( abs(jitteredDir.xyxy), ((_MainTex_TexelSize.xyxy * _MaxVelocity) * 0.15)) * sign(jitteredDir.xyxy)) * vec4( 1.0, 1.0, -1.0, -1.0));
+    highp int l = 0;
+    for ( ; (l < 12); (l++)) {
+       
+        highp vec4 y = (i.uv.xyxy + ((jitteredDir.xyxy * SmallDiscKernel[l].xyxy) * vec4( 1.0, 1.0, -1.0, -1.0)));
+        highp vec4 yf = y;
+       
+        if ((_MainTex_TexelSize.y < 0.0)){
+            yf.yw = (1.0 - yf.yw);
+        }
+       
+        highp vec2 vy = xll_tex2Dlod( _VelTex, vec4( yf.xy, 0.0, 0.0)).xy;
+        highp float zy = xll_tex2Dlod( _CameraDepthTexture, vec4( y.xy, 0.0, 0.0)).x;
+        zy = (-Linear01Depth( zy));
+       
+        highp float f = softDepthCompare( zx, zy);
+        highp float b = softDepthCompare( zy, zx);
+        highp float alphay = (((b * cone( x, y.xy, vx)) + (f * cone( y.xy, x, vy))) + ((cylinder( y.xy, x, vy) * cylinder( x, y.xy, vx)) * 2.0));
+       
+        highp vec4 cy = xll_tex2Dlod( _MainTex, vec4( y.xy, 0.0, 0.0));
+        sum += (cy * alphay);
+        weight += alphay;
+    }
+   
+    return (sum / weight);
+}
+in highp vec2 xlv_TEXCOORD0;
+out mediump vec4 _fragData;
+void main() {
+    highp vec4 xl_retval;
+    v2f xlt_i;
+    xlt_i.pos = vec4(0.0);
+    xlt_i.uv = vec2(xlv_TEXCOORD0);
+    xl_retval = ReconstructionDiscBlur(xlt_i);
+    _fragData = vec4(xl_retval);
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highpfull-outES3.txt

@@ -0,0 +1,161 @@
+#version 300 es
+uniform highp vec4 _ZBufferParams;
+uniform sampler2D _MainTex;
+uniform highp sampler2D _CameraDepthTexture;
+uniform sampler2D _VelTex;
+uniform sampler2D _NeighbourMaxTex;
+uniform sampler2D _NoiseTex;
+uniform highp vec4 _MainTex_TexelSize;
+uniform highp float _Jitter;
+uniform highp float _MaxVelocity;
+uniform highp float _SoftZDistance;
+in highp vec2 xlv_TEXCOORD0;
+out mediump vec4 _fragData;
+void main ()
+{
+  highp vec2 tmpvar_1;
+  tmpvar_1 = xlv_TEXCOORD0;
+  highp vec4 jitteredDir_3;
+  highp vec4 sum_4;
+  highp float weight_5;
+  highp float zx_6;
+  highp vec2 vx_7;
+  highp vec2 x_8;
+  highp vec2 xf_9;
+  xf_9 = xlv_TEXCOORD0;
+  x_8 = xlv_TEXCOORD0;
+  if ((_MainTex_TexelSize.y < 0.0)) {
+    xf_9.y = (1.0 - xlv_TEXCOORD0.y);
+  };
+  lowp vec4 tmpvar_10;
+  tmpvar_10 = textureLod (_NeighbourMaxTex, xf_9, 0.0);
+  highp vec2 tmpvar_11;
+  tmpvar_11 = tmpvar_10.xy;
+  lowp vec4 tmpvar_12;
+  tmpvar_12 = textureLod (_MainTex, xlv_TEXCOORD0, 0.0);
+  highp vec4 tmpvar_13;
+  tmpvar_13 = tmpvar_12;
+  lowp vec4 tmpvar_14;
+  tmpvar_14 = textureLod (_VelTex, xf_9, 0.0);
+  highp vec2 tmpvar_15;
+  tmpvar_15 = tmpvar_14.xy;
+  vx_7 = tmpvar_15;
+  highp vec4 tmpvar_16;
+  tmpvar_16.zw = vec2(0.0, 0.0);
+  tmpvar_16.xy = xlv_TEXCOORD0;
+  highp vec4 coord_17;
+  coord_17 = (tmpvar_16 * 11.0);
+  lowp vec4 tmpvar_18;
+  tmpvar_18 = textureLod (_NoiseTex, coord_17.xy, coord_17.w);
+  highp vec4 tmpvar_19;
+  tmpvar_19 = ((tmpvar_18 * 2.0) - 1.0);
+  zx_6 = -((1.0/((
+    (_ZBufferParams.x * textureLod (_CameraDepthTexture, xlv_TEXCOORD0, 0.0).x)
+   + _ZBufferParams.y))));
+  weight_5 = 1.0;
+  sum_4 = tmpvar_13;
+  highp vec4 tmpvar_20;
+  tmpvar_20 = (tmpvar_11.xyxy + (tmpvar_19 * (_MainTex_TexelSize.xyxy * _Jitter)).xyyz);
+  jitteredDir_3 = ((max (
+    abs(tmpvar_20.xyxy)
+  , 
+    ((_MainTex_TexelSize.xyxy * _MaxVelocity) * 0.15)
+  ) * sign(tmpvar_20.xyxy)) * vec4(1.0, 1.0, -1.0, -1.0));
+  for (highp int l_2 = 0; l_2 < 12; l_2++) {
+    highp float zy_21;
+    highp vec4 yf_22;
+    highp vec4 tmpvar_23;
+    tmpvar_23 = (tmpvar_1.xyxy + ((jitteredDir_3.xyxy * vec2[12](vec2(-0.326212, -0.40581), vec2(-0.840144, -0.07358), vec2(-0.695914, 0.457137), vec2(-0.203345, 0.620716), vec2(0.96234, -0.194983), vec2(0.473434, -0.480026), vec2(0.519456, 0.767022), vec2(0.185461, -0.893124), vec2(0.507431, 0.064425), vec2(0.89642, 0.412458), vec2(-0.32194, -0.932615), vec2(-0.791559, -0.59771))[l_2].xyxy) * vec4(1.0, 1.0, -1.0, -1.0)));
+    yf_22 = tmpvar_23;
+    if ((_MainTex_TexelSize.y < 0.0)) {
+      yf_22.yw = (1.0 - tmpvar_23.yw);
+    };
+    lowp vec4 tmpvar_24;
+    tmpvar_24 = textureLod (_VelTex, yf_22.xy, 0.0);
+    highp vec2 tmpvar_25;
+    tmpvar_25 = tmpvar_24.xy;
+    zy_21 = -((1.0/((
+      (_ZBufferParams.x * textureLod (_CameraDepthTexture, tmpvar_23.xy, 0.0).x)
+     + _ZBufferParams.y))));
+    highp vec2 x_26;
+    x_26 = (x_8 - tmpvar_23.xy);
+    highp vec2 x_27;
+    x_27 = (tmpvar_23.xy - x_8);
+    highp float tmpvar_28;
+    tmpvar_28 = sqrt(dot (tmpvar_25, tmpvar_25));
+    highp vec2 x_29;
+    x_29 = (tmpvar_23.xy - x_8);
+    highp float edge0_30;
+    edge0_30 = (0.95 * tmpvar_28);
+    highp float tmpvar_31;
+    tmpvar_31 = clamp (((
+      sqrt(dot (x_29, x_29))
+     - edge0_30) / (
+      (1.05 * tmpvar_28)
+     - edge0_30)), 0.0, 1.0);
+    highp float tmpvar_32;
+    tmpvar_32 = sqrt(dot (vx_7, vx_7));
+    highp vec2 x_33;
+    x_33 = (x_8 - tmpvar_23.xy);
+    highp float edge0_34;
+    edge0_34 = (0.95 * tmpvar_32);
+    highp float tmpvar_35;
+    tmpvar_35 = clamp (((
+      sqrt(dot (x_33, x_33))
+     - edge0_34) / (
+      (1.05 * tmpvar_32)
+     - edge0_34)), 0.0, 1.0);
+    highp float tmpvar_36;
+    tmpvar_36 = (((
+      clamp ((1.0 - ((zy_21 - zx_6) / _SoftZDistance)), 0.0, 1.0)
+     * 
+      clamp ((1.0 - (sqrt(
+        dot (x_26, x_26)
+      ) / sqrt(
+        dot (vx_7, vx_7)
+      ))), 0.0, 1.0)
+    ) + (
+      clamp ((1.0 - ((zx_6 - zy_21) / _SoftZDistance)), 0.0, 1.0)
+     * 
+      clamp ((1.0 - (sqrt(
+        dot (x_27, x_27)
+      ) / sqrt(
+        dot (tmpvar_25, tmpvar_25)
+      ))), 0.0, 1.0)
+    )) + ((
+      (1.0 - (tmpvar_31 * (tmpvar_31 * (3.0 - 
+        (2.0 * tmpvar_31)
+      ))))
+     * 
+      (1.0 - (tmpvar_35 * (tmpvar_35 * (3.0 - 
+        (2.0 * tmpvar_35)
+      ))))
+    ) * 2.0));
+    lowp vec4 tmpvar_37;
+    tmpvar_37 = textureLod (_MainTex, tmpvar_23.xy, 0.0);
+    highp vec4 tmpvar_38;
+    tmpvar_38 = tmpvar_37;
+    sum_4 = (sum_4 + (tmpvar_38 * tmpvar_36));
+    weight_5 = (weight_5 + tmpvar_36);
+  };
+  highp vec4 tmpvar_39;
+  tmpvar_39 = (sum_4 / weight_5);
+  _fragData = tmpvar_39;
+}
+
+
+// stats: 99 alu 8 tex 4 flow
+// inputs: 1
+//  #0: xlv_TEXCOORD0 (high float) 2x1 [-1]
+// uniforms: 5 (total size: 0)
+//  #0: _ZBufferParams (high float) 4x1 [-1]
+//  #1: _MainTex_TexelSize (high float) 4x1 [-1]
+//  #2: _Jitter (high float) 1x1 [-1]
+//  #3: _MaxVelocity (high float) 1x1 [-1]
+//  #4: _SoftZDistance (high float) 1x1 [-1]
+// textures: 5
+//  #0: _MainTex (low 2d) 0x0 [-1]
+//  #1: _CameraDepthTexture (high 2d) 0x0 [-1]
+//  #2: _VelTex (low 2d) 0x0 [-1]
+//  #3: _NeighbourMaxTex (low 2d) 0x0 [-1]
+//  #4: _NoiseTex (low 2d) 0x0 [-1]

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highpfull-outES3Metal.txt

@@ -0,0 +1,171 @@
+#include <metal_stdlib>
+using namespace metal;
+constant float2 _xlat_mtl_const1[12] = {float2(-0.326212, -0.40581), float2(-0.840144, -0.07358), float2(-0.695914, 0.457137), float2(-0.203345, 0.620716), float2(0.96234, -0.194983), float2(0.473434, -0.480026), float2(0.519456, 0.767022), float2(0.185461, -0.893124), float2(0.507431, 0.064425), float2(0.89642, 0.412458), float2(-0.32194, -0.932615), float2(-0.791559, -0.59771)};
+struct xlatMtlShaderInput {
+  float2 xlv_TEXCOORD0;
+};
+struct xlatMtlShaderOutput {
+  half4 _fragData [[color(0)]];
+};
+struct xlatMtlShaderUniform {
+  float4 _ZBufferParams;
+  float4 _MainTex_TexelSize;
+  float _Jitter;
+  float _MaxVelocity;
+  float _SoftZDistance;
+};
+fragment xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]], constant xlatMtlShaderUniform& _mtl_u [[buffer(0)]]
+  ,   texture2d<half> _MainTex [[texture(0)]], sampler _mtlsmp__MainTex [[sampler(0)]]
+  ,   texture2d<float> _CameraDepthTexture [[texture(1)]], sampler _mtlsmp__CameraDepthTexture [[sampler(1)]]
+  ,   texture2d<half> _VelTex [[texture(2)]], sampler _mtlsmp__VelTex [[sampler(2)]]
+  ,   texture2d<half> _NeighbourMaxTex [[texture(3)]], sampler _mtlsmp__NeighbourMaxTex [[sampler(3)]]
+  ,   texture2d<half> _NoiseTex [[texture(4)]], sampler _mtlsmp__NoiseTex [[sampler(4)]])
+{
+  xlatMtlShaderOutput _mtl_o;
+  float2 tmpvar_1;
+  tmpvar_1 = _mtl_i.xlv_TEXCOORD0;
+  float4 jitteredDir_3;
+  float4 sum_4;
+  float weight_5;
+  float zx_6;
+  float2 vx_7;
+  float2 x_8;
+  float2 xf_9;
+  xf_9 = _mtl_i.xlv_TEXCOORD0;
+  x_8 = _mtl_i.xlv_TEXCOORD0;
+  if ((_mtl_u._MainTex_TexelSize.y < 0.0)) {
+    xf_9.y = (1.0 - _mtl_i.xlv_TEXCOORD0.y);
+  };
+  half4 tmpvar_10;
+  tmpvar_10 = _NeighbourMaxTex.sample(_mtlsmp__NeighbourMaxTex, (float2)(xf_9), level(0.0));
+  float2 tmpvar_11;
+  tmpvar_11 = float2(tmpvar_10.xy);
+  half4 tmpvar_12;
+  tmpvar_12 = _MainTex.sample(_mtlsmp__MainTex, (float2)(_mtl_i.xlv_TEXCOORD0), level(0.0));
+  float4 tmpvar_13;
+  tmpvar_13 = float4(tmpvar_12);
+  half4 tmpvar_14;
+  tmpvar_14 = _VelTex.sample(_mtlsmp__VelTex, (float2)(xf_9), level(0.0));
+  float2 tmpvar_15;
+  tmpvar_15 = float2(tmpvar_14.xy);
+  vx_7 = tmpvar_15;
+  float4 tmpvar_16;
+  tmpvar_16.zw = float2(0.0, 0.0);
+  tmpvar_16.xy = _mtl_i.xlv_TEXCOORD0;
+  float4 coord_17;
+  coord_17 = (tmpvar_16 * 11.0);
+  half4 tmpvar_18;
+  tmpvar_18 = _NoiseTex.sample(_mtlsmp__NoiseTex, (float2)(coord_17.xy), level(coord_17.w));
+  float4 tmpvar_19;
+  tmpvar_19 = float4(((tmpvar_18 * (half)2.0) - (half)1.0));
+  zx_6 = -((1.0/((
+    (_mtl_u._ZBufferParams.x * _CameraDepthTexture.sample(_mtlsmp__CameraDepthTexture, (float2)(_mtl_i.xlv_TEXCOORD0), level(0.0)).x)
+   + _mtl_u._ZBufferParams.y))));
+  weight_5 = 1.0;
+  sum_4 = tmpvar_13;
+  float4 tmpvar_20;
+  tmpvar_20 = (tmpvar_11.xyxy + (tmpvar_19 * (_mtl_u._MainTex_TexelSize.xyxy * _mtl_u._Jitter)).xyyz);
+  jitteredDir_3 = ((max (
+    abs(tmpvar_20.xyxy)
+  , 
+    ((_mtl_u._MainTex_TexelSize.xyxy * _mtl_u._MaxVelocity) * 0.15)
+  ) * sign(tmpvar_20.xyxy)) * float4(1.0, 1.0, -1.0, -1.0));
+  for (int l_2 = 0; l_2 < 12; l_2++) {
+    float zy_21;
+    float4 yf_22;
+    float4 tmpvar_23;
+    tmpvar_23 = (tmpvar_1.xyxy + ((jitteredDir_3.xyxy * _xlat_mtl_const1[l_2].xyxy) * float4(1.0, 1.0, -1.0, -1.0)));
+    yf_22 = tmpvar_23;
+    if ((_mtl_u._MainTex_TexelSize.y < 0.0)) {
+      yf_22.yw = (1.0 - tmpvar_23.yw);
+    };
+    half4 tmpvar_24;
+    tmpvar_24 = _VelTex.sample(_mtlsmp__VelTex, (float2)(yf_22.xy), level(0.0));
+    float2 tmpvar_25;
+    tmpvar_25 = float2(tmpvar_24.xy);
+    zy_21 = -((1.0/((
+      (_mtl_u._ZBufferParams.x * _CameraDepthTexture.sample(_mtlsmp__CameraDepthTexture, (float2)(tmpvar_23.xy), level(0.0)).x)
+     + _mtl_u._ZBufferParams.y))));
+    float2 x_26;
+    x_26 = (x_8 - tmpvar_23.xy);
+    float2 x_27;
+    x_27 = (tmpvar_23.xy - x_8);
+    float tmpvar_28;
+    tmpvar_28 = sqrt(dot (tmpvar_25, tmpvar_25));
+    float2 x_29;
+    x_29 = (tmpvar_23.xy - x_8);
+    float edge0_30;
+    edge0_30 = (0.95 * tmpvar_28);
+    float tmpvar_31;
+    tmpvar_31 = clamp (((
+      sqrt(dot (x_29, x_29))
+     - edge0_30) / (
+      (1.05 * tmpvar_28)
+     - edge0_30)), 0.0, 1.0);
+    float tmpvar_32;
+    tmpvar_32 = sqrt(dot (vx_7, vx_7));
+    float2 x_33;
+    x_33 = (x_8 - tmpvar_23.xy);
+    float edge0_34;
+    edge0_34 = (0.95 * tmpvar_32);
+    float tmpvar_35;
+    tmpvar_35 = clamp (((
+      sqrt(dot (x_33, x_33))
+     - edge0_34) / (
+      (1.05 * tmpvar_32)
+     - edge0_34)), 0.0, 1.0);
+    float tmpvar_36;
+    tmpvar_36 = (((
+      clamp ((1.0 - ((zy_21 - zx_6) / _mtl_u._SoftZDistance)), 0.0, 1.0)
+     * 
+      clamp ((1.0 - (sqrt(
+        dot (x_26, x_26)
+      ) / sqrt(
+        dot (vx_7, vx_7)
+      ))), 0.0, 1.0)
+    ) + (
+      clamp ((1.0 - ((zx_6 - zy_21) / _mtl_u._SoftZDistance)), 0.0, 1.0)
+     * 
+      clamp ((1.0 - (sqrt(
+        dot (x_27, x_27)
+      ) / sqrt(
+        dot (tmpvar_25, tmpvar_25)
+      ))), 0.0, 1.0)
+    )) + ((
+      (1.0 - (tmpvar_31 * (tmpvar_31 * (3.0 - 
+        (2.0 * tmpvar_31)
+      ))))
+     * 
+      (1.0 - (tmpvar_35 * (tmpvar_35 * (3.0 - 
+        (2.0 * tmpvar_35)
+      ))))
+    ) * 2.0));
+    half4 tmpvar_37;
+    tmpvar_37 = _MainTex.sample(_mtlsmp__MainTex, (float2)(tmpvar_23.xy), level(0.0));
+    float4 tmpvar_38;
+    tmpvar_38 = float4(tmpvar_37);
+    sum_4 = (sum_4 + (tmpvar_38 * tmpvar_36));
+    weight_5 = (weight_5 + tmpvar_36);
+  };
+  float4 tmpvar_39;
+  tmpvar_39 = (sum_4 / weight_5);
+  _mtl_o._fragData = half4(tmpvar_39);
+  return _mtl_o;
+}
+
+
+// stats: 99 alu 8 tex 4 flow
+// inputs: 1
+//  #0: xlv_TEXCOORD0 (high float) 2x1 [-1]
+// uniforms: 5 (total size: 44)
+//  #0: _ZBufferParams (high float) 4x1 [-1] loc 0
+//  #1: _MainTex_TexelSize (high float) 4x1 [-1] loc 16
+//  #2: _Jitter (high float) 1x1 [-1] loc 32
+//  #3: _MaxVelocity (high float) 1x1 [-1] loc 36
+//  #4: _SoftZDistance (high float) 1x1 [-1] loc 40
+// textures: 5
+//  #0: _MainTex (low 2d) 0x0 [-1] loc 0
+//  #1: _CameraDepthTexture (high 2d) 0x0 [-1] loc 1
+//  #2: _VelTex (low 2d) 0x0 [-1] loc 2
+//  #3: _NeighbourMaxTex (low 2d) 0x0 [-1] loc 3
+//  #4: _NoiseTex (low 2d) 0x0 [-1] loc 4

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/loop-foraliasinductor-inES.txt

@@ -0,0 +1,29 @@
+struct v2f {
+    highp vec2 uv;
+    highp vec3 nl;
+};
+uniform sampler2D _MainTex;
+uniform highp vec4 _TerrainTreeLightColors[4];
+lowp vec4 xlat_main (in v2f i) {
+    lowp vec4 col = texture2D( _MainTex, i.uv);
+    mediump vec3 light = vec3(0.0);
+    if(col.x >= 0.0) {
+        for (float j = 0.0; (j < i.uv.x); (j++)) {
+            light += col.xyz;
+        }
+    }
+    if(col.x >= 1.0) {
+         float j = i.uv.y;
+         j *= sin(j);
+         light += col.xyz*j;
+    }
+    return vec4(light, 1.0);
+}
+varying highp vec2 xlv_uv;
+varying highp vec3 xlv_nl;
+void main() {
+    v2f i;
+    i.uv = xlv_uv;
+    i.nl = xlv_nl;
+    gl_FragData[0] = xlat_main(i);
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/loop-foraliasinductor-outES.txt

@@ -0,0 +1,36 @@
+uniform sampler2D _MainTex;
+varying highp vec2 xlv_uv;
+void main ()
+{
+  lowp vec4 tmpvar_1;
+  highp vec2 tmpvar_2;
+  tmpvar_2 = xlv_uv;
+  mediump vec3 light_3;
+  lowp vec4 col_4;
+  lowp vec4 tmpvar_5;
+  tmpvar_5 = texture2D (_MainTex, xlv_uv);
+  col_4 = tmpvar_5;
+  light_3 = vec3(0.0, 0.0, 0.0);
+  if ((tmpvar_5.x >= 0.0)) {
+    for (highp float j_6 = 0.0; j_6 < tmpvar_2.x; j_6 += 1.0) {
+      light_3 = (light_3 + col_4.xyz);
+    };
+  };
+  if ((tmpvar_5.x >= 1.0)) {
+    highp float j_7;
+    j_7 = (xlv_uv.y * sin(xlv_uv.y));
+    light_3 = (light_3 + (tmpvar_5.xyz * j_7));
+  };
+  mediump vec4 tmpvar_8;
+  tmpvar_8.w = 1.0;
+  tmpvar_8.xyz = light_3;
+  tmpvar_1 = tmpvar_8;
+  gl_FragData[0] = tmpvar_1;
+}
+
+
+// stats: 12 alu 1 tex 4 flow
+// inputs: 1
+//  #0: xlv_uv (high float) 2x1 [-1]
+// textures: 1
+//  #0: _MainTex (low 2d) 0x0 [-1]

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/loop-forwronginductor-inES.txt

@@ -0,0 +1,24 @@
+struct v2f {
+    highp vec2 uv;
+    highp vec3 nl;
+};
+uniform sampler2D _MainTex;
+uniform highp vec4 _TerrainTreeLightColors[4];
+lowp vec4 xlat_main (in v2f i) {
+    lowp vec4 col = texture2D( _MainTex, i.uv);
+    mediump vec3 light = vec3(0.0);
+    if(col.x >= 0.0) {
+        for (float j = 0.0; (j < i.uv.x); (j++)) {
+            light += col.xyz;
+        }
+    }
+    return vec4(light, 1.0);
+}
+varying highp vec2 xlv_uv;
+varying highp vec3 xlv_nl;
+void main() {
+    v2f i;
+    i.uv = xlv_uv;
+    i.nl = xlv_nl;
+    gl_FragData[0] = xlat_main(i);
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/loop-forwronginductor-outES.txt

@@ -0,0 +1,31 @@
+uniform sampler2D _MainTex;
+varying highp vec2 xlv_uv;
+void main ()
+{
+  lowp vec4 tmpvar_1;
+  highp vec2 tmpvar_2;
+  tmpvar_2 = xlv_uv;
+  mediump vec3 light_3;
+  lowp vec4 col_4;
+  lowp vec4 tmpvar_5;
+  tmpvar_5 = texture2D (_MainTex, xlv_uv);
+  col_4 = tmpvar_5;
+  light_3 = vec3(0.0, 0.0, 0.0);
+  if ((tmpvar_5.x >= 0.0)) {
+    for (highp float j_6 = 0.0; j_6 < tmpvar_2.x; j_6 += 1.0) {
+      light_3 = (light_3 + col_4.xyz);
+    };
+  };
+  mediump vec4 tmpvar_7;
+  tmpvar_7.w = 1.0;
+  tmpvar_7.xyz = light_3;
+  tmpvar_1 = tmpvar_7;
+  gl_FragData[0] = tmpvar_1;
+}
+
+
+// stats: 7 alu 1 tex 3 flow
+// inputs: 1
+//  #0: xlv_uv (high float) 2x1 [-1]
+// textures: 1
+//  #0: _MainTex (low 2d) 0x0 [-1]

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/matrix-cast-types-inES3.txt

@@ -0,0 +1,94 @@
+#version 300 es
+
+// Shader below was causing invalid matrix assignment (different types, i.e. half3x3 vs float3x3)
+// in the resulting Metal code. Caused by some combination of matrix transposes and other operations
+// on them.
+
+mat3 xll_transpose_mf3x3(mat3 m) {
+  return mat3( m[0][0], m[1][0], m[2][0],
+               m[0][1], m[1][1], m[2][1],
+               m[0][2], m[1][2], m[2][2]);
+}
+vec3 xll_matrixindex_mf3x3_i (mat3 m, int i) { vec3 v; v.x=m[0][i]; v.y=m[1][i]; v.z=m[2][i]; return v; }
+struct SurfaceOutput {
+    lowp vec3 Albedo;
+    lowp vec3 Normal;
+    lowp vec3 Emission;
+    mediump float Specular;
+    lowp float Gloss;
+    lowp float Alpha;
+};
+struct Input {
+    highp vec2 uv_PanelTex;
+    highp vec2 uv2_DecalTex;
+};
+struct v2f_surf {
+    highp vec4 pos;
+    highp vec4 pack0;
+    highp vec4 tSpace0;
+    highp vec4 tSpace1;
+    highp vec4 tSpace2;
+};
+uniform highp vec4 _WorldSpaceLightPos0;
+uniform sampler2D _PanelNorm;
+uniform sampler2D _DecalNorm;
+highp vec3 UnityWorldSpaceLightDir( in highp vec3 worldPos ) {
+    return (_WorldSpaceLightPos0.xyz - (worldPos * _WorldSpaceLightPos0.w));
+}
+void surf( in Input IN, inout SurfaceOutput o ) {
+   
+    lowp vec3 baseNormal = ((texture( _DecalNorm, IN.uv2_DecalTex).xyz * 2.0) - 1.0);
+    lowp vec3 detailNormal = ((texture( _PanelNorm, IN.uv_PanelTex).xyz * 2.0) - 1.0);
+    highp mat3 nBasis = xll_transpose_mf3x3(mat3( vec3( baseNormal.z, baseNormal.y, (-baseNormal.x)), vec3( baseNormal.x, baseNormal.z, (-baseNormal.y)), vec3( baseNormal.x, baseNormal.y, baseNormal.z)));
+   
+    lowp vec3 combinedNormal = normalize((((detailNormal.x * xll_matrixindex_mf3x3_i (nBasis, 0)) + (detailNormal.y * xll_matrixindex_mf3x3_i (nBasis, 1))) + (detailNormal.z * xll_matrixindex_mf3x3_i (nBasis, 2))));
+    combinedNormal *= 1.0;
+    o.Normal = combinedNormal;
+}
+lowp vec4 frag_surf( in v2f_surf IN ) {
+    Input surfIN;
+   
+    surfIN.uv_PanelTex = IN.pack0.xy;
+    surfIN.uv2_DecalTex = IN.pack0.zw;
+    highp vec3 worldPos = vec3( IN.tSpace0.w, IN.tSpace1.w, IN.tSpace2.w);
+   
+    lowp vec3 lightDir = normalize(UnityWorldSpaceLightDir( worldPos));
+   
+    SurfaceOutput o;
+    o.Albedo = vec3( 0.0);
+    o.Emission = vec3( 0.0);
+   
+    o.Specular = 0.0;
+    o.Alpha = 0.0;
+    o.Gloss = 0.0;
+    lowp vec3 normalWorldVertex = vec3( 0.0, 0.0, 1.0);
+   
+    surf( surfIN, o);
+    lowp vec3 worldN;
+    worldN.x = dot( IN.tSpace0.xyz, o.Normal);
+    worldN.y = dot( IN.tSpace1.xyz, o.Normal);
+   
+    worldN.z = dot( IN.tSpace2.xyz, o.Normal);
+    o.Normal = worldN;
+   
+    lowp vec4 res;
+    res.xyz = ((o.Normal * 0.5) + 0.5);
+    res.w = o.Specular;
+    return res;
+}
+in highp vec4 xlv_TEXCOORD0;
+in highp vec4 xlv_TEXCOORD1;
+in highp vec4 xlv_TEXCOORD2;
+in highp vec4 xlv_TEXCOORD3;
+out lowp vec4 _fragData;
+void main() {
+    lowp vec4 xl_retval;
+    v2f_surf xlt_IN;
+    xlt_IN.pos = vec4(0.0);
+    xlt_IN.pack0 = vec4(xlv_TEXCOORD0);
+    xlt_IN.tSpace0 = vec4(xlv_TEXCOORD1);
+    xlt_IN.tSpace1 = vec4(xlv_TEXCOORD2);
+    xlt_IN.tSpace2 = vec4(xlv_TEXCOORD3);
+    xl_retval = frag_surf( xlt_IN);
+    _fragData = vec4(xl_retval);
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/matrix-cast-types-outES3.txt

@@ -0,0 +1,78 @@
+#version 300 es
+uniform sampler2D _PanelNorm;
+uniform sampler2D _DecalNorm;
+in highp vec4 xlv_TEXCOORD0;
+in highp vec4 xlv_TEXCOORD1;
+in highp vec4 xlv_TEXCOORD2;
+in highp vec4 xlv_TEXCOORD3;
+out lowp vec4 _fragData;
+void main ()
+{
+  lowp vec4 res_1;
+  lowp vec3 worldN_2;
+  lowp vec3 combinedNormal_3;
+  lowp vec3 tmpvar_4;
+  tmpvar_4 = ((texture (_DecalNorm, xlv_TEXCOORD0.zw).xyz * 2.0) - 1.0);
+  lowp vec3 tmpvar_5;
+  tmpvar_5 = ((texture (_PanelNorm, xlv_TEXCOORD0.xy).xyz * 2.0) - 1.0);
+  lowp vec3 tmpvar_6;
+  tmpvar_6.x = tmpvar_4.z;
+  tmpvar_6.y = tmpvar_4.y;
+  tmpvar_6.z = -(tmpvar_4.x);
+  lowp vec3 tmpvar_7;
+  tmpvar_7.x = tmpvar_4.x;
+  tmpvar_7.y = tmpvar_4.z;
+  tmpvar_7.z = -(tmpvar_4.y);
+  highp mat3 tmpvar_8;
+  lowp mat3 tmpvar_9;
+  tmpvar_9[uint(0)].x = tmpvar_6.x;
+  tmpvar_9[uint(0)].y = tmpvar_7.x;
+  tmpvar_9[uint(0)].z = tmpvar_4.x;
+  tmpvar_9[1u].x = tmpvar_6.y;
+  tmpvar_9[1u].y = tmpvar_7.y;
+  tmpvar_9[1u].z = tmpvar_4.y;
+  tmpvar_9[2u].x = tmpvar_6.z;
+  tmpvar_9[2u].y = tmpvar_7.z;
+  tmpvar_9[2u].z = tmpvar_4.z;
+  tmpvar_8 = tmpvar_9;
+  highp vec3 v_10;
+  v_10.x = tmpvar_8[0].x;
+  v_10.y = tmpvar_8[1].x;
+  v_10.z = tmpvar_8[2].x;
+  highp vec3 v_11;
+  v_11.x = tmpvar_8[0].y;
+  v_11.y = tmpvar_8[1].y;
+  v_11.z = tmpvar_8[2].y;
+  highp vec3 v_12;
+  v_12.x = tmpvar_8[0].z;
+  v_12.y = tmpvar_8[1].z;
+  v_12.z = tmpvar_8[2].z;
+  combinedNormal_3 = normalize(((
+    (tmpvar_5.x * v_10)
+   + 
+    (tmpvar_5.y * v_11)
+  ) + (tmpvar_5.z * v_12)));
+  highp float tmpvar_13;
+  tmpvar_13 = dot (xlv_TEXCOORD1.xyz, combinedNormal_3);
+  worldN_2.x = tmpvar_13;
+  highp float tmpvar_14;
+  tmpvar_14 = dot (xlv_TEXCOORD2.xyz, combinedNormal_3);
+  worldN_2.y = tmpvar_14;
+  highp float tmpvar_15;
+  tmpvar_15 = dot (xlv_TEXCOORD3.xyz, combinedNormal_3);
+  worldN_2.z = tmpvar_15;
+  res_1.xyz = ((worldN_2 * 0.5) + 0.5);
+  res_1.w = 0.0;
+  _fragData = res_1;
+}
+
+
+// stats: 18 alu 2 tex 0 flow
+// inputs: 4
+//  #0: xlv_TEXCOORD0 (high float) 4x1 [-1]
+//  #1: xlv_TEXCOORD1 (high float) 4x1 [-1]
+//  #2: xlv_TEXCOORD2 (high float) 4x1 [-1]
+//  #3: xlv_TEXCOORD3 (high float) 4x1 [-1]
+// textures: 2
+//  #0: _PanelNorm (low 2d) 0x0 [-1]
+//  #1: _DecalNorm (low 2d) 0x0 [-1]

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/matrix-cast-types-outES3Metal.txt

@@ -0,0 +1,93 @@
+#include <metal_stdlib>
+using namespace metal;
+inline float4x4 _xlcast_float4x4(half4x4 v) { return float4x4(float4(v[0]), float4(v[1]), float4(v[2]), float4(v[3])); }
+inline float3x3 _xlcast_float3x3(half3x3 v) { return float3x3(float3(v[0]), float3(v[1]), float3(v[2])); }
+inline float2x2 _xlcast_float2x2(half2x2 v) { return float2x2(float2(v[0]), float2(v[1])); }
+inline half4x4 _xlcast_half4x4(float4x4 v) { return half4x4(half4(v[0]), half4(v[1]), half4(v[2]), half4(v[3])); }
+inline half3x3 _xlcast_half3x3(float3x3 v) { return half3x3(half3(v[0]), half3(v[1]), half3(v[2])); }
+inline half2x2 _xlcast_half2x2(float2x2 v) { return half2x2(half2(v[0]), half2(v[1])); }
+struct xlatMtlShaderInput {
+  float4 xlv_TEXCOORD0;
+  float4 xlv_TEXCOORD1;
+  float4 xlv_TEXCOORD2;
+  float4 xlv_TEXCOORD3;
+};
+struct xlatMtlShaderOutput {
+  half4 _fragData [[color(0)]];
+};
+struct xlatMtlShaderUniform {
+};
+fragment xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]], constant xlatMtlShaderUniform& _mtl_u [[buffer(0)]]
+  ,   texture2d<half> _PanelNorm [[texture(0)]], sampler _mtlsmp__PanelNorm [[sampler(0)]]
+  ,   texture2d<half> _DecalNorm [[texture(1)]], sampler _mtlsmp__DecalNorm [[sampler(1)]])
+{
+  xlatMtlShaderOutput _mtl_o;
+  half4 res_1;
+  half3 worldN_2;
+  half3 combinedNormal_3;
+  half3 tmpvar_4;
+  tmpvar_4 = ((_DecalNorm.sample(_mtlsmp__DecalNorm, (float2)(_mtl_i.xlv_TEXCOORD0.zw)).xyz * (half)2.0) - (half)1.0);
+  half3 tmpvar_5;
+  tmpvar_5 = ((_PanelNorm.sample(_mtlsmp__PanelNorm, (float2)(_mtl_i.xlv_TEXCOORD0.xy)).xyz * (half)2.0) - (half)1.0);
+  half3 tmpvar_6;
+  tmpvar_6.x = tmpvar_4.z;
+  tmpvar_6.y = tmpvar_4.y;
+  tmpvar_6.z = -(tmpvar_4.x);
+  half3 tmpvar_7;
+  tmpvar_7.x = tmpvar_4.x;
+  tmpvar_7.y = tmpvar_4.z;
+  tmpvar_7.z = -(tmpvar_4.y);
+  float3x3 tmpvar_8;
+  half3x3 tmpvar_9;
+  tmpvar_9[0].x = tmpvar_6.x;
+  tmpvar_9[0].y = tmpvar_7.x;
+  tmpvar_9[0].z = tmpvar_4.x;
+  tmpvar_9[1].x = tmpvar_6.y;
+  tmpvar_9[1].y = tmpvar_7.y;
+  tmpvar_9[1].z = tmpvar_4.y;
+  tmpvar_9[2].x = tmpvar_6.z;
+  tmpvar_9[2].y = tmpvar_7.z;
+  tmpvar_9[2].z = tmpvar_4.z;
+  tmpvar_8 = _xlcast_float3x3(tmpvar_9);
+  float3 v_10;
+  v_10.x = tmpvar_8[0].x;
+  v_10.y = tmpvar_8[1].x;
+  v_10.z = tmpvar_8[2].x;
+  float3 v_11;
+  v_11.x = tmpvar_8[0].y;
+  v_11.y = tmpvar_8[1].y;
+  v_11.z = tmpvar_8[2].y;
+  float3 v_12;
+  v_12.x = tmpvar_8[0].z;
+  v_12.y = tmpvar_8[1].z;
+  v_12.z = tmpvar_8[2].z;
+  combinedNormal_3 = normalize(((
+    ((half3)((float)tmpvar_5.x * v_10))
+   + 
+    ((half3)((float)tmpvar_5.y * v_11))
+  ) + ((half3)((float)tmpvar_5.z * v_12))));
+  float tmpvar_13;
+  tmpvar_13 = dot (_mtl_i.xlv_TEXCOORD1.xyz, (float3)combinedNormal_3);
+  worldN_2.x = half(tmpvar_13);
+  float tmpvar_14;
+  tmpvar_14 = dot (_mtl_i.xlv_TEXCOORD2.xyz, (float3)combinedNormal_3);
+  worldN_2.y = half(tmpvar_14);
+  float tmpvar_15;
+  tmpvar_15 = dot (_mtl_i.xlv_TEXCOORD3.xyz, (float3)combinedNormal_3);
+  worldN_2.z = half(tmpvar_15);
+  res_1.xyz = ((worldN_2 * (half)0.5) + (half)0.5);
+  res_1.w = half(0.0);
+  _mtl_o._fragData = res_1;
+  return _mtl_o;
+}
+
+
+// stats: 18 alu 2 tex 0 flow
+// inputs: 4
+//  #0: xlv_TEXCOORD0 (high float) 4x1 [-1]
+//  #1: xlv_TEXCOORD1 (high float) 4x1 [-1]
+//  #2: xlv_TEXCOORD2 (high float) 4x1 [-1]
+//  #3: xlv_TEXCOORD3 (high float) 4x1 [-1]
+// textures: 2
+//  #0: _PanelNorm (low 2d) 0x0 [-1] loc 0
+//  #1: _DecalNorm (low 2d) 0x0 [-1] loc 1

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/matrix-ops-inES3.txt

@@ -0,0 +1,30 @@
+#version 300 es
+out mediump vec4 _fragData;
+uniform highp float _Speed;
+uniform highp vec4 _Time;
+highp vec4 func( in highp vec2 uv )
+{
+    highp float s = sin(_Speed * _Time.x);
+    highp float c = cos(_Speed * _Time.x);
+
+    highp mat2 rotationMatrix = mat2(c, s, -s, c);
+    // various operations on a matrix
+    rotationMatrix = rotationMatrix * 2.0;
+    rotationMatrix = rotationMatrix - 1.0;
+    rotationMatrix = s - rotationMatrix;
+    rotationMatrix = c + rotationMatrix;
+    rotationMatrix /= s;
+
+    mediump mat2 halfMatrix = mat2(c, s, -s, c);
+    halfMatrix = halfMatrix * 2.0;
+    halfMatrix = halfMatrix - 1.0;
+    halfMatrix = s - halfMatrix;
+    halfMatrix = c + halfMatrix;
+    halfMatrix /= s;
+
+    return vec4((rotationMatrix * uv), (halfMatrix * uv));
+}
+in highp vec2 uv;
+void main() {
+    _fragData = func(uv);
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/matrix-ops-outES3.txt

@@ -0,0 +1,49 @@
+#version 300 es
+out mediump vec4 _fragData;
+uniform highp float _Speed;
+uniform highp vec4 _Time;
+in highp vec2 uv;
+void main ()
+{
+  mediump mat2 halfMatrix_1;
+  highp mat2 rotationMatrix_2;
+  highp float tmpvar_3;
+  highp float tmpvar_4;
+  tmpvar_4 = (_Speed * _Time.x);
+  tmpvar_3 = sin(tmpvar_4);
+  highp float tmpvar_5;
+  tmpvar_5 = cos(tmpvar_4);
+  highp mat2 tmpvar_6;
+  tmpvar_6[uint(0)].x = tmpvar_5;
+  tmpvar_6[uint(0)].y = tmpvar_3;
+  tmpvar_6[1u].x = -(tmpvar_3);
+  tmpvar_6[1u].y = tmpvar_5;
+  rotationMatrix_2 = (tmpvar_6 * 2.0);
+  rotationMatrix_2 = (rotationMatrix_2 - 1.0);
+  rotationMatrix_2 = (tmpvar_3 - rotationMatrix_2);
+  rotationMatrix_2 = (tmpvar_5 + rotationMatrix_2);
+  rotationMatrix_2 = (rotationMatrix_2 / tmpvar_3);
+  highp mat2 tmpvar_7;
+  tmpvar_7[uint(0)].x = tmpvar_5;
+  tmpvar_7[uint(0)].y = tmpvar_3;
+  tmpvar_7[1u].x = -(tmpvar_3);
+  tmpvar_7[1u].y = tmpvar_5;
+  halfMatrix_1 = tmpvar_7;
+  halfMatrix_1 = (halfMatrix_1 * 2.0);
+  halfMatrix_1 = (halfMatrix_1 - 1.0);
+  halfMatrix_1 = (tmpvar_3 - halfMatrix_1);
+  halfMatrix_1 = (tmpvar_5 + halfMatrix_1);
+  halfMatrix_1 = (halfMatrix_1 / tmpvar_3);
+  highp vec4 tmpvar_8;
+  tmpvar_8.xy = (rotationMatrix_2 * uv);
+  tmpvar_8.zw = (halfMatrix_1 * uv);
+  _fragData = tmpvar_8;
+}
+
+
+// stats: 17 alu 0 tex 0 flow
+// inputs: 1
+//  #0: uv (high float) 2x1 [-1]
+// uniforms: 2 (total size: 0)
+//  #0: _Speed (high float) 1x1 [-1]
+//  #1: _Time (high float) 4x1 [-1]

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/matrix-ops-outES3Metal.txt

@@ -0,0 +1,70 @@
+#include <metal_stdlib>
+using namespace metal;
+inline float4x4 _xlinit_float4x4(float v) { return float4x4(float4(v), float4(v), float4(v), float4(v)); }
+inline float3x3 _xlinit_float3x3(float v) { return float3x3(float3(v), float3(v), float3(v)); }
+inline float2x2 _xlinit_float2x2(float v) { return float2x2(float2(v), float2(v)); }
+inline half4x4 _xlinit_half4x4(half v) { return half4x4(half4(v), half4(v), half4(v), half4(v)); }
+inline half3x3 _xlinit_half3x3(half v) { return half3x3(half3(v), half3(v), half3(v)); }
+inline half2x2 _xlinit_half2x2(half v) { return half2x2(half2(v), half2(v)); }
+inline float4x4 _xlcast_float4x4(half4x4 v) { return float4x4(float4(v[0]), float4(v[1]), float4(v[2]), float4(v[3])); }
+inline float3x3 _xlcast_float3x3(half3x3 v) { return float3x3(float3(v[0]), float3(v[1]), float3(v[2])); }
+inline float2x2 _xlcast_float2x2(half2x2 v) { return float2x2(float2(v[0]), float2(v[1])); }
+inline half4x4 _xlcast_half4x4(float4x4 v) { return half4x4(half4(v[0]), half4(v[1]), half4(v[2]), half4(v[3])); }
+inline half3x3 _xlcast_half3x3(float3x3 v) { return half3x3(half3(v[0]), half3(v[1]), half3(v[2])); }
+inline half2x2 _xlcast_half2x2(float2x2 v) { return half2x2(half2(v[0]), half2(v[1])); }
+struct xlatMtlShaderInput {
+  float2 uv;
+};
+struct xlatMtlShaderOutput {
+  half4 _fragData [[color(0)]];
+};
+struct xlatMtlShaderUniform {
+  float _Speed;
+  float4 _Time;
+};
+fragment xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]], constant xlatMtlShaderUniform& _mtl_u [[buffer(0)]])
+{
+  xlatMtlShaderOutput _mtl_o;
+  half2x2 halfMatrix_1;
+  float2x2 rotationMatrix_2;
+  float tmpvar_3;
+  float tmpvar_4;
+  tmpvar_4 = (_mtl_u._Speed * _mtl_u._Time.x);
+  tmpvar_3 = sin(tmpvar_4);
+  float tmpvar_5;
+  tmpvar_5 = cos(tmpvar_4);
+  float2x2 tmpvar_6;
+  tmpvar_6[0].x = tmpvar_5;
+  tmpvar_6[0].y = tmpvar_3;
+  tmpvar_6[1].x = -(tmpvar_3);
+  tmpvar_6[1].y = tmpvar_5;
+  rotationMatrix_2 = (tmpvar_6 * 2.0);
+  rotationMatrix_2 = (rotationMatrix_2 - _xlinit_float2x2(1.0));
+  rotationMatrix_2 = (_xlinit_float2x2(tmpvar_3) - rotationMatrix_2);
+  rotationMatrix_2 = (_xlinit_float2x2(tmpvar_5) + rotationMatrix_2);
+  rotationMatrix_2 = (rotationMatrix_2 * (1.0/(tmpvar_3)));
+  float2x2 tmpvar_7;
+  tmpvar_7[0].x = tmpvar_5;
+  tmpvar_7[0].y = tmpvar_3;
+  tmpvar_7[1].x = -(tmpvar_3);
+  tmpvar_7[1].y = tmpvar_5;
+  halfMatrix_1 = _xlcast_half2x2(tmpvar_7);
+  halfMatrix_1 = (halfMatrix_1 * (half)2.0);
+  halfMatrix_1 = (halfMatrix_1 - _xlinit_half2x2(1.0));
+  halfMatrix_1 = _xlcast_half2x2(((float2x2)(_xlinit_half2x2(tmpvar_3) - halfMatrix_1)));
+  halfMatrix_1 = _xlcast_half2x2(((float2x2)(_xlinit_half2x2(tmpvar_5) + halfMatrix_1)));
+  halfMatrix_1 = _xlcast_half2x2(((float2x2)(halfMatrix_1 * (1.0h/half(tmpvar_3)))));
+  float4 tmpvar_8;
+  tmpvar_8.xy = (rotationMatrix_2 * _mtl_i.uv);
+  tmpvar_8.zw = ((float2)(halfMatrix_1 * (half2)_mtl_i.uv));
+  _mtl_o._fragData = half4(tmpvar_8);
+  return _mtl_o;
+}
+
+
+// stats: 17 alu 0 tex 0 flow
+// inputs: 1
+//  #0: uv (high float) 2x1 [-1]
+// uniforms: 2 (total size: 32)
+//  #0: _Speed (high float) 1x1 [-1] loc 0
+//  #1: _Time (high float) 4x1 [-1] loc 16

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/mrt-outES.txt

@@ -1,4 +1,4 @@
-#extension GL_EXT_draw_buffers : require
+#extension GL_EXT_draw_buffers : enable
 void main ()
 {
   gl_FragData[0] = vec4(0.0, 0.0, 0.0, 0.0);

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/opt-movevars-sideeffect2-outES.txt

@@ -12,7 +12,8 @@ void main ()
     discard;
   };
   c_1 = 0.0;
-  for (highp int i_2 = tmpvar_3; i_2 < 4; i_2++, c_1 = (c_1 + xx)) {
+  for (highp int i_2 = tmpvar_3; i_2 < 4; i_2++) {
+    c_1 = (c_1 + xx);
   };
   lowp vec4 tmpvar_4;
   tmpvar_4 = vec4(c_1);

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/prec-inlineexpr1-outES.txt

@@ -5,13 +5,13 @@ uniform mediump float _EmberFadeStart;
 varying mediump vec2 xlv_TEXCOORD0;
 void main ()
 {
-  mediump float x_1;
-  x_1 = ((_EmberFadeStart - 0.05) / (_EmberFadeStart - _EmberFadeEnd));
-  lowp float tmpvar_2;
-  tmpvar_2 = clamp (x_1, 0.0, 1.0);
+  lowp float tmpvar_1;
+  mediump float tmpvar_2;
+  tmpvar_2 = clamp (((_EmberFadeStart - 0.05) / (_EmberFadeStart - _EmberFadeEnd)), 0.0, 1.0);
+  tmpvar_1 = tmpvar_2;
   lowp vec4 tmpvar_3;
   tmpvar_3.w = 1.0;
-  tmpvar_3.xyz = mix (texture2D (_MainTex, xlv_TEXCOORD0).xyz, texture2D (_BurntTex, xlv_TEXCOORD0).xyz, vec3(tmpvar_2));
+  tmpvar_3.xyz = mix (texture2D (_MainTex, xlv_TEXCOORD0).xyz, texture2D (_BurntTex, xlv_TEXCOORD0).xyz, vec3(tmpvar_1));
   gl_FragColor = tmpvar_3;
 }
 

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/sampler-precision-outES.txt

@@ -11,21 +11,17 @@ void main ()
   lowp vec4 tmpvar_2;
   tmpvar_2 = texture2D (texlow, varUV.xy);
   c_1 = tmpvar_2;
-  mediump vec4 tmpvar_3;
-  tmpvar_3 = texture2D (texmed, varUV.xy);
+  c_1 = (c_1 + texture2D (texmed, varUV.xy));
+  highp vec4 tmpvar_3;
+  tmpvar_3 = texture2D (texhigh, varUV.xy);
   c_1 = (c_1 + tmpvar_3);
-  highp vec4 tmpvar_4;
-  tmpvar_4 = texture2D (texhigh, varUV.xy);
+  lowp vec4 tmpvar_4;
+  tmpvar_4 = textureCube (cubelow, varUV.xyz);
   c_1 = (c_1 + tmpvar_4);
-  lowp vec4 tmpvar_5;
-  tmpvar_5 = textureCube (cubelow, varUV.xyz);
+  c_1 = (c_1 + textureCube (cubemed, varUV.xyz));
+  highp vec4 tmpvar_5;
+  tmpvar_5 = textureCube (cubehigh, varUV.xyz);
   c_1 = (c_1 + tmpvar_5);
-  mediump vec4 tmpvar_6;
-  tmpvar_6 = textureCube (cubemed, varUV.xyz);
-  c_1 = (c_1 + tmpvar_6);
-  highp vec4 tmpvar_7;
-  tmpvar_7 = textureCube (cubehigh, varUV.xyz);
-  c_1 = (c_1 + tmpvar_7);
   gl_FragData[0] = c_1;
 }
 

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/sampler-precision-outES3.txt

@@ -13,21 +13,17 @@ void main ()
   lowp vec4 tmpvar_2;
   tmpvar_2 = texture (texlow, varUV.xy);
   c_1 = tmpvar_2;
-  mediump vec4 tmpvar_3;
-  tmpvar_3 = texture (texmed, varUV.xy);
+  c_1 = (c_1 + texture (texmed, varUV.xy));
+  highp vec4 tmpvar_3;
+  tmpvar_3 = texture (texhigh, varUV.xy);
   c_1 = (c_1 + tmpvar_3);
-  highp vec4 tmpvar_4;
-  tmpvar_4 = texture (texhigh, varUV.xy);
+  lowp vec4 tmpvar_4;
+  tmpvar_4 = texture (cubelow, varUV.xyz);
   c_1 = (c_1 + tmpvar_4);
-  lowp vec4 tmpvar_5;
-  tmpvar_5 = texture (cubelow, varUV.xyz);
+  c_1 = (c_1 + texture (cubemed, varUV.xyz));
+  highp vec4 tmpvar_5;
+  tmpvar_5 = texture (cubehigh, varUV.xyz);
   c_1 = (c_1 + tmpvar_5);
-  mediump vec4 tmpvar_6;
-  tmpvar_6 = texture (cubemed, varUV.xyz);
-  c_1 = (c_1 + tmpvar_6);
-  highp vec4 tmpvar_7;
-  tmpvar_7 = texture (cubehigh, varUV.xyz);
-  c_1 = (c_1 + tmpvar_7);
   _fragData = c_1;
 }
 

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/sampler-precision-outES3Metal.txt

@@ -21,21 +21,17 @@ fragment xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]]
   half4 tmpvar_2;
   tmpvar_2 = texlow.sample(_mtlsmp_texlow, (float2)(_mtl_i.varUV.xy));
   c_1 = tmpvar_2;
-  half4 tmpvar_3;
-  tmpvar_3 = texmed.sample(_mtlsmp_texmed, (float2)(_mtl_i.varUV.xy));
-  c_1 = (c_1 + tmpvar_3);
-  float4 tmpvar_4;
-  tmpvar_4 = float4(texhigh.sample(_mtlsmp_texhigh, (float2)(_mtl_i.varUV.xy)));
-  c_1 = half4(((float4)c_1 + tmpvar_4));
-  half4 tmpvar_5;
-  tmpvar_5 = cubelow.sample(_mtlsmp_cubelow, (float3)(_mtl_i.varUV.xyz));
-  c_1 = (c_1 + tmpvar_5);
-  half4 tmpvar_6;
-  tmpvar_6 = cubemed.sample(_mtlsmp_cubemed, (float3)(_mtl_i.varUV.xyz));
-  c_1 = (c_1 + tmpvar_6);
-  float4 tmpvar_7;
-  tmpvar_7 = float4(cubehigh.sample(_mtlsmp_cubehigh, (float3)(_mtl_i.varUV.xyz)));
-  c_1 = half4(((float4)c_1 + tmpvar_7));
+  c_1 = (c_1 + texmed.sample(_mtlsmp_texmed, (float2)(_mtl_i.varUV.xy)));
+  float4 tmpvar_3;
+  tmpvar_3 = texhigh.sample(_mtlsmp_texhigh, (float2)(_mtl_i.varUV.xy));
+  c_1 = half4(((float4)c_1 + tmpvar_3));
+  half4 tmpvar_4;
+  tmpvar_4 = cubelow.sample(_mtlsmp_cubelow, (float3)(_mtl_i.varUV.xyz));
+  c_1 = (c_1 + tmpvar_4);
+  c_1 = (c_1 + cubemed.sample(_mtlsmp_cubemed, (float3)(_mtl_i.varUV.xyz)));
+  float4 tmpvar_5;
+  tmpvar_5 = cubehigh.sample(_mtlsmp_cubehigh, (float3)(_mtl_i.varUV.xyz));
+  c_1 = half4(((float4)c_1 + tmpvar_5));
   _mtl_o._fragData = c_1;
   return _mtl_o;
 }

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/z-fxaa3-11-pc39-outES.txt

@@ -53,116 +53,116 @@ void main ()
   highp float range_37;
   highp float lumaN_38;
   highp float lumaS_39;
-  highp vec4 rgbyM_40;
-  highp vec2 posM_41;
-  posM_41 = xlv_TEXCOORD0;
+  highp vec2 posM_40;
+  posM_40 = xlv_TEXCOORD0;
+  highp vec4 tmpvar_41;
   lowp vec4 tmpvar_42;
   tmpvar_42 = impl_low_texture2DLodEXT (_MainTex, xlv_TEXCOORD0, 0.0);
-  rgbyM_40 = tmpvar_42;
+  tmpvar_41 = tmpvar_42;
   highp vec4 tmpvar_43;
   tmpvar_43.zw = vec2(0.0, 0.0);
   tmpvar_43.xy = (xlv_TEXCOORD0 + (vec2(0.0, 1.0) * _MainTex_TexelSize.xy));
-  lowp vec4 tmpvar_44;
-  tmpvar_44 = impl_low_texture2DLodEXT (_MainTex, tmpvar_43.xy, 0.0);
-  highp vec4 rgba_45;
-  rgba_45 = tmpvar_44;
-  lumaS_39 = rgba_45.w;
+  highp vec4 tmpvar_44;
+  lowp vec4 tmpvar_45;
+  tmpvar_45 = impl_low_texture2DLodEXT (_MainTex, tmpvar_43.xy, 0.0);
+  tmpvar_44 = tmpvar_45;
+  lumaS_39 = tmpvar_44.w;
   highp vec4 tmpvar_46;
   tmpvar_46.zw = vec2(0.0, 0.0);
   tmpvar_46.xy = (xlv_TEXCOORD0 + (vec2(1.0, 0.0) * _MainTex_TexelSize.xy));
-  lowp vec4 tmpvar_47;
-  tmpvar_47 = impl_low_texture2DLodEXT (_MainTex, tmpvar_46.xy, 0.0);
-  highp float tmpvar_48;
-  highp vec4 rgba_49;
-  rgba_49 = tmpvar_47;
-  tmpvar_48 = rgba_49.w;
+  highp vec4 tmpvar_47;
+  lowp vec4 tmpvar_48;
+  tmpvar_48 = impl_low_texture2DLodEXT (_MainTex, tmpvar_46.xy, 0.0);
+  tmpvar_47 = tmpvar_48;
+  highp float tmpvar_49;
+  tmpvar_49 = tmpvar_47.w;
   highp vec4 tmpvar_50;
   tmpvar_50.zw = vec2(0.0, 0.0);
   tmpvar_50.xy = (xlv_TEXCOORD0 + (vec2(0.0, -1.0) * _MainTex_TexelSize.xy));
-  lowp vec4 tmpvar_51;
-  tmpvar_51 = impl_low_texture2DLodEXT (_MainTex, tmpvar_50.xy, 0.0);
-  highp vec4 rgba_52;
-  rgba_52 = tmpvar_51;
-  lumaN_38 = rgba_52.w;
+  highp vec4 tmpvar_51;
+  lowp vec4 tmpvar_52;
+  tmpvar_52 = impl_low_texture2DLodEXT (_MainTex, tmpvar_50.xy, 0.0);
+  tmpvar_51 = tmpvar_52;
+  lumaN_38 = tmpvar_51.w;
   highp vec4 tmpvar_53;
   tmpvar_53.zw = vec2(0.0, 0.0);
   tmpvar_53.xy = (xlv_TEXCOORD0 + (vec2(-1.0, 0.0) * _MainTex_TexelSize.xy));
-  lowp vec4 tmpvar_54;
-  tmpvar_54 = impl_low_texture2DLodEXT (_MainTex, tmpvar_53.xy, 0.0);
-  highp float tmpvar_55;
-  highp vec4 rgba_56;
-  rgba_56 = tmpvar_54;
-  tmpvar_55 = rgba_56.w;
+  highp vec4 tmpvar_54;
+  lowp vec4 tmpvar_55;
+  tmpvar_55 = impl_low_texture2DLodEXT (_MainTex, tmpvar_53.xy, 0.0);
+  tmpvar_54 = tmpvar_55;
+  highp float tmpvar_56;
+  tmpvar_56 = tmpvar_54.w;
   highp float tmpvar_57;
-  tmpvar_57 = max (max (rgba_52.w, rgba_56.w), max (max (rgba_49.w, rgba_45.w), rgbyM_40.w));
-  range_37 = (tmpvar_57 - min (min (rgba_52.w, rgba_56.w), min (
-    min (rgba_49.w, rgba_45.w)
-  , rgbyM_40.w)));
+  tmpvar_57 = max (max (tmpvar_51.w, tmpvar_54.w), max (max (tmpvar_47.w, tmpvar_44.w), tmpvar_41.w));
+  range_37 = (tmpvar_57 - min (min (tmpvar_51.w, tmpvar_54.w), min (
+    min (tmpvar_47.w, tmpvar_44.w)
+  , tmpvar_41.w)));
   if ((range_37 < max (0.0833, (tmpvar_57 * 0.166)))) {
-    tmpvar_2 = rgbyM_40;
+    tmpvar_2 = tmpvar_41;
   } else {
     highp vec4 tmpvar_58;
     tmpvar_58.zw = vec2(0.0, 0.0);
     tmpvar_58.xy = (xlv_TEXCOORD0 - _MainTex_TexelSize.xy);
-    lowp vec4 tmpvar_59;
-    tmpvar_59 = impl_low_texture2DLodEXT (_MainTex, tmpvar_58.xy, 0.0);
-    highp vec4 rgba_60;
-    rgba_60 = tmpvar_59;
+    highp vec4 tmpvar_59;
+    lowp vec4 tmpvar_60;
+    tmpvar_60 = impl_low_texture2DLodEXT (_MainTex, tmpvar_58.xy, 0.0);
+    tmpvar_59 = tmpvar_60;
     highp vec4 tmpvar_61;
     tmpvar_61.zw = vec2(0.0, 0.0);
     tmpvar_61.xy = (xlv_TEXCOORD0 + _MainTex_TexelSize.xy);
-    lowp vec4 tmpvar_62;
-    tmpvar_62 = impl_low_texture2DLodEXT (_MainTex, tmpvar_61.xy, 0.0);
-    highp vec4 rgba_63;
-    rgba_63 = tmpvar_62;
+    highp vec4 tmpvar_62;
+    lowp vec4 tmpvar_63;
+    tmpvar_63 = impl_low_texture2DLodEXT (_MainTex, tmpvar_61.xy, 0.0);
+    tmpvar_62 = tmpvar_63;
     highp vec4 tmpvar_64;
     tmpvar_64.zw = vec2(0.0, 0.0);
     tmpvar_64.xy = (xlv_TEXCOORD0 + (vec2(1.0, -1.0) * _MainTex_TexelSize.xy));
-    lowp vec4 tmpvar_65;
-    tmpvar_65 = impl_low_texture2DLodEXT (_MainTex, tmpvar_64.xy, 0.0);
-    highp vec4 rgba_66;
-    rgba_66 = tmpvar_65;
+    highp vec4 tmpvar_65;
+    lowp vec4 tmpvar_66;
+    tmpvar_66 = impl_low_texture2DLodEXT (_MainTex, tmpvar_64.xy, 0.0);
+    tmpvar_65 = tmpvar_66;
     highp vec4 tmpvar_67;
     tmpvar_67.zw = vec2(0.0, 0.0);
     tmpvar_67.xy = (xlv_TEXCOORD0 + (vec2(-1.0, 1.0) * _MainTex_TexelSize.xy));
-    lowp vec4 tmpvar_68;
-    tmpvar_68 = impl_low_texture2DLodEXT (_MainTex, tmpvar_67.xy, 0.0);
-    highp vec4 rgba_69;
-    rgba_69 = tmpvar_68;
-    lumaNS_36 = (rgba_52.w + rgba_45.w);
-    lumaWE_35 = (rgba_56.w + rgba_49.w);
+    highp vec4 tmpvar_68;
+    lowp vec4 tmpvar_69;
+    tmpvar_69 = impl_low_texture2DLodEXT (_MainTex, tmpvar_67.xy, 0.0);
+    tmpvar_68 = tmpvar_69;
+    lumaNS_36 = (tmpvar_51.w + tmpvar_44.w);
+    lumaWE_35 = (tmpvar_54.w + tmpvar_47.w);
     subpixRcpRange_34 = (1.0/(range_37));
-    lumaNESE_33 = (rgba_66.w + rgba_63.w);
-    lumaNWSW_32 = (rgba_60.w + rgba_69.w);
+    lumaNESE_33 = (tmpvar_65.w + tmpvar_62.w);
+    lumaNWSW_32 = (tmpvar_59.w + tmpvar_68.w);
     lengthSign_31 = fxaaQualityRcpFrame_1.x;
     horzSpan_30 = ((abs(
-      ((-2.0 * rgba_56.w) + lumaNWSW_32)
+      ((-2.0 * tmpvar_54.w) + lumaNWSW_32)
     ) + (
-      (abs(((-2.0 * rgbyM_40.w) + lumaNS_36)) * 2.0)
+      (abs(((-2.0 * tmpvar_41.w) + lumaNS_36)) * 2.0)
      + 
-      abs(((-2.0 * rgba_49.w) + lumaNESE_33))
+      abs(((-2.0 * tmpvar_47.w) + lumaNESE_33))
     )) >= (abs(
-      ((-2.0 * rgba_45.w) + (rgba_69.w + rgba_63.w))
+      ((-2.0 * tmpvar_44.w) + (tmpvar_68.w + tmpvar_62.w))
     ) + (
-      (abs(((-2.0 * rgbyM_40.w) + lumaWE_35)) * 2.0)
+      (abs(((-2.0 * tmpvar_41.w) + lumaWE_35)) * 2.0)
      + 
-      abs(((-2.0 * rgba_52.w) + (rgba_60.w + rgba_66.w)))
+      abs(((-2.0 * tmpvar_51.w) + (tmpvar_59.w + tmpvar_65.w)))
     )));
     subpixA_29 = (((lumaNS_36 + lumaWE_35) * 2.0) + (lumaNWSW_32 + lumaNESE_33));
     if (!(horzSpan_30)) {
-      lumaN_38 = tmpvar_55;
+      lumaN_38 = tmpvar_56;
     };
     if (!(horzSpan_30)) {
-      lumaS_39 = tmpvar_48;
+      lumaS_39 = tmpvar_49;
     };
     if (horzSpan_30) {
       lengthSign_31 = fxaaQualityRcpFrame_1.y;
     };
-    subpixB_28 = ((subpixA_29 * 0.0833333) - rgbyM_40.w);
-    gradientN_27 = (lumaN_38 - rgbyM_40.w);
-    gradientS_26 = (lumaS_39 - rgbyM_40.w);
-    lumaNN_25 = (lumaN_38 + rgbyM_40.w);
-    lumaSS_24 = (lumaS_39 + rgbyM_40.w);
+    subpixB_28 = ((subpixA_29 * 0.0833333) - tmpvar_41.w);
+    gradientN_27 = (lumaN_38 - tmpvar_41.w);
+    gradientS_26 = (lumaS_39 - tmpvar_41.w);
+    lumaNN_25 = (lumaN_38 + tmpvar_41.w);
+    lumaSS_24 = (lumaS_39 + tmpvar_41.w);
     pairN_23 = (abs(gradientN_27) >= abs(gradientS_26));
     highp float tmpvar_70;
     tmpvar_70 = max (abs(gradientN_27), abs(gradientS_26));
@@ -195,25 +195,25 @@ void main ()
     posP_20.x = (posB_22.x + tmpvar_72);
     posP_20.y = (posB_22.y + tmpvar_73);
     subpixD_19 = ((-2.0 * tmpvar_71) + 3.0);
-    lowp vec4 tmpvar_74;
-    tmpvar_74 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
-    highp vec4 rgba_75;
-    rgba_75 = tmpvar_74;
-    lumaEndN_18 = rgba_75.w;
+    highp vec4 tmpvar_74;
+    lowp vec4 tmpvar_75;
+    tmpvar_75 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
+    tmpvar_74 = tmpvar_75;
+    lumaEndN_18 = tmpvar_74.w;
     subpixE_17 = (tmpvar_71 * tmpvar_71);
-    lowp vec4 tmpvar_76;
-    tmpvar_76 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
-    highp vec4 rgba_77;
-    rgba_77 = tmpvar_76;
-    lumaEndP_16 = rgba_77.w;
+    highp vec4 tmpvar_76;
+    lowp vec4 tmpvar_77;
+    tmpvar_77 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
+    tmpvar_76 = tmpvar_77;
+    lumaEndP_16 = tmpvar_76.w;
     if (!(pairN_23)) {
       lumaNN_25 = lumaSS_24;
     };
     gradientScaled_15 = (tmpvar_70 / 4.0);
     subpixF_14 = (subpixD_19 * subpixE_17);
-    lumaMLTZero_13 = ((rgbyM_40.w - (lumaNN_25 * 0.5)) < 0.0);
-    lumaEndN_18 = (rgba_75.w - (lumaNN_25 * 0.5));
-    lumaEndP_16 = (rgba_77.w - (lumaNN_25 * 0.5));
+    lumaMLTZero_13 = ((tmpvar_41.w - (lumaNN_25 * 0.5)) < 0.0);
+    lumaEndN_18 = (tmpvar_74.w - (lumaNN_25 * 0.5));
+    lumaEndP_16 = (tmpvar_76.w - (lumaNN_25 * 0.5));
     doneN_12 = (abs(lumaEndN_18) >= gradientScaled_15);
     doneP_11 = (abs(lumaEndP_16) >= gradientScaled_15);
     if (!(doneN_12)) {
@@ -231,18 +231,18 @@ void main ()
     };
     if (doneNP_10) {
       if (!(doneN_12)) {
-        lowp vec4 tmpvar_78;
-        tmpvar_78 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
-        highp vec4 rgba_79;
-        rgba_79 = tmpvar_78;
-        lumaEndN_18 = rgba_79.w;
+        highp vec4 tmpvar_78;
+        lowp vec4 tmpvar_79;
+        tmpvar_79 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
+        tmpvar_78 = tmpvar_79;
+        lumaEndN_18 = tmpvar_78.w;
       };
       if (!(doneP_11)) {
-        lowp vec4 tmpvar_80;
-        tmpvar_80 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
-        highp vec4 rgba_81;
-        rgba_81 = tmpvar_80;
-        lumaEndP_16 = rgba_81.w;
+        highp vec4 tmpvar_80;
+        lowp vec4 tmpvar_81;
+        tmpvar_81 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
+        tmpvar_80 = tmpvar_81;
+        lumaEndP_16 = tmpvar_80.w;
       };
       if (!(doneN_12)) {
         lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
@@ -267,18 +267,18 @@ void main ()
       };
       if (doneNP_10) {
         if (!(doneN_12)) {
-          lowp vec4 tmpvar_82;
-          tmpvar_82 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
-          highp vec4 rgba_83;
-          rgba_83 = tmpvar_82;
-          lumaEndN_18 = rgba_83.w;
+          highp vec4 tmpvar_82;
+          lowp vec4 tmpvar_83;
+          tmpvar_83 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
+          tmpvar_82 = tmpvar_83;
+          lumaEndN_18 = tmpvar_82.w;
         };
         if (!(doneP_11)) {
-          lowp vec4 tmpvar_84;
-          tmpvar_84 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
-          highp vec4 rgba_85;
-          rgba_85 = tmpvar_84;
-          lumaEndP_16 = rgba_85.w;
+          highp vec4 tmpvar_84;
+          lowp vec4 tmpvar_85;
+          tmpvar_85 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
+          tmpvar_84 = tmpvar_85;
+          lumaEndP_16 = tmpvar_84.w;
         };
         if (!(doneN_12)) {
           lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
@@ -303,18 +303,18 @@ void main ()
         };
         if (doneNP_10) {
           if (!(doneN_12)) {
-            lowp vec4 tmpvar_86;
-            tmpvar_86 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
-            highp vec4 rgba_87;
-            rgba_87 = tmpvar_86;
-            lumaEndN_18 = rgba_87.w;
+            highp vec4 tmpvar_86;
+            lowp vec4 tmpvar_87;
+            tmpvar_87 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
+            tmpvar_86 = tmpvar_87;
+            lumaEndN_18 = tmpvar_86.w;
           };
           if (!(doneP_11)) {
-            lowp vec4 tmpvar_88;
-            tmpvar_88 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
-            highp vec4 rgba_89;
-            rgba_89 = tmpvar_88;
-            lumaEndP_16 = rgba_89.w;
+            highp vec4 tmpvar_88;
+            lowp vec4 tmpvar_89;
+            tmpvar_89 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
+            tmpvar_88 = tmpvar_89;
+            lumaEndP_16 = tmpvar_88.w;
           };
           if (!(doneN_12)) {
             lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
@@ -339,18 +339,18 @@ void main ()
           };
           if (doneNP_10) {
             if (!(doneN_12)) {
-              lowp vec4 tmpvar_90;
-              tmpvar_90 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
-              highp vec4 rgba_91;
-              rgba_91 = tmpvar_90;
-              lumaEndN_18 = rgba_91.w;
+              highp vec4 tmpvar_90;
+              lowp vec4 tmpvar_91;
+              tmpvar_91 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
+              tmpvar_90 = tmpvar_91;
+              lumaEndN_18 = tmpvar_90.w;
             };
             if (!(doneP_11)) {
-              lowp vec4 tmpvar_92;
-              tmpvar_92 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
-              highp vec4 rgba_93;
-              rgba_93 = tmpvar_92;
-              lumaEndP_16 = rgba_93.w;
+              highp vec4 tmpvar_92;
+              lowp vec4 tmpvar_93;
+              tmpvar_93 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
+              tmpvar_92 = tmpvar_93;
+              lumaEndP_16 = tmpvar_92.w;
             };
             if (!(doneN_12)) {
               lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
@@ -375,18 +375,18 @@ void main ()
             };
             if (doneNP_10) {
               if (!(doneN_12)) {
-                lowp vec4 tmpvar_94;
-                tmpvar_94 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
-                highp vec4 rgba_95;
-                rgba_95 = tmpvar_94;
-                lumaEndN_18 = rgba_95.w;
+                highp vec4 tmpvar_94;
+                lowp vec4 tmpvar_95;
+                tmpvar_95 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
+                tmpvar_94 = tmpvar_95;
+                lumaEndN_18 = tmpvar_94.w;
               };
               if (!(doneP_11)) {
-                lowp vec4 tmpvar_96;
-                tmpvar_96 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
-                highp vec4 rgba_97;
-                rgba_97 = tmpvar_96;
-                lumaEndP_16 = rgba_97.w;
+                highp vec4 tmpvar_96;
+                lowp vec4 tmpvar_97;
+                tmpvar_97 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
+                tmpvar_96 = tmpvar_97;
+                lumaEndP_16 = tmpvar_96.w;
               };
               if (!(doneN_12)) {
                 lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
@@ -411,18 +411,18 @@ void main ()
               };
               if (doneNP_10) {
                 if (!(doneN_12)) {
-                  lowp vec4 tmpvar_98;
-                  tmpvar_98 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
-                  highp vec4 rgba_99;
-                  rgba_99 = tmpvar_98;
-                  lumaEndN_18 = rgba_99.w;
+                  highp vec4 tmpvar_98;
+                  lowp vec4 tmpvar_99;
+                  tmpvar_99 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
+                  tmpvar_98 = tmpvar_99;
+                  lumaEndN_18 = tmpvar_98.w;
                 };
                 if (!(doneP_11)) {
-                  lowp vec4 tmpvar_100;
-                  tmpvar_100 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
-                  highp vec4 rgba_101;
-                  rgba_101 = tmpvar_100;
-                  lumaEndP_16 = rgba_101.w;
+                  highp vec4 tmpvar_100;
+                  lowp vec4 tmpvar_101;
+                  tmpvar_101 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
+                  tmpvar_100 = tmpvar_101;
+                  lumaEndP_16 = tmpvar_100.w;
                 };
                 if (!(doneN_12)) {
                   lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
@@ -447,18 +447,18 @@ void main ()
                 };
                 if (doneNP_10) {
                   if (!(doneN_12)) {
-                    lowp vec4 tmpvar_102;
-                    tmpvar_102 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
-                    highp vec4 rgba_103;
-                    rgba_103 = tmpvar_102;
-                    lumaEndN_18 = rgba_103.w;
+                    highp vec4 tmpvar_102;
+                    lowp vec4 tmpvar_103;
+                    tmpvar_103 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
+                    tmpvar_102 = tmpvar_103;
+                    lumaEndN_18 = tmpvar_102.w;
                   };
                   if (!(doneP_11)) {
-                    lowp vec4 tmpvar_104;
-                    tmpvar_104 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
-                    highp vec4 rgba_105;
-                    rgba_105 = tmpvar_104;
-                    lumaEndP_16 = rgba_105.w;
+                    highp vec4 tmpvar_104;
+                    lowp vec4 tmpvar_105;
+                    tmpvar_105 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
+                    tmpvar_104 = tmpvar_105;
+                    lumaEndP_16 = tmpvar_104.w;
                   };
                   if (!(doneN_12)) {
                     lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
@@ -483,18 +483,18 @@ void main ()
                   };
                   if (doneNP_10) {
                     if (!(doneN_12)) {
-                      lowp vec4 tmpvar_106;
-                      tmpvar_106 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
-                      highp vec4 rgba_107;
-                      rgba_107 = tmpvar_106;
-                      lumaEndN_18 = rgba_107.w;
+                      highp vec4 tmpvar_106;
+                      lowp vec4 tmpvar_107;
+                      tmpvar_107 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
+                      tmpvar_106 = tmpvar_107;
+                      lumaEndN_18 = tmpvar_106.w;
                     };
                     if (!(doneP_11)) {
-                      lowp vec4 tmpvar_108;
-                      tmpvar_108 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
-                      highp vec4 rgba_109;
-                      rgba_109 = tmpvar_108;
-                      lumaEndP_16 = rgba_109.w;
+                      highp vec4 tmpvar_108;
+                      lowp vec4 tmpvar_109;
+                      tmpvar_109 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
+                      tmpvar_108 = tmpvar_109;
+                      lumaEndP_16 = tmpvar_108.w;
                     };
                     if (!(doneN_12)) {
                       lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
@@ -519,18 +519,18 @@ void main ()
                     };
                     if (doneNP_10) {
                       if (!(doneN_12)) {
-                        lowp vec4 tmpvar_110;
-                        tmpvar_110 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
-                        highp vec4 rgba_111;
-                        rgba_111 = tmpvar_110;
-                        lumaEndN_18 = rgba_111.w;
+                        highp vec4 tmpvar_110;
+                        lowp vec4 tmpvar_111;
+                        tmpvar_111 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
+                        tmpvar_110 = tmpvar_111;
+                        lumaEndN_18 = tmpvar_110.w;
                       };
                       if (!(doneP_11)) {
-                        lowp vec4 tmpvar_112;
-                        tmpvar_112 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
-                        highp vec4 rgba_113;
-                        rgba_113 = tmpvar_112;
-                        lumaEndP_16 = rgba_113.w;
+                        highp vec4 tmpvar_112;
+                        lowp vec4 tmpvar_113;
+                        tmpvar_113 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
+                        tmpvar_112 = tmpvar_113;
+                        lumaEndP_16 = tmpvar_112.w;
                       };
                       if (!(doneN_12)) {
                         lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
@@ -555,18 +555,18 @@ void main ()
                       };
                       if (doneNP_10) {
                         if (!(doneN_12)) {
-                          lowp vec4 tmpvar_114;
-                          tmpvar_114 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
-                          highp vec4 rgba_115;
-                          rgba_115 = tmpvar_114;
-                          lumaEndN_18 = rgba_115.w;
+                          highp vec4 tmpvar_114;
+                          lowp vec4 tmpvar_115;
+                          tmpvar_115 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
+                          tmpvar_114 = tmpvar_115;
+                          lumaEndN_18 = tmpvar_114.w;
                         };
                         if (!(doneP_11)) {
-                          lowp vec4 tmpvar_116;
-                          tmpvar_116 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
-                          highp vec4 rgba_117;
-                          rgba_117 = tmpvar_116;
-                          lumaEndP_16 = rgba_117.w;
+                          highp vec4 tmpvar_116;
+                          lowp vec4 tmpvar_117;
+                          tmpvar_117 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
+                          tmpvar_116 = tmpvar_117;
+                          lumaEndP_16 = tmpvar_116.w;
                         };
                         if (!(doneN_12)) {
                           lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
@@ -629,16 +629,16 @@ void main ()
     highp float tmpvar_121;
     tmpvar_121 = max (tmpvar_120, subpixH_3);
     if (!(horzSpan_30)) {
-      posM_41.x = (xlv_TEXCOORD0.x + (tmpvar_121 * lengthSign_31));
+      posM_40.x = (xlv_TEXCOORD0.x + (tmpvar_121 * lengthSign_31));
     };
     if (horzSpan_30) {
-      posM_41.y = (xlv_TEXCOORD0.y + (tmpvar_121 * lengthSign_31));
+      posM_40.y = (xlv_TEXCOORD0.y + (tmpvar_121 * lengthSign_31));
     };
     lowp vec4 tmpvar_122;
-    tmpvar_122 = impl_low_texture2DLodEXT (_MainTex, posM_41, 0.0);
+    tmpvar_122 = impl_low_texture2DLodEXT (_MainTex, posM_40, 0.0);
     highp vec4 tmpvar_123;
     tmpvar_123.xyz = tmpvar_122.xyz;
-    tmpvar_123.w = rgbyM_40.w;
+    tmpvar_123.w = tmpvar_41.w;
     tmpvar_2 = tmpvar_123;
   };
   gl_FragData[0] = tmpvar_2;

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/zun-SSAO24-outES3.txt

@@ -51,16 +51,14 @@ void main ()
     };
     randomDir_14 = (randomDir_14 * -(tmpvar_18));
     randomDir_14 = (randomDir_14 + (viewNorm_7 * 0.3));
-    highp vec4 tmpvar_19;
-    tmpvar_19 = texture (_CameraDepthNormalsTexture, (tmpvar_2 + (randomDir_14.xy * scale_5)));
-    highp float tmpvar_20;
-    tmpvar_20 = clamp (((depth_6 - 
+    highp float tmpvar_19;
+    tmpvar_19 = clamp (((depth_6 - 
       (randomDir_14.z * _Params.x)
     ) - (
-      dot (tmpvar_19.zw, vec2(1.0, 0.00392157))
+      dot (texture (_CameraDepthNormalsTexture, (tmpvar_2 + (randomDir_14.xy * scale_5))).zw, vec2(1.0, 0.00392157))
      * _ProjectionParams.z)), 0.0, 1.0);
-    if ((tmpvar_20 > _Params.y)) {
-      occ_4 = (occ_4 + pow ((1.0 - tmpvar_20), _Params.z));
+    if ((tmpvar_19 > _Params.y)) {
+      occ_4 = (occ_4 + pow ((1.0 - tmpvar_19), _Params.z));
     };
   };
   occ_4 = (occ_4 / 8.0);

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/fragment/zun-SSAO24-outES3Metal.txt

@@ -29,7 +29,7 @@ fragment xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]]
   tmpvar_9 = ((_RandomTexture.sample(_mtlsmp__RandomTexture, (float2)(_mtl_i.xlv_TEXCOORD1)).xyz * (half)2.0) - (half)1.0);
   randN_8 = tmpvar_9;
   float4 tmpvar_10;
-  tmpvar_10 = float4(_CameraDepthNormalsTexture.sample(_mtlsmp__CameraDepthNormalsTexture, (float2)(_mtl_i.xlv_TEXCOORD0)));
+  tmpvar_10 = _CameraDepthNormalsTexture.sample(_mtlsmp__CameraDepthNormalsTexture, (float2)(_mtl_i.xlv_TEXCOORD0));
   float3 n_11;
   float3 tmpvar_12;
   tmpvar_12 = ((tmpvar_10.xyz * float3(3.5554, 3.5554, 0.0)) + float3(-1.7777, -1.7777, 1.0));
@@ -60,16 +60,14 @@ fragment xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]]
     };
     randomDir_14 = (randomDir_14 * -(tmpvar_18));
     randomDir_14 = half3(((float3)randomDir_14 + (viewNorm_7 * 0.3)));
-    float4 tmpvar_19;
-    tmpvar_19 = float4(_CameraDepthNormalsTexture.sample(_mtlsmp__CameraDepthNormalsTexture, (float2)((tmpvar_2 + ((float2)randomDir_14.xy * scale_5)))));
-    float tmpvar_20;
-    tmpvar_20 = clamp (((depth_6 - 
+    float tmpvar_19;
+    tmpvar_19 = clamp (((depth_6 - 
       ((float)randomDir_14.z * _mtl_u._Params.x)
     ) - (
-      dot (tmpvar_19.zw, float2(1.0, 0.00392157))
+      dot (_CameraDepthNormalsTexture.sample(_mtlsmp__CameraDepthNormalsTexture, (float2)((tmpvar_2 + ((float2)randomDir_14.xy * scale_5)))).zw, float2(1.0, 0.00392157))
      * _mtl_u._ProjectionParams.z)), 0.0, 1.0);
-    if ((tmpvar_20 > _mtl_u._Params.y)) {
-      occ_4 = (occ_4 + pow ((1.0 - tmpvar_20), _mtl_u._Params.z));
+    if ((tmpvar_19 > _mtl_u._Params.y)) {
+      occ_4 = (occ_4 + pow ((1.0 - tmpvar_19), _mtl_u._Params.z));
     };
   };
   occ_4 = (occ_4 / 8.0);

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/glsl_optimizer_tests.cpp

@@ -19,23 +19,23 @@
 #include <windows.h>
 #include <gl/GL.h>
 extern "C" {
-typedef char GLcharARB;		/* native character */
-typedef unsigned int GLhandleARB;	/* shader object handle */
-#define GL_VERTEX_SHADER_ARB              0x8B31
-#define GL_FRAGMENT_SHADER_ARB            0x8B30
-#define GL_OBJECT_COMPILE_STATUS_ARB      0x8B81
-typedef void (WINAPI * PFNGLDELETEOBJECTARBPROC) (GLhandleARB obj);
-typedef GLhandleARB (WINAPI * PFNGLCREATESHADEROBJECTARBPROC) (GLenum shaderType);
-typedef void (WINAPI * PFNGLSHADERSOURCEARBPROC) (GLhandleARB shaderObj, GLsizei count, const GLcharARB* *string, const GLint *length);
-typedef void (WINAPI * PFNGLCOMPILESHADERARBPROC) (GLhandleARB shaderObj);
-typedef void (WINAPI * PFNGLGETINFOLOGARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog);
-typedef void (WINAPI * PFNGLGETOBJECTPARAMETERIVARBPROC) (GLhandleARB obj, GLenum pname, GLint *params);
-static PFNGLDELETEOBJECTARBPROC glDeleteObjectARB;
-static PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB;
-static PFNGLSHADERSOURCEARBPROC glShaderSourceARB;
-static PFNGLCOMPILESHADERARBPROC glCompileShaderARB;
-static PFNGLGETINFOLOGARBPROC glGetInfoLogARB;
-static PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB;
+typedef char GLchar;		/* native character */
+typedef unsigned int GLuint;	/* shader object handle */
+#define GL_VERTEX_SHADER              0x8B31
+#define GL_FRAGMENT_SHADER            0x8B30
+#define GL_COMPILE_STATUS             0x8B81
+typedef void (WINAPI * PFNGLDELETESHADERPROC) (GLuint shader);
+typedef GLuint (WINAPI * PFNGLCREATESHADERPROC) (GLenum type);
+typedef void (WINAPI * PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length);
+typedef void (WINAPI * PFNGLCOMPILESHADERPROC) (GLuint shader);
+typedef void (WINAPI * PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+typedef void (WINAPI * PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint *params);
+static PFNGLDELETESHADERPROC glDeleteShader;
+static PFNGLCREATESHADERPROC glCreateShader;
+static PFNGLSHADERSOURCEPROC glShaderSource;
+static PFNGLCOMPILESHADERPROC glCompileShader;
+static PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
+static PFNGLGETSHADERIVPROC glGetShaderiv;
 }
 #endif // #ifdef _MSC_VER
 
@@ -154,12 +154,12 @@ static bool InitializeOpenGL ()
 #ifdef _MSC_VER
 	if (hasGLSL)
 	{
-		glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)wglGetProcAddress("glDeleteObjectARB");
-		glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)wglGetProcAddress("glCreateShaderObjectARB");
-		glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)wglGetProcAddress("glShaderSourceARB");
-		glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)wglGetProcAddress("glCompileShaderARB");
-		glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)wglGetProcAddress("glGetInfoLogARB");
-		glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)wglGetProcAddress("glGetObjectParameterivARB");
+		glDeleteShader = (PFNGLDELETESHADERPROC)wglGetProcAddress("glDeleteShader");
+		glCreateShader = (PFNGLCREATESHADERPROC)wglGetProcAddress("glCreateShader");
+		glShaderSource = (PFNGLSHADERSOURCEPROC)wglGetProcAddress("glShaderSource");
+		glCompileShader = (PFNGLCOMPILESHADERPROC)wglGetProcAddress("glCompileShader");
+		glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)wglGetProcAddress("glGetShaderInfoLog");
+		glGetShaderiv = (PFNGLGETSHADERIVPROC)wglGetProcAddress("glGetShaderiv");
 	}
 #endif
 
@@ -266,6 +266,8 @@ static bool CheckGLSL (bool vertex, bool gles, const std::string& testName, cons
 	if (gles)
 	{
 		replace_string (src, "GL_EXT_shader_texture_lod", "GL_ARB_shader_texture_lod", 0);
+		replace_string (src, "GL_EXT_draw_instanced", "GL_ARB_draw_instanced", 0);
+		replace_string (src, "gl_InstanceIDEXT", "gl_InstanceIDARB	", 0);
 		replace_string (src, "#extension GL_OES_standard_derivatives : require", "", 0);
 		replace_string (src, "#extension GL_EXT_shadow_samplers : require", "", 0);
 		replace_string (src, "#extension GL_EXT_frag_depth : require", "", 0);

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/vertex/builtin-vars-in.txt

@@ -0,0 +1,16 @@
+#extension GL_ARB_draw_instanced : require
+#extension GL_EXT_gpu_shader4 : require
+
+attribute vec3 _inPos;
+attribute vec3 _inNor;
+
+void main()
+{
+	vec3 p;
+	p = _inPos;
+	p.y += float(gl_VertexID);
+	p.y += float(gl_InstanceIDARB);
+	p += _inNor;
+	gl_Position = vec4(p,1.0);
+	gl_PointSize = p.x;
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/vertex/builtin-vars-inES.txt

@@ -0,0 +1,14 @@
+#extension GL_EXT_draw_instanced : require
+
+attribute highp vec3 _inPos;
+attribute highp vec3 _inNor;
+
+void main()
+{
+	highp vec3 p;
+	p = _inPos;
+	p.y += float(gl_InstanceIDEXT);
+	p += _inNor;
+	gl_Position = vec4(p,1.0);
+	gl_PointSize = p.x;
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/vertex/builtin-vars-out.txt

@@ -0,0 +1,23 @@
+#extension GL_ARB_draw_instanced : enable
+#extension GL_EXT_gpu_shader4 : enable
+attribute vec3 _inPos;
+attribute vec3 _inNor;
+void main ()
+{
+  vec3 p_1;
+  p_1.xz = _inPos.xz;
+  p_1.y = (_inPos.y + float(gl_VertexID));
+  p_1.y = (p_1.y + float(gl_InstanceIDARB));
+  p_1 = (p_1 + _inNor);
+  vec4 tmpvar_2;
+  tmpvar_2.w = 1.0;
+  tmpvar_2.xyz = p_1;
+  gl_Position = tmpvar_2;
+  gl_PointSize = p_1.x;
+}
+
+
+// stats: 6 alu 0 tex 0 flow
+// inputs: 2
+//  #0: _inPos (high float) 3x1 [-1]
+//  #1: _inNor (high float) 3x1 [-1]

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/vertex/builtin-vars-outES.txt

@@ -0,0 +1,21 @@
+#extension GL_EXT_draw_instanced : enable
+attribute highp vec3 _inPos;
+attribute highp vec3 _inNor;
+void main ()
+{
+  highp vec3 p_1;
+  p_1.xz = _inPos.xz;
+  p_1.y = (_inPos.y + float(gl_InstanceIDEXT));
+  p_1 = (p_1 + _inNor);
+  highp vec4 tmpvar_2;
+  tmpvar_2.w = 1.0;
+  tmpvar_2.xyz = p_1;
+  gl_Position = tmpvar_2;
+  gl_PointSize = p_1.x;
+}
+
+
+// stats: 4 alu 0 tex 0 flow
+// inputs: 2
+//  #0: _inPos (high float) 3x1 [-1]
+//  #1: _inNor (high float) 3x1 [-1]

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/vertex/loops-for-withvec4inductorW-outES3.txt

@@ -40,7 +40,10 @@ void main ()
   Temp_int_1.xyz = floatBitsToInt((intBitsToFloat(Temp_int_0).www * intBitsToFloat(Temp_int_1).xyz));
   Temp_2.xyz = glstate_lightmodel_ambient.xyz;
   Temp_int_0.w = 0;
-  for (; Temp_int_0.w < 4; Temp_int_0.w = (Temp_int_0.w + 1)) {
+  while (true) {
+    if ((Temp_int_0.w >= 4)) {
+      break;
+    };
     Temp_3.xyz = ((-(
       intBitsToFloat(Temp_int_0)
     .xyz) * unity_LightPosition[Temp_int_0.w].www) + unity_LightPosition[Temp_int_0.w].xyz);
@@ -61,6 +64,7 @@ void main ()
     Temp_2.w = max (Temp_2.w, 0.0);
     Temp_int_1.w = floatBitsToInt((intBitsToFloat(Temp_int_1).w * Temp_2.w));
     Temp_2.xyz = ((unity_LightColor[Temp_int_0.w].xyz * intBitsToFloat(Temp_int_1).www) + Temp_2.xyz);
+    Temp_int_0.w = (Temp_int_0.w + 1);
   };
   COLOR0.xyz = (Temp_2.xyz * _Color.xyz);
   COLOR0.w = (_Color.w * _ReflectColor.w);

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/vertex/loops-for-withvec4inductorW-outES3Metal.txt

@@ -49,7 +49,10 @@ int4 Temp_int_1_5;
   Temp_int_1_5.xyz = as_type<int3>((as_type<float4>(Temp_int_0_4).www * as_type<float4>(Temp_int_1_5).xyz));
   Temp_2_2.xyz = _mtl_u.glstate_lightmodel_ambient.xyz;
   Temp_int_0_4.w = 0;
-  for (; Temp_int_0_4.w < 4; Temp_int_0_4.w = (Temp_int_0_4.w + 1)) {
+  while (true) {
+    if ((Temp_int_0_4.w >= 4)) {
+      break;
+    };
     Temp_3_3.xyz = ((-(
       as_type<float4>(Temp_int_0_4)
     .xyz) * _mtl_u.unity_LightPosition[Temp_int_0_4.w].www) + _mtl_u.unity_LightPosition[Temp_int_0_4.w].xyz);
@@ -70,6 +73,7 @@ int4 Temp_int_1_5;
     Temp_2_2.w = max (Temp_2_2.w, 0.0);
     Temp_int_1_5.w = as_type<int>((as_type<float4>(Temp_int_1_5).w * Temp_2_2.w));
     Temp_2_2.xyz = ((_mtl_u.unity_LightColor[Temp_int_0_4.w].xyz * as_type<float4>(Temp_int_1_5).www) + Temp_2_2.xyz);
+    Temp_int_0_4.w = (Temp_int_0_4.w + 1);
   };
   _mtl_o.COLOR0.xyz = (Temp_2_2.xyz * _mtl_u._Color.xyz);
   _mtl_o.COLOR0.w = (_mtl_u._Color.w * _mtl_u._ReflectColor.w);

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/vertex/loops-forlimitbreak-inES.txt

@@ -0,0 +1,63 @@
+#line 1
+attribute vec4 _glesVertex;
+attribute vec3 _glesNormal;
+struct v2f {
+    lowp vec4 color;
+    highp vec4 pos;
+};
+struct appdata {
+    highp vec3 pos;
+    highp vec3 normal;
+};
+uniform mediump vec4 unity_LightColor[8];
+uniform highp vec4 unity_LightPosition[8];
+uniform highp ivec4 unity_VertexLightParams;
+mediump vec3 computeLighting(in highp int idx, in mediump vec3 dirToLight, in mediump vec3 eyeNormal, in mediump float atten)
+{
+    mediump float NdotL = max( dot( eyeNormal, dirToLight), 0.0);
+    mediump vec3 color = NdotL * unity_LightColor[idx].xyz;
+    return color * atten;
+}
+mediump vec3 computeOneLight( in highp int idx, in mediump vec3 eyeNormal)
+{
+    highp vec3 dirToLight = unity_LightPosition[idx].xyz;
+    mediump float att = 1.0;
+   
+    att *= 0.5;
+    return min( computeLighting( idx, dirToLight, eyeNormal, att), vec3(1.0));
+}
+v2f vert( in appdata IN )
+{
+    v2f o;
+    mediump vec4 color = vec4(0.0, 0.0, 0.0, 1.1);
+   
+    mediump vec3 eyeNormal = IN.normal;
+   
+    mediump vec3 lcolor = vec3(0.0);
+
+    // loop doing up to N lights, with max cap
+    highp int il = 0;
+    for ( ; (float(il) < min( 8.0, float(unity_VertexLightParams.x))); (++il))
+    {
+        lcolor += computeOneLight(il, eyeNormal);
+    }
+    color.xyz = lcolor.xyz;
+
+    // other forms of a similar loop
+    for (int j = 0; j < int(min(float(unity_VertexLightParams.y),4.0)); ++j)
+    	color.xyz += unity_LightColor[j].xyz;
+
+    o.color = color;   
+    o.pos = vec4(IN.pos,1.0);
+    return o;
+}
+varying lowp vec4 xlv_COLOR0;
+void main() {
+    v2f xl_retval;
+    appdata xlt_IN;
+    xlt_IN.pos = _glesVertex.xyz;
+    xlt_IN.normal = _glesNormal;
+    xl_retval = vert(xlt_IN);
+    xlv_COLOR0 = vec4(xl_retval.color);
+    gl_Position = vec4(xl_retval.pos);
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/vertex/loops-forlimitbreak-inES3.txt

@@ -0,0 +1,66 @@
+#version 300 es
+#line 2
+in vec4 _glesVertex;
+in vec3 _glesNormal;
+struct v2f {
+    lowp vec4 color;
+    highp vec4 pos;
+};
+struct appdata {
+    highp vec3 pos;
+    highp vec3 normal;
+};
+uniform mediump vec4 unity_LightColor[8];
+uniform highp vec4 unity_LightPosition[8];
+uniform highp ivec4 unity_VertexLightParams;
+mediump vec3 computeLighting(in highp int idx, in mediump vec3 dirToLight, in mediump vec3 eyeNormal, in mediump float atten)
+{
+    mediump float NdotL = max( dot( eyeNormal, dirToLight), 0.0);
+    mediump vec3 color = NdotL * unity_LightColor[idx].xyz;
+    return color * atten;
+}
+mediump vec3 computeOneLight( in highp int idx, in mediump vec3 eyeNormal)
+{
+    highp vec3 dirToLight = unity_LightPosition[idx].xyz;
+    mediump float att = 1.0;
+   
+    att *= 0.5;
+    return min( computeLighting( idx, dirToLight, eyeNormal, att), vec3(1.0));
+}
+v2f vert( in appdata IN )
+{
+    v2f o;
+    mediump vec4 color = vec4(0.0, 0.0, 0.0, 1.1);
+   
+    mediump vec3 eyeNormal = IN.normal;
+   
+    mediump vec3 lcolor = vec3(0.0);
+
+    // loop doing up to N lights, with max cap
+    highp int il = 0;
+    for ( ; (float(il) < min( 8.0, float(unity_VertexLightParams.x))); (++il))
+    {
+        lcolor += computeOneLight(il, eyeNormal);
+    }
+    color.xyz = lcolor.xyz;
+
+    // other forms of a similar loop
+    for (int j = 0; j < int(min(float(unity_VertexLightParams.y),4.0)); ++j)
+    	color.xyz += unity_LightColor[j].xyz;
+    for (int j = 0; j < min(unity_VertexLightParams.y,4); ++j)
+        color.xyz *= unity_LightColor[j].xyz;
+
+    o.color = color;   
+    o.pos = vec4(IN.pos,1.0);
+    return o;
+}
+out lowp vec4 xlv_COLOR0;
+void main() {
+    v2f xl_retval;
+    appdata xlt_IN;
+    xlt_IN.pos = _glesVertex.xyz;
+    xlt_IN.normal = _glesNormal;
+    xl_retval = vert(xlt_IN);
+    xlv_COLOR0 = vec4(xl_retval.color);
+    gl_Position = vec4(xl_retval.pos);
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/vertex/loops-forlimitbreak-outES.txt

@@ -0,0 +1,65 @@
+attribute vec4 _glesVertex;
+attribute vec3 _glesNormal;
+uniform mediump vec4 unity_LightColor[8];
+uniform highp vec4 unity_LightPosition[8];
+uniform highp ivec4 unity_VertexLightParams;
+varying lowp vec4 xlv_COLOR0;
+void main ()
+{
+  highp vec3 tmpvar_1;
+  highp vec3 tmpvar_2;
+  tmpvar_1 = _glesVertex.xyz;
+  tmpvar_2 = _glesNormal;
+  highp int j_3;
+  highp int il_4;
+  mediump vec3 lcolor_5;
+  mediump vec3 eyeNormal_6;
+  mediump vec4 color_7;
+  lowp vec4 tmpvar_8;
+  color_7 = vec4(0.0, 0.0, 0.0, 1.1);
+  eyeNormal_6 = tmpvar_2;
+  lcolor_5 = vec3(0.0, 0.0, 0.0);
+  il_4 = 0;
+  while (true) {
+    highp float tmpvar_9;
+    tmpvar_9 = min (8.0, float(unity_VertexLightParams.x));
+    if ((float(il_4) >= tmpvar_9)) {
+      break;
+    };
+    highp vec3 tmpvar_10;
+    tmpvar_10 = unity_LightPosition[il_4].xyz;
+    mediump vec3 dirToLight_11;
+    dirToLight_11 = tmpvar_10;
+    lcolor_5 = (lcolor_5 + min ((
+      (max (dot (eyeNormal_6, dirToLight_11), 0.0) * unity_LightColor[il_4].xyz)
+     * 0.5), vec3(1.0, 1.0, 1.0)));
+    il_4++;
+  };
+  color_7.xyz = lcolor_5;
+  j_3 = 0;
+  while (true) {
+    highp float tmpvar_12;
+    tmpvar_12 = min (float(unity_VertexLightParams.y), 4.0);
+    if ((j_3 >= int(tmpvar_12))) {
+      break;
+    };
+    color_7.xyz = (color_7.xyz + unity_LightColor[j_3].xyz);
+    j_3++;
+  };
+  tmpvar_8 = color_7;
+  highp vec4 tmpvar_13;
+  tmpvar_13.w = 1.0;
+  tmpvar_13.xyz = tmpvar_1;
+  xlv_COLOR0 = tmpvar_8;
+  gl_Position = tmpvar_13;
+}
+
+
+// stats: 22 alu 0 tex 4 flow
+// inputs: 2
+//  #0: _glesVertex (high float) 4x1 [-1]
+//  #1: _glesNormal (high float) 3x1 [-1]
+// uniforms: 3 (total size: 0)
+//  #0: unity_LightColor (medium float) 4x1 [8]
+//  #1: unity_LightPosition (high float) 4x1 [8]
+//  #2: unity_VertexLightParams (high int) 4x1 [-1]

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/vertex/loops-forlimitbreak-outES3.txt

@@ -0,0 +1,77 @@
+#version 300 es
+in vec4 _glesVertex;
+in vec3 _glesNormal;
+uniform mediump vec4 unity_LightColor[8];
+uniform highp vec4 unity_LightPosition[8];
+uniform highp ivec4 unity_VertexLightParams;
+out lowp vec4 xlv_COLOR0;
+void main ()
+{
+  highp vec3 tmpvar_1;
+  highp vec3 tmpvar_2;
+  tmpvar_1 = _glesVertex.xyz;
+  tmpvar_2 = _glesNormal;
+  highp int j_3;
+  highp int j_4;
+  highp int il_5;
+  mediump vec3 lcolor_6;
+  mediump vec3 eyeNormal_7;
+  mediump vec4 color_8;
+  lowp vec4 tmpvar_9;
+  color_8 = vec4(0.0, 0.0, 0.0, 1.1);
+  eyeNormal_7 = tmpvar_2;
+  lcolor_6 = vec3(0.0, 0.0, 0.0);
+  il_5 = 0;
+  while (true) {
+    highp float tmpvar_10;
+    tmpvar_10 = min (8.0, float(unity_VertexLightParams.x));
+    if ((float(il_5) >= tmpvar_10)) {
+      break;
+    };
+    highp vec3 tmpvar_11;
+    tmpvar_11 = unity_LightPosition[il_5].xyz;
+    mediump vec3 dirToLight_12;
+    dirToLight_12 = tmpvar_11;
+    lcolor_6 = (lcolor_6 + min ((
+      (max (dot (eyeNormal_7, dirToLight_12), 0.0) * unity_LightColor[il_5].xyz)
+     * 0.5), vec3(1.0, 1.0, 1.0)));
+    il_5++;
+  };
+  color_8.xyz = lcolor_6;
+  j_4 = 0;
+  while (true) {
+    highp float tmpvar_13;
+    tmpvar_13 = min (float(unity_VertexLightParams.y), 4.0);
+    if ((j_4 >= int(tmpvar_13))) {
+      break;
+    };
+    color_8.xyz = (color_8.xyz + unity_LightColor[j_4].xyz);
+    j_4++;
+  };
+  j_3 = 0;
+  while (true) {
+    highp int tmpvar_14;
+    tmpvar_14 = min (unity_VertexLightParams.y, 4);
+    if ((j_3 >= tmpvar_14)) {
+      break;
+    };
+    color_8.xyz = (color_8.xyz * unity_LightColor[j_3].xyz);
+    j_3++;
+  };
+  tmpvar_9 = color_8;
+  highp vec4 tmpvar_15;
+  tmpvar_15.w = 1.0;
+  tmpvar_15.xyz = tmpvar_1;
+  xlv_COLOR0 = tmpvar_9;
+  gl_Position = tmpvar_15;
+}
+
+
+// stats: 27 alu 0 tex 6 flow
+// inputs: 2
+//  #0: _glesVertex (high float) 4x1 [-1]
+//  #1: _glesNormal (high float) 3x1 [-1]
+// uniforms: 3 (total size: 0)
+//  #0: unity_LightColor (medium float) 4x1 [8]
+//  #1: unity_LightPosition (high float) 4x1 [8]
+//  #2: unity_VertexLightParams (high int) 4x1 [-1]

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/vertex/loops-forlimitbreak-outES3Metal.txt

@@ -0,0 +1,85 @@
+#include <metal_stdlib>
+using namespace metal;
+struct xlatMtlShaderInput {
+  float4 _glesVertex [[attribute(0)]];
+  float3 _glesNormal [[attribute(1)]];
+};
+struct xlatMtlShaderOutput {
+  float4 gl_Position [[position]];
+  half4 xlv_COLOR0;
+};
+struct xlatMtlShaderUniform {
+  half4 unity_LightColor[8];
+  float4 unity_LightPosition[8];
+  int4 unity_VertexLightParams;
+};
+vertex xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]], constant xlatMtlShaderUniform& _mtl_u [[buffer(0)]])
+{
+  xlatMtlShaderOutput _mtl_o;
+  float3 tmpvar_1;
+  tmpvar_1 = _mtl_i._glesVertex.xyz;
+  int j_2;
+  int j_3;
+  int il_4;
+  half3 lcolor_5;
+  half3 eyeNormal_6;
+  half4 color_7;
+  half4 tmpvar_8;
+  color_7 = half4(float4(0.0, 0.0, 0.0, 1.1));
+  eyeNormal_6 = half3(_mtl_i._glesNormal);
+  lcolor_5 = half3(float3(0.0, 0.0, 0.0));
+  il_4 = 0;
+  while (true) {
+    float tmpvar_9;
+    tmpvar_9 = min (8.0, float(_mtl_u.unity_VertexLightParams.x));
+    if ((float(il_4) >= tmpvar_9)) {
+      break;
+    };
+    float3 tmpvar_10;
+    tmpvar_10 = _mtl_u.unity_LightPosition[il_4].xyz;
+    half3 dirToLight_11;
+    dirToLight_11 = half3(tmpvar_10);
+    lcolor_5 = (lcolor_5 + min ((
+      (max (dot (eyeNormal_6, dirToLight_11), (half)0.0) * _mtl_u.unity_LightColor[il_4].xyz)
+     * (half)0.5), (half3)float3(1.0, 1.0, 1.0)));
+    il_4++;
+  };
+  color_7.xyz = lcolor_5;
+  j_3 = 0;
+  while (true) {
+    float tmpvar_12;
+    tmpvar_12 = min (float(_mtl_u.unity_VertexLightParams.y), 4.0);
+    if ((j_3 >= int(tmpvar_12))) {
+      break;
+    };
+    color_7.xyz = (color_7.xyz + _mtl_u.unity_LightColor[j_3].xyz);
+    j_3++;
+  };
+  j_2 = 0;
+  while (true) {
+    int tmpvar_13;
+    tmpvar_13 = min (_mtl_u.unity_VertexLightParams.y, 4);
+    if ((j_2 >= tmpvar_13)) {
+      break;
+    };
+    color_7.xyz = (color_7.xyz * _mtl_u.unity_LightColor[j_2].xyz);
+    j_2++;
+  };
+  tmpvar_8 = color_7;
+  float4 tmpvar_14;
+  tmpvar_14.w = 1.0;
+  tmpvar_14.xyz = tmpvar_1;
+  _mtl_o.xlv_COLOR0 = tmpvar_8;
+  _mtl_o.gl_Position = tmpvar_14;
+  return _mtl_o;
+}
+
+
+// stats: 27 alu 0 tex 6 flow
+// inputs: 2
+//  #0: _glesVertex (high float) 4x1 [-1] loc 0
+//  #1: _glesNormal (high float) 3x1 [-1] loc 1
+// uniforms: 3 (total size: 208)
+//  #0: unity_LightColor (medium float) 4x1 [8] loc 0
+//  #1: unity_LightPosition (high float) 4x1 [8] loc 64
+//  #2: unity_VertexLightParams (high int) 4x1 [-1] loc 192

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/vertex/z-NichsHybridLightVectorInsertBug-outES.txt

@@ -17,134 +17,134 @@ void main ()
   highp vec2 tmpvar_6;
   tmpvar_6.y = 1.0;
   tmpvar_6.x = float(tmpvar_5.x);
-  mediump vec4 tmpvar_7;
-  mediump vec2 coord_8;
-  coord_8 = tmpvar_6;
+  mediump vec2 coord_7;
+  coord_7 = tmpvar_6;
+  mediump vec4 tmpvar_8;
+  tmpvar_8.zw = vec2(0.0, 0.0);
+  tmpvar_8.xy = (coord_7 / _DynLampInfo_bufferSize);
   mediump vec4 tmpvar_9;
-  tmpvar_9.zw = vec2(0.0, 0.0);
-  tmpvar_9.xy = (coord_8 / _DynLampInfo_bufferSize);
   lowp vec4 tmpvar_10;
-  tmpvar_10 = texture2DLod (_DynLampInfo, tmpvar_9.xy, 0.0);
-  tmpvar_7 = tmpvar_10;
+  tmpvar_10 = texture2DLod (_DynLampInfo, tmpvar_8.xy, 0.0);
+  tmpvar_9 = tmpvar_10;
   highp vec2 tmpvar_11;
   tmpvar_11.y = 2.0;
   tmpvar_11.x = float(tmpvar_5.x);
-  mediump vec4 tmpvar_12;
-  mediump vec2 coord_13;
-  coord_13 = tmpvar_11;
+  mediump vec2 coord_12;
+  coord_12 = tmpvar_11;
+  mediump vec4 tmpvar_13;
+  tmpvar_13.zw = vec2(0.0, 0.0);
+  tmpvar_13.xy = (coord_12 / _DynLampInfo_bufferSize);
   mediump vec4 tmpvar_14;
-  tmpvar_14.zw = vec2(0.0, 0.0);
-  tmpvar_14.xy = (coord_13 / _DynLampInfo_bufferSize);
   lowp vec4 tmpvar_15;
-  tmpvar_15 = texture2DLod (_DynLampInfo, tmpvar_14.xy, 0.0);
-  tmpvar_12 = tmpvar_15;
+  tmpvar_15 = texture2DLod (_DynLampInfo, tmpvar_13.xy, 0.0);
+  tmpvar_14 = tmpvar_15;
   highp vec2 tmpvar_16;
   tmpvar_16.y = 1.0;
   tmpvar_16.x = float(tmpvar_5.y);
-  mediump vec4 tmpvar_17;
-  mediump vec2 coord_18;
-  coord_18 = tmpvar_16;
+  mediump vec2 coord_17;
+  coord_17 = tmpvar_16;
+  mediump vec4 tmpvar_18;
+  tmpvar_18.zw = vec2(0.0, 0.0);
+  tmpvar_18.xy = (coord_17 / _DynLampInfo_bufferSize);
   mediump vec4 tmpvar_19;
-  tmpvar_19.zw = vec2(0.0, 0.0);
-  tmpvar_19.xy = (coord_18 / _DynLampInfo_bufferSize);
   lowp vec4 tmpvar_20;
-  tmpvar_20 = texture2DLod (_DynLampInfo, tmpvar_19.xy, 0.0);
-  tmpvar_17 = tmpvar_20;
+  tmpvar_20 = texture2DLod (_DynLampInfo, tmpvar_18.xy, 0.0);
+  tmpvar_19 = tmpvar_20;
   highp vec2 tmpvar_21;
   tmpvar_21.y = 2.0;
   tmpvar_21.x = float(tmpvar_5.y);
-  mediump vec4 tmpvar_22;
-  mediump vec2 coord_23;
-  coord_23 = tmpvar_21;
+  mediump vec2 coord_22;
+  coord_22 = tmpvar_21;
+  mediump vec4 tmpvar_23;
+  tmpvar_23.zw = vec2(0.0, 0.0);
+  tmpvar_23.xy = (coord_22 / _DynLampInfo_bufferSize);
   mediump vec4 tmpvar_24;
-  tmpvar_24.zw = vec2(0.0, 0.0);
-  tmpvar_24.xy = (coord_23 / _DynLampInfo_bufferSize);
   lowp vec4 tmpvar_25;
-  tmpvar_25 = texture2DLod (_DynLampInfo, tmpvar_24.xy, 0.0);
-  tmpvar_22 = tmpvar_25;
+  tmpvar_25 = texture2DLod (_DynLampInfo, tmpvar_23.xy, 0.0);
+  tmpvar_24 = tmpvar_25;
   highp vec2 tmpvar_26;
   tmpvar_26.y = 1.0;
   tmpvar_26.x = float(tmpvar_5.z);
-  mediump vec4 tmpvar_27;
-  mediump vec2 coord_28;
-  coord_28 = tmpvar_26;
+  mediump vec2 coord_27;
+  coord_27 = tmpvar_26;
+  mediump vec4 tmpvar_28;
+  tmpvar_28.zw = vec2(0.0, 0.0);
+  tmpvar_28.xy = (coord_27 / _DynLampInfo_bufferSize);
   mediump vec4 tmpvar_29;
-  tmpvar_29.zw = vec2(0.0, 0.0);
-  tmpvar_29.xy = (coord_28 / _DynLampInfo_bufferSize);
   lowp vec4 tmpvar_30;
-  tmpvar_30 = texture2DLod (_DynLampInfo, tmpvar_29.xy, 0.0);
-  tmpvar_27 = tmpvar_30;
+  tmpvar_30 = texture2DLod (_DynLampInfo, tmpvar_28.xy, 0.0);
+  tmpvar_29 = tmpvar_30;
   highp vec2 tmpvar_31;
   tmpvar_31.y = 2.0;
   tmpvar_31.x = float(tmpvar_5.z);
-  mediump vec4 tmpvar_32;
-  mediump vec2 coord_33;
-  coord_33 = tmpvar_31;
+  mediump vec2 coord_32;
+  coord_32 = tmpvar_31;
+  mediump vec4 tmpvar_33;
+  tmpvar_33.zw = vec2(0.0, 0.0);
+  tmpvar_33.xy = (coord_32 / _DynLampInfo_bufferSize);
   mediump vec4 tmpvar_34;
-  tmpvar_34.zw = vec2(0.0, 0.0);
-  tmpvar_34.xy = (coord_33 / _DynLampInfo_bufferSize);
   lowp vec4 tmpvar_35;
-  tmpvar_35 = texture2DLod (_DynLampInfo, tmpvar_34.xy, 0.0);
-  tmpvar_32 = tmpvar_35;
+  tmpvar_35 = texture2DLod (_DynLampInfo, tmpvar_33.xy, 0.0);
+  tmpvar_34 = tmpvar_35;
   highp vec2 tmpvar_36;
   tmpvar_36.y = 1.0;
   tmpvar_36.x = float(tmpvar_5.w);
-  mediump vec4 tmpvar_37;
-  mediump vec2 coord_38;
-  coord_38 = tmpvar_36;
+  mediump vec2 coord_37;
+  coord_37 = tmpvar_36;
+  mediump vec4 tmpvar_38;
+  tmpvar_38.zw = vec2(0.0, 0.0);
+  tmpvar_38.xy = (coord_37 / _DynLampInfo_bufferSize);
   mediump vec4 tmpvar_39;
-  tmpvar_39.zw = vec2(0.0, 0.0);
-  tmpvar_39.xy = (coord_38 / _DynLampInfo_bufferSize);
   lowp vec4 tmpvar_40;
-  tmpvar_40 = texture2DLod (_DynLampInfo, tmpvar_39.xy, 0.0);
-  tmpvar_37 = tmpvar_40;
+  tmpvar_40 = texture2DLod (_DynLampInfo, tmpvar_38.xy, 0.0);
+  tmpvar_39 = tmpvar_40;
   highp vec2 tmpvar_41;
   tmpvar_41.y = 2.0;
   tmpvar_41.x = float(tmpvar_5.w);
-  mediump vec4 tmpvar_42;
-  mediump vec2 coord_43;
-  coord_43 = tmpvar_41;
+  mediump vec2 coord_42;
+  coord_42 = tmpvar_41;
+  mediump vec4 tmpvar_43;
+  tmpvar_43.zw = vec2(0.0, 0.0);
+  tmpvar_43.xy = (coord_42 / _DynLampInfo_bufferSize);
   mediump vec4 tmpvar_44;
-  tmpvar_44.zw = vec2(0.0, 0.0);
-  tmpvar_44.xy = (coord_43 / _DynLampInfo_bufferSize);
   lowp vec4 tmpvar_45;
-  tmpvar_45 = texture2DLod (_DynLampInfo, tmpvar_44.xy, 0.0);
-  tmpvar_42 = tmpvar_45;
+  tmpvar_45 = texture2DLod (_DynLampInfo, tmpvar_43.xy, 0.0);
+  tmpvar_44 = tmpvar_45;
   mediump vec3 hybridCol_46;
   mediump vec4 atten_47;
   highp vec3 tmpvar_48;
-  tmpvar_48 = (tmpvar_7.xyz - tmpvar_2);
+  tmpvar_48 = (tmpvar_9.xyz - tmpvar_2);
   highp float tmpvar_49;
   tmpvar_49 = dot (tmpvar_48, tmpvar_48);
   mediump vec4 tmpvar_50;
   tmpvar_50.yzw = atten_47.yzw;
-  tmpvar_50.x = (tmpvar_49 * tmpvar_7.w);
+  tmpvar_50.x = (tmpvar_49 * tmpvar_9.w);
   highp vec3 tmpvar_51;
-  tmpvar_51 = (tmpvar_17.xyz - tmpvar_2);
+  tmpvar_51 = (tmpvar_19.xyz - tmpvar_2);
   highp float tmpvar_52;
   tmpvar_52 = dot (tmpvar_51, tmpvar_51);
   mediump vec4 tmpvar_53;
   tmpvar_53.xzw = tmpvar_50.xzw;
-  tmpvar_53.y = (tmpvar_52 * tmpvar_17.w);
+  tmpvar_53.y = (tmpvar_52 * tmpvar_19.w);
   highp vec3 tmpvar_54;
-  tmpvar_54 = (tmpvar_27.xyz - tmpvar_2);
+  tmpvar_54 = (tmpvar_29.xyz - tmpvar_2);
   highp float tmpvar_55;
   tmpvar_55 = dot (tmpvar_54, tmpvar_54);
   mediump vec4 tmpvar_56;
   tmpvar_56.xyw = tmpvar_53.xyw;
-  tmpvar_56.z = (tmpvar_55 * tmpvar_27.w);
+  tmpvar_56.z = (tmpvar_55 * tmpvar_29.w);
   highp vec3 tmpvar_57;
-  tmpvar_57 = (tmpvar_37.xyz - tmpvar_2);
+  tmpvar_57 = (tmpvar_39.xyz - tmpvar_2);
   highp float tmpvar_58;
   tmpvar_58 = dot (tmpvar_57, tmpvar_57);
   mediump vec4 tmpvar_59;
   tmpvar_59.xyz = tmpvar_56.xyz;
-  tmpvar_59.w = (tmpvar_58 * tmpvar_37.w);
+  tmpvar_59.w = (tmpvar_58 * tmpvar_39.w);
   atten_47 = tmpvar_59;
-  hybridCol_46 = (hybridCol_4 + (tmpvar_12.xyz * tmpvar_50.x));
-  hybridCol_46 = (hybridCol_46 + (tmpvar_22.xyz * tmpvar_53.y));
-  hybridCol_46 = (hybridCol_46 + (tmpvar_32.xyz * tmpvar_56.z));
-  hybridCol_46 = (hybridCol_46 + (tmpvar_42.xyz * tmpvar_59.w));
+  hybridCol_46 = (hybridCol_4 + (tmpvar_14.xyz * tmpvar_50.x));
+  hybridCol_46 = (hybridCol_46 + (tmpvar_24.xyz * tmpvar_53.y));
+  hybridCol_46 = (hybridCol_46 + (tmpvar_34.xyz * tmpvar_56.z));
+  hybridCol_46 = (hybridCol_46 + (tmpvar_44.xyz * tmpvar_59.w));
   tmpvar_3 = hybridCol_46;
   tmpvar_1 = tmpvar_3;
   gl_Position = (glstate_matrix_mvp * _glesVertex);

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/vertex/z-NichsHybridLightVectorInsertBug-outES3.txt

@@ -18,134 +18,134 @@ void main ()
   highp vec2 tmpvar_6;
   tmpvar_6.y = 1.0;
   tmpvar_6.x = float(tmpvar_5.x);
-  mediump vec4 tmpvar_7;
-  mediump vec2 coord_8;
-  coord_8 = tmpvar_6;
+  mediump vec2 coord_7;
+  coord_7 = tmpvar_6;
+  mediump vec4 tmpvar_8;
+  tmpvar_8.zw = vec2(0.0, 0.0);
+  tmpvar_8.xy = (coord_7 / _DynLampInfo_bufferSize);
   mediump vec4 tmpvar_9;
-  tmpvar_9.zw = vec2(0.0, 0.0);
-  tmpvar_9.xy = (coord_8 / _DynLampInfo_bufferSize);
   lowp vec4 tmpvar_10;
-  tmpvar_10 = textureLod (_DynLampInfo, tmpvar_9.xy, 0.0);
-  tmpvar_7 = tmpvar_10;
+  tmpvar_10 = textureLod (_DynLampInfo, tmpvar_8.xy, 0.0);
+  tmpvar_9 = tmpvar_10;
   highp vec2 tmpvar_11;
   tmpvar_11.y = 2.0;
   tmpvar_11.x = float(tmpvar_5.x);
-  mediump vec4 tmpvar_12;
-  mediump vec2 coord_13;
-  coord_13 = tmpvar_11;
+  mediump vec2 coord_12;
+  coord_12 = tmpvar_11;
+  mediump vec4 tmpvar_13;
+  tmpvar_13.zw = vec2(0.0, 0.0);
+  tmpvar_13.xy = (coord_12 / _DynLampInfo_bufferSize);
   mediump vec4 tmpvar_14;
-  tmpvar_14.zw = vec2(0.0, 0.0);
-  tmpvar_14.xy = (coord_13 / _DynLampInfo_bufferSize);
   lowp vec4 tmpvar_15;
-  tmpvar_15 = textureLod (_DynLampInfo, tmpvar_14.xy, 0.0);
-  tmpvar_12 = tmpvar_15;
+  tmpvar_15 = textureLod (_DynLampInfo, tmpvar_13.xy, 0.0);
+  tmpvar_14 = tmpvar_15;
   highp vec2 tmpvar_16;
   tmpvar_16.y = 1.0;
   tmpvar_16.x = float(tmpvar_5.y);
-  mediump vec4 tmpvar_17;
-  mediump vec2 coord_18;
-  coord_18 = tmpvar_16;
+  mediump vec2 coord_17;
+  coord_17 = tmpvar_16;
+  mediump vec4 tmpvar_18;
+  tmpvar_18.zw = vec2(0.0, 0.0);
+  tmpvar_18.xy = (coord_17 / _DynLampInfo_bufferSize);
   mediump vec4 tmpvar_19;
-  tmpvar_19.zw = vec2(0.0, 0.0);
-  tmpvar_19.xy = (coord_18 / _DynLampInfo_bufferSize);
   lowp vec4 tmpvar_20;
-  tmpvar_20 = textureLod (_DynLampInfo, tmpvar_19.xy, 0.0);
-  tmpvar_17 = tmpvar_20;
+  tmpvar_20 = textureLod (_DynLampInfo, tmpvar_18.xy, 0.0);
+  tmpvar_19 = tmpvar_20;
   highp vec2 tmpvar_21;
   tmpvar_21.y = 2.0;
   tmpvar_21.x = float(tmpvar_5.y);
-  mediump vec4 tmpvar_22;
-  mediump vec2 coord_23;
-  coord_23 = tmpvar_21;
+  mediump vec2 coord_22;
+  coord_22 = tmpvar_21;
+  mediump vec4 tmpvar_23;
+  tmpvar_23.zw = vec2(0.0, 0.0);
+  tmpvar_23.xy = (coord_22 / _DynLampInfo_bufferSize);
   mediump vec4 tmpvar_24;
-  tmpvar_24.zw = vec2(0.0, 0.0);
-  tmpvar_24.xy = (coord_23 / _DynLampInfo_bufferSize);
   lowp vec4 tmpvar_25;
-  tmpvar_25 = textureLod (_DynLampInfo, tmpvar_24.xy, 0.0);
-  tmpvar_22 = tmpvar_25;
+  tmpvar_25 = textureLod (_DynLampInfo, tmpvar_23.xy, 0.0);
+  tmpvar_24 = tmpvar_25;
   highp vec2 tmpvar_26;
   tmpvar_26.y = 1.0;
   tmpvar_26.x = float(tmpvar_5.z);
-  mediump vec4 tmpvar_27;
-  mediump vec2 coord_28;
-  coord_28 = tmpvar_26;
+  mediump vec2 coord_27;
+  coord_27 = tmpvar_26;
+  mediump vec4 tmpvar_28;
+  tmpvar_28.zw = vec2(0.0, 0.0);
+  tmpvar_28.xy = (coord_27 / _DynLampInfo_bufferSize);
   mediump vec4 tmpvar_29;
-  tmpvar_29.zw = vec2(0.0, 0.0);
-  tmpvar_29.xy = (coord_28 / _DynLampInfo_bufferSize);
   lowp vec4 tmpvar_30;
-  tmpvar_30 = textureLod (_DynLampInfo, tmpvar_29.xy, 0.0);
-  tmpvar_27 = tmpvar_30;
+  tmpvar_30 = textureLod (_DynLampInfo, tmpvar_28.xy, 0.0);
+  tmpvar_29 = tmpvar_30;
   highp vec2 tmpvar_31;
   tmpvar_31.y = 2.0;
   tmpvar_31.x = float(tmpvar_5.z);
-  mediump vec4 tmpvar_32;
-  mediump vec2 coord_33;
-  coord_33 = tmpvar_31;
+  mediump vec2 coord_32;
+  coord_32 = tmpvar_31;
+  mediump vec4 tmpvar_33;
+  tmpvar_33.zw = vec2(0.0, 0.0);
+  tmpvar_33.xy = (coord_32 / _DynLampInfo_bufferSize);
   mediump vec4 tmpvar_34;
-  tmpvar_34.zw = vec2(0.0, 0.0);
-  tmpvar_34.xy = (coord_33 / _DynLampInfo_bufferSize);
   lowp vec4 tmpvar_35;
-  tmpvar_35 = textureLod (_DynLampInfo, tmpvar_34.xy, 0.0);
-  tmpvar_32 = tmpvar_35;
+  tmpvar_35 = textureLod (_DynLampInfo, tmpvar_33.xy, 0.0);
+  tmpvar_34 = tmpvar_35;
   highp vec2 tmpvar_36;
   tmpvar_36.y = 1.0;
   tmpvar_36.x = float(tmpvar_5.w);
-  mediump vec4 tmpvar_37;
-  mediump vec2 coord_38;
-  coord_38 = tmpvar_36;
+  mediump vec2 coord_37;
+  coord_37 = tmpvar_36;
+  mediump vec4 tmpvar_38;
+  tmpvar_38.zw = vec2(0.0, 0.0);
+  tmpvar_38.xy = (coord_37 / _DynLampInfo_bufferSize);
   mediump vec4 tmpvar_39;
-  tmpvar_39.zw = vec2(0.0, 0.0);
-  tmpvar_39.xy = (coord_38 / _DynLampInfo_bufferSize);
   lowp vec4 tmpvar_40;
-  tmpvar_40 = textureLod (_DynLampInfo, tmpvar_39.xy, 0.0);
-  tmpvar_37 = tmpvar_40;
+  tmpvar_40 = textureLod (_DynLampInfo, tmpvar_38.xy, 0.0);
+  tmpvar_39 = tmpvar_40;
   highp vec2 tmpvar_41;
   tmpvar_41.y = 2.0;
   tmpvar_41.x = float(tmpvar_5.w);
-  mediump vec4 tmpvar_42;
-  mediump vec2 coord_43;
-  coord_43 = tmpvar_41;
+  mediump vec2 coord_42;
+  coord_42 = tmpvar_41;
+  mediump vec4 tmpvar_43;
+  tmpvar_43.zw = vec2(0.0, 0.0);
+  tmpvar_43.xy = (coord_42 / _DynLampInfo_bufferSize);
   mediump vec4 tmpvar_44;
-  tmpvar_44.zw = vec2(0.0, 0.0);
-  tmpvar_44.xy = (coord_43 / _DynLampInfo_bufferSize);
   lowp vec4 tmpvar_45;
-  tmpvar_45 = textureLod (_DynLampInfo, tmpvar_44.xy, 0.0);
-  tmpvar_42 = tmpvar_45;
+  tmpvar_45 = textureLod (_DynLampInfo, tmpvar_43.xy, 0.0);
+  tmpvar_44 = tmpvar_45;
   mediump vec3 hybridCol_46;
   mediump vec4 atten_47;
   highp vec3 tmpvar_48;
-  tmpvar_48 = (tmpvar_7.xyz - tmpvar_2);
+  tmpvar_48 = (tmpvar_9.xyz - tmpvar_2);
   highp float tmpvar_49;
   tmpvar_49 = dot (tmpvar_48, tmpvar_48);
   mediump vec4 tmpvar_50;
   tmpvar_50.yzw = atten_47.yzw;
-  tmpvar_50.x = (tmpvar_49 * tmpvar_7.w);
+  tmpvar_50.x = (tmpvar_49 * tmpvar_9.w);
   highp vec3 tmpvar_51;
-  tmpvar_51 = (tmpvar_17.xyz - tmpvar_2);
+  tmpvar_51 = (tmpvar_19.xyz - tmpvar_2);
   highp float tmpvar_52;
   tmpvar_52 = dot (tmpvar_51, tmpvar_51);
   mediump vec4 tmpvar_53;
   tmpvar_53.xzw = tmpvar_50.xzw;
-  tmpvar_53.y = (tmpvar_52 * tmpvar_17.w);
+  tmpvar_53.y = (tmpvar_52 * tmpvar_19.w);
   highp vec3 tmpvar_54;
-  tmpvar_54 = (tmpvar_27.xyz - tmpvar_2);
+  tmpvar_54 = (tmpvar_29.xyz - tmpvar_2);
   highp float tmpvar_55;
   tmpvar_55 = dot (tmpvar_54, tmpvar_54);
   mediump vec4 tmpvar_56;
   tmpvar_56.xyw = tmpvar_53.xyw;
-  tmpvar_56.z = (tmpvar_55 * tmpvar_27.w);
+  tmpvar_56.z = (tmpvar_55 * tmpvar_29.w);
   highp vec3 tmpvar_57;
-  tmpvar_57 = (tmpvar_37.xyz - tmpvar_2);
+  tmpvar_57 = (tmpvar_39.xyz - tmpvar_2);
   highp float tmpvar_58;
   tmpvar_58 = dot (tmpvar_57, tmpvar_57);
   mediump vec4 tmpvar_59;
   tmpvar_59.xyz = tmpvar_56.xyz;
-  tmpvar_59.w = (tmpvar_58 * tmpvar_37.w);
+  tmpvar_59.w = (tmpvar_58 * tmpvar_39.w);
   atten_47 = tmpvar_59;
-  hybridCol_46 = (hybridCol_4 + (tmpvar_12.xyz * tmpvar_50.x));
-  hybridCol_46 = (hybridCol_46 + (tmpvar_22.xyz * tmpvar_53.y));
-  hybridCol_46 = (hybridCol_46 + (tmpvar_32.xyz * tmpvar_56.z));
-  hybridCol_46 = (hybridCol_46 + (tmpvar_42.xyz * tmpvar_59.w));
+  hybridCol_46 = (hybridCol_4 + (tmpvar_14.xyz * tmpvar_50.x));
+  hybridCol_46 = (hybridCol_46 + (tmpvar_24.xyz * tmpvar_53.y));
+  hybridCol_46 = (hybridCol_46 + (tmpvar_34.xyz * tmpvar_56.z));
+  hybridCol_46 = (hybridCol_46 + (tmpvar_44.xyz * tmpvar_59.w));
   tmpvar_3 = hybridCol_46;
   tmpvar_1 = tmpvar_3;
   gl_Position = (glstate_matrix_mvp * _glesVertex);

3rdparty/bgfx/3rdparty/glsl-optimizer/tests/vertex/z-NichsHybridLightVectorInsertBug-outES3Metal.txt

@@ -27,134 +27,134 @@ vertex xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]],
   float2 tmpvar_6;
   tmpvar_6.y = 1.0;
   tmpvar_6.x = float(tmpvar_5.x);
-  half4 tmpvar_7;
-  half2 coord_8;
-  coord_8 = half2(tmpvar_6);
+  half2 coord_7;
+  coord_7 = half2(tmpvar_6);
+  half4 tmpvar_8;
+  tmpvar_8.zw = half2(float2(0.0, 0.0));
+  tmpvar_8.xy = (coord_7 / _mtl_u._DynLampInfo_bufferSize);
   half4 tmpvar_9;
-  tmpvar_9.zw = half2(float2(0.0, 0.0));
-  tmpvar_9.xy = (coord_8 / _mtl_u._DynLampInfo_bufferSize);
   half4 tmpvar_10;
-  tmpvar_10 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_9.xy), level(0.0));
-  tmpvar_7 = tmpvar_10;
+  tmpvar_10 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_8.xy), level(0.0));
+  tmpvar_9 = tmpvar_10;
   float2 tmpvar_11;
   tmpvar_11.y = 2.0;
   tmpvar_11.x = float(tmpvar_5.x);
-  half4 tmpvar_12;
-  half2 coord_13;
-  coord_13 = half2(tmpvar_11);
+  half2 coord_12;
+  coord_12 = half2(tmpvar_11);
+  half4 tmpvar_13;
+  tmpvar_13.zw = half2(float2(0.0, 0.0));
+  tmpvar_13.xy = (coord_12 / _mtl_u._DynLampInfo_bufferSize);
   half4 tmpvar_14;
-  tmpvar_14.zw = half2(float2(0.0, 0.0));
-  tmpvar_14.xy = (coord_13 / _mtl_u._DynLampInfo_bufferSize);
   half4 tmpvar_15;
-  tmpvar_15 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_14.xy), level(0.0));
-  tmpvar_12 = tmpvar_15;
+  tmpvar_15 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_13.xy), level(0.0));
+  tmpvar_14 = tmpvar_15;
   float2 tmpvar_16;
   tmpvar_16.y = 1.0;
   tmpvar_16.x = float(tmpvar_5.y);
-  half4 tmpvar_17;
-  half2 coord_18;
-  coord_18 = half2(tmpvar_16);
+  half2 coord_17;
+  coord_17 = half2(tmpvar_16);
+  half4 tmpvar_18;
+  tmpvar_18.zw = half2(float2(0.0, 0.0));
+  tmpvar_18.xy = (coord_17 / _mtl_u._DynLampInfo_bufferSize);
   half4 tmpvar_19;
-  tmpvar_19.zw = half2(float2(0.0, 0.0));
-  tmpvar_19.xy = (coord_18 / _mtl_u._DynLampInfo_bufferSize);
   half4 tmpvar_20;
-  tmpvar_20 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_19.xy), level(0.0));
-  tmpvar_17 = tmpvar_20;
+  tmpvar_20 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_18.xy), level(0.0));
+  tmpvar_19 = tmpvar_20;
   float2 tmpvar_21;
   tmpvar_21.y = 2.0;
   tmpvar_21.x = float(tmpvar_5.y);
-  half4 tmpvar_22;
-  half2 coord_23;
-  coord_23 = half2(tmpvar_21);
+  half2 coord_22;
+  coord_22 = half2(tmpvar_21);
+  half4 tmpvar_23;
+  tmpvar_23.zw = half2(float2(0.0, 0.0));
+  tmpvar_23.xy = (coord_22 / _mtl_u._DynLampInfo_bufferSize);
   half4 tmpvar_24;
-  tmpvar_24.zw = half2(float2(0.0, 0.0));
-  tmpvar_24.xy = (coord_23 / _mtl_u._DynLampInfo_bufferSize);
   half4 tmpvar_25;
-  tmpvar_25 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_24.xy), level(0.0));
-  tmpvar_22 = tmpvar_25;
+  tmpvar_25 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_23.xy), level(0.0));
+  tmpvar_24 = tmpvar_25;
   float2 tmpvar_26;
   tmpvar_26.y = 1.0;
   tmpvar_26.x = float(tmpvar_5.z);
-  half4 tmpvar_27;
-  half2 coord_28;
-  coord_28 = half2(tmpvar_26);
+  half2 coord_27;
+  coord_27 = half2(tmpvar_26);
+  half4 tmpvar_28;
+  tmpvar_28.zw = half2(float2(0.0, 0.0));
+  tmpvar_28.xy = (coord_27 / _mtl_u._DynLampInfo_bufferSize);
   half4 tmpvar_29;
-  tmpvar_29.zw = half2(float2(0.0, 0.0));
-  tmpvar_29.xy = (coord_28 / _mtl_u._DynLampInfo_bufferSize);
   half4 tmpvar_30;
-  tmpvar_30 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_29.xy), level(0.0));
-  tmpvar_27 = tmpvar_30;
+  tmpvar_30 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_28.xy), level(0.0));
+  tmpvar_29 = tmpvar_30;
   float2 tmpvar_31;
   tmpvar_31.y = 2.0;
   tmpvar_31.x = float(tmpvar_5.z);
-  half4 tmpvar_32;
-  half2 coord_33;
-  coord_33 = half2(tmpvar_31);
+  half2 coord_32;
+  coord_32 = half2(tmpvar_31);
+  half4 tmpvar_33;
+  tmpvar_33.zw = half2(float2(0.0, 0.0));
+  tmpvar_33.xy = (coord_32 / _mtl_u._DynLampInfo_bufferSize);
   half4 tmpvar_34;
-  tmpvar_34.zw = half2(float2(0.0, 0.0));
-  tmpvar_34.xy = (coord_33 / _mtl_u._DynLampInfo_bufferSize);
   half4 tmpvar_35;
-  tmpvar_35 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_34.xy), level(0.0));
-  tmpvar_32 = tmpvar_35;
+  tmpvar_35 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_33.xy), level(0.0));
+  tmpvar_34 = tmpvar_35;
   float2 tmpvar_36;
   tmpvar_36.y = 1.0;
   tmpvar_36.x = float(tmpvar_5.w);
-  half4 tmpvar_37;
-  half2 coord_38;
-  coord_38 = half2(tmpvar_36);
+  half2 coord_37;
+  coord_37 = half2(tmpvar_36);
+  half4 tmpvar_38;
+  tmpvar_38.zw = half2(float2(0.0, 0.0));
+  tmpvar_38.xy = (coord_37 / _mtl_u._DynLampInfo_bufferSize);
   half4 tmpvar_39;
-  tmpvar_39.zw = half2(float2(0.0, 0.0));
-  tmpvar_39.xy = (coord_38 / _mtl_u._DynLampInfo_bufferSize);
   half4 tmpvar_40;
-  tmpvar_40 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_39.xy), level(0.0));
-  tmpvar_37 = tmpvar_40;
+  tmpvar_40 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_38.xy), level(0.0));
+  tmpvar_39 = tmpvar_40;
   float2 tmpvar_41;
   tmpvar_41.y = 2.0;
   tmpvar_41.x = float(tmpvar_5.w);
-  half4 tmpvar_42;
-  half2 coord_43;
-  coord_43 = half2(tmpvar_41);
+  half2 coord_42;
+  coord_42 = half2(tmpvar_41);
+  half4 tmpvar_43;
+  tmpvar_43.zw = half2(float2(0.0, 0.0));
+  tmpvar_43.xy = (coord_42 / _mtl_u._DynLampInfo_bufferSize);
   half4 tmpvar_44;
-  tmpvar_44.zw = half2(float2(0.0, 0.0));
-  tmpvar_44.xy = (coord_43 / _mtl_u._DynLampInfo_bufferSize);
   half4 tmpvar_45;
-  tmpvar_45 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_44.xy), level(0.0));
-  tmpvar_42 = tmpvar_45;
+  tmpvar_45 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_43.xy), level(0.0));
+  tmpvar_44 = tmpvar_45;
   half3 hybridCol_46;
   half4 atten_47;
   float3 tmpvar_48;
-  tmpvar_48 = ((float3)tmpvar_7.xyz - tmpvar_2);
+  tmpvar_48 = ((float3)tmpvar_9.xyz - tmpvar_2);
   float tmpvar_49;
   tmpvar_49 = dot (tmpvar_48, tmpvar_48);
   half4 tmpvar_50;
   tmpvar_50.yzw = atten_47.yzw;
-  tmpvar_50.x = half((tmpvar_49 * (float)tmpvar_7.w));
+  tmpvar_50.x = half((tmpvar_49 * (float)tmpvar_9.w));
   float3 tmpvar_51;
-  tmpvar_51 = ((float3)tmpvar_17.xyz - tmpvar_2);
+  tmpvar_51 = ((float3)tmpvar_19.xyz - tmpvar_2);
   float tmpvar_52;
   tmpvar_52 = dot (tmpvar_51, tmpvar_51);
   half4 tmpvar_53;
   tmpvar_53.xzw = tmpvar_50.xzw;
-  tmpvar_53.y = half((tmpvar_52 * (float)tmpvar_17.w));
+  tmpvar_53.y = half((tmpvar_52 * (float)tmpvar_19.w));
   float3 tmpvar_54;
-  tmpvar_54 = ((float3)tmpvar_27.xyz - tmpvar_2);
+  tmpvar_54 = ((float3)tmpvar_29.xyz - tmpvar_2);
   float tmpvar_55;
   tmpvar_55 = dot (tmpvar_54, tmpvar_54);
   half4 tmpvar_56;
   tmpvar_56.xyw = tmpvar_53.xyw;
-  tmpvar_56.z = half((tmpvar_55 * (float)tmpvar_27.w));
+  tmpvar_56.z = half((tmpvar_55 * (float)tmpvar_29.w));
   float3 tmpvar_57;
-  tmpvar_57 = ((float3)tmpvar_37.xyz - tmpvar_2);
+  tmpvar_57 = ((float3)tmpvar_39.xyz - tmpvar_2);
   float tmpvar_58;
   tmpvar_58 = dot (tmpvar_57, tmpvar_57);
   half4 tmpvar_59;
   tmpvar_59.xyz = tmpvar_56.xyz;
-  tmpvar_59.w = half((tmpvar_58 * (float)tmpvar_37.w));
+  tmpvar_59.w = half((tmpvar_58 * (float)tmpvar_39.w));
   atten_47 = tmpvar_59;
-  hybridCol_46 = (hybridCol_4 + (tmpvar_12.xyz * tmpvar_50.x));
-  hybridCol_46 = (hybridCol_46 + (tmpvar_22.xyz * tmpvar_53.y));
-  hybridCol_46 = (hybridCol_46 + (tmpvar_32.xyz * tmpvar_56.z));
-  hybridCol_46 = (hybridCol_46 + (tmpvar_42.xyz * tmpvar_59.w));
+  hybridCol_46 = (hybridCol_4 + (tmpvar_14.xyz * tmpvar_50.x));
+  hybridCol_46 = (hybridCol_46 + (tmpvar_24.xyz * tmpvar_53.y));
+  hybridCol_46 = (hybridCol_46 + (tmpvar_34.xyz * tmpvar_56.z));
+  hybridCol_46 = (hybridCol_46 + (tmpvar_44.xyz * tmpvar_59.w));
   tmpvar_3 = float3(hybridCol_46);
   tmpvar_1 = half3(tmpvar_3);
   _mtl_o.gl_Position = (_mtl_u.glstate_matrix_mvp * _mtl_i._glesVertex);