diff options
Diffstat (limited to 'Runtime/GfxDevice/d3d11')
48 files changed, 50200 insertions, 0 deletions
diff --git a/Runtime/GfxDevice/d3d11/ConstantBuffersD3D11.cpp b/Runtime/GfxDevice/d3d11/ConstantBuffersD3D11.cpp new file mode 100644 index 0000000..fe61e06 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/ConstantBuffersD3D11.cpp @@ -0,0 +1,368 @@ +#include "UnityPrefix.h" +#include "ConstantBuffersD3D11.h" +#include "D3D11Context.h" +#include "D3D11Utils.h" + + +// NEVER enable this for release! Turns off all CB caching and makes things +// very slow, for debugging. +#define DEBUG_DISABLE_CONSTANT_BUFFER_CACHES (0 && !UNITY_RELEASE) + + +#if DEBUG_D3D11_CONSTANT_BUFFER_STATS +#include "External/shaderlab/Library/FastPropertyName.h" +extern std::string g_LastParsedShaderName; +#endif + + +ConstantBuffersD3D11::ConstantBuffersD3D11() +{ + InvalidateState(); +} + +void ConstantBuffersD3D11::InvalidateState() +{ + memset (m_ActiveBuffers, 0, sizeof(m_ActiveBuffers)); +} + + +void ConstantBuffersD3D11::Clear() +{ + memset (m_ActiveBuffers, 0, sizeof(m_ActiveBuffers)); + for (size_t i = 0; i < m_Buffers.size(); ++i) + { + ConstBuffer& cb = m_Buffers[i]; + delete[] cb.data; + if (cb.buffer) + { + cb.buffer->Release(); + REGISTER_EXTERNAL_GFX_DEALLOCATION(cb.buffer); + } + #if DEBUG_D3D11_CONSTANT_BUFFER_STATS + delete[] cb.changeCounts; + delete[] cb.tryCounts; + #endif + } + m_Buffers.clear(); + m_BufferKeys.clear(); +} + + +void ConstantBuffersD3D11::SetCBInfo (int id, int size) +{ + size_t n = m_Buffers.size(); + Assert (m_BufferKeys.size() == n); + UInt32 key = id | (size<<16); + for (size_t i = 0; i < n; ++i) + { + if (m_BufferKeys[i] == key) + return; + } + + // not found, create one + ConstBuffer cb; + cb.data = new UInt8[size]; + memset (cb.data, 0, size); + cb.dirty = true; + for (int i = 0; i < kShaderTypeCount; ++i) + cb.bindIndex[i] = -1; + cb.bindStages = 0; + #if DEBUG_D3D11_CONSTANT_BUFFER_STATS + cb.statsDirty = 0; + for (int i = 0; i < kShaderTypeCount; ++i) + cb.stats[i] = 0; + ShaderLab::FastPropertyName name; + name.index = id; + printf_console ("DX11 Constant Buffer Info: new %s size=%i shader=%s\n", name.GetName(), size, g_LastParsedShaderName.c_str()); + cb.changeCounts = new int[size/4]; + memset (cb.changeCounts, 0, size); + cb.tryCounts = new int[size/4]; + memset (cb.tryCounts, 0, size); + #endif + + ID3D11Device* dev = GetD3D11Device(); + // Default usage and using UpdateSubresource is seemingly preferred path in drivers + // over dynamic buffer with Map. + D3D11_BUFFER_DESC desc; + desc.ByteWidth = size; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + + HRESULT hr = dev->CreateBuffer (&desc, NULL, &cb.buffer); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(cb.buffer,size,this); + Assert (SUCCEEDED(hr)); + SetDebugNameD3D11 (cb.buffer, Format("ConstantBuffer-%d-%d", id, size)); + + m_Buffers.push_back (cb); + m_BufferKeys.push_back (key); +} + +void ConstantBuffersD3D11::SetBuiltinCBConstant (int id, int offset, const void* data, int size) +{ + int idx = GetCBIndexByID (id); + ConstBuffer& cb = m_Buffers[idx]; + Assert (offset >= 0 && offset+size <= (m_BufferKeys[idx]>>16) && size > 0); + + #if DEBUG_D3D11_CONSTANT_BUFFER_STATS + for (int i = offset/4; i < offset/4+size/4; ++i) + ++cb.tryCounts[i]; + #endif + + if (DEBUG_DISABLE_CONSTANT_BUFFER_CACHES || memcmp(cb.data+offset, data, size) != 0) + { + memcpy (cb.data+offset, data, size); + cb.dirty = true; + + #if DEBUG_D3D11_CONSTANT_BUFFER_STATS + for (int i = offset/4; i < offset/4+size/4; ++i) + ++cb.changeCounts[i]; + #endif + } +} + +void ConstantBuffersD3D11::SetCBConstant (int idx, int offset, const void* data, int size) +{ + Assert (idx >= 0 && idx < m_Buffers.size()); + ConstBuffer& cb = m_Buffers[idx]; + Assert (offset >= 0 && offset+size <= (m_BufferKeys[idx]>>16) && size > 0); + + #if DEBUG_D3D11_CONSTANT_BUFFER_STATS + for (int i = offset/4; i < offset/4+size/4; ++i) + ++cb.tryCounts[i]; + #endif + + if (size == 4) + { + UInt32* dstData = (UInt32*)(cb.data+offset); + UInt32 srcData = *(UInt32*)data; + if (DEBUG_DISABLE_CONSTANT_BUFFER_CACHES || *dstData != srcData) + { + *dstData = srcData; + cb.dirty = true; + + #if DEBUG_D3D11_CONSTANT_BUFFER_STATS + for (int i = offset/4; i < offset/4+size/4; ++i) + ++cb.changeCounts[i]; + #endif + } + } + else + { + if (DEBUG_DISABLE_CONSTANT_BUFFER_CACHES || memcmp(cb.data+offset, data, size) != 0) + { + memcpy (cb.data+offset, data, size); + cb.dirty = true; + + #if DEBUG_D3D11_CONSTANT_BUFFER_STATS + for (int i = offset/4; i < offset/4+size/4; ++i) + ++cb.changeCounts[i]; + #endif + } + } +} + +int ConstantBuffersD3D11::FindAndBindCB (int id, ShaderType shaderType, int bind, int size) +{ + UInt32 key = id | (size<<16); + int idx = 0; + for (ConstBufferKeys::const_iterator it = m_BufferKeys.begin(), itEnd = m_BufferKeys.end(); it != itEnd; ++it, ++idx) + { + if (*it == key) + { + ConstBuffer& cb = m_Buffers[idx]; + if (bind >= 0) + { + cb.bindIndex[shaderType] = bind; + cb.bindStages |= (1<<shaderType); + } + return idx; + } + } + Assert (false); + return -1; +} + +void ConstantBuffersD3D11::ResetBinds(ShaderType shaderType) +{ + for (ConstBuffers::iterator it = m_Buffers.begin(), itEnd = m_Buffers.end(); it != itEnd; ++it) + { + it->bindIndex[shaderType] = -1; + it->bindStages &= ~(1<<shaderType); + } +} + + +void ConstantBuffersD3D11::UpdateBuffers () +{ + ID3D11DeviceContext* ctx = GetD3D11Context(); + + D3D11_MAPPED_SUBRESOURCE mapped; + HRESULT hr; + size_t n = m_Buffers.size(); + + #if !UNITY_RELEASE + // check if we have duplicate buffers bound to the same slot (should never happen!) + UInt32 bound[kShaderTypeCount] = {0}; + for (size_t i = 0; i < n; ++i) + { + ConstBuffer& cb = m_Buffers[i]; + for (int pt = kShaderVertex; pt < kShaderTypeCount; ++pt) + { + int bind = cb.bindIndex[pt]; + if (bind >= 0 && bind < 32) + { + Assert (!(bound[pt] & (1<<bind))); + bound[pt] |= (1<<bind); + } + } + } + #endif + + + for (size_t i = 0; i < n; ++i) + { + ConstBuffer& cb = m_Buffers[i]; + if (!DEBUG_DISABLE_CONSTANT_BUFFER_CACHES && cb.bindStages == 0) + continue; + if (DEBUG_DISABLE_CONSTANT_BUFFER_CACHES || cb.dirty) + { + ctx->UpdateSubresource (cb.buffer, 0, NULL, cb.data, (m_BufferKeys[i]>>16), 1); + #if DEBUG_D3D11_CONSTANT_BUFFER_STATS + ++cb.statsDirty; + #endif + } + + int bindIndex; + + // Bind to used stages + // WP8 seems to be buggy with constant buffers; we need to always rebind them. Hence UNITY_WP8 test below. + #define BIND_CB(cbShaderType,dxCall) \ + bindIndex = cb.bindIndex[cbShaderType]; \ + if (bindIndex >= 0 && (DEBUG_DISABLE_CONSTANT_BUFFER_CACHES || UNITY_WP8 || m_ActiveBuffers[cbShaderType][bindIndex] != cb.buffer)) { \ + ctx->dxCall (bindIndex, 1, &cb.buffer); \ + m_ActiveBuffers[cbShaderType][bindIndex] = cb.buffer; \ + } + + BIND_CB(kShaderVertex,VSSetConstantBuffers); + BIND_CB(kShaderFragment,PSSetConstantBuffers); + BIND_CB(kShaderGeometry,GSSetConstantBuffers); + BIND_CB(kShaderHull,HSSetConstantBuffers); + BIND_CB(kShaderDomain,DSSetConstantBuffers); + cb.dirty = false; + } +} + + +#if DEBUG_D3D11_CONSTANT_BUFFER_STATS + +static void WriteTGAFile (const char* filename, int width, int height, const UInt8* bgr) +{ + FILE* f = fopen(filename, "wb"); + // header + putc(0,f); + putc(0,f); + putc(2,f); // uncompressed RGB + putc(0,f); putc(0,f); + putc(0,f); putc(0,f); + putc(0,f); + putc(0,f); putc(0,f); + putc(0,f); putc(0,f); + putc((width & 0x00FF),f); + putc((width & 0xFF00)>>8,f); + putc((height & 0x00FF),f); + putc((height & 0xFF00)>>8,f); + putc(24,f); // 24 bit + putc(0x20,f); // vertical flip + // data + fwrite (bgr, 3, width*height, f); + fclose (f); +} + +static void DensityToBGR (int density, UInt8* bgr) +{ + if (density < 1) + { + bgr[0] = bgr[1] = bgr[2] = 0; + return; + } + bgr[0] = clamp(40+density/4, 0, 255); + bgr[1] = clamp(40+density/4, 0, 255); + bgr[2] = clamp(40+density/4, 0, 255); +} + +static void PutBGRPixelBlock (UInt8* img, int imgWidth, int x, int y, const UInt8* bgr) +{ + for (int i = 0; i < 4; ++i) + { + UInt8* ptr = img + ((y+i)*imgWidth+x) * 3; + for (int j = 0; j < 4; ++j, ptr += 3) + { + ptr[0] = bgr[0]; + ptr[1] = bgr[1]; + ptr[2] = bgr[2]; + } + } +} + + +void ConstantBuffersD3D11::NewFrame() +{ + if (GetAsyncKeyState(VK_F7)) + { + printf_console ("DX11 Constant Buffer stats:\n"); + float traffic = 0.0f; + int uploads = 0; + int maxSize = 0; + for (size_t i = 0; i < m_BufferKeys.size(); ++i) + maxSize = std::max(int(m_BufferKeys[i]>>16), maxSize); + + int imgWidth = maxSize+1; + int imgHeight = m_Buffers.size()*3*4; + UInt8* imgData = new UInt8[imgWidth*imgHeight*3]; + memset (imgData, 0, imgWidth*imgHeight*3); + + for (size_t i = 0; i < m_Buffers.size(); ++i) + { + ConstBuffer& cb = m_Buffers[i]; + int cbId = (m_BufferKeys[i]&0xFFFF); + int cbSize = (m_BufferKeys[i]>>16); + ShaderLab::FastPropertyName name; + name.index = cbId; + traffic += (cbSize*cb.statsDirty)/1024.0f; + uploads += cb.statsDirty; + printf_console (" %s size:%i (%.1fkB in %i upl) vs:%i ps:%i\n", name.GetName(), cbSize, (cbSize*cb.statsDirty)/1024.0f, cb.statsDirty, cb.statsVS, cb.statsPS); + if (cb.statsDirty > 0) + { + for (int j = 0; j < cbSize/4; ++j) + { + UInt8 bgr[3]; + DensityToBGR (cb.tryCounts[j], bgr); + PutBGRPixelBlock (imgData, imgWidth, j*4, i*3*4, bgr); + DensityToBGR (cb.changeCounts[j], bgr); + PutBGRPixelBlock (imgData, imgWidth, j*4, i*3*4+4, bgr); + } + } + for (int j = 0; j < 8; ++j) + { + imgData[((i*3*4+j)*imgWidth + cbSize)*3 + 1] = 255; + } + } + WriteTGAFile ("cbStats.tga", imgWidth, imgHeight, imgData); + delete[] imgData; + printf_console (" =%i uploads, %.1fkB traffic\n\n", uploads, traffic); + } + + // reset stats + for (size_t i = 0; i < m_Buffers.size(); ++i) + { + ConstBuffer& cb = m_Buffers[i]; + int cbSize = (m_BufferKeys[i]>>16); + cb.statsDirty = cb.statsVS = cb.statsPS = 0; + memset (cb.changeCounts, 0, cbSize/4*4); + memset (cb.tryCounts, 0, cbSize/4*4); + } +} +#endif diff --git a/Runtime/GfxDevice/d3d11/ConstantBuffersD3D11.h b/Runtime/GfxDevice/d3d11/ConstantBuffersD3D11.h new file mode 100644 index 0000000..7c2a3eb --- /dev/null +++ b/Runtime/GfxDevice/d3d11/ConstantBuffersD3D11.h @@ -0,0 +1,74 @@ +#pragma once + +#include "D3D11Includes.h" +#include "Runtime/GfxDevice/GfxDeviceTypes.h" + + +#define DEBUG_D3D11_CONSTANT_BUFFER_STATS 0 + +#if DEBUG_D3D11_CONSTANT_BUFFER_STATS +#include <map> +#endif + + +class ConstantBuffersD3D11 +{ +public: + ConstantBuffersD3D11(); + ~ConstantBuffersD3D11() { Clear(); } + + void Clear(); + void InvalidateState(); + + struct ConstBuffer { + int bindIndex[kShaderTypeCount]; + unsigned bindStages; + bool dirty; + UInt8* data; + ID3D11Buffer* buffer; + #if DEBUG_D3D11_CONSTANT_BUFFER_STATS + int statsDirty; + int stats[kShaderTypeCount] + int* tryCounts; + int* changeCounts; + #endif + }; + + void SetCBInfo (int id, int size); + int FindAndBindCB (int id, ShaderType shaderType, int bind, int size); + void ResetBinds (ShaderType shaderType); + + void SetBuiltinCBConstant (int id, int offset, const void* data, int size); + void SetCBConstant (int index, int offset, const void* data, int size); + + void UpdateBuffers(); + void NewFrame(); + +private: + inline int GetCBIndexByID (int id) const + { + UInt32 key = id; + int n = m_BufferKeys.size(); + for (int i = 0; i < n; ++i) + { + if ((m_BufferKeys[i]&0xFFFF) == key) + return i; + } + Assert (false); + return -1; + } + +private: + typedef std::vector<UInt32> ConstBufferKeys; + typedef std::vector<ConstBuffer> ConstBuffers; + ConstBufferKeys m_BufferKeys; + ConstBuffers m_Buffers; + + ID3D11Buffer* m_ActiveBuffers[kShaderTypeCount][16]; +}; + + +#if !DEBUG_D3D11_CONSTANT_BUFFER_STATS +inline void ConstantBuffersD3D11::NewFrame() { } +#endif + diff --git a/Runtime/GfxDevice/d3d11/D3D11ByteCode.cpp b/Runtime/GfxDevice/d3d11/D3D11ByteCode.cpp new file mode 100644 index 0000000..8ec6c6a --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11ByteCode.cpp @@ -0,0 +1,2237 @@ +#include "UnityPrefix.h" +#include "D3D11ByteCode.h" +#include "D3D11Includes.h" +#include "Runtime/Utilities/BitUtility.h" +#include "External/DirectX/builds/dx9include/d3d9.h" + +// Some things in this file are based on Mesa3d DX11 state tracker: + +/************************************************************************** + * + * Copyright 2010 Luca Barbieri + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + **************************************************************************/ + + + + +enum SM4SystemValue +{ + kSM4SV_UNDEFINED, + kSM4SV_POSITION, + kSM4SV_CLIP_DISTANCE, + kSM4SV_CULL_DISTANCE, + kSM4SV_RENDER_TARGET_ARRAY_INDEX, + kSM4SV_VIEWPORT_ARRAY_INDEX, + kSM4SV_VERTEX_ID, + kSM4SV_PRIMITIVE_ID, + kSM4SV_INSTANCE_ID, + kSM4SV_IS_FRONT_FACE, + kSM4SV_SAMPLE_INDEX, + kSM4SV_FINAL_QUAD_U_EQ_0_EDGE_TESSFACTOR, + kSM4SV_FINAL_QUAD_V_EQ_0_EDGE_TESSFACTOR, + kSM4SV_FINAL_QUAD_U_EQ_1_EDGE_TESSFACTOR, + kSM4SV_FINAL_QUAD_V_EQ_1_EDGE_TESSFACTOR, + kSM4SV_FINAL_QUAD_U_INSIDE_TESSFACTOR, + kSM4SV_FINAL_QUAD_V_INSIDE_TESSFACTOR, + kSM4SV_FINAL_TRI_U_EQ_0_EDGE_TESSFACTOR, + kSM4SV_FINAL_TRI_V_EQ_0_EDGE_TESSFACTOR, + kSM4SV_FINAL_TRI_W_EQ_0_EDGE_TESSFACTOR, + kSM4SV_FINAL_TRI_INSIDE_TESSFACTOR, + kSM4SV_FINAL_LINE_DETAIL_TESSFACTOR, + kSM4SV_FINAL_LINE_DENSITY_TESSFACTOR, + kSM4SV_COUNT +}; + +enum SM4InstrExtype +{ + SM4_TOKEN_INSTRUCTION_EXTENDED_TYPE_EMPTY, + SM4_TOKEN_INSTRUCTION_EXTENDED_TYPE_SAMPLE_CONTROLS, + SM4_TOKEN_INSTRUCTION_EXTENDED_TYPE_RESOURCE_DIM, + SM4_TOKEN_INSTRUCTION_EXTENDED_TYPE_RESOURCE_RETURN_TYPE, + SM4_TOKEN_INSTRUCTION_EXTENDED_TYPE_COUNT +}; + +enum SM4OperExtype +{ + SM4_TOKEN_OPERAND_EXTENDED_TYPE_EMPTY, + SM4_TOKEN_OPERAND_EXTENDED_TYPE_MODIFIER, + SM4_TOKEN_OPERAND_EXTENDED_TYPE_COUNT +}; + +enum SM4ReturnType +{ + kSM4RetType_UNORM = 1, + kSM4RetType_SNORM = 2, + kSM4RetType_SINT = 3, + kSM4RetType_UINT = 4, + kSM4RetType_FLOAT = 5, + kSM4RetType_MIXED = 6, +}; + + +const char* kSM4OpcodeNames[kSM4Op_COUNT] = { + "add", + "and", + "break", + "breakc", + "call", + "callc", + "case", + "continue", + "continuec", + "cut", + "default", + "deriv_rtx", + "deriv_rty", + "discard", + "div", + "dp2", + "dp3", + "dp4", + "else", + "emit", + "emitthencut", + "endif", + "endloop", + "endswitch", + "eq", + "exp", + "frc", + "ftoi", + "ftou", + "ge", + "iadd", + "if", + "ieq", + "ige", + "ilt", + "imad", + "imax", + "imin", + "imul", + "ine", + "ineg", + "ishl", + "ishr", + "itof", + "label", + "ld", + "ldms", + "log", + "loop", + "lt", + "mad", + "min", + "max", + "customdata", + "mov", + "movc", + "mul", + "ne", + "nop", + "not", + "or", + "resinfo", + "ret", + "retc", + "round_ne", + "round_ni", + "round_pi", + "round_z", + "rsq", + "sample", + "sample_c", + "sample_c_lz", + "sample_l", + "sample_d", + "sample_b", + "sqrt", + "switch", + "sincos", + "udiv", + "ult", + "uge", + "umul", + "umad", + "umax", + "umin", + "ushr", + "utof", + "xor", + "dcl_resource", + "dcl_constant_buffer", + "dcl_sampler", + "dcl_index_range", + "dcl_gs_output_primitive_topology", + "dcl_gs_input_primitive", + "dcl_max_output_vertex_count", + "dcl_input", + "dcl_input_sgv", + "dcl_input_siv", + "dcl_input_ps", + "dcl_input_ps_sgv", + "dcl_input_ps_siv", + "dcl_output", + "dcl_output_sgv", + "dcl_output_siv", + "dcl_temps", + "dcl_indexable_temp", + "dcl_global_flags", + "d3d10_count", + "lod", + "gather4", + "sample_pos", + "sample_info", + "d3d10_1_count", + "hs_decls", + "hs_control_point_phase", + "hs_fork_phase", + "hs_join_phase", + "emit_stream", + "cut_stream", + "emitthencut_stream", + "interface_call", + "bufinfo", + "deriv_rtx_coarse", + "deriv_rtx_fine", + "deriv_rty_coarse", + "deriv_rty_fine", + "gather4_c", + "gather4_po", + "gather4_po_c", + "rcp", + "f32tof16", + "f16tof32", + "uaddc", + "usubb", + "countbits", + "firstbit_hi", + "firstbit_lo", + "firstbit_shi", + "ubfe", + "ibfe", + "bfi", + "bfrev", + "swapc", + "dcl_stream", + "dcl_function_body", + "dcl_function_table", + "dcl_interface", + "dcl_input_control_point_count", + "dcl_output_control_point_count", + "dcl_tess_domain", + "dcl_tess_partitioning", + "dcl_tess_output_primitive", + "dcl_hs_max_tessfactor", + "dcl_hs_fork_phase_instance_count", + "dcl_hs_join_phase_instance_count", + "dcl_thread_group", + "dcl_unordered_access_view_typed", + "dcl_unordered_access_view_raw", + "dcl_unordered_access_view_structured", + "dcl_thread_group_shared_memory_raw", + "dcl_thread_group_shared_memory_structured", + "dcl_resource_raw", + "dcl_resource_structured", + "ld_uav_typed", + "store_uav_typed", + "ld_raw", + "store_raw", + "ld_structured", + "store_structured", + "atomic_and", + "atomic_or", + "atomic_xor", + "atomic_cmp_store", + "atomic_iadd", + "atomic_imax", + "atomic_imin", + "atomic_umax", + "atomic_umin", + "imm_atomic_alloc", + "imm_atomic_consume", + "imm_atomic_iadd", + "imm_atomic_and", + "imm_atomic_or", + "imm_atomic_xor", + "imm_atomic_exch", + "imm_atomic_cmp_exch", + "imm_atomic_imax", + "imm_atomic_imin", + "imm_atomic_umax", + "imm_atomic_umin", + "sync", + "dadd", + "dmax", + "dmin", + "dmul", + "deq", + "dge", + "dlt", + "dne", + "dmov", + "dmovc", + "dtof", + "ftod", + "eval_snapped", + "eval_sample_index", + "eval_centroid", + "dcl_gs_instance_count", +}; + +struct SM4TokVersion +{ + unsigned minor : 4; + unsigned major : 4; + unsigned format : 8; + unsigned type : 16; +}; + + + +struct SM4TokResourceReturnType +{ + unsigned x : 4; + unsigned y : 4; + unsigned z : 4; + unsigned w : 4; +}; + + +#define SM4_OPERAND_SEL_MASK(sel) ((sel) & 0xf) +#define SM4_OPERAND_SEL_SWZ(sel, i) (((sel) >> ((i) * 2)) & 3) +#define SM4_OPERAND_SEL_SCALAR(sel) ((sel) & 3) + +struct SM4TokOperandEx +{ + union { + UInt32 dword; + struct { + unsigned type : 6; + unsigned neg : 1; + unsigned abs : 1; + }; + }; +}; + +struct SM4TokResourceRetType +{ + union { + UInt32 dword; + struct { + unsigned x : 4; + unsigned y : 4; + unsigned z : 4; + unsigned w : 4; + unsigned reserved : 16; + }; + }; +}; + + +union SM4Any +{ + float f32; + SInt64 i64; + SInt32 i32; +}; + +struct SM4Op; +struct SM4Instr; +struct SM4Decl; +struct SM4Program; + + +struct SM4Op +{ + UInt8 mode; + UInt8 comps; + UInt8 mask; + UInt8 num_indices; + UInt8 swizzle[4]; + SM4RegFile file; + SM4Any imm_values[4]; + bool neg; + bool abs; + struct + { + SInt64 disp; + std::auto_ptr<SM4Op> reg; + } indices[3]; + + bool is_index_simple(unsigned i) const + { + return !indices[i].reg.get() && indices[i].disp >= 0 && (SInt64)(SInt32)indices[i].disp == indices[i].disp; + } + + bool has_simple_index() const + { + return num_indices == 1 && is_index_simple(0); + } + + SM4Op() + { + memset(this, 0, sizeof(*this)); + } + +private: + SM4Op(const SM4Op& op) + {} +}; + +/* for sample_d */ +#define SM4_MAX_OPS 6 + +struct SM4Instr : public SM4TokInstruction +{ + SInt8 sample_offset[3]; + UInt8 resource_target; + UInt8 resource_return_type[4]; + + unsigned num; + unsigned num_ops; + std::auto_ptr<SM4Op> ops[SM4_MAX_OPS]; + + SM4Instr() + { + memset(this, 0, sizeof(*this)); + } + +private: + SM4Instr(const SM4Instr& op) + {} +}; + +struct SM4Decl : public SM4TokInstruction +{ + std::auto_ptr<SM4Op> op; + union + { + unsigned num; + float f32; + SM4SystemValue sv; + struct + { + unsigned id; + unsigned expected_function_table_length; + unsigned table_length; + unsigned array_length; + } intf; + unsigned thread_group_size[3]; + SM4TokResourceReturnType rrt; + struct + { + unsigned num; + unsigned comps; + } indexable_temp; + struct + { + unsigned stride; + unsigned count; + } structured; + }; + + void* data; + + SM4Decl() + { + memset(this, 0, sizeof(*this)); + } + + ~SM4Decl() + { + free(data); + } + +private: + SM4Decl(const SM4Decl& op) + {} +}; + +struct _D3D11_SIGNATURE_PARAMETER_DESC; + +struct SM4Program +{ + SM4TokVersion version; + dynamic_array<SM4Decl*> dcls; + dynamic_array<SM4Instr*> insns; + + SM4Program() + { + memset(&version, 0, sizeof(version)); + } + + ~SM4Program() + { + for(dynamic_array<SM4Decl*>::iterator i = dcls.begin(), e = dcls.end(); i != e; ++i) + delete *i; + for(dynamic_array<SM4Instr*>::iterator i = insns.begin(), e = insns.end(); i != e; ++i) + delete *i; + } + +private: + SM4Program(const SM4Decl& op) + {} +}; + +SM4Program* sm4_parse(const void* tokens, int size); + + + + +struct DXBCHeader +{ + UInt32 fourcc; + UInt32 hash[4]; + UInt32 one; + UInt32 total_size; + UInt32 chunk_count; +}; + + +static inline DXBCChunkHeader* dxbc_find_shader_bytecode(const void* data, int size) +{ + DXBCChunkHeader* chunk; + chunk = dxbc_find_chunk(data, size, kFOURCC_SHDR); + if(!chunk) + chunk = dxbc_find_chunk(data, size, kFOURCC_SHEX); + return chunk; +} + +#define DXBC_FIND_INPUT_SIGNATURE 0 +#define DXBC_FIND_OUTPUT_SIGNATURE 1 +#define DXBC_FIND_PATCH_SIGNATURE 2 + +static inline DXBCChunkSig* dxbc_find_signature(const void* data, int size, unsigned kind) +{ + unsigned fourcc; + switch(kind) { + case DXBC_FIND_INPUT_SIGNATURE: fourcc = kFOURCC_ISGN; break; + case DXBC_FIND_OUTPUT_SIGNATURE: fourcc = kFOURCC_OSGN; break; + case DXBC_FIND_PATCH_SIGNATURE: fourcc = kFOURCC_PCSG; break; + default: + return NULL; + } + return (DXBCChunkSig*)dxbc_find_chunk(data, size, fourcc); +} + +std::pair<void*, size_t> dxbc_assemble(struct DXBCChunkHeader** chunks, unsigned num_chunks); + + +DXBCContainer* dxbc_parse(const void* data, int size) +{ + std::auto_ptr<DXBCContainer> container(new DXBCContainer()); + container->data = data; + DXBCHeader* header = (DXBCHeader*)data; + UInt32* chunk_offsets = (UInt32*)(header + 1); + if(header->fourcc != kFOURCC_DXBC) + return 0; + unsigned num_chunks = header->chunk_count; + for(unsigned i = 0; i < num_chunks; ++i) + { + unsigned offset = chunk_offsets[i]; + DXBCChunkHeader* chunk = (DXBCChunkHeader*)((char*)data + offset); + unsigned fourcc = chunk->fourcc; + container->chunks.push_back(chunk); + } + return container.release(); +} + +DXBCChunkHeader* dxbc_find_chunk(const void* data, int size, unsigned fourcc) +{ + DXBCHeader* header = (DXBCHeader*)data; + UInt32* chunk_offsets = (UInt32*)(header + 1); + if(header->fourcc != kFOURCC_DXBC) + return 0; + unsigned num_chunks = header->chunk_count; + for(unsigned i = 0; i < num_chunks; ++i) + { + unsigned offset = chunk_offsets[i]; + DXBCChunkHeader* chunk = (DXBCChunkHeader*)((char*)data + offset); + if(chunk->fourcc == fourcc) + return chunk; + } + return 0; +} + +static void print_binary_chunk (const DXBCChunkHeader& chk, int perLine = 16) +{ + const char* kHex = "0123456789abcdef"; + const UInt8* ptr = ((const UInt8*)&chk) + sizeof(DXBCChunkHeader); + std::string res; + for (unsigned i = 0; i < chk.size; ++i) + { + if (i != 0 && i%perLine == 0) + res += '\n'; + if ((i & 3) == 0) + res += ' '; + UInt8 b = ptr[i]; + res += kHex[b>>4]; + res += kHex[b&0xF]; + } + printf_console ("%s\n", res.c_str()); +} + +static void print_sm4_program (const SM4Program& prog) +{ +} + +void dxbc_print(const DXBCContainer* dxbc) +{ + printf_console ("DXBC dump:\n"); + if (!dxbc) + { + printf_console ("null\n"); + return; + } + + printf_console ("chunk count: %d\n", (int)dxbc->chunks.size()); + for (size_t i = 0; i < dxbc->chunks.size(); ++i) + { + const DXBCChunkHeader& chk = *dxbc->chunks[i]; + printf_console ("chunk #%i: %c%c%c%c size %u\n", (int)i, chk.fourcc&0xFF, (chk.fourcc>>8)&0xFF, (chk.fourcc>>16)&0xFF, (chk.fourcc>>24)&0xFF, chk.size); + if (chk.fourcc == kFOURCC_ISGN || chk.fourcc == kFOURCC_OSGN) + { + print_binary_chunk (chk); + const DXBCChunkSig* sig = (const DXBCChunkSig*)&chk; + D3D11_SIGNATURE_PARAMETER_DESC* params; + int count = dxbc_parse_signature (sig, ¶ms); + for (int j = 0; j < count; ++j) + { + const D3D11_SIGNATURE_PARAMETER_DESC& p = params[j]; + printf_console (" #%i: %s/%u reg %u sv %u type %u mask %x rwmask %x stream %u\n", + j, p.SemanticName, p.SemanticIndex, p.Register, p.SystemValueType, p.ComponentType, p.Mask, p.ReadWriteMask, p.Stream); + } + free (params); + } + else if (chk.fourcc == kFOURCC_SHDR || chk.fourcc == kFOURCC_SHEX) + { + printf_console ("shader code:\n"); + print_binary_chunk (chk); + SM4Program* prog = sm4_parse((&chk)+1, chk.size); + if (prog) + { + print_sm4_program(*prog); + delete prog; + } + } + } +} + + +int dxbc_parse_signature(const DXBCChunkSig* sig, D3D11_SIGNATURE_PARAMETER_DESC** params) +{ + unsigned count = sig->count; + *params = (D3D11_SIGNATURE_PARAMETER_DESC*)malloc(sizeof(D3D11_SIGNATURE_PARAMETER_DESC) * count); + + for (unsigned i = 0; i < count; ++i) + { + D3D11_SIGNATURE_PARAMETER_DESC& param = (*params)[i]; + param.SemanticName = (char*)&sig->count + sig->elements[i].name_offset; + param.SemanticIndex = sig->elements[i].semantic_index; + param.SystemValueType = (D3D_NAME)sig->elements[i].system_value_type; + param.ComponentType = (D3D_REGISTER_COMPONENT_TYPE)sig->elements[i].component_type; + param.Register = sig->elements[i].register_num; + param.Mask = sig->elements[i].mask; + param.ReadWriteMask = sig->elements[i].read_write_mask; + param.Stream = sig->elements[i].stream; + } + return count; +} + +// sm4_parse.cpp + +struct SM4Parser +{ + const unsigned* tokens; + const unsigned* tokens_end; + SM4Program& program; + + SM4Parser(SM4Program& program, const void* p_tokens, unsigned size) + : program(program) + { + tokens = (const unsigned*)p_tokens; + tokens_end = (const unsigned*)((const char*)p_tokens + size); + } + + UInt32 read32() + { + Assert(tokens < tokens_end); + return *tokens++; + } + + template<typename T> + void read_token(T* tok) + { + *(unsigned*)tok = read32(); + } + + UInt64 read64() + { + unsigned a = read32(); + unsigned b = read32(); + return (UInt64)a | ((UInt64)b << 32); + } + + void skip(unsigned toskip) + { + tokens += toskip; + } + + bool read_op(SM4Op* pop) + { + SM4Op& op = *pop; + SM4TokOperand optok; + read_token(&optok); + if (optok.file >= kSM4File_COUNT) + { + AssertString ("DXBC: unknown register type"); + return false; + } + op.swizzle[0] = 0; + op.swizzle[1] = 1; + op.swizzle[2] = 2; + op.swizzle[3] = 3; + op.mask = 0xf; + switch(optok.comps_enum) + { + case kSM4OperComp0: + op.comps = 0; + break; + case kSM4OperComp1: + op.comps = 1; + op.swizzle[1] = op.swizzle[2] = op.swizzle[3] = 0; + break; + case kSM4OperComp4: + op.comps = 4; + op.mode = optok.mode; + switch(optok.mode) + { + case SM4_OPERAND_MODE_MASK: + op.mask = SM4_OPERAND_SEL_MASK(optok.sel); + break; + case SM4_OPERAND_MODE_SWIZZLE: + op.swizzle[0] = SM4_OPERAND_SEL_SWZ(optok.sel, 0); + op.swizzle[1] = SM4_OPERAND_SEL_SWZ(optok.sel, 1); + op.swizzle[2] = SM4_OPERAND_SEL_SWZ(optok.sel, 2); + op.swizzle[3] = SM4_OPERAND_SEL_SWZ(optok.sel, 3); + break; + case SM4_OPERAND_MODE_SCALAR: + op.swizzle[0] = op.swizzle[1] = op.swizzle[2] = op.swizzle[3] = SM4_OPERAND_SEL_SCALAR(optok.sel); + break; + } + break; + case kSM4OperCompN: + AssertString("Unhandled operand component type"); + return false; + break; + } + op.file = (SM4RegFile)optok.file; + op.num_indices = optok.num_indices; + + if(optok.extended) + { + SM4TokOperandEx optokext; + read_token(&optokext); + if(optokext.type == 0) + {} + else if(optokext.type == 1) + { + op.neg = optokext.neg; + op.abs= optokext.abs; + } + else + { + AssertString("Unhandled extended operand token type"); + return false; + } + } + + for(unsigned i = 0; i < op.num_indices; ++i) + { + unsigned repr; + if(i == 0) + repr = optok.index0_repr; + else if(i == 1) + repr = optok.index1_repr; + else if(i == 2) + repr = optok.index2_repr; + else + { + AssertString("Unhandled operand index representation"); + return false; + } + op.indices[i].disp = 0; + // TODO: is disp supposed to be signed here?? + switch(repr) + { + case SM4_OPERAND_INDEX_REPR_IMM32: + op.indices[i].disp = (SInt32)read32(); + break; + case SM4_OPERAND_INDEX_REPR_IMM64: + op.indices[i].disp = read64(); + break; + case SM4_OPERAND_INDEX_REPR_REG: +relative: + op.indices[i].reg.reset(new SM4Op()); + if (!read_op(&*op.indices[i].reg)) + return false; + break; + case SM4_OPERAND_INDEX_REPR_REG_IMM32: + op.indices[i].disp = (SInt32)read32(); + goto relative; + case SM4_OPERAND_INDEX_REPR_REG_IMM64: + op.indices[i].disp = read64(); + goto relative; + } + } + + if(op.file == kSM4File_IMMEDIATE32) + { + for(unsigned i = 0; i < op.comps; ++i) + op.imm_values[i].i32 = read32(); + } + else if(op.file == kSM4File_IMMEDIATE64) + { + for(unsigned i = 0; i < op.comps; ++i) + op.imm_values[i].i64 = read64(); + } + return true; + } + + bool parse() + { + read_token(&program.version); + + unsigned lentok = read32(); + tokens_end = tokens - 2 + lentok; + + while(tokens != tokens_end) + { + SM4TokInstruction insntok; + read_token(&insntok); + const unsigned* insn_end = tokens - 1 + insntok.length; + SM4Opcode opcode = (SM4Opcode)insntok.opcode; + if (opcode >= kSM4Op_COUNT) + { + AssertString ("Unknown DXBC opcode"); + return false; + } + + if(opcode == kSM4Op_CUSTOMDATA) + { + // immediate constant buffer data + unsigned customlen = read32() - 2; + + SM4Decl& dcl = *new SM4Decl; + program.dcls.push_back(&dcl); + + dcl.opcode = kSM4Op_CUSTOMDATA; + dcl.num = customlen; + dcl.data = malloc(customlen * sizeof(tokens[0])); + + memcpy(dcl.data, &tokens[0], customlen * sizeof(tokens[0])); + + skip(customlen); + continue; + } + + if(opcode == kSM4Op_HS_FORK_PHASE || opcode == kSM4Op_HS_JOIN_PHASE) + { + // need to interleave these with the declarations or we cannot + // assign fork/join phase instance counts to phases + SM4Decl& dcl = *new SM4Decl; + program.dcls.push_back(&dcl); + dcl.opcode = opcode; + } + + if((opcode >= kSM4Op_DCL_RESOURCE && opcode <= kSM4Op_DCL_GLOBAL_FLAGS) + || (opcode >= kSM4Op_DCL_STREAM && opcode <= kSM4Op_DCL_RESOURCE_STRUCTURED)) + { + SM4Decl& dcl = *new SM4Decl; + program.dcls.push_back(&dcl); + (SM4TokInstruction&)dcl = insntok; + + SM4TokInstructionEx exttok; + memcpy(&exttok, &insntok, sizeof(exttok)); + while(exttok.extended) + { + read_token(&exttok); + } + +#define READ_OP_ANY dcl.op.reset(new SM4Op()); if (!read_op(&*dcl.op)) return false; +#define READ_OP(FILE) READ_OP_ANY + //Assert(dcl.op->file == kSM4File_##FILE); + + switch(opcode) + { + case kSM4Op_DCL_GLOBAL_FLAGS: + break; + case kSM4Op_DCL_RESOURCE: + READ_OP(RESOURCE); + read_token(&dcl.rrt); + break; + case kSM4Op_DCL_SAMPLER: + READ_OP(SAMPLER); + break; + case kSM4Op_DCL_INPUT: + case kSM4Op_DCL_INPUT_PS: + READ_OP(INPUT); + break; + case kSM4Op_DCL_INPUT_SIV: + case kSM4Op_DCL_INPUT_SGV: + case kSM4Op_DCL_INPUT_PS_SIV: + case kSM4Op_DCL_INPUT_PS_SGV: + READ_OP(INPUT); + dcl.sv = (SM4SystemValue)(UInt16)read32(); + break; + case kSM4Op_DCL_OUTPUT: + READ_OP(OUTPUT); + break; + case kSM4Op_DCL_OUTPUT_SIV: + case kSM4Op_DCL_OUTPUT_SGV: + READ_OP(OUTPUT); + dcl.sv = (SM4SystemValue)(UInt16)read32(); + break; + case kSM4Op_DCL_INDEX_RANGE: + READ_OP_ANY; + Assert(dcl.op->file == kSM4File_INPUT || dcl.op->file == kSM4File_OUTPUT); + dcl.num = read32(); + break; + case kSM4Op_DCL_TEMPS: + dcl.num = read32(); + break; + case kSM4Op_DCL_INDEXABLE_TEMP: + READ_OP(INDEXABLE_TEMP); + dcl.indexable_temp.num = read32(); + dcl.indexable_temp.comps = read32(); + break; + case kSM4Op_DCL_CONSTANT_BUFFER: + READ_OP(CONSTANT_BUFFER); + break; + case kSM4Op_DCL_GS_INPUT_PRIMITIVE: + case kSM4Op_DCL_GS_OUTPUT_PRIMITIVE_TOPOLOGY: + break; + case kSM4Op_DCL_MAX_OUTPUT_VERTEX_COUNT: + dcl.num = read32(); + break; + case kSM4Op_DCL_GS_INSTANCE_COUNT: + dcl.num = read32(); + break; + case kSM4Op_DCL_INPUT_CONTROL_POINT_COUNT: + case kSM4Op_DCL_OUTPUT_CONTROL_POINT_COUNT: + case kSM4Op_DCL_TESS_DOMAIN: + case kSM4Op_DCL_TESS_PARTITIONING: + case kSM4Op_DCL_TESS_OUTPUT_PRIMITIVE: + break; + case kSM4Op_DCL_HS_MAX_TESSFACTOR: + dcl.f32 = read32(); + break; + case kSM4Op_DCL_HS_FORK_PHASE_INSTANCE_COUNT: + dcl.num = read32(); + break; + case kSM4Op_DCL_FUNCTION_BODY: + dcl.num = read32(); + break; + case kSM4Op_DCL_FUNCTION_TABLE: + dcl.num = read32(); + dcl.data = malloc(dcl.num * sizeof(UInt32)); + for(unsigned i = 0; i < dcl.num; ++i) + ((UInt32*)dcl.data)[i] = read32(); + break; + case kSM4Op_DCL_INTERFACE: + dcl.intf.id = read32(); + dcl.intf.expected_function_table_length = read32(); + { + UInt32 v = read32(); + dcl.intf.table_length = v & 0xffff; + dcl.intf.array_length = v >> 16; + } + dcl.data = malloc(dcl.intf.table_length * sizeof(UInt32)); + for(unsigned i = 0; i < dcl.intf.table_length; ++i) + ((UInt32*)dcl.data)[i] = read32(); + break; + case kSM4Op_DCL_THREAD_GROUP: + dcl.thread_group_size[0] = read32(); + dcl.thread_group_size[1] = read32(); + dcl.thread_group_size[2] = read32(); + break; + case kSM4Op_DCL_UNORDERED_ACCESS_VIEW_TYPED: + READ_OP(UNORDERED_ACCESS_VIEW); + read_token(&dcl.rrt); + break; + case kSM4Op_DCL_UNORDERED_ACCESS_VIEW_RAW: + READ_OP(UNORDERED_ACCESS_VIEW); + break; + case kSM4Op_DCL_UNORDERED_ACCESS_VIEW_STRUCTURED: + READ_OP(UNORDERED_ACCESS_VIEW); + dcl.structured.stride = read32(); + break; + case kSM4Op_DCL_THREAD_GROUP_SHARED_MEMORY_RAW: + READ_OP(THREAD_GROUP_SHARED_MEMORY); + dcl.num = read32(); + break; + case kSM4Op_DCL_THREAD_GROUP_SHARED_MEMORY_STRUCTURED: + READ_OP(THREAD_GROUP_SHARED_MEMORY); + dcl.structured.stride = read32(); + dcl.structured.count = read32(); + break; + case kSM4Op_DCL_RESOURCE_RAW: + READ_OP(RESOURCE); + break; + case kSM4Op_DCL_RESOURCE_STRUCTURED: + READ_OP(RESOURCE); + dcl.structured.stride = read32(); + break; + case kSM4Op_DCL_STREAM: + // TODO: dcl_stream is undocumented: what is it? + AssertString("DXBC: Unhandled dcl_stream since it's undocumented"); + return false; + break; + default: + AssertString("DXBC: Unhandled declaration type"); + return false; + } + + if (tokens != insn_end) + { + AssertString("DXBC: token size mismatch"); + return false; + } + } + else + { + SM4Instr& insn = *new SM4Instr; + program.insns.push_back(&insn); + (SM4TokInstruction&)insn = insntok; + + SM4TokInstructionEx exttok; + memcpy(&exttok, &insntok, sizeof(exttok)); + while(exttok.extended) + { + read_token(&exttok); + if(exttok.type == SM4_TOKEN_INSTRUCTION_EXTENDED_TYPE_SAMPLE_CONTROLS) + { + insn.sample_offset[0] = exttok.sample_controls.offset_u; + insn.sample_offset[1] = exttok.sample_controls.offset_v; + insn.sample_offset[2] = exttok.sample_controls.offset_w; + } + else if(exttok.type == SM4_TOKEN_INSTRUCTION_EXTENDED_TYPE_RESOURCE_DIM) + insn.resource_target = exttok.resource_target.target; + else if(exttok.type == SM4_TOKEN_INSTRUCTION_EXTENDED_TYPE_RESOURCE_RETURN_TYPE) + { + insn.resource_return_type[0] = exttok.resource_return_type.x; + insn.resource_return_type[1] = exttok.resource_return_type.y; + insn.resource_return_type[2] = exttok.resource_return_type.z; + insn.resource_return_type[3] = exttok.resource_return_type.w; + } + } + + switch(opcode) + { + case kSM4Op_INTERFACE_CALL: + insn.num = read32(); + break; + default: + break; + } + + unsigned op_num = 0; + while(tokens != insn_end) + { + if (tokens >= insn_end) + { + AssertString ("DXBC: token size mismatch"); + return false; + } + if (op_num >= SM4_MAX_OPS) + { + AssertString ("DXBC: too many operands"); + return false; + } + insn.ops[op_num].reset(new SM4Op); + if (!read_op(&*insn.ops[op_num])) + return false; + ++op_num; + } + insn.num_ops = op_num; + } + } + return true; + } +}; + +SM4Program* sm4_parse(const void* tokens, int size) +{ + SM4Program* program = new SM4Program; + SM4Parser parser(*program, tokens, size); + if(parser.parse()) + return program; + delete program; + return 0; +} + +static void dxbc_create_internal(struct DXBCChunkHeader** chunks, unsigned num_chunks, void* buffer, unsigned total_size) +{ + DXBCHeader* header = (DXBCHeader*)buffer; + + header->fourcc = kFOURCC_DXBC; + memset(header->hash, 0, sizeof(header->hash)); + + header->one = 1; + header->total_size = total_size; + header->chunk_count = num_chunks; + + UInt32* chunk_offsets = (UInt32*)(header + 1); + UInt32 off = sizeof(struct DXBCHeader) + num_chunks * sizeof(UInt32); + for(unsigned i = 0; i < num_chunks; ++i) + { + chunk_offsets[i] = off; + unsigned chunk_full_size = sizeof(DXBCChunkHeader) + chunks[i]->size; + memcpy((char*)header + off, chunks[i], chunk_full_size); + off += chunk_full_size; + } + + void D3DHash (const unsigned char* data, unsigned size, unsigned char res[16]); + D3DHash ((const UInt8*)&header->one, total_size-20, (UInt8*)header->hash); +} + + +static std::pair<void*, size_t> dxbc_create(struct DXBCChunkHeader** chunks, unsigned num_chunks) +{ + size_t data_size = 0; + for(unsigned i = 0; i < num_chunks; ++i) + data_size += sizeof(UInt32) + sizeof(DXBCChunkHeader) + chunks[i]->size; + const size_t total_size = sizeof(DXBCHeader) + data_size; + + void* buffer = malloc(total_size); + if (!buffer) + return std::make_pair((void*)0, 0); + + dxbc_create_internal (chunks, num_chunks, buffer, total_size); + + return std::make_pair(buffer, total_size); +} + + +void dxbc_create(struct DXBCChunkHeader** chunks, unsigned num_chunks, dynamic_array<UInt8>& out) +{ + size_t data_size = 0; + for(unsigned i = 0; i < num_chunks; ++i) + data_size += sizeof(UInt32) + sizeof(DXBCChunkHeader) + chunks[i]->size; + const size_t total_size = sizeof(DXBCHeader) + data_size; + + out.resize_uninitialized (total_size); + + dxbc_create_internal (chunks, num_chunks, out.data(), total_size); +} + + + + +// ------------------------------------------------------------------- + +enum DXBCBuilderChunks { + kBuilderChunkInput = 0, + kBuilderChunkOutput, + kBuilderChunkCode, + kBuilderChunkSM20, + kBuilderChunkCount +}; +struct SigElement { + const char* name; + int index; + int reg; + int mask; +}; + +struct DXBCCodeBuilder +{ + DXBCCodeBuilder(dynamic_array<UInt32>& destArray) + : insns(destArray) + , curInsnIndex(-1) + , tempCount(0) + , opcode(kSM4Op_MOV) + , opcode2(kSM2Op_MOV) + , saturate(0) + { } + dynamic_array<UInt32>& insns; // reference to actual output array! + int curInsnIndex; + int tempCount; + + SM4Opcode opcode; + SM2Opcode opcode2; + + int saturate; + char dstRegType; + int dstRegIndex; + unsigned dstRegMask; + unsigned dstRegComps; + int tmpSatRegIndex; +}; + +struct DXBCBuilder +{ + DXBCBuilder() : codeBuilder(insns) { } + DXBCCodeBuilder codeBuilder; + dynamic_array<SigElement> inputs; + dynamic_array<SigElement> outputs; + dynamic_array<UInt32> insns; + dynamic_array<UInt32> dcls; + //sm20 stuff + dynamic_array<UInt32> inputs2; + dynamic_array<UInt32> defs2; + dynamic_array<UInt32> insns2; + std::map<UInt32,UInt32> outputMap; + std::map<UInt32,UInt32> inputMap; + + int numTextures2; + int curInsnIndex2; + + SM4TokVersion version; + DXBCChunkHeader* chunks[kBuilderChunkCount]; +}; + +DXBCCodeBuilder* dxb_create_code(dynamic_array<UInt32>& destArray) +{ + DXBCCodeBuilder* b = new DXBCCodeBuilder(destArray); + return b; +} + +void dxb_destroy_code(DXBCCodeBuilder* b) +{ + delete b; +} + +const UInt32* dxb_get_code(DXBCCodeBuilder* b, size_t* outSize) +{ + *outSize = b->insns.size(); + return b->insns.data(); +} + + +DXBCBuilder* dxb_create(int major, int minor, SM4ShaderType type) +{ + DXBCBuilder* b = new DXBCBuilder(); + memset (b->chunks, 0, sizeof(b->chunks)); + b->version.major = major; + b->version.minor = minor; + b->version.type = type; + b->version.format = 0; //@TODO? + b->numTextures2 = 0; + + return b; +} +void dxb_destroy(DXBCBuilder* b) +{ + if (b) + { + for (int i = 0; i < kBuilderChunkCount; ++i) + if (b->chunks[i]) + free(b->chunks[i]); + } + delete b; +} + +DXBCCodeBuilder* dxb_get_code_builder(DXBCBuilder* b) +{ + return &b->codeBuilder; +} + + +void dxb_dcl_input (DXBCBuilder* b, const char* name, int index, int reg, int mask) +{ + SigElement el; + el.name = name; + el.index = index; + el.reg = reg; + el.mask = mask; + b->inputs.push_back (el); + + dxb_dcl_input2(b,name,index,reg,mask); +} + +void dxb_dcl_output (DXBCBuilder* b, const char* name, int index, int reg, int mask) +{ + SigElement el; + el.name = name; + el.index = index; + el.reg = reg; + el.mask = mask; + b->outputs.push_back (el); + + dxb_dcl_output2(b,name,index,reg,mask); +} + + +void dxb_dcl_tex (DXBCBuilder* b, int index, SM4Target dim) +{ + SM4TokInstruction dcl; + dcl.dword = 0; + dcl.opcode = kSM4Op_DCL_SAMPLER; + dcl.length = 3; + b->dcls.push_back (dcl.dword); + SM4TokOperand op; + op.dword = 0; + op.file = kSM4File_SAMPLER; + op.num_indices = 1; + b->dcls.push_back (op.dword); + b->dcls.push_back (index); + + dcl.dword = 0; + dcl.opcode = kSM4Op_DCL_RESOURCE; + dcl.length = 4; + dcl.dcl_resource.target = dim; + b->dcls.push_back (dcl.dword); + op.dword = 0; + op.file = kSM4File_RESOURCE; + op.num_indices = 1; + SM4TokResourceRetType ret; + ret.dword = 0; + ret.x = ret.y = ret.z = ret.w = kSM4RetType_FLOAT; + b->dcls.push_back (op.dword); + b->dcls.push_back (index); + b->dcls.push_back (ret.dword); + + dxb_dcl_tex2 (b, index, dim); +} + + +void dxb_dcl_cb (DXBCBuilder* b, int index, int size) +{ + SM4TokInstruction dcl; + dcl.dword = 0; + dcl.opcode = kSM4Op_DCL_CONSTANT_BUFFER; + dcl.length = 4; + dcl.dcl_constant_buffer.dynamic = 0; + b->dcls.push_back (dcl.dword); + SM4TokOperand op; + op.dword = 0; + op.comps_enum = kSM4OperComp4; + op.file = kSM4File_CONSTANT_BUFFER; + op.num_indices = 2; + b->dcls.push_back (op.dword); + b->dcls.push_back (index); + b->dcls.push_back (size); +} + + +static void dxbc_update_insn_length (DXBCCodeBuilder* b, int len) +{ + DebugAssert (b->curInsnIndex >= 0 && b->curInsnIndex < b->insns.size()); + SM4TokInstruction* tok = (SM4TokInstruction*)&b->insns[b->curInsnIndex]; + tok->length += len; +} + +void dxb_op (DXBCCodeBuilder* b, SM4Opcode op, bool sat) +{ + b->opcode = op; + b->curInsnIndex = b->insns.size(); + SM4TokInstruction tok; + tok.dword = 0; + tok.opcode = op; + tok.insn.sat = sat ? 1 : 0; + tok.length = 1; + if (op == kSM4Op_DISCARD) // discard instructions emitted by HLSL have nz flag set + tok.insn.test_nz = 1; + b->insns.push_back (tok.dword); +} + +static inline SM4RegFile dxb_reg_type(char c) +{ + switch (c) + { + case 'r': return kSM4File_TEMP; + case 'v': return kSM4File_INPUT; + case 'o': return kSM4File_OUTPUT; + case 'c': return kSM4File_CONSTANT_BUFFER; + case 's': return kSM4File_SAMPLER; + case 't': return kSM4File_RESOURCE; + default: AssertString("unknown register type"); return kSM4File_TEMP; + } +} + + +void dxb_reg (DXBCCodeBuilder* b, char rchar, int reg, unsigned mask) +{ + b->dstRegMask = mask; + b->dstRegComps = BitsInMask(mask); + + SM4RegFile rtype = dxb_reg_type(rchar); + dxbc_update_insn_length (b, 2); + SM4TokOperand op; + op.dword = 0; + op.comps_enum = rtype==kSM4File_SAMPLER ? kSM4OperComp0 : kSM4OperComp4; + + // discard only has 1 parameter which is similar to a source register argument: + // if it's one channel only, then emit it as a "scalar channel index" + op.mode = (b->dstRegComps==1 && b->opcode==kSM4Op_DISCARD) ? SM4_OPERAND_MODE_SCALAR : SM4_OPERAND_MODE_MASK; + op.sel = (b->dstRegComps==1 && b->opcode==kSM4Op_DISCARD) ? HighestBit(mask) : mask; + if (rtype==kSM4File_SAMPLER) + op.sel = 0; + op.file = rtype; + op.num_indices = 1; + b->insns.push_back (op.dword); + b->insns.push_back (reg); + if (rtype == kSM4File_TEMP) + b->tempCount = std::max (b->tempCount, reg+1); +} + + +static unsigned adjust_swizzle (DXBCCodeBuilder* b, unsigned swizzle, bool sm2) +{ + // For DP3 with "no swizzle", SM2 expects to not have the swizzle, while SM4 expects xyzx + if (b->opcode == kSM4Op_DP3 && swizzle == kSM4SwzNone && !sm2) + swizzle = kSM4SwzXYZX; + + // arguments for single-channel destinations in SM4 should be emitted as "1 channel index" + // instead of "swizzle that replicates all channels" + if (!sm2 && b->dstRegComps==1) + { + if (swizzle == kSM4SwzRepX) + swizzle = 0; + else if (swizzle == kSM4SwzRepY) + swizzle = 1; + else if (swizzle == kSM4SwzRepZ) + swizzle = 2; + else if (swizzle == kSM4SwzRepW) + swizzle = 3; + } + return swizzle; +} + + +void dxb_swz (DXBCCodeBuilder* b, char rchar, int reg, unsigned swizzle, bool neg) +{ + swizzle = adjust_swizzle (b, swizzle, false); + + SM4RegFile rtype = dxb_reg_type(rchar); + int len = 2; + if (neg) ++len; + if (rtype==kSM4File_CONSTANT_BUFFER) ++len; + dxbc_update_insn_length (b, len); + SM4TokOperand op; + op.dword = 0; + op.comps_enum = rtype==kSM4File_SAMPLER ? kSM4OperComp0 : kSM4OperComp4; + op.mode = (b->dstRegComps==1 && swizzle<4) ? SM4_OPERAND_MODE_SCALAR : SM4_OPERAND_MODE_SWIZZLE; + op.sel = swizzle; + op.file = rtype; + op.num_indices = rtype==kSM4File_CONSTANT_BUFFER ? 2 : 1; + op.extended = neg ? 1 : 0; + b->insns.push_back (op.dword); + if (neg) + { + SM4TokOperandEx opex; + opex.dword = 0; + opex.type = 1; + opex.neg = 1; + b->insns.push_back (opex.dword); + } + if (rtype==kSM4File_CONSTANT_BUFFER) + { + b->insns.push_back (reg >> 16); + b->insns.push_back (reg & 0xFFFF); + } + else + { + b->insns.push_back (reg); + } + if (rtype == kSM4File_TEMP) + b->tempCount = std::max (b->tempCount, reg+1); +} + +void dxb_float1 (DXBCCodeBuilder* b, float v) +{ + dxbc_update_insn_length (b, 2); + SM4TokOperand op; + op.dword = 0; + op.comps_enum = kSM4OperComp1; + op.file = kSM4File_IMMEDIATE32; + b->insns.push_back (op.dword); + union { float f; UInt32 i; } f2i; + f2i.f = v; + b->insns.push_back (f2i.i); +} + +void dxb_int1 (DXBCCodeBuilder* b, int i) +{ + dxbc_update_insn_length (b, 2); + SM4TokOperand op; + op.dword = 0; + op.comps_enum = kSM4OperComp1; + op.file = kSM4File_IMMEDIATE32; + b->insns.push_back (op.dword); + b->insns.push_back (i); +} + + +void dxb_float4 (DXBCCodeBuilder* b, float v0, float v1, float v2, float v3) +{ + dxbc_update_insn_length (b, 5); + SM4TokOperand op; + op.dword = 0; + op.comps_enum = kSM4OperComp4; + op.file = kSM4File_IMMEDIATE32; + b->insns.push_back (op.dword); + union { float f; UInt32 i; } f2i; + f2i.f = v0; b->insns.push_back (f2i.i); + f2i.f = v1; b->insns.push_back (f2i.i); + f2i.f = v2; b->insns.push_back (f2i.i); + f2i.f = v3; b->insns.push_back (f2i.i); +} + + + +static void dxbc_builder_build_sig (DXBCBuilder* b, bool input) +{ + int chunkIdx = input ? kBuilderChunkInput : kBuilderChunkOutput; + const dynamic_array<SigElement>& sigs = input ? b->inputs : b->outputs; + const int nsigs = sigs.size(); + + // size = 8 (header) + 8 (sig chunk header) + count * DXBCSignatureElement + names + unsigned size = 16 + nsigs * sizeof(DXBCSignatureElement); + unsigned namesOffset = size; + for (int i = 0; i < nsigs; ++i) + size += strlen(sigs[i].name) + 1; + size = (size + 3) & ~3; // align to next dword + + UInt8* buf = (UInt8*)malloc(size); + DXBCChunkSig* chunk = (DXBCChunkSig*)buf; + memset (chunk, 0xAB, size); + + chunk->fourcc = input ? kFOURCC_ISGN : kFOURCC_OSGN; + chunk->size = size-8; + chunk->count = nsigs; + chunk->unk8 = 8; + for (int i = 0; i < nsigs; ++i) + { + DXBCSignatureElement* s = &chunk->elements[i]; + s->name_offset = namesOffset-8; + int len = strlen(sigs[i].name) + 1; + memcpy (buf + namesOffset, sigs[i].name, len); + namesOffset += len; + const bool outputPos = !strcmp(sigs[i].name,"SV_POSITION"); + unsigned mask = sigs[i].mask; + s->semantic_index = sigs[i].index; + s->system_value_type = outputPos ? 1 : 0; + s->component_type = 3; // float + s->register_num = sigs[i].reg; + s->mask = mask; // mask of channels used + if (input) + s->read_write_mask = mask; + else + s->read_write_mask = ~mask & 0xF; + s->stream = 0; + s->unused = 0; + + + SM4TokInstruction dcl; + dcl.dword = 0; + dcl.opcode = input ? + (b->version.type == kSM4Shader_Pixel ? kSM4Op_DCL_INPUT_PS : kSM4Op_DCL_INPUT) : + (outputPos ? kSM4Op_DCL_OUTPUT_SIV : kSM4Op_DCL_OUTPUT); + dcl.length = outputPos ? 4 : 3; + if (dcl.opcode == kSM4Op_DCL_INPUT_PS) + dcl.dcl_input_ps.interpolation = kSM4Interp_LINEAR; + b->dcls.push_back (dcl.dword); + SM4TokOperand op; + op.dword = 0; + op.comps_enum = kSM4OperComp4; + op.mode = SM4_OPERAND_MODE_MASK; + op.sel = mask; + op.file = input ? kSM4File_INPUT : kSM4File_OUTPUT; + op.num_indices = 1; + op.index0_repr = SM4_OPERAND_INDEX_REPR_IMM32; + b->dcls.push_back (op.dword); + b->dcls.push_back (sigs[i].reg); + if (outputPos) + b->dcls.push_back (s->system_value_type); + } + + b->chunks[chunkIdx] = chunk; +} + + +static void dxbc_builder_build_code (DXBCBuilder* b) +{ + const unsigned n = b->dcls.size() + b->insns.size(); + + // size = 8 (header) + 8 (code chunk header) + tokens + unsigned size = 16 + n*4; + + UInt8* buf = (UInt8*)malloc(size); + DXBCChunkCode* chunk = (DXBCChunkCode*)buf; + + chunk->fourcc = kFOURCC_SHDR; + chunk->size = size-8; + chunk->version = *(UInt32*)&b->version; + chunk->length = n+2; + + UInt8* codePtr = (UInt8*)(chunk+1); + if (!b->dcls.empty()) + { + size_t size = b->dcls.size()*sizeof(b->dcls[0]); + memcpy (codePtr, &b->dcls[0], size); + codePtr += size; + } + if (!b->insns.empty()) + { + size_t size = b->insns.size()*sizeof(b->insns[0]); + memcpy (codePtr, &b->insns[0], size); + codePtr += size; + } + DebugAssert (buf + size == codePtr); + + b->chunks[kBuilderChunkCode] = chunk; +} + +void dxbc_builder_build_code2 (DXBCBuilder* b); + +void* dxb_build (DXBCBuilder* b, size_t& outSize) +{ + dxbc_builder_build_sig (b, true); + dxbc_builder_build_sig (b, false); + if (b->codeBuilder.tempCount > 0) + { + SM4TokInstruction tok; + tok.dword = 0; + tok.opcode = kSM4Op_DCL_TEMPS; + tok.length = 2; + b->dcls.push_back (tok.dword); + b->dcls.push_back (b->codeBuilder.tempCount); + } + dxbc_builder_build_code (b); + dxbc_builder_build_code2(b); + + std::pair<void*,size_t> dxbc = dxbc_create (b->chunks, kBuilderChunkCount); + outSize = dxbc.second; + + return dxbc.first; +} + + + +//------------------------------------------------------------------------------------ +//SM 2.0 stuff + + +//table format was reversed and is still not 100% known +static dynamic_array<UInt32> dxbc_builder_build_mapping_table2 (DXBCBuilder* b) +{ + const unsigned shader_size = b->inputs2.size() + b->insns2.size() + b->defs2.size() + 1; + dynamic_array<UInt32> table; + + const unsigned rmap_offset = 0x24; + const unsigned cmap_offset = rmap_offset + b->numTextures2*4; + const unsigned imap_offset = cmap_offset + 3*4; + const unsigned shdr_offset = imap_offset + (b->version.type == kSM4Shader_Vertex ? 4 : 0); + + unsigned t = b->version.type == kSM4Shader_Pixel ? 4 : 0; + table.push_back(b->version.type == kSM4Shader_Pixel ? 0xffff0200 : 0xfffe0200); + table.push_back(shader_size*4); + table.push_back(shdr_offset); + table.push_back(1|(cmap_offset<<16)); + table.push_back(shdr_offset<<16); + table.push_back(shdr_offset<<16); + table.push_back(b->numTextures2|(rmap_offset<<16)); + table.push_back((b->version.type == kSM4Shader_Pixel ? 0 : 1)|(imap_offset<<16)); + + // Sampler mapping: 16-23 bits target sampler, 8-15 bits source sampler, 0-7 bits source resource + for (int n = 0;n < b->numTextures2;n++) + table.push_back(n|(n<<8)|(n<<16)); + + //constant to CB mapping + //CBn:CBoff; always zero + table.push_back(0); + //REGnum:REGn + table.push_back(b->version.type == kSM4Shader_Pixel ? 10 : 63); //k11VertexSize or k11PixelSize + //convert mode 8:8:8:8; always zero + table.push_back(0); + + //input mapping; always one constant for vertex shader with pixel offset: oPos.xy += offset.xy * oPos.w; + if (b->version.type == kSM4Shader_Vertex) + table.push_back(64<<16); //k11VertexPosOffset9x + + return table; +} + + +static unsigned swizzle_from_mask (unsigned mask) +{ + if (mask == 1) + return kSM4SwzRepX; + if (mask == 2) + return kSM4SwzRepY; + if (mask == 4) + return kSM4SwzRepZ; + if (mask == 8) + return kSM4SwzRepW; + //@TODO: more? + return kSM4SwzNone; +} + +static void dxb_handle_saturate2 (DXBCBuilder* b) +{ + if (!b->codeBuilder.saturate || b->version.type == kSM4Shader_Pixel) + return; + + // previous instruction had saturate on destination, so insert manual min/max instructions + const int tmpReg = b->codeBuilder.tmpSatRegIndex; + DebugAssert(tmpReg >= 0); + b->codeBuilder.saturate = 0; + + const int constReg = dxb_imm_f4 (b, 0, 1, 0, 0); + const unsigned mask = b->codeBuilder.dstRegMask; + const unsigned swz = swizzle_from_mask(mask); + + dxb_op2(b, kSM2Op_MAX, false); + dxb_reg2(b,'r',tmpReg,mask); + dxb_swz2(b,'r',tmpReg,swz); + dxb_swz2(b,'c',constReg,kSM4SwzRepX); + dxb_op2(b, kSM2Op_MIN, false); + dxb_reg2(b,b->codeBuilder.dstRegType,b->codeBuilder.dstRegIndex,mask); + dxb_swz2(b,'r',tmpReg,swz); + dxb_swz2(b,'c',constReg,kSM4SwzRepY); +} + +static void dxbc_builder_build_code2 (DXBCBuilder* b) +{ + dxb_handle_saturate2(b); // handle possible saturate on the last instruction + + dynamic_array<UInt32> table = dxbc_builder_build_mapping_table2(b); + + const unsigned shader_size = b->inputs2.size() + b->insns2.size() + b->defs2.size() + 1; + + // size = 8 (header) + 8 (code chunk header) + tokens + unsigned size = 12 + 4*table.size() + shader_size*4; + + UInt8* buf = (UInt8*)malloc(size); + DXBCChunkSM20* chunk = (DXBCChunkSM20*)buf; + + chunk->fourcc = kFOURCC_SM20; + chunk->size = size - 8; + chunk->length = chunk->size; + + UInt8* codePtr = (UInt8*)(chunk+1); + if (!table.empty()) + { + size_t size = table.size()*sizeof(table[0]); + memcpy (codePtr, &table[0], size); + codePtr += size; + } + + *(UInt32*)codePtr = b->version.type == kSM4Shader_Pixel ? 0xffff0201 : 0xfffe0201; + codePtr += 4; + + if (!b->defs2.empty()) + { + size_t size = b->defs2.size()*sizeof(b->defs2[0]); + memcpy (codePtr, &b->defs2[0], size); + codePtr += size; + } + if (!b->inputs2.empty()) + { + size_t size = b->inputs2.size()*sizeof(b->inputs2[0]); + memcpy (codePtr, &b->inputs2[0], size); + codePtr += size; + } + if (!b->insns2.empty()) + { + size_t size = b->insns2.size()*sizeof(b->insns2[0]); + memcpy (codePtr, &b->insns2[0], size); + codePtr += size; + } + + b->chunks[kBuilderChunkSM20] = chunk; +} + + +struct SM2TokSrc +{ + union { + UInt32 dword; + struct { + unsigned reg_num : 11; + unsigned reg_type34 : 2; + unsigned _res0 : 1; + unsigned _res1 : 2; + unsigned swizzle : 8; + unsigned src_mod : 4; + unsigned reg_type02 : 3; + unsigned _one : 1; + }; + }; +}; + +static inline UInt32 dxb_reg_split2(UInt32 n) +{ + return ((n<<D3DSP_REGTYPE_SHIFT)&D3DSP_REGTYPE_MASK)|((n<<(D3DSP_REGTYPE_SHIFT2))&D3DSP_REGTYPE_MASK2); +} + +static inline UInt32 dxb_reg_type2(char c) +{ + switch (c) + { + case 'r': return D3DSPR_TEMP; + case 'v': return D3DSPR_INPUT; + case 'c': return D3DSPR_CONST; + //should be D3DSPR_TEXTURE, however, I'm replacing + //t swizzle with sampler source and removing s source reg + //to convert sm40 sample to sm20 texld on-fly + case 't': return D3DSPR_SAMPLER; + // case 's': return D3DSPR_SAMPLER; + + case 'x': return D3DSPR_RASTOUT; + case 'y': return D3DSPR_TEXCRDOUT; + + case 'o': return D3DSPR_RASTOUT; + + default: AssertString("unknown register type"); return D3DSPR_TEMP; + } +} + +static void dxbc_update_insn_length2 (DXBCBuilder* b, int len) +{ + DebugAssert (b->curInsnIndex2 >= 0 && b->curInsnIndex2 < b->insns2.size()); + SM2TokInstruction* tok = (SM2TokInstruction*)&b->insns2[b->curInsnIndex2]; + tok->length += len; +} + +struct SNameToID +{ + const char* name; + UInt32 id; +}; + + +//SM4.0 semantic to SM2.0 VS usage mapping +static const SNameToID s_VSDeclNames[] = +{ + {"POSITION", D3DDECLUSAGE_POSITION}, + {"NORMAL", D3DDECLUSAGE_NORMAL}, + {"TEXCOORD", D3DDECLUSAGE_TEXCOORD}, + {"COLOR", D3DDECLUSAGE_COLOR}, + {"FOG", D3DDECLUSAGE_FOG}, + + {"SV_POSITION", 0}, + + {NULL, 0}, +}; + + +//SM4.0 semantic to SM2.0 PS register file mapping +static const SNameToID s_PSDeclNames[] = +{ + {"TEXCOORD", D3DSPR_TEXTURE}, + {"COLOR", D3DSPR_INPUT}, + + {"SV_Target", D3DSPR_COLOROUT}, + + {NULL, 0}, +}; + + +//SM4.0 semantic to SM2.0 register file mapping +static const SNameToID s_OutNames[] = +{ + {"POSITION", D3DSPR_RASTOUT}, + {"SV_POSITION", D3DSPR_RASTOUT}, + {"FOG", D3DSPR_RASTOUT}, + {"TEXCOORD", D3DSPR_TEXCRDOUT}, + {"COLOR", D3DSPR_ATTROUT}, + + {"SV_Target", D3DSPR_COLOROUT}, + + {NULL, 0}, +}; + + +static UInt32 find_dcl_by_name(const char* name,const SNameToID* p=s_VSDeclNames) +{ + while (p->name) + { + if (0 == strcmp(p->name,name)) + return p->id; + p++; + } + + Assert(0 || "DCL name not found!"); + + return -1; +} + +void dxb_dcl_tex2 (DXBCBuilder* b, int index, SM4Target dim) +{ + UInt32 tok2 = 0x80000000; + + switch (dim) + { + case kSM4Target_TEXTURE2D: + tok2 |= D3DSTT_2D; + break; + case kSM4Target_TEXTURE3D: + tok2 |= D3DSTT_VOLUME; + break; + case kSM4Target_TEXTURECUBE: + tok2 |= D3DSTT_CUBE; + break; + default: + Assert(0 || "Wrong texture type!"); + }; + + SM2TokInstruction tok; + tok.dword = 0; + tok.opcode = kSM2Op_DCL; + tok.length = 2; + + b->inputs2.push_back (tok.dword); + b->inputs2.push_back (tok2); + + SM2TokDst op; + op.dword = dxb_reg_split2(D3DSPR_SAMPLER); + op.reg_num = index; + op.write_mask = 0xf; + op._one = 1; + b->inputs2.push_back (op.dword); + + b->numTextures2++; +} + +//CAVEAT: DX11 feature level 9.x vertex shaders use texcoord semantics for _all_ attributes +int dxb_find_input_by_name2(DXBCBuilder* b,const char* name, int index) +{ + int index2 = 0; + while (0 != strcmp(b->inputs[index2].name,name) || b->inputs[index2].index != index) + index2++; + + return index2; +} + +int dxb_find_output_by_name2(DXBCBuilder* b,const char* name, int index) +{ + int index2 = 0; + while (0 != strcmp(b->outputs[index2].name,name) || b->outputs[index2].index != index) + index2++; + + return index2; +} + + +//CAVEAT1: DX11 feature level 9.x vertex shaders use texcoord semantics for _all_ attributes +//CAVEAT2: [Qualcomm] DX11 feature level 9.x uses texcoord interpolators for _all_ varyings +void dxb_dcl_input2 (DXBCBuilder* b, const char* name, int index, int reg, int mask) +{ + //TODO: this is not needed anymore. + UInt32 decl = find_dcl_by_name(name,b->version.type == kSM4Shader_Vertex ? s_VSDeclNames : s_PSDeclNames); + UInt32 reg_type = b->version.type == kSM4Shader_Vertex ? dxb_reg_type2('v') : (decl); + + SM2TokInstruction tok; + tok.dword = 0; + tok.opcode = kSM2Op_DCL; + tok.length = 2; + + b->inputs2.push_back (tok.dword); + + UInt32 tok2 = 0x80000000; + //CAVEAT1 + if (b->version.type == kSM4Shader_Vertex) + tok2 |= D3DDECLUSAGE_TEXCOORD|(dxb_find_input_by_name2(b,name,index)<<16); + b->inputs2.push_back (tok2); + +#if 1 + //CAVEAT2 + if (b->version.type == kSM4Shader_Pixel) + { + index = dxb_find_input_by_name2(b,name,index); + reg_type = D3DSPR_TEXTURE; + } +#endif + + SM2TokDst op; + op.dword = dxb_reg_split2(reg_type); + op.reg_num = b->version.type == kSM4Shader_Vertex ? reg : index; + op.write_mask = mask; + op._one = 1; + op._res0 = 0; + op._res1 = 0; + b->inputs2.push_back (op.dword); + + if (b->version.type == kSM4Shader_Pixel) + { + op.write_mask = 0; + b->inputMap[reg] = op.dword; + } +} + +void dxb_dcl_output2 (DXBCBuilder* b, const char* name, int index, int reg, int mask) +{ + UInt32 reg_type = find_dcl_by_name(name,s_OutNames); +#if 1 + //CAVEAT2. Excluding POSITION + if (b->version.type == kSM4Shader_Vertex && NULL == strstr(name,"POSITION")) + { + index = dxb_find_output_by_name2(b,name,index); + reg_type = D3DSPR_TEXCRDOUT; + } +#else + //special case in raster reg. file + if (0 == strcmp(name,"FOG")) + index = 2; +#endif + + SM2TokDst op; + op.dword = dxb_reg_split2(reg_type); + op.reg_num = index; + + b->outputMap[reg] = op.dword; +} + +static UInt32 dxb_find_output2 (DXBCBuilder* b, int reg) +{ + Assert (b->outputMap.find(reg) != b->outputMap.end()); + return b->outputMap[reg]; +} + +static UInt32 dxb_find_input2 (DXBCBuilder* b, int reg) +{ + Assert (b->inputMap.find(reg) != b->inputMap.end()); + return b->inputMap[reg]; +} + + +void dxb_op2 (DXBCBuilder* b, SM2Opcode op, bool sat, int scratchTmpRegForSat) +{ + dxb_handle_saturate2 (b); + + b->codeBuilder.opcode2 = op; + b->curInsnIndex2 = b->insns2.size(); + + SM2TokInstruction tok; + tok.dword = 0; + tok.opcode = op; + tok.specific = op>>16; + tok.length = 0; + + b->insns2.push_back (tok.dword); + b->codeBuilder.saturate = sat; + b->codeBuilder.tmpSatRegIndex = scratchTmpRegForSat; +} + +void dxb_reg2 (DXBCBuilder* b, char rchar, int reg,unsigned mask) +{ + b->codeBuilder.dstRegMask = mask; + b->codeBuilder.dstRegComps = BitsInMask(mask); + if (b->codeBuilder.saturate) + { + b->codeBuilder.dstRegType = rchar; + b->codeBuilder.dstRegIndex = reg; + if (b->version.type != kSM4Shader_Pixel) + { + rchar = 'r'; + reg = b->codeBuilder.tmpSatRegIndex; + } + } + + //for sm20 sampler will be emitted by texture coords swizzle source op + if ('s' == rchar && b->version.type == kSM4Shader_Pixel) + return; + + dxbc_update_insn_length2 (b, 1); + SM2TokDst op; + + if ('o' == rchar) + op.dword = dxb_find_output2(b,reg); + else if ('v' == rchar && b->version.type == kSM4Shader_Pixel) + op.dword = dxb_find_input2(b,reg); + else + { + op.dword = dxb_reg_split2(dxb_reg_type2(rchar)); + op.reg_num = reg; + } + + op.res_mod = 0; + if (b->codeBuilder.saturate && b->version.type == kSM4Shader_Pixel) + { + op.res_mod = D3DSPDM_SATURATE>>D3DSP_DSTMOD_SHIFT; + b->codeBuilder.saturate = 0; + } + + op.write_mask = mask; + op._one = 1; + op._res0 = 0; + op._res1 = 0; + + b->insns2.push_back (op.dword); +} + +void dxb_swz2 (DXBCBuilder* b, char rchar, int reg, unsigned swizzle, bool neg) +{ + swizzle = adjust_swizzle (&b->codeBuilder, swizzle, true); + + UInt32 rtype = dxb_reg_type2(rchar); + dxbc_update_insn_length2 (b, 1); + + SM2TokSrc op; + if ('o' == rchar) + op.dword = dxb_find_output2(b,reg); + else if ('v' == rchar && b->version.type == kSM4Shader_Pixel) + op.dword = dxb_find_input2(b,reg); + else + { + op.dword = dxb_reg_split2(dxb_reg_type2(rchar)); + op.reg_num = reg; + } + + //texld must not swizzle + if ('s' != rchar && 't' != rchar)// && op.reg_type02 != D3DSPR_TEXTURE) + { + op.swizzle = swizzle; + op.src_mod = neg ? 1 : 0; + } + else + op.swizzle = kSM4SwzNone; + + op._one = 1; + op._res0 = 0; + op._res1 = 0; + + b->insns2.push_back (op.dword); +} + +//find a constant, define a constant if not found +int dxb_imm_f4 (DXBCBuilder* b, float v0, float v1, float v2, float v3) +{ + union { float f; UInt32 i; } f2i; + //TODO: do not hardcode! + int reg = b->version.type == kSM4Shader_Pixel ? 10 : 63 + 2; + dynamic_array<UInt32>::const_iterator it = b->defs2.begin(); + for (;it != b->defs2.end();it += 6, reg++) + { + f2i.f = v0; + if (f2i.i != *(it + 2)) + continue; + f2i.f = v1; + if (f2i.i != *(it + 3)) + continue; + f2i.f = v2; + if (f2i.i != *(it + 4)) + continue; + f2i.f = v3; + if (f2i.i != *(it + 5)) + continue; + + break; + } + + if (it == b->defs2.end()) + { + SM2TokInstruction tok; + tok.dword = 0; + tok.opcode = kSM2Op_DEF; + tok.specific = 0; + tok.length = 5; + b->defs2.push_back (tok.dword); + + SM2TokDst op; + op.dword = dxb_reg_split2(dxb_reg_type2('c')); + op.reg_num = reg; + op.write_mask = 0xF; + op._one = 1; + b->defs2.push_back (op.dword); + + f2i.f = v0; b->defs2.push_back (f2i.i); + f2i.f = v1; b->defs2.push_back (f2i.i); + f2i.f = v2; b->defs2.push_back (f2i.i); + f2i.f = v3; b->defs2.push_back (f2i.i); + } + + return reg; +} + +SM2Opcode dxb_to_sm2 (SM4Opcode op) +{ + switch (op) + { + case kSM4Op_SQRT: + break; + case kSM4Op_DIV: + break; + case kSM4Op_RSQ: + return kSM2Op_RSQ; + case kSM4Op_LOG: + return kSM2Op_LOG; + case kSM4Op_EXP: + return kSM2Op_EXP; + case kSM4Op_RCP: + return kSM2Op_RCP; + + case kSM4Op_MOV: + return kSM2Op_MOV; + case kSM4Op_MOVC: + break; + + case kSM4Op_MAD: + return kSM2Op_MAD; + case kSM4Op_DP2: + break; + case kSM4Op_DP3: + return kSM2Op_DP3; + case kSM4Op_DP4: + return kSM2Op_DP4; + case kSM4Op_MUL: + return kSM2Op_MUL; + case kSM4Op_ADD: + return kSM2Op_ADD; + case kSM4Op_AND: + break; + case kSM4Op_MIN: + return kSM2Op_MIN; + case kSM4Op_MAX: + return kSM2Op_MAX; + + case kSM4Op_SAMPLE: + return kSM2Op_TEX; + case kSM4Op_DISCARD: + return kSM2Op_TEXKILL; + + case kSM4Op_LT: + return kSM2Op_SLT; + case kSM4Op_GE: + return kSM2Op_SGE; + case kSM4Op_NE: + break; + case kSM4Op_EQ: + break; + + case kSM4Op_RET: + return kSM2Op_END; + } + + AssertString("unknown SM4 opcode"); + __debugbreak(); + + return kSM2Op_NOP; +} + + diff --git a/Runtime/GfxDevice/d3d11/D3D11ByteCode.h b/Runtime/GfxDevice/d3d11/D3D11ByteCode.h new file mode 100644 index 0000000..020a8c1 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11ByteCode.h @@ -0,0 +1,856 @@ +#pragma once + +#include "Runtime/Utilities/dynamic_array.h" + +struct _D3D11_SIGNATURE_PARAMETER_DESC; +typedef struct _D3D11_SIGNATURE_PARAMETER_DESC D3D11_SIGNATURE_PARAMETER_DESC; + + + +#define MAKE_FOURCC(a, b, c, d) ((UInt32)(UInt8)(a) | ((UInt32)(UInt8)(b) << 8) | ((UInt32)(UInt8)(c) << 16) | ((UInt32)(UInt8)(d) << 24 )) +#define kFOURCC_DXBC MAKE_FOURCC('D', 'X', 'B', 'C') + +// Reflection or debug information? stripped shaders don't have this chunk +#define kFOURCC_RDEF MAKE_FOURCC('R', 'D', 'E', 'F') +// Shader input signature +#define kFOURCC_ISGN MAKE_FOURCC('I', 'S', 'G', 'N') +// Shader output signature +#define kFOURCC_OSGN MAKE_FOURCC('O', 'S', 'G', 'N') +// Shader code +#define kFOURCC_SHDR MAKE_FOURCC('S', 'H', 'D', 'R') +#define kFOURCC_SHEX MAKE_FOURCC('S', 'H', 'E', 'X') +// Statistics? stripped shaders don't have this chunk +#define kFOURCC_STAT MAKE_FOURCC('S', 'T', 'A', 'T') +// Patch information? +#define kFOURCC_PCSG MAKE_FOURCC('P', 'C', 'S', 'G') +//FL 9.x SM 2.0 shader magic signature +#define kFOURCC_SM20 MAKE_FOURCC('A', 'o', 'n', '9') + + +struct DXBCChunkHeader +{ + unsigned fourcc; + unsigned size; +}; + + +struct DXBCContainer +{ + const void* data; + dynamic_array<DXBCChunkHeader*> chunks; +}; + +struct DXBCSignatureElement +{ + UInt32 name_offset; + UInt32 semantic_index; + UInt32 system_value_type; + UInt32 component_type; + UInt32 register_num; + UInt8 mask; + UInt8 read_write_mask; + UInt8 stream; + UInt8 unused; +}; + +struct DXBCChunkSig : public DXBCChunkHeader +{ + UInt32 count; + UInt32 unk8; // always has 8? + DXBCSignatureElement elements[1]; +}; + +struct DXBCChunkCode : public DXBCChunkHeader +{ + UInt32 version; + UInt32 length; // length in dword tokens +}; + +struct DXBCChunkSM20 : public DXBCChunkHeader +{ + UInt32 length; // length in bytes +}; + + +struct SM4TokInstruction +{ + // not an union directly because unions can't be inherited from + union + { + UInt32 dword; + // length and extended are always present, but they are only here to reduce duplication + struct + { + unsigned opcode : 11; + unsigned _11_23 : 13; + unsigned length : 7; + unsigned extended : 1; + }; + struct + { + unsigned opcode : 11; + unsigned resinfo_return_type : 2; + unsigned sat : 1; + unsigned _14_17 : 4; + unsigned test_nz : 1; // bit 18 + unsigned precise_mask : 4; + unsigned _23 : 1; + unsigned length : 7; + unsigned extended : 1; + } insn; + struct + { + unsigned opcode : 11; + unsigned threads_in_group : 1; + unsigned shared_memory : 1; + unsigned uav_group : 1; + unsigned uav_global : 1; + unsigned _15_17 : 3; + } sync; + struct + { + unsigned opcode : 11; + unsigned allow_refactoring : 1; + unsigned fp64 : 1; + unsigned early_depth_stencil : 1; + unsigned enable_raw_and_structured_in_non_cs : 1; + } dcl_global_flags; + struct + { + unsigned opcode : 11; + unsigned target : 5; + unsigned nr_samples : 7; + } dcl_resource; + struct + { + unsigned opcode : 11; + unsigned shadow : 1; + unsigned mono : 1; + } dcl_sampler; + struct + { + unsigned opcode : 11; + unsigned interpolation : 5; + } dcl_input_ps; + struct + { + unsigned opcode : 11; + unsigned dynamic : 1; + } dcl_constant_buffer; + struct + { + unsigned opcode : 11; + unsigned primitive : 6; + } dcl_gs_input_primitive; + struct + { + unsigned opcode : 11; + unsigned primitive_topology : 7; + } dcl_gs_output_primitive_topology; + struct + { + unsigned opcode : 11; + unsigned control_points : 6; + } dcl_input_control_point_count; + struct + { + unsigned opcode : 11; + unsigned control_points : 6; + } dcl_output_control_point_count; + struct + { + unsigned opcode : 11; + unsigned domain : 3; /* D3D_TESSELLATOR_DOMAIN */ + } dcl_tess_domain; + struct + { + unsigned opcode : 11; + unsigned partitioning : 3; /* D3D_TESSELLATOR_PARTITIONING */ + } dcl_tess_partitioning; + struct + { + unsigned opcode : 11; + unsigned primitive : 3; /* D3D_TESSELLATOR_OUTPUT_PRIMITIVE */ + } dcl_tess_output_primitive; + }; +}; + +union SM4TokInstructionEx +{ + UInt32 dword; + struct + { + unsigned type : 6; + unsigned _6_30 : 25; + unsigned extended :1; + }; + struct + { + unsigned type : 6; + unsigned _6_8 : 3; + int offset_u : 4; + int offset_v : 4; + int offset_w : 4; + } sample_controls; + struct + { + unsigned type : 6; + unsigned target : 5; + } resource_target; + struct + { + unsigned type : 6; + unsigned x : 4; + unsigned y : 4; + unsigned z : 4; + unsigned w : 4; + } resource_return_type; +}; + +struct SM4TokOperand +{ + union { + UInt32 dword; + struct { + unsigned comps_enum : 2; /* sm4_operands_comps */ + unsigned mode : 2; /* SM4OperMode */ + unsigned sel : 8; + unsigned file : 8; /* SM4RegFile */ + unsigned num_indices : 2; + unsigned index0_repr : 3; /* SM4OperIndexRepr */ + unsigned index1_repr : 3; /* SM4OperIndexRepr */ + unsigned index2_repr : 3; /* SM4OperIndexRepr */ + unsigned extended : 1; + }; + }; +}; + +struct SM2TokInstruction +{ + union + { + UInt32 dword; + struct + { + unsigned opcode : 16; + unsigned specific : 8; + unsigned length : 4; + unsigned predicated : 1; + unsigned _res0 : 1; + unsigned _res1 : 1; + unsigned _res2 : 1; + }; + struct + { + unsigned minor : 8; + unsigned major : 8; + unsigned _magic : 16; + } version; + }; +}; + +struct SM2TokDst +{ + union { + UInt32 dword; + struct { + unsigned reg_num : 11; + unsigned reg_type34 : 2; + unsigned _res0 : 1; + unsigned _res1 : 2; + unsigned write_mask : 4; + unsigned res_mod : 4; + unsigned shift_scl : 4; + unsigned reg_type02 : 3; + unsigned _one : 1; + }; + }; +}; + +void dxbc_create(struct DXBCChunkHeader** chunks, unsigned num_chunks, dynamic_array<UInt8>& out); + + +DXBCContainer* dxbc_parse(const void* data, int size); +DXBCChunkHeader* dxbc_find_chunk(const void* data, int size, unsigned fourcc); +void dxbc_print(const DXBCContainer* dxbc); +int dxbc_parse_signature(const DXBCChunkSig* sig, D3D11_SIGNATURE_PARAMETER_DESC** params); + + +enum SM2Opcode +{ + kSM2Op_NOP = 0, + kSM2Op_MOV , + kSM2Op_ADD , + kSM2Op_SUB , + kSM2Op_MAD , + kSM2Op_MUL , + kSM2Op_RCP , + kSM2Op_RSQ , + kSM2Op_DP3 , + kSM2Op_DP4 , + kSM2Op_MIN , + kSM2Op_MAX , + kSM2Op_SLT , + kSM2Op_SGE , + kSM2Op_EXP , + kSM2Op_LOG , + kSM2Op_LIT , + kSM2Op_DST , + kSM2Op_LRP , + kSM2Op_FRC , + kSM2Op_M4x4 , + kSM2Op_M4x3 , + kSM2Op_M3x4 , + kSM2Op_M3x3 , + kSM2Op_M3x2 , + kSM2Op_CALL , + kSM2Op_CALLNZ , + kSM2Op_LOOP , + kSM2Op_RET , + kSM2Op_ENDLOOP , + kSM2Op_LABEL , + kSM2Op_DCL , + kSM2Op_POW , + kSM2Op_CRS , + kSM2Op_SGN , + kSM2Op_ABS , + kSM2Op_NRM , + kSM2Op_SINCOS , + kSM2Op_REP , + kSM2Op_ENDREP , + kSM2Op_IF , + kSM2Op_IFC , + kSM2Op_ELSE , + kSM2Op_ENDIF , + kSM2Op_BREAK , + kSM2Op_BREAKC , + kSM2Op_MOVA , + kSM2Op_DEFB , + kSM2Op_DEFI , + + kSM2Op_TEXCOORD = 64, + kSM2Op_TEXKILL , + kSM2Op_TEX , + kSM2Op_TEXBEM , + kSM2Op_TEXBEML , + kSM2Op_TEXREG2AR , + kSM2Op_TEXREG2GB , + kSM2Op_TEXM3x2PAD , + kSM2Op_TEXM3x2TEX , + kSM2Op_TEXM3x3PAD , + kSM2Op_TEXM3x3TEX , + kSM2Op_RESERVED0 , + kSM2Op_TEXM3x3SPEC , + kSM2Op_TEXM3x3VSPEC , + kSM2Op_EXPP , + kSM2Op_LOGP , + kSM2Op_CND , + kSM2Op_DEF , + kSM2Op_TEXREG2RGB , + kSM2Op_TEXDP3TEX , + kSM2Op_TEXM3x2DEPTH , + kSM2Op_TEXDP3 , + kSM2Op_TEXM3x3 , + kSM2Op_TEXDEPTH , + kSM2Op_CMP , + kSM2Op_BEM , + kSM2Op_DP2ADD , + kSM2Op_DSX , + kSM2Op_DSY , + kSM2Op_TEXLDD , + kSM2Op_SETP , + kSM2Op_TEXLDL , + kSM2Op_BREAKP , + + kSM2Op_PHASE = 0xFFFD, + kSM2Op_COMMENT = 0xFFFE, + kSM2Op_END = 0xFFFF, +}; + +enum SM4ShaderType +{ + kSM4Shader_Pixel, + kSM4Shader_Vertex, +}; + +enum SM4Opcode +{ + kSM4Op_ADD, + kSM4Op_AND, + kSM4Op_BREAK, + kSM4Op_BREAKC, + kSM4Op_CALL, + kSM4Op_CALLC, + kSM4Op_CASE, + kSM4Op_CONTINUE, + kSM4Op_CONTINUEC, + kSM4Op_CUT, + kSM4Op_DEFAULT, + kSM4Op_DERIV_RTX, + kSM4Op_DERIV_RTY, + kSM4Op_DISCARD, + kSM4Op_DIV, + kSM4Op_DP2, + kSM4Op_DP3, + kSM4Op_DP4, + kSM4Op_ELSE, + kSM4Op_EMIT, + kSM4Op_EMITTHENCUT, + kSM4Op_ENDIF, + kSM4Op_ENDLOOP, + kSM4Op_ENDSWITCH, + kSM4Op_EQ, + kSM4Op_EXP, + kSM4Op_FRC, + kSM4Op_FTOI, + kSM4Op_FTOU, + kSM4Op_GE, + kSM4Op_IADD, + kSM4Op_IF, + kSM4Op_IEQ, + kSM4Op_IGE, + kSM4Op_ILT, + kSM4Op_IMAD, + kSM4Op_IMAX, + kSM4Op_IMIN, + kSM4Op_IMUL, + kSM4Op_INE, + kSM4Op_INEG, + kSM4Op_ISHL, + kSM4Op_ISHR, + kSM4Op_ITOF, + kSM4Op_LABEL, + kSM4Op_LD, + kSM4Op_LD_MS, + kSM4Op_LOG, + kSM4Op_LOOP, + kSM4Op_LT, + kSM4Op_MAD, + kSM4Op_MIN, + kSM4Op_MAX, + kSM4Op_CUSTOMDATA, + kSM4Op_MOV, + kSM4Op_MOVC, + kSM4Op_MUL, + kSM4Op_NE, + kSM4Op_NOP, + kSM4Op_NOT, + kSM4Op_OR, + kSM4Op_RESINFO, + kSM4Op_RET, + kSM4Op_RETC, + kSM4Op_ROUND_NE, + kSM4Op_ROUND_NI, + kSM4Op_ROUND_PI, + kSM4Op_ROUND_Z, + kSM4Op_RSQ, + kSM4Op_SAMPLE, + kSM4Op_SAMPLE_C, + kSM4Op_SAMPLE_C_LZ, + kSM4Op_SAMPLE_L, + kSM4Op_SAMPLE_D, + kSM4Op_SAMPLE_B, + kSM4Op_SQRT, + kSM4Op_SWITCH, + kSM4Op_SINCOS, + kSM4Op_UDIV, + kSM4Op_ULT, + kSM4Op_UGE, + kSM4Op_UMUL, + kSM4Op_UMAD, + kSM4Op_UMAX, + kSM4Op_UMIN, + kSM4Op_USHR, + kSM4Op_UTOF, + kSM4Op_XOR, + kSM4Op_DCL_RESOURCE, + kSM4Op_DCL_CONSTANT_BUFFER, + kSM4Op_DCL_SAMPLER, + kSM4Op_DCL_INDEX_RANGE, + kSM4Op_DCL_GS_OUTPUT_PRIMITIVE_TOPOLOGY, + kSM4Op_DCL_GS_INPUT_PRIMITIVE, + kSM4Op_DCL_MAX_OUTPUT_VERTEX_COUNT, + kSM4Op_DCL_INPUT, + kSM4Op_DCL_INPUT_SGV, + kSM4Op_DCL_INPUT_SIV, + kSM4Op_DCL_INPUT_PS, + kSM4Op_DCL_INPUT_PS_SGV, + kSM4Op_DCL_INPUT_PS_SIV, + kSM4Op_DCL_OUTPUT, + kSM4Op_DCL_OUTPUT_SGV, + kSM4Op_DCL_OUTPUT_SIV, + kSM4Op_DCL_TEMPS, + kSM4Op_DCL_INDEXABLE_TEMP, + kSM4Op_DCL_GLOBAL_FLAGS, + kSM4Op_D3D10_COUNT, + kSM4Op_LOD, + kSM4Op_GATHER4, + kSM4Op_SAMPLE_POS, + kSM4Op_SAMPLE_INFO, + kSM4Op_D3D10_1_COUNT, + kSM4Op_HS_DECLS, + kSM4Op_HS_CONTROL_POINT_PHASE, + kSM4Op_HS_FORK_PHASE, + kSM4Op_HS_JOIN_PHASE, + kSM4Op_EMIT_STREAM, + kSM4Op_CUT_STREAM, + kSM4Op_EMITTHENCUT_STREAM, + kSM4Op_INTERFACE_CALL, + kSM4Op_BUFINFO, + kSM4Op_DERIV_RTX_COARSE, + kSM4Op_DERIV_RTX_FINE, + kSM4Op_DERIV_RTY_COARSE, + kSM4Op_DERIV_RTY_FINE, + kSM4Op_GATHER4_C, + kSM4Op_GATHER4_PO, + kSM4Op_GATHER4_PO_C, + kSM4Op_RCP, + kSM4Op_F32TOF16, + kSM4Op_F16TOF32, + kSM4Op_UADDC, + kSM4Op_USUBB, + kSM4Op_COUNTBITS, + kSM4Op_FIRSTBIT_HI, + kSM4Op_FIRSTBIT_LO, + kSM4Op_FIRSTBIT_SHI, + kSM4Op_UBFE, + kSM4Op_IBFE, + kSM4Op_BFI, + kSM4Op_BFREV, + kSM4Op_SWAPC, + kSM4Op_DCL_STREAM, + kSM4Op_DCL_FUNCTION_BODY, + kSM4Op_DCL_FUNCTION_TABLE, + kSM4Op_DCL_INTERFACE, + kSM4Op_DCL_INPUT_CONTROL_POINT_COUNT, + kSM4Op_DCL_OUTPUT_CONTROL_POINT_COUNT, + kSM4Op_DCL_TESS_DOMAIN, + kSM4Op_DCL_TESS_PARTITIONING, + kSM4Op_DCL_TESS_OUTPUT_PRIMITIVE, + kSM4Op_DCL_HS_MAX_TESSFACTOR, + kSM4Op_DCL_HS_FORK_PHASE_INSTANCE_COUNT, + kSM4Op_DCL_HS_JOIN_PHASE_INSTANCE_COUNT, + kSM4Op_DCL_THREAD_GROUP, + kSM4Op_DCL_UNORDERED_ACCESS_VIEW_TYPED, + kSM4Op_DCL_UNORDERED_ACCESS_VIEW_RAW, + kSM4Op_DCL_UNORDERED_ACCESS_VIEW_STRUCTURED, + kSM4Op_DCL_THREAD_GROUP_SHARED_MEMORY_RAW, + kSM4Op_DCL_THREAD_GROUP_SHARED_MEMORY_STRUCTURED, + kSM4Op_DCL_RESOURCE_RAW, + kSM4Op_DCL_RESOURCE_STRUCTURED, + kSM4Op_LD_UAV_TYPED, + kSM4Op_STORE_UAV_TYPED, + kSM4Op_LD_RAW, + kSM4Op_STORE_RAW, + kSM4Op_LD_STRUCTURED, + kSM4Op_STORE_STRUCTURED, + kSM4Op_ATOMIC_AND, + kSM4Op_ATOMIC_OR, + kSM4Op_ATOMIC_XOR, + kSM4Op_ATOMIC_CMP_STORE, + kSM4Op_ATOMIC_IADD, + kSM4Op_ATOMIC_IMAX, + kSM4Op_ATOMIC_IMIN, + kSM4Op_ATOMIC_UMAX, + kSM4Op_ATOMIC_UMIN, + kSM4Op_IMM_ATOMIC_ALLOC, + kSM4Op_IMM_ATOMIC_CONSUME, + kSM4Op_IMM_ATOMIC_IADD, + kSM4Op_IMM_ATOMIC_AND, + kSM4Op_IMM_ATOMIC_OR, + kSM4Op_IMM_ATOMIC_XOR, + kSM4Op_IMM_ATOMIC_EXCH, + kSM4Op_IMM_ATOMIC_CMP_EXCH, + kSM4Op_IMM_ATOMIC_IMAX, + kSM4Op_IMM_ATOMIC_IMIN, + kSM4Op_IMM_ATOMIC_UMAX, + kSM4Op_IMM_ATOMIC_UMIN, + kSM4Op_SYNC, + kSM4Op_DADD, + kSM4Op_DMAX, + kSM4Op_DMIN, + kSM4Op_DMUL, + kSM4Op_DEQ, + kSM4Op_DGE, + kSM4Op_DLT, + kSM4Op_DNE, + kSM4Op_DMOV, + kSM4Op_DMOVC, + kSM4Op_DTOF, + kSM4Op_FTOD, + kSM4Op_EVAL_SNAPPED, + kSM4Op_EVAL_SAMPLE_INDEX, + kSM4Op_EVAL_CENTROID, + kSM4Op_DCL_GS_INSTANCE_COUNT, + kSM4Op_COUNT +}; + + +enum SM4Interpolation +{ + kSM4Interp_UNDEFINED, + kSM4Interp_CONSTANT, + kSM4Interp_LINEAR, + kSM4Interp_LINEAR_CENTROID, + kSM4Interp_LINEAR_NOPERSPECTIVE, + kSM4Interp_LINEAR_NOPERSPECTIVE_CENTROID, + kSM4Interp_LINEAR_SAMPLE, + kSM4Interp_LINEAR_NOPERSPECTIVE_SAMPLE, + kSM4Interp_COUNT +}; + + +enum SM4OperCompnum +{ + kSM4OperComp0, + kSM4OperComp1, + kSM4OperComp4, + kSM4OperCompN, + kSM4OperComp, + kSM4OperCompCOUNT +}; + +enum SM4OperMode +{ + SM4_OPERAND_MODE_MASK, + SM4_OPERAND_MODE_SWIZZLE, + SM4_OPERAND_MODE_SCALAR, + SM4_OPERAND_MODE_, + SM4_OPERAND_MODE_COUNT +}; + +enum SM4OperIndexRepr +{ + SM4_OPERAND_INDEX_REPR_IMM32, + SM4_OPERAND_INDEX_REPR_IMM64, + SM4_OPERAND_INDEX_REPR_REG, + SM4_OPERAND_INDEX_REPR_REG_IMM32, + SM4_OPERAND_INDEX_REPR_REG_IMM64, + SM4_OPERAND_INDEX_REPR_COUNT +}; + + +enum SM4RegFile +{ + kSM4File_TEMP, + kSM4File_INPUT, + kSM4File_OUTPUT, + kSM4File_INDEXABLE_TEMP, + kSM4File_IMMEDIATE32, + kSM4File_IMMEDIATE64, + kSM4File_SAMPLER, + kSM4File_RESOURCE, + kSM4File_CONSTANT_BUFFER, + kSM4File_IMMEDIATE_CONSTANT_BUFFER, + kSM4File_LABEL, + kSM4File_INPUT_PRIMITIVEID, + kSM4File_OUTPUT_DEPTH, + kSM4File_NULL, + kSM4File_RASTERIZER, + kSM4File_OUTPUT_COVERAGE_MASK, + kSM4File_STREAM, + kSM4File_FUNCTION_BODY, + kSM4File_FUNCTION_TABLE, + kSM4File_INTERFACE, + kSM4File_FUNCTION_INPUT, + kSM4File_FUNCTION_OUTPUT, + kSM4File_OUTPUT_CONTROL_POINT_ID, + kSM4File_INPUT_FORK_INSTANCE_ID, + kSM4File_INPUT_JOIN_INSTANCE_ID, + kSM4File_INPUT_CONTROL_POINT, + kSM4File_OUTPUT_CONTROL_POINT, + kSM4File_INPUT_PATCH_CONSTANT, + kSM4File_INPUT_DOMAIN_POINT, + kSM4File_THIS_POINTER, + kSM4File_UNORDERED_ACCESS_VIEW, + kSM4File_THREAD_GROUP_SHARED_MEMORY, + kSM4File_INPUT_THREAD_ID, + kSM4File_INPUT_THREAD_GROUP_ID, + kSM4File_INPUT_THREAD_ID_IN_GROUP, + kSM4File_INPUT_COVERAGE_MASK, + kSM4File_INPUT_THREAD_ID_IN_GROUP_FLATTENED, + kSM4File_INPUT_GS_INSTANCE_ID, + kSM4File_OUTPUT_DEPTH_GREATER_EQUAL, + kSM4File_OUTPUT_DEPTH_LESS_EQUAL, + kSM4File_CYCLE_COUNTER, + kSM4File_COUNT +}; + + +extern const char* kSM4OpcodeNames[kSM4Op_COUNT]; + + +enum SM4Swizzle { + kSM4SwzNone = 0xE4, // 11.10.01.00 + kSM4SwzRepX = 0x00, // 00.00.00.00 + kSM4SwzRepY = 0x55, // 01.01.01.01 + kSM4SwzRepZ = 0xAA, // 10.10.10.10 + kSM4SwzRepW = 0xFF, // 11.11.11.11 + kSM4SwzXYZZ = 0xA4, // 10.10.01.00 + kSM4SwzXYYY = 0x54, // 01.01.01.00 + kSM4SwzXYXX = 0x04, // 00.00.01.00 + kSM4SwzXYXY = 0x44, // 01.00.01.00 + kSM4SwzZWZW = 0xEE, // 11.10.11.10 + kSM4SwzZWWW = 0xFE, // 11.11.11.10 + kSM4SwzYYYZ = 0x95, // 10.01.01.01 + kSM4SwzXYZX = 0x24, // 00.10.01.00 + kSM4SwzXYZY = 0x64, // 01.10.01.00 + kSM4SwzYZWY = 0x79, // 01.11.10.01 +}; + +enum SM4Target +{ + kSM4Target_UNKNOWN, + kSM4Target_BUFFER, + kSM4Target_TEXTURE1D, + kSM4Target_TEXTURE2D, + kSM4Target_TEXTURE2DMS, + kSM4Target_TEXTURE3D, + kSM4Target_TEXTURECUBE, + kSM4Target_TEXTURE1DARRAY, + kSM4Target_TEXTURE2DARRAY, + kSM4Target_TEXTURE2DMSARRAY, + kSM4Target_TEXTURECUBEARRAY, + kSM4Target_RAW_BUFFER, + kSM4Target_STRUCTURED_BUFFER, + kSM4Target_COUNT +}; + + +struct DXBCBuilder; +DXBCBuilder* dxb_create(int major, int minor, SM4ShaderType type); +void dxb_destroy(DXBCBuilder* b); + + +struct DXBCCodeBuilder; +DXBCCodeBuilder* dxb_get_code_builder(DXBCBuilder* b); +DXBCCodeBuilder* dxb_create_code(dynamic_array<UInt32>& destArray); +void dxb_destroy_code(DXBCCodeBuilder* b); + +// result must be free()'d +void* dxb_build (DXBCBuilder* b, size_t& outSize); + +void dxb_dcl_input (DXBCBuilder* b, const char* name, int index, int reg, int mask = 0xF); +void dxb_dcl_output (DXBCBuilder* b, const char* name, int index, int reg, int mask = 0xF); +void dxb_dcl_tex (DXBCBuilder* b, int index, SM4Target dim); +void dxb_dcl_cb (DXBCBuilder* b, int index, int size); + +void dxb_op (DXBCCodeBuilder* b, SM4Opcode op, bool sat); +void dxb_reg (DXBCCodeBuilder* b, char rchar, int reg, unsigned mask = 0xF); +void dxb_swz (DXBCCodeBuilder* b, char rchar, int reg, unsigned swiz = kSM4SwzNone, bool neg=false); +void dxb_float1 (DXBCCodeBuilder* b, float v); +void dxb_int1 (DXBCCodeBuilder* b, int i); +void dxb_float4 (DXBCCodeBuilder* b, float v0, float v1, float v2, float v3); + +//------------------------------------------------------------------------------------ +//SM 2.0 stuff +void dxb_dcl_input2 (DXBCBuilder* b, const char* name, int index, int reg, int mask); +void dxb_dcl_output2 (DXBCBuilder* b, const char* name, int index, int reg, int mask); +void dxb_dcl_tex2 (DXBCBuilder* b, int index, SM4Target dim); +void dxb_op2 (DXBCBuilder* b, SM2Opcode op, bool sat, int scratchTmpRegForSat = -1); +void dxb_reg2 (DXBCBuilder* b, char rchar, int reg, unsigned mask = 0xF); +void dxb_swz2 (DXBCBuilder* b, char rchar, int reg, unsigned swiz = kSM4SwzNone, bool neg=false); +int dxb_imm_f4 (DXBCBuilder* b, float v0, float v1, float v2, float v3); +SM2Opcode dxb_to_sm2 (SM4Opcode op); + + +struct DXBCBuilderStream +{ + //no shader builder and no auto SM20 code for raw code works + DXBCBuilderStream (DXBCCodeBuilder* b) : builder(NULL), bldcode(b), noSM2(true) { } + DXBCBuilderStream (DXBCBuilder* b) : builder(b), bldcode(dxb_get_code_builder(b)), noSM2(false) { } + + DXBCBuilderStream& op(SM4Opcode op) + { + dxb_op(bldcode, op, false); + if (!noSM2 && builder) + dxb_op2(builder, dxb_to_sm2(op), false); + return *this; + } + DXBCBuilderStream& op_sat(SM4Opcode op, int scratchTmpRegForSM2) + { + dxb_op(bldcode, op, true); + if (!noSM2 && builder) + dxb_op2(builder, dxb_to_sm2(op), true, scratchTmpRegForSM2); + return *this; + } + DXBCBuilderStream& reg (char rchar, int reg, unsigned mask = 0xF) + { + dxb_reg(bldcode, rchar, reg, mask); + if (!noSM2 && builder) + dxb_reg2(builder, rchar, reg, mask); + return *this; + } + DXBCBuilderStream& swz (char rchar, int reg, unsigned swiz = kSM4SwzNone, bool neg=false) + { + dxb_swz(bldcode, rchar, reg, swiz, neg); + if (!noSM2 && builder) + dxb_swz2(builder, rchar, reg, swiz, neg); + return *this; + } + DXBCBuilderStream& float1 (float v) + { + dxb_float1(bldcode, v); + + if (!noSM2 && builder) + { + const int reg = dxb_imm_f4 (builder, v, v, v, v); + dxb_swz2(builder, 'c', reg, kSM4SwzRepX); + } + return *this; + } + // float1 constant for SM2 only + DXBCBuilderStream& float1_2 (float v) + { + if (builder) + { + const int reg = dxb_imm_f4 (builder, v, v, v, v); + dxb_swz2(builder, 'c', reg, kSM4SwzRepX); + } + return *this; + } + DXBCBuilderStream& float4 (float v0, float v1, float v2, float v3) + { + dxb_float4(bldcode, v0, v1, v2, v3); + + if (!noSM2 && builder) + { + const int reg = dxb_imm_f4 (builder, v0, v1, v2, v3); + dxb_swz2(builder, 'c', reg); + } + return *this; + } + + + //------------------------------------------------------------------------------------ + //SM 2.0 stuff + + DXBCBuilderStream& op2(SM2Opcode op) + { + dxb_op2(builder, op, false); + return *this; + } + DXBCBuilderStream& reg2 (char rchar, int reg, unsigned mask = 0xF) + { + dxb_reg2(builder, rchar, reg, mask); + return *this; + } + DXBCBuilderStream& swz2 (char rchar, int reg, unsigned swiz = kSM4SwzNone, bool neg=false) + { + dxb_swz2(builder, rchar, reg, swiz, neg); + return *this; + } + void noAutoSM2(bool _noSM2=true) + { + noSM2 = _noSM2; + } + void autoSM2() + { + noSM2 = false; + } + + DXBCBuilder* builder; + DXBCCodeBuilder* bldcode; + bool noSM2; +}; + diff --git a/Runtime/GfxDevice/d3d11/D3D11Compiler.cpp b/Runtime/GfxDevice/d3d11/D3D11Compiler.cpp new file mode 100644 index 0000000..5cda3d7 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11Compiler.cpp @@ -0,0 +1,2 @@ +#include "UnityPrefix.h" +#include "D3D11Compiler.h" diff --git a/Runtime/GfxDevice/d3d11/D3D11Compiler.h b/Runtime/GfxDevice/d3d11/D3D11Compiler.h new file mode 100644 index 0000000..93284b2 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11Compiler.h @@ -0,0 +1,117 @@ +#pragma once + +#if UNITY_WIN + +#if UNITY_WP8 + +#pragma message("WP8 TODO: implement") // ?!- + +#define kD3D11CompilerDLL "dummy.dll" // ?!- + +struct D3D11Compiler // ?!- +{ +public: + void Initialize (const char* dllName) {} + void Shutdown () {} + bool IsValid() const { return false; } +}; + +#else + +#if UNITY_WINRT +#include <d3dcompiler.h> +#else +#include "External/DirectX/builds/dx11include/d3d11.h" +#endif + +#if UNITY_WINRT +#define kD3D11CompilerDLL "D3DCompiler_45.dll" +#else +#define kD3D11CompilerDLL "D3DCompiler_43.dll" +#endif + +struct D3D11Compiler +{ +public: + #if UNITY_WINRT + typedef HRESULT (WINAPI* D3DCompileFunc)( + _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, + _Out_ ID3DBlob** ppCode, + _Out_opt_ ID3DBlob** ppErrorMsgs); + + typedef HRESULT (WINAPI* D3DStripShaderFunc)( + _In_reads_bytes_(BytecodeLength) LPCVOID pShaderBytecode, + _In_ SIZE_T BytecodeLength, + _In_ UINT uStripFlags, + _Out_ ID3DBlob** ppStrippedBlob); + + typedef HRESULT (WINAPI* D3DReflectFunc)( + _In_reads_bytes_(SrcDataSize) LPCVOID pSrcData, + _In_ SIZE_T SrcDataSize, + _In_ REFIID pInterface, + _Out_ void** ppReflector); + #else + typedef HRESULT (WINAPI *D3DCompileFunc)( + const void* pSrcData, + unsigned long SrcDataSize, + const char* pFileName, + const D3D10_SHADER_MACRO* pDefines, + ID3D10Include* pInclude, + const char* pEntrypoint, + const char* pTarget, + UINT Flags1, + UINT Flags2, + ID3D10Blob** ppCode, + ID3D10Blob** ppErrorMsgs); + + typedef HRESULT (WINAPI *D3DStripShaderFunc)( + __in_bcount(BytecodeLength) const void* pShaderBytecode, + __in unsigned long BytecodeLength, + __in unsigned int uStripFlags, + __out ID3D10Blob** ppStrippedBlob); + + typedef HRESULT (WINAPI *D3DReflectFunc)( + __in_bcount(SrcDataSize) const void* pSrcData, + __in unsigned long SrcDataSize, + __in REFIID pInterface, + __out void** ppReflector); + #endif + + typedef HRESULT (WINAPI *D3DDisassembleFunc)( + __in const void* pSrcData, + __in SIZE_T SrcDataSize, + __in UINT Flags, + __in const char* szComments, + __out ID3D10Blob** ppDisassembly); + + typedef HRESULT (WINAPI *D3DCreateBlobFunc)(SIZE_T size, ID3D10Blob** blob); + +public: + void Initialize (const char* dllName); + void Shutdown (); + bool IsValid() const { return compileFunc && reflectFunc; } + +public: + #if !UNITY_WINRT + HINSTANCE dll; + #endif + D3DCompileFunc compileFunc; + D3DStripShaderFunc stripShaderFunc; + D3DReflectFunc reflectFunc; + D3DDisassembleFunc disassembleFunc; + D3DCreateBlobFunc createBlobFunc; +}; + +extern GUID kIID_ID3D11ShaderReflection; + +#endif + +#endif // UNITY_WIN diff --git a/Runtime/GfxDevice/d3d11/D3D11Context.cpp b/Runtime/GfxDevice/d3d11/D3D11Context.cpp new file mode 100644 index 0000000..06abd9b --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11Context.cpp @@ -0,0 +1,610 @@ +#include "UnityPrefix.h" + +#if !UNITY_WP8 && !UNITY_METRO + +#include "D3D11Context.h" +#include "Runtime/GfxDevice/GfxDevice.h" +#include "Runtime/Shaders/GraphicsCaps.h" +#include "Runtime/Profiler/ExternalGraphicsProfiler.h" +#include "D3D11Includes.h" +#include "D3D11Utils.h" +#include "TexturesD3D11.h" +#include "TimerQueryD3D11.h" +#include "Runtime/Misc/QualitySettings.h" +#include "Runtime/Math/ColorSpaceConversion.h" +#include "Runtime/Utilities/ArrayUtility.h" +#include "Runtime/Utilities/LogUtility.h" +#include "PlatformDependent/Win/ComPtr.h" +#include "Runtime/Utilities/Argv.h" + + +SupportedFeatureLevels GetSupportedFeatureLevels() +{ + SupportedFeatureLevels features; + + if (HasARGV("force-feature-level-9-1")) features.push_back(D3D_FEATURE_LEVEL_9_1); + if (HasARGV("force-feature-level-9-2")) features.push_back(D3D_FEATURE_LEVEL_9_2); + if (HasARGV("force-feature-level-9-3")) features.push_back(D3D_FEATURE_LEVEL_9_3); + if (HasARGV("force-feature-level-10-0")) features.push_back(D3D_FEATURE_LEVEL_10_0); + if (HasARGV("force-feature-level-10-1")) features.push_back(D3D_FEATURE_LEVEL_10_1); + if (HasARGV("force-feature-level-11-0")) features.push_back(D3D_FEATURE_LEVEL_11_0); + + features.push_back(D3D_FEATURE_LEVEL_11_0); + features.push_back(D3D_FEATURE_LEVEL_10_1); + features.push_back(D3D_FEATURE_LEVEL_10_0); + + return features; +} + +#if ENABLE_PROFILER +D3D11PERF_BeginEventFunc g_D3D11BeginEventFunc = NULL; +D3D11PERF_EndEventFunc g_D3D11EndEventFunc = NULL; +#endif + +using namespace win; + +#if !UNITY_RELEASE +#define UNITY_DX11_CREATE_FLAGS D3D11_CREATE_DEVICE_DEBUG +#else +#define UNITY_DX11_CREATE_FLAGS 0 +#endif + + +static D3D_FEATURE_LEVEL kSupportedFeatureLevels[] = { + D3D_FEATURE_LEVEL_11_0, + D3D_FEATURE_LEVEL_10_1, + D3D_FEATURE_LEVEL_10_0, +}; + + +bool InitD3D11RenderDepthSurface (RenderDepthSurfaceD3D11& rs, TexturesD3D11* textures, bool sampleOnly); + + +static ComPtr<ID3D11Device> s_Device = NULL; +// DX11.1 runtime only. On older runtimes this will stay null. Internally accessed by GetGfxDevice11_1(). +static ComPtr<ID3D11Device1> s_Device11_1; + +static ID3D11DeviceContext* s_Context = NULL; +static IDXGIFactory* s_DXGIFactory = NULL; +IDXGIFactory* GetDXGIFactory() { return s_DXGIFactory; } +static IDXGISwapChain* s_SwapChain = NULL; +static IDXGIOutput* s_Output = NULL; +static int s_SwapChainAA = -1; +IDXGISwapChain* GetD3D11SwapChain() { return s_SwapChain; } + +static int s_SyncInterval = 0; +int GetD3D11SyncInterval() { return s_SyncInterval; } + +static RenderColorSurfaceD3D11 s_BackBuffer; +static RenderDepthSurfaceD3D11 s_DepthStencil; + +ID3D11RenderTargetView* g_D3D11CurrRT; +ID3D11DepthStencilView* g_D3D11CurrDS; +ID3D11Resource* g_D3D11CurrRTResource; +ID3D11Resource* g_D3D11CurrDSResource; +RenderColorSurfaceD3D11* g_D3D11CurrColorRT; +RenderDepthSurfaceD3D11* g_D3D11CurrDepthRT; +int g_D3D11Adapter = 0; +int g_D3D11Output = 0; + +static HWND s_Window = NULL; +static HINSTANCE s_D3DDll = NULL; +static HINSTANCE s_D3D9Dll = NULL; +static HINSTANCE s_DXGIDll = NULL; +static bool s_CurrentlyWindowed = true; + +typedef HRESULT (WINAPI* D3D11CreateDeviceFunc)( + IDXGIAdapter *pAdapter, + D3D_DRIVER_TYPE DriverType, + HMODULE Software, + UINT Flags, + CONST D3D_FEATURE_LEVEL *pFeatureLevels, + UINT FeatureLevels, + UINT SDKVersion, + ID3D11Device **ppDevice, + D3D_FEATURE_LEVEL *pFeatureLevel, + ID3D11DeviceContext **ppImmediateContext +); + +typedef HRESULT (WINAPI* CreateDXGIFactoryFunc)( + REFIID ridd, + void** ppFactory +); + +// Either selects default adapter (NULL) or n-th one, +// defined by adapterIndex. Returned adapter +// must be released if not NULL! +static IDXGIAdapter* SelectAdapter (int adapterIndex) +{ + s_DXGIDll = LoadLibrary( "dxgi.dll" ); + if( !s_DXGIDll ) + return NULL; + + CreateDXGIFactoryFunc createDXGIFactory = (CreateDXGIFactoryFunc)GetProcAddress( s_DXGIDll, "CreateDXGIFactory" ); + if( !createDXGIFactory ) + return NULL; + + IDXGIAdapter* adapter = NULL; + if ( SUCCEEDED(createDXGIFactory(__uuidof(IDXGIFactory), (void**)&s_DXGIFactory)) ) + { + for ( int i = 0; SUCCEEDED(s_DXGIFactory->EnumAdapters(i, &adapter)); ++i ) + { + if ( i == adapterIndex ) + break; + else + adapter->Release(); + } + } + + return adapter; +} + +// Selects default output (NULL) or the one defined by outputIndex. +// Result must be released! +static IDXGIOutput* SelectOutput (IDXGIAdapter* adapter, int outputIndex) +{ + if (outputIndex == 0) + return NULL; + + Assert(adapter); + + IDXGIOutput* output = NULL; + for ( int i = 0; SUCCEEDED(adapter->EnumOutputs(i, &output)); ++i ) + { + if ( i == outputIndex ) + break; + else + output->Release(); + } + + return output; +} + +bool InitializeD3D11 () +{ + AssertIf (s_Device || s_Context || s_Window || s_D3DDll || s_D3D9Dll || s_DXGIDll); + + SupportedFeatureLevels features = GetSupportedFeatureLevels(); + IDXGIAdapter* adapter = NULL; + + s_D3DDll = LoadLibrary( "d3d11.dll" ); + if (!s_D3DDll) + { + printf_console ("d3d11: no D3D11 installed\n"); + goto _cleanup; + } + + D3D11CreateDeviceFunc createFunc = (D3D11CreateDeviceFunc)GetProcAddress( s_D3DDll, "D3D11CreateDevice" ); + if( !createFunc ) + { + printf_console ("d3d11: D3D11CreateDevice not found\n"); + goto _cleanup; + } + + + DWORD d3d11CreateFlags = 0; + if (!HasARGV("force-d3d11-no-singlethreaded")) + { + d3d11CreateFlags |= D3D11_CREATE_DEVICE_SINGLETHREADED; + } + + adapter = SelectAdapter (g_D3D11Adapter); + if (adapter) + s_Output = SelectOutput (adapter, g_D3D11Output); + + // create D3D device & immediate context, + // with debug layer in Debug config + HRESULT hr = E_FAIL; + D3D_FEATURE_LEVEL level; + D3D_DRIVER_TYPE driverType = adapter ? D3D_DRIVER_TYPE_UNKNOWN : D3D_DRIVER_TYPE_HARDWARE; + #if !UNITY_RELEASE + hr = createFunc ( + adapter, driverType, NULL, + d3d11CreateFlags | D3D11_CREATE_DEVICE_DEBUG, + &features[0], + features.size(), + D3D11_SDK_VERSION, &s_Device, &level, &s_Context + ); + #endif + // create without debug layer if the above failed or was not called at all + if (FAILED(hr)) + { + hr = createFunc ( + adapter, driverType, NULL, + d3d11CreateFlags, + &features[0], features.size(), + D3D11_SDK_VERSION, &s_Device, &level, &s_Context + ); + } + if (FAILED(hr)) + { + printf_console( "d3d11: failed to create D3D11 device (0x%08x)\n", hr ); + goto _cleanup; + } + + SAFE_RELEASE(adapter); + + // Query DX11.1 interface, may well fail for older runtimes and is silently ignored. + s_Device->QueryInterface(&s_Device11_1); + + // Create DXGIFactory if it isn't already created by SelectAdapter + if (!s_DXGIFactory) + { + IDXGIDevice* dxgiDevice = NULL; + hr = s_Device->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice); + IDXGIAdapter* dxgiAdapter = NULL; + hr = dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&dxgiAdapter); + hr = dxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&s_DXGIFactory); + dxgiAdapter->Release(); + dxgiDevice->Release(); + } + + + #if ENABLE_PROFILER + // Even on D3D11, PIX event marker functions are in D3D9 DLL + s_D3D9Dll = LoadLibrary ("d3d9.dll"); + if (s_D3D9Dll) + { + g_D3D11BeginEventFunc = (D3D11PERF_BeginEventFunc)GetProcAddress(s_D3D9Dll, "D3DPERF_BeginEvent"); + g_D3D11EndEventFunc = (D3D11PERF_EndEventFunc)GetProcAddress(s_D3D9Dll, "D3DPERF_EndEvent"); + } + #endif + + return true; + +_cleanup: + SAFE_RELEASE(adapter); + SAFE_RELEASE(s_Output); + SAFE_RELEASE(s_DXGIFactory); + + s_Device11_1.Free(); + s_Device.Free(); + + SAFE_RELEASE(s_Context); + + if (s_D3DDll) { + FreeLibrary (s_D3DDll); + s_D3DDll = NULL; + } + if (s_D3D9Dll) { + FreeLibrary (s_D3D9Dll); + s_D3D9Dll = NULL; + } + if (s_DXGIDll) { + FreeLibrary (s_DXGIDll); + s_DXGIDll = NULL; + } + return false; +} + + +void CleanupD3D11() +{ + AssertIf (((ID3D11Device *)s_Device) || s_Context || s_Window); + + if (s_D3DDll) + { + FreeLibrary (s_D3DDll); + s_D3DDll = NULL; + } + if (s_D3D9Dll) + { + FreeLibrary (s_D3D9Dll); + s_D3D9Dll = NULL; + } + if (s_DXGIDll) { + FreeLibrary (s_DXGIDll); + s_DXGIDll = NULL; + } +} + +static void ReleaseBackbufferResources() +{ + //NESTED_LOG("DX11 debug", "ReleaseBackbufferResources"); + + Assert(s_Device && s_Context); + + #if ENABLE_PROFILER + g_TimerQueriesD3D11.ReleaseAllQueries(); + #endif + + SAFE_RELEASE(s_DepthStencil.m_Texture); + SAFE_RELEASE(s_DepthStencil.m_SRView); + SAFE_RELEASE(s_DepthStencil.m_DSView); + s_BackBuffer.Reset(); + + if (s_Context) + s_Context->OMSetRenderTargets(0, NULL, NULL); +} + + +static void CreateBackbufferResources(GfxDevice* device, int width, int height, int antiAlias, DXGI_FORMAT swapFormat, bool sRGB) +{ + //NESTED_LOG("DX11 debug", "CreateBackbufferResources %ix%i", width, height); + + HRESULT hr; + + // Set the Backbuffer primary format flags + s_BackBuffer.flags = sRGB ? (s_BackBuffer.flags | kSurfaceCreateSRGB) : (s_BackBuffer.flags & ~kSurfaceCreateSRGB); + + // Backbuffer + s_BackBuffer.width = width; + s_BackBuffer.height = height; + s_BackBuffer.samples = antiAlias; + s_BackBuffer.backBuffer = true; + s_BackBuffer.format = kRTFormatARGB32; + + hr = s_SwapChain->GetBuffer (0, __uuidof(*s_BackBuffer.m_Texture), (void**)&s_BackBuffer.m_Texture); + Assert(SUCCEEDED(hr)); + SetDebugNameD3D11 (s_BackBuffer.m_Texture, Format("SwapChain-BackBuffer-Texture-%dx%d", width, height)); + + // Create the primary backbuffer view + ID3D11RenderTargetView* rtv = NULL; + D3D11_RENDER_TARGET_VIEW_DESC rtDesc; + rtDesc.Format = sRGB ? DXGI_FORMAT_R8G8B8A8_UNORM_SRGB : DXGI_FORMAT_R8G8B8A8_UNORM; + rtDesc.ViewDimension = antiAlias > 1 ? D3D11_RTV_DIMENSION_TEXTURE2DMS : D3D11_RTV_DIMENSION_TEXTURE2D; + rtDesc.Texture2D.MipSlice = 0; + hr = s_Device->CreateRenderTargetView (s_BackBuffer.m_Texture, &rtDesc, &rtv); + s_BackBuffer.SetRTV (0, 0, false, rtv); + Assert(SUCCEEDED(hr)); + SetDebugNameD3D11 (rtv, Format("SwapChain-BackBuffer-RTV-%dx%d", width, height)); + + // Create the secondary backbuffer view + D3D11_RENDER_TARGET_VIEW_DESC rtDescSecondary; + rtDescSecondary.Format = !sRGB ? DXGI_FORMAT_R8G8B8A8_UNORM_SRGB : DXGI_FORMAT_R8G8B8A8_UNORM; + rtDescSecondary.ViewDimension = antiAlias > 1 ? D3D11_RTV_DIMENSION_TEXTURE2DMS : D3D11_RTV_DIMENSION_TEXTURE2D; + rtDescSecondary.Texture2D.MipSlice = 0; + hr = s_Device->CreateRenderTargetView (s_BackBuffer.m_Texture, &rtDescSecondary, &rtv); + s_BackBuffer.SetRTV (0, 0, true, rtv); + Assert(SUCCEEDED(hr)); + SetDebugNameD3D11 (rtv, Format("SwapChain-BackBuffer-RTVSec-%dx%d", width, height)); + + if (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0) + { + // Create shader resource view + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = swapFormat; + srvDesc.ViewDimension = antiAlias > 1 ? D3D11_SRV_DIMENSION_TEXTURE2DMS : D3D11_SRV_DIMENSION_TEXTURE2D; + srvDesc.Texture2D.MostDetailedMip = 0; + srvDesc.Texture2D.MipLevels = 1; + + ID3D11ShaderResourceView* srView = NULL; + hr = s_Device->CreateShaderResourceView (s_BackBuffer.m_Texture, &srvDesc, &s_BackBuffer.m_SRView); + Assert (SUCCEEDED(hr)); + SetDebugNameD3D11 (s_BackBuffer.m_SRView, Format("SwapChain-BackBuffer-SRV-%dx%d", width, height)); + } + + // Depth stencil + s_DepthStencil.width = width; + s_DepthStencil.height = height; + s_DepthStencil.samples = antiAlias; + s_DepthStencil.dim = kTexDim2D; + s_DepthStencil.backBuffer = true; + s_DepthStencil.depthFormat = device->GetFramebufferDepthFormat(); + { + bool dsOk = InitD3D11RenderDepthSurface (s_DepthStencil, NULL, false); + Assert (dsOk); + } + +#if !UNITY_EDITOR + RenderSurfaceHandle bbHandle(&s_BackBuffer), dsHandle(&s_DepthStencil); + device->SetRenderTargets(1, &bbHandle, dsHandle); +#endif + + #if ENABLE_PROFILER + if (gGraphicsCaps.hasTimerQuery) + g_TimerQueriesD3D11.RecreateAllQueries(); + #endif +} + + +bool InitializeOrResetD3D11SwapChain( + class GfxDevice* device, + HWND window, int width, int height, + int refreshRate, bool fullscreen, int vsynccount, int antiAlias, + int& outBackbufferBPP, int& outFrontbufferBPP, int& outDepthBPP, int& outFSAA ) +{ + Assert(s_Device && s_Context); + + ReleaseBackbufferResources(); + + outBackbufferBPP = 4; + outFrontbufferBPP = 4; + outDepthBPP = 4; + outFSAA = 0; + + device->SetCurrentWindowSize (width, height); + + // pick supported AA level + if (antiAlias == -1) + antiAlias = GetQualitySettings().GetCurrent().antiAliasing; + while (antiAlias > 1 && !(gGraphicsCaps.d3d11.msaa & (1<<antiAlias))) + --antiAlias; + antiAlias = std::max(antiAlias, 1); + + const bool sRGB = GetActiveColorSpace() == kLinearColorSpace; + + // Release old swap chain if we need to change AA + if (s_SwapChain && s_SwapChainAA != antiAlias) + { + // swap chain must go out of fullscreen before releasing it + s_SwapChain->SetFullscreenState (FALSE, NULL); + SAFE_RELEASE(s_SwapChain); + } + + // Create Swap Chain + HRESULT hr; + + DWORD swapFlags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; + DXGI_FORMAT swapFormat = sRGB ? DXGI_FORMAT_R8G8B8A8_UNORM_SRGB : DXGI_FORMAT_R8G8B8A8_UNORM; + s_SwapChainAA = antiAlias; + s_SyncInterval = vsynccount; + if (!s_SwapChain) + { + //NESTED_LOG("DX11 debug", "InitializeOrResetD3D11SwapChain, init %ix%i, window %p", width, height, window); + + DXGI_SWAP_CHAIN_DESC sd; + ZeroMemory (&sd, sizeof(sd)); + sd.BufferCount = 1; + sd.BufferDesc.Width = width; + sd.BufferDesc.Height = height; + sd.BufferDesc.Format = swapFormat; + sd.BufferDesc.RefreshRate.Numerator = refreshRate; + sd.BufferDesc.RefreshRate.Denominator = 1; + sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + if (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0) + sd.BufferUsage |= DXGI_USAGE_SHADER_INPUT; + sd.Flags = swapFlags; + sd.OutputWindow = window; + sd.SampleDesc.Count = antiAlias; + sd.SampleDesc.Quality = 0; + // Docs suggest always setting this to true and then doing SetFullscreenState + sd.Windowed = TRUE; + hr = s_DXGIFactory->CreateSwapChain (s_Device, &sd, &s_SwapChain); + Assert(SUCCEEDED(hr)); + + // We'll handle Alt-Enter and other things ourselves + DWORD dxgiFlags = DXGI_MWA_NO_ALT_ENTER | DXGI_MWA_NO_WINDOW_CHANGES; + s_DXGIFactory->MakeWindowAssociation (window, dxgiFlags); + + if (fullscreen) + s_SwapChain->SetFullscreenState(TRUE, s_Output); + + CreateBackbufferResources(device, width, height, antiAlias, swapFormat, sRGB); + } + else + { + DXGI_MODE_DESC mode; + mode.Width = width; + mode.Height = height; + mode.RefreshRate.Numerator = refreshRate; + mode.RefreshRate.Denominator = 1; + mode.Format = swapFormat; + mode.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; + mode.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; + + //NESTED_LOG("DX11 debug", "InitializeOrResetD3D11SwapChain, resize %ix%i, fs=%i, window %p", width, height, fullscreen, window); + + // Note: the following will often call WM_SIZE on us, which will handle actual resizing (since size might be slightly different!), + // which will go into ResizeSwapD3D11SwapChain. + + { + //NESTED_LOG("DX11 debug", "ResizeTarget 1st"); + s_SwapChain->ResizeTarget (&mode); + } + { + //NESTED_LOG("DX11 debug", "SetFullscreenState"); + s_SwapChain->SetFullscreenState (fullscreen, fullscreen ? s_Output : NULL); + } + + // according to "DXGI: Best Practices" on MSDN, advisable + // to call resize target again with refresh rate zeroed out. + mode.RefreshRate.Numerator = 0; + mode.RefreshRate.Denominator = 0; + if (fullscreen) + { + //NESTED_LOG("DX11 debug", "ResizeTarget 2nd"); + s_SwapChain->ResizeTarget (&mode); + } + + // In some cases above calls do not post WM_SIZE, so ResizeSwapD3D11SwapChain is not called, + // which means we won't get back buffer. + // If we still don't have back buffer here, just set it up. + if (!s_BackBuffer.m_Texture) + { + CreateBackbufferResources (device, width, height, s_SwapChainAA, swapFormat, sRGB); + } + } + + return true; +} + + +void ResizeSwapD3D11SwapChain (class GfxDevice* device, HWND window, int width, int height) +{ + if (!s_SwapChain) + return; + + const bool hadBackBuffer = (s_DepthStencil.m_Texture != NULL); + if (hadBackBuffer) + ReleaseBackbufferResources(); + + device->SetCurrentWindowSize (width, height); + + const bool sRGB = GetActiveColorSpace() == kLinearColorSpace; + DWORD swapFlags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; + DXGI_FORMAT swapFormat = sRGB ? DXGI_FORMAT_R8G8B8A8_UNORM_SRGB : DXGI_FORMAT_R8G8B8A8_UNORM; + + //NESTED_LOG("DX11 debug", "ResizeSwapD3D11SwapChain, resize %ix%i", width, height); + s_SwapChain->ResizeBuffers (1, width, height, sRGB ? DXGI_FORMAT_R8G8B8A8_UNORM_SRGB : DXGI_FORMAT_R8G8B8A8_UNORM, swapFlags); + + CreateBackbufferResources (device, width, height, s_SwapChainAA, swapFormat, sRGB); +} + + + +void DestroyD3D11Device() +{ + // This can happen when quiting from screen selector - window is not set up yet + if( !((ID3D11Device *)s_Device)|| !s_Context || !s_DXGIFactory ) + return; + + // swap chain must go out of fullscreen before releasing it + if (s_SwapChain) + { + s_SwapChain->SetFullscreenState (FALSE, NULL); + } + + // cleanup + SAFE_RELEASE(s_DepthStencil.m_Texture); + SAFE_RELEASE(s_DepthStencil.m_SRView); + SAFE_RELEASE(s_DepthStencil.m_DSView); + s_BackBuffer.Reset(); + SAFE_RELEASE(s_SwapChain); + + s_Context->ClearState(); + s_Context->Flush(); + + s_Context->Release(); + s_Context = NULL; + + /* + // Helper code to report any live objects + ID3D11Debug *d3dDebug = NULL; + if (SUCCEEDED(s_Device->QueryInterface(__uuidof(ID3D11Debug), (void**)&d3dDebug))) + { + d3dDebug->ReportLiveDeviceObjects(D3D11_RLDO_DETAIL | D3D11_RLDO_SUMMARY); + d3dDebug->Release(); + } + */ + + s_Device11_1.Free(); + s_Device.Free(); + + SAFE_RELEASE(s_Output); + SAFE_RELEASE(s_DXGIFactory); + + s_Window = NULL; +} + +ID3D11Device* GetD3D11Device() +{ + AssertIf( !((ID3D11Device *)s_Device) ); + return s_Device; +} + +ID3D11Device1* GetD3D11_1Device() +{ + return s_Device11_1; +} + + +ID3D11DeviceContext* GetD3D11Context(bool expectNull) +{ + if (!expectNull) + Assert( s_Context ); + return s_Context; +} + +#endif + diff --git a/Runtime/GfxDevice/d3d11/D3D11Context.h b/Runtime/GfxDevice/d3d11/D3D11Context.h new file mode 100644 index 0000000..16134ce --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11Context.h @@ -0,0 +1,65 @@ +#pragma once + +#include "D3D11Includes.h" + +#if UNITY_METRO +#include <windows.ui.xaml.media.dxinterop.h> +#endif + +struct D3D11Compiler; + +bool InitializeD3D11(); +void CleanupD3D11(); +#if UNITY_WP8 +HRESULT UpdateD3D11Device(ID3D11Device1* device, ID3D11DeviceContext1* deviceContext, ID3D11RenderTargetView* renderTargetView, int& width, int& height); +void ActivateD3D11BackBuffer(class GfxDevice* device); +#elif UNITY_METRO +IDXGISwapChain1* CreateSwapChainForXAML(ISwapChainBackgroundPanelNative* panel, int width, int height); +#if UNITY_METRO_VS2013 +IDXGIDevice3* GetIDXGIDevice3(); +#endif +IDXGISwapChain1* CreateSwapChainForD3D(IUnknown* coreWindow, int width, int height); +bool InitializeOrResetD3D11SwapChain( + class GfxDevice* device, + IDXGISwapChain1* chain, int width, int height, int vsynccount, + int& outBackbufferBPP, int& outFrontbufferBPP, int& outDepthBPP, int& outFSAA); +void ActivateD3D11BackBuffer(class GfxDevice* device); +#else +bool InitializeOrResetD3D11SwapChain( + class GfxDevice* device, + HWND window, int width, int height, + int refreshRate, bool fullscreen, int vsynccount, int fsaa, + int& outBackbufferBPP, int& outFrontbufferBPP, int& outDepthBPP, int& outFSAA); +void ResizeSwapD3D11SwapChain (class GfxDevice* device, HWND window, int width, int height); + +#endif + +typedef std::vector<D3D_FEATURE_LEVEL> SupportedFeatureLevels; +SupportedFeatureLevels GetSupportedFeatureLevels(); + +void DestroyD3D11Device(); + +ID3D11Device* GetD3D11Device(); +ID3D11Device1* GetD3D11_1Device(); +ID3D11DeviceContext* GetD3D11Context(bool expectNull = false); + +IDXGIFactory* GetDXGIFactory(); +IDXGISwapChain* GetD3D11SwapChain(); +int GetD3D11SyncInterval(); + +#if ENABLE_DX11_FRAME_LATENCY_WAITABLE_OBJECT +HANDLE GetFrameLatencyWaitableObject(); +void WaitOnSwapChain(); +#endif + +extern ID3D11RenderTargetView* g_D3D11CurrRT; +extern ID3D11DepthStencilView* g_D3D11CurrDS; +struct RenderColorSurfaceD3D11; +struct RenderDepthSurfaceD3D11; +extern RenderColorSurfaceD3D11* g_D3D11CurrColorRT; +extern RenderDepthSurfaceD3D11* g_D3D11CurrDepthRT; + +typedef int (WINAPI* D3D11PERF_BeginEventFunc)(DWORD, LPCWSTR); +typedef int (WINAPI* D3D11PERF_EndEventFunc)(); +extern D3D11PERF_BeginEventFunc g_D3D11BeginEventFunc; +extern D3D11PERF_EndEventFunc g_D3D11EndEventFunc; diff --git a/Runtime/GfxDevice/d3d11/D3D11Context_Metro.cpp b/Runtime/GfxDevice/d3d11/D3D11Context_Metro.cpp new file mode 100644 index 0000000..4c285ff --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11Context_Metro.cpp @@ -0,0 +1,484 @@ +#include "UnityPrefix.h" + +#if UNITY_METRO +#include "D3D11Context.h" +#include "Runtime/GfxDevice/GfxDevice.h" +#include "Runtime/Shaders/GraphicsCaps.h" +#include "Runtime/Profiler/ExternalGraphicsProfiler.h" +#include "D3D11Includes.h" +#include "D3D11Utils.h" +#include "TexturesD3D11.h" +#include "TimerQueryD3D11.h" +#include "Runtime/Misc/QualitySettings.h" +#include "Runtime/Math/ColorSpaceConversion.h" +#include "Runtime/Utilities/ArrayUtility.h" +#include "Runtime/Utilities/LogUtility.h" +#include "PlatformDependent/Win/ComPtr.h" +#include "PlatformDependent/MetroPlayer/AppCallbacks.h" +#include "Runtime/Utilities/Argv.h" + +SupportedFeatureLevels GetSupportedFeatureLevels() +{ + SupportedFeatureLevels features; + + if (HasARGV("force-feature-level-9-1")) features.push_back(D3D_FEATURE_LEVEL_9_1); + if (HasARGV("force-feature-level-9-2")) features.push_back(D3D_FEATURE_LEVEL_9_2); + if (HasARGV("force-feature-level-9-3")) features.push_back(D3D_FEATURE_LEVEL_9_3); + if (HasARGV("force-feature-level-10-0")) features.push_back(D3D_FEATURE_LEVEL_10_0); + if (HasARGV("force-feature-level-10-1")) features.push_back(D3D_FEATURE_LEVEL_10_1); + if (HasARGV("force-feature-level-11-0")) features.push_back(D3D_FEATURE_LEVEL_11_0); + + features.push_back(D3D_FEATURE_LEVEL_11_0); + features.push_back(D3D_FEATURE_LEVEL_10_1); + features.push_back(D3D_FEATURE_LEVEL_10_0); + features.push_back(D3D_FEATURE_LEVEL_9_3); + features.push_back(D3D_FEATURE_LEVEL_9_2); + features.push_back(D3D_FEATURE_LEVEL_9_1); + + return features; +} + +#if ENABLE_PROFILER +D3D11PERF_BeginEventFunc g_D3D11BeginEventFunc = NULL; +D3D11PERF_EndEventFunc g_D3D11EndEventFunc = NULL; +#endif + +using namespace win; + +#if !UNITY_RELEASE && !defined(__arm__) +#define UNITY_DX11_CREATE_FLAGS D3D11_CREATE_DEVICE_DEBUG +#else +#define UNITY_DX11_CREATE_FLAGS 0 +#endif + + +static ComPtr<ID3D11Device1> s_Device; +static ComPtr<ID3D11DeviceContext1> s_Context; +static ComPtr<IDXGIFactory2> s_DXGIFactory; +static IDXGISwapChain1* s_SwapChain = NULL; +#if UNITY_METRO_VS2013 +static IDXGIDevice3* s_DXGIDevice3 = NULL; +#endif +IDXGISwapChain* GetD3D11SwapChain() { return s_SwapChain; } + +static int s_SyncInterval = 0; +int GetD3D11SyncInterval() { return s_SyncInterval; } + +static RenderColorSurfaceD3D11 s_BackBuffer; +static RenderDepthSurfaceD3D11 s_DepthStencil; + +ID3D11RenderTargetView* g_D3D11CurrRT; +ID3D11DepthStencilView* g_D3D11CurrDS; +ID3D11Resource* g_D3D11CurrRTResource; +ID3D11Resource* g_D3D11CurrDSResource; +RenderColorSurfaceD3D11* g_D3D11CurrColorRT; +RenderDepthSurfaceD3D11* g_D3D11CurrDepthRT; + +static const int kSwapChainBackBufferCount = 2; +#if ENABLE_DX11_FRAME_LATENCY_WAITABLE_OBJECT +static bool s_EnableLowLatencyPresentationAPI = true; +static HANDLE s_FrameLatencyWaitableObject = NULL; +static UINT kSwapChainFlags = DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT; +#else +static UINT kSwapChainFlags = 0; +#endif +static const DXGI_FORMAT kSwapChainBackBufferFormat = DXGI_FORMAT_R8G8B8A8_UNORM; + +#define DX_CHECK(HR, ...) if (FAILED(hr)) {ErrorStringMsg(__VA_ARGS__); goto error; } + +bool InitializeD3D11() +{ + HRESULT hr; + + ComPtr<ID3D11Device> device; + ComPtr<ID3D11DeviceContext> context; + ComPtr<IDXGIDevice1> dxgiDevice; + ComPtr<IDXGIAdapter> dxgiAdapter; + + #if UNITY_DX11_CREATE_FLAGS + ComPtr<ID3D11Debug> debug; + #endif + + Assert(!s_Device); + Assert(!s_Context); + Assert(!s_DXGIFactory); + + SupportedFeatureLevels features = GetSupportedFeatureLevels(); + + D3D_DRIVER_TYPE driverType = D3D_DRIVER_TYPE_HARDWARE; + + if (HasARGV("force-driver-type-warp")) + { + driverType = D3D_DRIVER_TYPE_WARP; + } + + DWORD d3d11CreateFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT; + if (!HasARGV("force-d3d11-no-singlethreaded")) + { + d3d11CreateFlags |= D3D11_CREATE_DEVICE_SINGLETHREADED; + } +#if ENABLE_DX11_FRAME_LATENCY_WAITABLE_OBJECT + if (HasARGV("disable-low-latency-presentation-api")) + { + printf_console("Disabling Low Latency presentation API.\n"); + s_EnableLowLatencyPresentationAPI = false; + kSwapChainFlags = 0; + } +#endif + + D3D_FEATURE_LEVEL level; + hr = D3D11CreateDevice( + nullptr, + driverType, + nullptr, + (d3d11CreateFlags | UNITY_DX11_CREATE_FLAGS), + &features[0], + features.size(), + D3D11_SDK_VERSION, + &device, + &level, + &context); + + if (FAILED(hr) && driverType != D3D_DRIVER_TYPE_WARP) + { + WarningStringMsg("D3D11 failed to create with D3D_DRIVER_TYPE_HARDWARE, fallbacking D3D_DRIVER_TYPE_WARP..."); + driverType = D3D_DRIVER_TYPE_WARP; + hr = D3D11CreateDevice( + nullptr, + driverType, + nullptr, + (d3d11CreateFlags | UNITY_DX11_CREATE_FLAGS), + &features[0], + features.size(), + D3D11_SDK_VERSION, + &device, + &level, + &context); + } + + DX_CHECK(hr, "D3D11CreateDevice failed with error 0x%08x ", hr); + + hr = device->QueryInterface(&s_Device); + DX_CHECK(hr, "device->QueryInterface(&s_Device) failed with error 0x%08x ", hr); + + hr = context->QueryInterface(&s_Context); + DX_CHECK(hr, "context->QueryInterface(&s_Context) failed with error 0x%08x ", hr); + + #if UNITY_DX11_CREATE_FLAGS + hr = s_Device->QueryInterface(&debug); + AssertMsg(SUCCEEDED(hr), "s_Device->QueryInterface(&debug) failed failed with error 0x%08x", hr); + + if (SUCCEEDED(hr)) + { + hr = debug->SetFeatureMask(D3D11_DEBUG_FEATURE_FLUSH_PER_RENDER_OP); + AssertMsg(SUCCEEDED(hr), "debug->SetFeatureMask(D3D11_DEBUG_FEATURE_FLUSH_PER_RENDER_OP) failed with error 0x%08x", hr); + } + + #endif + #if UNITY_METRO_VS2013 + hr = s_Device->QueryInterface(__uuidof(IDXGIDevice3), (void**) &s_DXGIDevice3); + DX_CHECK(hr, "s_Device->QueryInterface(__uuidof(IDXGIDevice3), (void**) &s_DXGIDevice3) with error 0x%08x ", hr); + #endif + + hr = s_Device->QueryInterface(&dxgiDevice); + DX_CHECK(hr, "s_Device->QueryInterface(&dxgiDevice) failed with error 0x%08x ", hr); + +#if ENABLE_DX11_FRAME_LATENCY_WAITABLE_OBJECT + // The maximum frame latency should be 1, if game is running at 60 FPS, but because + // most games will probably be running around 30, I guess it's better to set 2 + hr = dxgiDevice->SetMaximumFrameLatency(s_EnableLowLatencyPresentationAPI ? 2 : 1); +#else + hr = dxgiDevice->SetMaximumFrameLatency(1); +#endif + DX_CHECK(hr, "dxgiDevice->SetMaximumFrameLatency(1)) failed with error 0x%08x ", hr); + + hr = dxgiDevice->GetAdapter(&dxgiAdapter); + DX_CHECK(hr, "dxgiDevice->GetAdapter(&dxgiAdapter) failed with error 0x%08x ", hr); + + hr = dxgiAdapter->GetParent(__uuidof(s_DXGIFactory), reinterpret_cast<void**>(&s_DXGIFactory)); // ??? + DX_CHECK(hr, "dxgiAdapter->GetParent(...) failed with error 0x%08x ", hr); + + return true; + + + +error: + + s_DXGIFactory.Free(); + s_Context.Free(); + s_Device.Free(); + + return false; +} + +void GetSwapChainDesc1(DXGI_SWAP_CHAIN_DESC1& sd) +{ + // Found on forums, why BGRA is used here instead of RGBA: + // Microsoft dude - "I believe there are some flip optimizatoin benefits to using BGR rather than RGB." + // Update: So I changed the format to DXGI_FORMAT_R8G8B8A8_UNORM, checked the FPS in one of the games, didn't see any FPS loss + // But because all D3D11 gfxdevice was origanlly tested with DXGI_FORMAT_R8G8B8A8_UNORM, I think it makes sense to have this format instead + // It also makes image effects work correctly, for ex., it fixes bug - https://fogbugz.unity3d.com/default.asp?492440 + sd.Format = kSwapChainBackBufferFormat; + sd.Stereo = FALSE; + sd.SampleDesc.Count = 1; + sd.SampleDesc.Quality = 0; + sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + sd.BufferCount = kSwapChainBackBufferCount; + sd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; + sd.Flags = kSwapChainFlags; + sd.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED; +} +IDXGISwapChain1* CreateSwapChainForXAML(ISwapChainBackgroundPanelNative* panel, int width, int height) +{ + IDXGISwapChain1* chain; + DXGI_SWAP_CHAIN_DESC1 sd; + GetSwapChainDesc1(sd); + + sd.Width = width; + sd.Height = height; + + HRESULT hr; + sd.Scaling = DXGI_SCALING_STRETCH; + hr = s_DXGIFactory->CreateSwapChainForComposition(s_Device, &sd, nullptr, &chain); + DX_CHECK(hr, "CreateSwapChainForComposition failed with error 0x%08x", hr); + +#if UNITY_METRO_VS2013 + UnityPlayer::AppCallbacks::Instance->InvokeOnUIThread(ref new UnityPlayer::AppCallbackItem([panel, chain]() + { + HRESULT hr = panel->SetSwapChain(chain); + if (FAILED(hr)) FatalErrorMsg("SetSwapChain failed with error 0x%08x", hr); + } + ), false); +#else + hr = panel->SetSwapChain(chain); + if (FAILED(hr)) FatalErrorMsg("SetSwapChain failed with error 0x%08x", hr); +#endif + + return chain; +error: + return NULL; +} +IDXGISwapChain1* CreateSwapChainForD3D(IUnknown* coreWindow, int width, int height) +{ + IDXGISwapChain1* chain; + DXGI_SWAP_CHAIN_DESC1 sd; + GetSwapChainDesc1(sd); + + sd.Width = width; + sd.Height = height; + + HRESULT hr; + + sd.Scaling = DXGI_SCALING_STRETCH; + hr = s_DXGIFactory->CreateSwapChainForCoreWindow(s_Device, coreWindow, &sd, nullptr, &chain); + DX_CHECK(hr, "CreateSwapChainForCoreWindow failed with error 0x%08x", hr); + + return chain; +error: + return NULL; +} +bool InitializeOrResetD3D11SwapChain(GfxDevice* device, IDXGISwapChain1* chain, int width, int height, int vsynccount, int& outBackbufferBPP, int& outFrontbufferBPP, int& outDepthBPP, int& outFSAA) +{ + HRESULT hr; + Microsoft::WRL::ComPtr<ID3D11Texture2D> backBuffer; + Microsoft::WRL::ComPtr<ID3D11Texture2D> depthStencil; + + // + + Assert(nullptr != device); + Assert(nullptr != s_Device); + Assert(nullptr != s_Context); + Assert(nullptr != s_DXGIFactory); + + // + + outBackbufferBPP = 4; + outFrontbufferBPP = 4; + outDepthBPP = 4; + outFSAA = 0; + + + SAFE_RELEASE(s_DepthStencil.m_Texture); + SAFE_RELEASE(s_DepthStencil.m_SRView); + SAFE_RELEASE(s_DepthStencil.m_DSView); + s_BackBuffer.Reset(); + + // + + s_Context->OMSetRenderTargets(0, nullptr, nullptr); + s_Context->Flush(); + + s_SyncInterval = vsynccount; + + if (nullptr == s_SwapChain) + { + s_SwapChain = chain; +#if ENABLE_DX11_FRAME_LATENCY_WAITABLE_OBJECT + s_FrameLatencyWaitableObject = s_EnableLowLatencyPresentationAPI ? + ((IDXGISwapChain2*) s_SwapChain)->GetFrameLatencyWaitableObject() : + NULL; +#endif + } + else + { + // Use efficient DX 11.2 swap chain scaling if available +#if 0 && UNITY_METRO_VS2013 + + // Check if new resolution fits into already allocated swap chain + DXGI_SWAP_CHAIN_DESC swapChainDesc; + s_SwapChain->GetDesc(&swapChainDesc); + if (width <= swapChainDesc.BufferDesc.Width && height <= swapChainDesc.BufferDesc.Height) + { + hr = ((IDXGISwapChain2*)s_SwapChain)->SetSourceSize(width, height); + DX_CHECK(hr, "SetSourceSize failed with error 0x%08x", hr); + } + else +#endif + { + // Note: If you set third parameter as DXGI_FORMAT_UNKNOWN, D3D11 debugger incorrectly captures frame when swap chain is resized, for ex., when you perform snapping + hr = s_SwapChain->ResizeBuffers(kSwapChainBackBufferCount, width, height, kSwapChainBackBufferFormat, kSwapChainFlags); + DX_CHECK(hr, "ResizeBuffers failed with error 0x%08x", hr); + } + } + + hr = s_SwapChain->GetBuffer(0, __uuidof(backBuffer), reinterpret_cast<void**>(backBuffer.GetAddressOf())); + DX_CHECK(hr, "s_SwapChain->GetBuffer failed with error 0x%08x", hr); + + D3D11_TEXTURE2D_DESC backBufferDesc; + backBuffer->GetDesc(&backBufferDesc); + + width = backBufferDesc.Width; + height = backBufferDesc.Height; + + s_BackBuffer.m_Texture = backBuffer.Detach(); + s_BackBuffer.width = width; + s_BackBuffer.height = height; + s_BackBuffer.format = kRTFormatARGB32; + + device->SetCurrentWindowSize(width, height); + + ID3D11RenderTargetView* rtv = 0; + hr = s_Device->CreateRenderTargetView(s_BackBuffer.m_Texture, nullptr, &rtv); + DX_CHECK(hr, "CreateRenderTargetView failed with error 0x%08x", hr); + s_BackBuffer.SetRTV(0,0,false,rtv); + + hr = s_Device->CreateTexture2D(&CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_D24_UNORM_S8_UINT, width, height, 1, 1, D3D11_BIND_DEPTH_STENCIL), nullptr, &depthStencil); + DX_CHECK(hr, "CreateTexture2D failed with error 0x%08x", hr); + + device->SetFramebufferDepthFormat(kDepthFormat24); + if (IsGfxDevice()) + GetGfxDevice().SetFramebufferDepthFormat(kDepthFormat24); + + s_DepthStencil.m_Texture = depthStencil.Get(); + + hr = s_Device->CreateDepthStencilView(depthStencil.Get(), &CD3D11_DEPTH_STENCIL_VIEW_DESC(D3D11_DSV_DIMENSION_TEXTURE2D), &s_DepthStencil.m_DSView); // ??? + DX_CHECK(hr, "CreateDepthStencilView failed with error 0x%08x", hr); + + s_BackBuffer.backBuffer = true; + s_DepthStencil.backBuffer = true; + + ActivateD3D11BackBuffer(device); + + return true; + +error: + + SAFE_RELEASE(s_DepthStencil.m_Texture); + SAFE_RELEASE(s_DepthStencil.m_SRView); + SAFE_RELEASE(s_DepthStencil.m_DSView); + s_BackBuffer.Reset(); + + SAFE_RELEASE(s_SwapChain); +#if UNITY_METRO_VS2013 + SAFE_RELEASE(s_DXGIDevice3); +#endif + return false; +} + +void ActivateD3D11BackBuffer(GfxDevice* device) +{ + Assert(nullptr != device); + device->SetRenderTargets(1, &RenderSurfaceHandle(&s_BackBuffer), RenderSurfaceHandle(&s_DepthStencil)); +} + +void DestroyD3D11Device() +{ + // This can happen when quiting from screen selector - window is not set up yet + if( !s_Device || !s_Context || !s_DXGIFactory) + return; + + // swap chain must go out of fullscreen before releasing it + if (s_SwapChain) + { + s_SwapChain->SetFullscreenState (FALSE, NULL); + } + + // cleanup + SAFE_RELEASE(s_DepthStencil.m_Texture); + SAFE_RELEASE(s_DepthStencil.m_SRView); + SAFE_RELEASE(s_DepthStencil.m_DSView); + s_BackBuffer.Reset(); + SAFE_RELEASE(s_SwapChain); +#if UNITY_METRO_VS2013 + SAFE_RELEASE(s_DXGIDevice3); +#endif + s_Context->ClearState(); + s_Context->Flush(); + + s_Context->Release(); + s_Context = NULL; + s_Device->Release(); + s_Device = NULL; + s_DXGIFactory->Release(); + s_DXGIFactory = NULL; +} + +void CleanupD3D11() +{ + AssertIf (s_Device || s_Context); +} + +ID3D11Device* GetD3D11Device() +{ + AssertIf( !s_Device ); + return s_Device; +} + +ID3D11Device1* GetD3D11_1Device() +{ + AssertIf( !s_Device ); + return s_Device; +} + + +ID3D11DeviceContext* GetD3D11Context(bool expectNull) +{ + if (!expectNull) + Assert( s_Context ); + return s_Context; +} +#if ENABLE_DX11_FRAME_LATENCY_WAITABLE_OBJECT +HANDLE GetFrameLatencyWaitableObject() +{ + return s_FrameLatencyWaitableObject; +} +void WaitOnSwapChain() +{ + if (s_EnableLowLatencyPresentationAPI) + { + DWORD result = WaitForSingleObjectEx( + s_FrameLatencyWaitableObject, + 1000, // 1 second timeout (shouldn't ever occur) + true + ); + } +} +#endif + +#if UNITY_METRO_VS2013 +IDXGIDevice3* GetIDXGIDevice3() +{ + return s_DXGIDevice3; +} +#endif +#endif diff --git a/Runtime/GfxDevice/d3d11/D3D11Context_WP8.cpp b/Runtime/GfxDevice/d3d11/D3D11Context_WP8.cpp new file mode 100644 index 0000000..dbf8613 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11Context_WP8.cpp @@ -0,0 +1,233 @@ +#include "UnityPrefix.h" + +#if UNITY_WP8 + +#include "D3D11Context.h" +#include "Runtime/GfxDevice/GfxDevice.h" +#include "Runtime/Shaders/GraphicsCaps.h" +#include "Runtime/Profiler/ExternalGraphicsProfiler.h" +#include "D3D11Includes.h" +#include "D3D11Utils.h" +#include "TexturesD3D11.h" +#include "TimerQueryD3D11.h" +#include "Runtime/Misc/Plugins.h" +#include "Runtime/Misc/QualitySettings.h" +#include "Runtime/Math/ColorSpaceConversion.h" +#include "Runtime/Utilities/ArrayUtility.h" +#include "Runtime/Utilities/LogUtility.h" +#include "Runtime/Utilities/Argv.h" +#include "Runtime/Graphics/ScreenManager.h" + +SupportedFeatureLevels GetSupportedFeatureLevels() +{ + SupportedFeatureLevels features; + + features.push_back(D3D_FEATURE_LEVEL_9_3); + + return features; +} + +#if ENABLE_PROFILER +D3D11PERF_BeginEventFunc g_D3D11BeginEventFunc = NULL; +D3D11PERF_EndEventFunc g_D3D11EndEventFunc = NULL; +#endif + +using namespace Microsoft::WRL; + + +static ComPtr<ID3D11Device1> s_Device; +static ComPtr<ID3D11DeviceContext1> s_Context; + +static RenderColorSurfaceD3D11 s_BackBuffer; +static RenderDepthSurfaceD3D11 s_DepthStencil; + +ID3D11RenderTargetView* g_D3D11CurrRT; +ID3D11DepthStencilView* g_D3D11CurrDS; +ID3D11Resource* g_D3D11CurrRTResource; +ID3D11Resource* g_D3D11CurrDSResource; +RenderColorSurfaceD3D11* g_D3D11CurrColorRT; +RenderDepthSurfaceD3D11* g_D3D11CurrDepthRT; + + +HRESULT UpdateD3D11Device(ID3D11Device1* device, ID3D11DeviceContext1* deviceContext, ID3D11RenderTargetView* renderTargetView, int& width, int& height) +{ + HRESULT hr; + + Assert(device); + + // update device context + + if (deviceContext) + s_Context = deviceContext; + else + device->GetImmediateContext1(s_Context.ReleaseAndGetAddressOf()); + + // update device + + if (s_Device.Get() != device) + { + s_Context->OMSetRenderTargets(0, nullptr, nullptr); + s_BackBuffer.Reset(); + s_DepthStencil.Reset(); + + //@TODO: have to recreate all graphics resources, + // Runtime/GfxDevice/GfxDeviceRecreate.h + // + // CleanupAllGfxDeviceResources should be called while the "old device" is still active; + // RecreateAllGfxDeviceResources should be called when the "new device" is ready. + // + // Right now that works fine (tm) for switching editor between dx9 & dx11 in player settings, + // but possibly needs some adjustment for WP8. + + s_Device = device; + PluginsSetGraphicsDevice(device, kGfxRendererD3D11, kGfxDeviceEventInitialize); + + void RecreateAllGfxDeviceResources(); + + if (deviceContext) + RecreateAllGfxDeviceResources(); + } + + // update render target + + if (renderTargetView) + { + // get back buffer + + ComPtr<ID3D11Texture2D> backBuffer; + + { + ComPtr<ID3D11Resource> resource; + renderTargetView->GetResource(resource.GetAddressOf()); + + hr = resource.As(&backBuffer); + Assert(SUCCEEDED(hr)); + } + + // get description + + D3D11_TEXTURE2D_DESC backBufferDesc; + backBuffer->GetDesc(&backBufferDesc); + + // get actual resolution + + width = backBufferDesc.Width; + height = backBufferDesc.Height; + + bool const sizeChanged = ((s_BackBuffer.width != backBufferDesc.Width) || (s_BackBuffer.height != backBufferDesc.Height)); + + // update back buffer + + s_Context->OMSetRenderTargets(0, nullptr, nullptr); + Assert(DXGI_FORMAT_B8G8R8A8_UNORM == backBufferDesc.Format); + + s_BackBuffer.Reset(); + s_BackBuffer.width = backBufferDesc.Width; + s_BackBuffer.height = backBufferDesc.Height; + s_BackBuffer.backBuffer = true; + s_BackBuffer.format = kRTFormatARGB32; + s_BackBuffer.backBuffer = true; + s_BackBuffer.m_Texture = backBuffer.Detach(); + + s_BackBuffer.SetRTV(0, 0, false, renderTargetView); + renderTargetView->AddRef(); + + // update depth/stencil buffer if sice changed + + if (sizeChanged) + { + s_DepthStencil.Reset(); + + // create depth/stencil texture + + ComPtr<ID3D11Texture2D> depthStencil; + + hr = s_Device->CreateTexture2D(&CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_D24_UNORM_S8_UINT, backBufferDesc.Width, backBufferDesc.Height, 1, 1, D3D11_BIND_DEPTH_STENCIL), nullptr, &depthStencil); + Assert(SUCCEEDED(hr)); + + if (FAILED(hr)) + return hr; + + // create depth/stencil view + + hr = s_Device->CreateDepthStencilView(depthStencil.Get(), &CD3D11_DEPTH_STENCIL_VIEW_DESC(D3D11_DSV_DIMENSION_TEXTURE2D), &s_DepthStencil.m_DSView); // ??? + Assert(SUCCEEDED(hr)); + + if (FAILED(hr)) + return hr; + + // store depth/stencil buffer + + s_DepthStencil.m_Texture = depthStencil.Detach(); + s_DepthStencil.width = backBufferDesc.Width; + s_DepthStencil.height = backBufferDesc.Height; + s_DepthStencil.backBuffer = true; // ?!- + s_DepthStencil.depthFormat = kDepthFormat24; + + GetGfxDevice().SetFramebufferDepthFormat(kDepthFormat24); + } + + // set active render target + + ActivateD3D11BackBuffer(&GetGfxDevice()); // ?!- + } + + return S_OK; +} + +bool InitializeD3D11() +{ + Assert(s_Device); + Assert(s_Context); + return true; +} + +void CleanupD3D11() +{ + Assert(!s_Device); + Assert(!s_Context); +} + +void ActivateD3D11BackBuffer(GfxDevice* device) +{ + Assert(nullptr != device); + device->SetRenderTargets(1, &RenderSurfaceHandle(&s_BackBuffer), RenderSurfaceHandle(&s_DepthStencil)); +} + +void DestroyD3D11Device() +{ + if (!s_Device || !s_Context) + return; + + SAFE_RELEASE(s_DepthStencil.m_Texture); + SAFE_RELEASE(s_DepthStencil.m_SRView); + SAFE_RELEASE(s_DepthStencil.m_DSView); + s_BackBuffer.Reset(); + + s_Context->ClearState(); + s_Context->Flush(); + + s_Context.Reset(); + s_Device.Reset(); +} + +ID3D11Device* GetD3D11Device() +{ + AssertIf(!s_Device); + return s_Device.Get(); +} + +ID3D11Device1* GetD3D11_1Device() +{ + AssertIf( !s_Device ); + return s_Device.Get(); +} + +ID3D11DeviceContext* GetD3D11Context(bool expectNull) +{ + if (!expectNull) + Assert(s_Context); + return s_Context.Get(); +} + +#endif diff --git a/Runtime/GfxDevice/d3d11/D3D11Debug.cpp b/Runtime/GfxDevice/d3d11/D3D11Debug.cpp new file mode 100644 index 0000000..f6ed253 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11Debug.cpp @@ -0,0 +1,282 @@ +#include "UnityPrefix.h" +#include "Configuration/UnityConfigure.h" +#include "D3D11Includes.h" + + +#if ENABLE_DX11_DEBUGGING +#include "Runtime/GfxDevice/GfxDevice.h" +#include "Runtime/GfxDevice/ChannelAssigns.h" +#include "D3D11VBO.h" + + +static bool s_DX11LoggingEnabled = true; +static UInt32 s_DX11CommandCount = 0; +static UInt32 s_Indentation = 0; +static DbgFrameDebugType s_FrameDebugType = kFrameDebugOutputDX11Commands; +//static DbgFrameDebugType s_FrameDebugType = kFrameDebugOutputNone; +static bool s_BreakpointReached = FALSE; + + +void DbgDX11DisableLogging() +{ + s_DX11LoggingEnabled = false; +} +void DbgDX11EnableLogging() +{ + s_DX11LoggingEnabled = true; +} +void DbgDX11LogOutput(const char* format,...) +{ + if (!s_DX11LoggingEnabled || s_FrameDebugType == kFrameDebugOutputNone) return; + + va_list va; + va_start (va, format); + char buffer [1024 * 10]; + vsnprintf (buffer, sizeof(buffer), format, va); + va_end (va); + printf_console("%*s[%d]%s\n", s_Indentation, "", ++s_DX11CommandCount, buffer); + +} + +void DbgDX11IncreaseIndentation() +{ + s_Indentation++; +} +void DbgDX11DecreaseIndentation() +{ + s_Indentation--; +} +void DbgDX11PostOperation() +{ + if (!s_DX11LoggingEnabled) return; +} +void DbgDX11MarkDrawing(UInt32 triCount, UInt32 vertexCount) +{ + if (s_FrameDebugType != kFrameDebugOutputDX11CommandsWithStepping) return; + + printf_console("Submitted draw call, triangle count: %d, vertex count: %d\n", triCount, vertexCount); + printf_console("------------------------------------------------------------------------------------------------\n"); + DbgDX11ShowCurrentGfxState(); + printf_console("------------------------------------------------------------------------------------------------\n"); + + /* + RenderColorSurfaceWiiU* colorSurface = InternalGetActiveRenderColorSurfaceWiiU(0); + if (colorSurface != NULL) + { + DX11SwapBuffers(&colorSurface->colorBuffer); + } + else + { + DX11SwapBuffers(cafe::GetColorBuffer()); + } +// DX11_CHK (DX11SwapBuffers(&s_ColorBuffer)); + + cafe::SetContextState(); + + DX11_CHK (DX11Flush()); + printf_console("A - Contine, B - Cancel, + - Capture screenshot\n"); + + bool done = false; + + while (!done) + { + + switch (cafe::DbgWaitForKey()) + { + case KPAD_BUTTON_A: + done = true; + break; + case KPAD_BUTTON_B: + DbgDX11SetFrameDebug(kFrameDebugOutputNone); + break; + case KPAD_BUTTON_PLUS: + cafe::DbgCaptureScreenshot(); + break; + default: + #if ENABLE_DX11_METRICS + DbgDX11SetBreakpoint(); + DX11ClearGPMetric(); + #endif + break; + } + } + */ +} +void DbgDX11SetFrameDebug(DbgFrameDebugType type) +{ + s_DX11CommandCount = 0; + + switch (s_FrameDebugType) + { + case kFrameDebugOutputDX11CommandsWithStepping: + break; + } + + s_FrameDebugType = type; + + switch (s_FrameDebugType) + { + case kFrameDebugOutputDX11CommandsWithStepping: + break; + } +} + +void DbgDX11MarkFrameBegin() +{ + switch (s_FrameDebugType) + { + case kFrameDebugOutputDX11CommandsWithStepping: + break; + } +} +void DbgDX11MarkFrameEnd() +{ + DbgDX11SetFrameDebug(kFrameDebugOutputNone); +} + + +const char* DbgDX11GetShaderChannelName(ShaderChannel channel) +{ + const char* kShaderChannelStrings[kShaderChannelCount] = { + "kShaderChannelVertex", + "kShaderChannelNormal", + "kShaderChannelColor", + "kShaderChannelTexCoord0", + "kShaderChannelTexCoord1", + "kShaderChannelTangent" + }; + return kShaderChannelStrings[channel]; +} +const char* DbgDX11GetVertexComponentName(VertexComponent comp) +{ + const char* kVertexComponentStrings[kVertexCompCount] = { + "kVertexCompVertex", + "kVertexCompColor", + "kVertexCompNormal", + "kVertexCompTexCoord", + "kVertexCompTexCoord0", "kVertexCompTexCoord1", "kVertexCompTexCoord2", "kVertexCompTexCoord3", + "kVertexCompTexCoord4", "kVertexCompTexCoord5", "kVertexCompTexCoord6", "kVertexCompTexCoord7", + "kVertexCompAttrib0", "kVertexCompAttrib1", "kVertexCompAttrib2", "kVertexCompAttrib3", + "kVertexCompAttrib4", "kVertexCompAttrib5", "kVertexCompAttrib6", "kVertexCompAttrib7", + "kVertexCompAttrib8", "kVertexCompAttrib9", "kVertexCompAttrib10", "kVertexCompAttrib11", + "kVertexCompAttrib12", "kVertexCompAttrib13", "kVertexCompAttrib14", "kVertexCompAttrib15" + }; + return kVertexComponentStrings[comp]; +} +void DbgDX11ShowChannelBindings(const ChannelAssigns& channels, VertexBufferData& data) +{ + /* + DX11_LOG_OUTPUT("VBO layout, VertexStride: %d", data.vertexStride); + for (int i = 0; i < kShaderChannelCount; i++) + { + DX11_LOG_OUTPUT(" [%d] - 0x%08x, Stride: %d (%s)", i, data.channel[i], data.channelStrides[i], DbgDX11GetShaderChannelName((ShaderChannel)i)); + } + for (int i = kVertexCompVertex; i < kVertexCompCount; i++) + { + ShaderChannel sh = channels.GetSourceForTarget((VertexComponent)i); + if (sh != kShaderChannelNone) + { + DX11_LOG_OUTPUT(" Vertex component %d targets %s", i, DbgDX11GetShaderChannelName((ShaderChannel)sh)); + } + } + */ +} +void DbgDX11ShowStridedVertexData(const VertexBufferData& data, void* rawData) +{ + /* + DX11_LOG_OUTPUT("VBO has %d vertices with stride %d", data.vertexCount, data.vertexStride); + + UInt8* p = (UInt8*) rawData; + + int offset[kShaderChannelCount]; + int curOffset = 0; + for (int i = 0; i < kShaderChannelCount; i++) + { + if (data.channel[i] == NULL) offset[i] = -1; + else + { + offset[i] = curOffset; + curOffset += VBO::GetChannelByteSize(i); + } + } + Assert (VBO::GetChannelByteSize(kShaderChannelVertex) == sizeof(Vector3f)); + Assert (VBO::GetChannelByteSize(kShaderChannelNormal) == sizeof(Vector3f)); + Assert (VBO::GetChannelByteSize(kShaderChannelColor) == sizeof(ColorRGBA32)); + Assert (VBO::GetChannelByteSize(kShaderChannelTexCoord0) == sizeof(Vector2f)); + Assert (VBO::GetChannelByteSize(kShaderChannelTexCoord1) == sizeof(Vector2f)); + Assert (VBO::GetChannelByteSize(kShaderChannelTangent) == sizeof(Vector4f)); + for (int i = 0; i < data.vertexCount; i++) + { + if (offset[kShaderChannelVertex] != -1) + { + Vector3f v = *(Vector3f*)(p + offset[kShaderChannelVertex] + i * data.vertexStride); + DX11_LOG_OUTPUT("[%d - Vertex] - %.2f %.2f %.2f", i, v.x, v.y, v.z); + } + + if (offset[kShaderChannelNormal] != -1) + { + Vector3f n = *(Vector3f*)(p + offset[kShaderChannelNormal] + i * data.vertexStride); + DX11_LOG_OUTPUT("[%d - Normal] - %.2f %.2f %.2f", i, n.x, n.y, n.z); + } + if (offset[kShaderChannelColor] != -1) + { + ColorRGBA32 c = *(ColorRGBA32*)(p + offset[kShaderChannelColor] + i * data.vertexStride); + DX11_LOG_OUTPUT("[%d - Color] - %d %d %d %d", i, c.r, c.g, c.b, c.a); + } + if (offset[kShaderChannelTexCoord0] != -1) + { + Vector2f uv = *(Vector2f*)(p + offset[kShaderChannelTexCoord0] + i * data.vertexStride); + DX11_LOG_OUTPUT("[%d - UV0] - %.2f %.2f", i, uv.x, uv.x, uv.y); + } + if (offset[kShaderChannelTexCoord1] != -1) + { + Vector2f uv = *(Vector2f*)(p + offset[kShaderChannelTexCoord1] + i * data.vertexStride); + DX11_LOG_OUTPUT("[%d - UV1] - %.2f %.2f", i, uv.x, uv.x, uv.y); + } + if (offset[kShaderChannelTangent] != -1) + { + Vector4f t = *(Vector4f*)(p + offset[kShaderChannelTangent] + i * data.vertexStride); + DX11_LOG_OUTPUT("[%d - Tangent] - %.2f %.2f %.2f %.2f", i, t.x, t.y, t.z, t.w); + } + } + */ + FatalErrorMsg("Stop"); +} +void DbgDX11ShowStridedIndexData(const IndexBufferData& data, void* rawData) +{ + /* + DX11_LOG_OUTPUT("VBO has %d indices with stride %d", data.count, data.stride); + UInt8* p = (UInt8*) rawData; + for (int i = 0; i < data.count; i++) + { + Assert (data.stride == sizeof(UInt16)); + DX11_LOG_OUTPUT("[%d] - %d", i, *(UInt16*)(p + data.stride * i)); + } + */ + FatalErrorMsg("Stop"); +} + + + +void DbgDX11ShowCurrentGfxState() +{ + /* + const DeviceStateWiiU& state = GetWiiUDeviceState(GetGfxDevice()); + + int blendingEnabled = state.currBlendState->blendingEnabled; + DbgDX11ShowColorControlReg(state.colorControlReg, blendingEnabled); + if (blendingEnabled > 0) + { + DbgDX11ShowBlendControlReg(state.blendControlReg); + } + + DbgDX11ShowTargetChannelMaskReg(state.targetChannelMaskReg); + DbgDX11ShowAlphaTestReg(state.alphaTestReg); + DbgDX11ShowPolygonControlReg(state.polygonControlReg); + //DbgDX11ShowPolygonOffsetReg(state.polygonOffsetReg); + DbgDX11ShowDepthStencilControlReg(state.depthStencilReg); + */ +} + + +#endif diff --git a/Runtime/GfxDevice/d3d11/D3D11Debug.h b/Runtime/GfxDevice/d3d11/D3D11Debug.h new file mode 100644 index 0000000..1f57adf --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11Debug.h @@ -0,0 +1,54 @@ +#pragma once + +#define ENABLE_DX11_DEBUGGING (!UNITY_RELEASE && UNITY_METRO) && 0 + +#if ENABLE_DX11_DEBUGGING + + enum DbgFrameDebugType + { + kFrameDebugOutputNone, + kFrameDebugOutputDX11Commands, + kFrameDebugOutputDX11CommandsWithStepping + }; + + void DbgDX11DisableLogging(); + void DbgDX11EnableLogging(); + void DbgDX11LogOutput(const char* format,...); + void DbgDX11IncreaseIndentation(); + void DbgDX11DecreaseIndentation(); + void DbgDX11MarkDrawing(UInt32 triCount, UInt32 vertexCount); + void DbgDX11MarkFrameBegin(); + void DbgDX11MarkFrameEnd(); + void DbgDX11ShowCurrentGfxState(); + + class DbgDX11AutoIndentation + { + public: + DbgDX11AutoIndentation() {DbgDX11IncreaseIndentation();} + ~DbgDX11AutoIndentation() {DbgDX11DecreaseIndentation();} + }; + + inline const char* GetDX11BoolString (bool val) {return val == true ? "true" : "false";} + + #define DX11_DISABLE_LOGGING() DbgDX11DisableLogging() + #define DX11_ENABLE_LOGGING() DbgDX11EnableLogging() + #define DX11_LOG_OUTPUT(...) DbgDX11LogOutput(__VA_ARGS__); + #define DX11_LOG_ENTER_FUNCTION(...) DbgDX11LogOutput(__VA_ARGS__); DbgDX11AutoIndentation sDbgDX11AutoIndentation; + #define DX11_MARK_DRAWING(TriCount, VertexCount) DbgDX11MarkDrawing(TriCount, VertexCount); + #define DX11_MARK_FRAME_BEGIN() DbgDX11MarkFrameBegin(); + #define DX11_MARK_FRAME_END() DbgDX11MarkFrameEnd(); + #define DX11_CHK(x) {DbgDX11LogOutput(#x); x; } + +#else + #define DX11_DISABLE_LOGGING() {} + #define DX11_ENABLE_LOGGING() {} + #define DX11_LOG_OUTPUT(...) {} + #define DX11_LOG_OUTPUT_MTX3x4(m) {} + #define DX11_LOG_OUTPUT_MTX4x4(m) {} + #define DX11_LOG_ENTER_FUNCTION(...) {} + #define DX11_MARK_FRAME_BEGIN() {} + #define DX11_MARK_FRAME_END() {} + #define DX11_CHK(x) x + #define DX11_MARK_DRAWING(TriCount, VertexCount) {} + #define DX11_SET_FRAME_DEBUG(Type) {} +#endif diff --git a/Runtime/GfxDevice/d3d11/D3D11Hash.cpp b/Runtime/GfxDevice/d3d11/D3D11Hash.cpp new file mode 100644 index 0000000..f4f692f --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11Hash.cpp @@ -0,0 +1,326 @@ +// Original MD5 implementation put into public domain +// by Alexander Peslyak, see comment below. +// Modifications for D3D hash by Aras Pranckevicius, public domain. + +// D3D shader hash seems to be almost MD5, except small differences in +// the final step (MD5_Final in OpenSSL). Look for "CHANGE FROM MD5". + + +/* + * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc. + * MD5 Message-Digest Algorithm (RFC 1321). + * + * Homepage: + * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5 + * + * Author: + * Alexander Peslyak, better known as Solar Designer <solar at openwall.com> + * + * This software was written by Alexander Peslyak in 2001. No copyright is + * claimed, and the software is hereby placed in the public domain. + * In case this attempt to disclaim copyright and place the software in the + * public domain is deemed null and void, then the software is + * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the + * general public under the following terms: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted. + * + * There's ABSOLUTELY NO WARRANTY, express or implied. + * + * (This is a heavily cut-down "BSD license".) + * + * This differs from Colin Plumb's older public domain implementation in that + * no exactly 32-bit integer data type is required (any 32-bit or wider + * unsigned integer data type will do), there's no compile-time endianness + * configuration, and the function prototypes match OpenSSL's. No code from + * Colin Plumb's implementation has been reused; this comment merely compares + * the properties of the two independent implementations. + * + * The primary goals of this implementation are portability and ease of use. + * It is meant to be fast, but not as fast as possible. Some known + * optimizations are not included to reduce source code size and avoid + * compile-time configuration. + */ + +/* Any 32-bit or wider unsigned integer data type will do */ +typedef unsigned int MD5_u32plus; + +typedef struct { + MD5_u32plus a, b, c, d; + MD5_u32plus hi; + MD5_u32plus lo; // CHANGE FROM MD5: need to have "lo" go directly before the buffer + unsigned char buffer[64]; + MD5_u32plus block[16]; +} MD5_CTX; + +extern void MD5_Init(MD5_CTX *ctx); +extern void MD5_Update(MD5_CTX *ctx, void *data, unsigned long size); +extern void MD5_Final(unsigned char *result, MD5_CTX *ctx); + + +#include <string.h> + +/* + * The basic MD5 functions. + * + * F and G are optimized compared to their RFC 1321 definitions for + * architectures that lack an AND-NOT instruction, just like in Colin Plumb's + * implementation. + */ +#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z)))) +#define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y)))) +#define H(x, y, z) ((x) ^ (y) ^ (z)) +#define I(x, y, z) ((y) ^ ((x) | ~(z))) + +/* + * The MD5 transformation for all four rounds. + */ +#define STEP(f, a, b, c, d, x, t, s) \ + (a) += f((b), (c), (d)) + (x) + (t); \ + (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \ + (a) += (b); + +/* + * SET reads 4 input bytes in little-endian byte order and stores them + * in a properly aligned word in host byte order. + * + * The check for little-endian architectures that tolerate unaligned + * memory accesses is just an optimization. Nothing will break if it + * doesn't work. + */ +#if defined(__i386__) || defined(__x86_64__) || defined(__vax__) || defined(_MSC_VER) +#define SET(n) \ + (*(MD5_u32plus *)&ptr[(n) * 4]) +#define GET(n) \ + SET(n) +#else +#define SET(n) \ + (ctx->block[(n)] = \ + (MD5_u32plus)ptr[(n) * 4] | \ + ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \ + ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \ + ((MD5_u32plus)ptr[(n) * 4 + 3] << 24)) +#define GET(n) \ + (ctx->block[(n)]) +#endif + +/* + * This processes one or more 64-byte data blocks, but does NOT update + * the bit counters. There are no alignment requirements. + */ +static void *body(MD5_CTX *ctx, void *data, unsigned long size) +{ + unsigned char *ptr; + MD5_u32plus a, b, c, d; + MD5_u32plus saved_a, saved_b, saved_c, saved_d; + + ptr = (unsigned char*)data; + + a = ctx->a; + b = ctx->b; + c = ctx->c; + d = ctx->d; + + do { + saved_a = a; + saved_b = b; + saved_c = c; + saved_d = d; + +/* Round 1 */ + STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7) + STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12) + STEP(F, c, d, a, b, SET(2), 0x242070db, 17) + STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22) + STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7) + STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12) + STEP(F, c, d, a, b, SET(6), 0xa8304613, 17) + STEP(F, b, c, d, a, SET(7), 0xfd469501, 22) + STEP(F, a, b, c, d, SET(8), 0x698098d8, 7) + STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12) + STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17) + STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22) + STEP(F, a, b, c, d, SET(12), 0x6b901122, 7) + STEP(F, d, a, b, c, SET(13), 0xfd987193, 12) + STEP(F, c, d, a, b, SET(14), 0xa679438e, 17) + STEP(F, b, c, d, a, SET(15), 0x49b40821, 22) + +/* Round 2 */ + STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5) + STEP(G, d, a, b, c, GET(6), 0xc040b340, 9) + STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14) + STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20) + STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5) + STEP(G, d, a, b, c, GET(10), 0x02441453, 9) + STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14) + STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20) + STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5) + STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9) + STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14) + STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20) + STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5) + STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9) + STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14) + STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20) + +/* Round 3 */ + STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4) + STEP(H, d, a, b, c, GET(8), 0x8771f681, 11) + STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16) + STEP(H, b, c, d, a, GET(14), 0xfde5380c, 23) + STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4) + STEP(H, d, a, b, c, GET(4), 0x4bdecfa9, 11) + STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16) + STEP(H, b, c, d, a, GET(10), 0xbebfbc70, 23) + STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4) + STEP(H, d, a, b, c, GET(0), 0xeaa127fa, 11) + STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16) + STEP(H, b, c, d, a, GET(6), 0x04881d05, 23) + STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4) + STEP(H, d, a, b, c, GET(12), 0xe6db99e5, 11) + STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16) + STEP(H, b, c, d, a, GET(2), 0xc4ac5665, 23) + +/* Round 4 */ + STEP(I, a, b, c, d, GET(0), 0xf4292244, 6) + STEP(I, d, a, b, c, GET(7), 0x432aff97, 10) + STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15) + STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21) + STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6) + STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10) + STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15) + STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21) + STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6) + STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10) + STEP(I, c, d, a, b, GET(6), 0xa3014314, 15) + STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21) + STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6) + STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10) + STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15) + STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21) + + a += saved_a; + b += saved_b; + c += saved_c; + d += saved_d; + + ptr += 64; + } while (size -= 64); + + ctx->a = a; + ctx->b = b; + ctx->c = c; + ctx->d = d; + + return ptr; +} + +void MD5_Init(MD5_CTX *ctx) +{ + ctx->a = 0x67452301; + ctx->b = 0xefcdab89; + ctx->c = 0x98badcfe; + ctx->d = 0x10325476; + + ctx->lo = 0; + ctx->hi = 0; +} + +void MD5_Update(MD5_CTX *ctx, void *data, unsigned long size) +{ + MD5_u32plus saved_lo; + unsigned long used, free; + + saved_lo = ctx->lo; + if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo) + ctx->hi++; + ctx->hi += size >> 29; + + used = saved_lo & 0x3f; + + if (used) { + free = 64 - used; + + if (size < free) { + memcpy(&ctx->buffer[used], data, size); + return; + } + + memcpy(&ctx->buffer[used], data, free); + data = (unsigned char *)data + free; + size -= free; + body(ctx, ctx->buffer, 64); + } + + if (size >= 64) { + data = body(ctx, data, size & ~(unsigned long)0x3f); + size &= 0x3f; + } + + memcpy(ctx->buffer, data, size); +} + +void MD5_Final(unsigned char *result, MD5_CTX *ctx) +{ + unsigned long used, free; + + used = ctx->lo & 0x3f; + + ctx->buffer[used++] = 0x80; + + free = 64 - used; + + if (free < 8) { + memset(&ctx->buffer[used], 0, free); + body(ctx, ctx->buffer, 64); + used = 0; + free = 64; + } + + memset(&ctx->buffer[used], 0, free - 8); + + // CHANGE FROM MD5: put lo*2|1 instead of ctx->lo at buffer[56] + MD5_u32plus lo2 = ctx->lo * 2 | 1; + ctx->lo <<= 3; + ctx->buffer[56] = lo2; + ctx->buffer[57] = lo2 >> 8; + ctx->buffer[58] = lo2 >> 16; + ctx->buffer[59] = lo2 >> 24; + ctx->buffer[60] = ctx->hi; + ctx->buffer[61] = ctx->hi >> 8; + ctx->buffer[62] = ctx->hi >> 16; + ctx->buffer[63] = ctx->hi >> 24; + + // CHANGE FROM MD5: pass buffer-4 (that contains lo) + // instead of buffer. Essentially the buffer is shifted by 4 bytes + body(ctx, &ctx->lo, 64); + + result[0] = ctx->a; + result[1] = ctx->a >> 8; + result[2] = ctx->a >> 16; + result[3] = ctx->a >> 24; + result[4] = ctx->b; + result[5] = ctx->b >> 8; + result[6] = ctx->b >> 16; + result[7] = ctx->b >> 24; + result[8] = ctx->c; + result[9] = ctx->c >> 8; + result[10] = ctx->c >> 16; + result[11] = ctx->c >> 24; + result[12] = ctx->d; + result[13] = ctx->d >> 8; + result[14] = ctx->d >> 16; + result[15] = ctx->d >> 24; + + memset(ctx, 0, sizeof(*ctx)); +} + + +void D3DHash (const unsigned char* data, unsigned size, unsigned char res[16]) +{ + MD5_CTX ctx; + MD5_Init (&ctx); + MD5_Update (&ctx, (void*)data, size); + MD5_Final (res, &ctx); +} diff --git a/Runtime/GfxDevice/d3d11/D3D11Includes.h b/Runtime/GfxDevice/d3d11/D3D11Includes.h new file mode 100644 index 0000000..7629ef7 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11Includes.h @@ -0,0 +1,49 @@ +#pragma once + + +#if UNITY_WP8 + +#include <initguid.h> + +#include <dxgi1_2.h> +#include <d3d11_1.h> + +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 D3D10_COMPONENT_MASK values) + UINT Stream; // Stream index + D3D_MIN_PRECISION MinPrecision; // Minimum desired interpolation precision +} D3D11_SIGNATURE_PARAMETER_DESC; + +#elif UNITY_METRO + +#include <dxgi1_2.h> +#include <d3d11_1.h> +#if UNITY_METRO_VS2013 +#include <d3d11_2.h> +#endif +#include <d3d11shader.h> + +#else + +#include "External/DirectX/builds/dx11include/DXGI.h" +#include "External/DirectX/builds/dx11include/D3D11.h" +#include "External/DirectX/builds/dx11include/d3d11_1.h" +#include "External/DirectX/builds/dx11include/D3D11Shader.h" + +#define D3D_NAME D3D10_NAME +#define D3D_REGISTER_COMPONENT_TYPE D3D10_REGISTER_COMPONENT_TYPE + +#endif + +#include "D3D11Debug.h" diff --git a/Runtime/GfxDevice/d3d11/D3D11Utils.cpp b/Runtime/GfxDevice/d3d11/D3D11Utils.cpp new file mode 100644 index 0000000..55535f3 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11Utils.cpp @@ -0,0 +1,85 @@ +#include "UnityPrefix.h" +#include "D3D11Utils.h" + + +#ifdef DUMMY_D3D11_CALLS +HRESULT CallDummyD3D11Function() +{ + return S_OK; +} +#endif + +void ReportLiveObjectsD3D11 (ID3D11Device* dev) +{ + ID3D11Debug* dbg = NULL; + if (FAILED(dev->QueryInterface(IID_ID3D11Debug, (void**)&dbg))) + return; + if (!dbg) + return; + + dbg->ReportLiveDeviceObjects (D3D11_RLDO_DETAIL); + dbg->Release(); +} + + +void SetDebugNameD3D11 (ID3D11DeviceChild* obj, const std::string& name) +{ + if (obj) + obj->SetPrivateData (WKPDID_D3DDebugObjectName, name.size(), name.c_str()); +} + +std::string GetDebugNameD3D11 (ID3D11DeviceChild* obj) +{ + if (obj) + { + char tmp[1024]; + int maxLength = sizeof(tmp) - 1; + UINT size = maxLength; + obj->GetPrivateData (WKPDID_D3DDebugObjectName, &size, tmp); + tmp[size] = '\0'; + tmp[maxLength] = '\0'; + return tmp; + } + return ""; +} + + + +int GetBPPFromDXGIFormat (DXGI_FORMAT fmt) +{ + if (fmt == DXGI_FORMAT_UNKNOWN) + return 0; + if (fmt >= DXGI_FORMAT_R32G32B32A32_TYPELESS && fmt <= DXGI_FORMAT_R32G32B32A32_SINT) + return 128; + if (fmt >= DXGI_FORMAT_R32G32B32_TYPELESS && fmt <= DXGI_FORMAT_R32G32B32_SINT) + return 96; + if (fmt >= DXGI_FORMAT_R16G16B16A16_TYPELESS && fmt <= DXGI_FORMAT_X32_TYPELESS_G8X24_UINT) + return 64; + if (fmt >= DXGI_FORMAT_R10G10B10A2_TYPELESS && fmt <= DXGI_FORMAT_X24_TYPELESS_G8_UINT) + return 32; + if (fmt >= DXGI_FORMAT_R8G8_TYPELESS && fmt <= DXGI_FORMAT_R16_SINT) + return 16; + if (fmt >= DXGI_FORMAT_R8_TYPELESS && fmt <= DXGI_FORMAT_A8_UNORM) + return 8; + if (fmt == DXGI_FORMAT_R1_UNORM) + return 1; + if (fmt >= DXGI_FORMAT_R9G9B9E5_SHAREDEXP && fmt <= DXGI_FORMAT_G8R8_G8B8_UNORM) + return 32; + if (fmt >= DXGI_FORMAT_BC1_TYPELESS && fmt <= DXGI_FORMAT_BC1_UNORM_SRGB) // DXT1 + return 4; + if (fmt >= DXGI_FORMAT_BC2_TYPELESS && fmt <= DXGI_FORMAT_BC3_UNORM_SRGB) // DXT3/5 + return 8; + if (fmt >= DXGI_FORMAT_BC4_TYPELESS && fmt <= DXGI_FORMAT_BC4_SNORM) + return 4; + if (fmt >= DXGI_FORMAT_BC5_TYPELESS && fmt <= DXGI_FORMAT_BC5_SNORM) + return 8; + if (fmt >= DXGI_FORMAT_B5G6R5_UNORM && fmt <= DXGI_FORMAT_B5G5R5A1_UNORM) + return 16; + if (fmt >= DXGI_FORMAT_B8G8R8A8_UNORM && fmt <= DXGI_FORMAT_B8G8R8X8_UNORM_SRGB) + return 32; + if (fmt >= DXGI_FORMAT_BC6H_TYPELESS && fmt <= DXGI_FORMAT_BC7_UNORM_SRGB) + return 8; + AssertString ("Unknown DXGI format"); + return 0; +} + diff --git a/Runtime/GfxDevice/d3d11/D3D11Utils.h b/Runtime/GfxDevice/d3d11/D3D11Utils.h new file mode 100644 index 0000000..69c5f44 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11Utils.h @@ -0,0 +1,20 @@ +#pragma once + +#include "D3D11Includes.h" + +//#define DUMMY_D3D11_CALLS + +#ifndef DUMMY_D3D11_CALLS +#define D3D11_CALL(x) x +#define D3D11_CALL_HR(x) x +#else +HRESULT CallDummyD3D11Function(); +#define D3D11_CALL(x) CallDummyD3D11Function() +#define D3D11_CALL_HR(x) CallDummyD3D11Function() +#endif + +int GetBPPFromDXGIFormat (DXGI_FORMAT fmt); +void ReportLiveObjectsD3D11 (ID3D11Device* dev); +void SetDebugNameD3D11 (ID3D11DeviceChild* obj, const std::string& name); +std::string GetDebugNameD3D11 (ID3D11DeviceChild* obj); + diff --git a/Runtime/GfxDevice/d3d11/D3D11VBO.cpp b/Runtime/GfxDevice/d3d11/D3D11VBO.cpp new file mode 100644 index 0000000..e0beaf1 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11VBO.cpp @@ -0,0 +1,1193 @@ +#include "UnityPrefix.h" +#include "D3D11VBO.h" +#include "D3D11Context.h" +#include "Runtime/GfxDevice/GfxDevice.h" +#include "Runtime/Graphics/TriStripper.h" +#include "Runtime/GfxDevice/ChannelAssigns.h" +#include "Runtime/Utilities/ArrayUtility.h" +#include "D3D11Utils.h" + + + +// defined in GfxDeviceD3D11.cpp +ID3D11InputLayout* GetD3D11VertexDeclaration (const ChannelInfoArray& channels); +void UpdateChannelBindingsD3D11 (const ChannelAssigns& channels); + +ID3D11InputLayout* g_ActiveInputLayoutD3D11; +D3D11_PRIMITIVE_TOPOLOGY g_ActiveTopologyD3D11 = D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED; + + + +static const D3D11_PRIMITIVE_TOPOLOGY kTopologyD3D11[kPrimitiveTypeCount] = +{ + D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST, + D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, + D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST, + D3D11_PRIMITIVE_TOPOLOGY_LINELIST, + D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP, + D3D11_PRIMITIVE_TOPOLOGY_POINTLIST, +}; + +static const D3D11_PRIMITIVE_TOPOLOGY kTopologyD3D11Tess[kPrimitiveTypeCount] = +{ + D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED, + D3D11_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED, + D3D11_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST, +}; + + +void SetInputLayoutD3D11 (ID3D11DeviceContext* ctx, ID3D11InputLayout* layout) +{ + if (g_ActiveInputLayoutD3D11 != layout) + { + g_ActiveInputLayoutD3D11 = layout; + D3D11_CALL (ctx->IASetInputLayout (layout)); + } +} + + +static ID3D11InputLayout* GetD3D11VertexDeclaration (UInt32 shaderChannelsMap) +{ + ChannelInfoArray channels; + int offset = 0; + for (int i = 0; i < kShaderChannelCount; i++) + { + ChannelInfo& info = channels[i]; + if (shaderChannelsMap & (1 << i)) + { + info.stream = 0; + info.offset = offset; + info.format = VBO::GetDefaultChannelFormat( i ); + info.dimension = VBO::GetDefaultChannelDimension( i ); + offset += VBO::GetDefaultChannelByteSize( i ); + } + else + info.Reset(); + } + return GetD3D11VertexDeclaration (channels); +} + + +// ----------------------------------------------------------------------------- + +ID3D11Buffer* D3D11VBO::ms_CustomIB = NULL; +int D3D11VBO::ms_CustomIBSize = 0; +UInt32 D3D11VBO::ms_CustomIBUsedBytes = 0; + +ID3D11Buffer* D3D11VBO::ms_AllWhiteBuffer = NULL; + + +D3D11VBO::D3D11VBO() +: m_IB(NULL) +, m_StagingIB(NULL) +, m_IBReadable(NULL) +, m_IBSize(0) +, m_useForSO(false) +{ + memset(m_VBStreams, 0, sizeof(m_VBStreams)); + memset(m_StagingVB, 0, sizeof(m_StagingVB)); +} + +D3D11VBO::~D3D11VBO () +{ + for (int s = 0; s < kMaxVertexStreams; ++s) + { + //std::string tmp = GetDebugNameD3D11(m_StagingVB[s]); + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_VBStreams[s]); + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_StagingVB[s]); + SAFE_RELEASE(m_VBStreams[s]); + SAFE_RELEASE(m_StagingVB[s]); + } + if (m_IB) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_IB); + SAFE_RELEASE(m_IB); + } + if (m_StagingIB) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_StagingIB); + SAFE_RELEASE(m_StagingIB); + } + delete[] m_IBReadable; +} + + +static ID3D11Buffer* CreateStagingBuffer (int size) +{ + ID3D11Device* dev = GetD3D11Device(); + D3D11_BUFFER_DESC desc; + desc.ByteWidth = size; + desc.Usage = D3D11_USAGE_STAGING; + desc.BindFlags = 0; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + + ID3D11Buffer* buffer = NULL; + HRESULT hr = dev->CreateBuffer (&desc, NULL, &buffer); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(buffer,size,NULL); + AssertIf (FAILED(hr)); + return buffer; +} + +void D3D11VBO::CleanupSharedBuffers() +{ + REGISTER_EXTERNAL_GFX_DEALLOCATION(ms_CustomIB); + REGISTER_EXTERNAL_GFX_DEALLOCATION(ms_AllWhiteBuffer); + SAFE_RELEASE (ms_CustomIB); + SAFE_RELEASE (ms_AllWhiteBuffer); + ms_CustomIBSize = 0; + ms_CustomIBUsedBytes = 0; +} + + +void D3D11VBO::UpdateVertexStream (const VertexBufferData& sourceData, unsigned stream) +{ + DebugAssert (!m_IsStreamMapped[stream]); + const StreamInfo& srcStream = sourceData.streams[stream]; + const int oldSize = CalculateVertexStreamSize(m_Streams[stream], m_VertexCount); + +#if UNITY_METRO + #pragma message("Fix ugly hack CreateStagingBuffer") + // So honestly I don't how what's happening here, but when running on ARM (Surface) with Feature Level 9.1 and if we create a vertex buffer with size 144 + // Sometimes we crash in D3D11VBO dtor in this line SAFE_RELEASE(m_StagingVB[s]); + // Sometimes we get an access violation but sometimes it's Data misalignment exception like below + // First-chance exception at 0x75499B2A (setupapi.dll) in Drift Mania Championship 2.exe: 0x80000002: Datatype misalignment + // Repro case 495782 + // Not reproducible on Win32 running Feature Level 9.1 + + // In any case it seems increasing min size up to 256, solves this issue for now + int newSize = CalculateVertexStreamSize(srcStream, sourceData.vertexCount); + int addon = 1; + while (newSize > 0 && newSize < 256) + { + newSize = CalculateVertexStreamSize(srcStream, sourceData.vertexCount + addon); + addon++; + } + +#else + const int newSize = CalculateVertexStreamSize(srcStream, sourceData.vertexCount); +#endif + + + m_Streams[stream] = srcStream; + if (newSize == 0) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_VBStreams[stream]); + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_StagingVB[stream]); + SAFE_RELEASE (m_VBStreams[stream]); + SAFE_RELEASE (m_StagingVB[stream]); + return; + } + + const bool isDynamic = (m_StreamModes[stream] == kStreamModeDynamic); + const bool useStaging = !isDynamic; + + if (m_VBStreams[stream] == NULL || newSize != oldSize) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_VBStreams[stream]); + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_StagingVB[stream]); + SAFE_RELEASE (m_VBStreams[stream]); + SAFE_RELEASE (m_StagingVB[stream]); // release staging VB as well here + + ID3D11Device* dev = GetD3D11Device(); + D3D11_BUFFER_DESC desc; + desc.ByteWidth = newSize; + desc.Usage = isDynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_DEFAULT; + desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + if ( m_useForSO ) + desc.BindFlags |= D3D11_BIND_STREAM_OUTPUT; + desc.CPUAccessFlags = isDynamic ? D3D11_CPU_ACCESS_WRITE : 0; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + HRESULT hr = dev->CreateBuffer (&desc, NULL, &m_VBStreams[stream]); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(m_VBStreams[stream],newSize,this); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to create vertex buffer of size %d [0x%X]\n", newSize, hr); + return; + } + SetDebugNameD3D11 (m_VBStreams[stream], Format("VertexBuffer-%d", newSize)); + + if (useStaging) + { + m_StagingVB[stream] = CreateStagingBuffer (newSize); + SetDebugNameD3D11 (m_StagingVB[stream], Format("StagingVertexBuffer-%d", newSize)); + } + } + + // Don't update contents if there is no source data. + // This is used to update the vertex declaration only, leaving buffer intact. + // Also to create an empty buffer that is written to later. + if (!sourceData.buffer) + return; + + HRESULT hr; + + ID3D11Buffer* mapVB = NULL; + D3D11_MAP mapType; + + if (useStaging) + { + mapVB = m_StagingVB[stream]; + mapType = D3D11_MAP_WRITE; + } + else + { + mapVB = m_VBStreams[stream]; + mapType = D3D11_MAP_WRITE_DISCARD; + } + + Assert (mapVB); + + ID3D11DeviceContext* ctx = GetD3D11Context(); + + D3D11_MAPPED_SUBRESOURCE mapped; + hr = ctx->Map (mapVB, 0, mapType, 0, &mapped); + Assert (SUCCEEDED(hr)); + CopyVertexStream (sourceData, reinterpret_cast<UInt8*>(mapped.pData), stream); + ctx->Unmap (mapVB, 0); + + if (useStaging) + ctx->CopyResource (m_VBStreams[stream], m_StagingVB[stream]); +} + + +void D3D11VBO::UpdateIndexBufferData (const IndexBufferData& sourceData) +{ + if( !sourceData.indices ) + { + m_IBSize = 0; + return; + } + + Assert (m_IB); + HRESULT hr; + + int size = sourceData.count * kVBOIndexSize; + if (sourceData.hasTopologies & ((1<<kPrimitiveTriangleStripDeprecated) | (1<<kPrimitiveQuads))) + { + delete[] m_IBReadable; + m_IBReadable = new UInt16[sourceData.count]; + memcpy (m_IBReadable, sourceData.indices, size); + } + + const D3D11_MAP mapType = m_IndicesDynamic ? D3D11_MAP_WRITE_DISCARD : D3D11_MAP_WRITE; + ID3D11Buffer* mapIB; + if (m_IndicesDynamic) + mapIB = m_IB; + else + { + if (!m_StagingIB) + m_StagingIB = CreateStagingBuffer(m_IBSize); + mapIB = m_StagingIB; + } + + ID3D11DeviceContext* ctx = GetD3D11Context(); + D3D11_MAPPED_SUBRESOURCE mapped; + hr = ctx->Map (mapIB, 0, mapType, 0, &mapped); + Assert (SUCCEEDED(hr)); + + memcpy (mapped.pData, sourceData.indices, size); + + ctx->Unmap (mapIB, 0); + if (!m_IndicesDynamic) + ctx->CopyResource (m_IB, m_StagingIB); +} + +bool D3D11VBO::MapVertexStream( VertexStreamData& outData, unsigned stream ) +{ + if (m_VBStreams[stream] == NULL) + { + printf_console ("d3d11: attempt to map null vertex buffer\n"); + return false; + } + DebugAssert(!IsVertexBufferLost()); + Assert(!m_IsStreamMapped[stream]); + + const int vbSize = CalculateVertexStreamSize(m_Streams[stream], m_VertexCount); + + const bool dynamic = (m_StreamModes[stream]==kStreamModeDynamic); + + D3D11_MAPPED_SUBRESOURCE mapped; + ID3D11Buffer* mapVB = dynamic ? m_VBStreams[stream] : m_StagingVB[stream]; + D3D11_MAP mapType = dynamic ? D3D11_MAP_WRITE_DISCARD : D3D11_MAP_WRITE; + HRESULT hr = GetD3D11Context()->Map (mapVB, 0, mapType, 0, &mapped); + if( FAILED(hr) ) + { + printf_console ("d3d11: failed to map vertex buffer %p of size %i [%x]\n", mapVB, vbSize, hr); + return false; + } + m_IsStreamMapped[stream] = true; + + UInt8* buffer = (UInt8*)mapped.pData; + + outData.buffer = buffer; + outData.channelMask = m_Streams[stream].channelMask; + outData.stride = m_Streams[stream].stride; + outData.vertexCount = m_VertexCount; + + GetRealGfxDevice().GetFrameStats().AddUploadVBO(vbSize); + + return true; +} + +void D3D11VBO::UnmapVertexStream (unsigned stream) +{ + DebugAssert(m_VBStreams[stream]); + Assert(m_IsStreamMapped[stream]); + m_IsStreamMapped[stream] = false; + ID3D11DeviceContext* ctx = GetD3D11Context(); + + const bool dynamic = (m_StreamModes[stream]==kStreamModeDynamic); + ID3D11Buffer* mapVB = dynamic ? m_VBStreams[stream] : m_StagingVB[stream]; + ctx->Unmap (mapVB, 0); + + if (!dynamic) + ctx->CopyResource (m_VBStreams[stream], m_StagingVB[stream]); +} + +bool D3D11VBO::IsVertexBufferLost() const +{ + for (int s = 0; s < kMaxVertexStreams; ++s) + if (m_Streams[s].channelMask && !m_VBStreams[s]) + return true; + return false; +} + +int D3D11VBO::GetRuntimeMemorySize() const +{ + int vertexSize = 0; + for( int s = 0; s < kMaxVertexStreams; s++ ) + vertexSize += m_Streams[s].stride; + return vertexSize * m_VertexCount + m_IBSize; +} + + +bool SetTopologyD3D11 (GfxPrimitiveType topology, GfxDevice& device, ID3D11DeviceContext* ctx) +{ + bool tessellation = device.IsShaderActive (kShaderHull) || device.IsShaderActive (kShaderDomain); + D3D11_PRIMITIVE_TOPOLOGY topod3d = tessellation ? kTopologyD3D11Tess[topology] : kTopologyD3D11[topology]; + if (topod3d == D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED) + return false; + + if (topod3d != g_ActiveTopologyD3D11) + { + g_ActiveTopologyD3D11 = topod3d; + D3D11_CALL (ctx->IASetPrimitiveTopology (topod3d)); + } + return true; +} + + +ID3D11Buffer* D3D11VBO::GetAllWhiteBuffer() +{ + if (!ms_AllWhiteBuffer) + { + int maxVerts = 0x10000; + int size = maxVerts * sizeof(UInt32); + UInt8* data = new UInt8[size]; + memset (data, 0xFF, size); + + D3D11_BUFFER_DESC desc; + desc.ByteWidth = size; + desc.Usage = D3D11_USAGE_IMMUTABLE; + desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + D3D11_SUBRESOURCE_DATA sdata; + sdata.pSysMem = data; + sdata.SysMemPitch = 0; + sdata.SysMemSlicePitch = 0; + HRESULT hr = GetD3D11Device()->CreateBuffer (&desc, &sdata, &ms_AllWhiteBuffer); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(ms_AllWhiteBuffer,size,NULL); + delete[] data; + } + return ms_AllWhiteBuffer; +} + + +void D3D11VBO::BindVertexStreams(GfxDevice& device, ID3D11DeviceContext* ctx, const ChannelAssigns& channels) +{ + DX11_LOG_ENTER_FUNCTION("D3D11VBO::BindVertexStreams"); + int freeStream = -1; + for (int s = 0; s < kMaxVertexStreams; ++s) + { + if (m_VBStreams[s]) + { + UINT offset = 0; + UINT stride = m_Streams[s].stride; + D3D11_CALL (ctx->IASetVertexBuffers(s, 1, &m_VBStreams[s], &stride, &offset)); + } + else + freeStream = s; + } + + UpdateChannelBindingsD3D11(channels); + + device.BeforeDrawCall( false ); + + const ChannelInfoArray* channelInfo = &m_ChannelInfo; + if ((channels.GetSourceMap() & VERTEX_FORMAT1(Color)) && !m_ChannelInfo[kShaderChannelColor].IsValid()) + { + if (freeStream != -1) + { + static ChannelInfoArray colorChannelInfo; + memcpy(&colorChannelInfo, m_ChannelInfo, sizeof(colorChannelInfo)); + ChannelInfo& colorInfo = colorChannelInfo[kShaderChannelColor]; + colorInfo.stream = freeStream; + colorInfo.offset = 0; + colorInfo.format = kChannelFormatColor; + colorInfo.dimension = 1; + channelInfo = &colorChannelInfo; + ID3D11Buffer* whiteVB = GetAllWhiteBuffer(); + UINT stride = 4; + UINT offset = 0; + D3D11_CALL (ctx->IASetVertexBuffers(freeStream, 1, &whiteVB, &stride, &offset)); + } + else + ErrorString("Need a free stream to add default vertex colors!"); + } + ID3D11InputLayout* inputLayout = GetD3D11VertexDeclaration(m_ChannelInfo); + SetInputLayoutD3D11 (ctx, inputLayout); +} + +void D3D11VBO::BindToStreamOutput() +{ + const UINT offsets[] = { 0 }; + GetD3D11Context()->SOSetTargets(1, m_VBStreams, offsets); +} + +void D3D11VBO::UnbindFromStreamOutput() +{ + ID3D11Buffer* const buffers[] = { 0 }; + const UINT offsets[] = { 0 }; + GetD3D11Context()->SOSetTargets(1, buffers, offsets); +} + + +void D3D11VBO::DrawVBO (const ChannelAssigns& channels, UInt32 firstIndexByte, UInt32 indexCount, GfxPrimitiveType topology, UInt32 firstVertex, UInt32 vertexCount) +{ + DX11_LOG_ENTER_FUNCTION("D3D11VBO::DrawVBO"); + // just return if no indices + if( m_IBSize == 0 ) + return; + + Assert(!m_IsStreamMapped[0]); + if (m_VBStreams[0] == 0 || m_IB == 0) + { + printf_console( "d3d: VB or IB is null\n" ); + return; + } + + GfxDevice& device = GetRealGfxDevice(); + ID3D11DeviceContext* ctx = GetD3D11Context(); + BindVertexStreams (device, ctx, channels); + + bool tessellation = device.IsShaderActive (kShaderHull) || device.IsShaderActive (kShaderDomain); + if (tessellation && topology == kPrimitiveTriangleStripDeprecated) + { + if (!m_IBReadable) + return; + + const UInt16* ibSrc = (const UInt16*)((const UInt8*)m_IBReadable + firstIndexByte); + const int triCount = CountTrianglesInStrip (ibSrc, indexCount); + + UInt32 ibBytesLocked; + UInt16* ibPtr = MapDynamicIndexBuffer (triCount*3, ibBytesLocked); + if (!ibPtr) + return; + Destripify (ibSrc, indexCount, ibPtr, triCount*3); + UnmapDynamicIndexBuffer (); + firstIndexByte = ms_CustomIBUsedBytes; + ms_CustomIBUsedBytes += ibBytesLocked; + D3D11_CALL (ctx->IASetIndexBuffer (ms_CustomIB, DXGI_FORMAT_R16_UINT, 0)); + indexCount = ibBytesLocked/kVBOIndexSize; + topology = kPrimitiveTriangles; + } + else if (topology == kPrimitiveQuads && !tessellation) + { + if (!m_IBReadable) + return; + UInt32 ibBytesLocked; + UInt16* ibPtr = MapDynamicIndexBuffer (indexCount/4*6, ibBytesLocked); + if (!ibPtr) + return; + const UInt16* ibSrc = (const UInt16*)((const UInt8*)m_IBReadable + firstIndexByte); + FillIndexBufferForQuads (ibPtr, ibBytesLocked, ibSrc, indexCount/4); + UnmapDynamicIndexBuffer (); + firstIndexByte = ms_CustomIBUsedBytes; + ms_CustomIBUsedBytes += ibBytesLocked; + D3D11_CALL (ctx->IASetIndexBuffer (ms_CustomIB, DXGI_FORMAT_R16_UINT, 0)); + indexCount = ibBytesLocked/kVBOIndexSize; + } + else + { + D3D11_CALL (ctx->IASetIndexBuffer (m_IB, DXGI_FORMAT_R16_UINT, 0)); + } + + // draw + if (!SetTopologyD3D11 (topology, device, ctx)) + return; + D3D11_CALL (ctx->DrawIndexed (indexCount, firstIndexByte/2, 0)); + device.GetFrameStats().AddDrawCall (GetPrimitiveCount(indexCount,topology,false), vertexCount); + DX11_MARK_DRAWING(GetPrimitiveCount(indexCount,topology,false), vertexCount); + +} + +UInt16* D3D11VBO::MapDynamicIndexBuffer (int indexCount, UInt32& outBytesUsed) +{ + HRESULT hr; + const UInt32 maxIndices = 64000; + Assert (indexCount <= maxIndices); + indexCount = std::min<UInt32>(indexCount, maxIndices); + + int ibCapacity = indexCount * kVBOIndexSize; + int newIBSize = std::max (ibCapacity, 32*1024); // 32k IB at least + + if (newIBSize > ms_CustomIBSize) + { + if (ms_CustomIB) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(ms_CustomIB); + ms_CustomIB->Release(); + } + ms_CustomIBSize = newIBSize; + ms_CustomIBUsedBytes = 0; + + ID3D11Device* dev = GetD3D11Device(); + + D3D11_BUFFER_DESC desc; + desc.ByteWidth = newIBSize; + desc.Usage = D3D11_USAGE_DYNAMIC; + desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + hr = dev->CreateBuffer (&desc, NULL, &ms_CustomIB); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(ms_CustomIB,newIBSize,NULL); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to create custom index buffer of size %d [%x]\n", newIBSize, hr); + return NULL; + } + SetDebugNameD3D11 (ms_CustomIB, Format("IndexBufferCustomDynamic-%d", newIBSize)); + } + + ID3D11DeviceContext* ctx = GetD3D11Context(); + D3D11_MAPPED_SUBRESOURCE mapped; + if (ms_CustomIBUsedBytes + ibCapacity > ms_CustomIBSize) + { + hr = ctx->Map (ms_CustomIB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to lock shared index buffer with discard [%x]\n", hr); + return NULL; + } + ms_CustomIBUsedBytes = 0; + } + else + { + hr = ctx->Map (ms_CustomIB, 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &mapped); + if (FAILED(hr)) + { + printf_console( "d3d11: failed to lock shared index buffer, offset %i size %i [%x]\n", ms_CustomIBUsedBytes, ibCapacity, hr); + return NULL; + } + } + outBytesUsed = ibCapacity; + + return (UInt16*)((UInt8*)mapped.pData + ms_CustomIBUsedBytes); +} + +void D3D11VBO::UnmapDynamicIndexBuffer () +{ + GetD3D11Context()->Unmap (ms_CustomIB, 0); +} + + +#if GFX_ENABLE_DRAW_CALL_BATCHING +void D3D11VBO::DrawCustomIndexed( const ChannelAssigns& channels, void* indices, UInt32 indexCount, + GfxPrimitiveType topology, UInt32 vertexRangeBegin, UInt32 vertexRangeEnd, UInt32 drawVertexCount ) +{ + HRESULT hr; + Assert (!m_IsStreamMapped[0]); + + if (m_VBStreams[0] == 0) + { + printf_console( "d3d11: VB is null\n" ); + return; + } + + ID3D11DeviceContext* ctx = GetD3D11Context(); + + UInt32 ibBytesUsed; + UInt16* ibPtr = MapDynamicIndexBuffer (indexCount, ibBytesUsed); + if (!ibPtr) + return; + memcpy (ibPtr, indices, ibBytesUsed); + UnmapDynamicIndexBuffer (); + + // draw + GfxDevice& device = GetRealGfxDevice(); + BindVertexStreams(device, ctx, channels); + + D3D11_CALL (ctx->IASetIndexBuffer (ms_CustomIB, DXGI_FORMAT_R16_UINT, 0)); + + // draw + if (!SetTopologyD3D11 (topology, device, ctx)) + return; + D3D11_CALL (ctx->DrawIndexed (indexCount, ms_CustomIBUsedBytes / kVBOIndexSize, 0)); + device.GetFrameStats().AddDrawCall (GetPrimitiveCount(indexCount,topology,false), drawVertexCount); + + ms_CustomIBUsedBytes += ibBytesUsed; +} + +#endif // GFX_ENABLE_DRAW_CALL_BATCHING + + + +void D3D11VBO::UpdateVertexData( const VertexBufferData& buffer ) +{ + for (unsigned stream = 0; stream < kMaxVertexStreams; stream++) + UpdateVertexStream (buffer, stream); + + memcpy (m_ChannelInfo, buffer.channels, sizeof(m_ChannelInfo)); + m_VertexCount = buffer.vertexCount; +} + +void D3D11VBO::UpdateIndexData (const IndexBufferData& buffer) +{ + int newSize = CalculateIndexBufferSize(buffer); + + // If we have old buffer, but need different size: delete old one + if (newSize != m_IBSize) + { + if (m_IB) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_IB); + SAFE_RELEASE(m_IB); + } + if (m_StagingIB) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_StagingIB); + SAFE_RELEASE(m_StagingIB); + } + } + + // Create buffer if we need to + if (!m_IB) + { + ID3D11Device* dev = GetD3D11Device(); + D3D11_BUFFER_DESC desc; + desc.ByteWidth = newSize; + desc.Usage = m_IndicesDynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_DEFAULT; + desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + desc.CPUAccessFlags = m_IndicesDynamic ? D3D11_CPU_ACCESS_WRITE : 0; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + HRESULT hr = dev->CreateBuffer (&desc, NULL, &m_IB); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(m_IB,newSize,this); + if( FAILED(hr) ) + { + printf_console( "d3d11: failed to create index buffer of size %d [0x%X]\n", newSize, hr ); + return; + } + SetDebugNameD3D11 (m_IB, Format("IndexBuffer-%d", newSize)); + } + + m_IBSize = newSize; + UpdateIndexBufferData(buffer); +} + +void D3D11VBO::SetIndicesDynamic(bool dynamic) +{ + // do nothing if a no-op + if (dynamic == m_IndicesDynamic) + return; + + VBO::SetIndicesDynamic(dynamic); + + // release current index buffers + if (m_IB) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_IB); + SAFE_RELEASE(m_IB); + } + if (m_StagingIB) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_StagingIB); + SAFE_RELEASE(m_StagingIB); + } +} + + + +// ----------------------------------------------------------------------------- + + +DynamicD3D11VBO::DynamicD3D11VBO( UInt32 vbSize, UInt32 ibSize ) +: DynamicVBO() +, m_VBSize(vbSize) +, m_VBUsedBytes(0) +, m_IBSize(ibSize) +, m_IBUsedBytes(0) +, m_VB(NULL) +, m_IB(NULL) +, m_LastChunkStartVertex(0) +, m_LastChunkStartIndex(0) +, m_QuadsIB(NULL) +{ +} + +DynamicD3D11VBO::~DynamicD3D11VBO () +{ + if( m_VB ) { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_VB); + ULONG refCount = m_VB->Release(); + AssertIf( refCount != 0 ); + } + if( m_IB ) { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_IB); + ULONG refCount = m_IB->Release(); + AssertIf( refCount != 0 ); + } + if( m_QuadsIB ) { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_QuadsIB); + ULONG refCount = m_QuadsIB->Release(); + AssertIf( refCount != 0 ); + } +} + +void DynamicD3D11VBO::InitializeQuadsIB() +{ + AssertIf( m_QuadsIB ); + + const int kMaxQuads = 65536/4 - 4; // so we fit into 16 bit indices, minus some more just in case + + UInt16* data = new UInt16[kMaxQuads*6]; + UInt16* ib = data; + UInt32 baseIndex = 0; + for( int i = 0; i < kMaxQuads; ++i ) + { + ib[0] = baseIndex + 1; + ib[1] = baseIndex + 2; + ib[2] = baseIndex; + ib[3] = baseIndex + 2; + ib[4] = baseIndex + 3; + ib[5] = baseIndex; + baseIndex += 4; + ib += 6; + } + + ID3D11Device* dev = GetD3D11Device(); + D3D11_BUFFER_DESC desc; + desc.ByteWidth = kMaxQuads * 6 * kVBOIndexSize; + desc.Usage = D3D11_USAGE_IMMUTABLE; + desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + D3D11_SUBRESOURCE_DATA srData; + srData.pSysMem = data; + srData.SysMemPitch = 0; + srData.SysMemSlicePitch = 0; + HRESULT hr = dev->CreateBuffer (&desc, &srData, &m_QuadsIB); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(m_QuadsIB,desc.ByteWidth,this); + delete[] data; + if (FAILED(hr)) + { + printf_console ("d3d11: failed to create quads index buffer [%x]\n", hr); + } + SetDebugNameD3D11 (m_QuadsIB, "IndexBufferQuads"); +} + + +void DynamicD3D11VBO::DrawChunk (const ChannelAssigns& channels) +{ + DX11_LOG_ENTER_FUNCTION("DynamicD3D11VBO::DrawChunk"); + // just return if nothing to render + if( !m_LastChunkShaderChannelMask ) + return; + + HRESULT hr; + + AssertIf( !m_LastChunkShaderChannelMask || !m_LastChunkStride ); + AssertIf( m_LendedChunk ); + + GfxDevice& device = GetRealGfxDevice(); + ID3D11DeviceContext* ctx = GetD3D11Context(); + + // setup VBO + DebugAssert (m_VB); + UINT strides = m_LastChunkStride; + UINT offsets = 0; + D3D11_CALL (ctx->IASetVertexBuffers(0, 1, &m_VB, &strides, &offsets)); + + UpdateChannelBindingsD3D11(channels); + device.BeforeDrawCall (false); + + ID3D11InputLayout* inputLayout = GetD3D11VertexDeclaration (m_LastChunkShaderChannelMask); + SetInputLayoutD3D11 (ctx, inputLayout); + + // draw + GfxDeviceStats& stats = device.GetFrameStats(); + int primCount = 0; + if (m_LastRenderMode == kDrawTriangleStrip) + { + if (!SetTopologyD3D11(kPrimitiveTriangleStripDeprecated,device,ctx)) + return; + D3D11_CALL (ctx->Draw (m_LastChunkVertices, m_LastChunkStartVertex)); + primCount = m_LastChunkVertices-2; + } + else if (m_LastRenderMode == kDrawIndexedTriangleStrip) + { + DebugAssert (m_IB); + if (!SetTopologyD3D11(kPrimitiveTriangleStripDeprecated,device,ctx)) + return; + D3D11_CALL (ctx->IASetIndexBuffer (m_IB, DXGI_FORMAT_R16_UINT, 0)); + D3D11_CALL (ctx->DrawIndexed (m_LastChunkIndices, m_LastChunkStartIndex, m_LastChunkStartVertex)); + primCount = m_LastChunkIndices-2; + } + else if( m_LastRenderMode == kDrawQuads ) + { + if (!SetTopologyD3D11(kPrimitiveTriangles,device,ctx)) + return; + // initialize quads index buffer if needed + if (!m_QuadsIB) + InitializeQuadsIB(); + // if quads index buffer has valid data, draw with it + if (m_QuadsIB) + { + D3D11_CALL (ctx->IASetIndexBuffer (m_QuadsIB, DXGI_FORMAT_R16_UINT, 0)); + D3D11_CALL (ctx->DrawIndexed (m_LastChunkVertices/4*6, 0, m_LastChunkStartVertex)); + primCount = m_LastChunkVertices/2; + } + } + else if (m_LastRenderMode == kDrawIndexedLines) + { + DebugAssert( m_IB ); + if (!SetTopologyD3D11(kPrimitiveLines,device,ctx)) + return; + D3D11_CALL (ctx->IASetIndexBuffer (m_IB, DXGI_FORMAT_R16_UINT, 0)); + D3D11_CALL (ctx->DrawIndexed (m_LastChunkIndices, m_LastChunkStartIndex, m_LastChunkStartVertex)); + primCount = m_LastChunkIndices/2; + } + else if (m_LastRenderMode == kDrawIndexedPoints) + { + DebugAssert (m_IB); + D3D11_CALL (ctx->IASetIndexBuffer (m_IB, DXGI_FORMAT_R16_UINT, 0)); + if (!SetTopologyD3D11 (kPrimitivePoints, device, ctx)) + return; + D3D11_CALL (ctx->DrawIndexed (m_LastChunkIndices, m_LastChunkStartIndex, m_LastChunkStartVertex)); + primCount = m_LastChunkIndices; + } + else + { + DebugAssert (m_IB); + D3D11_CALL (ctx->IASetIndexBuffer (m_IB, DXGI_FORMAT_R16_UINT, 0)); + if (!SetTopologyD3D11 (kPrimitiveTriangles, device, ctx)) + return; + D3D11_CALL (ctx->DrawIndexed (m_LastChunkIndices, m_LastChunkStartIndex, m_LastChunkStartVertex)); + primCount = m_LastChunkIndices/3; + } + stats.AddDrawCall (primCount, m_LastChunkVertices); + DX11_MARK_DRAWING(primCount, m_LastChunkVertices); +} + + +#if UNITY_EDITOR +void DynamicD3D11VBO::DrawChunkUserPrimitives (GfxPrimitiveType type) +{ + // just return if nothing to render + if( !m_LastChunkShaderChannelMask ) + return; + + HRESULT hr; + + AssertIf( !m_LastChunkShaderChannelMask || !m_LastChunkStride ); + AssertIf( m_LendedChunk ); + + ChannelAssigns channels; + for( int i = 0; i < kShaderChannelCount; ++i ) + { + if (!(m_LastChunkShaderChannelMask & (1<<i))) + continue; + VertexComponent destComponent = kSuitableVertexComponentForChannel[i]; + channels.Bind ((ShaderChannel)i, destComponent); + } + + GfxDevice& device = GetRealGfxDevice(); + ID3D11DeviceContext* ctx = GetD3D11Context(); + + // setup VBO + DebugAssert (m_VB); + UINT strides = m_LastChunkStride; + UINT offsets = 0; + D3D11_CALL (ctx->IASetVertexBuffers(0, 1, &m_VB, &strides, &offsets)); + + UpdateChannelBindingsD3D11(channels); + device.BeforeDrawCall (false); + + ID3D11InputLayout* inputLayout = GetD3D11VertexDeclaration (m_LastChunkShaderChannelMask); + SetInputLayoutD3D11 (ctx, inputLayout); + + // draw + GfxDeviceStats& stats = device.GetFrameStats(); + int primCount = 0; + switch (type) + { + case kPrimitiveTriangles: + if (!SetTopologyD3D11(kPrimitiveTriangles,device,ctx)) + return; + D3D11_CALL (ctx->Draw (m_LastChunkVertices, m_LastChunkStartVertex)); + primCount = m_LastChunkVertices/3; + break; + case kPrimitiveQuads: + if (!SetTopologyD3D11(kPrimitiveTriangles,device,ctx)) + return; + // initialize quads index buffer if needed + if (!m_QuadsIB) + InitializeQuadsIB(); + // if quads index buffer has valid data, draw with it + if (m_QuadsIB) + { + D3D11_CALL (ctx->IASetIndexBuffer (m_QuadsIB, DXGI_FORMAT_R16_UINT, 0)); + D3D11_CALL (ctx->DrawIndexed (m_LastChunkVertices/4*6, 0, m_LastChunkStartVertex)); + primCount = m_LastChunkVertices/2; + } + break; + case kPrimitiveLines: + if (!SetTopologyD3D11(kPrimitiveLines,device,ctx)) + return; + D3D11_CALL (ctx->Draw (m_LastChunkVertices, m_LastChunkStartVertex)); + primCount = m_LastChunkVertices/2; + break; + case kPrimitiveLineStrip: + if (!SetTopologyD3D11(kPrimitiveLineStrip,device,ctx)) + return; + D3D11_CALL (ctx->Draw (m_LastChunkVertices, m_LastChunkStartVertex)); + primCount = m_LastChunkVertices-1; + break; + default: + ErrorString("Primitive type not supported"); + return; + } + stats.AddDrawCall (primCount, m_LastChunkVertices); +} +#endif // UNITY_EDITOR + + +bool DynamicD3D11VBO::GetChunk( UInt32 shaderChannelMask, UInt32 maxVertices, UInt32 maxIndices, RenderMode renderMode, void** outVB, void** outIB ) +{ + Assert( !m_LendedChunk ); + Assert( maxVertices < 65536 && maxIndices < 65536*3 ); + DebugAssertMsg(outVB != NULL && maxVertices > 0, "DynamicD3D11VBO::GetChunk - outVB: 0x%08x maxVertices: %d", outVB, maxVertices); + DebugAssertMsg( + (renderMode == kDrawIndexedQuads && (outIB != NULL && maxIndices > 0)) || + (renderMode == kDrawIndexedPoints && (outIB != NULL && maxIndices > 0)) || + (renderMode == kDrawIndexedLines && (outIB != NULL && maxIndices > 0)) || + (renderMode == kDrawIndexedTriangles && (outIB != NULL && maxIndices > 0)) || + (renderMode == kDrawIndexedTriangleStrip && (outIB != NULL && maxIndices > 0)) || + (renderMode == kDrawTriangleStrip && (outIB == NULL && maxIndices == 0)) || + (renderMode == kDrawQuads && (outIB == NULL && maxIndices == 0)), + "DynamicD3D11VBO::GetChunk - renderMode: %d outIB: 0x%08x maxIndices: %d", renderMode, outIB, maxIndices); + + HRESULT hr; + bool success = true; + + m_LendedChunk = true; + m_LastChunkShaderChannelMask = shaderChannelMask; + m_LastRenderMode = renderMode; + + if( maxVertices == 0 ) + maxVertices = 8; + + m_LastChunkStride = 0; + for( int i = 0; i < kShaderChannelCount; ++i ) { + if( shaderChannelMask & (1<<i) ) + m_LastChunkStride += VBO::GetDefaultChannelByteSize(i); + } + ID3D11Device* dev = GetD3D11Device(); + ID3D11DeviceContext* ctx = GetD3D11Context(); + + // -------- vertex buffer + + DebugAssertIf( !outVB ); + UInt32 vbCapacity = maxVertices * m_LastChunkStride; + // check if requested chunk is larger than current buffer + if( vbCapacity > m_VBSize ) { + m_VBSize = vbCapacity * 2; // allocate more up front + if( m_VB ) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_VB); + m_VB->Release(); + } + m_VB = NULL; + } + // allocate buffer if don't have it yet + if( !m_VB ) + { + D3D11_BUFFER_DESC desc; + desc.ByteWidth = m_VBSize; + desc.Usage = D3D11_USAGE_DYNAMIC; + desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + hr = dev->CreateBuffer (&desc, NULL, &m_VB); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(m_VB,m_VBSize,this); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to create dynamic vertex buffer of size %d [%x]\n", m_VBSize, hr); + success = false; + *outVB = NULL; + } + SetDebugNameD3D11 (m_VB, Format("VertexBufferDynamic-%d", m_VBSize)); + } + + // map, making sure the offset we lock is multiple of vertex stride + if (m_VB) + { + m_VBUsedBytes = ((m_VBUsedBytes + (m_LastChunkStride-1)) / m_LastChunkStride) * m_LastChunkStride; + if (m_VBUsedBytes + vbCapacity > m_VBSize) + { + D3D11_MAPPED_SUBRESOURCE mapped; + hr = ctx->Map (m_VB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to lock dynamic vertex buffer with discard [%x]\n", hr); + *outVB = NULL; + success = false; + } + *outVB = mapped.pData; + m_VBUsedBytes = 0; + } else { + D3D11_MAPPED_SUBRESOURCE mapped; + hr = ctx->Map (m_VB, 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &mapped); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to lock vertex index buffer, offset %i size %i [%x]\n", m_VBUsedBytes, vbCapacity, hr); + *outVB = NULL; + success = false; + } + *outVB = ((UInt8*)mapped.pData) + m_VBUsedBytes; + } + m_LastChunkStartVertex = m_VBUsedBytes / m_LastChunkStride; + DebugAssertIf( m_LastChunkStartVertex * m_LastChunkStride != m_VBUsedBytes ); + } + + // -------- index buffer + + const bool indexed = (renderMode != kDrawQuads) && (renderMode != kDrawTriangleStrip); + if( success && maxIndices && indexed ) + { + UInt32 ibCapacity = maxIndices * kVBOIndexSize; + // check if requested chunk is larger than current buffer + if( ibCapacity > m_IBSize ) { + m_IBSize = ibCapacity * 2; // allocate more up front + if( m_IB ) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_IB); + m_IB->Release(); + } + m_IB = NULL; + } + // allocate buffer if don't have it yet + if( !m_IB ) + { + D3D11_BUFFER_DESC desc; + desc.ByteWidth = m_IBSize; + desc.Usage = D3D11_USAGE_DYNAMIC; + desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + hr = dev->CreateBuffer (&desc, NULL, &m_IB); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(m_IB,m_IBSize,this); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to create dynamic index buffer of size %d [%x]\n", m_IBSize, hr); + if (m_VB) + ctx->Unmap (m_VB, 0); + } + SetDebugNameD3D11 (m_IB, Format("IndexBufferDynamic-%d", m_IBSize)); + } + // lock it if we have IB created successfully + if( m_IB ) + { + if( m_IBUsedBytes + ibCapacity > m_IBSize ) + { + D3D11_MAPPED_SUBRESOURCE mapped; + hr = ctx->Map (m_IB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to lock dynamic index buffer with discard [%x]\n", hr); + *outIB = NULL; + success = false; + if (m_VB) + ctx->Unmap (m_VB, 0); + } + *outIB = mapped.pData; + m_IBUsedBytes = 0; + } else { + D3D11_MAPPED_SUBRESOURCE mapped; + hr = ctx->Map (m_IB, 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &mapped); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to lock dynamic index buffer, offset %i size %i [%x]\n", m_IBUsedBytes, ibCapacity, hr); + *outIB = NULL; + success = false; + if (m_VB) + ctx->Unmap (m_VB, 0); + } + *outIB = ((UInt8*)mapped.pData) + m_IBUsedBytes; + } + m_LastChunkStartIndex = m_IBUsedBytes / 2; + } + else + { + *outIB = NULL; + success = false; + } + } + + if( !success ) + m_LendedChunk = false; + + return success; +} + +void DynamicD3D11VBO::ReleaseChunk( UInt32 actualVertices, UInt32 actualIndices ) +{ + Assert( m_LendedChunk ); + Assert( m_LastRenderMode == kDrawIndexedTriangleStrip || m_LastRenderMode == kDrawIndexedQuads || m_LastRenderMode == kDrawIndexedPoints || m_LastRenderMode == kDrawIndexedLines || actualIndices % 3 == 0 ); + m_LendedChunk = false; + + const bool indexed = (m_LastRenderMode != kDrawQuads) && (m_LastRenderMode != kDrawTriangleStrip); + + m_LastChunkVertices = actualVertices; + m_LastChunkIndices = actualIndices; + + // unlock buffers + ID3D11DeviceContext* ctx = GetD3D11Context(); + ctx->Unmap (m_VB, 0); + if (indexed) + ctx->Unmap (m_IB, 0); + + if( !actualVertices || (indexed && !actualIndices) ) { + m_LastChunkShaderChannelMask = 0; + return; + } + + UInt32 actualVBSize = actualVertices * m_LastChunkStride; + m_VBUsedBytes += actualVBSize; + UInt32 actualIBSize = actualIndices * kVBOIndexSize; + m_IBUsedBytes += actualIBSize; +} + + diff --git a/Runtime/GfxDevice/d3d11/D3D11VBO.h b/Runtime/GfxDevice/d3d11/D3D11VBO.h new file mode 100644 index 0000000..9c0d0d2 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11VBO.h @@ -0,0 +1,99 @@ +#pragma once + +#include "Runtime/Shaders/VBO.h" +#include "D3D11Includes.h" + +class GfxDevice; + +class D3D11VBO : public VBO { +public: + D3D11VBO(); + virtual ~D3D11VBO(); + + virtual void UpdateVertexData( const VertexBufferData& buffer ); + virtual void UpdateIndexData (const IndexBufferData& buffer); + virtual void DrawVBO (const ChannelAssigns& channels, UInt32 firstIndexByte, UInt32 indexCount, GfxPrimitiveType topology, UInt32 firstVertex, UInt32 vertexCount ); + #if GFX_ENABLE_DRAW_CALL_BATCHING + virtual void DrawCustomIndexed( const ChannelAssigns& channels, void* indices, UInt32 indexCount, + GfxPrimitiveType topology, UInt32 vertexRangeBegin, UInt32 vertexRangeEnd, UInt32 drawVertexCount ) ; + #endif + virtual bool MapVertexStream( VertexStreamData& outData, unsigned stream ); + virtual void UnmapVertexStream( unsigned stream ); + virtual bool IsVertexBufferLost() const; + + virtual void SetIndicesDynamic(bool dynamic); + + virtual int GetRuntimeMemorySize() const; + + static void CleanupSharedBuffers(); + + virtual void UseAsStreamOutput() { m_useForSO = true; } + void BindToStreamOutput(); + void UnbindFromStreamOutput(); + +private: + void UpdateVertexStream (const VertexBufferData& sourceData, unsigned stream); + void UpdateIndexBufferData (const IndexBufferData& sourceData); + void BindVertexStreams (GfxDevice& device, ID3D11DeviceContext* ctx, const ChannelAssigns& channels); + + static UInt16* MapDynamicIndexBuffer (int indexCount, UInt32& outBytesUsed); + static void UnmapDynamicIndexBuffer (); + + static ID3D11Buffer* GetAllWhiteBuffer(); + +private: + int m_VertexCount; + + ID3D11Buffer* m_VBStreams[kMaxVertexStreams]; + ChannelInfoArray m_ChannelInfo; + ID3D11Buffer* m_StagingVB[kMaxVertexStreams]; + ID3D11Buffer* m_IB; + ID3D11Buffer* m_StagingIB; + UInt16* m_IBReadable; + int m_IBSize; + bool m_useForSO; + + static ID3D11Buffer* ms_CustomIB; + static int ms_CustomIBSize; + static UInt32 ms_CustomIBUsedBytes; + static ID3D11Buffer* ms_AllWhiteBuffer; +}; + + +class DynamicD3D11VBO : public DynamicVBO { +public: + DynamicD3D11VBO( UInt32 vbSize, UInt32 ibSize ); + virtual ~DynamicD3D11VBO(); + + virtual bool GetChunk( UInt32 shaderChannelMask, UInt32 maxVertices, UInt32 maxIndices, RenderMode mode, void** outVB, void** outIB ); + virtual void ReleaseChunk( UInt32 actualVertices, UInt32 actualIndices ); + virtual void DrawChunk (const ChannelAssigns& channels); + + ID3D11Buffer* GetQuadsIB() + { + if (!m_QuadsIB) + InitializeQuadsIB(); + return m_QuadsIB; + } + + #if UNITY_EDITOR + void DrawChunkUserPrimitives (GfxPrimitiveType type); + #endif + +private: + void InitializeQuadsIB(); + +private: + UInt32 m_VBSize; + UInt32 m_VBUsedBytes; + UInt32 m_IBSize; + UInt32 m_IBUsedBytes; + + ID3D11Buffer* m_VB; + ID3D11Buffer* m_IB; + + UInt32 m_LastChunkStartVertex; + UInt32 m_LastChunkStartIndex; + + ID3D11Buffer* m_QuadsIB; +}; diff --git a/Runtime/GfxDevice/d3d11/D3D11Window.cpp b/Runtime/GfxDevice/d3d11/D3D11Window.cpp new file mode 100644 index 0000000..bdf2e1f --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11Window.cpp @@ -0,0 +1,220 @@ +#include "UnityPrefix.h" +#include "D3D11Window.h" +#include "D3D11Context.h" +#include "Runtime/GfxDevice/GfxDevice.h" +#include "Runtime/Math/ColorSpaceConversion.h" +#include "Runtime/Misc/QualitySettings.h" + + +#if UNITY_EDITOR + +static D3D11Window* s_CurrentD3D11Window = NULL; +static int s_CurrentD3D11AA = 0; + +void SetNoRenderTextureActiveEditor(); // RenderTexture.cpp +void InternalDestroyRenderSurfaceD3D11 (RenderSurfaceD3D11* rs, TexturesD3D11* textures); // RenderTextureD3D11.cpp +bool InitD3D11RenderDepthSurface (RenderDepthSurfaceD3D11& rs, TexturesD3D11* textures, bool sampleOnly); + + +D3D11Window::D3D11Window (HWND window, int width, int height, DepthBufferFormat depthFormat, int antiAlias) +: GfxDeviceWindow(window, width, height, depthFormat, antiAlias) +, m_SwapChain(NULL) +, m_AntiAlias(0) +{ + Reshape (width, height, depthFormat, antiAlias); +} + +D3D11Window::~D3D11Window() +{ + if (s_CurrentD3D11Window == this) + { + s_CurrentD3D11Window = NULL; + s_CurrentD3D11AA = 0; + } + + InternalDestroyRenderSurfaceD3D11 (&m_DepthStencil, NULL); + InternalDestroyRenderSurfaceD3D11 (&m_BackBuffer, NULL); + SAFE_RELEASE (m_SwapChain); +} + +bool D3D11Window::Reshape (int width, int height, DepthBufferFormat depthFormat, int antiAlias) +{ + if (!GfxDeviceWindow::Reshape(width, height, depthFormat, antiAlias)) + return false; + + // release old + SAFE_RELEASE(m_DepthStencil.m_Texture); + SAFE_RELEASE(m_DepthStencil.m_SRView); + SAFE_RELEASE(m_DepthStencil.m_DSView); + m_BackBuffer.Reset(); + SAFE_RELEASE(m_SwapChain); + + // pick supported AA level + if (antiAlias == -1) + antiAlias = GetQualitySettings().GetCurrent().antiAliasing; + while (antiAlias > 1 && !(gGraphicsCaps.d3d11.msaa & (1<<antiAlias))) + --antiAlias; + antiAlias = std::max(antiAlias, 1); + + HRESULT hr; + + const bool sRGB = GetActiveColorSpace() == kLinearColorSpace; + + const bool createSRV = (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0); // swap chain can't have SRV before 10.0, it seems + + DXGI_SWAP_CHAIN_DESC sd; + ZeroMemory (&sd, sizeof(DXGI_SWAP_CHAIN_DESC)); + sd.BufferCount = 1; + sd.BufferDesc.Width = m_Width; + sd.BufferDesc.Height = m_Height; + sd.BufferDesc.Format = sRGB ? DXGI_FORMAT_R8G8B8A8_UNORM_SRGB : DXGI_FORMAT_R8G8B8A8_UNORM; + sd.BufferDesc.RefreshRate.Numerator = 0; + sd.BufferDesc.RefreshRate.Denominator = 1; + sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + if (createSRV) + sd.BufferUsage |= DXGI_USAGE_SHADER_INPUT; + sd.OutputWindow = m_Window; + sd.SampleDesc.Count = antiAlias; + sd.SampleDesc.Quality = 0; + sd.Windowed = TRUE; + + hr = GetDXGIFactory()->CreateSwapChain (GetD3D11Device(), &sd, &m_SwapChain); + Assert(SUCCEEDED(hr)); + + if (FAILED(hr)) + { + printf_console ("d3d11: swap chain: w=%i h=%i fmt=%i\n", + sd.BufferDesc.Width, sd.BufferDesc.Height, sd.BufferDesc.Format); + printf_console ("d3d11: failed to create swap chain [0x%x]\n", hr); + m_InvalidState = true; + return !m_InvalidState; + } + + //@TODO: false if AA is used? + m_CanUseBlitOptimization = true; + m_AntiAlias = 0; + + // Swap Chain + ID3D11Texture2D* backBufferTexture; + hr = m_SwapChain->GetBuffer (0, __uuidof(*backBufferTexture), (void**)&backBufferTexture); + Assert(SUCCEEDED(hr)); + + // Set the primary backbuffer view + ID3D11RenderTargetView* rtView; + D3D11_RENDER_TARGET_VIEW_DESC rtDesc; + rtDesc.Format = sRGB ? DXGI_FORMAT_R8G8B8A8_UNORM_SRGB : DXGI_FORMAT_R8G8B8A8_UNORM; + rtDesc.ViewDimension = antiAlias > 1 ? D3D11_RTV_DIMENSION_TEXTURE2DMS : D3D11_RTV_DIMENSION_TEXTURE2D; + rtDesc.Texture2D.MipSlice = 0; + hr = GetD3D11Device()->CreateRenderTargetView (backBufferTexture, &rtDesc, &rtView); + Assert(SUCCEEDED(hr)); + + // Set the secondary backbuffer view + ID3D11RenderTargetView* rtViewSecondary; + D3D11_RENDER_TARGET_VIEW_DESC rtDescSecondary; + rtDescSecondary.Format = !sRGB ? DXGI_FORMAT_R8G8B8A8_UNORM_SRGB : DXGI_FORMAT_R8G8B8A8_UNORM; + rtDescSecondary.ViewDimension = antiAlias > 1 ? D3D11_RTV_DIMENSION_TEXTURE2DMS : D3D11_RTV_DIMENSION_TEXTURE2D; + rtDescSecondary.Texture2D.MipSlice = 0; + hr = GetD3D11Device()->CreateRenderTargetView (backBufferTexture, &rtDescSecondary, &rtViewSecondary); + Assert(SUCCEEDED(hr)); + + // Create shader resource view + if (createSRV) + { + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = sd.BufferDesc.Format; + srvDesc.ViewDimension = antiAlias > 1 ? D3D11_SRV_DIMENSION_TEXTURE2DMS : D3D11_SRV_DIMENSION_TEXTURE2D; + srvDesc.Texture2D.MostDetailedMip = 0; + srvDesc.Texture2D.MipLevels = 1; + ID3D11ShaderResourceView* srView = NULL; + hr = GetD3D11Device()->CreateShaderResourceView (backBufferTexture, &srvDesc, &m_BackBuffer.m_SRView); + Assert (SUCCEEDED(hr)); + } + + //Pass through flags + m_BackBuffer.m_Texture = backBufferTexture; + m_BackBuffer.SetRTV (0, 0, false, rtView); + m_BackBuffer.SetRTV (0, 0, true, rtViewSecondary); + m_BackBuffer.width = sd.BufferDesc.Width; + m_BackBuffer.height = sd.BufferDesc.Height; + m_BackBuffer.samples = antiAlias; + m_BackBuffer.format = kRTFormatARGB32; + m_BackBuffer.backBuffer = true; + m_BackBuffer.flags = sRGB ? (m_BackBuffer.flags | kSurfaceCreateSRGB) : (m_BackBuffer.flags & ~kSurfaceCreateSRGB); + + // Depth stencil + m_DepthStencil.width = m_Width; + m_DepthStencil.height = m_Height; + m_DepthStencil.samples = antiAlias; + m_DepthStencil.depthFormat = depthFormat; + m_DepthStencil.backBuffer = true; + + bool dsOk = InitD3D11RenderDepthSurface (m_DepthStencil, NULL, false); + Assert (dsOk); + + return !m_InvalidState; +} + +void D3D11Window::SetAsActiveWindow () +{ + GfxDevice& device = GetRealGfxDevice(); + device.SetRenderTargets(1, &GetBackBuffer(), GetDepthStencil()); + device.SetActiveRenderTexture(NULL); + device.SetCurrentWindowSize(m_Width, m_Height); + device.SetInvertProjectionMatrix(false); + + s_CurrentD3D11Window = this; + s_CurrentD3D11AA = m_AntiAlias; +} + +bool D3D11Window::BeginRendering() +{ + if (!GfxDeviceWindow::BeginRendering()) + return false; + + SetAsActiveWindow (); + + GfxDevice& device = GetRealGfxDevice(); + if (device.IsInsideFrame()) + { + ErrorString ("GUI Window tries to begin rendering while something else has not finished rendering! Either you have a recursive OnGUI rendering, or previous OnGUI did not clean up properly."); + } + device.SetInsideFrame(true); + + return true; +} + +bool D3D11Window::EndRendering( bool presentContent ) +{ + if (!GfxDeviceWindow::EndRendering(presentContent)) + return false; + + GfxDevice& device = GetRealGfxDevice(); + Assert(device.IsInsideFrame()); + device.SetInsideFrame(false); + + s_CurrentD3D11Window = NULL; + + HRESULT hr; + if (m_SwapChain && presentContent) + { + HRESULT hr = m_SwapChain->Present (0, 0); + Assert (SUCCEEDED(hr)); + } + return true; +} + +RenderSurfaceHandle D3D11Window::GetBackBuffer() +{ + RenderSurfaceHandle handle; + handle.object = &m_BackBuffer; + return handle; +} + +RenderSurfaceHandle D3D11Window::GetDepthStencil() +{ + RenderSurfaceHandle handle; + handle.object = &m_DepthStencil; + return handle; +} + +#endif diff --git a/Runtime/GfxDevice/d3d11/D3D11Window.h b/Runtime/GfxDevice/d3d11/D3D11Window.h new file mode 100644 index 0000000..e269cf2 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11Window.h @@ -0,0 +1,28 @@ +#pragma once + +#include "External/DirectX/builds/dx11include/d3d11.h" +#include "Runtime/GfxDevice/GfxDeviceWindow.h" +#include "Runtime/GfxDevice/GfxDeviceObjects.h" +#include "TexturesD3D11.h" + +class D3D11Window : public GfxDeviceWindow +{ +private: + IDXGISwapChain* m_SwapChain; + RenderColorSurfaceD3D11 m_BackBuffer; + RenderDepthSurfaceD3D11 m_DepthStencil; + int m_AntiAlias; + +public: + D3D11Window (HWND window, int width, int height, DepthBufferFormat depthFormat, int antiAlias); + ~D3D11Window (); + + bool Reshape (int width, int height, DepthBufferFormat depthFormat, int antiAlias); + + bool BeginRendering (); + bool EndRendering (bool presentContent); + void SetAsActiveWindow (); + + RenderSurfaceHandle GetBackBuffer(); + RenderSurfaceHandle GetDepthStencil(); +}; diff --git a/Runtime/GfxDevice/d3d11/FixedFunctionStateD3D11.h b/Runtime/GfxDevice/d3d11/FixedFunctionStateD3D11.h new file mode 100644 index 0000000..e174f26 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/FixedFunctionStateD3D11.h @@ -0,0 +1,98 @@ +#pragma once + +#include "Runtime/GfxDevice/GfxDeviceTypes.h" + + +enum TextureSourceD3D11 { + kTexSourceUV0, + kTexSourceUV1, + kTexSourceUV2, + kTexSourceUV3, + kTexSourceUV4, + kTexSourceUV5, + kTexSourceUV6, + kTexSourceUV7, + // match the order of TexGenMode! + kTexSourceSphereMap, + kTexSourceObject, + kTexSourceEyeLinear, + kTexSourceCubeReflect, + kTexSourceCubeNormal, + kTexSourceTypeCount +}; + +#define CMP_STATE(member) { \ + if (a.member < b.member) \ + return true; \ + else if (b.member < a.member) \ + return false; \ + } + + +struct FixedFunctionStateD3D11 +{ + FixedFunctionStateD3D11() + : texUnitSources(0) + , texUnitCube(0) + , texUnit3D(0) + , texUnitProjected(0) + , texUnitCount(0) + , alphaTest(kFuncDisabled) + , useUniformInsteadOfVertexColor(false) + , lightingEnabled(false) + , specularEnabled(false) + , lightCount(0) + , colorMaterial(kColorMatDisabled) + , fogMode(kFogDisabled) + { + for (int i = 0; i < kMaxSupportedTextureUnits; ++i) + { + texUnitColorCombiner[i] = ~0U; + texUnitAlphaCombiner[i] = ~0U; + } + } + + UInt64 texUnitSources; // 4 bits for each unit + UInt32 texUnitColorCombiner[kMaxSupportedTextureUnits]; + UInt32 texUnitAlphaCombiner[kMaxSupportedTextureUnits]; + UInt32 texUnitCube; // bit per unit + UInt32 texUnit3D; // bit per unit + UInt32 texUnitProjected; // bit per unit + + int texUnitCount; + CompareFunction alphaTest; + + bool useUniformInsteadOfVertexColor; + bool lightingEnabled; + bool specularEnabled; + int lightCount; + ColorMaterialMode colorMaterial; + FogMode fogMode; +}; + + +struct FixedFuncStateCompareD3D11 +{ + bool operator() (const FixedFunctionStateD3D11& a, const FixedFunctionStateD3D11& b) const + { + CMP_STATE(lightingEnabled); + CMP_STATE(specularEnabled); + CMP_STATE(lightCount); + CMP_STATE(texUnitCount); + CMP_STATE(texUnitSources); + CMP_STATE(texUnitCube); + CMP_STATE(texUnit3D); + CMP_STATE(texUnitProjected); + CMP_STATE(alphaTest); + for (int i = 0; i < a.texUnitCount; i++) + { + CMP_STATE(texUnitColorCombiner[i]) + CMP_STATE(texUnitAlphaCombiner[i]) + } + CMP_STATE(useUniformInsteadOfVertexColor); + CMP_STATE(colorMaterial); + CMP_STATE(fogMode); + + return false; + } +}; diff --git a/Runtime/GfxDevice/d3d11/GfxDeviceD3D11.cpp b/Runtime/GfxDevice/d3d11/GfxDeviceD3D11.cpp new file mode 100644 index 0000000..237ae6c --- /dev/null +++ b/Runtime/GfxDevice/d3d11/GfxDeviceD3D11.cpp @@ -0,0 +1,3133 @@ +#include "UnityPrefix.h" +#include "Runtime/GfxDevice/GfxDevice.h" +#include "Runtime/Shaders/GraphicsCaps.h" +#include "D3D11Context.h" +#include "D3D11VBO.h" +#include "External/shaderlab/Library/program.h" +#include "Runtime/GfxDevice/ChannelAssigns.h" +#include "Runtime/GfxDevice/GpuProgramParamsApply.h" +#include "External/shaderlab/Library/TextureBinding.h" +#include "External/shaderlab/Library/properties.h" +#include "D3D11Utils.h" +#include "GpuProgramsD3D11.h" +#include "ShaderPatchingD3D11.h" +#include "TimerQueryD3D11.h" +#include "PlatformDependent/Win/SmartComPointer.h" +#include "PlatformDependent/Win/WinUnicode.h" +#include "Runtime/Camera/CameraUtil.h" +#include "Runtime/Graphics/GraphicsHelper.h" +#include "Runtime/Graphics/Image.h" +#include "Runtime/Utilities/ArrayUtility.h" +#include "Runtime/Misc/Plugins.h" +#if UNITY_EDITOR +#include "D3D11Window.h" +#endif +#include "Runtime/GfxDevice/d3d11/StreamOutSkinnedMesh.h" + +class GfxDeviceD3D11; + +namespace ShaderLab { + TexEnv* GetTexEnvForBinding( const TextureBinding& binding, const PropertySheet* props ); // pass.cpp +} + + +#include "GfxDeviceD3D11.h" + +extern const InputSignatureD3D11* g_CurrentVSInputD3D11; +extern ID3D11InputLayout* g_ActiveInputLayoutD3D11; +extern D3D11_PRIMITIVE_TOPOLOGY g_ActiveTopologyD3D11; + + +static ShaderLab::FastPropertyName kSLPropFogCB = ShaderLab::Property ("UnityFogPatchCB"); + + + +static const D3D11_COMPARISON_FUNC kCmpFuncD3D11[] = { + D3D11_COMPARISON_ALWAYS, D3D11_COMPARISON_NEVER, D3D11_COMPARISON_LESS, D3D11_COMPARISON_EQUAL, D3D11_COMPARISON_LESS_EQUAL, D3D11_COMPARISON_GREATER, D3D11_COMPARISON_NOT_EQUAL, D3D11_COMPARISON_GREATER_EQUAL, D3D11_COMPARISON_ALWAYS +}; + +static const D3D11_STENCIL_OP kStencilOpD3D11[] = { + D3D11_STENCIL_OP_KEEP, D3D11_STENCIL_OP_ZERO, D3D11_STENCIL_OP_REPLACE, D3D11_STENCIL_OP_INCR_SAT, + D3D11_STENCIL_OP_DECR_SAT, D3D11_STENCIL_OP_INVERT, D3D11_STENCIL_OP_INCR, D3D11_STENCIL_OP_DECR +}; + +// Graphics device requires access to reset render textures +bool RebindActiveRenderTargets (TexturesD3D11* textures); + +DXGI_FORMAT GetRenderTextureFormat (RenderTextureFormat format, bool sRGB); +DXGI_FORMAT GetShaderResourceViewFormat (RenderTextureFormat format, bool sRGB); +extern DXGI_FORMAT kD3D11RenderResourceFormats[kRTFormatCount]; +extern DXGI_FORMAT kD3D11RenderTextureFormatsNorm[kRTFormatCount]; + + +bool SetTopologyD3D11 (GfxPrimitiveType topology, GfxDevice& device, ID3D11DeviceContext* ctx); +void SetInputLayoutD3D11 (ID3D11DeviceContext* ctx, ID3D11InputLayout* layout); + + +// -------------------------------------------------------------------------- + + +ResolveTexturePool::ResolveTexturePool() +: m_UseCounter(0) +{ + memset (m_Entries, 0, sizeof(m_Entries)); +} + +void ResolveTexturePool::Clear() +{ + for (int i = 0; i < ARRAY_SIZE(m_Entries); ++i) + { + SAFE_RELEASE(m_Entries[i].texture); + SAFE_RELEASE(m_Entries[i].srv); + } +} + +ResolveTexturePool::Entry* ResolveTexturePool::GetResolveTexture (int width, int height, RenderTextureFormat fmt, bool sRGB) +{ + ++m_UseCounter; + + // check if we have a suitable temporary resolve texture already? + int newIndex = -1; + int lruIndex = 0; + int lruScore = 0; + for (int i = 0; i < ARRAY_SIZE(m_Entries); ++i) + { + Entry& e = m_Entries[i]; + if (e.width == width && e.height == height && e.format == fmt && e.sRGB == sRGB) + { + Assert (e.texture); + Assert (e.srv); + e.lastUse = m_UseCounter; + return &e; + } + + if (e.width == 0) + { + // unused slot + Assert (e.height == 0 && !e.texture && !e.srv); + if (newIndex == -1) + newIndex = i; + } + else + { + // used slot + if (m_UseCounter - e.lastUse > lruScore) + { + lruIndex = i; + lruScore = m_UseCounter - e.lastUse; + } + } + } + + // if all slots are used; release least recently used + if (newIndex == -1) + { + Entry& e = m_Entries[lruIndex]; + Assert (e.texture); + e.width = e.height = 0; + SAFE_RELEASE(e.texture); + SAFE_RELEASE(e.srv); + newIndex = lruIndex; + } + + Entry& ee = m_Entries[newIndex]; + + // create texture & SRV in this slot + + ID3D11Device* dev = GetD3D11Device(); + D3D11_TEXTURE2D_DESC tDesc; + tDesc.Width = width; + tDesc.Height = height; + tDesc.MipLevels = 1; + tDesc.ArraySize = 1; + tDesc.Format = (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0 ? kD3D11RenderResourceFormats[fmt] : kD3D11RenderTextureFormatsNorm[fmt]); + + tDesc.SampleDesc.Count = 1; + tDesc.SampleDesc.Quality = 0; + tDesc.Usage = D3D11_USAGE_DEFAULT; + tDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE; + // 9.x feature levels require the resolved texture to also have a render target flag, otherwise + // CopySubresourceRegion will silently corrupt runtime/driver state. + if (gGraphicsCaps.d3d11.featureLevel < kDX11Level10_0) + tDesc.BindFlags |= D3D11_BIND_RENDER_TARGET; + + tDesc.CPUAccessFlags = 0; + tDesc.MiscFlags = 0; + + HRESULT hr = dev->CreateTexture2D (&tDesc, NULL, &ee.texture); + if (FAILED(hr)) + return NULL; + SetDebugNameD3D11 (ee.texture, Format("ResolveTexture2D-%dx%d", width, height)); + + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = GetShaderResourceViewFormat (fmt, (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0) ? sRGB : false); + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; + srvDesc.Texture2D.MostDetailedMip = 0; + srvDesc.Texture2D.MipLevels = 1; + hr = dev->CreateShaderResourceView (ee.texture, &srvDesc, &ee.srv); + if (FAILED(hr)) + return NULL; + SetDebugNameD3D11 (ee.srv, Format("ResolveTexture2D-SRV-%dx%d", width, height)); + + ee.width = width; + ee.height = height; + ee.format = fmt; + ee.sRGB = sRGB; + ee.lastUse = m_UseCounter; + + return ⅇ +} + + +// -------------------------------------------------------------------------- + + +static FixedFunctionProgramD3D11* GetFixedFunctionProgram11 (FFProgramCacheD3D11& cache, const FixedFunctionStateD3D11& state) +{ + // Do we have one for this state already? + FFProgramCacheD3D11::iterator cachedProgIt = cache.find (state); + if (cachedProgIt != cache.end()) + return cachedProgIt->second; + + // Don't have one yet, create it + FixedFunctionProgramD3D11* ffProg = new FixedFunctionProgramD3D11 (state); + cache.insert (std::make_pair(state, ffProg)); + return ffProg; +} + + + +// -------------------------------------------------------------------------- + + + +void GfxDeviceD3D11::SetupDeferredDepthStencilState () +{ + ID3D11DepthStencilState* dss = m_CurrDSState; + if (!dss) + { + DepthStencilState state; + memset (&state, 0, sizeof(state)); + if (m_CurrDepthState) + state.d = *m_CurrDepthState; + if (m_CurrStencilState) + state.s = *m_CurrStencilState; + + CachedDepthStencilStates::iterator it = m_CachedDepthStencilStates.find(state); + if (it == m_CachedDepthStencilStates.end()) + { + D3D11_DEPTH_STENCIL_DESC desc; + memset (&desc, 0, sizeof(desc)); + if (m_CurrDepthState) + { + desc.DepthEnable = TRUE; + desc.DepthWriteMask = (m_CurrDepthState->sourceState.depthWrite ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO); + desc.DepthFunc = kCmpFuncD3D11[m_CurrDepthState->sourceState.depthFunc]; + } + if (m_CurrStencilState) + { + desc.StencilEnable = m_CurrStencilState->sourceState.stencilEnable; + desc.StencilReadMask = m_CurrStencilState->sourceState.readMask; + desc.StencilWriteMask = m_CurrStencilState->sourceState.writeMask; + desc.FrontFace.StencilFunc = kCmpFuncD3D11[m_CurrStencilState->sourceState.stencilFuncFront]; + desc.FrontFace.StencilFailOp = kStencilOpD3D11[m_CurrStencilState->sourceState.stencilFailOpFront]; + desc.FrontFace.StencilDepthFailOp = kStencilOpD3D11[m_CurrStencilState->sourceState.stencilZFailOpFront]; + desc.FrontFace.StencilPassOp = kStencilOpD3D11[m_CurrStencilState->sourceState.stencilPassOpFront]; + desc.BackFace.StencilFunc = kCmpFuncD3D11[m_CurrStencilState->sourceState.stencilFuncBack]; + desc.BackFace.StencilFailOp = kStencilOpD3D11[m_CurrStencilState->sourceState.stencilFailOpBack]; + desc.BackFace.StencilDepthFailOp = kStencilOpD3D11[m_CurrStencilState->sourceState.stencilZFailOpBack]; + desc.BackFace.StencilPassOp = kStencilOpD3D11[m_CurrStencilState->sourceState.stencilPassOpBack]; + } + + ID3D11DepthStencilState* d3dstate = NULL; + HRESULT hr = GetD3D11Device()->CreateDepthStencilState (&desc, &d3dstate); + Assert(SUCCEEDED(hr)); + SetDebugNameD3D11 (d3dstate, Format("DepthStencilState-%d-%d", desc.DepthWriteMask, desc.DepthFunc)); + it = m_CachedDepthStencilStates.insert (std::make_pair(state, d3dstate)).first; + } + dss = it->second; + } + if (dss != m_CurrDSState || m_StencilRef != m_CurrStencilRef) + { + GetD3D11Context()->OMSetDepthStencilState (dss, m_StencilRef); + m_CurrDSState = dss; + m_CurrStencilRef = m_StencilRef; + } +} + +void GfxDeviceD3D11::SetupDeferredRasterState () +{ + // raster state; needs to be deferred due to cull winding / scissor / wireframe + // not known at creation time + if (!m_CurrRasterState) + return; + + ID3D11RasterizerState* rss = m_CurrRSState; + if (!rss) + { + FinalRasterState11 rsKey; + memcpy (&rsKey.raster, &m_CurrRasterState->sourceState, sizeof(rsKey.raster)); + rsKey.backface = (m_CurrRasterState->sourceState.cullMode != kCullOff) && ((m_AppBackfaceMode==m_UserBackfaceMode) == m_InvertProjMatrix); + rsKey.wireframe = m_Wireframe; + rsKey.scissor = m_Scissor; + + CachedFinalRasterStates::iterator it = m_CachedFinalRasterStates.find(rsKey); + if (it == m_CachedFinalRasterStates.end()) + { + D3D11_RASTERIZER_DESC desc; + memset (&desc, 0, sizeof(desc)); + + desc.FrontCounterClockwise = rsKey.backface ? TRUE : FALSE; + //TODO: wtf??? DepthBias doesn't work at 9.1 + if (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0) + desc.DepthBias = rsKey.raster.sourceState.depthBias; + desc.SlopeScaledDepthBias = rsKey.raster.sourceState.slopeScaledDepthBias; + desc.ScissorEnable = m_Scissor; + desc.MultisampleEnable = TRUE; // only applies to line drawing in MSAA; if set to FALSE lines will be aliased even when MSAA is used + desc.DepthClipEnable = TRUE; + desc.FillMode = rsKey.wireframe ? D3D11_FILL_WIREFRAME : D3D11_FILL_SOLID; + switch (rsKey.raster.sourceState.cullMode) + { + case kCullOff: desc.CullMode = D3D11_CULL_NONE; break; + case kCullFront: desc.CullMode = D3D11_CULL_FRONT; break; + case kCullBack: desc.CullMode = D3D11_CULL_BACK; break; + default: AssertIf("Unsupported cull mode!"); + } + ID3D11RasterizerState* d3dstate = NULL; + HRESULT hr = GetD3D11Device()->CreateRasterizerState (&desc, &d3dstate); + Assert(SUCCEEDED(hr)); + SetDebugNameD3D11 (d3dstate, Format("RasterizerState-%d-%d", desc.FrontCounterClockwise, desc.FillMode)); + it = m_CachedFinalRasterStates.insert (std::make_pair(rsKey, d3dstate)).first; + } + rss = it->second; + } + if (rss != m_CurrRSState) + { + GetD3D11Context()->RSSetState (rss); + m_CurrRSState = rss; + } +} + + +void UpdateChannelBindingsD3D11 (const ChannelAssigns& channels) +{ + DX11_LOG_ENTER_FUNCTION("UpdateChannelBindingsD3D11"); + GfxDeviceD3D11& device = static_cast<GfxDeviceD3D11&>(GetRealGfxDevice()); + if (!device.IsShaderActive(kShaderVertex)) + { + const int maxTexCoords = gGraphicsCaps.maxTexCoords; // fetch here once + UInt64 textureSources = device.m_FFState.texUnitSources; + for (int i = 0; i < maxTexCoords; ++i) + { + UInt32 source = (textureSources >> (i*4)) & 0xF; + if (source > kTexSourceUV7) + continue; + ShaderChannel texCoordChannel = channels.GetSourceForTarget ((VertexComponent)(kVertexCompTexCoord0 + i)); + if (texCoordChannel == kShaderChannelTexCoord0) + textureSources = textureSources & ~(0xFUL<<i*4) | (UInt64(kTexSourceUV0)<<i*4); + else if (texCoordChannel == kShaderChannelTexCoord1) + textureSources = textureSources & ~(0xFUL<<i*4) | (UInt64(kTexSourceUV1)<<i*4); + else if (texCoordChannel != kShaderChannelNone) { + AssertString( "Bad texcoord index" ); + } + } + device.m_FFState.texUnitSources = textureSources; + } + + device.m_FFState.useUniformInsteadOfVertexColor = !(channels.GetTargetMap() & (1<<kVertexCompColor)); +} + + +struct SetValuesFunctorD3D11 +{ + SetValuesFunctorD3D11(GfxDevice& device, ConstantBuffersD3D11& cbs) : m_Device(device), m_CBs(cbs) { } + GfxDevice& m_Device; + ConstantBuffersD3D11& m_CBs; + void SetVectorVal (ShaderType shaderType, ShaderParamType type, int index, const float* ptr, int cols, const GpuProgramParameters& params, int cbIndex) + { + const GpuProgramParameters::ConstantBuffer& cb = params.GetConstantBuffers()[cbIndex]; + int idx = m_CBs.FindAndBindCB (cb.m_Name.index, shaderType, cb.m_BindIndex, cb.m_Size); + if (type != kShaderParamInt) + m_CBs.SetCBConstant (idx, index, ptr, cols*4); + else + { + int vali[4] = {ptr[0], ptr[1], ptr[2], ptr[3]}; + m_CBs.SetCBConstant (idx, index, vali, cols*4); + } + } + void SetMatrixVal (ShaderType shaderType, int index, const Matrix4x4f* ptr, int rows, const GpuProgramParameters& params, int cbIndex) + { + DebugAssert(rows == 4); + const GpuProgramParameters::ConstantBuffer& cb = params.GetConstantBuffers()[cbIndex]; + int idx = m_CBs.FindAndBindCB (cb.m_Name.index, shaderType, cb.m_BindIndex, cb.m_Size); + m_CBs.SetCBConstant (idx, index, ptr, 64); + } + void SetTextureVal (ShaderType shaderType, int index, int samplerIndex, TextureDimension dim, TextureID texID) + { + m_Device.SetTexture (shaderType, index, samplerIndex, texID, dim, std::numeric_limits<float>::infinity()); + } +}; + + +void GfxDeviceD3D11::BeforeDrawCall( bool immediateMode ) +{ + DX11_LOG_ENTER_FUNCTION("GfxDeviceD3D11::BeforeDrawCall"); + ID3D11DeviceContext* ctx = GetD3D11Context(); + HRESULT hr; + + SetupDeferredSRGBWrite (); + SetupDeferredDepthStencilState (); + SetupDeferredRasterState (); + + m_TransformState.UpdateWorldViewMatrix (m_BuiltinParamValues); + + if (m_FogParams.mode != kFogDisabled) + { + float diff = m_FogParams.mode == kFogLinear ? m_FogParams.end - m_FogParams.start : 0.0f; + float invDiff = Abs(diff) > 0.0001f ? 1.0f/diff : 0.0f; + Vector4f fogParams(m_FogParams.density * 1.2011224087f, + m_FogParams.density * 1.4426950408f, + m_FogParams.mode == kFogLinear ? -invDiff : 0.0f, + m_FogParams.mode == kFogLinear ? m_FogParams.end * invDiff : 0.0f + ); + m_BuiltinParamValues.SetVectorParam(kShaderVecFFFogParams, fogParams); + m_BuiltinParamValues.SetVectorParam(kShaderVecFFFogColor, m_FogParams.color); + } + + void* shader[kShaderTypeCount]; + for (int pt = 0; pt < kShaderTypeCount; ++pt) + { + shader[pt] = NULL; + m_BuiltinParamIndices[pt] = &m_NullParamIndices; + } + + if (m_ActiveGpuProgram[kShaderVertex] && m_ActiveGpuProgram[kShaderFragment]) + { + // Programmable shaders + const bool haveDomainShader = m_ActiveGpuProgram[kShaderDomain]; + bool resetToNoFog = false; + for (int pt = kShaderVertex; pt < kShaderTypeCount; ++pt) + { + if (m_ActiveGpuProgram[pt]) + { + DebugAssert (!m_ActiveGpuProgram[pt] || m_ActiveGpuProgram[pt]->GetImplType() == pt); + m_BuiltinParamIndices[pt] = &m_ActiveGpuProgramParams[pt]->GetBuiltinParams(); + D3D11CommonShader* prog = static_cast<D3D11CommonShader*>(m_ActiveGpuProgram[pt]); + shader[pt] = prog->GetShader(m_FogParams.mode, haveDomainShader, resetToNoFog); + if (resetToNoFog) + m_FogParams.mode = kFogDisabled; + } + } + + // Apply fog parameters if needed + if (m_FogParams.mode > kFogDisabled) + { + const int cbIndex = m_CBs.FindAndBindCB (kSLPropFogCB.index, kShaderFragment, k11FogConstantBufferBind, k11FogSize*16); + + m_CBs.SetCBConstant (cbIndex, k11FogColor*16, m_FogParams.color.GetPtr(), 16); + + float params[4]; + params[0] = m_FogParams.density * 1.2011224087f ; // density / sqrt(ln(2)) + params[1] = m_FogParams.density * 1.4426950408f; // density / ln(2) + if (m_FogParams.mode == kFogLinear) + { + float diff = m_FogParams.end - m_FogParams.start; + float invDiff = Abs(diff) > 0.0001f ? 1.0f/diff : 0.0f; + params[2] = -invDiff; + params[3] = m_FogParams.end * invDiff; + } + else + { + params[2] = 0.0f; + params[3] = 0.0f; + } + m_CBs.SetCBConstant (cbIndex, k11FogParams*16, params, 16); + } + } + else + { + // Emulate fixed function + m_FFState.fogMode = m_FogParams.mode; + FixedFunctionProgramD3D11* program = GetFixedFunctionProgram11 (m_FFPrograms, m_FFState); + + shader[kShaderVertex] = program->GetVertexShader(); + shader[kShaderFragment] = program->GetPixelShader(); + + program->ApplyFFGpuProgram (m_BuiltinParamValues, m_CBs); + + m_BuiltinParamIndices[kShaderVertex] = &program->GetVPMatrices(); + } + + // Set D3D shaders + for (int pt = kShaderVertex; pt < kShaderTypeCount; ++pt) + { + if (m_ActiveShaders[pt] == shader[pt]) + continue; + switch (pt) { + case kShaderVertex: D3D11_CALL(ctx->VSSetShader ((ID3D11VertexShader*)shader[pt], NULL, 0)); break; + case kShaderFragment: D3D11_CALL(ctx->PSSetShader ((ID3D11PixelShader*)shader[pt], NULL, 0)); break; + case kShaderGeometry: D3D11_CALL(ctx->GSSetShader ((ID3D11GeometryShader*)shader[pt], NULL, 0)); break; + case kShaderHull: D3D11_CALL(ctx->HSSetShader ((ID3D11HullShader*)shader[pt], NULL, 0)); break; + case kShaderDomain: D3D11_CALL(ctx->DSSetShader ((ID3D11DomainShader*)shader[pt], NULL, 0)); break; + } + m_ActiveShaders[pt] = shader[pt]; + } + + // Set Unity built-in parameters + bool anyGpuIndexValid; + int gpuIndex[kShaderTypeCount]; + +#define SET_BUILTIN_MATRIX_BEGIN(idx) \ + anyGpuIndexValid = false; \ + for (int pt = kShaderVertex; pt < kShaderTypeCount; ++pt) { \ + int gi = m_BuiltinParamIndices[pt]->mat[idx].gpuIndex; \ + if (gi >= 0) anyGpuIndexValid = true; \ + gpuIndex[pt] = gi; \ + } \ + if (anyGpuIndexValid) + +#define SET_BUILTIN_MATRIX_END(idx,mtx) \ + for (int pt = kShaderVertex; pt < kShaderTypeCount; ++pt) { \ + int gi = gpuIndex[pt]; \ + if (gi >= 0) m_CBs.SetBuiltinCBConstant (m_BuiltinParamIndices[pt]->mat[idx].cbID, gi, mtx.GetPtr(), sizeof(mtx)); \ + } + + + // MVP matrix + SET_BUILTIN_MATRIX_BEGIN(kShaderInstanceMatMVP) + { + Matrix4x4f mat; + MultiplyMatrices4x4 (&m_BuiltinParamValues.GetMatrixParam(kShaderMatProj), &m_TransformState.worldViewMatrix, &mat); + SET_BUILTIN_MATRIX_END(kShaderInstanceMatMVP,mat); + } + // MV matrix + SET_BUILTIN_MATRIX_BEGIN(kShaderInstanceMatMV) + { + Matrix4x4f& mat = m_TransformState.worldViewMatrix; + SET_BUILTIN_MATRIX_END(kShaderInstanceMatMV,mat); + } + // Transpose MV matrix + SET_BUILTIN_MATRIX_BEGIN(kShaderInstanceMatTransMV) + { + Matrix4x4f mat; + TransposeMatrix4x4 (&m_TransformState.worldViewMatrix, &mat); + SET_BUILTIN_MATRIX_END(kShaderInstanceMatTransMV,mat); + } + // Inverse transpose of MV matrix + SET_BUILTIN_MATRIX_BEGIN(kShaderInstanceMatInvTransMV) + { + Matrix4x4f mat; + Matrix4x4f::Invert_Full (m_TransformState.worldViewMatrix, mat); + if (true) //@TODO m_VertexData.normalization == kNormalizationScale) + { + // Inverse transpose of modelview should be scaled by uniform + // normal scale (this will match state.matrix.invtrans.modelview + // and gl_NormalMatrix in OpenGL) + float scale = Magnitude (m_TransformState.worldMatrix.GetAxisX()); + mat.Get (0, 0) *= scale; + mat.Get (1, 0) *= scale; + mat.Get (2, 0) *= scale; + mat.Get (0, 1) *= scale; + mat.Get (1, 1) *= scale; + mat.Get (2, 1) *= scale; + mat.Get (0, 2) *= scale; + mat.Get (1, 2) *= scale; + mat.Get (2, 2) *= scale; + } + Matrix4x4f transposed; + TransposeMatrix4x4 (&mat, &transposed); + SET_BUILTIN_MATRIX_END(kShaderInstanceMatInvTransMV,transposed); + } + // M matrix + SET_BUILTIN_MATRIX_BEGIN(kShaderInstanceMatM) + { + Matrix4x4f& mat = m_TransformState.worldMatrix; + SET_BUILTIN_MATRIX_END(kShaderInstanceMatM,mat); + } + // Inverse M matrix + SET_BUILTIN_MATRIX_BEGIN(kShaderInstanceMatInvM) + { + Matrix4x4f mat = m_TransformState.worldMatrix; + if (true) //@TODO m_VertexData.normalization == kNormalizationScale) + { + // Kill scale in the world matrix before inverse + float invScale = m_BuiltinParamValues.GetInstanceVectorParam(kShaderInstanceVecScale).w; + mat.Get (0, 0) *= invScale; + mat.Get (1, 0) *= invScale; + mat.Get (2, 0) *= invScale; + mat.Get (0, 1) *= invScale; + mat.Get (1, 1) *= invScale; + mat.Get (2, 1) *= invScale; + mat.Get (0, 2) *= invScale; + mat.Get (1, 2) *= invScale; + mat.Get (2, 2) *= invScale; + } + Matrix4x4f inverseMat; + Matrix4x4f::Invert_General3D (mat, inverseMat); + SET_BUILTIN_MATRIX_END(kShaderInstanceMatInvM,inverseMat); + } + + // Set instance vector parameters + for (int i = 0; i < kShaderInstanceVecCount; ++i) + { + for (int pt = kShaderVertex; pt < kShaderTypeCount; ++pt) + { + int gi = m_BuiltinParamIndices[pt]->vec[i].gpuIndex; + if (gi >= 0) + { + m_CBs.SetBuiltinCBConstant (m_BuiltinParamIndices[pt]->vec[i].cbID, gi, m_BuiltinParamValues.GetInstanceVectorParam((ShaderBuiltinInstanceVectorParam)i).GetPtr(), m_BuiltinParamIndices[pt]->vec[i].dim*4); + } + } + } + + // Texture matrices for vertex shader + for( int i = 0; i < 8; ++i ) + { + const BuiltinShaderParamIndices::MatrixParamData* matParam = &m_BuiltinParamIndices[kShaderVertex]->mat[kShaderInstanceMatTexture0 + i]; + if (matParam->gpuIndex >= 0) + { + const Matrix4x4f& mat = m_TextureUnits[i].matrix; + m_CBs.SetBuiltinCBConstant (matParam->cbID, matParam->gpuIndex, mat.GetPtr(), sizeof(mat)); + } + } + + // Material properties + SetValuesFunctorD3D11 setValuesFunc(*this, m_CBs); + ApplyMaterialPropertyBlockValues(m_MaterialProperties, m_ActiveGpuProgram, m_ActiveGpuProgramParams, setValuesFunc); + + ///@TODO the rest + + m_CBs.UpdateBuffers (); +} + +static const D3D11_BLEND kBlendModeD3D11[] = { + D3D11_BLEND_ZERO, D3D11_BLEND_ONE, D3D11_BLEND_DEST_COLOR, D3D11_BLEND_SRC_COLOR, D3D11_BLEND_INV_DEST_COLOR, D3D11_BLEND_SRC_ALPHA, D3D11_BLEND_INV_SRC_COLOR, + D3D11_BLEND_DEST_ALPHA, D3D11_BLEND_INV_DEST_ALPHA, D3D11_BLEND_SRC_ALPHA_SAT, D3D11_BLEND_INV_SRC_ALPHA, +}; +static const D3D11_BLEND kBlendModeAlphaD3D11[] = { + D3D11_BLEND_ZERO, D3D11_BLEND_ONE, D3D11_BLEND_DEST_ALPHA, D3D11_BLEND_SRC_ALPHA, D3D11_BLEND_INV_DEST_ALPHA, D3D11_BLEND_SRC_ALPHA, D3D11_BLEND_INV_SRC_ALPHA, + D3D11_BLEND_DEST_ALPHA, D3D11_BLEND_INV_DEST_ALPHA, D3D11_BLEND_SRC_ALPHA_SAT, D3D11_BLEND_INV_SRC_ALPHA, +}; +static const D3D11_BLEND_OP kBlendOpD3D11[] = { + D3D11_BLEND_OP_ADD, D3D11_BLEND_OP_SUBTRACT, D3D11_BLEND_OP_REV_SUBTRACT, D3D11_BLEND_OP_MIN, D3D11_BLEND_OP_MAX, + /* ADD for all the logic op modes, used for fallback.*/ + D3D11_BLEND_OP_ADD, + D3D11_BLEND_OP_ADD, + D3D11_BLEND_OP_ADD, + D3D11_BLEND_OP_ADD, + D3D11_BLEND_OP_ADD, + D3D11_BLEND_OP_ADD, + D3D11_BLEND_OP_ADD, + D3D11_BLEND_OP_ADD, + D3D11_BLEND_OP_ADD, + D3D11_BLEND_OP_ADD, + D3D11_BLEND_OP_ADD, + D3D11_BLEND_OP_ADD, + D3D11_BLEND_OP_ADD, + D3D11_BLEND_OP_ADD, + D3D11_BLEND_OP_ADD, + D3D11_BLEND_OP_ADD, + +}; + +static const D3D11_LOGIC_OP kLogicOpD3D11[] = { + /* Zeroes for the blend modes */ + D3D11_LOGIC_OP_CLEAR, + D3D11_LOGIC_OP_CLEAR, + D3D11_LOGIC_OP_CLEAR, + D3D11_LOGIC_OP_CLEAR, + D3D11_LOGIC_OP_CLEAR, + /* Actual logic ops */ + D3D11_LOGIC_OP_CLEAR, + D3D11_LOGIC_OP_SET, + D3D11_LOGIC_OP_COPY, + D3D11_LOGIC_OP_COPY_INVERTED, + D3D11_LOGIC_OP_NOOP, + D3D11_LOGIC_OP_INVERT, + D3D11_LOGIC_OP_AND, + D3D11_LOGIC_OP_NAND, + D3D11_LOGIC_OP_OR, + D3D11_LOGIC_OP_NOR, + D3D11_LOGIC_OP_XOR, + D3D11_LOGIC_OP_EQUIV, + D3D11_LOGIC_OP_AND_REVERSE, + D3D11_LOGIC_OP_AND_INVERTED, + D3D11_LOGIC_OP_OR_REVERSE, + D3D11_LOGIC_OP_OR_INVERTED +}; + + + +DeviceBlendState* GfxDeviceD3D11::CreateBlendState (const GfxBlendState& state) +{ + std::pair<CachedBlendStates::iterator, bool> result = m_CachedBlendStates.insert(std::make_pair(state, DeviceBlendStateD3D11())); + if (!result.second) + return &result.first->second; + + DeviceBlendStateD3D11& d3dstate = result.first->second; + memcpy (&d3dstate.sourceState, &state, sizeof(d3dstate.sourceState)); + + // DX11.1 logic ops, falls through to ADD blendop if not supported + if(state.blendOp >= kBlendOpLogicalClear && state.blendOp <= kBlendOpLogicalOrInverted + && gGraphicsCaps.hasBlendLogicOps) + { + D3D11_BLEND_DESC1 desc; + memset (&desc, 0, sizeof(desc)); + if (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0) + desc.AlphaToCoverageEnable = state.alphaToMask; + + desc.IndependentBlendEnable = FALSE; + + D3D11_RENDER_TARGET_BLEND_DESC1& dst = desc.RenderTarget[0]; + + dst.BlendEnable = false; + dst.LogicOpEnable = true; + + dst.LogicOp = kLogicOpD3D11[state.blendOp]; + + DWORD d3dmask = 0; + const UInt8 mask = state.renderTargetWriteMask; + if( mask & kColorWriteR ) d3dmask |= D3D11_COLOR_WRITE_ENABLE_RED; + if( mask & kColorWriteG ) d3dmask |= D3D11_COLOR_WRITE_ENABLE_GREEN; + if( mask & kColorWriteB ) d3dmask |= D3D11_COLOR_WRITE_ENABLE_BLUE; + if( mask & kColorWriteA ) d3dmask |= D3D11_COLOR_WRITE_ENABLE_ALPHA; + dst.RenderTargetWriteMask = d3dmask; + // GetD3D11_1Device cannot return null if we're running on DX11 and have gGraphicsCaps.hasBlendLogicOps, so no need to check. + + ID3D11BlendState1 *blendObj = NULL; + HRESULT hr = GetD3D11_1Device()->CreateBlendState1 (&desc, &blendObj); + d3dstate.deviceState = blendObj; + AssertIf(FAILED(hr)); + SetDebugNameD3D11 (d3dstate.deviceState, Format("BlendState-%d-%d", dst.SrcBlend, dst.DestBlend)); + + } + else + { + D3D11_BLEND_DESC desc; + memset (&desc, 0, sizeof(desc)); + if (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0) + desc.AlphaToCoverageEnable = state.alphaToMask; + desc.IndependentBlendEnable = FALSE; + + D3D11_RENDER_TARGET_BLEND_DESC& dst = desc.RenderTarget[0]; + dst.BlendEnable = state.srcBlend != kBlendOne || state.dstBlend != kBlendZero || state.srcBlendAlpha != kBlendOne || state.dstBlendAlpha != kBlendZero; + dst.SrcBlend = kBlendModeD3D11[state.srcBlend]; + dst.DestBlend = kBlendModeD3D11[state.dstBlend]; + dst.BlendOp = kBlendOpD3D11[state.blendOp]; + dst.SrcBlendAlpha = kBlendModeAlphaD3D11[state.srcBlendAlpha]; + dst.DestBlendAlpha = kBlendModeAlphaD3D11[state.dstBlendAlpha]; + dst.BlendOpAlpha = kBlendOpD3D11[state.blendOpAlpha]; + + DWORD d3dmask = 0; + const UInt8 mask = state.renderTargetWriteMask; + if( mask & kColorWriteR ) d3dmask |= D3D11_COLOR_WRITE_ENABLE_RED; + if( mask & kColorWriteG ) d3dmask |= D3D11_COLOR_WRITE_ENABLE_GREEN; + if( mask & kColorWriteB ) d3dmask |= D3D11_COLOR_WRITE_ENABLE_BLUE; + if( mask & kColorWriteA ) d3dmask |= D3D11_COLOR_WRITE_ENABLE_ALPHA; + dst.RenderTargetWriteMask = d3dmask; + HRESULT hr = GetD3D11Device()->CreateBlendState (&desc, &d3dstate.deviceState); + AssertIf(FAILED(hr)); + SetDebugNameD3D11 (d3dstate.deviceState, Format("BlendState-%d-%d", dst.SrcBlend, dst.DestBlend)); + + } + + + return &result.first->second; +} + + +DeviceDepthState* GfxDeviceD3D11::CreateDepthState(const GfxDepthState& state) +{ + std::pair<CachedDepthStates::iterator, bool> result = m_CachedDepthStates.insert(std::make_pair(state, DeviceDepthState())); + if (!result.second) + return &result.first->second; + + DeviceDepthState& st = result.first->second; + memcpy(&st.sourceState, &state, sizeof(st.sourceState)); + return &result.first->second; +} + +DeviceStencilState* GfxDeviceD3D11::CreateStencilState(const GfxStencilState& state) +{ + std::pair<CachedStencilStates::iterator, bool> result = m_CachedStencilStates.insert(std::make_pair(state, DeviceStencilState())); + if (!result.second) + return &result.first->second; + + DeviceStencilState& st = result.first->second; + memcpy(&st.sourceState, &state, sizeof(state)); + return &result.first->second; +} + + +DeviceRasterState* GfxDeviceD3D11::CreateRasterState(const GfxRasterState& state) +{ + std::pair<CachedRasterStates::iterator, bool> result = m_CachedRasterStates.insert(std::make_pair(state, DeviceRasterState())); + if (!result.second) + return &result.first->second; + + DeviceRasterState& st = result.first->second; + memcpy(&st.sourceState, &state, sizeof(state)); + return &result.first->second; +} + + +void GfxDeviceD3D11::SetBlendState(const DeviceBlendState* state, float alphaRef) +{ + if (state != m_CurrBlendState) + { + m_CurrBlendState = state; + DeviceBlendStateD3D11* devstate = (DeviceBlendStateD3D11*)state; + GetD3D11Context()->OMSetBlendState (devstate->deviceState, NULL, 0xFFFFFFFF); + } + + // alpha test + m_FFState.alphaTest = state->sourceState.alphaTest; + m_BuiltinParamValues.SetVectorParam(kShaderVecFFAlphaTestRef, Vector4f(alphaRef, alphaRef, alphaRef, alphaRef)); +} + + +void GfxDeviceD3D11::SetRasterState(const DeviceRasterState* state) +{ + if (m_CurrRasterState != state) + { + m_CurrRasterState = state; + m_CurrRSState = NULL; + } +} + + +void GfxDeviceD3D11::SetDepthState (const DeviceDepthState* state) +{ + if (m_CurrDepthState != state) + { + m_CurrDepthState = state; + m_CurrDSState = NULL; + } +} + +void GfxDeviceD3D11::SetStencilState(const DeviceStencilState* state, int stencilRef) +{ + if (m_CurrStencilState != state) + { + m_CurrStencilState = state; + m_CurrDSState = NULL; + } + m_StencilRef = stencilRef; +} + +void GfxDeviceD3D11::SetupDeferredSRGBWrite() +{ + if (m_SRGBWrite == m_ActualSRGBWrite) + return; + + // sRGB write is not just a render state on DX11; we need to actually rebind the render target views with + // a different format. Looks like some drivers do not optimize useless RT changes away, causing + // a lot of performance being wasted. So only apply sRGB write change when actually needed. + m_ActualSRGBWrite = m_SRGBWrite; + RebindActiveRenderTargets (&m_Textures); +} + +void GfxDeviceD3D11::SetSRGBWrite (bool enable) +{ + m_SRGBWrite = enable; +} + +bool GfxDeviceD3D11::GetSRGBWrite () +{ + return m_SRGBWrite; +} + +void GfxDeviceD3D11::DiscardContents (RenderSurfaceHandle& rs) +{ +# if UNITY_WINRT // WSA/WP8 guaranteed to have DX11.1 runtime, needed for DiscardResource + + if(!rs.IsValid()) + return; + + RenderSurfaceD3D11 *surf = reinterpret_cast<RenderSurfaceD3D11*>( rs.object ); + if (surf->m_Texture) + { + ID3D11DeviceContext1 * ctx = (ID3D11DeviceContext1 *)GetD3D11Context(); + DX11_CHK(ctx->DiscardResource(surf->m_Texture)); + } + +# endif +} + +GfxDevice* CreateD3D11GfxDevice() +{ + if( !InitializeD3D11() ) + return NULL; + + gGraphicsCaps.InitD3D11(); + + GfxDeviceD3D11* device = UNITY_NEW_AS_ROOT(GfxDeviceD3D11(), kMemGfxDevice, "D3D11GfxDevice", ""); + return device; +} + + +GfxDeviceD3D11::GfxDeviceD3D11() +{ + m_DynamicVBO = NULL; + InvalidateState(); + ResetFrameStats(); + + m_Renderer = kGfxRendererD3D11; + m_UsesOpenGLTextureCoords = false; + m_UsesHalfTexelOffset = false; + m_IsThreadable = true; + + m_MaxBufferedFrames = -1; // no limiting + + m_Viewport[0] = m_Viewport[1] = m_Viewport[2] = m_Viewport[3] = 0; + m_ScissorRect[0] = m_ScissorRect[1] = m_ScissorRect[2] = m_ScissorRect[3] = 0; + m_CurrTargetWidth = 0; + m_CurrTargetHeight = 0; + m_CurrWindowWidth = 0; + m_CurrWindowHeight = 0; + + m_InvertProjMatrix = false; + m_AppBackfaceMode = false; + m_UserBackfaceMode = false; + m_Wireframe = false; + m_Scissor = false; + m_SRGBWrite = false; + m_ActualSRGBWrite = false; + + m_FramebufferDepthFormat = kDepthFormat24; + + // constant buffer for fog params + m_CBs.SetCBInfo (kSLPropFogCB.index, k11FogSize*16); + + extern RenderSurfaceBase* DummyColorBackBuferD3D11(); + SetBackBufferColorSurface(DummyColorBackBuferD3D11()); + + extern RenderSurfaceBase* DummyDepthBackBuferD3D11(); + SetBackBufferDepthSurface(DummyDepthBackBuferD3D11()); +} + +GfxDeviceD3D11::~GfxDeviceD3D11() +{ +#if !ENABLE_GFXDEVICE_REMOTE_PROCESS_WORKER + PluginsSetGraphicsDevice (GetD3D11Device(), kGfxRendererD3D11, kGfxDeviceEventShutdown); +#endif + + StreamOutSkinningInfo::CleanUp(); + +#if ENABLE_PROFILER + g_TimerQueriesD3D11.ReleaseAllQueries(); +#endif + + D3D11VBO::CleanupSharedBuffers(); + if( m_DynamicVBO ) + delete m_DynamicVBO; + for (FFProgramCacheD3D11::iterator it = m_FFPrograms.begin(); it != m_FFPrograms.end(); ++it) + delete it->second; + for (CachedBlendStates::iterator it = m_CachedBlendStates.begin(); it != m_CachedBlendStates.end(); ++it) + it->second.deviceState->Release(); + for (CachedDepthStencilStates::iterator it = m_CachedDepthStencilStates.begin(); it != m_CachedDepthStencilStates.end(); ++it) + it->second->Release(); + for (CachedFinalRasterStates::iterator it = m_CachedFinalRasterStates.begin(); it != m_CachedFinalRasterStates.end(); ++it) + it->second->Release(); + m_Imm.Cleanup(); + m_VertexDecls.Clear(); + m_CBs.Clear(); + m_Textures.ClearTextureResources(); + m_Resolves.Clear(); + DestroyD3D11Device(); + CleanupD3D11(); +} + + +void GfxDeviceD3D11::InvalidateState() +{ + g_ActiveInputLayoutD3D11 = NULL; + g_CurrentVSInputD3D11 = NULL; + g_ActiveTopologyD3D11 = D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED; + + m_TransformState.Invalidate(m_BuiltinParamValues); + + m_FogParams.Invalidate(); + + //m_State.Invalidate(*this); + m_Imm.Invalidate(); + //m_VSConstantCache.Invalidate(); + //m_PSConstantCache.Invalidate(); + + memset (&m_FFState, 0, sizeof(m_FFState)); + m_FFState.useUniformInsteadOfVertexColor = true; + + m_CurrBlendState = NULL; + m_CurrRasterState = NULL; + m_CurrDepthState = NULL; + m_CurrStencilState = NULL; + m_CurrRSState = NULL; + m_CurrDSState = NULL; + m_CurrStencilRef = -1; + + for (int pt = 0; pt < kShaderTypeCount; ++pt) + { + m_ActiveGpuProgram[pt] = NULL; + m_ActiveGpuProgramParams[pt] = NULL; + m_ActiveShaders[pt] = NULL; + for (int i = 0; i < kMaxSupportedTextureUnits; ++i) + { + m_ActiveTextures[pt][i].m_ID = -1; + m_ActiveSamplers[pt][i].m_ID = -1; + } + } + + m_Textures.InvalidateSamplers(); + m_CBs.InvalidateState(); + + ID3D11DeviceContext* ctx = GetD3D11Context(true); + if (ctx) + { + D3D11_CALL(ctx->VSSetShader (NULL, NULL, 0)); + D3D11_CALL(ctx->PSSetShader (NULL, NULL, 0)); + D3D11_CALL(ctx->GSSetShader (NULL, NULL, 0)); + D3D11_CALL(ctx->HSSetShader (NULL, NULL, 0)); + D3D11_CALL(ctx->DSSetShader (NULL, NULL, 0)); + } +} + + +void GfxDeviceD3D11::Clear (UInt32 clearFlags, const float color[4], float depth, int stencil) +{ + DX11_LOG_ENTER_FUNCTION("Clear(%d, (%.2f, %.2f, %.2f, %.2f), %.2f, %d)", clearFlags, color[0], color[1], color[2], color[3], depth, stencil); + SetupDeferredSRGBWrite (); + ID3D11DeviceContext* ctx = GetD3D11Context(); + + if ((clearFlags & kGfxClearColor) && g_D3D11CurrRT) + DX11_CHK(ctx->ClearRenderTargetView (g_D3D11CurrRT, color)); + if ((clearFlags & kGfxClearDepthStencil) && g_D3D11CurrDS) + { + UINT flags = 0; + if (clearFlags & kGfxClearDepth) + flags |= D3D11_CLEAR_DEPTH; + if (clearFlags & kGfxClearStencil) + flags |= D3D11_CLEAR_STENCIL; + DX11_CHK(ctx->ClearDepthStencilView (g_D3D11CurrDS, flags, depth, stencil)); + } +} + +void GfxDeviceD3D11::SetUserBackfaceMode( bool enable ) +{ + if (m_UserBackfaceMode != enable) + { + m_UserBackfaceMode = enable; + m_CurrRSState = NULL; + } +} + +void GfxDeviceD3D11::SetWireframe (bool wire) +{ + if (m_Wireframe != wire) + { + m_Wireframe = wire; + m_CurrRSState = NULL; + } +} + +bool GfxDeviceD3D11::GetWireframe() const +{ + return m_Wireframe; +} + + + +void GfxDeviceD3D11::SetInvertProjectionMatrix( bool enable ) +{ + if (m_InvertProjMatrix == enable) + return; + + m_InvertProjMatrix = enable; + + // When setting up "invert" flag, invert the matrix as well. + Matrix4x4f& m = m_BuiltinParamValues.GetWritableMatrixParam(kShaderMatProj); + m.Get(1,1) = -m.Get(1,1); + m.Get(1,3) = -m.Get(1,3); + m_TransformState.dirtyFlags |= TransformState::kProjDirty; + + m_CurrRSState = NULL; +} + +bool GfxDeviceD3D11::GetInvertProjectionMatrix() const +{ + return m_InvertProjMatrix; +} + +void GfxDeviceD3D11::SetWorldMatrix( const float matrix[16] ) +{ + CopyMatrix( matrix, m_TransformState.worldMatrix.GetPtr() ); + m_TransformState.dirtyFlags |= TransformState::kWorldDirty; +} + +void GfxDeviceD3D11::SetViewMatrix( const float matrix[16] ) +{ + m_TransformState.SetViewMatrix (matrix, m_BuiltinParamValues); +} + +void GfxDeviceD3D11::SetProjectionMatrix (const Matrix4x4f& matrix) +{ + Matrix4x4f& m = m_BuiltinParamValues.GetWritableMatrixParam(kShaderMatProj); + CopyMatrix (matrix.GetPtr(), m.GetPtr()); + CopyMatrix (matrix.GetPtr(), m_TransformState.projectionMatrixOriginal.GetPtr()); + CalculateDeviceProjectionMatrix (m, m_UsesOpenGLTextureCoords, m_InvertProjMatrix); + m_TransformState.dirtyFlags |= TransformState::kProjDirty; +} + +void GfxDeviceD3D11::GetMatrix( float outMatrix[16] ) const +{ + m_TransformState.UpdateWorldViewMatrix (m_BuiltinParamValues); + CopyMatrix (m_TransformState.worldViewMatrix.GetPtr(), outMatrix); +} + +const float* GfxDeviceD3D11::GetWorldMatrix() const +{ + return m_TransformState.worldMatrix.GetPtr(); +} + +const float* GfxDeviceD3D11::GetViewMatrix() const +{ + return m_BuiltinParamValues.GetMatrixParam(kShaderMatView).GetPtr(); +} + +const float* GfxDeviceD3D11::GetProjectionMatrix() const +{ + return m_TransformState.projectionMatrixOriginal.GetPtr(); +} + +const float* GfxDeviceD3D11::GetDeviceProjectionMatrix() const +{ + return m_BuiltinParamValues.GetMatrixParam(kShaderMatProj).GetPtr(); +} + + +void GfxDeviceD3D11::SetNormalizationBackface( NormalizationMode mode, bool backface ) +{ + if (m_AppBackfaceMode != backface) + { + m_AppBackfaceMode = backface; + m_CurrRSState = NULL; + } +} + +void GfxDeviceD3D11::SetFFLighting( bool on, bool separateSpecular, ColorMaterialMode colorMaterial ) +{ + DX11_LOG_ENTER_FUNCTION("SetFFLighting(%s, %s, %d)", GetDX11BoolString(on), GetDX11BoolString(separateSpecular), colorMaterial); + DebugAssert(colorMaterial!=kColorMatUnknown); + m_FFState.lightingEnabled = on; + m_FFState.specularEnabled = on && separateSpecular; + m_FFState.colorMaterial = colorMaterial; +} + +void GfxDeviceD3D11::SetMaterial( const float ambient[4], const float diffuse[4], const float specular[4], const float emissive[4], const float shininess ) +{ + DX11_LOG_ENTER_FUNCTION("SetMaterial((%.2f, %.2f, %.2f, %.2f), (%.2f, %.2f, %.2f, %.2f), (%.2f, %.2f, %.2f, %.2f), (%.2f, %.2f, %.2f, %.2f), %.2f)", + ambient[0], ambient[1], ambient[2], ambient[3], + diffuse[0], diffuse[1], diffuse[2], diffuse[3], + specular[0], specular[1], specular[2], specular[3], + emissive[0], emissive[1], emissive[2], emissive[3], + shininess); + + float glshine = clamp01 (shininess) * 128.0f; + + m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatAmbient, Vector4f(ambient[0], ambient[1], ambient[2], 1.0F)); + m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatDiffuse, Vector4f(diffuse)); + m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatSpecular, Vector4f(specular[0], specular[1], specular[2], glshine)); + m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatEmission, Vector4f(emissive[0], emissive[1], emissive[2], 1.0F)); +} + + +void GfxDeviceD3D11::SetColor( const float color[4] ) +{ + m_BuiltinParamValues.SetVectorParam(kShaderVecFFColor, Vector4f(color)); +} + + + +void GfxDeviceD3D11::SetViewport( int x, int y, int width, int height ) +{ + DX11_LOG_ENTER_FUNCTION("SetViewport(%d, %d, %d, %d)", x, y, width, height); + m_Viewport[0] = x; + m_Viewport[1] = y; + m_Viewport[2] = width; + m_Viewport[3] = height; + + D3D11_VIEWPORT view; + view.TopLeftX = x; + view.TopLeftY = y; + view.Width = width; + view.Height = height; + view.MinDepth = 0.0f; + view.MaxDepth = 1.0f; + ID3D11DeviceContext* ctx = GetD3D11Context(); + //@TODO + //if( !dev ) // happens on startup, when deleting all render textures + // return; + ctx->RSSetViewports (1, &view); +} + +void GfxDeviceD3D11::GetViewport( int* port ) const +{ + port[0] = m_Viewport[0]; + port[1] = m_Viewport[1]; + port[2] = m_Viewport[2]; + port[3] = m_Viewport[3]; +} + + +void GfxDeviceD3D11::SetScissorRect (int x, int y, int width, int height) +{ + DX11_LOG_ENTER_FUNCTION("SetScissorRect(%d, %d, %d, %d)", x, y, width, height); + if (!m_Scissor) + { + m_Scissor = true; + m_CurrRSState = NULL; + } + + m_ScissorRect[0] = x; + m_ScissorRect[1] = y; + m_ScissorRect[2] = width; + m_ScissorRect[3] = height; + + D3D11_RECT rc; + rc.left = x; + rc.top = y; + rc.right = x + width; + rc.bottom = y + height; + GetD3D11Context()->RSSetScissorRects (1, &rc); +} + +void GfxDeviceD3D11::DisableScissor() +{ + if (m_Scissor) + { + m_Scissor = false; + m_CurrRSState = NULL; + } +} + +bool GfxDeviceD3D11::IsScissorEnabled() const +{ + return m_Scissor; +} + +void GfxDeviceD3D11::GetScissorRect (int scissor[4]) const +{ + scissor[0] = m_ScissorRect[0]; + scissor[1] = m_ScissorRect[1]; + scissor[2] = m_ScissorRect[2]; + scissor[3] = m_ScissorRect[3]; +} + + +struct TextureCombiners11 +{ + const ShaderLab::TextureBinding* texEnvs; + int count; +}; + +bool GfxDeviceD3D11::IsCombineModeSupported( unsigned int combiner ) +{ + return true; +} + +TextureCombinersHandle GfxDeviceD3D11::CreateTextureCombiners (int count, const ShaderLab::TextureBinding* texEnvs, const ShaderLab::PropertySheet* props, bool hasVertexColorOrLighting, bool usesAddSpecular) +{ + DX11_LOG_ENTER_FUNCTION("CreateTextureCombiners()"); + if (count > gGraphicsCaps.maxTexUnits) + return TextureCombinersHandle(NULL); + + TextureCombiners11* combiners = new TextureCombiners11(); + combiners->texEnvs = texEnvs; + combiners->count = count; + return TextureCombinersHandle(combiners); +} + +void GfxDeviceD3D11::DeleteTextureCombiners (TextureCombinersHandle& textureCombiners) +{ + DX11_LOG_ENTER_FUNCTION("DeleteTextureCombiners()"); + TextureCombiners11* combiners = OBJECT_FROM_HANDLE(textureCombiners,TextureCombiners11); + delete combiners; + textureCombiners.Reset(); +} + +void GfxDeviceD3D11::SetTextureCombinersThreadable( TextureCombinersHandle textureCombiners, const TexEnvData* texEnvData, const Vector4f* texColors ) +{ + DX11_LOG_ENTER_FUNCTION("SetTextureCombinersThreadable()"); + TextureCombiners11* combiners = OBJECT_FROM_HANDLE(textureCombiners,TextureCombiners11); + Assert (combiners); + + const int count = std::min(combiners->count, gGraphicsCaps.maxTexUnits); + m_FFState.texUnitCount = count; + for (int i = 0; i < count; ++i) + { + const ShaderLab::TextureBinding& binding = combiners->texEnvs[i]; + ApplyTexEnvData (i, i, texEnvData[i]); + m_BuiltinParamValues.SetVectorParam ((BuiltinShaderVectorParam)(kShaderVecFFTextureEnvColor0 + i), texColors[i]); + m_FFState.texUnitColorCombiner[i] = binding.m_CombColor; + m_FFState.texUnitAlphaCombiner[i] = binding.m_CombAlpha; + } + + // unused textures + UInt32 mask = (1<<count)-1; + m_FFState.texUnitCube &= mask; + m_FFState.texUnit3D &= mask; + m_FFState.texUnitProjected &= mask; +} + +void GfxDeviceD3D11::SetTextureCombiners( TextureCombinersHandle textureCombiners, const ShaderLab::PropertySheet* props ) +{ + DX11_LOG_ENTER_FUNCTION("SetTextureCombiners()"); + TextureCombiners11* combiners = OBJECT_FROM_HANDLE(textureCombiners,TextureCombiners11); + Assert(combiners); + + const int count = std::min(combiners->count, gGraphicsCaps.maxTexUnits); + + // Fill in arrays + TexEnvData* texEnvData; + ALLOC_TEMP (texEnvData, TexEnvData, count); + for (int i = 0; i < count; ++i) + { + const ShaderLab::TextureBinding& binding = combiners->texEnvs[i]; + ShaderLab::TexEnv *te = ShaderLab::GetTexEnvForBinding(binding, props); + Assert(te != NULL); + te->PrepareData (binding.m_TextureName.index, binding.m_MatrixName, props, &texEnvData[i]); + } + + Vector4f* texColors; + ALLOC_TEMP (texColors, Vector4f, count); + for (int i = 0; i < count; ++i) + { + const ShaderLab::TextureBinding& binding = combiners->texEnvs[i]; + texColors[i] = binding.GetTexColor().Get (props); + } + GfxDeviceD3D11::SetTextureCombinersThreadable (textureCombiners, texEnvData, texColors); +} + + + +void UnbindTextureD3D11 (TextureID texture) +{ + DX11_LOG_ENTER_FUNCTION("UnbindTextureD3D11(%d)", texture.m_ID); + GfxDeviceD3D11& device = static_cast<GfxDeviceD3D11&>(GetRealGfxDevice()); + ID3D11DeviceContext* ctx = GetD3D11Context(); + + for (int pt = kShaderVertex; pt < kShaderTypeCount; ++pt) + { + for (int i = 0; i < kMaxSupportedTextureUnits; ++i) + { + if (device.m_ActiveTextures[pt][i]==texture) + { + ID3D11ShaderResourceView* srv = NULL; + switch (pt) { + case kShaderVertex: ctx->VSSetShaderResources (i, 1, &srv); break; + case kShaderFragment: ctx->PSSetShaderResources (i, 1, &srv); break; + case kShaderGeometry: ctx->GSSetShaderResources (i, 1, &srv); break; + case kShaderHull: ctx->HSSetShaderResources (i, 1, &srv); break; + case kShaderDomain: ctx->DSSetShaderResources (i, 1, &srv); break; + default: AssertString("unknown shader type"); + } + device.m_ActiveTextures[pt][i].m_ID = -1; + } + if (device.m_ActiveSamplers[pt][i]==texture) + { + device.m_ActiveSamplers[pt][i].m_ID = -1; + } + } + } +} + + + +void GfxDeviceD3D11::SetTexture (ShaderType shaderType, int unit, int samplerUnit, TextureID texture, TextureDimension dim, float bias) +{ + DebugAssertIf (dim < kTexDim2D || dim > kTexDimCUBE); + DebugAssertIf (unit < 0 || unit >= kMaxSupportedTextureUnits); + + // WP8 seems to have a driver bug (?) with occasionally losing texture state; can't do redundant bind early out here. + // Repros on Shadowgun flyby on Nokia Not For Sale. + #if !UNITY_WP8 + if (m_ActiveTextures[shaderType][unit] == texture && (samplerUnit >= 0 && m_ActiveSamplers[shaderType][samplerUnit] == texture)) + return; + #endif + + if (m_Textures.SetTexture (shaderType, unit, samplerUnit, texture, bias)) + { + m_Stats.AddUsedTexture(texture); + m_ActiveTextures[shaderType][unit] = texture; + if (samplerUnit >= 0) + m_ActiveSamplers[shaderType][samplerUnit] = texture; + } + + if (shaderType == kShaderFragment && unit < kMaxSupportedTextureCoords) + { + if (m_FFState.texUnitCount <= unit) + m_FFState.texUnitCount = unit+1; + + UInt32 mask = 1<<unit; + if (dim==kTexDimCUBE) + m_FFState.texUnitCube |= mask; + else + m_FFState.texUnitCube &= ~mask; + if (dim==kTexDim3D) + m_FFState.texUnit3D |= mask; + else + m_FFState.texUnit3D &= ~mask; + } +} + + +void GfxDeviceD3D11::SetTextureTransform( int unit, TextureDimension dim, TexGenMode texGen, bool identity, const float matrix[16]) +{ + Assert (unit >= 0 && unit < kMaxSupportedTextureCoords); + + TextureSourceD3D11 texSource = texGen == kTexGenDisabled ? kTexSourceUV0 : static_cast<TextureSourceD3D11>(texGen + kTexSourceUV7); + m_FFState.texUnitSources = m_FFState.texUnitSources & ~(15<<(unit*4)) | (UInt64(texSource)<<(unit*4)); + + if (identity) + m_TextureUnits[unit].matrix.SetIdentity(); + else + CopyMatrix (matrix, m_TextureUnits[unit].matrix.GetPtr()); + + // Detect if we have a projective texture matrix + m_FFState.texUnitProjected &= ~(1<<unit); + if (!identity && dim==kTexDim2D) + { + if (matrix[3] != 0.0f || matrix[7] != 0.0f || matrix[11] != 0.0f || matrix[15] != 1.0f) + m_FFState.texUnitProjected |= (1<<unit); + } +} + +void GfxDeviceD3D11::SetTextureParams( TextureID texture, TextureDimension texDim, TextureFilterMode filter, TextureWrapMode wrap, int anisoLevel, bool hasMipMap, TextureColorSpace colorSpace ) +{ + UnbindTextureD3D11 (texture); + m_Textures.SetTextureParams (texture, texDim, filter, wrap, anisoLevel, hasMipMap, colorSpace); +} + + + +void GfxDeviceD3D11::SetShadersThreadable (GpuProgram* programs[kShaderTypeCount], const GpuProgramParameters* params[kShaderTypeCount], UInt8 const * const paramsBuffer[kShaderTypeCount]) +{ + for (int pt = kShaderVertex; pt < kShaderTypeCount; ++pt) + { + m_ActiveGpuProgram[pt] = programs[pt]; + m_ActiveGpuProgramParams[pt] = params[pt]; + } + + // Apply programmable shader parameters + if (m_ActiveGpuProgram[kShaderVertex] && m_ActiveGpuProgram[kShaderFragment]) + { + for (int pt = kShaderVertex; pt < kShaderTypeCount; ++pt) + { + if (m_ActiveGpuProgram[pt]) + { + DebugAssert (!m_ActiveGpuProgram[pt] || m_ActiveGpuProgram[pt]->GetImplType() == pt); + D3D11CommonShader* prog = static_cast<D3D11CommonShader*>(m_ActiveGpuProgram[pt]); + m_ActiveGpuProgram[pt]->ApplyGpuProgram (*params[pt], paramsBuffer[pt]); + } + } + } +} + + +bool GfxDeviceD3D11::IsShaderActive( ShaderType type ) const +{ + return (m_ActiveGpuProgram[type] != 0); +} + +void GfxDeviceD3D11::DestroySubProgram( ShaderLab::SubProgram* subprogram ) +{ + delete subprogram; +} + +void GfxDeviceD3D11::SetConstantBufferInfo (int id, int size) +{ + m_CBs.SetCBInfo (id, size); +} + +void GfxDeviceD3D11::DisableLights( int startLight ) +{ + startLight = std::min (startLight, gGraphicsCaps.maxLights); + m_FFState.lightCount = startLight; + + const Vector4f black(0.0F, 0.0F, 0.0F, 0.0F); + const Vector4f zpos(0.0F, 0.0F, 1.0F, 0.0F); + for (int i = startLight; i < gGraphicsCaps.maxLights; ++i) + { + m_BuiltinParamValues.SetVectorParam(BuiltinShaderVectorParam(kShaderVecLight0Position + i), zpos); + m_BuiltinParamValues.SetVectorParam(BuiltinShaderVectorParam(kShaderVecLight0Diffuse + i), black); + } +} + +void GfxDeviceD3D11::SetLight( int light, const GfxVertexLight& data) +{ + if (light >= gGraphicsCaps.maxLights) + return; + SetupVertexLightParams (light, data); +} + +void GfxDeviceD3D11::SetAmbient( const float ambient[4] ) +{ + m_BuiltinParamValues.SetVectorParam(kShaderVecLightModelAmbient, Vector4f(ambient)); +} + + +void GfxDeviceD3D11::EnableFog (const GfxFogParams& fog) +{ + DebugAssert (fog.mode > kFogDisabled); + m_FogParams = fog; + + //@TODO: fog DXBC patching not implemented for 9.x level; and something still wrong with FF shaders in 9.x level as well + // (e.g. crashes WARP). Just disable fog for now. + if (gGraphicsCaps.d3d11.featureLevel < kDX11Level10_0) + m_FogParams.mode = kFogDisabled; +} + +void GfxDeviceD3D11::DisableFog() +{ + m_FogParams.mode = kFogDisabled; + m_FogParams.density = 0.0f; +} + + +VBO* GfxDeviceD3D11::CreateVBO() +{ + VBO* vbo = new D3D11VBO(); + OnCreateVBO(vbo); + return vbo; +} + +void GfxDeviceD3D11::DeleteVBO( VBO* vbo ) +{ + OnDeleteVBO(vbo); + delete vbo; +} + +DynamicVBO& GfxDeviceD3D11::GetDynamicVBO() +{ + if( !m_DynamicVBO ) { + m_DynamicVBO = new DynamicD3D11VBO( 1024 * 1024, 65536 ); // initial 1 MiB VB, 64 KiB IB + } + return *m_DynamicVBO; +} + +/* +void GfxDeviceD3D11::ResetDynamicResources() +{ + delete m_DynamicVBO; + m_DynamicVBO = NULL; + + CleanupEventQueries (); + + for( ListIterator<D3D11VBO*> i = m_DynamicVBOs.begin(); i != m_DynamicVBOs.end(); ++i ) + { + D3D11VBO* vbo = *i; + vbo->ResetDynamicVB(); + } +} +*/ + +GfxDeviceD3D11& GetD3D11GfxDevice() +{ + GfxDevice& device = GetRealGfxDevice(); + DebugAssert(device.GetRenderer() == kGfxRendererD3D11); + return static_cast<GfxDeviceD3D11&>(device); +} + + +ID3D11InputLayout* GetD3D11VertexDeclaration (const ChannelInfoArray& channels) +{ + GfxDevice& device = GetRealGfxDevice(); + DebugAssert(device.GetRenderer() == kGfxRendererD3D11); + GfxDeviceD3D11* deviceD3D = static_cast<GfxDeviceD3D11*>( &device ); + return deviceD3D->GetVertexDecls().GetVertexDecl (channels, g_CurrentVSInputD3D11); +} + +const InputSignatureD3D11* GetD3D11InputSignature (void* code, unsigned length) +{ + GfxDevice& device = GetRealGfxDevice(); + DebugAssert(device.GetRenderer() == kGfxRendererD3D11); + GfxDeviceD3D11* deviceD3D = static_cast<GfxDeviceD3D11*>( &device ); + return deviceD3D->GetVertexDecls().GetShaderInputSignature (code, length); +} + +ConstantBuffersD3D11& GetD3D11ConstantBuffers (GfxDevice& device) +{ + Assert (device.GetRenderer() == kGfxRendererD3D11); + GfxDeviceD3D11& deviceD3D = static_cast<GfxDeviceD3D11&>(device); + return deviceD3D.GetConstantBuffers(); +} + +TexturesD3D11& GetD3D11Textures (GfxDevice& device) +{ + Assert (device.GetRenderer() == kGfxRendererD3D11); + GfxDeviceD3D11& deviceD3D = static_cast<GfxDeviceD3D11&>(device); + return deviceD3D.GetTextures(); +} + + +// ---------- render textures + + +RenderSurfaceHandle CreateRenderColorSurfaceD3D11( TextureID textureID, int width, int height, int samples, int depth, TextureDimension dim, UInt32 createFlags, RenderTextureFormat format, TexturesD3D11& textures); +RenderSurfaceHandle CreateRenderDepthSurfaceD3D11( TextureID textureID, int width, int height, int samples, TextureDimension dim, DepthBufferFormat depthFormat, UInt32 createFlags, TexturesD3D11& textures); +void DestroyRenderSurfaceD3D11 (RenderSurfaceHandle& rsHandle, TexturesD3D11& textures); +bool SetRenderTargetD3D11 (int count, RenderSurfaceHandle* colorHandles, RenderSurfaceHandle depthHandle, int mipLevel, CubemapFace face, int* outTargetWidth, int* outTargetHeight, TexturesD3D11* textures); +RenderSurfaceHandle GetActiveRenderColorSurfaceD3D11(int index); +RenderSurfaceHandle GetActiveRenderDepthSurfaceD3D11(); +RenderSurfaceHandle GetActiveRenderColorSurfaceBBD3D11(); + +RenderSurfaceHandle GfxDeviceD3D11::CreateRenderColorSurface (TextureID textureID, int width, int height, int samples, int depth, TextureDimension dim, RenderTextureFormat format, UInt32 createFlags) +{ + DX11_LOG_ENTER_FUNCTION("CreateRenderColorSurface(%d, %d, %d, %d, %d)", textureID.m_ID, width, height, format, createFlags); + return CreateRenderColorSurfaceD3D11 (textureID, width, height, samples, depth, dim, createFlags, format, m_Textures); +} +RenderSurfaceHandle GfxDeviceD3D11::CreateRenderDepthSurface (TextureID textureID, int width, int height, int samples, TextureDimension dim, DepthBufferFormat depthFormat, UInt32 createFlags) +{ + DX11_LOG_ENTER_FUNCTION("CreateRenderDepthSurface(%d, %d, %d, %d, %d, %d)", textureID.m_ID, width, height, dim, depthFormat, createFlags); + return CreateRenderDepthSurfaceD3D11 (textureID, width, height, samples, dim, depthFormat, createFlags, m_Textures); +} +void GfxDeviceD3D11::DestroyRenderSurface (RenderSurfaceHandle& rs) +{ + DX11_LOG_ENTER_FUNCTION("DestroyRenderSurface()"); + DestroyRenderSurfaceD3D11 (rs, m_Textures); +} +void GfxDeviceD3D11::SetRenderTargets (int count, RenderSurfaceHandle* colorHandles, RenderSurfaceHandle depthHandle, int mipLevel, CubemapFace face) +{ + DX11_LOG_ENTER_FUNCTION("SetRenderTargets(%i, c0=%p, d=%p, mip=%i, f=%i)", count, colorHandles[0].object, depthHandle.object, mipLevel, face); + SetupDeferredSRGBWrite (); + m_CurrTargetWidth = m_CurrWindowWidth; + m_CurrTargetHeight = m_CurrWindowHeight; + if (SetRenderTargetD3D11 (count, colorHandles, depthHandle, mipLevel, face, &m_CurrTargetWidth, &m_CurrTargetHeight, &m_Textures)) + { + // changing render target might mean different color clear flags; so reset current state + m_CurrBlendState = NULL; + } +} + +void GfxDeviceD3D11::ResolveDepthIntoTexture (RenderSurfaceHandle colorHandle, RenderSurfaceHandle depthHandle) +{ + DX11_LOG_ENTER_FUNCTION("ResolveDepthIntoTexture(%p, %p)", colorHandle.object, depthHandle.object); + RenderSurfaceD3D11* depthSurf = reinterpret_cast<RenderSurfaceD3D11*>(depthHandle.object); + TexturesD3D11::D3D11Texture* destTexture = m_Textures.GetTexture (depthSurf->textureID); + DebugAssert (destTexture); + if (!destTexture) + return; + DebugAssert (g_D3D11CurrDepthRT); + if (!g_D3D11CurrDepthRT || !g_D3D11CurrDepthRT->m_Texture) + return; + + GetD3D11Context()->CopyResource (destTexture->m_Texture, g_D3D11CurrDepthRT->m_Texture); +} + + +void GfxDeviceD3D11::ResolveColorSurface (RenderSurfaceHandle srcHandle, RenderSurfaceHandle dstHandle) +{ + Assert (srcHandle.IsValid()); + Assert (dstHandle.IsValid()); + RenderColorSurfaceD3D11* src = reinterpret_cast<RenderColorSurfaceD3D11*>(srcHandle.object); + RenderColorSurfaceD3D11* dst = reinterpret_cast<RenderColorSurfaceD3D11*>(dstHandle.object); + if (!src->colorSurface || !dst->colorSurface) + { + WarningString("RenderTexture: Resolving non-color surfaces."); + return; + } + if (src->dim != dst->dim) + { + WarningString("RenderTexture: Resolving surfaces of different types."); + return; + } + if (src->format != dst->format) + { + WarningString("RenderTexture: Resolving surfaces of different formats."); + return; + } + if (src->width != dst->width || src->height != dst->height) + { + WarningString("RenderTexture: Resolving surfaces of different sizes."); + return; + } + + ID3D11DeviceContext* ctx = GetD3D11Context(); + if (src->samples <= 1 && dst->samples <= 1) + { + ctx->CopyResource (dst->m_Texture, src->m_Texture); + } + else + { + extern DXGI_FORMAT kD3D11RenderTextureFormatsNorm[kRTFormatCount]; + ctx->ResolveSubresource (dst->m_Texture, 0, src->m_Texture, 0, kD3D11RenderTextureFormatsNorm[dst->format]); + if ((dst->flags & kSurfaceCreateMipmap) && + (dst->flags & kSurfaceCreateAutoGenMips) && + dst->m_SRViewForMips) + { + ctx->GenerateMips (dst->m_SRViewForMips); + } + } +} + + +RenderSurfaceHandle GfxDeviceD3D11::GetActiveRenderColorSurface(int index) +{ + DX11_LOG_ENTER_FUNCTION("GetActiveRenderColorSurface(%d)", index); + return GetActiveRenderColorSurfaceD3D11(index); +} +RenderSurfaceHandle GfxDeviceD3D11::GetActiveRenderDepthSurface() +{ + DX11_LOG_ENTER_FUNCTION("GetActiveRenderDepthSurface"); + return GetActiveRenderDepthSurfaceD3D11(); +} +void GfxDeviceD3D11::SetSurfaceFlags (RenderSurfaceHandle surf, UInt32 flags, UInt32 keepFlags) +{ +} + + +// ---------- uploading textures + +void GfxDeviceD3D11::UploadTexture2D( TextureID texture, TextureDimension dimension, UInt8* srcData, int srcSize, int width, int height, TextureFormat format, int mipCount, UInt32 uploadFlags, int skipMipLevels, TextureUsageMode usageMode, TextureColorSpace colorSpace ) +{ + DX11_LOG_ENTER_FUNCTION("UploadTexture2D(%d, %d, <srcData>, %d, %d, %d, %d, %d, %d, %d)", + texture.m_ID, dimension, width, height, format, mipCount, uploadFlags, skipMipLevels, usageMode); + UnbindTextureD3D11 (texture); + m_Textures.UploadTexture2D (texture, dimension, srcData, width, height, format, mipCount, uploadFlags, skipMipLevels, usageMode, colorSpace); +} +void GfxDeviceD3D11::UploadTextureSubData2D( TextureID texture, UInt8* srcData, int srcSize, int mipLevel, int x, int y, int width, int height, TextureFormat format, TextureColorSpace colorSpace ) +{ + DX11_LOG_ENTER_FUNCTION("UploadTextureSubData2D(%d, <srcData>, ...)", texture.m_ID) + m_Textures.UploadTextureSubData2D (texture, srcData, mipLevel, x, y, width, height, format, colorSpace); +} +void GfxDeviceD3D11::UploadTextureCube( TextureID texture, UInt8* srcData, int srcSize, int faceDataSize, int size, TextureFormat format, int mipCount, UInt32 uploadFlags, TextureColorSpace colorSpace ) +{ + DX11_LOG_ENTER_FUNCTION("UploadTextureCube(%d, <srcData>, ...)", texture.m_ID) + UnbindTextureD3D11 (texture); + m_Textures.UploadTextureCube (texture, srcData, faceDataSize, size, format, mipCount, uploadFlags, colorSpace); +} +void GfxDeviceD3D11::UploadTexture3D( TextureID texture, UInt8* srcData, int srcSize, int width, int height, int depth, TextureFormat format, int mipCount, UInt32 uploadFlags ) +{ + DX11_LOG_ENTER_FUNCTION("UploadTexture3D(%d, <srcData>, ...)", texture.m_ID) + UnbindTextureD3D11 (texture); + m_Textures.UploadTexture3D (texture, srcData, width, height, depth, format, mipCount, uploadFlags); +} +void GfxDeviceD3D11::DeleteTexture( TextureID texture ) +{ + DX11_LOG_ENTER_FUNCTION("DeleteTexture(%d)", texture.m_ID) + UnbindTextureD3D11 (texture); + m_Textures.DeleteTexture (texture); +} + + +// ---------- context + +GfxDevice::PresentMode GfxDeviceD3D11::GetPresentMode() +{ + return kPresentBeforeUpdate; +} + +void GfxDeviceD3D11::BeginFrame() +{ + DX11_LOG_OUTPUT("*****************************************"); + DX11_LOG_OUTPUT("*****************************************"); + DX11_LOG_OUTPUT("*****************************************"); + DX11_LOG_ENTER_FUNCTION("BeginFrame()"); + DX11_MARK_FRAME_BEGIN(); + m_InsideFrame = true; + + #if UNITY_WINRT + ActivateD3D11BackBuffer(this); // ?!- + #endif +} + + + +void GfxDeviceD3D11::EndFrame() +{ + DX11_LOG_ENTER_FUNCTION("EndFrame()"); + DX11_MARK_FRAME_END(); + m_InsideFrame = false; +} + +bool GfxDeviceD3D11::IsValidState() +{ + return true; +} + +void GfxDeviceD3D11::PresentFrame() +{ + #if !UNITY_WP8 + IDXGISwapChain* swapChain = GetD3D11SwapChain(); + if (swapChain) + swapChain->Present (GetD3D11SyncInterval(), 0); + #endif + m_CBs.NewFrame(); +} + +void GfxDeviceD3D11::FinishRendering() +{ + // not needed on D3D +} + + + +// ---------- immediate mode rendering + +// we break very large immediate mode submissions into multiple batches internally +const int kMaxImmediateVerticesPerDraw = 8192; + + +ImmediateModeD3D11::ImmediateModeD3D11() +: m_VB(NULL) +, m_VBUsedBytes(0) +, m_VBStartVertex(0) +{ +} + +ImmediateModeD3D11::~ImmediateModeD3D11() +{ + Assert (!m_VB); +} + +void ImmediateModeD3D11::Cleanup() +{ + REGISTER_EXTERNAL_GFX_DEALLOCATION(m_VB); + SAFE_RELEASE(m_VB); + m_VBUsedBytes = 0; +} + + +void ImmediateModeD3D11::Invalidate() +{ + m_Vertices.clear(); + memset( &m_Current, 0, sizeof(m_Current) ); + m_HadColor = false; +} + +void GfxDeviceD3D11::ImmediateVertex( float x, float y, float z ) +{ + // If the current batch is becoming too large, internally end it and begin it again. + size_t currentSize = m_Imm.m_Vertices.size(); + if( currentSize >= kMaxImmediateVerticesPerDraw - 4 ) + { + GfxPrimitiveType mode = m_Imm.m_Mode; + // For triangles, break batch when multiple of 3's is reached. + if( mode == kPrimitiveTriangles && currentSize % 3 == 0 ) + { + bool hadColor = m_Imm.m_HadColor; + ImmediateEnd(); + ImmediateBegin( mode ); + m_Imm.m_HadColor = hadColor; + } + // For other primitives, break on multiple of 4's. + // NOTE: This won't quite work for triangle strips, but we'll just pretend + // that will never happen. + else if( mode != kPrimitiveTriangles && currentSize % 4 == 0 ) + { + bool hadColor = m_Imm.m_HadColor; + ImmediateEnd(); + ImmediateBegin( mode ); + m_Imm.m_HadColor = hadColor; + } + } + Vector3f& vert = m_Imm.m_Current.vertex; + vert.x = x; + vert.y = y; + vert.z = z; + m_Imm.m_Vertices.push_back( m_Imm.m_Current ); +} + +void GfxDeviceD3D11::ImmediateNormal( float x, float y, float z ) +{ + m_Imm.m_Current.normal.x = x; + m_Imm.m_Current.normal.y = y; + m_Imm.m_Current.normal.z = z; +} + +void GfxDeviceD3D11::ImmediateColor( float r, float g, float b, float a ) +{ + m_Imm.m_Current.color.Set (ColorRGBAf(r,g,b,a)); + m_Imm.m_HadColor = true; +} + +void GfxDeviceD3D11::ImmediateTexCoordAll( float x, float y, float z ) +{ + for( int i = 0; i < 8; ++i ) + { + Vector3f& uv = m_Imm.m_Current.texCoords[i]; + uv.x = x; + uv.y = y; + uv.z = z; + } +} + +void GfxDeviceD3D11::ImmediateTexCoord( int unit, float x, float y, float z ) +{ + if( unit < 0 || unit >= 8 ) + { + ErrorString( "Invalid unit for texcoord" ); + return; + } + Vector3f& uv = m_Imm.m_Current.texCoords[unit]; + uv.x = x; + uv.y = y; + uv.z = z; +} + +void GfxDeviceD3D11::ImmediateBegin( GfxPrimitiveType type ) +{ + m_Imm.m_Mode = type; + m_Imm.m_Vertices.clear(); + m_Imm.m_HadColor = false; +} + +bool GfxDeviceD3D11::ImmediateEndSetup() +{ + if( m_Imm.m_Vertices.empty() ) + return false; + + HRESULT hr = S_OK; + ID3D11DeviceContext* ctx = GetD3D11Context(); + + // vertex buffer + const int kImmediateVBSize = kMaxImmediateVerticesPerDraw * sizeof(ImmediateVertexD3D11); + if (!m_Imm.m_VB) + { + ID3D11Device* dev = GetD3D11Device(); + D3D11_BUFFER_DESC desc; + desc.ByteWidth = kImmediateVBSize; + desc.Usage = D3D11_USAGE_DYNAMIC; + desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + hr = dev->CreateBuffer (&desc, NULL, &m_Imm.m_VB); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(m_Imm.m_VB,kImmediateVBSize,this); + SetDebugNameD3D11 (m_Imm.m_VB, "VertexBufferImmediate"); + m_Imm.m_VBUsedBytes = 0; + m_Imm.m_VBStartVertex = 0; + } + + const ImmediateVertexD3D11* vb = &m_Imm.m_Vertices[0]; + const int vertexCount = m_Imm.m_Vertices.size(); + const int vertexDataSize = vertexCount * sizeof(vb[0]); + D3D11_MAPPED_SUBRESOURCE mapped; + + if (m_Imm.m_VBUsedBytes + vertexDataSize > kImmediateVBSize) + { + D3D11_CALL_HR(ctx->Map (m_Imm.m_VB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped)); + m_Imm.m_VBUsedBytes = 0; + } + else + { + D3D11_CALL_HR(ctx->Map (m_Imm.m_VB, 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &mapped)); + } + m_Imm.m_VBStartVertex = m_Imm.m_VBUsedBytes / sizeof(vb[0]); + + memcpy ((UInt8*)mapped.pData + m_Imm.m_VBUsedBytes, vb, vertexDataSize); + D3D11_CALL_HR(ctx->Unmap (m_Imm.m_VB, 0)); + m_Imm.m_VBUsedBytes += vertexDataSize; + + UINT strides = sizeof(vb[0]); + UINT offsets = 0; + D3D11_CALL (ctx->IASetVertexBuffers(0, 1, &m_Imm.m_VB, &strides, &offsets)); + + + m_FFState.useUniformInsteadOfVertexColor = !m_Imm.m_HadColor; + if (!IsShaderActive(kShaderVertex)) + { + UInt64 textureSources = m_FFState.texUnitSources; + for (int i = 0; i < gGraphicsCaps.maxTexCoords; ++i) + { + UInt32 source = (textureSources >> (i*4)) & 0xF; + // In immediate mode, each texcoord binds to it's own stage, unless we have texgen + // on some of them. + if (source <= kTexSourceUV7) + { + textureSources = textureSources & ~(0xFUL<<i*4) | (UInt64(kTexSourceUV0+i) << i*4); + } + } + m_FFState.texUnitSources = textureSources; + } + + BeforeDrawCall (true); + return true; +} + + +void GfxDeviceD3D11::ImmediateEndDraw() +{ + ID3D11DeviceContext* ctx = GetD3D11Context(); + int vertexCount = m_Imm.m_Vertices.size(); + + // vertex layout + ID3D11InputLayout* inputLayout = m_VertexDecls.GetImmVertexDecl (g_CurrentVSInputD3D11); + if (inputLayout) + { + SetInputLayoutD3D11 (ctx, inputLayout); + if (SetTopologyD3D11 (m_Imm.m_Mode, *this, ctx)) + { + + // draw + switch (m_Imm.m_Mode) + { + case kPrimitiveTriangles: + D3D11_CALL(ctx->Draw (vertexCount, m_Imm.m_VBStartVertex)); + m_Stats.AddDrawCall (vertexCount / 3, vertexCount); + break; + case kPrimitiveTriangleStripDeprecated: + D3D11_CALL(ctx->Draw (vertexCount, m_Imm.m_VBStartVertex)); + m_Stats.AddDrawCall (vertexCount - 2, vertexCount); + break; + case kPrimitiveQuads: + GetDynamicVBO(); // ensure it's created + D3D11_CALL(ctx->IASetIndexBuffer (m_DynamicVBO->GetQuadsIB(), DXGI_FORMAT_R16_UINT, 0)); + D3D11_CALL(ctx->DrawIndexed (vertexCount/4*6, 0, m_Imm.m_VBStartVertex)); + m_Stats.AddDrawCall( vertexCount / 4 * 2, vertexCount ); + break; + case kPrimitiveLines: + D3D11_CALL(ctx->Draw (vertexCount, m_Imm.m_VBStartVertex)); + m_Stats.AddDrawCall( vertexCount / 2, vertexCount ); + break; + default: + AssertString("ImmediateEnd: unknown draw mode"); + } + } + } + + // clear vertices + m_Imm.m_Vertices.clear(); +} + + +void GfxDeviceD3D11::ImmediateEnd() +{ + if (ImmediateEndSetup()) + ImmediateEndDraw(); +} + + +typedef SmartComPointer<ID3D11RenderTargetView> RTVPointer; +typedef SmartComPointer<ID3D11Resource> ResourcePointer; +typedef SmartComPointer<ID3D11Texture2D> Texture2DPointer; + + +bool GfxDeviceD3D11::CaptureScreenshot( int left, int bottom, int width, int height, UInt8* rgba32 ) +{ + DX11_LOG_ENTER_FUNCTION("CaptureScreenshot(%d, %d, %dx%d)", left, bottom, width, height); + HRESULT hr; + ID3D11DeviceContext* ctx = GetD3D11Context(); + + SetupDeferredSRGBWrite (); + + RenderSurfaceHandle currColorSurface = GetActiveRenderColorSurfaceBBD3D11(); + RenderColorSurfaceD3D11* colorSurf = reinterpret_cast<RenderColorSurfaceD3D11*>(currColorSurface.object); + if (!colorSurf) + return false; + + RTVPointer rtView; + ctx->OMGetRenderTargets (1, &rtView, NULL); + if (!rtView) + return false; + + ResourcePointer rtRes; + rtView->GetResource (&rtRes); + if (!rtRes) + return false; + + D3D11_RESOURCE_DIMENSION rtType; + rtRes->GetType (&rtType); + if (rtType != D3D11_RESOURCE_DIMENSION_TEXTURE2D) + return false; + + ID3D11Texture2D* rtTex = static_cast<ID3D11Texture2D*>((ID3D11Resource*)rtRes); + D3D11_TEXTURE2D_DESC rtDesc; + rtTex->GetDesc (&rtDesc); + if (rtDesc.Format != DXGI_FORMAT_R8G8B8A8_UNORM && + rtDesc.Format != DXGI_FORMAT_R8G8B8A8_TYPELESS && + rtDesc.Format != DXGI_FORMAT_R8G8B8A8_UNORM_SRGB && + rtDesc.Format != DXGI_FORMAT_B8G8R8A8_UNORM) + return false; + + ID3D11Device* dev = GetD3D11Device(); + ResolveTexturePool::Entry* resolved = NULL; + if (rtDesc.SampleDesc.Count != 1) + { + resolved = m_Resolves.GetResolveTexture (rtDesc.Width, rtDesc.Height, colorSurf->format, m_SRGBWrite); + if (!resolved) + return false; + + ctx->ResolveSubresource (resolved->texture, 0, rtTex, 0, rtDesc.Format); + rtTex = resolved->texture; + } + + Texture2DPointer stagingTex; + D3D11_TEXTURE2D_DESC stagingDesc; + stagingDesc.Width = width; + stagingDesc.Height = height; + stagingDesc.MipLevels = 1; + stagingDesc.ArraySize = 1; + + bool useRGBA = rtDesc.Format == DXGI_FORMAT_R8G8B8A8_UNORM || + rtDesc.Format == DXGI_FORMAT_R8G8B8A8_TYPELESS || + rtDesc.Format == DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; + + stagingDesc.Format = useRGBA ? DXGI_FORMAT_R8G8B8A8_UNORM : DXGI_FORMAT_B8G8R8A8_UNORM; + stagingDesc.SampleDesc.Count = 1; + stagingDesc.SampleDesc.Quality = 0; + stagingDesc.Usage = D3D11_USAGE_STAGING; + stagingDesc.BindFlags = 0; + stagingDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; + stagingDesc.MiscFlags = 0; + hr = dev->CreateTexture2D (&stagingDesc, NULL, &stagingTex); + if (FAILED(hr)) + return false; + SetDebugNameD3D11 (stagingTex, Format("CaptureScreenshot-Texture2D-%dx%d", width, height)); + + D3D11_BOX srcBox; + srcBox.left = left; + srcBox.right = left + width; +#if UNITY_WP8 + /* In WP8 m_CurrTargetHeight seems not to match + * ID3D11DeviceContext height */ + srcBox.top = bottom; + srcBox.bottom = bottom + height; +#else + srcBox.top = m_CurrTargetHeight - (bottom + height); + srcBox.bottom = m_CurrTargetHeight - (bottom); +#endif + srcBox.front = 0; + srcBox.back = 1; + ctx->CopySubresourceRegion (stagingTex, 0, 0, 0, 0, rtTex, 0, &srcBox); + + D3D11_MAPPED_SUBRESOURCE mapped; + hr = ctx->Map (stagingTex, 0, D3D11_MAP_READ, 0, &mapped); + if (FAILED(hr)) + return false; + + rgba32 += (height-1) * width * sizeof(UInt32); + const UInt8* src = (const UInt8*)mapped.pData; + for (int y = 0; y < height; ++y) + { + if (useRGBA) + { + memcpy (rgba32, src, width*4); + } + else + { + for (int x = 0; x < width*4; x +=4) + { + rgba32[x] = src[x + 2]; + rgba32[x + 1] = src[x + 1]; + rgba32[x + 2] = src[x + 0]; + rgba32[x + 3] = src[x + 3]; + } + } + + rgba32 -= width * sizeof(UInt32); + src += mapped.RowPitch; + } + + + ctx->Unmap (stagingTex, 0); + return true; +} + + + +bool GfxDeviceD3D11::ReadbackImage( ImageReference& image, int left, int bottom, int width, int height, int destX, int destY ) +{ + Assert (image.GetFormat() == kTexFormatARGB32 || image.GetFormat() == kTexFormatRGB24); + + SetupDeferredSRGBWrite (); + + HRESULT hr; + ID3D11DeviceContext* ctx = GetD3D11Context(); + + RenderSurfaceHandle currColorSurface = GetActiveRenderColorSurfaceBBD3D11(); + RenderColorSurfaceD3D11* colorSurf = reinterpret_cast<RenderColorSurfaceD3D11*>(currColorSurface.object); + if (!colorSurf) + return false; + + RTVPointer rtView; + ctx->OMGetRenderTargets (1, &rtView, NULL); + if (!rtView) + return false; + + ResourcePointer rtRes; + rtView->GetResource (&rtRes); + if (!rtRes) + return false; + + D3D11_RESOURCE_DIMENSION rtType; + rtRes->GetType (&rtType); + if (rtType != D3D11_RESOURCE_DIMENSION_TEXTURE2D) + return false; + + ID3D11Texture2D* rtTex = static_cast<ID3D11Texture2D*>((ID3D11Resource*)rtRes); + D3D11_TEXTURE2D_DESC rtDesc; + rtTex->GetDesc (&rtDesc); + if (rtDesc.Format != DXGI_FORMAT_R8G8B8A8_UNORM && rtDesc.Format != DXGI_FORMAT_R8G8B8A8_TYPELESS && rtDesc.Format != DXGI_FORMAT_R8G8B8A8_UNORM_SRGB) + return false; + + ID3D11Device* dev = GetD3D11Device(); + ResolveTexturePool::Entry* resolved = NULL; + if (rtDesc.SampleDesc.Count != 1) + { + resolved = m_Resolves.GetResolveTexture (rtDesc.Width, rtDesc.Height, colorSurf->format, m_SRGBWrite); + if (!resolved) + return false; + + ctx->ResolveSubresource (resolved->texture, 0, rtTex, 0, rtDesc.Format); + rtTex = resolved->texture; + } + + Texture2DPointer stagingTex; + D3D11_TEXTURE2D_DESC stagingDesc; + stagingDesc.Width = width; + stagingDesc.Height = height; + stagingDesc.MipLevels = 1; + stagingDesc.ArraySize = 1; + stagingDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + stagingDesc.SampleDesc.Count = 1; + stagingDesc.SampleDesc.Quality = 0; + stagingDesc.Usage = D3D11_USAGE_STAGING; + stagingDesc.BindFlags = 0; + stagingDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; + stagingDesc.MiscFlags = 0; + hr = dev->CreateTexture2D (&stagingDesc, NULL, &stagingTex); + if (FAILED(hr)) + return false; + SetDebugNameD3D11 (stagingTex, Format("Readback-Texture2D-%dx%d", width, height)); + + D3D11_BOX srcBox; + srcBox.left = left; + srcBox.right = left + width; + srcBox.top = m_CurrTargetHeight - (bottom + height); + srcBox.bottom = m_CurrTargetHeight - (bottom); + srcBox.front = 0; + srcBox.back = 1; + ctx->CopySubresourceRegion (stagingTex, 0, 0, 0, 0, rtTex, 0, &srcBox); + + D3D11_MAPPED_SUBRESOURCE mapped; + hr = ctx->Map (stagingTex, 0, D3D11_MAP_READ, 0, &mapped); + if (FAILED(hr)) + return false; + + const UInt8* src = (const UInt8*)mapped.pData; + + if (image.GetFormat() == kTexFormatARGB32) + { + for (int y = height-1; y >= 0; --y) + { + const UInt32* srcPtr = (const UInt32*)src; + UInt32* dstPtr = (UInt32*)(image.GetRowPtr(destY+y) + destX * 4); + for (int x = 0; x < width; ++x) + { + UInt32 abgrCol = *srcPtr; + UInt32 bgraCol = ((abgrCol & 0x00FFFFFF) << 8) | ((abgrCol&0xFF000000) >> 24); + *dstPtr = bgraCol; + ++srcPtr; + ++dstPtr; + } + src += mapped.RowPitch; + } + } + else if (image.GetFormat() == kTexFormatRGB24) + { + for (int y = height-1; y >= 0; --y) + { + const UInt32* srcPtr = (const UInt32*)src; + UInt8* dstPtr = image.GetRowPtr(destY+y) + destX * 3; + for (int x = 0; x < width; ++x) + { + UInt32 abgrCol = *srcPtr; + dstPtr[0] = (abgrCol & 0x000000FF); + dstPtr[1] = (abgrCol & 0x0000FF00) >> 8; + dstPtr[2] = (abgrCol & 0x00FF0000) >> 16; + ++srcPtr; + dstPtr += 3; + } + src += mapped.RowPitch; + } + } + ctx->Unmap (stagingTex, 0); + return true; +} + +void GfxDeviceD3D11::GrabIntoRenderTexture(RenderSurfaceHandle rtHandle, RenderSurfaceHandle rd, int x, int y, int width, int height) +{ + DX11_LOG_ENTER_FUNCTION("GrabIntoRenderTexture(%p, %p, %d, %d, %dx%d)", rtHandle.object, rd.object, x, y, width, height); + if (!rtHandle.IsValid()) + return; + if (!g_D3D11CurrColorRT) + return; + RenderSurfaceHandle currColorSurface = GetActiveRenderColorSurfaceBBD3D11(); + RenderColorSurfaceD3D11* colorSurf = reinterpret_cast<RenderColorSurfaceD3D11*>(currColorSurface.object); + if (!colorSurf) + return; + const bool sRGB = (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0) ? (colorSurf->flags & kSurfaceCreateSRGB) : false; + + RenderColorSurfaceD3D11* renderTexture = reinterpret_cast<RenderColorSurfaceD3D11*>(rtHandle.object); + TexturesD3D11::D3D11Texture* texturePointer = m_Textures.GetTexture (renderTexture->textureID); + if (!texturePointer) + return; + + SetupDeferredSRGBWrite (); + + ID3D11Resource* srcResource = g_D3D11CurrColorRT->m_Texture; + ID3D11Texture2D* srcTex = static_cast<ID3D11Texture2D*>(srcResource); + D3D11_TEXTURE2D_DESC rtDesc; + srcTex->GetDesc (&rtDesc); + Assert (rtDesc.Width == colorSurf->width && rtDesc.Height == colorSurf->height); + + ID3D11DeviceContext* ctx = GetD3D11Context(); + ResolveTexturePool::Entry* resolved = NULL; + if (rtDesc.SampleDesc.Count != 1) + { + resolved = m_Resolves.GetResolveTexture (rtDesc.Width, rtDesc.Height, colorSurf->format, sRGB); + if (!resolved) + return; + + ctx->ResolveSubresource (resolved->texture, 0, srcResource, 0, GetRenderTextureFormat(colorSurf->format, sRGB)); + srcResource = resolved->texture; + } + + ID3D11Texture2D* dstTex = static_cast<ID3D11Texture2D*>(texturePointer->m_Texture); + D3D11_TEXTURE2D_DESC dstDesc; + dstTex->GetDesc (&dstDesc); + + if (GetBPPFromDXGIFormat(rtDesc.Format) == GetBPPFromDXGIFormat(dstDesc.Format)) + { + D3D11_BOX srcBox; + srcBox.left = x; + srcBox.right = x + width; + srcBox.top = m_CurrTargetHeight - (y + height); + srcBox.bottom = m_CurrTargetHeight - (y); + srcBox.front = 0; + srcBox.back = 1; + + ctx->CopySubresourceRegion (texturePointer->m_Texture, 0, 0, 0, 0, srcResource, 0, &srcBox); + } + else + { + // formats not compatible; have to draw a quad into destination, sampling the source texture + RenderColorSurfaceD3D11* currRT = g_D3D11CurrColorRT; + int oldTargetHeight = m_CurrTargetHeight; + int oldView[4]; + GetViewport (oldView); + bool oldScissor = IsScissorEnabled(); + int oldScissorRect[4]; + GetScissorRect (oldScissorRect); + + SetViewport (0, 0, dstDesc.Width, dstDesc.Height); + DisableScissor (); + + RenderSurfaceHandle currColor = GetActiveRenderColorSurface(0); + RenderSurfaceHandle currDepth = GetActiveRenderDepthSurface(); + SetRenderTargets (1, &rtHandle, rd, 0, kCubeFaceUnknown); + + const float u0 = x / float(rtDesc.Width); + const float u1 = (x+width) / float(rtDesc.Width); + const float v0 = (rtDesc.Height - y) / float(rtDesc.Height); + const float v1 = (rtDesc.Height - (y+height)) / float(rtDesc.Height); + + ID3D11ShaderResourceView* srv = currRT ? currRT->m_SRView : NULL; + if (resolved) + srv = resolved->srv; + + DrawQuad (u0, v0, u1, v1, 0.0f, srv); + SetRenderTargets (1, &currColor, currDepth, 0, kCubeFaceUnknown); + SetViewport (oldView[0], oldView[1], oldView[2], oldView[3]); + if (oldScissor) + SetScissorRect (oldScissorRect[0], oldScissorRect[1], oldScissorRect[2], oldScissorRect[3]); + } +} + +void GfxDeviceD3D11::DrawQuad (float u0, float v0, float u1, float v1, float z, ID3D11ShaderResourceView* texture) +{ + // Can't use DeviceMVPMatricesState since that tries to get potentially threaded device. + // We need to access our own device directly. + Matrix4x4f m_World, m_View, m_Proj; + CopyMatrix(GetViewMatrix(), m_View.GetPtr()); + CopyMatrix(GetWorldMatrix(), m_World.GetPtr()); + CopyMatrix(GetProjectionMatrix(), m_Proj.GetPtr()); + + // Can't use LoadFullScreenOrthoMatrix for the same reason. + Matrix4x4f matrix; + matrix.SetOrtho(0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 100.0f); + SetProjectionMatrix (matrix); + SetViewMatrix (Matrix4x4f::identity.GetPtr()); // implicitly sets world to identity + + DisableFog (); + + SetFFLighting (false, false, kColorMatDisabled); + DisableLights (0); + + ShaderLab::SubProgram* programs[kShaderTypeCount] = {0}; + GraphicsHelper::SetShaders (*this, programs, NULL); + + GfxBlendState blendDesc; + DeviceBlendState* blendState = CreateBlendState(blendDesc); + SetBlendState (blendState, 0.0f); + + GfxDepthState depthDesc; depthDesc.depthWrite = false; depthDesc.depthFunc = kFuncAlways; + DeviceDepthState* depthState = CreateDepthState(depthDesc); + SetDepthState (depthState); + + GfxRasterState rasterDesc; rasterDesc.cullMode = kCullOff; + DeviceRasterState* rasterState = CreateRasterState(rasterDesc); + SetRasterState (rasterState); + + ShaderLab::TextureBinding texEnv; + texEnv.m_TextureName.index = kShaderTexEnvWhite | ShaderLab::FastPropertyName::kBuiltinTexEnvMask; + TextureCombinersHandle combiners = CreateTextureCombiners (1, &texEnv, NULL, false, false); + + // Can't call SetTextureCombiners here since that expects to be called on main thread, + // and we might be on the device thread here. So do the work manually and call + // SetTextureCombinersThreadable. + + TexEnvData texEnvData; + memset(&texEnvData, 0, sizeof(texEnvData)); + texEnvData.textureID = TextureID(); + texEnvData.texDim = kTexDim2D; + texEnvData.texGen = kTexGenDisabled; + texEnvData.identityMatrix = true; + Vector4f texColors; + texColors.Set(1,1,1,1); + SetTextureCombinersThreadable (combiners, &texEnvData, &texColors); + + ImmediateBegin (kPrimitiveQuads); + ImmediateTexCoord(0,u0,v0,0.0f); ImmediateVertex (0.0f, 0.0f, z); + ImmediateTexCoord(0,u0,v1,0.0f); ImmediateVertex (0.0f, 1.0f, z); + ImmediateTexCoord(0,u1,v1,0.0f); ImmediateVertex (1.0f, 1.0f, z); + ImmediateTexCoord(0,u1,v0,0.0f); ImmediateVertex (1.0f, 0.0f, z); + if (ImmediateEndSetup ()) + { + ID3D11SamplerState* sampler = m_Textures.GetSampler (kSamplerPointClamp); + Assert (sampler); + ID3D11DeviceContext* ctx = GetD3D11Context(); + ctx->PSSetShaderResources (0, 1, &texture); + ctx->PSSetSamplers (0, 1, &sampler); + m_Textures.InvalidateSampler (kShaderFragment, 0); + m_ActiveTextures[kShaderFragment][0].m_ID = -1; + m_ActiveSamplers[kShaderFragment][0].m_ID = -1; + + ImmediateEndDraw (); + + ID3D11ShaderResourceView* nullTex = NULL; + ctx->PSSetShaderResources (0, 1, &nullTex); + } + + // restore matrices + SetViewMatrix(m_View.GetPtr()); + SetWorldMatrix(m_World.GetPtr()); + SetProjectionMatrix(m_Proj); +} + +void* GfxDeviceD3D11::GetNativeGfxDevice() +{ + return GetD3D11Device(); +} + +void* GfxDeviceD3D11::GetNativeTexturePointer(TextureID id) +{ + TexturesD3D11::D3D11Texture* tex = m_Textures.GetTexture(id); + if (!tex) + return NULL; + return tex->m_Texture; +} + +intptr_t GfxDeviceD3D11::CreateExternalTextureFromNative(intptr_t nativeTex) +{ + return m_Textures.RegisterNativeTexture((ID3D11ShaderResourceView*)nativeTex); +} + +void GfxDeviceD3D11::UpdateExternalTextureFromNative(TextureID tex, intptr_t nativeTex) +{ + m_Textures.UpdateNativeTexture(tex, (ID3D11ShaderResourceView*)nativeTex); +} + + +#if ENABLE_PROFILER + +void GfxDeviceD3D11::BeginProfileEvent (const char* name) +{ + if (g_D3D11BeginEventFunc) + { + wchar_t wideName[100]; + UTF8ToWide (name, wideName, 100); + g_D3D11BeginEventFunc (0, wideName); + } +} + +void GfxDeviceD3D11::EndProfileEvent () +{ + if (g_D3D11EndEventFunc) + { + g_D3D11EndEventFunc (); + } +} + +GfxTimerQuery* GfxDeviceD3D11::CreateTimerQuery() +{ + Assert(gGraphicsCaps.hasTimerQuery); + return g_TimerQueriesD3D11.CreateTimerQuery(); +} + +void GfxDeviceD3D11::DeleteTimerQuery(GfxTimerQuery* query) +{ + delete query; +} + +void GfxDeviceD3D11::BeginTimerQueries() +{ + if(!gGraphicsCaps.hasTimerQuery) + return; + + g_TimerQueriesD3D11.BeginTimerQueries(); + } + +void GfxDeviceD3D11::EndTimerQueries() +{ + if(!gGraphicsCaps.hasTimerQuery) + return; + + g_TimerQueriesD3D11.EndTimerQueries(); +} + +#endif // ENABLE_PROFILER + + +// -------- editor only functions + +#if UNITY_EDITOR + +void GfxDeviceD3D11::SetAntiAliasFlag (bool aa) +{ +} + + +void GfxDeviceD3D11::DrawUserPrimitives (GfxPrimitiveType type, int vertexCount, UInt32 vertexChannels, const void* data, int stride) +{ + if (vertexCount == 0) + return; + + Assert(vertexCount <= 60000); // TODO: handle this by multi-batching + + Assert(data && vertexCount >= 0 && vertexChannels != 0); + + DynamicD3D11VBO& vbo = static_cast<DynamicD3D11VBO&>(GetDynamicVBO()); + + void* vbPtr; + //@TODO: hack to pass kDrawTriangleStrip, but we only need that to determine if we need index buffer or not (we don't) + if (!vbo.GetChunk(vertexChannels, vertexCount, 0, DynamicVBO::kDrawTriangleStrip, &vbPtr, NULL)) + return; + memcpy (vbPtr, data, vertexCount * stride); + vbo.ReleaseChunk (vertexCount, 0); + + vbo.DrawChunkUserPrimitives (type); +} + +int GfxDeviceD3D11::GetCurrentTargetAA() const +{ + return 0; //@TODO +} + +GfxDeviceWindow* GfxDeviceD3D11::CreateGfxWindow (HWND window, int width, int height, DepthBufferFormat depthFormat, int antiAlias) +{ + return new D3D11Window(window, width, height, depthFormat, antiAlias); +} + +static ID3D11Texture2D* FindD3D11TextureByID (TextureID tid) +{ + GfxDevice& device = GetRealGfxDevice(); + if (device.GetRenderer() != kGfxRendererD3D11) + return NULL; + GfxDeviceD3D11& dev = static_cast<GfxDeviceD3D11&>(device); + TexturesD3D11::D3D11Texture* basetex = dev.GetTextures().GetTexture(tid); + if (!basetex || !basetex->m_Texture) + return NULL; + D3D11_RESOURCE_DIMENSION dim = D3D11_RESOURCE_DIMENSION_UNKNOWN; + basetex->m_Texture->GetType(&dim); + if (dim != D3D11_RESOURCE_DIMENSION_TEXTURE2D) + return NULL; + return static_cast<ID3D11Texture2D*>(basetex->m_Texture); +} + +HDC AcquireHDCForTextureD3D11 (TextureID tid, int& outWidth, int& outHeight) +{ + ID3D11Texture2D* tex = FindD3D11TextureByID (tid); + if (!tex) + return NULL; + + D3D11_TEXTURE2D_DESC desc; + tex->GetDesc (&desc); + outWidth = desc.Width; + outHeight = desc.Height; + + IDXGISurface1* dxgiSurface = NULL; + tex->QueryInterface(__uuidof(IDXGISurface1), (void**)(&dxgiSurface)); + HDC dc = NULL; + if (dxgiSurface) + { + dxgiSurface->GetDC (false, &dc); + dxgiSurface->Release(); + } + return dc; +} + +void ReleaseHDCForTextureD3D11 (TextureID tid, HDC dc) +{ + ID3D11Texture2D* tex = FindD3D11TextureByID (tid); + if (!tex) + return; + + IDXGISurface1* dxgiSurface = NULL; + tex->QueryInterface(__uuidof(IDXGISurface1), (void**)(&dxgiSurface)); + if (dxgiSurface) + { + dxgiSurface->ReleaseDC(NULL); + dxgiSurface->Release(); + } +} + +#endif // UNITY_EDITOR + + +int GfxDeviceD3D11::GetCurrentTargetWidth() const +{ + return m_CurrTargetWidth; +} + +int GfxDeviceD3D11::GetCurrentTargetHeight() const +{ + return m_CurrTargetHeight; +} + +void GfxDeviceD3D11::SetCurrentTargetSize(int width, int height) +{ + m_CurrTargetWidth = width; + m_CurrTargetHeight = height; +} + +void GfxDeviceD3D11::SetCurrentWindowSize(int width, int height) +{ + m_CurrWindowWidth = m_CurrTargetWidth = width; + m_CurrWindowHeight = m_CurrTargetHeight = height; +} + + +// ---------------------------------------------------------------------- + +void GfxDeviceD3D11::SetComputeBuffer11 (ShaderType shaderType, int unit, ComputeBufferID bufferHandle) +{ + ComputeBuffer11* buffer = m_Textures.GetComputeBuffer(bufferHandle); + ID3D11ShaderResourceView* srv = buffer ? buffer->srv : NULL; + ID3D11DeviceContext* ctx = GetD3D11Context(); + switch (shaderType) { + case kShaderVertex: ctx->VSSetShaderResources (unit, 1, &srv); break; + case kShaderFragment: ctx->PSSetShaderResources (unit, 1, &srv); break; + case kShaderGeometry: ctx->GSSetShaderResources (unit, 1, &srv); break; + case kShaderHull: ctx->HSSetShaderResources (unit, 1, &srv); break; + case kShaderDomain: ctx->DSSetShaderResources (unit, 1, &srv); break; + default: AssertString("unknown shader type"); + } + m_ActiveTextures[shaderType][unit].m_ID = 0; +} + + +void GfxDeviceD3D11::SetComputeBufferData (ComputeBufferID bufferHandle, const void* data, size_t size) +{ + if (!data || !size) + return; + ComputeBuffer11* buffer = m_Textures.GetComputeBuffer(bufferHandle); + if (!buffer || !buffer->buffer) + return; + + ID3D11DeviceContext* ctx = GetD3D11Context(); + D3D11_BOX box; + box.left = 0; + box.top = 0; + box.front = 0; + box.right = size; + box.bottom = 1; + box.back = 1; + ctx->UpdateSubresource (buffer->buffer, 0, &box, data, 0, 0); +} + + +void GfxDeviceD3D11::GetComputeBufferData (ComputeBufferID bufferHandle, void* dest, size_t destSize) +{ + if (!dest || !destSize) + return; + ComputeBuffer11* buffer = m_Textures.GetComputeBuffer(bufferHandle); + if (!buffer || !buffer->buffer) + return; + + ID3D11DeviceContext* ctx = GetD3D11Context(); + + ID3D11Buffer* cpuBuffer = NULL; + D3D11_BUFFER_DESC desc; + ZeroMemory (&desc, sizeof(desc)); + buffer->buffer->GetDesc (&desc); + desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; + desc.Usage = D3D11_USAGE_STAGING; + desc.BindFlags = 0; + desc.MiscFlags = 0; + HRESULT hr = GetD3D11Device()->CreateBuffer(&desc, NULL, &cpuBuffer); + if (FAILED(hr)) + return; + SetDebugNameD3D11 (cpuBuffer, Format("CSGetData-Staging-%d", desc.ByteWidth)); + + ctx->CopyResource (cpuBuffer, buffer->buffer); + + D3D11_MAPPED_SUBRESOURCE mapped; + hr = ctx->Map (cpuBuffer, 0, D3D11_MAP_READ, 0, &mapped); + if (SUCCEEDED(hr)) + { + memcpy (dest, mapped.pData, destSize); + ctx->Unmap (cpuBuffer, 0); + } + SAFE_RELEASE (cpuBuffer); +} + + + +void GfxDeviceD3D11::CopyComputeBufferCount (ComputeBufferID srcBuffer, ComputeBufferID dstBuffer, UInt32 dstOffset) +{ + ComputeBuffer11* src = m_Textures.GetComputeBuffer(srcBuffer); + if (!src || !src->uav) + return; + ComputeBuffer11* dst = m_Textures.GetComputeBuffer(dstBuffer); + if (!dst || !dst->buffer) + return; + ID3D11DeviceContext* ctx = GetD3D11Context(); + ctx->CopyStructureCount (dst->buffer, dstOffset, src->uav); +} + + + +void GfxDeviceD3D11::SetRandomWriteTargetTexture (int index, TextureID tid) +{ + void SetRandomWriteTargetTextureD3D11 (int index, TextureID tid); + SetRandomWriteTargetTextureD3D11 (index, tid); +} + +void GfxDeviceD3D11::SetRandomWriteTargetBuffer (int index, ComputeBufferID bufferHandle) +{ + void SetRandomWriteTargetBufferD3D11 (int index, ComputeBufferID bufferHandle); + SetRandomWriteTargetBufferD3D11 (index, bufferHandle); +} + +void GfxDeviceD3D11::ClearRandomWriteTargets () +{ + void ClearRandomWriteTargetsD3D11 (TexturesD3D11* textures); + ClearRandomWriteTargetsD3D11 (&m_Textures); +} + + +ComputeProgramHandle GfxDeviceD3D11::CreateComputeProgram (const UInt8* code, size_t codeSize) +{ + ComputeProgramHandle cpHandle; + if (gGraphicsCaps.d3d11.featureLevel < kDX11Level11_0) + return cpHandle; + + ID3D11Device* dev = GetD3D11Device(); + HRESULT hr; + ID3D11ComputeShader* cs = NULL; + hr = dev->CreateComputeShader (code, codeSize, NULL, &cs); + if (FAILED(hr)) + return cpHandle; + SetDebugNameD3D11 (cs, Format("ComputeShader-%d", (int)codeSize)); + + cpHandle.object = cs; + return cpHandle; +} + +void GfxDeviceD3D11::DestroyComputeProgram (ComputeProgramHandle& cpHandle) +{ + if (!cpHandle.IsValid()) + return; + + ID3D11ComputeShader* cs = reinterpret_cast<ID3D11ComputeShader*>(cpHandle.object); + SAFE_RELEASE(cs); + cpHandle.Reset(); +} + +void GfxDeviceD3D11::CreateComputeConstantBuffers (unsigned count, const UInt32* sizes, ConstantBufferHandle* outCBs) +{ + ID3D11Device* dev = GetD3D11Device(); + HRESULT hr; + + D3D11_BUFFER_DESC desc; + desc.Usage = D3D11_USAGE_DYNAMIC; + desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + for (unsigned i = 0; i < count; ++i) + { + desc.ByteWidth = sizes[i]; + ID3D11Buffer* cb = NULL; + hr = dev->CreateBuffer (&desc, NULL, &cb); + if (cb) + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(cb,sizes[i],this); + Assert (SUCCEEDED(hr)); + outCBs[i].object = cb; + + SetDebugNameD3D11 (cb, Format("CSConstantBuffer-%d-%d", i, sizes[i])); + } +} + +void GfxDeviceD3D11::DestroyComputeConstantBuffers (unsigned count, ConstantBufferHandle* cbs) +{ + for (unsigned i = 0; i < count; ++i) + { + ID3D11Buffer* cb = reinterpret_cast<ID3D11Buffer*>(cbs[i].object); + REGISTER_EXTERNAL_GFX_DEALLOCATION(cb); + SAFE_RELEASE(cb); + cbs[i].Reset(); + } +} + + +void GfxDeviceD3D11::CreateComputeBuffer (ComputeBufferID id, size_t count, size_t stride, UInt32 flags) +{ + ComputeBuffer11 buffer; + buffer.buffer = NULL; + buffer.srv = NULL; + buffer.uav = NULL; + if (gGraphicsCaps.d3d11.featureLevel < kDX11Level10_0) + return; + + ID3D11Device* dev = GetD3D11Device(); + HRESULT hr; + + // buffer + D3D11_BUFFER_DESC bufferDesc; + memset (&bufferDesc, 0, sizeof(bufferDesc)); + bufferDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE; + if (gGraphicsCaps.d3d11.featureLevel >= kDX11Level11_0) + bufferDesc.BindFlags |= D3D11_BIND_UNORDERED_ACCESS; + bufferDesc.ByteWidth = count * stride; + if (flags & kCBFlagDrawIndirect) + bufferDesc.MiscFlags = (gGraphicsCaps.d3d11.featureLevel >= kDX11Level11_0 ? D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS : 0); + else if (flags & kCBFlagRaw) + bufferDesc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; + else + bufferDesc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED; + bufferDesc.StructureByteStride = stride; + bufferDesc.Usage = D3D11_USAGE_DEFAULT; + hr = dev->CreateBuffer (&bufferDesc, NULL, &buffer.buffer); + if (buffer.buffer) + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(buffer.buffer,count * stride,this); + Assert (SUCCEEDED(hr)); + SetDebugNameD3D11 (buffer.buffer, Format("ComputeBuffer-%dx%d", (int)count, (int)stride)); + + // unordered access view, only on DX11+ HW + if (gGraphicsCaps.d3d11.featureLevel >= kDX11Level11_0 && !(flags & kCBFlagDrawIndirect)) + { + D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc; + memset (&uavDesc, 0, sizeof(uavDesc)); + uavDesc.Format = (flags & kCBFlagRaw) ? DXGI_FORMAT_R32_TYPELESS : DXGI_FORMAT_UNKNOWN; + uavDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER; + uavDesc.Buffer.FirstElement = 0; + uavDesc.Buffer.NumElements = count; + uavDesc.Buffer.Flags = flags & kCBFlagTypeMask; + hr = dev->CreateUnorderedAccessView (buffer.buffer, &uavDesc, &buffer.uav); + Assert (SUCCEEDED(hr)); + SetDebugNameD3D11 (buffer.uav, Format("ComputeBuffer-UAV-%dx%d", (int)count, (int)stride)); + + // shader resource view + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + memset (&srvDesc, 0, sizeof(srvDesc)); + if (flags & kCBFlagRaw) + { + srvDesc.Format = DXGI_FORMAT_R32_TYPELESS; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFEREX; + srvDesc.BufferEx.FirstElement = 0; + srvDesc.BufferEx.NumElements = count; + srvDesc.BufferEx.Flags = D3D11_BUFFEREX_SRV_FLAG_RAW; + } + else + { + srvDesc.Format = DXGI_FORMAT_UNKNOWN; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER; + srvDesc.Buffer.FirstElement = 0; + srvDesc.Buffer.NumElements = count; + } + hr = dev->CreateShaderResourceView (buffer.buffer, &srvDesc, &buffer.srv); + Assert (SUCCEEDED(hr)); + SetDebugNameD3D11 (buffer.uav, Format("ComputeBuffer-SRV-%dx%d", (int)count, (int)stride)); + } + + m_Textures.AddComputeBuffer (id, buffer); +} + + +void GfxDeviceD3D11::DestroyComputeBuffer (ComputeBufferID handle) +{ + if (!handle.IsValid()) + return; + + ComputeBuffer11* buffer = m_Textures.GetComputeBuffer(handle); + if (buffer) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(buffer->buffer); + SAFE_RELEASE(buffer->buffer); + SAFE_RELEASE(buffer->srv); + SAFE_RELEASE(buffer->uav); + } + m_Textures.RemoveComputeBuffer (handle); +} + + +void GfxDeviceD3D11::UpdateComputeConstantBuffers (unsigned count, ConstantBufferHandle* cbs, UInt32 cbDirty, size_t dataSize, const UInt8* data, const UInt32* cbSizes, const UInt32* cbOffsets, const int* bindPoints) +{ + ID3D11DeviceContext* ctx = GetD3D11Context(); + + // go over constant buffers in use + for (unsigned i = 0; i < count; ++i) + { + if (bindPoints[i] < 0) + continue; // CB not going to be used, no point in updating it + + ID3D11Buffer* cb = reinterpret_cast<ID3D11Buffer*>(cbs[i].object); + + // update buffer if dirty + UInt32 dirtyMask = (1<<i); + if (cbDirty & dirtyMask) + { + D3D11_MAPPED_SUBRESOURCE mapped; + HRESULT hr; + hr = ctx->Map (cb, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped); + Assert (SUCCEEDED(hr)); + memcpy (mapped.pData, data + cbOffsets[i], cbSizes[i]); + ctx->Unmap (cb, 0); + } + + // bind it + ctx->CSSetConstantBuffers (bindPoints[i], 1, &cb); + } +} + + + +void GfxDeviceD3D11::UpdateComputeResources ( + unsigned texCount, const TextureID* textures, const int* texBindPoints, + unsigned samplerCount, const unsigned* samplers, + unsigned inBufferCount, const ComputeBufferID* inBuffers, const int* inBufferBindPoints, + unsigned outBufferCount, const ComputeBufferID* outBuffers, const TextureID* outTextures, const UInt32* outBufferBindPoints) +{ + ID3D11DeviceContext* ctx = GetD3D11Context(); + + for (unsigned i = 0; i < texCount; ++i) + { + if (textures[i].m_ID == 0) + continue; + TexturesD3D11::D3D11Texture* tex = m_Textures.GetTexture (textures[i]); + if (!tex) + continue; + + // if texture is bound as render target: unbind it (set backbuffer as RT) + if ((g_D3D11CurrColorRT && g_D3D11CurrColorRT->m_Texture == tex->m_Texture) || + (g_D3D11CurrDepthRT && g_D3D11CurrDepthRT->m_Texture == tex->m_Texture)) + { + RenderSurfaceHandle defaultColor = GetBackBufferColorSurface(); + RenderSurfaceHandle defaultDepth = GetBackBufferDepthSurface(); + SetRenderTargets (1, &defaultColor, defaultDepth, 0, kCubeFaceUnknown); + } + ctx->CSSetShaderResources (texBindPoints[i] & 0xFFFF, 1, &tex->m_SRV); + unsigned samplerBindPoint = (texBindPoints[i] >> 16) & 0xFFFF; + if (samplerBindPoint != 0xFFFF) + { + ID3D11SamplerState* smp = m_Textures.GetSampler(tex->m_Sampler); + ctx->CSSetSamplers (samplerBindPoint, 1, &smp); + } + } + + for (unsigned i = 0; i < samplerCount; ++i) + { + BuiltinSamplerState type = (BuiltinSamplerState)((samplers[i] & 0xFFFF0000) >> 16); + unsigned bindPoint = samplers[i] & 0xFFFF; + ID3D11SamplerState* smp = m_Textures.GetSampler (type); + Assert (smp); + ctx->CSSetSamplers (bindPoint, 1, &smp); + } + + for (unsigned i = 0; i < inBufferCount; ++i) + { + ComputeBuffer11* buffer = m_Textures.GetComputeBuffer(inBuffers[i]); + if (!buffer) + continue; + ctx->CSSetShaderResources (inBufferBindPoints[i], 1, &buffer->srv); + } + + for (unsigned i = 0; i < outBufferCount; ++i) + { + ID3D11UnorderedAccessView* uav = NULL; + if (outBufferBindPoints[i] & 0x80000000) + { + // UAV comes from texture + if (outTextures[i].m_ID == 0) + continue; + TexturesD3D11::D3D11Texture* tex = m_Textures.GetTexture (outTextures[i]); + if (!tex || !tex->m_UAV) + continue; + uav = tex->m_UAV; + } + else + { + // UAV is raw buffer + if (!outBuffers[i].IsValid()) + continue; + ComputeBuffer11* buffer = m_Textures.GetComputeBuffer(outBuffers[i]); + if (!buffer) + continue; + uav = buffer->uav; + } + UINT uavInitialCounts[] = { -1 }; // keeps current offsets for Appendable/Consumeable UAVs + ctx->CSSetUnorderedAccessViews (outBufferBindPoints[i] & 0x7FFFFFFF, 1, &uav, uavInitialCounts); + } +} + + + +void GfxDeviceD3D11::DispatchComputeProgram (ComputeProgramHandle cpHandle, unsigned threadsX, unsigned threadsY, unsigned threadsZ) +{ + if (!cpHandle.IsValid()) + return; + + ID3D11DeviceContext* ctx = GetD3D11Context(); + ID3D11ComputeShader* cs = reinterpret_cast<ID3D11ComputeShader*>(cpHandle.object); + ctx->CSSetShader (cs, NULL, 0); + ctx->Dispatch (threadsX, threadsY, threadsZ); + + + // DEBUG: readback output UAV contents + #if 0 && !UNITY_RELEASE + ID3D11UnorderedAccessView* uav; + ctx->CSGetUnorderedAccessViews (0, 1, &uav); + ID3D11Buffer* res; + uav->GetResource ((ID3D11Resource**)&res); + + ID3D11Buffer* debugbuf = NULL; + D3D11_BUFFER_DESC desc; + ZeroMemory (&desc, sizeof(desc)); + res->GetDesc (&desc); + desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; + desc.Usage = D3D11_USAGE_STAGING; + desc.BindFlags = 0; + desc.MiscFlags = 0; + GetD3D11Device()->CreateBuffer(&desc, NULL, &debugbuf); + ctx->CopyResource (debugbuf, res); + + D3D11_MAPPED_SUBRESOURCE mapped; + ctx->Map(debugbuf, 0, D3D11_MAP_READ, 0, &mapped); + ctx->Unmap(debugbuf, 0); + SAFE_RELEASE(debugbuf); + #endif + + ID3D11UnorderedAccessView* nullUAVs[8] = {0}; + ctx->CSSetUnorderedAccessViews (0, 8, nullUAVs, NULL); +} + + +// ---------------------------------------------------------------------- + + +void GfxDeviceD3D11::DrawNullGeometry (GfxPrimitiveType topology, int vertexCount, int instanceCount) +{ + ID3D11DeviceContext* ctx = GetD3D11Context(); + UINT strides = 0; + UINT offsets = 0; + ID3D11Buffer* vb = NULL; + D3D11_CALL (ctx->IASetVertexBuffers(0, 1, &vb, &strides, &offsets)); + + BeforeDrawCall (false); + + // vertex layout + SetInputLayoutD3D11 (ctx, NULL); + + // draw + if (!SetTopologyD3D11 (topology, *this, ctx)) + return; + if (instanceCount > 1) + { + D3D11_CALL (ctx->DrawInstanced (vertexCount, instanceCount, 0, 0)); + } + else + { + D3D11_CALL (ctx->Draw (vertexCount, 0)); + } +} + +void GfxDeviceD3D11::DrawNullGeometryIndirect (GfxPrimitiveType topology, ComputeBufferID bufferHandle, UInt32 bufferOffset) +{ + if (gGraphicsCaps.d3d11.featureLevel < kDX11Level11_0) + return; + + ID3D11DeviceContext* ctx = GetD3D11Context(); + UINT strides = 0; + UINT offsets = 0; + ID3D11Buffer* vb = NULL; + D3D11_CALL (ctx->IASetVertexBuffers(0, 1, &vb, &strides, &offsets)); + + BeforeDrawCall (false); + + // vertex layout + SetInputLayoutD3D11 (ctx, NULL); + + // draw + if (!SetTopologyD3D11 (topology, *this, ctx)) + return; + ComputeBuffer11* buffer = m_Textures.GetComputeBuffer(bufferHandle); + if (!buffer || !buffer->buffer) + return; + D3D11_CALL (ctx->DrawInstancedIndirect (buffer->buffer, bufferOffset)); +} + + +// GPU skinning functionality +GPUSkinningInfo * GfxDeviceD3D11::CreateGPUSkinningInfo() +{ + // stream-out requires at least DX10.0 + if (gGraphicsCaps.d3d11.featureLevel < kDX11Level10_0) + return NULL; + + return new StreamOutSkinningInfo(); +} + +void GfxDeviceD3D11::DeleteGPUSkinningInfo(GPUSkinningInfo *info) +{ + delete reinterpret_cast<StreamOutSkinningInfo *>(info); +} + +// All actual functionality is performed in StreamOutSkinningInfo, just forward the calls +void GfxDeviceD3D11::SkinOnGPU( GPUSkinningInfo * info, bool lastThisFrame ) +{ + reinterpret_cast<StreamOutSkinningInfo *>(info)->SkinMesh(lastThisFrame); +} + +void GfxDeviceD3D11::UpdateSkinSourceData(GPUSkinningInfo *info, const void *vertData, const BoneInfluence *skinData, bool dirty) +{ + reinterpret_cast<StreamOutSkinningInfo *>(info)->UpdateSourceData(vertData, skinData, dirty); +} + +void GfxDeviceD3D11::UpdateSkinBonePoses(GPUSkinningInfo *info, const int boneCount, const Matrix4x4f* poses) +{ + reinterpret_cast<StreamOutSkinningInfo *>(info)->UpdateSourceBones(boneCount, poses); +} + + +// ---------------------------------------------------------------------- +// verification of state + +#if GFX_DEVICE_VERIFY_ENABLE + + +void GfxDeviceD3D11::VerifyState() +{ +} +#endif // GFX_DEVICE_VERIFY_ENABLE diff --git a/Runtime/GfxDevice/d3d11/GfxDeviceD3D11.h b/Runtime/GfxDevice/d3d11/GfxDeviceD3D11.h new file mode 100644 index 0000000..8a7595c --- /dev/null +++ b/Runtime/GfxDevice/d3d11/GfxDeviceD3D11.h @@ -0,0 +1,357 @@ +#pragma once + +#include "Runtime/GfxDevice/GfxDevice.h" +#include "Runtime/GfxDevice/TransformState.h" +#include "D3D11Includes.h" +#include "VertexDeclarationsD3D11.h" +#include "TexturesD3D11.h" +#include "FixedFunctionStateD3D11.h" +#include "ConstantBuffersD3D11.h" +#include <map> + +class FixedFunctionProgramD3D11; +class DynamicD3D11VBO; + + +// TODO: optimize this. Right now we just send off whole 8 float3 UVs with each +// immediate mode vertex. We could at least detect the number of them used from +// ImmediateTexCoord calls. +struct ImmediateVertexD3D11 { + Vector3f vertex; + Vector3f normal; + ColorRGBA32 color; + Vector3f texCoords[8]; +}; + +struct ImmediateModeD3D11 { + std::vector<ImmediateVertexD3D11> m_Vertices; + ImmediateVertexD3D11 m_Current; + GfxPrimitiveType m_Mode; + ID3D11Buffer* m_VB; + int m_VBUsedBytes; + int m_VBStartVertex; + bool m_HadColor; + + ImmediateModeD3D11(); + ~ImmediateModeD3D11(); + void Cleanup(); + void Invalidate(); +}; + +struct TextureUnitState11 +{ + Matrix4x4f matrix; +}; + + + +typedef std::map<FixedFunctionStateD3D11, FixedFunctionProgramD3D11*, FixedFuncStateCompareD3D11> FFProgramCacheD3D11; + +struct ResolveTexturePool +{ + enum { kResolvePoolSize = 8 }; + struct Entry + { + // key + int width; + int height; + RenderTextureFormat format; + bool sRGB; + + // data + ID3D11Texture2D* texture; + ID3D11ShaderResourceView* srv; + int lastUse; + }; + + ResolveTexturePool(); + void Clear(); + + Entry* GetResolveTexture (int width, int height, RenderTextureFormat fmt, bool sRGB); + + Entry m_Entries[kResolvePoolSize]; + int m_UseCounter; +}; + +class GfxDeviceD3D11 : public GfxThreadableDevice +{ +public: + struct DeviceBlendStateD3D11 : public DeviceBlendState + { + ID3D11BlendState* deviceState; + }; + + typedef std::map< GfxBlendState, DeviceBlendStateD3D11, memcmp_less<GfxBlendState> > CachedBlendStates; + typedef std::map< GfxDepthState, DeviceDepthState, memcmp_less<GfxDepthState> > CachedDepthStates; + typedef std::map< GfxStencilState, DeviceStencilState, memcmp_less<GfxStencilState> > CachedStencilStates; + typedef std::map< GfxRasterState, DeviceRasterState, memcmp_less<GfxRasterState> > CachedRasterStates; + + struct DepthStencilState { + DeviceDepthState d; + DeviceStencilState s; + }; + typedef std::map< DepthStencilState, ID3D11DepthStencilState*, memcmp_less<DepthStencilState> > CachedDepthStencilStates; + + struct FinalRasterState11 { + DeviceRasterState raster; + bool backface; + bool wireframe; + bool scissor; + }; + typedef std::map< FinalRasterState11, ID3D11RasterizerState*, memcmp_less<FinalRasterState11> > CachedFinalRasterStates; + +public: + GfxDeviceD3D11(); + GFX_API ~GfxDeviceD3D11(); + + GFX_API void InvalidateState(); + #if GFX_DEVICE_VERIFY_ENABLE + GFX_API void VerifyState(); + #endif + + GFX_API void Clear (UInt32 clearFlags, const float color[4], float depth, int stencil); + GFX_API void SetUserBackfaceMode( bool enable ); + GFX_API void SetWireframe (bool wire); + GFX_API bool GetWireframe() const; + GFX_API void SetInvertProjectionMatrix( bool enable ); + GFX_API bool GetInvertProjectionMatrix() const; + + GFX_API DeviceBlendState* CreateBlendState(const GfxBlendState& state); + GFX_API DeviceDepthState* CreateDepthState(const GfxDepthState& state); + GFX_API DeviceStencilState* CreateStencilState(const GfxStencilState& state); + GFX_API DeviceRasterState* CreateRasterState(const GfxRasterState& state); + + GFX_API void SetBlendState(const DeviceBlendState* state, float alphaRef); + GFX_API void SetRasterState(const DeviceRasterState* state); + GFX_API void SetDepthState(const DeviceDepthState* state); + GFX_API void SetStencilState(const DeviceStencilState* state, int stencilRef); + GFX_API void SetSRGBWrite (const bool); + GFX_API bool GetSRGBWrite (); + + /* GPU Skinning functions */ + GFX_API GPUSkinningInfo *CreateGPUSkinningInfo(); + GFX_API void DeleteGPUSkinningInfo(GPUSkinningInfo *info); + GFX_API void SkinOnGPU( GPUSkinningInfo * info, bool lastThisFrame ); + GFX_API void UpdateSkinSourceData(GPUSkinningInfo *info, const void *vertData, const BoneInfluence *skinData, bool dirty); + GFX_API void UpdateSkinBonePoses(GPUSkinningInfo *info, const int boneCount, const Matrix4x4f* poses); + + GFX_API void SetWorldMatrix( const float matrix[16] ); + GFX_API void SetViewMatrix( const float matrix[16] ); + GFX_API void SetProjectionMatrix (const Matrix4x4f& matrix); + GFX_API void GetMatrix( float outMatrix[16] ) const; + + GFX_API const float* GetWorldMatrix() const ; + GFX_API const float* GetViewMatrix() const ; + GFX_API const float* GetProjectionMatrix() const ; + GFX_API const float* GetDeviceProjectionMatrix() const; + + GFX_API void SetNormalizationBackface( NormalizationMode mode, bool backface ); + GFX_API void SetFFLighting( bool on, bool separateSpecular, ColorMaterialMode colorMaterial ); + GFX_API void SetMaterial( const float ambient[4], const float diffuse[4], const float specular[4], const float emissive[4], const float shininess ); + GFX_API void SetColor( const float color[4] ); + GFX_API void SetViewport( int x, int y, int width, int height ); + GFX_API void GetViewport( int* port ) const; + + GFX_API void SetScissorRect( int x, int y, int width, int height ); + GFX_API void DisableScissor(); + GFX_API bool IsScissorEnabled() const; + GFX_API void GetScissorRect( int values[4] ) const; + + GFX_API bool IsCombineModeSupported( unsigned int combiner ); + GFX_API TextureCombinersHandle CreateTextureCombiners( int count, const ShaderLab::TextureBinding* texEnvs, const ShaderLab::PropertySheet* props, bool hasVertexColorOrLighting, bool usesAddSpecular ); + GFX_API void DeleteTextureCombiners( TextureCombinersHandle& textureCombiners ); + GFX_API void SetTextureCombinersThreadable( TextureCombinersHandle textureCombiners, const TexEnvData* texEnvData, const Vector4f* texColors ); + GFX_API void SetTextureCombiners( TextureCombinersHandle textureCombiners, const ShaderLab::PropertySheet* props ); + + GFX_API void SetTexture (ShaderType shaderType, int unit, int samplerUnit, TextureID texture, TextureDimension dim, float bias); + GFX_API void SetTextureParams( TextureID texture, TextureDimension texDim, TextureFilterMode filter, TextureWrapMode wrap, int anisoLevel, bool hasMipMap, TextureColorSpace colorSpace ); + GFX_API void SetTextureTransform( int unit, TextureDimension dim, TexGenMode texGen, bool identity, const float matrix[16]); + GFX_API void SetTextureName ( TextureID texture, const char* name ) { } + + GFX_API void SetShadersThreadable (GpuProgram* programs[kShaderTypeCount], const GpuProgramParameters* params[kShaderTypeCount], UInt8 const * const paramsBuffer[kShaderTypeCount]); + GFX_API bool IsShaderActive( ShaderType type ) const; + GFX_API void DestroySubProgram( ShaderLab::SubProgram* subprogram ); + GFX_API void SetConstantBufferInfo (int id, int size); + + GFX_API void DisableLights( int startLight ); + GFX_API void SetLight( int light, const GfxVertexLight& data); + GFX_API void SetAmbient( const float ambient[4] ); + + GFX_API void EnableFog (const GfxFogParams& fog); + GFX_API void DisableFog(); + + GFX_API VBO* CreateVBO(); + GFX_API void DeleteVBO( VBO* vbo ); + GFX_API DynamicVBO& GetDynamicVBO(); + + GFX_API void DiscardContents (RenderSurfaceHandle& rs); + + GFX_API RenderSurfaceHandle CreateRenderColorSurface (TextureID textureID, int width, int height, int samples, int depth, TextureDimension dim, RenderTextureFormat format, UInt32 createFlags); + GFX_API RenderSurfaceHandle CreateRenderDepthSurface (TextureID textureID, int width, int height, int samples, TextureDimension dim, DepthBufferFormat depthFormat, UInt32 createFlags); + GFX_API void DestroyRenderSurface (RenderSurfaceHandle& rs); + GFX_API void SetRenderTargets (int count, RenderSurfaceHandle* colorHandles, RenderSurfaceHandle depthHandle, int mipLevel, CubemapFace face = kCubeFaceUnknown); + GFX_API void ResolveColorSurface (RenderSurfaceHandle srcHandle, RenderSurfaceHandle dstHandle); + GFX_API void ResolveDepthIntoTexture (RenderSurfaceHandle colorHandle, RenderSurfaceHandle depthHandle); + GFX_API RenderSurfaceHandle GetActiveRenderColorSurface (int index); + GFX_API RenderSurfaceHandle GetActiveRenderDepthSurface (); + GFX_API void SetSurfaceFlags(RenderSurfaceHandle surf, UInt32 flags, UInt32 keepFlags); + + + GFX_API void UploadTexture2D( TextureID texture, TextureDimension dimension, UInt8* srcData, int srcSize, int width, int height, TextureFormat format, int mipCount, UInt32 uploadFlags, int skipMipLevels, TextureUsageMode usageMode, TextureColorSpace colorSpace ); + GFX_API void UploadTextureSubData2D( TextureID texture, UInt8* srcData, int srcSize, int mipLevel, int x, int y, int width, int height, TextureFormat format, TextureColorSpace colorSpace ); + GFX_API void UploadTextureCube( TextureID texture, UInt8* srcData, int srcSize, int faceDataSize, int size, TextureFormat format, int mipCount, UInt32 uploadFlags, TextureColorSpace colorSpace ); + GFX_API void UploadTexture3D( TextureID texture, UInt8* srcData, int srcSize, int width, int height, int depth, TextureFormat format, int mipCount, UInt32 uploadFlags ); + GFX_API void DeleteTexture( TextureID texture ); + + GFX_API PresentMode GetPresentMode(); + + GFX_API void BeginFrame(); + GFX_API void EndFrame(); + GFX_API void PresentFrame(); + GFX_API bool IsValidState(); + + GFX_API void FinishRendering(); + + // Immediate mode rendering + GFX_API void ImmediateVertex( float x, float y, float z ); + GFX_API void ImmediateNormal( float x, float y, float z ); + GFX_API void ImmediateColor( float r, float g, float b, float a ); + GFX_API void ImmediateTexCoordAll( float x, float y, float z ); + GFX_API void ImmediateTexCoord( int unit, float x, float y, float z ); + GFX_API void ImmediateBegin( GfxPrimitiveType type ); + GFX_API void ImmediateEnd(); + + GFX_API bool CaptureScreenshot( int left, int bottom, int width, int height, UInt8* rgba32 ); + GFX_API bool ReadbackImage( ImageReference& image, int left, int bottom, int width, int height, int destX, int destY ); + GFX_API void GrabIntoRenderTexture( RenderSurfaceHandle rs, RenderSurfaceHandle rd, int x, int y, int width, int height ); + + GFX_API void BeforeDrawCall( bool immediateMode ); + + GFX_API bool IsPositionRequiredForTexGen (int texStageIndex) const { return false; } + GFX_API bool IsNormalRequiredForTexGen (int texStageIndex) const { return false; } + GFX_API bool IsPositionRequiredForTexGen() const { return false; } + GFX_API bool IsNormalRequiredForTexGen() const { return false; } + + #if ENABLE_PROFILER + GFX_API void BeginProfileEvent (const char* name); + GFX_API void EndProfileEvent (); + + GFX_API GfxTimerQuery* CreateTimerQuery(); + GFX_API void DeleteTimerQuery(GfxTimerQuery* query); + GFX_API void BeginTimerQueries(); + GFX_API void EndTimerQueries(); + #endif // ENABLE_PROFILER + + #if UNITY_EDITOR + GFX_API void SetAntiAliasFlag (bool aa); + GFX_API void DrawUserPrimitives (GfxPrimitiveType type, int vertexCount, UInt32 vertexChannels, const void* data, int stride); + GFX_API int GetCurrentTargetAA() const; + GFX_API GfxDeviceWindow* CreateGfxWindow (HWND window, int width, int height, DepthBufferFormat depthFormat, int antiAlias); + #endif + + GFX_API int GetCurrentTargetWidth() const; + GFX_API int GetCurrentTargetHeight() const; + GFX_API void SetCurrentTargetSize(int width, int height); + GFX_API void SetCurrentWindowSize(int width, int height); + + GFX_API void* GetNativeGfxDevice(); + GFX_API void* GetNativeTexturePointer(TextureID id); + GFX_API intptr_t CreateExternalTextureFromNative(intptr_t nativeTex); + GFX_API void UpdateExternalTextureFromNative(TextureID tex, intptr_t nativeTex); + + GFX_API void SetComputeBufferData (ComputeBufferID bufferHandle, const void* data, size_t size); + GFX_API void GetComputeBufferData (ComputeBufferID bufferHandle, void* dest, size_t destSize); + GFX_API void CopyComputeBufferCount (ComputeBufferID srcBuffer, ComputeBufferID dstBuffer, UInt32 dstOffset); + + GFX_API void SetRandomWriteTargetTexture (int index, TextureID tid); + GFX_API void SetRandomWriteTargetBuffer (int index, ComputeBufferID bufferHandle); + GFX_API void ClearRandomWriteTargets (); + + GFX_API ComputeProgramHandle CreateComputeProgram (const UInt8* code, size_t codeSize); + GFX_API void DestroyComputeProgram (ComputeProgramHandle& cpHandle); + GFX_API void CreateComputeConstantBuffers (unsigned count, const UInt32* sizes, ConstantBufferHandle* outCBs); + GFX_API void DestroyComputeConstantBuffers (unsigned count, ConstantBufferHandle* cbs); + GFX_API void CreateComputeBuffer (ComputeBufferID id, size_t count, size_t stride, UInt32 flags); + GFX_API void DestroyComputeBuffer (ComputeBufferID handle); + GFX_API void UpdateComputeConstantBuffers (unsigned count, ConstantBufferHandle* cbs, UInt32 cbDirty, size_t dataSize, const UInt8* data, const UInt32* cbSizes, const UInt32* cbOffsets, const int* bindPoints); + GFX_API void UpdateComputeResources ( + unsigned texCount, const TextureID* textures, const int* texBindPoints, + unsigned samplerCount, const unsigned* samplers, + unsigned inBufferCount, const ComputeBufferID* inBuffers, const int* inBufferBindPoints, + unsigned outBufferCount, const ComputeBufferID* outBuffers, const TextureID* outTextures, const UInt32* outBufferBindPoints); + GFX_API void DispatchComputeProgram (ComputeProgramHandle cpHandle, unsigned threadsX, unsigned threadsY, unsigned threadsZ); + + GFX_API void DrawNullGeometry (GfxPrimitiveType topology, int vertexCount, int instanceCount); + GFX_API void DrawNullGeometryIndirect (GfxPrimitiveType topology, ComputeBufferID bufferHandle, UInt32 bufferOffset); + + ID3D11Buffer* GetAllWhiteVertexStream(); + VertexDeclarationsD3D11& GetVertexDecls() { return m_VertexDecls; } + ConstantBuffersD3D11& GetConstantBuffers() { return m_CBs; } + TexturesD3D11& GetTextures() { return m_Textures; } + void SetComputeBuffer11 (ShaderType shaderType, int unit, ComputeBufferID bufferHandle); + +private: + void SetupDeferredDepthStencilState(); + void SetupDeferredRasterState(); + void SetupDeferredSRGBWrite(); + + void DrawQuad (float u0, float v0, float u1, float v1, float z, ID3D11ShaderResourceView* texture); + bool ImmediateEndSetup(); + void ImmediateEndDraw(); + +public: + ImmediateModeD3D11 m_Imm; + TransformState m_TransformState; + + ConstantBuffersD3D11 m_CBs; + VertexDeclarationsD3D11 m_VertexDecls; + TexturesD3D11 m_Textures; + DynamicD3D11VBO* m_DynamicVBO; + + FFProgramCacheD3D11 m_FFPrograms; + FixedFunctionStateD3D11 m_FFState; + + CachedBlendStates m_CachedBlendStates; + CachedDepthStates m_CachedDepthStates; + CachedStencilStates m_CachedStencilStates; + CachedRasterStates m_CachedRasterStates; + CachedFinalRasterStates m_CachedFinalRasterStates; + CachedDepthStencilStates m_CachedDepthStencilStates; + + TextureUnitState11 m_TextureUnits[kMaxSupportedTextureUnits]; + TextureID m_ActiveTextures[kShaderTypeCount][kMaxSupportedTextureUnits]; + TextureID m_ActiveSamplers[kShaderTypeCount][kMaxSupportedTextureUnits]; + + GpuProgram* m_ActiveGpuProgram[kShaderTypeCount]; + const GpuProgramParameters* m_ActiveGpuProgramParams[kShaderTypeCount]; + + void* m_ActiveShaders[kShaderTypeCount]; + + const DeviceBlendState* m_CurrBlendState; + const DeviceRasterState* m_CurrRasterState; + const DeviceDepthState* m_CurrDepthState; + const DeviceStencilState* m_CurrStencilState; + ID3D11RasterizerState* m_CurrRSState; + ID3D11DepthStencilState* m_CurrDSState; + int m_StencilRef; + int m_CurrStencilRef; + + bool m_InvertProjMatrix; + bool m_AppBackfaceMode; + bool m_UserBackfaceMode; + bool m_Wireframe; + bool m_Scissor; + bool m_SRGBWrite; + bool m_ActualSRGBWrite; + + int m_Viewport[4]; + int m_ScissorRect[4]; + int m_CurrTargetWidth; + int m_CurrTargetHeight; + int m_CurrWindowWidth; + int m_CurrWindowHeight; + + ResolveTexturePool m_Resolves; +}; + +GfxDeviceD3D11& GetD3D11GfxDevice(); diff --git a/Runtime/GfxDevice/d3d11/GpuProgramsD3D11.cpp b/Runtime/GfxDevice/d3d11/GpuProgramsD3D11.cpp new file mode 100644 index 0000000..0cb9143 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/GpuProgramsD3D11.cpp @@ -0,0 +1,703 @@ +#include "UnityPrefix.h" +#include "GpuProgramsD3D11.h" +#include "ConstantBuffersD3D11.h" +#include "D3D11Context.h" +#include "D3D11Utils.h" +#include "GfxDeviceD3D11.h" +#include "ShaderGeneratorD3D11.h" +#include "Runtime/Math/Vector4.h" +#include "Runtime/GfxDevice/GfxDevice.h" +#include "Runtime/Shaders/ComputeShader.h" +#include "ShaderGeneratorD3D11.h" +#include "ShaderPatchingD3D11.h" +#include "FixedFunctionStateD3D11.h" +#include "External/shaderlab/Library/properties.h" + + + +ConstantBuffersD3D11& GetD3D11ConstantBuffers (GfxDevice& device); +const InputSignatureD3D11* GetD3D11InputSignature (void* code, unsigned length); + +const InputSignatureD3D11* g_CurrentVSInputD3D11; + + +static GpuProgramLevel DecodeShader (const std::string& source, dynamic_array<UInt8>& output) +{ + GpuProgramLevel level = kGpuProgramNone; + + // decode shader + int startSkip = 0; + if (gGraphicsCaps.d3d11.featureLevel < kDX11Level10_0) + { + if (strncmp(source.c_str()+1, "s_4_0_level_9_", strlen("s_4_0_level_9_")) == 0) + { + startSkip = strlen("vs_4_0_level_9_x") + 1; + level = kGpuProgramSM3; + } + Assert ("Unsupported shader found!"); + } + else if (strncmp(source.c_str()+1, "s_dx11", 6) == 0) + { + startSkip = 7; + level = kGpuProgramSM4; + } + else if (strncmp(source.c_str()+1, "s_4_0", 5) == 0) + { + startSkip = 6; + level = kGpuProgramSM4; + } + else if (strncmp(source.c_str()+1, "s_5_0", 5) == 0) + { + startSkip = 6; + level = kGpuProgramSM5; + } + else + { + Assert ("Unknown shader prefix"); + } + int sourceSize = source.size() - startSkip; + const char* sourcePtr = source.c_str() + startSkip; + + output.reserve (sourceSize / 2); + int i = 0; + while (i < sourceSize) + { + char c1 = sourcePtr[i]; + if (c1 >= 'a') + { + AssertIf (i+1 == sourceSize); + char c2 = sourcePtr[i+1]; + output.push_back ((c1-'a') * 16 + (c2-'a')); + i += 2; + } + else + { + ++i; + } + } + + // debug check: does our shader hashing code match D3Ds? + #if !UNITY_RELEASE + if (output.size() > 20) + { + void D3DHash (const unsigned char* data, unsigned size, unsigned char res[16]); + UInt8 hsh[16]; + D3DHash (&output[20], output.size()-20, hsh); + DebugAssert (0 == memcmp(hsh,&output[4],16)); + } + #endif + + // patch shader code to do driver workarounds + if (level < kGpuProgramSM4 && gGraphicsCaps.d3d11.buggyPartialPrecision10Level9) + { + PatchRemovePartialPrecisionD3D11 (output); + } + + // patch shader code to do driver workarounds + if (level < kGpuProgramSM4 && gGraphicsCaps.d3d11.buggyPartialPrecision10Level9) + { + PatchRemovePartialPrecisionD3D11 (output); + } + + return level; +} + +static const UInt8* ApplyValueParameters11 (ConstantBuffersD3D11& cbs, const UInt8* buffer, const GpuProgramParameters::ValueParameterArray& valueParams, int cbIndex) +{ + GpuProgramParameters::ValueParameterArray::const_iterator valueParamsEnd = valueParams.end(); + for (GpuProgramParameters::ValueParameterArray::const_iterator i = valueParams.begin(); i != valueParamsEnd; ++i) + { + if (i->m_RowCount == 1) + { + // Vector + const Vector4f* val = reinterpret_cast<const Vector4f*>(buffer); + if (i->m_Type != kShaderParamInt) + { + cbs.SetCBConstant (cbIndex, i->m_Index, val->GetPtr(), i->m_ColCount*4); + } + else + { + int vali[4] = {val->x, val->y, val->z, val->w}; + cbs.SetCBConstant (cbIndex, i->m_Index, vali, i->m_ColCount*4); + } + buffer += sizeof(Vector4f); + } + else + { + // matrix/array + int size = *reinterpret_cast<const int*>(buffer); buffer += sizeof(int); + Assert (i->m_RowCount == 4 && size == 16); + const Matrix4x4f* val = reinterpret_cast<const Matrix4x4f*>(buffer); + cbs.SetCBConstant (cbIndex, i->m_Index, val->GetPtr(), 64); + buffer += size * sizeof(float); + } + } + return buffer; +} + +static const UInt8* ApplyBufferParameters11 (GfxDevice& device, ShaderType shaderType, const UInt8* buffer, const GpuProgramParameters::BufferParameterArray& bufferParams) +{ + GfxDeviceD3D11& device11 = static_cast<GfxDeviceD3D11&>(device); + + GpuProgramParameters::BufferParameterArray::const_iterator bufferParamsEnd = bufferParams.end(); + for (GpuProgramParameters::BufferParameterArray::const_iterator i = bufferParams.begin(); i != bufferParamsEnd; ++i) + { + ComputeBufferID buf = *reinterpret_cast<const ComputeBufferID*>(buffer); + device11.SetComputeBuffer11 (shaderType, i->m_Index, buf); + buffer += sizeof(ComputeBufferID); + } + return buffer; +} + + +// -------------------------------------------------------------------------- + + +D3D11CommonShader::~D3D11CommonShader () +{ + for (int i = 0; i < kFogModeCount; ++i) + { + SAFE_RELEASE(m_Shaders[i]); + } +} + +IUnknown* D3D11CommonShader::GetShader(FogMode fog, bool haveDomainShader, bool& outResetToNoFog) +{ + outResetToNoFog = false; + // no fog? + if (fog <= kFogDisabled) + return m_Shaders[0]; + + // already have shader for this fog mode? + Assert (fog >= 0 && fog < kFogModeCount); + if (m_Shaders[fog]) + return m_Shaders[fog]; + + // can't do fog for this mode? + unsigned fogBit = (1<<fog); + if (m_FogFailed & fogBit) + { + outResetToNoFog = true; + return m_Shaders[0]; + } + + // have domain shader and we're vertex - nothing to do; fog delegated to domain one + if (haveDomainShader && m_ImplType == kShaderImplVertex) + return m_Shaders[0]; + + // patch shader to handle fog + bool ok = PatchShaderForFog (fog); + if (!ok) + { + m_FogFailed |= fogBit; + return m_Shaders[0]; + } + + Assert(m_Shaders[fog]); + return m_Shaders[fog]; +} + +bool D3D11CommonShader::PatchShaderForFog (FogMode fog) +{ + Assert (fog > kFogDisabled && fog < kFogModeCount); + Assert (!m_Shaders[fog]); + IUnknown* s = m_Shaders[0]; + m_Shaders[fog] = s; + if (s) + s->AddRef(); + return true; +} + + +const UInt8* D3D11CommonShader::ApplyTextures (GfxDevice& device, ShaderType shaderType, const GpuProgramParameters& params, const UInt8* buffer) +{ + const GpuProgramParameters::TextureParameterList& textureParams = params.GetTextureParams(); + const GpuProgramParameters::TextureParameterList::const_iterator textureParamsEnd = textureParams.end(); + for (GpuProgramParameters::TextureParameterList::const_iterator i = textureParams.begin(); i != textureParamsEnd; ++i) + { + const GpuProgramParameters::TextureParameter& t = *i; + const TexEnvData* texdata = reinterpret_cast<const TexEnvData*>(buffer); + device.SetTexture (shaderType, t.m_Index, t.m_SamplerIndex, texdata->textureID, static_cast<TextureDimension>(texdata->texDim), 0); + buffer += sizeof(*texdata); + } + return buffer; +} + + +// -------------------------------------------------------------------------- + +D3D11VertexShader::D3D11VertexShader (const std::string& compiledSource) +: m_InputSignature(NULL) +{ + m_ImplType = kShaderImplVertex; + if (!Create(compiledSource)) + m_NotSupported = true; +} + +D3D11VertexShader::~D3D11VertexShader () +{ +} + + +bool D3D11VertexShader::Create (const std::string& compiledSource) +{ + m_GpuProgramLevel = DecodeShader (compiledSource, m_ByteCode); + + m_InputSignature = GetD3D11InputSignature (&m_ByteCode[0], m_ByteCode.size()); + + HRESULT hr = GetD3D11Device()->CreateVertexShader (&m_ByteCode[0], m_ByteCode.size(), NULL, (ID3D11VertexShader**)&m_Shaders[0]); + if( FAILED(hr) ) + { + printf_console ("D3D shader create error for shader %s\n", compiledSource.c_str()); + return false; + } + + std::string debugName = Format("VS-%d", compiledSource.size()); + hr = ((ID3D11DeviceChild*)m_Shaders[0])->SetPrivateData (WKPDID_D3DDebugObjectName, debugName.size(), debugName.c_str()); + + return true; +} + +bool D3D11VertexShader::PatchShaderForFog (FogMode fog) +{ + // no fog patching for 9.x level yet + if (m_GpuProgramLevel < kGpuProgramSM4) + return false; + + dynamic_array<UInt8> bc = m_ByteCode; + bool ok = PatchVertexOrDomainShaderFogD3D11 (bc); + if (!ok) + { + printf_console("DX11: failed to patch vertex shader for fog mode %d\n", fog); + return false; + } + + Assert (!m_Shaders[fog]); + HRESULT hr = GetD3D11Device()->CreateVertexShader (&bc[0], bc.size(), NULL, (ID3D11VertexShader**)&m_Shaders[fog]); + if (FAILED(hr)) + { + printf_console ("D3D11 shader create error for VS with fog mode %i\n", fog); + return false; + } + + SetDebugNameD3D11 ((ID3D11DeviceChild*)m_Shaders[fog], Format("VS-%d-fog-%d", (int)bc.size(), fog)); + return true; +} + + +void D3D11VertexShader::ApplyGpuProgram (const GpuProgramParameters& params, const UInt8* buffer) +{ + g_CurrentVSInputD3D11 = m_InputSignature; + + GfxDevice& device = GetRealGfxDevice(); + ConstantBuffersD3D11& cbs = GetD3D11ConstantBuffers(device); + cbs.ResetBinds (kShaderVertex); + + for (GpuProgramParameters::ConstantBufferList::const_iterator cbi = params.GetConstantBuffers().begin(); cbi != params.GetConstantBuffers().end(); ++cbi) + { + const int cbIndex = cbs.FindAndBindCB (cbi->m_Name.index, kShaderVertex, cbi->m_BindIndex, cbi->m_Size); + buffer = ApplyValueParameters11 (cbs, buffer, cbi->m_ValueParams, cbIndex); + } + buffer = ApplyTextures (device, kShaderVertex, params, buffer); + buffer = ApplyBufferParameters11 (device, kShaderVertex, buffer, params.GetBufferParams()); +} + + +// -------------------------------------------------------------------------- + + +D3D11PixelShader::D3D11PixelShader (const std::string& compiledSource) +{ + m_ImplType = kShaderImplFragment; + if (!Create(compiledSource)) + m_NotSupported = true; +} + + +bool D3D11PixelShader::Create (const std::string& compiledSource) +{ + m_GpuProgramLevel = DecodeShader (compiledSource, m_ByteCode); + + HRESULT hr = GetD3D11Device()->CreatePixelShader (&m_ByteCode[0], m_ByteCode.size(), NULL, (ID3D11PixelShader**)&m_Shaders[0]); + if( FAILED(hr) ) + { + printf_console ("D3D shader create error for shader %s\n", compiledSource.c_str()); + return false; + } + + std::string debugName = Format("PS-%d", compiledSource.size()); + hr = ((ID3D11DeviceChild*)m_Shaders[0])->SetPrivateData (WKPDID_D3DDebugObjectName, debugName.size(), debugName.c_str()); + + return true; +} + + +bool D3D11PixelShader::PatchShaderForFog (FogMode fog) +{ + // no fog patching for 9.x level yet + if (m_GpuProgramLevel < kGpuProgramSM4) + return false; + + dynamic_array<UInt8> bc = m_ByteCode; + bool ok = PatchPixelShaderFogD3D11 (bc, fog); + if (!ok) + { + printf_console("DX11: failed to patch pixel shader for fog mode %d\n", fog); + return false; + } + + Assert (!m_Shaders[fog]); + HRESULT hr = GetD3D11Device()->CreatePixelShader (&bc[0], bc.size(), NULL, (ID3D11PixelShader**)&m_Shaders[fog]); + if (FAILED(hr)) + { + printf_console ("D3D11 shader create error for PS with fog mode %i\n", fog); + return false; + } + + SetDebugNameD3D11 ((ID3D11DeviceChild*)m_Shaders[fog], Format("PS-%d-fog-%d", (int)bc.size(), fog)); + + return true; +} + + +void D3D11PixelShader::ApplyGpuProgram (const GpuProgramParameters& params, const UInt8* buffer) +{ + GfxDevice& device = GetRealGfxDevice(); + ConstantBuffersD3D11& cbs = GetD3D11ConstantBuffers(device); + cbs.ResetBinds (kShaderFragment); + + for (GpuProgramParameters::ConstantBufferList::const_iterator cbi = params.GetConstantBuffers().begin(); cbi != params.GetConstantBuffers().end(); ++cbi) + { + const int cbIndex = cbs.FindAndBindCB (cbi->m_Name.index, kShaderFragment, cbi->m_BindIndex, cbi->m_Size); + buffer = ApplyValueParameters11 (cbs, buffer, cbi->m_ValueParams, cbIndex); + } + + // Apply textures + const GpuProgramParameters::TextureParameterList& textureParams = params.GetTextureParams(); + GpuProgramParameters::TextureParameterList::const_iterator textureParamsEnd = textureParams.end(); + for( GpuProgramParameters::TextureParameterList::const_iterator i = textureParams.begin(); i != textureParamsEnd; ++i ) + { + const GpuProgramParameters::TextureParameter& t = *i; + const TexEnvData* texdata = reinterpret_cast<const TexEnvData*>(buffer); + ApplyTexEnvData (t.m_Index, t.m_SamplerIndex, *texdata); + buffer += sizeof(*texdata); + } + + buffer = ApplyBufferParameters11 (device, kShaderFragment, buffer, params.GetBufferParams()); +} + + +// -------------------------------------------------------------------------- + +D3D11GeometryShader::D3D11GeometryShader (const std::string& compiledSource) +{ + m_ImplType = kShaderImplGeometry; + if (!Create(compiledSource)) + m_NotSupported = true; +} + + +bool D3D11GeometryShader::Create (const std::string& compiledSource) +{ + m_GpuProgramLevel = DecodeShader (compiledSource, m_ByteCode); + + HRESULT hr = GetD3D11Device()->CreateGeometryShader (&m_ByteCode[0], m_ByteCode.size(), NULL, (ID3D11GeometryShader**)&m_Shaders[0]); + if( FAILED(hr) ) + { + printf_console ("D3D shader create error for shader %s\n", compiledSource.c_str()); + return false; + } + + std::string debugName = Format("GS-%d", compiledSource.size()); + hr = ((ID3D11DeviceChild*)m_Shaders[0])->SetPrivateData (WKPDID_D3DDebugObjectName, debugName.size(), debugName.c_str()); + + return true; +} + +void D3D11GeometryShader::ApplyGpuProgram (const GpuProgramParameters& params, const UInt8* buffer) +{ + GfxDevice& device = GetRealGfxDevice(); + ConstantBuffersD3D11& cbs = GetD3D11ConstantBuffers(device); + cbs.ResetBinds (kShaderGeometry); + + for (GpuProgramParameters::ConstantBufferList::const_iterator cbi = params.GetConstantBuffers().begin(); cbi != params.GetConstantBuffers().end(); ++cbi) + { + const int cbIndex = cbs.FindAndBindCB (cbi->m_Name.index, kShaderGeometry, cbi->m_BindIndex, cbi->m_Size); + buffer = ApplyValueParameters11 (cbs, buffer, cbi->m_ValueParams, cbIndex); + } + buffer = ApplyTextures (device, kShaderGeometry, params, buffer); + buffer = ApplyBufferParameters11 (device, kShaderGeometry, buffer, params.GetBufferParams()); +} + + +// -------------------------------------------------------------------------- + +D3D11HullShader::D3D11HullShader (const std::string& compiledSource) +{ + m_ImplType = kShaderImplHull; + if (!Create(compiledSource)) + m_NotSupported = true; +} + + +bool D3D11HullShader::Create (const std::string& compiledSource) +{ + m_GpuProgramLevel = DecodeShader (compiledSource, m_ByteCode); + + HRESULT hr = GetD3D11Device()->CreateHullShader (&m_ByteCode[0], m_ByteCode.size(), NULL, (ID3D11HullShader**)&m_Shaders[0]); + if( FAILED(hr) ) + { + printf_console ("D3D shader create error for shader %s\n", compiledSource.c_str()); + return false; + } + + std::string debugName = Format("HS-%d", compiledSource.size()); + hr = ((ID3D11DeviceChild*)m_Shaders[0])->SetPrivateData (WKPDID_D3DDebugObjectName, debugName.size(), debugName.c_str()); + + return true; +} + +void D3D11HullShader::ApplyGpuProgram (const GpuProgramParameters& params, const UInt8* buffer) +{ + GfxDevice& device = GetRealGfxDevice(); + ConstantBuffersD3D11& cbs = GetD3D11ConstantBuffers(device); + cbs.ResetBinds (kShaderHull); + + for (GpuProgramParameters::ConstantBufferList::const_iterator cbi = params.GetConstantBuffers().begin(); cbi != params.GetConstantBuffers().end(); ++cbi) + { + const int cbIndex = cbs.FindAndBindCB (cbi->m_Name.index, kShaderHull, cbi->m_BindIndex, cbi->m_Size); + buffer = ApplyValueParameters11 (cbs, buffer, cbi->m_ValueParams, cbIndex); + } + buffer = ApplyTextures (device, kShaderHull, params, buffer); + buffer = ApplyBufferParameters11 (device, kShaderHull, buffer, params.GetBufferParams()); +} + + +// -------------------------------------------------------------------------- + +D3D11DomainShader::D3D11DomainShader (const std::string& compiledSource) +{ + m_ImplType = kShaderImplDomain; + if (!Create(compiledSource)) + m_NotSupported = true; +} + +bool D3D11DomainShader::Create (const std::string& compiledSource) +{ + m_GpuProgramLevel = DecodeShader (compiledSource, m_ByteCode); + + HRESULT hr = GetD3D11Device()->CreateDomainShader (&m_ByteCode[0], m_ByteCode.size(), NULL, (ID3D11DomainShader**)&m_Shaders[0]); + if( FAILED(hr) ) + { + printf_console ("D3D shader create error for shader %s\n", compiledSource.c_str()); + return false; + } + + std::string debugName = Format("DS-%d", compiledSource.size()); + hr = ((ID3D11DeviceChild*)m_Shaders[0])->SetPrivateData (WKPDID_D3DDebugObjectName, debugName.size(), debugName.c_str()); + + return true; +} + +bool D3D11DomainShader::PatchShaderForFog (FogMode fog) +{ + // no fog patching for 9.x level yet + if (m_GpuProgramLevel < kGpuProgramSM4) + return false; + + dynamic_array<UInt8> bc = m_ByteCode; + bool ok = PatchVertexOrDomainShaderFogD3D11 (bc); + if (!ok) + { + printf_console("DX11: failed to patch domain shader for fog mode %d\n", fog); + return false; + } + + Assert (!m_Shaders[fog]); + HRESULT hr = GetD3D11Device()->CreateDomainShader (&bc[0], bc.size(), NULL, (ID3D11DomainShader**)&m_Shaders[fog]); + if (FAILED(hr)) + { + printf_console ("D3D11 shader create error for DS with fog mode %i\n", fog); + return false; + } + + SetDebugNameD3D11 ((ID3D11DeviceChild*)m_Shaders[fog], Format("DS-%d-fog-%d", (int)bc.size(), fog)); + return true; +} + + +void D3D11DomainShader::ApplyGpuProgram (const GpuProgramParameters& params, const UInt8* buffer) +{ + GfxDevice& device = GetRealGfxDevice(); + ConstantBuffersD3D11& cbs = GetD3D11ConstantBuffers(device); + cbs.ResetBinds (kShaderDomain); + + for (GpuProgramParameters::ConstantBufferList::const_iterator cbi = params.GetConstantBuffers().begin(); cbi != params.GetConstantBuffers().end(); ++cbi) + { + const int cbIndex = cbs.FindAndBindCB (cbi->m_Name.index, kShaderDomain, cbi->m_BindIndex, cbi->m_Size); + buffer = ApplyValueParameters11 (cbs, buffer, cbi->m_ValueParams, cbIndex); + } + buffer = ApplyTextures (device, kShaderDomain, params, buffer); + buffer = ApplyBufferParameters11 (device, kShaderDomain, buffer, params.GetBufferParams()); +} + + +// -------------------------------------------------------------------------- + + +void FixedFunctionProgramD3D11::ValueParameters::ApplyValues (const BuiltinShaderParamValues& values, ConstantBuffersD3D11& cbs, ShaderType shaderType) const +{ + int cbBindIndex = cbs.FindAndBindCB (m_CBID, shaderType, 0, m_CBSize); + + ValueParameterArray::const_iterator valueParamsEnd = m_Params.end(); + for (ValueParameterArray::const_iterator i = m_Params.begin(); i != valueParamsEnd; ++i) + { + const Vector4f& val = values.GetVectorParam((BuiltinShaderVectorParam)i->m_Name); + cbs.SetCBConstant (cbBindIndex, i->m_Index, &val, i->m_Bytes); + } +} + + +// -------------------------------------------------------------------------- + + +static std::string GetFixedFunctionStateDesc (const FixedFunctionStateD3D11& state) +{ + std::string res; + if (state.lightingEnabled) + { + res += Format(" lighting with %i lights\n", state.lightCount); + } + res += Format(" combiners: %i\n", state.texUnitCount); + for (int i = 0; i < state.texUnitCount; ++i) + { + res += Format (" #%i: %08x %08x uv=%i %s %s\n", + i, state.texUnitColorCombiner[i], state.texUnitAlphaCombiner[i], + unsigned((state.texUnitSources>>(i*4))&0xF), + (state.texUnitCube&(1<<i))?"cube":"2d", + (state.texUnitProjected&(1<<i))?"projected":""); + } + res += state.useUniformInsteadOfVertexColor ? " color from uniform" : " color from VBO\n"; + if (state.alphaTest != kFuncDisabled && state.alphaTest != kFuncAlways) + res += Format(" alpha test: %d\n", state.alphaTest); + return res; +} + +#if UNITY_METRO_VS2013 || (UNITY_WIN && !UNITY_WINRT) +extern bool HasD3D11Linker(); +extern void* BuildVertexShaderD3D11_Link(const FixedFunctionStateD3D11& state, FixedFunctionProgramD3D11::ValueParameters& params, BuiltinShaderParamIndices& matrices, size_t& outSize); +extern void* BuildFragmentShaderD3D11_Link(const FixedFunctionStateD3D11& state, FixedFunctionProgramD3D11::ValueParameters& params, size_t& outSize); +#endif + +FixedFunctionProgramD3D11::FixedFunctionProgramD3D11 (const FixedFunctionStateD3D11& state) +: m_VS(NULL) +, m_PS(NULL) +, m_InputSig(NULL) +{ + size_t sizeVS, sizePS; + + void* codeVS = NULL; + void* codePS = NULL; + + // Generate using DX11 shader linker if available + #if UNITY_METRO_VS2013 || (UNITY_WIN && !UNITY_WINRT) + if (HasD3D11Linker()) + { + codeVS = BuildVertexShaderD3D11_Link(state, m_VPParams, m_VPMatrices, sizeVS); + if (codeVS) + codePS = BuildFragmentShaderD3D11_Link(state, m_FPParams, sizePS); + } + #endif + + // If linker failed or not available, generate raw hlsl bytecode + if (!codeVS || !codePS) + { + if (codeVS) + free(codeVS); + if (codePS) + free(codePS); + codeVS = BuildVertexShaderD3D11(state, m_VPParams, m_VPMatrices, sizeVS); + codePS = BuildFragmentShaderD3D11(state, m_FPParams, sizePS); + } + + // Both generators failed, give up + if (!codeVS || !codePS) + { + ErrorString ("Failed to create fixed function shader pair"); + if (codeVS) + free(codeVS); + if (codePS) + free(codePS); + return; + } + + /* + // debug check: does our shader hashing code match D3Ds? + #if !UNITY_RELEASE + if (sizeVS > 20 && sizePS > 20) + { + void D3DHash (const unsigned char* data, unsigned size, unsigned char res[16]); + UInt8 hsh[16]; + D3DHash (&codeVS[20], sizeVS-20, hsh); + DebugAssert (0 == memcmp(hsh,&codeVS[4],16)); + D3DHash (&codePS[20], sizePS-20, hsh); + DebugAssert (0 == memcmp(hsh,&codePS[4],16)); + } + // dump vertex shader code + DXBCContainer* dxbc = dxbc_parse (codeVS, sizeVS); + dxbc_print (dxbc); + delete dxbc; + #endif + */ + +#if _DEBUG && !UNITY_METRO && 0 + static int s_Num = 0; + char sz[1024]; + + sprintf(sz,"dump%04d.vs",s_Num); + FILE* f = fopen(sz,"wb"); + fwrite(codeVS,sizeVS,1,f); + fclose(f); + sprintf(sz,"dump%04d.ps",s_Num); + f = fopen(sz,"wb"); + fwrite(codePS,sizePS,1,f); + fclose(f); + s_Num++; +#endif + + + ID3D11Device* dev = GetD3D11Device(); + HRESULT hr; + hr = dev->CreateVertexShader (codeVS, sizeVS, NULL, &m_VS); + Assert (SUCCEEDED(hr)); + hr = dev->CreatePixelShader (codePS, sizePS, NULL, &m_PS); + Assert (SUCCEEDED(hr)); + + std::string debugName = Format("FixedFunctionVS-%d", sizeVS); + hr = m_VS->SetPrivateData (WKPDID_D3DDebugObjectName, debugName.size(), debugName.c_str()); + debugName = Format("FixedFunctionPS-%d", sizePS); + hr = m_PS->SetPrivateData (WKPDID_D3DDebugObjectName, debugName.size(), debugName.c_str()); + + m_InputSig = GetD3D11InputSignature (codeVS, sizeVS); + + free(codeVS); + free(codePS); +} + +FixedFunctionProgramD3D11::~FixedFunctionProgramD3D11 () +{ + SAFE_RELEASE(m_VS); + SAFE_RELEASE(m_PS); +} + + +void FixedFunctionProgramD3D11::ApplyFFGpuProgram (const BuiltinShaderParamValues& values, ConstantBuffersD3D11& cbs) const +{ + g_CurrentVSInputD3D11 = m_InputSig; + + cbs.ResetBinds (kShaderVertex); + cbs.ResetBinds (kShaderFragment); + + m_VPParams.ApplyValues (values, cbs, kShaderVertex); + m_FPParams.ApplyValues (values, cbs, kShaderFragment); +} diff --git a/Runtime/GfxDevice/d3d11/GpuProgramsD3D11.h b/Runtime/GfxDevice/d3d11/GpuProgramsD3D11.h new file mode 100644 index 0000000..305144b --- /dev/null +++ b/Runtime/GfxDevice/d3d11/GpuProgramsD3D11.h @@ -0,0 +1,125 @@ +#pragma once + +#include "Runtime/GfxDevice/GpuProgram.h" +#include "Runtime/Utilities/dynamic_array.h" +#include "D3D11Includes.h" + +class GfxDevice; + +class ConstantBuffersD3D11; +struct FixedFunctionStateD3D11; +struct InputSignatureD3D11; + +class D3D11CommonShader : public GpuProgram { +public: + virtual ~D3D11CommonShader(); + IUnknown* GetShader(FogMode fog, bool haveDomainShader, bool& outResetToNoFog); + +protected: + D3D11CommonShader () + : m_FogFailed(0) + { + for (int i = 0; i < kFogModeCount; ++i) + m_Shaders[i] = NULL; + } + + const UInt8* ApplyTextures (GfxDevice& device, ShaderType shaderType, const GpuProgramParameters& params, const UInt8* buffer); + + // default implementation just uses non-fog shader + virtual bool PatchShaderForFog (FogMode fog); + +protected: + IUnknown* m_Shaders[kFogModeCount]; + dynamic_array<UInt8> m_ByteCode; // stored for fog patching + UInt32 m_FogFailed; +}; + +class D3D11VertexShader : public D3D11CommonShader { +public: + D3D11VertexShader (const std::string& compiledSource); + virtual ~D3D11VertexShader(); + virtual void ApplyGpuProgram (const GpuProgramParameters& params, const UInt8* buffer); + +protected: + virtual bool PatchShaderForFog (FogMode fog); +private: + bool Create (const std::string& compiledSource); + const InputSignatureD3D11* m_InputSignature; +}; + +class D3D11PixelShader : public D3D11CommonShader { +public: + D3D11PixelShader (const std::string& compiledSource); + virtual void ApplyGpuProgram (const GpuProgramParameters& params, const UInt8* buffer); +protected: + virtual bool PatchShaderForFog (FogMode fog); +private: + bool Create (const std::string& compiledSource); +}; + +class D3D11GeometryShader : public D3D11CommonShader { +public: + D3D11GeometryShader (const std::string& compiledSource); + virtual void ApplyGpuProgram (const GpuProgramParameters& params, const UInt8* buffer); +private: + bool Create (const std::string& compiledSource); +}; + +class D3D11HullShader : public D3D11CommonShader { +public: + D3D11HullShader (const std::string& compiledSource); + virtual void ApplyGpuProgram (const GpuProgramParameters& params, const UInt8* buffer); +private: + bool Create (const std::string& compiledSource); +}; + +class D3D11DomainShader : public D3D11CommonShader { +public: + D3D11DomainShader (const std::string& compiledSource); + virtual void ApplyGpuProgram (const GpuProgramParameters& params, const UInt8* buffer); +protected: + virtual bool PatchShaderForFog (FogMode fog); +private: + bool Create (const std::string& compiledSource); +}; + + +class FixedFunctionProgramD3D11 +{ +public: + struct ValueParameter { + int m_Name; + int m_Index; + int m_Bytes; + ValueParameter (int n, int idx, int bytes) : m_Name(n), m_Index(idx), m_Bytes(bytes) {} + }; + typedef dynamic_array<ValueParameter> ValueParameterArray; + struct ValueParameters { + ValueParameters() : m_CBID(0), m_CBSize(0) { } + void AddVectorParam (int index, int dim, BuiltinShaderVectorParam name) { m_Params.push_back (ValueParameter (name, index, dim*4)); } + bool HasVectorParams() const { return !m_Params.empty(); } + void ApplyValues (const BuiltinShaderParamValues& values, ConstantBuffersD3D11& cbs, ShaderType shaderType) const; + ValueParameterArray m_Params; + int m_CBID; + int m_CBSize; + }; + +public: + FixedFunctionProgramD3D11 (const FixedFunctionStateD3D11& state); + ~FixedFunctionProgramD3D11 (); + + void ApplyFFGpuProgram (const BuiltinShaderParamValues& values, ConstantBuffersD3D11& cbs) const; + + const BuiltinShaderParamIndices& GetVPMatrices() const { return m_VPMatrices; } + + ID3D11VertexShader* GetVertexShader() { return m_VS; } + ID3D11PixelShader* GetPixelShader() { return m_PS; } + +private: + ValueParameters m_VPParams; + ValueParameters m_FPParams; + BuiltinShaderParamIndices m_VPMatrices; + ID3D11VertexShader* m_VS; + ID3D11PixelShader* m_PS; + const InputSignatureD3D11* m_InputSig; +}; diff --git a/Runtime/GfxDevice/d3d11/GraphicsCapsD3D11.cpp b/Runtime/GfxDevice/d3d11/GraphicsCapsD3D11.cpp new file mode 100644 index 0000000..6ad8356 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/GraphicsCapsD3D11.cpp @@ -0,0 +1,363 @@ +#include "UnityPrefix.h" +#include "Runtime/Shaders/GraphicsCaps.h" +#include "Runtime/Utilities/ArrayUtility.h" +#include "D3D11Context.h" + + +extern DXGI_FORMAT kD3D11RenderTextureFormats[kRTFormatCount]; + + + +enum { + kVendorDummyRef = 0x0000, + kVendor3DLabs = 0x3d3d, + kVendorMatrox = 0x102b, + kVendorS3 = 0x5333, + kVendorSIS = 0x1039, + kVendorXGI = 0x18ca, + kVendorIntel = 0x8086, + kVendorATI = 0x1002, + kVendorNVIDIA = 0x10de, + kVendorTrident = 0x1023, + kVendorImgTech = 0x104a, + kVendorVIAS3G = 0x1106, + kVendor3dfx = 0x121a, + kVendorParallels= 0x1ab8, + kVendorMicrosoft= 0x1414, + kVendorVMWare = 0x15ad, + kVendorQualcomm = 0x4d4f4351, +}; + +enum { + kRendererIntel3150 = 0xa011, //Intel(R) Graphics Media Accelerator 3150 (Microsoft Corporation - WDDM 1.0) +}; +struct KnownVendors { + DWORD vendorId; + const char* name; +}; +static KnownVendors s_KnownVendors[] = { + { kVendorDummyRef, "REFERENCE" }, + { kVendor3DLabs, "3dLabs" }, + { kVendorMatrox, "Matrox" }, + { kVendorS3, "S3" }, + { kVendorSIS, "SIS" }, + { kVendorXGI, "XGI" }, + { kVendorIntel, "Intel" }, + { kVendorATI, "ATI" }, + { kVendorNVIDIA, "NVIDIA" }, + { kVendorTrident, "Trident" }, + { kVendorImgTech, "Imagination Technologies" }, + { kVendorVIAS3G, "VIA/S3" }, + { kVendor3dfx, "3dfx" }, + { kVendorParallels, "Parallels" }, + { kVendorMicrosoft, "Microsoft" }, + { kVendorVMWare, "VMWare" }, + { kVendorQualcomm, "Qualcomm" }, +}; +static int kKnownVendorsSize = sizeof(s_KnownVendors)/sizeof(s_KnownVendors[0]); + +DX11FeatureLevel kD3D11RenderTextureFeatureLevels[kRTFormatCount] = { + kDX11Level9_1, // ARGB32: 9.1 + kDX11Level10_0, // Depth: 10.0 + kDX11Level9_3, // ARGBHalf: 9.3 + kDX11Level10_0, // Shadowmap: 10.0 + kDX11LevelCount, // RGB565, unsupported + kDX11LevelCount, // ARGB4444, unsupported + kDX11LevelCount, // ARGB1555, unsupported + kDX11LevelCount, // Default + kDX11Level10_0, // A2RGB10: 10.0 + kDX11LevelCount, // DefaultHDR + kDX11Level10_1, // ARGB64: 10.1 + kDX11Level10_0, // ARGBFloat: 10.0 + kDX11Level10_0, // RGFloat: 10.0 + kDX11Level10_0, // RGHalf: 10.0 + kDX11Level10_0, // RFloat: 10.0 + kDX11Level10_0, // RHalf: 10.0 + kDX11Level10_0, // R8: 10.0 + kDX11Level10_0, // ARGBInt: 10.0 + kDX11Level10_0, // RGInt: 10.0 + kDX11Level10_0, // RInt: 10.0 +}; + + + +void GraphicsCaps::InitD3D11() +{ + ID3D11Device* d3d = GetD3D11Device(); + HRESULT hr; + + // get device information +#if UNITY_WINRT + DXGI_ADAPTER_DESC2 adapterDesc; + + IDXGIDevice2* dxgiDevice2; + hr = d3d->QueryInterface(__uuidof(IDXGIDevice2), (void**)&dxgiDevice2); + IDXGIAdapter* dxgiAdapter; + IDXGIAdapter2* dxgiAdapter2; + dxgiDevice2->GetAdapter (&dxgiAdapter); + dxgiAdapter->QueryInterface(__uuidof(IDXGIAdapter2), (void**)&dxgiAdapter2); + dxgiAdapter2->GetDesc2 (&adapterDesc); + dxgiAdapter2->Release(); + dxgiAdapter->Release(); + dxgiDevice2->Release(); +#else + DXGI_ADAPTER_DESC adapterDesc; + + IDXGIDevice* dxgiDevice; + IDXGIAdapter* dxgiAdapter; + hr = d3d->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice); + dxgiDevice->GetAdapter (&dxgiAdapter); + dxgiAdapter->GetDesc (&adapterDesc); + dxgiAdapter->Release(); + dxgiDevice->Release(); +#endif + adapterDesc.Description[127] = 0; + + char bufUtf8[1024]; + WideCharToMultiByte (CP_UTF8, 0, adapterDesc.Description, -1, bufUtf8, 1024, NULL, NULL ); + rendererString = bufUtf8; + + int i; + for( i = 0; i < kKnownVendorsSize; ++i ) + { + if( s_KnownVendors[i].vendorId == adapterDesc.VendorId ) + { + vendorString = s_KnownVendors[i].name; + break; + } + } + if( i == kKnownVendorsSize ) + { + vendorString = Format( "Unknown (ID=%x)", adapterDesc.VendorId ); + } + + vendorID = adapterDesc.VendorId; + rendererID = adapterDesc.DeviceId; + + // No easy way to get driver information in DXGI... + driverLibraryString.clear(); + driverVersionString.clear(); + + D3D_FEATURE_LEVEL d3dlevel = d3d->GetFeatureLevel(); + DX11FeatureLevel level = kDX11Level9_1; + switch (d3dlevel) { + case D3D_FEATURE_LEVEL_9_1: level = kDX11Level9_1; break; + case D3D_FEATURE_LEVEL_9_2: level = kDX11Level9_2; break; + case D3D_FEATURE_LEVEL_9_3: level = kDX11Level9_3; break; + case D3D_FEATURE_LEVEL_10_0: level = kDX11Level10_0; break; + case D3D_FEATURE_LEVEL_10_1: level = kDX11Level10_1; break; + case D3D_FEATURE_LEVEL_11_0: level = kDX11Level11_0; break; + default: AssertString ("Unknown feature level"); + } + d3d11.featureLevel = level; + + fixedVersionString = Format("Direct3D 11.0 [level %i.%i]", + (d3dlevel & 0xF000) >> 12, + (d3dlevel & 0x0F00) >> 8); + +#if UNITY_WINRT + // Note: On Intel HD 4000, adapterDesc.DedicatedVideoMemory was returning 32 MB, which wasn't enough to even have on render texture on Surface Pro + // That's why there were bugs with shadows + // If you change something here, do check https://fogbugz.unity3d.com/default.asp?546560#1066534481 on Surface Pro, if it's still works + #if defined(__arm__) + const float kSaneMinVRAM = 64; + #else + const float kSaneMinVRAM = 128; + #endif + videoMemoryMB = (adapterDesc.DedicatedVideoMemory == 0) ? (adapterDesc.SharedSystemMemory / 2) : adapterDesc.DedicatedVideoMemory; + videoMemoryMB = std::max(videoMemoryMB / (1024 * 1024), kSaneMinVRAM); +#if UNITY_METRO && defined(__arm__) + // tested on Tegra Tablet (Tegra T300?) and Surface (Tegra 3) - tested on 2013.02.20 + gGraphicsCaps.buggyShadowMapBilinearSampling = true; +#else + gGraphicsCaps.buggyShadowMapBilinearSampling = false; +#endif +#else + videoMemoryMB = adapterDesc.DedicatedVideoMemory / 1024 / 1024; +#endif + + // Output D3D info to console + printf_console( "Direct3D:\n" ); + printf_console( " Version: %s\n", fixedVersionString.c_str() ); + printf_console( " Renderer: %s (ID=0x%x)\n", rendererString.c_str(), rendererID); + printf_console( " Vendor: %s\n", vendorString.c_str() ); + printf_console( " VRAM: %i MB\n", (int)videoMemoryMB ); + + needsToSwizzleVertexColors = false; + maxVSyncInterval = 4; + maxLights = 8; + + // Texture sizes + static const int kTextureSizes[kDX11LevelCount] = {2048, 2048, 4096, 8192, 8192, 16384}; + static const int kCubemapSizes[kDX11LevelCount] = { 512, 512, 4096, 8192, 8192, 16384}; + maxTextureSize = kTextureSizes[level]; + maxRenderTextureSize = maxTextureSize; + maxCubeMapSize = kCubemapSizes[level]; + + // Vertex/Fragment program parts + hasFixedFunction = true; +#if UNITY_METRO + // Disable fixed function shaders on crappy devices + // One fix would be to rewrite byte code emitter to target 9.1 feature level instead of 9.3... + // For now, let's just disable it on all Intel devices with feature level < 9.3 + if (vendorID == kVendorIntel && level < kDX11Level9_3) // Internal driver error occurs when first fixed function shader is loaded + { + printf_console("WARNING: Disabling fixed function shaders.\n"); + hasFixedFunction = false; + } + else +#endif + has3DTexture = true; + maxTexUnits = kMaxSupportedTextureUnits; + maxTexImageUnits = kMaxSupportedTextureUnits; + maxTexCoords = 8; + + hasAnisoFilter = true; + static const int kMaxAniso[kDX11LevelCount] = {2, 16, 16, 16, 16, 16}; + maxAnisoLevel = kMaxAniso[level]; + hasMipLevelBias = true; + + hasS3TCCompression = true; + npotRT = npot = (level >= kDX11Level10_0) ? kNPOTFull : kNPOTRestricted; + + hasBlendSquare = true; + hasSeparateAlphaBlend = level > kDX11Level9_1; +#if UNITY_WP8 + hasSeparateAlphaBlend = level > kDX11Level9_3; // WP8 uses 9.3 feature level, but seems to not support separate alpha blending +#endif + hasBlendSub = true; + hasBlendMinMax = true; + + hasBlendLogicOps = false; + if(GetD3D11_1Device()) + { + D3D11_FEATURE_DATA_D3D11_OPTIONS opt; + + HRESULT hr = GetD3D11_1Device()->CheckFeatureSupport(D3D11_FEATURE_D3D11_OPTIONS, (void *)&opt, sizeof(opt)); + if(!FAILED(hr)) + { + hasBlendLogicOps = opt.OutputMergerLogicOp; + } + + } + + hasAutoMipMapGeneration = true; + + #pragma message ("Properly implement supported formats!") + for (int q = 0; q < kTexFormatPCCount; ++q) + supportsTextureFormat[q] = true; //@TODO + + if (level < kDX11Level9_3) + { + supportsTextureFormat[kTexFormatARGBFloat] = false; + supportsTextureFormat[kTexFormatRGB565] = false; + } + // 9.1 level doesn't really support R16 format. But we pretend we do, and then do unpacking + // into R8G8B8A8 on load. + supportsTextureFormat[kTexFormatAlphaLum16] = true; + + hasRenderToTexture = true; + for (int i = 0; i < kRTFormatCount; ++i) + { + if (i == kRTFormatDefault || i == kRTFormatDefaultHDR) + continue; + supportsRenderTextureFormat[i] = (level >= kD3D11RenderTextureFeatureLevels[i]); + } + +#if UNITY_METRO // works on adreno 305 devices (nokia lumia 620) but not adreno 225 (nokia lumia 920 and samsung ativ s) + if (level < D3D_FEATURE_LEVEL_10_0) + { + D3D11_FEATURE_DATA_D3D9_SHADOW_SUPPORT shadowSupport; + memset(&shadowSupport, 0, sizeof(shadowSupport)); + + // Devices which don't support this: + // * Intel 3150 + // D3D11 ERROR: ID3D11Device::CreatePixelShader: Shader uses comparision filtering with shader target ps_4_0_level_9_*, but the device does not support this . To check for support, call the CheckFeatureSupport() API with D3D11_FEATURE_D3D9_SHADOW_SUPPORT. The SupportsDepthAsTextureWithLessEqualComparisonFilter member indicates support for comparison filtering on level_9 shaders. [ STATE_CREATION ERROR #192: CREATEPIXELSHADER_INVALIDSHADERBYTECODE] + // First-chance exception at 0x74DD277C in New Unity Project 10.exe: Microsoft C++ exception: _com_error at memory location 0x0996ED90. + // Would be nice, if you could ignore such shaders if this feature is not supported. + + d3d->CheckFeatureSupport(D3D11_FEATURE_D3D9_SHADOW_SUPPORT, &shadowSupport, sizeof(shadowSupport)); + gGraphicsCaps.supportsRenderTextureFormat[kRTFormatDepth] = shadowSupport.SupportsDepthAsTextureWithLessEqualComparisonFilter; + gGraphicsCaps.supportsRenderTextureFormat[kRTFormatShadowMap] = shadowSupport.SupportsDepthAsTextureWithLessEqualComparisonFilter; + gGraphicsCaps.d3d11.hasShadows10Level9 = (shadowSupport.SupportsDepthAsTextureWithLessEqualComparisonFilter != 0); + } +#else + gGraphicsCaps.d3d11.hasShadows10Level9 = false; +#endif + + // Looks like 9.x levels can't easily render into cubemaps: + // * DepthStencil texture must be a cubemap as well (otherwise can't set a cubemap color & regular 2D depth) + // * But a cubemap doesn't support any of the depth buffer formats + // A workaround could be to create 2D resources for each cubemap face, render into them, and then blit into a face + // of the final cubemap. Bah. + hasRenderToCubemap = (level >= kDX11Level10_0); + + hasRenderTo3D = (level >= kDX11Level11_0); + hasStencil = true; + hasRenderTargetStencil = true; + hasTwoSidedStencil = true; + hasNativeDepthTexture = true; + hasStencilInDepthTexture = true; + hasNativeShadowMap = true; + + hasSRGBReadWrite = true; + + hasComputeShader = (level >= kDX11Level11_0); //@TODO: some sort of limited CS support in SM4? + hasInstancing = (level >= kDX11Level9_3); + hasNonFullscreenClear = false; + + hasMultiSample = true; + d3d11.msaa = d3d11.msaaSRGB = 0; + static const int kAASampleTests[] = { 2, 4, 8 }; + for (int i = 0; i < ARRAY_SIZE(kAASampleTests); ++i) + { + int samples = kAASampleTests[i]; + UInt32 mask = 1<<samples; + UINT levels = 0; + hr = d3d->CheckMultisampleQualityLevels (DXGI_FORMAT_R8G8B8A8_UNORM, samples, &levels); + if (SUCCEEDED(hr) && levels > 0) + d3d11.msaa |= mask; + d3d->CheckMultisampleQualityLevels (DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, samples, &levels); + if (SUCCEEDED(hr) && levels > 0) + d3d11.msaaSRGB |= mask; + } + + + // Crashes on ARM tablets +#if defined(__arm__) && UNITY_WINRT + hasTimerQuery = false; +#else + // In theory just doing a query create with NULL destination, like + // CreateQuery(&disjointQueryDesc, NULL) == S_FALSE + // should be enough. But this makes NVIDIA NSight 2.1 crash, so do full query creation. + const D3D11_QUERY_DESC disjointQueryDesc = { D3D11_QUERY_TIMESTAMP_DISJOINT, 0 }; + const D3D11_QUERY_DESC timestampQueryDesc = { D3D11_QUERY_TIMESTAMP, 0 }; + ID3D11Query *query1 = NULL, *query2 = NULL; + hasTimerQuery = true; + hasTimerQuery &= SUCCEEDED(d3d->CreateQuery(&disjointQueryDesc, &query1)); + hasTimerQuery &= SUCCEEDED(d3d->CreateQuery(×tampQueryDesc, &query2)); + SAFE_RELEASE(query1); + SAFE_RELEASE(query2); +#endif + + static const int kMRTCount[kDX11LevelCount] = { 1, 1, 4, 8, 8, 8 }; + maxMRTs = std::min<int> (kMRTCount[level], kMaxSupportedRenderTargets); + + // in the very end, figure out shader capabilities level (after all workarounds are applied) + static const ShaderCapsLevel kShaderLevels[kDX11LevelCount] = {kShaderLevel2, kShaderLevel2, kShaderLevel2, kShaderLevel4, kShaderLevel4_1, kShaderLevel5}; + shaderCaps = kShaderLevels[level]; + + // Looks like mipmapped cubemaps & 3D textures are broken on 9.x level; + // can't update proper faces via CopySubresourceRegion / UpdateSubresource. + buggyMipmappedCubemaps = buggyMipmapped3DTextures = (level < kDX11Level10_0); + + d3d11.buggyPartialPrecision10Level9 = false; + if (level < kDX11Level10_0) + { + // Lumia 620 crashes on partial precision (on WP8 as of 2013 March), with renderer + // string "Qualcomm Adreno 305 (WDDM v1.2)". Let's try removing partial precision + // on all Adreno 3xx. + if (rendererString.find("Adreno 3") != std::string::npos) + d3d11.buggyPartialPrecision10Level9 = true; + } +} diff --git a/Runtime/GfxDevice/d3d11/InternalShaders/CompileShaderLib/CompileShaderLib.cpp b/Runtime/GfxDevice/d3d11/InternalShaders/CompileShaderLib/CompileShaderLib.cpp new file mode 100644 index 0000000..f25090b --- /dev/null +++ b/Runtime/GfxDevice/d3d11/InternalShaders/CompileShaderLib/CompileShaderLib.cpp @@ -0,0 +1,185 @@ +// This is a small program to precompile hlsl library to a header file, +// used only for fixed function shader generation with d3d11 linker. +// It also generates 8 * 4 combinations of texture sampling functions. +// +// Useful because fxc doesn't support lib_* targets, +// but once it does it's probably a good idea to deprecate this. + +#include <windows.h> +#include <d3d11.h> +#include <d3dcommon.h> +#include <d3dcompiler.h> + +#include <cstdio> +#include <cassert> + +typedef HRESULT (WINAPI *D3DCompileFunc)( + const void* pSrcData, + unsigned long SrcDataSize, + const char* pFileName, + const D3D10_SHADER_MACRO* pDefines, + void* pInclude, + const char* pEntrypoint, + const char* pTarget, + unsigned int Flags1, + unsigned int Flags2, + ID3DBlob** ppCode, + ID3DBlob** ppErrorMsgs +); + +const char* dllName = "D3DCompiler_47.dll"; + +const char* readFile(const char* path) +{ + FILE* f = fopen(path, "rb"); + if (!f) + return NULL; + + fseek(f, 0, SEEK_END); + size_t s = ftell(f); + fseek(f, 0, SEEK_SET); + char* out = (char*)malloc(s+1); + fread(out, s, 1, f); + out[s] = '\0'; + fclose(f); + return out; +} + +void printCompiledShader(ID3DBlob* shader, const char* name, FILE* out) +{ + const unsigned char* data = (const unsigned char*)shader->GetBufferPointer(); + size_t size = (size_t)shader->GetBufferSize(); + + fprintf(out, "const BYTE %s[] = { \n", name); + for(int i = 0; i < size; ++i) { + fprintf(out, ((i==size-1) ? "%d" : "%d,"), (int)data[i]); + if((i+1) % 16 == 0) + fprintf(out, "\n"); + } + fprintf(out, "\n};\n"); +} + +// type: 0 - 2d, 1 - 2d proj, 2 - 3d, 3 - cube +const char* generateTextureSamplingLib(int type, int unit) +{ + const int maxSize = 2048; + static char hlsl[maxSize]; + + const char* textureTypes[] = { "Texture2D", "Texture2D", "Texture3D", "TextureCube" }; + const char* coordTypes[] = {"float2", "float4", "float3", "float3" }; + const char* coords[] = {"uv.xy", "uv.xy/uv.w", "uv.xyz", "uv.xyz" }; + + sprintf(hlsl, + "%s<float4> Tex%d : register(t%d);\n" + "SamplerState Smp%d : register(s%d);\n" + "export float4 LoadTex%d(%s uv) { return Tex%d.Sample(Smp%d, %s); }\n", + textureTypes[type], unit, unit, unit, unit, unit, + coordTypes[type], unit, unit, coords[type] + ); + + return hlsl; +} + +const char* textureSamplingLibName(int type, int unit) +{ + static const char* typeStr[] = {"2D", "Proj", "3D", "Cube"}; + static char name[32]; + sprintf(name, "g_FFSampleTex%s%d", typeStr[type], unit); + return name; +} + +// Since we can't bind multiple textures to the same texture register, +// we'll have to generate 4 * 8 sampling functions and link the correct ones +// at runtime. +void printTextureSampling(D3DCompileFunc compileFunc, FILE* out) +{ + // Print compiled shaders + for (int type = 0; type < 4; ++type) + { + for (int unit = 0; unit < 8; ++unit) + { + const char* name = textureSamplingLibName(type, unit); + const char* hlsl = generateTextureSamplingLib(type, unit); + + ID3DBlob* errors; + ID3DBlob* shader; + HRESULT hr = compileFunc( + hlsl, strlen(hlsl), name, NULL, NULL, NULL, + "lib_4_0_level_9_1", D3DCOMPILE_OPTIMIZATION_LEVEL3, 0, &shader, &errors + ); + + assert(SUCCEEDED(hr)); + + printCompiledShader(shader, name, out); + + shader->Release(); + } + } + + // Print index to all shaders + fprintf(out, "const BYTE* g_FFSampleTexLib[] = { \n"); + for (int type = 0; type < 4; ++type) + for (int unit = 0; unit < 8; ++unit) + fprintf(out, "%s,\n", textureSamplingLibName(type, unit)); + fprintf(out, "};\n"); + + // Print sizes of all shaders + fprintf(out, "const size_t g_FFSampleTexLibSize[] = { \n"); + for (int type = 0; type < 4; ++type) + for (int unit = 0; unit < 8; ++unit) + fprintf(out, "sizeof(%s),\n", textureSamplingLibName(type, unit)); + fprintf(out, "};\n"); +} + +int main(int argc, const char** argv) +{ + if (argc != 3) + { + printf("Usage: CompileShaderLib.exe src.hlsl out.h\n"); + return 1; + } + + HMODULE dll = LoadLibraryA (dllName); + if (!dll) + { + printf("Can't load %s\n", dllName); + return 1; + } + + D3DCompileFunc compileFunc = (D3DCompileFunc) GetProcAddress(dll, "D3DCompile"); + if (!compileFunc) + { + printf("Can't get D3DCompile function address\n"); + return 1; + } + + const char* hlsl = readFile(argv[1]); + + ID3DBlob* errors; + ID3DBlob* shader; + HRESULT hr = compileFunc( + hlsl, strlen(hlsl), argv[1], NULL, NULL, NULL, + "lib_4_0_level_9_1", D3DCOMPILE_OPTIMIZATION_LEVEL3, 0, &shader, &errors + ); + + if (FAILED(hr)) + { + printf("Failed to compile, 0x%x:\n%s\n", hr, errors ? errors->GetBufferPointer() : ""); + return 1; + } + + free((void*)hlsl); + FILE* out = fopen(argv[2], "w"); + + fprintf(out, "// File autogenerated by CompileShaderLib.exe\n"); + + printCompiledShader(shader, "g_FFShaderLibrary", out); + shader->Release(); + + printTextureSampling(compileFunc, out); + + fclose(out); + + return 0; +} + diff --git a/Runtime/GfxDevice/d3d11/InternalShaders/CompileShaderLib/CompileShaderLib.exe b/Runtime/GfxDevice/d3d11/InternalShaders/CompileShaderLib/CompileShaderLib.exe Binary files differnew file mode 100644 index 0000000..9452400 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/InternalShaders/CompileShaderLib/CompileShaderLib.exe diff --git a/Runtime/GfxDevice/d3d11/InternalShaders/CompileShaderLib/d3dcompiler_47.dll b/Runtime/GfxDevice/d3d11/InternalShaders/CompileShaderLib/d3dcompiler_47.dll Binary files differnew file mode 100644 index 0000000..f8708d3 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/InternalShaders/CompileShaderLib/d3dcompiler_47.dll diff --git a/Runtime/GfxDevice/d3d11/InternalShaders/FFShaderLib.h b/Runtime/GfxDevice/d3d11/InternalShaders/FFShaderLib.h new file mode 100644 index 0000000..cfb7617 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/InternalShaders/FFShaderLib.h @@ -0,0 +1,11341 @@ +// File autogenerated by CompileShaderLib.exe +const BYTE g_FFShaderLibrary[] = { +68,88,66,67,53,175,93,57,187,158,181,204,26,193,132,124, +173,199,196,230,1,0,0,0,85,80,2,0,83,0,0,0, +108,1,0,0,248,3,0,0,176,10,0,0,204,18,0,0, +32,27,0,0,140,29,0,0,136,32,0,0,60,36,0,0, +240,42,0,0,164,49,0,0,88,56,0,0,4,64,0,0, +20,68,0,0,40,72,0,0,100,87,0,0,88,105,0,0, +104,124,0,0,192,140,0,0,116,157,0,0,204,173,0,0, +4,192,0,0,92,208,0,0,24,228,0,0,112,244,0,0, +176,9,1,0,8,26,1,0,204,48,1,0,36,65,1,0, +72,89,1,0,160,105,1,0,200,108,1,0,232,116,1,0, +164,119,1,0,96,122,1,0,224,124,1,0,0,132,1,0, +24,140,1,0,48,148,1,0,72,156,1,0,96,164,1,0, +232,166,1,0,112,169,1,0,248,171,1,0,128,174,1,0, +72,179,1,0,48,182,1,0,248,185,1,0,192,189,1,0, +136,193,1,0,80,197,1,0,24,201,1,0,224,204,1,0, +168,208,1,0,112,212,1,0,68,215,1,0,36,218,1,0, +4,221,1,0,140,223,1,0,160,226,1,0,172,229,1,0, +64,233,1,0,88,236,1,0,20,240,1,0,72,244,1,0, +84,248,1,0,228,251,1,0,120,255,1,0,140,3,2,0, +44,6,2,0,8,9,2,0,72,12,2,0,96,15,2,0, +88,23,2,0,116,31,2,0,136,39,2,0,156,44,2,0, +28,47,2,0,92,51,2,0,172,55,2,0,236,59,2,0, +48,64,2,0,132,68,2,0,196,72,2,0,76,73,66,70, +132,2,0,0,68,88,66,67,97,223,247,81,192,181,190,245, +62,154,200,24,62,42,44,199,1,0,0,0,132,2,0,0, +6,0,0,0,56,0,0,0,132,0,0,0,208,0,0,0, +16,1,0,0,140,1,0,0,0,2,0,0,65,111,110,57, +68,0,0,0,68,0,0,0,0,2,86,76,32,0,0,0, +36,0,0,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,2,86,76,31,0,0,2, +5,0,0,128,0,0,15,144,1,0,0,2,0,0,15,224, +0,0,228,144,255,255,0,0,65,111,110,57,68,0,0,0, +68,0,0,0,0,2,80,76,32,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,15,176,1,0,0,2,0,0,15,224,0,0,228,176, +255,255,0,0,83,72,68,82,56,0,0,0,64,0,240,255, +14,0,0,0,95,0,0,3,242,16,16,0,0,0,0,0, +101,0,0,3,242,32,16,0,0,0,0,0,54,0,0,5, +242,32,16,0,0,0,0,0,70,30,16,0,0,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,2,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,108,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +60,0,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,171,171,76,70,83,48,124,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,120,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,86,101,114,116,101,120,67,111, +108,111,114,0,118,99,0,171,76,73,66,70,176,6,0,0, +68,88,66,67,193,45,92,32,38,130,119,195,162,50,75,220, +113,111,147,34,1,0,0,0,176,6,0,0,6,0,0,0, +56,0,0,0,132,0,0,0,208,0,0,0,24,1,0,0, +148,1,0,0,88,6,0,0,65,111,110,57,68,0,0,0, +68,0,0,0,0,2,86,76,20,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,0,0,8,0,1,0,0,0,0,0,0,0, +0,2,86,76,1,0,0,2,0,0,15,224,0,0,228,160, +255,255,0,0,65,111,110,57,68,0,0,0,68,0,0,0, +0,2,80,76,20,0,0,0,48,0,0,0,1,0,36,0, +0,0,48,0,0,0,48,0,0,0,36,0,0,0,48,0, +0,0,8,0,1,0,0,0,0,0,0,0,0,2,80,76, +1,0,0,2,0,0,15,224,0,0,228,160,255,255,0,0, +83,72,68,82,64,0,0,0,64,0,240,255,16,0,0,0, +89,0,0,4,70,142,32,0,0,0,0,0,9,0,0,0, +101,0,0,3,242,32,16,0,0,0,0,0,54,0,0,6, +242,32,16,0,0,0,0,0,70,142,32,0,0,0,0,0, +8,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,188,4,0,0,1,0,0,0, +108,0,0,0,1,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,142,4,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,85,110,105,116,121,70,70,86, +101,114,116,101,120,0,171,171,92,0,0,0,14,0,0,0, +132,0,0,0,240,3,0,0,0,0,0,0,0,0,0,0, +180,2,0,0,0,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,240,2,0,0,64,0,0,0, +64,0,0,0,0,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +253,2,0,0,128,0,0,0,16,0,0,0,2,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,56,3,0,0,144,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +71,3,0,0,160,0,0,0,128,0,0,0,0,0,0,0, +88,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,124,3,0,0,32,1,0,0, +128,0,0,0,0,0,0,0,140,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +176,3,0,0,160,1,0,0,128,0,0,0,0,0,0,0, +192,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,228,3,0,0,32,2,0,0, +128,0,0,0,0,0,0,0,244,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +24,4,0,0,160,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,39,4,0,0,176,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +54,4,0,0,192,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,66,4,0,0,208,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +82,4,0,0,224,2,0,0,0,1,0,0,0,0,0,0, +96,4,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,132,4,0,0,224,3,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +102,102,95,109,97,116,114,105,120,95,109,118,112,0,102,108, +111,97,116,52,120,52,0,171,3,0,3,0,4,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,194,2,0,0,102,102,95,109, +97,116,114,105,120,95,109,118,0,102,102,95,118,101,99,95, +99,111,108,111,114,0,102,108,111,97,116,52,0,171,171,171, +1,0,3,0,1,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,118,101,99,95,97,109,98,105,101, +110,116,0,102,102,95,108,105,103,104,116,95,99,111,108,111, +114,0,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,112,111,115,0,171,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,97,116,116,101,110,0,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,115,112,111,116,0,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,109,97,116,95,100,105,102,102,117, +115,101,0,102,102,95,109,97,116,95,97,109,98,105,101,110, +116,0,102,102,95,109,97,116,95,115,112,101,99,0,102,102, +95,109,97,116,95,101,109,105,115,115,105,111,110,0,102,102, +95,109,97,116,114,105,120,95,116,101,120,0,3,0,3,0, +4,0,4,0,4,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,194,2,0,0, +102,102,95,102,111,103,95,118,115,0,77,105,99,114,111,115, +111,102,116,32,40,82,41,32,72,76,83,76,32,83,104,97, +100,101,114,32,67,111,109,112,105,108,101,114,32,54,46,51, +46,57,52,49,53,46,48,0,76,70,83,48,80,0,0,0, +1,0,0,0,8,0,0,0,56,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,76,111,97,100,86,101,114,116, +101,120,67,111,108,111,114,85,110,105,102,111,114,109,0,171, +76,73,66,70,20,8,0,0,68,88,66,67,29,191,205,137, +232,73,220,57,32,180,48,231,114,9,102,236,1,0,0,0, +20,8,0,0,6,0,0,0,56,0,0,0,208,0,0,0, +116,1,0,0,80,2,0,0,204,2,0,0,144,7,0,0, +65,111,110,57,144,0,0,0,144,0,0,0,0,2,86,76, +96,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,0,0,4,0, +4,0,0,0,0,0,0,0,0,2,86,76,31,0,0,2, +5,0,0,128,0,0,15,144,5,0,0,3,0,0,7,128, +0,0,85,144,1,0,228,160,4,0,0,4,0,0,7,128, +0,0,228,160,0,0,0,144,0,0,228,128,4,0,0,4, +0,0,7,128,2,0,228,160,0,0,170,144,0,0,228,128, +4,0,0,4,0,0,7,224,3,0,228,160,0,0,255,144, +0,0,228,128,255,255,0,0,65,111,110,57,156,0,0,0, +156,0,0,0,0,2,80,76,108,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,0,0,4,0,4,0,0,0,0,0,0,0, +0,2,80,76,31,0,0,2,0,0,0,128,0,0,15,176, +5,0,0,3,0,0,7,128,0,0,85,176,1,0,228,160, +4,0,0,4,0,0,7,128,0,0,228,160,0,0,0,176, +0,0,228,128,4,0,0,4,0,0,7,128,2,0,228,160, +0,0,170,176,0,0,228,128,4,0,0,4,0,0,7,128, +3,0,228,160,0,0,255,176,0,0,228,128,1,0,0,2, +0,0,7,224,0,0,228,128,255,255,0,0,83,72,68,82, +212,0,0,0,64,0,240,255,53,0,0,0,89,0,0,4, +70,142,32,0,0,0,0,0,8,0,0,0,95,0,0,3, +242,16,16,0,0,0,0,0,101,0,0,3,114,32,16,0, +0,0,0,0,104,0,0,2,1,0,0,0,56,0,0,8, +114,0,16,0,0,0,0,0,86,21,16,0,0,0,0,0, +70,130,32,0,0,0,0,0,5,0,0,0,50,0,0,10, +114,0,16,0,0,0,0,0,70,130,32,0,0,0,0,0, +4,0,0,0,6,16,16,0,0,0,0,0,70,2,16,0, +0,0,0,0,50,0,0,10,114,0,16,0,0,0,0,0, +70,130,32,0,0,0,0,0,6,0,0,0,166,26,16,0, +0,0,0,0,70,2,16,0,0,0,0,0,50,0,0,10, +114,32,16,0,0,0,0,0,70,130,32,0,0,0,0,0, +7,0,0,0,246,31,16,0,0,0,0,0,70,2,16,0, +0,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +5,0,0,0,1,0,0,0,0,0,0,0,2,0,0,0, +4,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,188,4,0,0,1,0,0,0, +108,0,0,0,1,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,142,4,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,85,110,105,116,121,70,70,86, +101,114,116,101,120,0,171,171,92,0,0,0,14,0,0,0, +132,0,0,0,240,3,0,0,0,0,0,0,0,0,0,0, +180,2,0,0,0,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,240,2,0,0,64,0,0,0, +64,0,0,0,2,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +253,2,0,0,128,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,56,3,0,0,144,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +71,3,0,0,160,0,0,0,128,0,0,0,0,0,0,0, +88,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,124,3,0,0,32,1,0,0, +128,0,0,0,0,0,0,0,140,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +176,3,0,0,160,1,0,0,128,0,0,0,0,0,0,0, +192,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,228,3,0,0,32,2,0,0, +128,0,0,0,0,0,0,0,244,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +24,4,0,0,160,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,39,4,0,0,176,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +54,4,0,0,192,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,66,4,0,0,208,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +82,4,0,0,224,2,0,0,0,1,0,0,0,0,0,0, +96,4,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,132,4,0,0,224,3,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +102,102,95,109,97,116,114,105,120,95,109,118,112,0,102,108, +111,97,116,52,120,52,0,171,3,0,3,0,4,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,194,2,0,0,102,102,95,109, +97,116,114,105,120,95,109,118,0,102,102,95,118,101,99,95, +99,111,108,111,114,0,102,108,111,97,116,52,0,171,171,171, +1,0,3,0,1,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,118,101,99,95,97,109,98,105,101, +110,116,0,102,102,95,108,105,103,104,116,95,99,111,108,111, +114,0,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,112,111,115,0,171,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,97,116,116,101,110,0,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,115,112,111,116,0,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,109,97,116,95,100,105,102,102,117, +115,101,0,102,102,95,109,97,116,95,97,109,98,105,101,110, +116,0,102,102,95,109,97,116,95,115,112,101,99,0,102,102, +95,109,97,116,95,101,109,105,115,115,105,111,110,0,102,102, +95,109,97,116,114,105,120,95,116,101,120,0,3,0,3,0, +4,0,4,0,4,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,194,2,0,0, +102,102,95,102,111,103,95,118,115,0,77,105,99,114,111,115, +111,102,116,32,40,82,41,32,72,76,83,76,32,83,104,97, +100,101,114,32,67,111,109,112,105,108,101,114,32,54,46,51, +46,57,52,49,53,46,48,0,76,70,83,48,124,0,0,0, +2,0,0,0,8,0,0,0,104,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,115,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,76,111,97,100,69,121,101,80, +111,115,0,118,101,114,116,101,120,0,171,171,76,73,66,70, +76,8,0,0,68,88,66,67,108,68,195,40,106,156,44,20, +245,155,105,169,96,77,47,194,1,0,0,0,76,8,0,0, +6,0,0,0,56,0,0,0,232,0,0,0,132,1,0,0, +132,2,0,0,0,3,0,0,196,7,0,0,65,111,110,57, +168,0,0,0,168,0,0,0,0,2,86,76,120,0,0,0, +48,0,0,0,1,0,36,0,0,0,48,0,0,0,48,0, +0,0,36,0,0,0,48,0,0,0,4,0,3,0,0,0, +0,0,0,0,0,2,86,76,31,0,0,2,5,0,0,128, +0,0,15,144,5,0,0,3,0,0,7,128,0,0,85,144, +1,0,228,160,4,0,0,4,0,0,7,128,0,0,228,160, +0,0,0,144,0,0,228,128,4,0,0,4,0,0,7,128, +2,0,228,160,0,0,170,144,0,0,228,128,8,0,0,3, +0,0,8,128,0,0,228,128,0,0,228,128,7,0,0,2, +0,0,8,128,0,0,255,128,5,0,0,3,0,0,7,224, +0,0,255,128,0,0,228,128,255,255,0,0,65,111,110,57, +148,0,0,0,148,0,0,0,0,2,80,76,100,0,0,0, +48,0,0,0,1,0,36,0,0,0,48,0,0,0,48,0, +0,0,36,0,0,0,48,0,0,0,4,0,3,0,0,0, +0,0,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,5,0,0,3,0,0,7,128,0,0,85,176, +1,0,228,160,4,0,0,4,0,0,7,128,0,0,228,160, +0,0,0,176,0,0,228,128,4,0,0,4,0,0,7,128, +2,0,228,160,0,0,170,176,0,0,228,128,36,0,0,2, +1,0,7,128,0,0,228,128,1,0,0,2,0,0,7,224, +1,0,228,128,255,255,0,0,83,72,68,82,248,0,0,0, +64,0,240,255,62,0,0,0,89,0,0,4,70,142,32,0, +0,0,0,0,7,0,0,0,95,0,0,3,114,16,16,0, +0,0,0,0,101,0,0,3,114,32,16,0,0,0,0,0, +104,0,0,2,1,0,0,0,56,0,0,8,114,0,16,0, +0,0,0,0,86,21,16,0,0,0,0,0,70,130,32,0, +0,0,0,0,5,0,0,0,50,0,0,10,114,0,16,0, +0,0,0,0,70,130,32,0,0,0,0,0,4,0,0,0, +6,16,16,0,0,0,0,0,70,2,16,0,0,0,0,0, +50,0,0,10,114,0,16,0,0,0,0,0,70,130,32,0, +0,0,0,0,6,0,0,0,166,26,16,0,0,0,0,0, +70,2,16,0,0,0,0,0,16,0,0,7,130,0,16,0, +0,0,0,0,70,2,16,0,0,0,0,0,70,2,16,0, +0,0,0,0,68,0,0,5,130,0,16,0,0,0,0,0, +58,0,16,0,0,0,0,0,56,0,0,7,114,32,16,0, +0,0,0,0,246,15,16,0,0,0,0,0,70,2,16,0, +0,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +7,0,0,0,1,0,0,0,0,0,0,0,2,0,0,0, +6,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,188,4,0,0,1,0,0,0, +108,0,0,0,1,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,142,4,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,85,110,105,116,121,70,70,86, +101,114,116,101,120,0,171,171,92,0,0,0,14,0,0,0, +132,0,0,0,240,3,0,0,0,0,0,0,0,0,0,0, +180,2,0,0,0,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,240,2,0,0,64,0,0,0, +64,0,0,0,2,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +253,2,0,0,128,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,56,3,0,0,144,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +71,3,0,0,160,0,0,0,128,0,0,0,0,0,0,0, +88,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,124,3,0,0,32,1,0,0, +128,0,0,0,0,0,0,0,140,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +176,3,0,0,160,1,0,0,128,0,0,0,0,0,0,0, +192,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,228,3,0,0,32,2,0,0, +128,0,0,0,0,0,0,0,244,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +24,4,0,0,160,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,39,4,0,0,176,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +54,4,0,0,192,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,66,4,0,0,208,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +82,4,0,0,224,2,0,0,0,1,0,0,0,0,0,0, +96,4,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,132,4,0,0,224,3,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +102,102,95,109,97,116,114,105,120,95,109,118,112,0,102,108, +111,97,116,52,120,52,0,171,3,0,3,0,4,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,194,2,0,0,102,102,95,109, +97,116,114,105,120,95,109,118,0,102,102,95,118,101,99,95, +99,111,108,111,114,0,102,108,111,97,116,52,0,171,171,171, +1,0,3,0,1,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,118,101,99,95,97,109,98,105,101, +110,116,0,102,102,95,108,105,103,104,116,95,99,111,108,111, +114,0,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,112,111,115,0,171,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,97,116,116,101,110,0,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,115,112,111,116,0,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,109,97,116,95,100,105,102,102,117, +115,101,0,102,102,95,109,97,116,95,97,109,98,105,101,110, +116,0,102,102,95,109,97,116,95,115,112,101,99,0,102,102, +95,109,97,116,95,101,109,105,115,115,105,111,110,0,102,102, +95,109,97,116,114,105,120,95,116,101,120,0,3,0,3,0, +4,0,4,0,4,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,194,2,0,0, +102,102,95,102,111,103,95,118,115,0,77,105,99,114,111,115, +111,102,116,32,40,82,41,32,72,76,83,76,32,83,104,97, +100,101,114,32,67,111,109,112,105,108,101,114,32,54,46,51, +46,57,52,49,53,46,48,0,76,70,83,48,128,0,0,0, +2,0,0,0,8,0,0,0,104,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,118,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,76,111,97,100,69,121,101,78, +111,114,109,97,108,0,110,111,114,109,97,108,0,171,171,171, +76,73,66,70,100,2,0,0,68,88,66,67,13,191,80,101, +135,3,145,74,141,73,23,109,153,81,118,66,1,0,0,0, +100,2,0,0,6,0,0,0,56,0,0,0,144,0,0,0, +232,0,0,0,40,1,0,0,164,1,0,0,24,2,0,0, +65,111,110,57,80,0,0,0,80,0,0,0,0,2,86,76, +44,0,0,0,36,0,0,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,2,86,76, +81,0,0,5,0,0,15,160,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,2,0,0,7,224, +0,0,0,160,255,255,0,0,65,111,110,57,80,0,0,0, +80,0,0,0,0,2,80,76,44,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,80,76,81,0,0,5,0,0,15,160, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,2,0,0,7,224,0,0,0,160,255,255,0,0, +83,72,68,82,56,0,0,0,64,0,240,255,14,0,0,0, +101,0,0,3,114,32,16,0,0,0,0,0,54,0,0,8, +114,32,16,0,0,0,0,0,2,64,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +108,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,60,0,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +77,105,99,114,111,115,111,102,116,32,40,82,41,32,72,76, +83,76,32,83,104,97,100,101,114,32,67,111,109,112,105,108, +101,114,32,54,46,51,46,57,52,49,53,46,48,0,171,171, +76,70,83,48,68,0,0,0,1,0,0,0,8,0,0,0, +56,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,2,0,0,0, +255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0, +76,111,97,100,90,101,114,111,0,171,171,171,76,73,66,70, +244,2,0,0,68,88,66,67,53,78,34,111,89,96,24,187, +132,251,160,114,111,40,100,183,1,0,0,0,244,2,0,0, +6,0,0,0,56,0,0,0,144,0,0,0,232,0,0,0, +128,1,0,0,252,1,0,0,112,2,0,0,65,111,110,57, +80,0,0,0,80,0,0,0,0,2,86,76,44,0,0,0, +36,0,0,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,2,86,76,31,0,0,2, +5,0,0,128,0,0,15,144,36,0,0,2,0,0,7,128, +0,0,228,144,1,0,0,2,0,0,7,224,0,0,228,129, +255,255,0,0,65,111,110,57,80,0,0,0,80,0,0,0, +0,2,80,76,44,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,80,76,31,0,0,2,0,0,0,128,0,0,7,176, +36,0,0,2,0,0,7,128,0,0,228,176,1,0,0,2, +0,0,7,224,0,0,228,129,255,255,0,0,83,72,68,82, +144,0,0,0,64,0,240,255,36,0,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,114,32,16,0, +0,0,0,0,104,0,0,2,1,0,0,0,16,0,0,7, +18,0,16,0,0,0,0,0,70,18,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,68,0,0,5,18,0,16,0, +0,0,0,0,10,0,16,0,0,0,0,0,56,0,0,7, +114,0,16,0,0,0,0,0,6,0,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,54,0,0,6,114,32,16,0, +0,0,0,0,70,2,16,128,65,0,0,0,0,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,5,0,0,0, +1,0,0,0,0,0,0,0,2,0,0,0,4,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,108,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +60,0,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,171,171,76,70,83,48,124,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,116,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,86,105,101,119,68,105,114,0, +101,121,101,80,111,115,0,171,76,73,66,70,172,3,0,0, +68,88,66,67,254,31,22,103,65,178,142,215,125,145,113,223, +36,2,176,21,1,0,0,0,172,3,0,0,6,0,0,0, +56,0,0,0,196,0,0,0,92,1,0,0,252,1,0,0, +120,2,0,0,236,2,0,0,65,111,110,57,132,0,0,0, +132,0,0,0,0,2,86,76,96,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,86,76,31,0,0,2,5,0,0,128, +0,0,15,144,31,0,0,2,5,0,1,128,1,0,15,144, +1,0,0,2,0,0,7,128,0,0,228,144,8,0,0,3, +0,0,8,128,0,0,228,128,1,0,228,144,2,0,0,3, +0,0,8,128,0,0,255,128,0,0,255,128,4,0,0,4, +0,0,7,224,0,0,255,128,1,0,228,144,0,0,228,129, +255,255,0,0,65,111,110,57,144,0,0,0,144,0,0,0, +0,2,80,76,108,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,80,76,31,0,0,2,0,0,0,128,0,0,7,176, +31,0,0,2,0,0,0,128,1,0,7,176,1,0,0,2, +0,0,7,128,0,0,228,176,8,0,0,3,0,0,8,128, +0,0,228,128,1,0,228,176,2,0,0,3,0,0,8,128, +0,0,255,128,0,0,255,128,4,0,0,4,0,0,7,128, +0,0,255,128,1,0,228,176,0,0,228,129,1,0,0,2, +0,0,7,224,0,0,228,128,255,255,0,0,83,72,68,82, +152,0,0,0,64,0,240,255,38,0,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,95,0,0,3,114,16,16,0, +1,0,0,0,101,0,0,3,114,32,16,0,0,0,0,0, +104,0,0,2,1,0,0,0,16,0,0,7,18,0,16,0, +0,0,0,0,70,18,16,0,0,0,0,0,70,18,16,0, +1,0,0,0,0,0,0,7,18,0,16,0,0,0,0,0, +10,0,16,0,0,0,0,0,10,0,16,0,0,0,0,0, +50,0,0,10,114,32,16,0,0,0,0,0,6,0,16,0, +0,0,0,0,70,18,16,0,1,0,0,0,70,18,16,128, +65,0,0,0,0,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,4,0,0,0,1,0,0,0,0,0,0,0, +3,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,108,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,60,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,77,105,99,114, +111,115,111,102,116,32,40,82,41,32,72,76,83,76,32,83, +104,97,100,101,114,32,67,111,109,112,105,108,101,114,32,54, +46,51,46,57,52,49,53,46,48,0,171,171,76,70,83,48, +184,0,0,0,3,0,0,0,8,0,0,0,152,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,2,0,0,0,255,255,255,255, +255,255,255,255,0,0,0,0,0,0,0,0,164,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,172,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,76,111,97,100, +69,121,101,82,101,102,108,0,118,105,101,119,68,105,114,0, +101,121,101,78,111,114,109,97,108,0,171,171,76,73,66,70, +172,6,0,0,68,88,66,67,200,162,94,107,60,63,213,125, +45,223,136,185,236,153,37,63,1,0,0,0,172,6,0,0, +6,0,0,0,56,0,0,0,132,0,0,0,208,0,0,0, +24,1,0,0,148,1,0,0,88,6,0,0,65,111,110,57, +68,0,0,0,68,0,0,0,0,2,86,76,20,0,0,0, +48,0,0,0,1,0,36,0,0,0,48,0,0,0,48,0, +0,0,36,0,0,0,48,0,0,0,43,0,1,0,0,0, +0,0,0,0,0,2,86,76,1,0,0,2,0,0,15,224, +0,0,228,160,255,255,0,0,65,111,110,57,68,0,0,0, +68,0,0,0,0,2,80,76,20,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,0,0,43,0,1,0,0,0,0,0,0,0, +0,2,80,76,1,0,0,2,0,0,15,224,0,0,228,160, +255,255,0,0,83,72,68,82,64,0,0,0,64,0,240,255, +16,0,0,0,89,0,0,4,70,142,32,0,0,0,0,0, +44,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +54,0,0,6,242,32,16,0,0,0,0,0,70,142,32,0, +0,0,0,0,43,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,188,4,0,0, +1,0,0,0,108,0,0,0,1,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,142,4,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,92,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,85,110,105,116, +121,70,70,86,101,114,116,101,120,0,171,171,92,0,0,0, +14,0,0,0,132,0,0,0,240,3,0,0,0,0,0,0, +0,0,0,0,180,2,0,0,0,0,0,0,64,0,0,0, +0,0,0,0,204,2,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,240,2,0,0, +64,0,0,0,64,0,0,0,0,0,0,0,204,2,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,253,2,0,0,128,0,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,56,3,0,0, +144,0,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,71,3,0,0,160,0,0,0,128,0,0,0, +0,0,0,0,88,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,124,3,0,0, +32,1,0,0,128,0,0,0,0,0,0,0,140,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,176,3,0,0,160,1,0,0,128,0,0,0, +0,0,0,0,192,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,228,3,0,0, +32,2,0,0,128,0,0,0,0,0,0,0,244,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,24,4,0,0,160,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,39,4,0,0, +176,2,0,0,16,0,0,0,2,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,54,4,0,0,192,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,66,4,0,0, +208,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,82,4,0,0,224,2,0,0,0,1,0,0, +0,0,0,0,96,4,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,132,4,0,0, +224,3,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,102,102,95,109,97,116,114,105,120,95,109,118, +112,0,102,108,111,97,116,52,120,52,0,171,3,0,3,0, +4,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,194,2,0,0, +102,102,95,109,97,116,114,105,120,95,109,118,0,102,102,95, +118,101,99,95,99,111,108,111,114,0,102,108,111,97,116,52, +0,171,171,171,1,0,3,0,1,0,4,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,118,101,99,95,97, +109,98,105,101,110,116,0,102,102,95,108,105,103,104,116,95, +99,111,108,111,114,0,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,112,111,115,0,171,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,97,116,116,101,110,0,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,115,112,111, +116,0,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,109,97,116,95,100, +105,102,102,117,115,101,0,102,102,95,109,97,116,95,97,109, +98,105,101,110,116,0,102,102,95,109,97,116,95,115,112,101, +99,0,102,102,95,109,97,116,95,101,109,105,115,115,105,111, +110,0,102,102,95,109,97,116,114,105,120,95,116,101,120,0, +3,0,3,0,4,0,4,0,4,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +194,2,0,0,102,102,95,102,111,103,95,118,115,0,77,105, +99,114,111,115,111,102,116,32,40,82,41,32,72,76,83,76, +32,83,104,97,100,101,114,32,67,111,109,112,105,108,101,114, +32,54,46,51,46,57,52,49,53,46,48,0,76,70,83,48, +76,0,0,0,1,0,0,0,8,0,0,0,56,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,2,0,0,0,255,255,255,255, +255,255,255,255,0,0,0,0,0,0,0,0,76,111,97,100, +65,109,98,105,101,110,116,67,111,108,111,114,0,171,171,171, +76,73,66,70,172,6,0,0,68,88,66,67,146,119,135,218, +29,151,113,93,178,158,120,136,238,224,122,235,1,0,0,0, +172,6,0,0,6,0,0,0,56,0,0,0,132,0,0,0, +208,0,0,0,24,1,0,0,148,1,0,0,88,6,0,0, +65,111,110,57,68,0,0,0,68,0,0,0,0,2,86,76, +20,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,0,0,42,0, +1,0,0,0,0,0,0,0,0,2,86,76,1,0,0,2, +0,0,15,224,0,0,228,160,255,255,0,0,65,111,110,57, +68,0,0,0,68,0,0,0,0,2,80,76,20,0,0,0, +48,0,0,0,1,0,36,0,0,0,48,0,0,0,48,0, +0,0,36,0,0,0,48,0,0,0,42,0,1,0,0,0, +0,0,0,0,0,2,80,76,1,0,0,2,0,0,15,224, +0,0,228,160,255,255,0,0,83,72,68,82,64,0,0,0, +64,0,240,255,16,0,0,0,89,0,0,4,70,142,32,0, +0,0,0,0,43,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,54,0,0,6,242,32,16,0,0,0,0,0, +70,142,32,0,0,0,0,0,42,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +188,4,0,0,1,0,0,0,108,0,0,0,1,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,142,4,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +85,110,105,116,121,70,70,86,101,114,116,101,120,0,171,171, +92,0,0,0,14,0,0,0,132,0,0,0,240,3,0,0, +0,0,0,0,0,0,0,0,180,2,0,0,0,0,0,0, +64,0,0,0,0,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +240,2,0,0,64,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,253,2,0,0,128,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +56,3,0,0,144,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,71,3,0,0,160,0,0,0, +128,0,0,0,0,0,0,0,88,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +124,3,0,0,32,1,0,0,128,0,0,0,0,0,0,0, +140,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,176,3,0,0,160,1,0,0, +128,0,0,0,0,0,0,0,192,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +228,3,0,0,32,2,0,0,128,0,0,0,0,0,0,0, +244,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,24,4,0,0,160,2,0,0, +16,0,0,0,2,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +39,4,0,0,176,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,54,4,0,0,192,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +66,4,0,0,208,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,82,4,0,0,224,2,0,0, +0,1,0,0,0,0,0,0,96,4,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +132,4,0,0,224,3,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,102,102,95,109,97,116,114,105, +120,95,109,118,112,0,102,108,111,97,116,52,120,52,0,171, +3,0,3,0,4,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +194,2,0,0,102,102,95,109,97,116,114,105,120,95,109,118, +0,102,102,95,118,101,99,95,99,111,108,111,114,0,102,108, +111,97,116,52,0,171,171,171,1,0,3,0,1,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,118, +101,99,95,97,109,98,105,101,110,116,0,102,102,95,108,105, +103,104,116,95,99,111,108,111,114,0,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,112,111,115,0,171,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,97,116,116, +101,110,0,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,115,112,111,116,0,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,109, +97,116,95,100,105,102,102,117,115,101,0,102,102,95,109,97, +116,95,97,109,98,105,101,110,116,0,102,102,95,109,97,116, +95,115,112,101,99,0,102,102,95,109,97,116,95,101,109,105, +115,115,105,111,110,0,102,102,95,109,97,116,114,105,120,95, +116,101,120,0,3,0,3,0,4,0,4,0,4,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,194,2,0,0,102,102,95,102,111,103,95,118, +115,0,77,105,99,114,111,115,111,102,116,32,40,82,41,32, +72,76,83,76,32,83,104,97,100,101,114,32,67,111,109,112, +105,108,101,114,32,54,46,51,46,57,52,49,53,46,48,0, +76,70,83,48,76,0,0,0,1,0,0,0,8,0,0,0, +56,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,2,0,0,0, +255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0, +76,111,97,100,68,105,102,102,117,115,101,67,111,108,111,114, +0,171,171,171,76,73,66,70,172,6,0,0,68,88,66,67, +94,177,69,203,112,152,93,11,209,9,165,81,59,198,204,73, +1,0,0,0,172,6,0,0,6,0,0,0,56,0,0,0, +132,0,0,0,208,0,0,0,24,1,0,0,148,1,0,0, +88,6,0,0,65,111,110,57,68,0,0,0,68,0,0,0, +0,2,86,76,20,0,0,0,48,0,0,0,1,0,36,0, +0,0,48,0,0,0,48,0,0,0,36,0,0,0,48,0, +0,0,45,0,1,0,0,0,0,0,0,0,0,2,86,76, +1,0,0,2,0,0,15,224,0,0,228,160,255,255,0,0, +65,111,110,57,68,0,0,0,68,0,0,0,0,2,80,76, +20,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,0,0,45,0, +1,0,0,0,0,0,0,0,0,2,80,76,1,0,0,2, +0,0,15,224,0,0,228,160,255,255,0,0,83,72,68,82, +64,0,0,0,64,0,240,255,16,0,0,0,89,0,0,4, +70,142,32,0,0,0,0,0,46,0,0,0,101,0,0,3, +242,32,16,0,0,0,0,0,54,0,0,6,242,32,16,0, +0,0,0,0,70,142,32,0,0,0,0,0,45,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,2,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,188,4,0,0,1,0,0,0,108,0,0,0, +1,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +142,4,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,92,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,85,110,105,116,121,70,70,86,101,114,116,101, +120,0,171,171,92,0,0,0,14,0,0,0,132,0,0,0, +240,3,0,0,0,0,0,0,0,0,0,0,180,2,0,0, +0,0,0,0,64,0,0,0,0,0,0,0,204,2,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,240,2,0,0,64,0,0,0,64,0,0,0, +0,0,0,0,204,2,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,253,2,0,0, +128,0,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,56,3,0,0,144,0,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,71,3,0,0, +160,0,0,0,128,0,0,0,0,0,0,0,88,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,124,3,0,0,32,1,0,0,128,0,0,0, +0,0,0,0,140,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,176,3,0,0, +160,1,0,0,128,0,0,0,0,0,0,0,192,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,228,3,0,0,32,2,0,0,128,0,0,0, +0,0,0,0,244,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,24,4,0,0, +160,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,39,4,0,0,176,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,54,4,0,0, +192,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,66,4,0,0,208,2,0,0,16,0,0,0, +2,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,82,4,0,0, +224,2,0,0,0,1,0,0,0,0,0,0,96,4,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,132,4,0,0,224,3,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,102,102,95,109, +97,116,114,105,120,95,109,118,112,0,102,108,111,97,116,52, +120,52,0,171,3,0,3,0,4,0,4,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,194,2,0,0,102,102,95,109,97,116,114,105, +120,95,109,118,0,102,102,95,118,101,99,95,99,111,108,111, +114,0,102,108,111,97,116,52,0,171,171,171,1,0,3,0, +1,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,118,101,99,95,97,109,98,105,101,110,116,0,102, +102,95,108,105,103,104,116,95,99,111,108,111,114,0,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,112,111,115, +0,171,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,97,116,116,101,110,0,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,115,112,111,116,0,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,109,97,116,95,100,105,102,102,117,115,101,0,102, +102,95,109,97,116,95,97,109,98,105,101,110,116,0,102,102, +95,109,97,116,95,115,112,101,99,0,102,102,95,109,97,116, +95,101,109,105,115,115,105,111,110,0,102,102,95,109,97,116, +114,105,120,95,116,101,120,0,3,0,3,0,4,0,4,0, +4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,194,2,0,0,102,102,95,102, +111,103,95,118,115,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,76,0,0,0,1,0,0,0, +8,0,0,0,56,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,76,111,97,100,69,109,105,115,115,105,111,110, +67,111,108,111,114,0,171,171,76,73,66,70,164,7,0,0, +68,88,66,67,15,22,159,155,21,14,178,159,161,27,46,101, +18,246,102,242,1,0,0,0,164,7,0,0,6,0,0,0, +56,0,0,0,176,0,0,0,52,1,0,0,164,1,0,0, +32,2,0,0,228,6,0,0,65,111,110,57,112,0,0,0, +112,0,0,0,0,2,86,76,64,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,0,0,9,0,1,0,0,0,0,0,0,0, +0,2,86,76,31,0,0,2,5,0,0,128,0,0,15,144, +31,0,0,2,5,0,1,128,1,0,15,144,1,0,0,2, +0,0,7,128,1,0,228,144,4,0,0,4,0,0,7,224, +0,0,228,128,0,0,228,160,0,0,228,144,255,255,0,0, +65,111,110,57,124,0,0,0,124,0,0,0,0,2,80,76, +76,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,0,0,9,0, +1,0,0,0,0,0,0,0,0,2,80,76,31,0,0,2, +0,0,0,128,0,0,7,176,31,0,0,2,0,0,0,128, +1,0,7,176,1,0,0,2,0,0,7,128,1,0,228,176, +4,0,0,4,0,0,7,128,0,0,228,128,0,0,228,160, +0,0,228,176,1,0,0,2,0,0,7,224,0,0,228,128, +255,255,0,0,83,72,68,82,104,0,0,0,64,0,240,255, +26,0,0,0,89,0,0,4,70,142,32,0,0,0,0,0, +10,0,0,0,95,0,0,3,114,16,16,0,0,0,0,0, +95,0,0,3,114,16,16,0,1,0,0,0,101,0,0,3, +114,32,16,0,0,0,0,0,50,0,0,10,114,32,16,0, +0,0,0,0,70,18,16,0,1,0,0,0,70,130,32,0, +0,0,0,0,9,0,0,0,70,18,16,0,0,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,2,0,0,0, +0,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,188,4,0,0,1,0,0,0,108,0,0,0, +1,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +142,4,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,92,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,85,110,105,116,121,70,70,86,101,114,116,101, +120,0,171,171,92,0,0,0,14,0,0,0,132,0,0,0, +240,3,0,0,0,0,0,0,0,0,0,0,180,2,0,0, +0,0,0,0,64,0,0,0,0,0,0,0,204,2,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,240,2,0,0,64,0,0,0,64,0,0,0, +0,0,0,0,204,2,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,253,2,0,0, +128,0,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,56,3,0,0,144,0,0,0,16,0,0,0, +2,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,71,3,0,0, +160,0,0,0,128,0,0,0,0,0,0,0,88,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,124,3,0,0,32,1,0,0,128,0,0,0, +0,0,0,0,140,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,176,3,0,0, +160,1,0,0,128,0,0,0,0,0,0,0,192,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,228,3,0,0,32,2,0,0,128,0,0,0, +0,0,0,0,244,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,24,4,0,0, +160,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,39,4,0,0,176,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,54,4,0,0, +192,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,66,4,0,0,208,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,82,4,0,0, +224,2,0,0,0,1,0,0,0,0,0,0,96,4,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,132,4,0,0,224,3,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,102,102,95,109, +97,116,114,105,120,95,109,118,112,0,102,108,111,97,116,52, +120,52,0,171,3,0,3,0,4,0,4,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,194,2,0,0,102,102,95,109,97,116,114,105, +120,95,109,118,0,102,102,95,118,101,99,95,99,111,108,111, +114,0,102,108,111,97,116,52,0,171,171,171,1,0,3,0, +1,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,118,101,99,95,97,109,98,105,101,110,116,0,102, +102,95,108,105,103,104,116,95,99,111,108,111,114,0,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,112,111,115, +0,171,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,97,116,116,101,110,0,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,115,112,111,116,0,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,109,97,116,95,100,105,102,102,117,115,101,0,102, +102,95,109,97,116,95,97,109,98,105,101,110,116,0,102,102, +95,109,97,116,95,115,112,101,99,0,102,102,95,109,97,116, +95,101,109,105,115,115,105,111,110,0,102,102,95,109,97,116, +114,105,120,95,116,101,120,0,3,0,3,0,4,0,4,0, +4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,194,2,0,0,102,102,95,102, +111,103,95,118,115,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,184,0,0,0,3,0,0,0, +8,0,0,0,152,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,167,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,176,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,1,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,73,110,105,116,76,105,103,104,116,67,111,108, +111,114,0,101,109,105,115,115,105,111,110,0,97,109,98,105, +101,110,116,0,76,73,66,70,8,4,0,0,68,88,66,67, +217,57,65,149,73,15,7,156,48,31,51,6,237,141,183,152, +1,0,0,0,8,4,0,0,6,0,0,0,56,0,0,0, +156,0,0,0,0,1,0,0,108,1,0,0,232,1,0,0, +92,2,0,0,65,111,110,57,92,0,0,0,92,0,0,0, +0,2,86,76,56,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,86,76,31,0,0,2,5,0,4,128,4,0,15,144, +31,0,0,2,5,0,5,128,5,0,15,144,1,0,0,2, +0,0,7,224,5,0,228,144,1,0,0,2,1,0,7,224, +4,0,228,144,255,255,0,0,65,111,110,57,92,0,0,0, +92,0,0,0,0,2,80,76,56,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,80,76,31,0,0,2,0,0,0,128, +4,0,7,176,31,0,0,2,0,0,0,128,5,0,7,176, +1,0,0,2,0,0,7,224,5,0,228,176,1,0,0,2, +1,0,7,224,4,0,228,176,255,255,0,0,83,72,68,82, +100,0,0,0,64,0,240,255,25,0,0,0,95,0,0,3, +114,16,16,0,4,0,0,0,95,0,0,3,114,16,16,0, +5,0,0,0,101,0,0,3,114,32,16,0,0,0,0,0, +101,0,0,3,114,32,16,0,1,0,0,0,54,0,0,5, +114,32,16,0,0,0,0,0,70,18,16,0,5,0,0,0, +54,0,0,5,114,32,16,0,1,0,0,0,70,18,16,0, +4,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,108,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,60,0,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,77,105,99,114,111,115,111,102, +116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101, +114,32,67,111,109,112,105,108,101,114,32,54,46,51,46,57, +52,49,53,46,48,0,171,171,76,70,83,48,164,1,0,0, +7,0,0,0,8,0,0,0,88,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,106,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,118,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,128,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,136,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,149,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,3,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,159,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,5,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,67,111,109,112,117,116,101,83, +112,111,116,76,105,103,104,116,48,0,101,121,101,80,111,115, +105,116,105,111,110,0,101,121,101,78,111,114,109,97,108,0, +118,105,101,119,68,105,114,0,100,105,102,102,117,115,101,67, +111,108,111,114,0,115,112,101,99,67,111,108,111,114,0,97, +109,98,0,171,76,73,66,70,12,4,0,0,68,88,66,67, +168,113,54,160,157,176,131,165,153,237,223,53,171,61,110,8, +1,0,0,0,12,4,0,0,6,0,0,0,56,0,0,0, +156,0,0,0,0,1,0,0,108,1,0,0,232,1,0,0, +92,2,0,0,65,111,110,57,92,0,0,0,92,0,0,0, +0,2,86,76,56,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,86,76,31,0,0,2,5,0,4,128,4,0,15,144, +31,0,0,2,5,0,5,128,5,0,15,144,1,0,0,2, +0,0,7,224,5,0,228,144,1,0,0,2,1,0,7,224, +4,0,228,144,255,255,0,0,65,111,110,57,92,0,0,0, +92,0,0,0,0,2,80,76,56,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,80,76,31,0,0,2,0,0,0,128, +4,0,7,176,31,0,0,2,0,0,0,128,5,0,7,176, +1,0,0,2,0,0,7,224,5,0,228,176,1,0,0,2, +1,0,7,224,4,0,228,176,255,255,0,0,83,72,68,82, +100,0,0,0,64,0,240,255,25,0,0,0,95,0,0,3, +114,16,16,0,4,0,0,0,95,0,0,3,114,16,16,0, +5,0,0,0,101,0,0,3,114,32,16,0,0,0,0,0, +101,0,0,3,114,32,16,0,1,0,0,0,54,0,0,5, +114,32,16,0,0,0,0,0,70,18,16,0,5,0,0,0, +54,0,0,5,114,32,16,0,1,0,0,0,70,18,16,0, +4,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,108,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,60,0,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,77,105,99,114,111,115,111,102, +116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101, +114,32,67,111,109,112,105,108,101,114,32,54,46,51,46,57, +52,49,53,46,48,0,171,171,76,70,83,48,168,1,0,0, +7,0,0,0,8,0,0,0,88,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,110,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,122,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,132,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,140,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,153,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,3,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,163,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,5,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,67,111,109,112,117,116,101,83, +112,111,116,76,105,103,104,116,83,112,101,99,48,0,101,121, +101,80,111,115,105,116,105,111,110,0,101,121,101,78,111,114, +109,97,108,0,118,105,101,119,68,105,114,0,100,105,102,102, +117,115,101,67,111,108,111,114,0,115,112,101,99,67,111,108, +111,114,0,97,109,98,0,171,76,73,66,70,52,15,0,0, +68,88,66,67,19,20,51,10,247,197,70,16,164,41,109,237, +111,182,64,127,1,0,0,0,52,15,0,0,6,0,0,0, +56,0,0,0,156,2,0,0,248,4,0,0,72,8,0,0, +196,8,0,0,136,13,0,0,65,111,110,57,92,2,0,0, +92,2,0,0,0,2,86,76,8,2,0,0,84,0,0,0, +4,0,36,0,0,0,84,0,0,0,84,0,0,0,36,0, +0,0,84,0,0,0,10,0,1,0,0,0,0,0,0,0, +0,0,18,0,1,0,1,0,0,0,0,0,0,0,26,0, +1,0,2,0,0,0,0,0,0,0,34,0,1,0,3,0, +0,0,0,0,0,2,86,76,81,0,0,5,4,0,15,160, +0,0,128,63,0,0,0,0,0,0,0,0,0,0,0,0, +31,0,0,2,5,0,0,128,0,0,15,144,31,0,0,2, +5,0,1,128,1,0,15,144,31,0,0,2,5,0,3,128, +3,0,15,144,31,0,0,2,5,0,4,128,4,0,15,144, +31,0,0,2,5,0,5,128,5,0,15,144,5,0,0,3, +0,0,1,128,1,0,255,160,1,0,255,160,12,0,0,3, +0,0,1,128,0,0,0,129,0,0,0,128,4,0,0,4, +0,0,14,128,0,0,144,144,1,0,255,161,1,0,144,160, +8,0,0,3,1,0,1,128,0,0,249,128,0,0,249,128, +12,0,0,3,1,0,2,128,2,0,255,160,1,0,0,128, +5,0,0,3,0,0,1,128,0,0,0,128,1,0,85,128, +1,0,0,2,2,0,1,128,4,0,0,160,4,0,0,4, +1,0,2,128,2,0,170,160,1,0,0,128,2,0,0,128, +7,0,0,2,1,0,1,128,1,0,0,128,5,0,0,3, +0,0,14,128,0,0,228,128,1,0,0,128,6,0,0,2, +1,0,1,128,1,0,85,128,4,0,0,4,0,0,1,128, +0,0,0,128,1,0,0,129,1,0,0,128,8,0,0,3, +1,0,1,128,0,0,249,128,3,0,228,160,8,0,0,3, +0,0,2,128,1,0,228,144,0,0,249,128,11,0,0,3, +0,0,2,128,0,0,85,128,4,0,85,160,5,0,0,3, +0,0,14,128,0,0,85,128,3,0,144,144,5,0,0,3, +0,0,14,128,0,0,228,128,0,0,144,160,11,0,0,3, +1,0,1,128,1,0,0,128,4,0,85,160,2,0,0,3, +1,0,1,128,1,0,0,128,2,0,0,161,5,0,0,3, +1,0,1,128,1,0,0,128,2,0,85,160,11,0,0,3, +1,0,1,128,1,0,0,128,4,0,85,160,10,0,0,3, +1,0,1,128,1,0,0,128,4,0,0,160,5,0,0,3, +0,0,1,128,0,0,0,128,1,0,0,128,5,0,0,3, +0,0,7,128,0,0,0,128,0,0,249,128,10,0,0,3, +0,0,7,128,0,0,228,128,4,0,0,160,2,0,0,3, +0,0,7,224,0,0,228,128,5,0,228,144,1,0,0,2, +1,0,7,224,4,0,228,144,255,255,0,0,65,111,110,57, +84,2,0,0,84,2,0,0,0,2,80,76,0,2,0,0, +84,0,0,0,4,0,36,0,0,0,84,0,0,0,84,0, +0,0,36,0,0,0,84,0,0,0,10,0,1,0,0,0, +0,0,0,0,0,0,18,0,1,0,1,0,0,0,0,0, +0,0,26,0,1,0,2,0,0,0,0,0,0,0,34,0, +1,0,3,0,0,0,0,0,0,2,80,76,81,0,0,5, +4,0,15,160,0,0,128,63,0,0,0,128,0,0,128,191, +0,0,0,0,31,0,0,2,0,0,0,128,0,0,7,176, +31,0,0,2,0,0,0,128,1,0,7,176,31,0,0,2, +0,0,0,128,3,0,7,176,31,0,0,2,0,0,0,128, +4,0,7,176,31,0,0,2,0,0,0,128,5,0,7,176, +4,0,0,4,0,0,7,128,0,0,228,176,1,0,255,161, +1,0,228,160,8,0,0,3,0,0,8,128,0,0,228,128, +0,0,228,128,7,0,0,2,1,0,8,128,0,0,255,128, +5,0,0,3,0,0,7,128,0,0,228,128,1,0,255,128, +8,0,0,3,1,0,1,128,0,0,228,128,3,0,228,160, +8,0,0,3,0,0,1,128,1,0,228,176,0,0,228,128, +11,0,0,3,0,0,2,128,1,0,0,128,4,0,255,160, +2,0,0,3,0,0,2,128,0,0,85,128,2,0,0,161, +5,0,0,3,0,0,18,128,0,0,85,128,2,0,85,160, +1,0,0,2,1,0,1,128,4,0,0,160,4,0,0,4, +0,0,4,128,2,0,170,160,0,0,255,128,1,0,0,128, +2,0,0,3,0,0,8,128,0,0,255,129,2,0,255,160, +88,0,0,4,0,0,8,128,0,0,255,128,4,0,85,160, +4,0,170,160,6,0,0,2,0,0,4,128,0,0,170,128, +5,0,0,3,0,0,2,128,0,0,85,128,0,0,170,128, +5,0,0,3,0,0,4,128,1,0,255,160,1,0,255,160, +88,0,0,4,0,0,4,128,0,0,170,129,4,0,255,160, +0,0,255,128,88,0,0,4,0,0,2,128,0,0,170,128, +0,0,85,128,4,0,255,160,5,0,0,3,1,0,7,128, +0,0,0,128,3,0,228,176,5,0,0,3,1,0,7,128, +1,0,228,128,0,0,228,160,88,0,0,4,1,0,7,128, +0,0,0,128,1,0,228,128,4,0,255,160,5,0,0,3, +0,0,7,128,0,0,85,128,1,0,228,128,10,0,0,3, +1,0,7,128,0,0,228,128,4,0,0,160,2,0,0,3, +0,0,7,128,1,0,228,128,5,0,228,176,1,0,0,2, +0,0,7,224,0,0,228,128,1,0,0,2,1,0,7,224, +4,0,228,176,255,255,0,0,83,72,68,82,72,3,0,0, +64,0,240,255,210,0,0,0,89,0,0,4,70,142,32,0, +0,0,0,0,35,0,0,0,95,0,0,3,114,16,16,0, +0,0,0,0,95,0,0,3,114,16,16,0,1,0,0,0, +95,0,0,3,114,16,16,0,3,0,0,0,95,0,0,3, +114,16,16,0,4,0,0,0,95,0,0,3,114,16,16,0, +5,0,0,0,101,0,0,3,114,32,16,0,0,0,0,0, +101,0,0,3,114,32,16,0,1,0,0,0,104,0,0,2, +2,0,0,0,57,0,0,8,18,0,16,0,0,0,0,0, +58,128,32,0,0,0,0,0,18,0,0,0,1,64,0,0, +0,0,0,0,50,0,0,12,226,0,16,0,0,0,0,0, +6,25,16,128,65,0,0,0,0,0,0,0,246,143,32,0, +0,0,0,0,18,0,0,0,6,137,32,0,0,0,0,0, +18,0,0,0,16,0,0,7,18,0,16,0,1,0,0,0, +150,7,16,0,0,0,0,0,150,7,16,0,0,0,0,0, +49,0,0,8,34,0,16,0,1,0,0,0,58,128,32,0, +0,0,0,0,26,0,0,0,10,0,16,0,1,0,0,0, +1,0,0,7,18,0,16,0,0,0,0,0,10,0,16,0, +0,0,0,0,26,0,16,0,1,0,0,0,50,0,0,10, +34,0,16,0,1,0,0,0,42,128,32,0,0,0,0,0, +26,0,0,0,10,0,16,0,1,0,0,0,1,64,0,0, +0,0,128,63,68,0,0,5,18,0,16,0,1,0,0,0, +10,0,16,0,1,0,0,0,56,0,0,7,226,0,16,0, +0,0,0,0,86,14,16,0,0,0,0,0,6,0,16,0, +1,0,0,0,14,0,0,10,18,0,16,0,1,0,0,0, +2,64,0,0,0,0,128,63,0,0,128,63,0,0,128,63, +0,0,128,63,26,0,16,0,1,0,0,0,55,0,0,9, +18,0,16,0,0,0,0,0,10,0,16,0,0,0,0,0, +1,64,0,0,0,0,0,0,10,0,16,0,1,0,0,0, +16,0,0,8,18,0,16,0,1,0,0,0,150,7,16,0, +0,0,0,0,70,130,32,0,0,0,0,0,34,0,0,0, +16,0,0,7,34,0,16,0,0,0,0,0,70,18,16,0, +1,0,0,0,150,7,16,0,0,0,0,0,52,0,0,7, +34,0,16,0,0,0,0,0,26,0,16,0,0,0,0,0, +1,64,0,0,0,0,0,0,56,0,0,7,226,0,16,0, +0,0,0,0,86,5,16,0,0,0,0,0,6,25,16,0, +3,0,0,0,56,0,0,8,226,0,16,0,0,0,0,0, +86,14,16,0,0,0,0,0,6,137,32,0,0,0,0,0, +10,0,0,0,52,0,0,7,18,0,16,0,1,0,0,0, +10,0,16,0,1,0,0,0,1,64,0,0,0,0,0,0, +0,0,0,9,18,0,16,0,1,0,0,0,10,0,16,0, +1,0,0,0,10,128,32,128,65,0,0,0,0,0,0,0, +26,0,0,0,56,32,0,8,18,0,16,0,1,0,0,0, +10,0,16,0,1,0,0,0,26,128,32,0,0,0,0,0, +26,0,0,0,56,0,0,7,18,0,16,0,0,0,0,0, +10,0,16,0,0,0,0,0,10,0,16,0,1,0,0,0, +56,0,0,7,114,0,16,0,0,0,0,0,6,0,16,0, +0,0,0,0,150,7,16,0,0,0,0,0,51,0,0,10, +114,0,16,0,0,0,0,0,70,2,16,0,0,0,0,0, +2,64,0,0,0,0,128,63,0,0,128,63,0,0,128,63, +0,0,0,0,0,0,0,7,114,32,16,0,0,0,0,0, +70,2,16,0,0,0,0,0,70,18,16,0,5,0,0,0, +54,0,0,5,114,32,16,0,1,0,0,0,70,18,16,0, +4,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +24,0,0,0,2,0,0,0,0,0,0,0,7,0,0,0, +20,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,188,4,0,0,1,0,0,0, +108,0,0,0,1,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,142,4,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,85,110,105,116,121,70,70,86, +101,114,116,101,120,0,171,171,92,0,0,0,14,0,0,0, +132,0,0,0,240,3,0,0,0,0,0,0,0,0,0,0, +180,2,0,0,0,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,240,2,0,0,64,0,0,0, +64,0,0,0,0,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +253,2,0,0,128,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,56,3,0,0,144,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +71,3,0,0,160,0,0,0,128,0,0,0,2,0,0,0, +88,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,124,3,0,0,32,1,0,0, +128,0,0,0,2,0,0,0,140,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +176,3,0,0,160,1,0,0,128,0,0,0,2,0,0,0, +192,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,228,3,0,0,32,2,0,0, +128,0,0,0,2,0,0,0,244,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +24,4,0,0,160,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,39,4,0,0,176,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +54,4,0,0,192,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,66,4,0,0,208,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +82,4,0,0,224,2,0,0,0,1,0,0,0,0,0,0, +96,4,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,132,4,0,0,224,3,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +102,102,95,109,97,116,114,105,120,95,109,118,112,0,102,108, +111,97,116,52,120,52,0,171,3,0,3,0,4,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,194,2,0,0,102,102,95,109, +97,116,114,105,120,95,109,118,0,102,102,95,118,101,99,95, +99,111,108,111,114,0,102,108,111,97,116,52,0,171,171,171, +1,0,3,0,1,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,118,101,99,95,97,109,98,105,101, +110,116,0,102,102,95,108,105,103,104,116,95,99,111,108,111, +114,0,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,112,111,115,0,171,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,97,116,116,101,110,0,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,115,112,111,116,0,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,109,97,116,95,100,105,102,102,117, +115,101,0,102,102,95,109,97,116,95,97,109,98,105,101,110, +116,0,102,102,95,109,97,116,95,115,112,101,99,0,102,102, +95,109,97,116,95,101,109,105,115,115,105,111,110,0,102,102, +95,109,97,116,114,105,120,95,116,101,120,0,3,0,3,0, +4,0,4,0,4,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,194,2,0,0, +102,102,95,102,111,103,95,118,115,0,77,105,99,114,111,115, +111,102,116,32,40,82,41,32,72,76,83,76,32,83,104,97, +100,101,114,32,67,111,109,112,105,108,101,114,32,54,46,51, +46,57,52,49,53,46,48,0,76,70,83,48,164,1,0,0, +7,0,0,0,8,0,0,0,88,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,106,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,118,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,128,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,136,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,149,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,3,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,159,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,5,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,67,111,109,112,117,116,101,83, +112,111,116,76,105,103,104,116,49,0,101,121,101,80,111,115, +105,116,105,111,110,0,101,121,101,78,111,114,109,97,108,0, +118,105,101,119,68,105,114,0,100,105,102,102,117,115,101,67, +111,108,111,114,0,115,112,101,99,67,111,108,111,114,0,97, +109,98,0,171,76,73,66,70,236,17,0,0,68,88,66,67, +216,144,48,14,233,134,86,193,213,85,149,228,66,253,63,44, +1,0,0,0,236,17,0,0,6,0,0,0,56,0,0,0, +60,3,0,0,52,6,0,0,252,10,0,0,120,11,0,0, +60,16,0,0,65,111,110,57,252,2,0,0,252,2,0,0, +0,2,86,76,156,2,0,0,96,0,0,0,5,0,36,0, +0,0,96,0,0,0,96,0,0,0,36,0,0,0,96,0, +0,0,10,0,1,0,0,0,0,0,0,0,0,0,18,0, +1,0,1,0,0,0,0,0,0,0,26,0,1,0,2,0, +0,0,0,0,0,0,34,0,1,0,3,0,0,0,0,0, +0,0,44,0,1,0,4,0,0,0,0,0,0,2,86,76, +81,0,0,5,5,0,15,160,0,0,128,63,0,0,0,0, +0,0,0,0,0,0,0,0,31,0,0,2,5,0,0,128, +0,0,15,144,31,0,0,2,5,0,1,128,1,0,15,144, +31,0,0,2,5,0,2,128,2,0,15,144,31,0,0,2, +5,0,3,128,3,0,15,144,31,0,0,2,5,0,4,128, +4,0,15,144,31,0,0,2,5,0,5,128,5,0,15,144, +5,0,0,3,0,0,1,128,1,0,255,160,1,0,255,160, +12,0,0,3,0,0,1,128,0,0,0,129,0,0,0,128, +4,0,0,4,0,0,14,128,0,0,144,144,1,0,255,161, +1,0,144,160,8,0,0,3,1,0,1,128,0,0,249,128, +0,0,249,128,12,0,0,3,1,0,2,128,2,0,255,160, +1,0,0,128,5,0,0,3,0,0,1,128,0,0,0,128, +1,0,85,128,1,0,0,2,2,0,1,128,5,0,0,160, +4,0,0,4,1,0,2,128,2,0,170,160,1,0,0,128, +2,0,0,128,7,0,0,2,1,0,1,128,1,0,0,128, +6,0,0,2,1,0,2,128,1,0,85,128,4,0,0,4, +0,0,1,128,0,0,0,128,1,0,85,129,1,0,85,128, +5,0,0,3,1,0,14,128,0,0,228,128,1,0,0,128, +4,0,0,4,0,0,14,128,0,0,228,128,1,0,0,128, +2,0,144,144,36,0,0,2,2,0,7,128,0,0,249,128, +8,0,0,3,0,0,2,128,1,0,228,144,2,0,228,128, +11,0,0,3,0,0,2,128,0,0,85,128,5,0,85,160, +32,0,0,3,1,0,1,128,0,0,85,128,4,0,255,160, +10,0,0,3,0,0,2,128,1,0,0,128,5,0,0,160, +8,0,0,3,0,0,4,128,1,0,249,128,3,0,228,160, +8,0,0,3,0,0,8,128,1,0,228,144,1,0,249,128, +11,0,0,3,0,0,12,128,0,0,228,128,5,0,85,160, +2,0,0,3,0,0,4,128,0,0,170,128,2,0,0,161, +5,0,0,3,0,0,4,128,0,0,170,128,2,0,85,160, +11,0,0,3,0,0,4,128,0,0,170,128,5,0,85,160, +10,0,0,3,0,0,4,128,0,0,170,128,5,0,0,160, +5,0,0,3,0,0,1,128,0,0,170,128,0,0,0,128, +5,0,0,3,0,0,2,128,0,0,85,128,0,0,0,128, +5,0,0,3,1,0,7,128,0,0,85,128,0,0,228,160, +12,0,0,3,0,0,2,128,5,0,85,160,0,0,255,128, +5,0,0,3,2,0,7,128,0,0,255,128,3,0,228,144, +5,0,0,3,2,0,7,128,2,0,228,128,0,0,228,160, +5,0,0,3,0,0,13,128,0,0,0,128,2,0,148,128, +10,0,0,3,0,0,13,128,0,0,228,128,5,0,0,160, +2,0,0,3,0,0,7,224,0,0,248,128,5,0,228,144, +4,0,0,4,1,0,7,224,0,0,85,128,1,0,228,128, +4,0,228,144,255,255,0,0,65,111,110,57,240,2,0,0, +240,2,0,0,0,2,80,76,144,2,0,0,96,0,0,0, +5,0,36,0,0,0,96,0,0,0,96,0,0,0,36,0, +0,0,96,0,0,0,10,0,1,0,0,0,0,0,0,0, +0,0,18,0,1,0,1,0,0,0,0,0,0,0,26,0, +1,0,2,0,0,0,0,0,0,0,34,0,1,0,3,0, +0,0,0,0,0,0,44,0,1,0,4,0,0,0,0,0, +0,2,80,76,81,0,0,5,5,0,15,160,0,0,128,63, +0,0,0,128,0,0,128,191,0,0,0,0,31,0,0,2, +0,0,0,128,0,0,7,176,31,0,0,2,0,0,0,128, +1,0,7,176,31,0,0,2,0,0,0,128,2,0,7,176, +31,0,0,2,0,0,0,128,3,0,7,176,31,0,0,2, +0,0,0,128,4,0,7,176,31,0,0,2,0,0,0,128, +5,0,7,176,4,0,0,4,0,0,7,128,0,0,228,176, +1,0,255,161,1,0,228,160,8,0,0,3,0,0,8,128, +0,0,228,128,0,0,228,128,7,0,0,2,1,0,8,128, +0,0,255,128,5,0,0,3,1,0,7,128,0,0,228,128, +1,0,255,128,4,0,0,4,0,0,7,128,0,0,228,128, +1,0,255,128,2,0,228,176,36,0,0,2,2,0,7,128, +0,0,228,128,8,0,0,3,1,0,8,128,1,0,228,176, +2,0,228,128,11,0,0,3,0,0,1,128,1,0,255,128, +5,0,255,160,32,0,0,3,1,0,24,128,0,0,0,128, +4,0,255,160,8,0,0,3,0,0,1,128,1,0,228,128, +3,0,228,160,8,0,0,3,0,0,2,128,1,0,228,176, +1,0,228,128,11,0,0,3,1,0,1,128,0,0,85,128, +5,0,255,160,11,0,0,3,1,0,2,128,0,0,0,128, +5,0,255,160,2,0,0,3,0,0,1,128,1,0,85,128, +2,0,0,161,5,0,0,3,0,0,17,128,0,0,0,128, +2,0,85,160,1,0,0,2,2,0,1,128,5,0,0,160, +4,0,0,4,0,0,2,128,2,0,170,160,0,0,255,128, +2,0,0,128,2,0,0,3,0,0,4,128,0,0,255,129, +2,0,255,160,88,0,0,4,0,0,4,128,0,0,170,128, +5,0,85,160,5,0,170,160,6,0,0,2,0,0,2,128, +0,0,85,128,5,0,0,3,0,0,1,128,0,0,0,128, +0,0,85,128,5,0,0,3,0,0,2,128,1,0,255,160, +1,0,255,160,88,0,0,4,0,0,2,128,0,0,85,129, +5,0,255,160,0,0,170,128,88,0,0,4,0,0,1,128, +0,0,85,128,0,0,0,128,5,0,255,160,5,0,0,3, +0,0,14,128,1,0,0,128,3,0,27,176,5,0,0,3, +0,0,14,128,0,0,228,128,0,0,27,160,5,0,0,3, +0,0,14,128,0,0,0,128,0,0,228,128,5,0,0,3, +0,0,1,128,1,0,255,128,0,0,0,128,4,0,0,4, +1,0,14,128,0,0,0,128,0,0,27,160,4,0,27,176, +88,0,0,4,1,0,7,128,1,0,0,129,4,0,228,176, +1,0,27,128,1,0,0,2,1,0,7,224,1,0,228,128, +10,0,0,3,1,0,7,128,0,0,27,128,5,0,0,160, +2,0,0,3,0,0,7,128,1,0,228,128,5,0,228,176, +1,0,0,2,0,0,7,224,0,0,228,128,255,255,0,0, +83,72,68,82,192,4,0,0,64,0,240,255,48,1,0,0, +89,0,0,4,70,142,32,0,0,0,0,0,45,0,0,0, +95,0,0,3,114,16,16,0,0,0,0,0,95,0,0,3, +114,16,16,0,1,0,0,0,95,0,0,3,114,16,16,0, +2,0,0,0,95,0,0,3,114,16,16,0,3,0,0,0, +95,0,0,3,114,16,16,0,4,0,0,0,95,0,0,3, +114,16,16,0,5,0,0,0,101,0,0,3,114,32,16,0, +0,0,0,0,101,0,0,3,114,32,16,0,1,0,0,0, +104,0,0,2,2,0,0,0,57,0,0,8,18,0,16,0, +0,0,0,0,58,128,32,0,0,0,0,0,18,0,0,0, +1,64,0,0,0,0,0,0,50,0,0,12,226,0,16,0, +0,0,0,0,6,25,16,128,65,0,0,0,0,0,0,0, +246,143,32,0,0,0,0,0,18,0,0,0,6,137,32,0, +0,0,0,0,18,0,0,0,16,0,0,7,18,0,16,0, +1,0,0,0,150,7,16,0,0,0,0,0,150,7,16,0, +0,0,0,0,49,0,0,8,34,0,16,0,1,0,0,0, +58,128,32,0,0,0,0,0,26,0,0,0,10,0,16,0, +1,0,0,0,1,0,0,7,18,0,16,0,0,0,0,0, +10,0,16,0,0,0,0,0,26,0,16,0,1,0,0,0, +50,0,0,10,34,0,16,0,1,0,0,0,42,128,32,0, +0,0,0,0,26,0,0,0,10,0,16,0,1,0,0,0, +1,64,0,0,0,0,128,63,68,0,0,5,18,0,16,0, +1,0,0,0,10,0,16,0,1,0,0,0,14,0,0,10, +34,0,16,0,1,0,0,0,2,64,0,0,0,0,128,63, +0,0,128,63,0,0,128,63,0,0,128,63,26,0,16,0, +1,0,0,0,55,0,0,9,18,0,16,0,0,0,0,0, +10,0,16,0,0,0,0,0,1,64,0,0,0,0,0,0, +26,0,16,0,1,0,0,0,56,0,0,7,226,0,16,0, +1,0,0,0,86,14,16,0,0,0,0,0,6,0,16,0, +1,0,0,0,50,0,0,9,226,0,16,0,0,0,0,0, +86,14,16,0,0,0,0,0,6,0,16,0,1,0,0,0, +6,25,16,0,2,0,0,0,16,0,0,8,18,0,16,0, +1,0,0,0,150,7,16,0,1,0,0,0,70,130,32,0, +0,0,0,0,34,0,0,0,16,0,0,7,34,0,16,0, +1,0,0,0,70,18,16,0,1,0,0,0,150,7,16,0, +1,0,0,0,52,0,0,10,50,0,16,0,1,0,0,0, +70,0,16,0,1,0,0,0,2,64,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9, +18,0,16,0,1,0,0,0,10,0,16,0,1,0,0,0, +10,128,32,128,65,0,0,0,0,0,0,0,26,0,0,0, +56,32,0,8,18,0,16,0,1,0,0,0,10,0,16,0, +1,0,0,0,26,128,32,0,0,0,0,0,26,0,0,0, +56,0,0,7,18,0,16,0,0,0,0,0,10,0,16,0, +0,0,0,0,10,0,16,0,1,0,0,0,56,0,0,7, +210,0,16,0,1,0,0,0,86,5,16,0,1,0,0,0, +6,25,16,0,3,0,0,0,49,0,0,7,34,0,16,0, +1,0,0,0,1,64,0,0,0,0,0,0,26,0,16,0, +1,0,0,0,56,0,0,8,210,0,16,0,1,0,0,0, +6,14,16,0,1,0,0,0,6,137,32,0,0,0,0,0, +10,0,0,0,56,0,0,7,210,0,16,0,1,0,0,0, +6,0,16,0,0,0,0,0,6,14,16,0,1,0,0,0, +51,0,0,10,210,0,16,0,1,0,0,0,6,14,16,0, +1,0,0,0,2,64,0,0,0,0,128,63,0,0,0,0, +0,0,128,63,0,0,128,63,0,0,0,7,114,32,16,0, +0,0,0,0,134,3,16,0,1,0,0,0,70,18,16,0, +5,0,0,0,16,0,0,7,18,0,16,0,1,0,0,0, +150,7,16,0,0,0,0,0,150,7,16,0,0,0,0,0, +68,0,0,5,18,0,16,0,1,0,0,0,10,0,16,0, +1,0,0,0,56,0,0,7,226,0,16,0,0,0,0,0, +86,14,16,0,0,0,0,0,6,0,16,0,1,0,0,0, +16,0,0,7,34,0,16,0,0,0,0,0,70,18,16,0, +1,0,0,0,150,7,16,0,0,0,0,0,52,0,0,7, +34,0,16,0,0,0,0,0,26,0,16,0,0,0,0,0, +1,64,0,0,0,0,0,0,47,0,0,5,34,0,16,0, +0,0,0,0,26,0,16,0,0,0,0,0,56,0,0,8, +34,0,16,0,0,0,0,0,26,0,16,0,0,0,0,0, +58,128,32,0,0,0,0,0,44,0,0,0,25,0,0,5, +34,0,16,0,0,0,0,0,26,0,16,0,0,0,0,0, +51,0,0,7,34,0,16,0,0,0,0,0,26,0,16,0, +0,0,0,0,1,64,0,0,0,0,128,63,56,0,0,7, +18,0,16,0,0,0,0,0,26,0,16,0,0,0,0,0, +10,0,16,0,0,0,0,0,50,0,0,10,114,0,16,0, +0,0,0,0,6,0,16,0,0,0,0,0,70,130,32,0, +0,0,0,0,10,0,0,0,70,18,16,0,4,0,0,0, +55,0,0,9,114,32,16,0,1,0,0,0,86,5,16,0, +1,0,0,0,70,2,16,0,0,0,0,0,70,18,16,0, +4,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +36,0,0,0,2,0,0,0,0,0,0,0,8,0,0,0, +32,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,188,4,0,0,1,0,0,0, +108,0,0,0,1,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,142,4,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,85,110,105,116,121,70,70,86, +101,114,116,101,120,0,171,171,92,0,0,0,14,0,0,0, +132,0,0,0,240,3,0,0,0,0,0,0,0,0,0,0, +180,2,0,0,0,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,240,2,0,0,64,0,0,0, +64,0,0,0,0,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +253,2,0,0,128,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,56,3,0,0,144,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +71,3,0,0,160,0,0,0,128,0,0,0,2,0,0,0, +88,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,124,3,0,0,32,1,0,0, +128,0,0,0,2,0,0,0,140,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +176,3,0,0,160,1,0,0,128,0,0,0,2,0,0,0, +192,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,228,3,0,0,32,2,0,0, +128,0,0,0,2,0,0,0,244,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +24,4,0,0,160,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,39,4,0,0,176,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +54,4,0,0,192,2,0,0,16,0,0,0,2,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,66,4,0,0,208,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +82,4,0,0,224,2,0,0,0,1,0,0,0,0,0,0, +96,4,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,132,4,0,0,224,3,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +102,102,95,109,97,116,114,105,120,95,109,118,112,0,102,108, +111,97,116,52,120,52,0,171,3,0,3,0,4,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,194,2,0,0,102,102,95,109, +97,116,114,105,120,95,109,118,0,102,102,95,118,101,99,95, +99,111,108,111,114,0,102,108,111,97,116,52,0,171,171,171, +1,0,3,0,1,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,118,101,99,95,97,109,98,105,101, +110,116,0,102,102,95,108,105,103,104,116,95,99,111,108,111, +114,0,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,112,111,115,0,171,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,97,116,116,101,110,0,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,115,112,111,116,0,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,109,97,116,95,100,105,102,102,117, +115,101,0,102,102,95,109,97,116,95,97,109,98,105,101,110, +116,0,102,102,95,109,97,116,95,115,112,101,99,0,102,102, +95,109,97,116,95,101,109,105,115,115,105,111,110,0,102,102, +95,109,97,116,114,105,120,95,116,101,120,0,3,0,3,0, +4,0,4,0,4,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,194,2,0,0, +102,102,95,102,111,103,95,118,115,0,77,105,99,114,111,115, +111,102,116,32,40,82,41,32,72,76,83,76,32,83,104,97, +100,101,114,32,67,111,109,112,105,108,101,114,32,54,46,51, +46,57,52,49,53,46,48,0,76,70,83,48,168,1,0,0, +7,0,0,0,8,0,0,0,88,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,110,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,122,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,132,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,140,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,153,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,3,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,163,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,5,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,67,111,109,112,117,116,101,83, +112,111,116,76,105,103,104,116,83,112,101,99,49,0,101,121, +101,80,111,115,105,116,105,111,110,0,101,121,101,78,111,114, +109,97,108,0,118,105,101,119,68,105,114,0,100,105,102,102, +117,115,101,67,111,108,111,114,0,115,112,101,99,67,111,108, +111,114,0,97,109,98,0,171,76,73,66,70,8,19,0,0, +68,88,66,67,162,247,150,119,108,183,177,195,169,152,12,225, +187,188,175,22,1,0,0,0,8,19,0,0,6,0,0,0, +56,0,0,0,32,4,0,0,252,7,0,0,28,12,0,0, +152,12,0,0,92,17,0,0,65,111,110,57,224,3,0,0, +224,3,0,0,0,2,86,76,140,3,0,0,84,0,0,0, +4,0,36,0,0,0,84,0,0,0,84,0,0,0,36,0, +0,0,84,0,0,0,10,0,2,0,0,0,0,0,0,0, +0,0,18,0,2,0,2,0,0,0,0,0,0,0,26,0, +2,0,4,0,0,0,0,0,0,0,34,0,2,0,6,0, +0,0,0,0,0,2,86,76,81,0,0,5,8,0,15,160, +0,0,128,63,0,0,0,0,0,0,0,0,0,0,0,0, +31,0,0,2,5,0,0,128,0,0,15,144,31,0,0,2, +5,0,1,128,1,0,15,144,31,0,0,2,5,0,3,128, +3,0,15,144,31,0,0,2,5,0,4,128,4,0,15,144, +31,0,0,2,5,0,5,128,5,0,15,144,5,0,0,3, +0,0,1,128,2,0,255,160,2,0,255,160,12,0,0,3, +0,0,1,128,0,0,0,129,0,0,0,128,4,0,0,4, +0,0,14,128,0,0,144,144,2,0,255,161,2,0,144,160, +8,0,0,3,1,0,1,128,0,0,249,128,0,0,249,128, +12,0,0,3,1,0,2,128,4,0,255,160,1,0,0,128, +5,0,0,3,0,0,1,128,0,0,0,128,1,0,85,128, +1,0,0,2,2,0,1,128,8,0,0,160,4,0,0,4, +1,0,2,128,4,0,170,160,1,0,0,128,2,0,0,128, +7,0,0,2,1,0,1,128,1,0,0,128,5,0,0,3, +0,0,14,128,0,0,228,128,1,0,0,128,6,0,0,2, +1,0,1,128,1,0,85,128,4,0,0,4,0,0,1,128, +0,0,0,128,1,0,0,129,1,0,0,128,8,0,0,3, +1,0,1,128,0,0,249,128,6,0,228,160,8,0,0,3, +0,0,2,128,1,0,228,144,0,0,249,128,11,0,0,3, +0,0,2,128,0,0,85,128,8,0,85,160,5,0,0,3, +0,0,14,128,0,0,85,128,3,0,144,144,5,0,0,3, +0,0,14,128,0,0,228,128,0,0,144,160,11,0,0,3, +1,0,1,128,1,0,0,128,8,0,85,160,2,0,0,3, +1,0,1,128,1,0,0,128,4,0,0,161,5,0,0,3, +1,0,1,128,1,0,0,128,4,0,85,160,11,0,0,3, +1,0,1,128,1,0,0,128,8,0,85,160,10,0,0,3, +1,0,1,128,1,0,0,128,8,0,0,160,5,0,0,3, +0,0,1,128,0,0,0,128,1,0,0,128,5,0,0,3, +0,0,7,128,0,0,0,128,0,0,249,128,10,0,0,3, +0,0,7,128,0,0,228,128,8,0,0,160,2,0,0,3, +0,0,7,128,0,0,228,128,5,0,228,144,5,0,0,3, +0,0,8,128,3,0,255,160,3,0,255,160,12,0,0,3, +0,0,8,128,0,0,255,129,0,0,255,128,4,0,0,4, +1,0,7,128,0,0,228,144,3,0,255,161,3,0,228,160, +8,0,0,3,1,0,8,128,1,0,228,128,1,0,228,128, +12,0,0,3,2,0,2,128,5,0,255,160,1,0,255,128, +5,0,0,3,0,0,8,128,0,0,255,128,2,0,85,128, +4,0,0,4,2,0,1,128,5,0,170,160,1,0,255,128, +2,0,0,128,7,0,0,2,1,0,8,128,1,0,255,128, +5,0,0,3,1,0,7,128,1,0,255,128,1,0,228,128, +6,0,0,2,1,0,8,128,2,0,0,128,4,0,0,4, +0,0,8,128,0,0,255,128,1,0,255,129,1,0,255,128, +8,0,0,3,1,0,8,128,1,0,228,128,7,0,228,160, +8,0,0,3,1,0,1,128,1,0,228,144,1,0,228,128, +11,0,0,3,1,0,9,128,1,0,228,128,8,0,85,160, +5,0,0,3,1,0,7,128,1,0,0,128,3,0,228,144, +5,0,0,3,1,0,7,128,1,0,228,128,1,0,228,160, +2,0,0,3,1,0,8,128,1,0,255,128,5,0,0,161, +5,0,0,3,1,0,8,128,1,0,255,128,5,0,85,160, +11,0,0,3,1,0,8,128,1,0,255,128,8,0,85,160, +10,0,0,3,1,0,8,128,1,0,255,128,8,0,0,160, +5,0,0,3,0,0,8,128,0,0,255,128,1,0,255,128, +5,0,0,3,1,0,7,128,0,0,255,128,1,0,228,128, +10,0,0,3,1,0,7,128,1,0,228,128,8,0,0,160, +2,0,0,3,0,0,7,224,0,0,228,128,1,0,228,128, +1,0,0,2,1,0,7,224,4,0,228,144,255,255,0,0, +65,111,110,57,212,3,0,0,212,3,0,0,0,2,80,76, +128,3,0,0,84,0,0,0,4,0,36,0,0,0,84,0, +0,0,84,0,0,0,36,0,0,0,84,0,0,0,10,0, +2,0,0,0,0,0,0,0,0,0,18,0,2,0,2,0, +0,0,0,0,0,0,26,0,2,0,4,0,0,0,0,0, +0,0,34,0,2,0,6,0,0,0,0,0,0,2,80,76, +81,0,0,5,8,0,15,160,0,0,128,63,0,0,0,128, +0,0,128,191,0,0,0,0,31,0,0,2,0,0,0,128, +0,0,7,176,31,0,0,2,0,0,0,128,1,0,7,176, +31,0,0,2,0,0,0,128,3,0,7,176,31,0,0,2, +0,0,0,128,4,0,7,176,31,0,0,2,0,0,0,128, +5,0,7,176,4,0,0,4,0,0,7,128,0,0,228,176, +2,0,255,161,2,0,228,160,8,0,0,3,0,0,8,128, +0,0,228,128,0,0,228,128,7,0,0,2,1,0,8,128, +0,0,255,128,5,0,0,3,0,0,7,128,0,0,228,128, +1,0,255,128,8,0,0,3,1,0,1,128,0,0,228,128, +6,0,228,160,8,0,0,3,0,0,1,128,1,0,228,176, +0,0,228,128,11,0,0,3,0,0,2,128,1,0,0,128, +8,0,255,160,2,0,0,3,0,0,2,128,0,0,85,128, +4,0,0,161,5,0,0,3,0,0,18,128,0,0,85,128, +4,0,85,160,1,0,0,2,1,0,1,128,8,0,0,160, +4,0,0,4,0,0,4,128,4,0,170,160,0,0,255,128, +1,0,0,128,2,0,0,3,0,0,8,128,0,0,255,129, +4,0,255,160,88,0,0,4,0,0,8,128,0,0,255,128, +8,0,85,160,8,0,170,160,6,0,0,2,0,0,4,128, +0,0,170,128,5,0,0,3,0,0,2,128,0,0,85,128, +0,0,170,128,5,0,0,3,0,0,4,128,2,0,255,160, +2,0,255,160,88,0,0,4,0,0,4,128,0,0,170,129, +8,0,255,160,0,0,255,128,88,0,0,4,0,0,2,128, +0,0,170,128,0,0,85,128,8,0,255,160,5,0,0,3, +1,0,14,128,0,0,0,128,3,0,27,176,5,0,0,3, +1,0,14,128,1,0,228,128,0,0,27,160,88,0,0,4, +1,0,14,128,0,0,0,128,1,0,228,128,8,0,255,160, +5,0,0,3,0,0,7,128,0,0,85,128,1,0,27,128, +10,0,0,3,1,0,14,128,0,0,27,128,8,0,0,160, +2,0,0,3,0,0,7,128,1,0,27,128,5,0,228,176, +4,0,0,4,2,0,7,128,0,0,228,176,3,0,255,161, +3,0,228,160,8,0,0,3,0,0,8,128,2,0,228,128, +2,0,228,128,7,0,0,2,2,0,8,128,0,0,255,128, +5,0,0,3,2,0,7,128,2,0,255,128,2,0,228,128, +8,0,0,3,2,0,8,128,2,0,228,128,7,0,228,160, +8,0,0,3,1,0,2,128,1,0,228,176,2,0,228,128, +11,0,0,3,1,0,4,128,2,0,255,128,8,0,255,160, +2,0,0,3,1,0,4,128,1,0,170,128,5,0,0,161, +5,0,0,3,1,0,20,128,1,0,170,128,5,0,85,160, +4,0,0,4,1,0,1,128,5,0,170,160,0,0,255,128, +1,0,0,128,2,0,0,3,0,0,8,128,0,0,255,129, +5,0,255,160,88,0,0,4,0,0,8,128,0,0,255,128, +8,0,85,160,8,0,170,160,6,0,0,2,1,0,1,128, +1,0,0,128,5,0,0,3,1,0,1,128,1,0,170,128, +1,0,0,128,5,0,0,3,1,0,4,128,3,0,255,160, +3,0,255,160,88,0,0,4,0,0,8,128,1,0,170,129, +8,0,255,160,0,0,255,128,88,0,0,4,0,0,8,128, +0,0,255,128,1,0,0,128,8,0,255,160,5,0,0,3, +2,0,7,128,1,0,85,128,3,0,228,176,5,0,0,3, +2,0,7,128,2,0,228,128,1,0,228,160,88,0,0,4, +1,0,7,128,1,0,85,128,2,0,228,128,8,0,255,160, +5,0,0,3,1,0,7,128,0,0,255,128,1,0,228,128, +10,0,0,3,2,0,7,128,1,0,228,128,8,0,0,160, +2,0,0,3,0,0,7,128,0,0,228,128,2,0,228,128, +1,0,0,2,0,0,7,224,0,0,228,128,1,0,0,2, +1,0,7,224,4,0,228,176,255,255,0,0,83,72,68,82, +24,4,0,0,64,0,240,255,6,1,0,0,89,8,0,4, +70,142,32,0,0,0,0,0,37,0,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,95,0,0,3,114,16,16,0, +1,0,0,0,95,0,0,3,114,16,16,0,3,0,0,0, +95,0,0,3,114,16,16,0,4,0,0,0,95,0,0,3, +114,16,16,0,5,0,0,0,101,0,0,3,114,32,16,0, +0,0,0,0,101,0,0,3,114,32,16,0,1,0,0,0, +104,0,0,2,3,0,0,0,54,0,0,5,114,0,16,0, +0,0,0,0,70,18,16,0,5,0,0,0,54,0,0,5, +130,0,16,0,0,0,0,0,1,64,0,0,0,0,0,0, +48,0,0,1,33,0,0,7,18,0,16,0,1,0,0,0, +58,0,16,0,0,0,0,0,1,64,0,0,2,0,0,0, +3,0,4,3,10,0,16,0,1,0,0,0,50,0,0,16, +114,0,16,0,1,0,0,0,70,18,16,128,65,0,0,0, +0,0,0,0,246,143,32,6,0,0,0,0,18,0,0,0, +58,0,16,0,0,0,0,0,70,130,32,6,0,0,0,0, +18,0,0,0,58,0,16,0,0,0,0,0,16,0,0,7, +130,0,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +70,2,16,0,1,0,0,0,50,0,0,12,18,0,16,0, +2,0,0,0,42,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,58,0,16,0,1,0,0,0, +1,64,0,0,0,0,128,63,14,0,0,10,18,0,16,0, +2,0,0,0,2,64,0,0,0,0,128,63,0,0,128,63, +0,0,128,63,0,0,128,63,10,0,16,0,2,0,0,0, +57,0,0,10,34,0,16,0,2,0,0,0,1,64,0,0, +0,0,0,0,58,128,32,6,0,0,0,0,18,0,0,0, +58,0,16,0,0,0,0,0,49,0,0,10,66,0,16,0, +2,0,0,0,58,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,58,0,16,0,1,0,0,0, +1,0,0,7,34,0,16,0,2,0,0,0,42,0,16,0, +2,0,0,0,26,0,16,0,2,0,0,0,55,0,0,9, +18,0,16,0,2,0,0,0,26,0,16,0,2,0,0,0, +1,64,0,0,0,0,0,0,10,0,16,0,2,0,0,0, +68,0,0,5,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,56,0,0,7,114,0,16,0,1,0,0,0, +246,15,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +16,0,0,10,130,0,16,0,1,0,0,0,70,2,16,0, +1,0,0,0,70,130,32,6,0,0,0,0,34,0,0,0, +58,0,16,0,0,0,0,0,52,0,0,7,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,1,64,0,0, +0,0,0,0,0,0,0,11,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,10,128,32,134,65,0,0,0, +0,0,0,0,26,0,0,0,58,0,16,0,0,0,0,0, +56,32,0,10,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,26,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,56,0,0,7,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,10,0,16,0, +2,0,0,0,16,0,0,7,18,0,16,0,1,0,0,0, +70,18,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +52,0,0,7,18,0,16,0,1,0,0,0,10,0,16,0, +1,0,0,0,1,64,0,0,0,0,0,0,56,0,0,7, +114,0,16,0,1,0,0,0,6,0,16,0,1,0,0,0, +70,18,16,0,3,0,0,0,56,0,0,10,114,0,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,70,130,32,6, +0,0,0,0,10,0,0,0,58,0,16,0,0,0,0,0, +56,0,0,7,114,0,16,0,1,0,0,0,246,15,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,51,0,0,10, +114,0,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +2,64,0,0,0,0,128,63,0,0,128,63,0,0,128,63, +0,0,0,0,0,0,0,7,114,0,16,0,0,0,0,0, +70,2,16,0,0,0,0,0,70,2,16,0,1,0,0,0, +30,0,0,7,130,0,16,0,0,0,0,0,58,0,16,0, +0,0,0,0,1,64,0,0,1,0,0,0,22,0,0,1, +54,0,0,5,114,32,16,0,0,0,0,0,70,2,16,0, +0,0,0,0,54,0,0,5,114,32,16,0,1,0,0,0, +70,18,16,0,4,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,32,0,0,0,3,0,0,0,0,0,0,0, +7,0,0,0,20,0,0,0,2,0,0,0,1,0,0,0, +1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +4,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,188,4,0,0, +1,0,0,0,108,0,0,0,1,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,142,4,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,92,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,85,110,105,116, +121,70,70,86,101,114,116,101,120,0,171,171,92,0,0,0, +14,0,0,0,132,0,0,0,240,3,0,0,0,0,0,0, +0,0,0,0,180,2,0,0,0,0,0,0,64,0,0,0, +0,0,0,0,204,2,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,240,2,0,0, +64,0,0,0,64,0,0,0,0,0,0,0,204,2,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,253,2,0,0,128,0,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,56,3,0,0, +144,0,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,71,3,0,0,160,0,0,0,128,0,0,0, +2,0,0,0,88,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,124,3,0,0, +32,1,0,0,128,0,0,0,2,0,0,0,140,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,176,3,0,0,160,1,0,0,128,0,0,0, +2,0,0,0,192,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,228,3,0,0, +32,2,0,0,128,0,0,0,2,0,0,0,244,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,24,4,0,0,160,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,39,4,0,0, +176,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,54,4,0,0,192,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,66,4,0,0, +208,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,82,4,0,0,224,2,0,0,0,1,0,0, +0,0,0,0,96,4,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,132,4,0,0, +224,3,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,102,102,95,109,97,116,114,105,120,95,109,118, +112,0,102,108,111,97,116,52,120,52,0,171,3,0,3,0, +4,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,194,2,0,0, +102,102,95,109,97,116,114,105,120,95,109,118,0,102,102,95, +118,101,99,95,99,111,108,111,114,0,102,108,111,97,116,52, +0,171,171,171,1,0,3,0,1,0,4,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,118,101,99,95,97, +109,98,105,101,110,116,0,102,102,95,108,105,103,104,116,95, +99,111,108,111,114,0,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,112,111,115,0,171,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,97,116,116,101,110,0,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,115,112,111, +116,0,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,109,97,116,95,100, +105,102,102,117,115,101,0,102,102,95,109,97,116,95,97,109, +98,105,101,110,116,0,102,102,95,109,97,116,95,115,112,101, +99,0,102,102,95,109,97,116,95,101,109,105,115,115,105,111, +110,0,102,102,95,109,97,116,114,105,120,95,116,101,120,0, +3,0,3,0,4,0,4,0,4,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +194,2,0,0,102,102,95,102,111,103,95,118,115,0,77,105, +99,114,111,115,111,102,116,32,40,82,41,32,72,76,83,76, +32,83,104,97,100,101,114,32,67,111,109,112,105,108,101,114, +32,54,46,51,46,57,52,49,53,46,48,0,76,70,83,48, +164,1,0,0,7,0,0,0,8,0,0,0,88,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,2,0,0,0,255,255,255,255, +255,255,255,255,0,0,0,0,0,0,0,0,106,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,118,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,128,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,136,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,149,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,3,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,159,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,5,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,67,111,109,112, +117,116,101,83,112,111,116,76,105,103,104,116,50,0,101,121, +101,80,111,115,105,116,105,111,110,0,101,121,101,78,111,114, +109,97,108,0,118,105,101,119,68,105,114,0,100,105,102,102, +117,115,101,67,111,108,111,114,0,115,112,101,99,67,111,108, +111,114,0,97,109,98,0,171,76,73,66,70,80,16,0,0, +68,88,66,67,247,83,83,41,89,91,110,3,164,72,197,192, +107,184,230,166,1,0,0,0,80,16,0,0,5,0,0,0, +52,0,0,0,156,3,0,0,96,9,0,0,220,9,0,0, +160,14,0,0,65,111,110,57,96,3,0,0,96,3,0,0, +0,2,86,76,48,3,0,0,48,0,0,0,1,0,36,0, +0,0,48,0,0,0,48,0,0,0,36,0,0,0,48,0, +0,0,0,0,45,0,0,0,0,0,0,0,0,2,86,76, +81,0,0,5,45,0,15,160,0,0,0,0,0,0,0,0, +0,0,128,63,0,0,0,0,48,0,0,5,0,0,15,240, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +31,0,0,2,5,0,0,128,0,0,15,144,31,0,0,2, +5,0,1,128,1,0,15,144,31,0,0,2,5,0,2,128, +2,0,15,144,31,0,0,2,5,0,3,128,3,0,15,144, +31,0,0,2,5,0,4,128,4,0,15,144,31,0,0,2, +5,0,5,128,5,0,15,144,1,0,0,2,0,0,7,128, +4,0,228,144,1,0,0,2,1,0,7,128,5,0,228,144, +27,0,0,2,0,8,228,240,0,0,228,240,4,0,0,6, +2,0,7,128,0,0,228,144,18,32,255,161,0,8,228,240, +18,32,228,160,0,8,228,240,8,0,0,3,0,0,8,128, +2,0,228,128,2,0,228,128,7,0,0,2,1,0,8,128, +0,0,255,128,4,0,0,4,3,0,7,128,2,0,228,128, +1,0,255,128,2,0,228,144,36,0,0,2,4,0,7,128, +3,0,228,128,8,0,0,3,2,0,8,128,1,0,228,144, +4,0,228,128,5,0,0,5,3,0,1,128,18,32,255,160, +0,8,228,240,18,32,255,160,0,8,228,240,12,0,0,3, +3,0,1,128,3,0,0,129,3,0,0,128,12,0,0,4, +3,0,2,128,26,32,255,160,0,8,228,240,0,0,255,128, +5,0,0,3,3,0,1,128,3,0,85,128,3,0,0,128, +5,0,0,4,0,0,8,128,0,0,255,128,26,32,170,160, +0,8,228,240,2,0,0,3,0,0,8,128,0,0,255,128, +45,0,170,160,6,0,0,2,0,0,8,128,0,0,255,128, +4,0,0,4,0,0,8,128,3,0,0,128,0,0,255,129, +0,0,255,128,11,0,0,3,2,0,8,128,2,0,255,128, +45,0,85,160,32,0,0,3,3,0,1,128,2,0,255,128, +44,0,255,160,10,0,0,3,2,0,8,128,3,0,0,128, +45,0,170,160,5,0,0,3,2,0,7,128,1,0,255,128, +2,0,228,128,8,0,0,3,1,0,8,128,1,0,228,144, +2,0,228,128,8,0,0,4,2,0,1,128,2,0,228,128, +34,32,228,160,0,8,228,240,11,0,0,3,2,0,1,128, +2,0,0,128,45,0,85,160,2,0,0,4,2,0,1,128, +2,0,0,128,26,32,0,161,0,8,228,240,5,0,0,4, +2,0,1,128,2,0,0,128,26,32,85,160,0,8,228,240, +11,0,0,3,2,0,1,128,2,0,0,128,45,0,85,160, +10,0,0,3,2,0,1,128,2,0,0,128,45,0,170,160, +5,0,0,3,0,0,8,128,0,0,255,128,2,0,0,128, +11,0,0,3,1,0,8,128,1,0,255,128,45,0,85,160, +12,0,0,3,2,0,1,128,45,0,85,160,1,0,255,128, +5,0,0,3,2,0,2,128,2,0,255,128,0,0,255,128, +5,0,0,4,2,0,14,128,2,0,85,128,10,32,144,160, +0,8,228,240,4,0,0,4,0,0,7,128,2,0,0,128, +2,0,249,128,0,0,228,128,5,0,0,3,2,0,7,128, +1,0,255,128,3,0,228,144,5,0,0,4,2,0,7,128, +2,0,228,128,10,32,228,160,0,8,228,240,5,0,0,3, +2,0,7,128,0,0,255,128,2,0,228,128,10,0,0,3, +2,0,7,128,2,0,228,128,45,0,170,160,2,0,0,3, +1,0,7,128,1,0,228,128,2,0,228,128,29,0,0,0, +1,0,0,2,1,0,7,224,0,0,228,128,1,0,0,2, +0,0,7,224,1,0,228,128,255,255,0,0,83,72,68,82, +188,5,0,0,64,0,240,255,111,1,0,0,89,8,0,4, +70,142,32,0,0,0,0,0,45,0,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,95,0,0,3,114,16,16,0, +1,0,0,0,95,0,0,3,114,16,16,0,2,0,0,0, +95,0,0,3,114,16,16,0,3,0,0,0,95,0,0,3, +114,16,16,0,4,0,0,0,95,0,0,3,114,16,16,0, +5,0,0,0,101,0,0,3,114,32,16,0,0,0,0,0, +101,0,0,3,114,32,16,0,1,0,0,0,104,0,0,2, +4,0,0,0,54,0,0,5,114,0,16,0,0,0,0,0, +70,18,16,0,4,0,0,0,54,0,0,5,114,0,16,0, +1,0,0,0,70,18,16,0,5,0,0,0,54,0,0,5, +130,0,16,0,0,0,0,0,1,64,0,0,0,0,0,0, +48,0,0,1,33,0,0,7,130,0,16,0,1,0,0,0, +58,0,16,0,0,0,0,0,1,64,0,0,2,0,0,0, +3,0,4,3,58,0,16,0,1,0,0,0,50,0,0,16, +114,0,16,0,2,0,0,0,70,18,16,128,65,0,0,0, +0,0,0,0,246,143,32,6,0,0,0,0,18,0,0,0, +58,0,16,0,0,0,0,0,70,130,32,6,0,0,0,0, +18,0,0,0,58,0,16,0,0,0,0,0,16,0,0,7, +130,0,16,0,1,0,0,0,70,2,16,0,2,0,0,0, +70,2,16,0,2,0,0,0,50,0,0,12,130,0,16,0, +2,0,0,0,42,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,58,0,16,0,1,0,0,0, +1,64,0,0,0,0,128,63,14,0,0,10,130,0,16,0, +2,0,0,0,2,64,0,0,0,0,128,63,0,0,128,63, +0,0,128,63,0,0,128,63,58,0,16,0,2,0,0,0, +57,0,0,10,18,0,16,0,3,0,0,0,1,64,0,0, +0,0,0,0,58,128,32,6,0,0,0,0,18,0,0,0, +58,0,16,0,0,0,0,0,49,0,0,10,34,0,16,0, +3,0,0,0,58,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,58,0,16,0,1,0,0,0, +1,0,0,7,18,0,16,0,3,0,0,0,26,0,16,0, +3,0,0,0,10,0,16,0,3,0,0,0,55,0,0,9, +130,0,16,0,2,0,0,0,10,0,16,0,3,0,0,0, +1,64,0,0,0,0,0,0,58,0,16,0,2,0,0,0, +68,0,0,5,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,56,0,0,7,114,0,16,0,3,0,0,0, +246,15,16,0,1,0,0,0,70,2,16,0,2,0,0,0, +16,0,0,10,130,0,16,0,3,0,0,0,70,2,16,0, +3,0,0,0,70,130,32,6,0,0,0,0,34,0,0,0, +58,0,16,0,0,0,0,0,52,0,0,7,130,0,16,0, +3,0,0,0,58,0,16,0,3,0,0,0,1,64,0,0, +0,0,0,0,0,0,0,11,130,0,16,0,3,0,0,0, +58,0,16,0,3,0,0,0,10,128,32,134,65,0,0,0, +0,0,0,0,26,0,0,0,58,0,16,0,0,0,0,0, +56,32,0,10,130,0,16,0,3,0,0,0,58,0,16,0, +3,0,0,0,26,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,56,0,0,7,130,0,16,0, +2,0,0,0,58,0,16,0,2,0,0,0,58,0,16,0, +3,0,0,0,16,0,0,7,18,0,16,0,3,0,0,0, +70,18,16,0,1,0,0,0,70,2,16,0,3,0,0,0, +52,0,0,7,18,0,16,0,3,0,0,0,10,0,16,0, +3,0,0,0,1,64,0,0,0,0,0,0,56,0,0,7, +226,0,16,0,3,0,0,0,6,0,16,0,3,0,0,0, +6,25,16,0,3,0,0,0,56,0,0,10,226,0,16,0, +3,0,0,0,86,14,16,0,3,0,0,0,6,137,32,6, +0,0,0,0,10,0,0,0,58,0,16,0,0,0,0,0, +49,0,0,7,18,0,16,0,3,0,0,0,1,64,0,0, +0,0,0,0,10,0,16,0,3,0,0,0,31,0,4,3, +10,0,16,0,3,0,0,0,50,0,0,9,114,0,16,0, +2,0,0,0,70,2,16,0,2,0,0,0,246,15,16,0, +1,0,0,0,70,18,16,0,2,0,0,0,16,0,0,7, +130,0,16,0,1,0,0,0,70,2,16,0,2,0,0,0, +70,2,16,0,2,0,0,0,68,0,0,5,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,56,0,0,7, +114,0,16,0,2,0,0,0,246,15,16,0,1,0,0,0, +70,2,16,0,2,0,0,0,16,0,0,7,130,0,16,0, +1,0,0,0,70,18,16,0,1,0,0,0,70,2,16,0, +2,0,0,0,52,0,0,7,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,1,64,0,0,0,0,0,0, +47,0,0,5,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,56,0,0,8,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,58,128,32,0,0,0,0,0, +44,0,0,0,25,0,0,5,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,51,0,0,7,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,1,64,0,0, +0,0,128,63,56,0,0,7,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,58,0,16,0,2,0,0,0, +50,0,0,12,114,0,16,0,0,0,0,0,246,15,16,0, +1,0,0,0,70,130,32,6,0,0,0,0,10,0,0,0, +58,0,16,0,0,0,0,0,70,2,16,0,0,0,0,0, +21,0,0,1,56,0,0,7,114,0,16,0,2,0,0,0, +246,15,16,0,2,0,0,0,150,7,16,0,3,0,0,0, +51,0,0,10,114,0,16,0,2,0,0,0,70,2,16,0, +2,0,0,0,2,64,0,0,0,0,128,63,0,0,128,63, +0,0,128,63,0,0,0,0,0,0,0,7,114,0,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,70,2,16,0, +2,0,0,0,30,0,0,7,130,0,16,0,0,0,0,0, +58,0,16,0,0,0,0,0,1,64,0,0,1,0,0,0, +22,0,0,1,54,0,0,5,114,32,16,0,1,0,0,0, +70,2,16,0,0,0,0,0,54,0,0,5,114,32,16,0, +0,0,0,0,70,2,16,0,1,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,48,0,0,0,4,0,0,0, +0,0,0,0,8,0,0,0,33,0,0,0,2,0,0,0, +1,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,5,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +188,4,0,0,1,0,0,0,108,0,0,0,1,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,142,4,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +85,110,105,116,121,70,70,86,101,114,116,101,120,0,171,171, +92,0,0,0,14,0,0,0,132,0,0,0,240,3,0,0, +0,0,0,0,0,0,0,0,180,2,0,0,0,0,0,0, +64,0,0,0,0,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +240,2,0,0,64,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,253,2,0,0,128,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +56,3,0,0,144,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,71,3,0,0,160,0,0,0, +128,0,0,0,2,0,0,0,88,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +124,3,0,0,32,1,0,0,128,0,0,0,2,0,0,0, +140,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,176,3,0,0,160,1,0,0, +128,0,0,0,2,0,0,0,192,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +228,3,0,0,32,2,0,0,128,0,0,0,2,0,0,0, +244,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,24,4,0,0,160,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +39,4,0,0,176,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,54,4,0,0,192,2,0,0, +16,0,0,0,2,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +66,4,0,0,208,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,82,4,0,0,224,2,0,0, +0,1,0,0,0,0,0,0,96,4,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +132,4,0,0,224,3,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,102,102,95,109,97,116,114,105, +120,95,109,118,112,0,102,108,111,97,116,52,120,52,0,171, +3,0,3,0,4,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +194,2,0,0,102,102,95,109,97,116,114,105,120,95,109,118, +0,102,102,95,118,101,99,95,99,111,108,111,114,0,102,108, +111,97,116,52,0,171,171,171,1,0,3,0,1,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,118, +101,99,95,97,109,98,105,101,110,116,0,102,102,95,108,105, +103,104,116,95,99,111,108,111,114,0,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,112,111,115,0,171,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,97,116,116, +101,110,0,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,115,112,111,116,0,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,109, +97,116,95,100,105,102,102,117,115,101,0,102,102,95,109,97, +116,95,97,109,98,105,101,110,116,0,102,102,95,109,97,116, +95,115,112,101,99,0,102,102,95,109,97,116,95,101,109,105, +115,115,105,111,110,0,102,102,95,109,97,116,114,105,120,95, +116,101,120,0,3,0,3,0,4,0,4,0,4,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,194,2,0,0,102,102,95,102,111,103,95,118, +115,0,77,105,99,114,111,115,111,102,116,32,40,82,41,32, +72,76,83,76,32,83,104,97,100,101,114,32,67,111,109,112, +105,108,101,114,32,54,46,51,46,57,52,49,53,46,48,0, +76,70,83,48,168,1,0,0,7,0,0,0,8,0,0,0, +88,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,2,0,0,0, +255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0, +110,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +122,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,1,0,0,0, +1,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +132,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,1,0,0,0, +2,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +140,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +153,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,3,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +163,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,1,0,0,0, +5,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +67,111,109,112,117,116,101,83,112,111,116,76,105,103,104,116, +83,112,101,99,50,0,101,121,101,80,111,115,105,116,105,111, +110,0,101,121,101,78,111,114,109,97,108,0,118,105,101,119, +68,105,114,0,100,105,102,102,117,115,101,67,111,108,111,114, +0,115,112,101,99,67,111,108,111,114,0,97,109,98,0,171, +76,73,66,70,172,16,0,0,68,88,66,67,196,226,164,1, +85,73,127,248,194,26,134,144,141,122,227,103,1,0,0,0, +172,16,0,0,5,0,0,0,52,0,0,0,160,5,0,0, +192,9,0,0,60,10,0,0,0,15,0,0,65,111,110,57, +100,5,0,0,100,5,0,0,0,2,86,76,16,5,0,0, +84,0,0,0,4,0,36,0,0,0,84,0,0,0,84,0, +0,0,36,0,0,0,84,0,0,0,10,0,3,0,0,0, +0,0,0,0,0,0,18,0,3,0,3,0,0,0,0,0, +0,0,26,0,3,0,6,0,0,0,0,0,0,0,34,0, +3,0,9,0,0,0,0,0,0,2,86,76,81,0,0,5, +12,0,15,160,0,0,128,63,0,0,0,0,0,0,0,0, +0,0,0,0,31,0,0,2,5,0,0,128,0,0,15,144, +31,0,0,2,5,0,1,128,1,0,15,144,31,0,0,2, +5,0,3,128,3,0,15,144,31,0,0,2,5,0,4,128, +4,0,15,144,31,0,0,2,5,0,5,128,5,0,15,144, +5,0,0,3,0,0,1,128,3,0,255,160,3,0,255,160, +12,0,0,3,0,0,1,128,0,0,0,129,0,0,0,128, +4,0,0,4,0,0,14,128,0,0,144,144,3,0,255,161, +3,0,144,160,8,0,0,3,1,0,1,128,0,0,249,128, +0,0,249,128,12,0,0,3,1,0,2,128,6,0,255,160, +1,0,0,128,5,0,0,3,0,0,1,128,0,0,0,128, +1,0,85,128,1,0,0,2,2,0,1,128,12,0,0,160, +4,0,0,4,1,0,2,128,6,0,170,160,1,0,0,128, +2,0,0,128,7,0,0,2,1,0,1,128,1,0,0,128, +5,0,0,3,0,0,14,128,0,0,228,128,1,0,0,128, +6,0,0,2,1,0,1,128,1,0,85,128,4,0,0,4, +0,0,1,128,0,0,0,128,1,0,0,129,1,0,0,128, +8,0,0,3,1,0,1,128,0,0,249,128,9,0,228,160, +8,0,0,3,0,0,2,128,1,0,228,144,0,0,249,128, +11,0,0,3,0,0,2,128,0,0,85,128,12,0,85,160, +5,0,0,3,0,0,14,128,0,0,85,128,3,0,144,144, +5,0,0,3,0,0,14,128,0,0,228,128,0,0,144,160, +11,0,0,3,1,0,1,128,1,0,0,128,12,0,85,160, +2,0,0,3,1,0,1,128,1,0,0,128,6,0,0,161, +5,0,0,3,1,0,1,128,1,0,0,128,6,0,85,160, +11,0,0,3,1,0,1,128,1,0,0,128,12,0,85,160, +10,0,0,3,1,0,1,128,1,0,0,128,12,0,0,160, +5,0,0,3,0,0,1,128,0,0,0,128,1,0,0,128, +5,0,0,3,0,0,7,128,0,0,0,128,0,0,249,128, +10,0,0,3,0,0,7,128,0,0,228,128,12,0,0,160, +2,0,0,3,0,0,7,128,0,0,228,128,5,0,228,144, +5,0,0,3,0,0,8,128,4,0,255,160,4,0,255,160, +12,0,0,3,0,0,8,128,0,0,255,129,0,0,255,128, +4,0,0,4,1,0,7,128,0,0,228,144,4,0,255,161, +4,0,228,160,8,0,0,3,1,0,8,128,1,0,228,128, +1,0,228,128,12,0,0,3,2,0,2,128,7,0,255,160, +1,0,255,128,5,0,0,3,0,0,8,128,0,0,255,128, +2,0,85,128,4,0,0,4,2,0,2,128,7,0,170,160, +1,0,255,128,2,0,0,128,7,0,0,2,1,0,8,128, +1,0,255,128,5,0,0,3,1,0,7,128,1,0,255,128, +1,0,228,128,6,0,0,2,1,0,8,128,2,0,85,128, +4,0,0,4,0,0,8,128,0,0,255,128,1,0,255,129, +1,0,255,128,8,0,0,3,1,0,8,128,1,0,228,128, +10,0,228,160,8,0,0,3,1,0,1,128,1,0,228,144, +1,0,228,128,11,0,0,3,1,0,9,128,1,0,228,128, +12,0,85,160,5,0,0,3,1,0,7,128,1,0,0,128, +3,0,228,144,5,0,0,3,1,0,7,128,1,0,228,128, +1,0,228,160,2,0,0,3,1,0,8,128,1,0,255,128, +7,0,0,161,5,0,0,3,1,0,8,128,1,0,255,128, +7,0,85,160,11,0,0,3,1,0,8,128,1,0,255,128, +12,0,85,160,10,0,0,3,1,0,8,128,1,0,255,128, +12,0,0,160,5,0,0,3,0,0,8,128,0,0,255,128, +1,0,255,128,5,0,0,3,1,0,7,128,0,0,255,128, +1,0,228,128,10,0,0,3,1,0,7,128,1,0,228,128, +12,0,0,160,2,0,0,3,0,0,7,128,0,0,228,128, +1,0,228,128,5,0,0,3,0,0,8,128,5,0,255,160, +5,0,255,160,12,0,0,3,0,0,8,128,0,0,255,129, +0,0,255,128,4,0,0,4,1,0,7,128,0,0,228,144, +5,0,255,161,5,0,228,160,8,0,0,3,1,0,8,128, +1,0,228,128,1,0,228,128,12,0,0,3,2,0,2,128, +8,0,255,160,1,0,255,128,5,0,0,3,0,0,8,128, +0,0,255,128,2,0,85,128,4,0,0,4,2,0,1,128, +8,0,170,160,1,0,255,128,2,0,0,128,7,0,0,2, +1,0,8,128,1,0,255,128,5,0,0,3,1,0,7,128, +1,0,255,128,1,0,228,128,6,0,0,2,1,0,8,128, +2,0,0,128,4,0,0,4,0,0,8,128,0,0,255,128, +1,0,255,129,1,0,255,128,8,0,0,3,1,0,8,128, +1,0,228,128,11,0,228,160,8,0,0,3,1,0,1,128, +1,0,228,144,1,0,228,128,11,0,0,3,1,0,9,128, +1,0,228,128,12,0,85,160,5,0,0,3,1,0,7,128, +1,0,0,128,3,0,228,144,5,0,0,3,1,0,7,128, +1,0,228,128,2,0,228,160,2,0,0,3,1,0,8,128, +1,0,255,128,8,0,0,161,5,0,0,3,1,0,8,128, +1,0,255,128,8,0,85,160,11,0,0,3,1,0,8,128, +1,0,255,128,12,0,85,160,10,0,0,3,1,0,8,128, +1,0,255,128,12,0,0,160,5,0,0,3,0,0,8,128, +0,0,255,128,1,0,255,128,5,0,0,3,1,0,7,128, +0,0,255,128,1,0,228,128,10,0,0,3,1,0,7,128, +1,0,228,128,12,0,0,160,2,0,0,3,0,0,7,224, +0,0,228,128,1,0,228,128,1,0,0,2,1,0,7,224, +4,0,228,144,255,255,0,0,83,72,68,82,24,4,0,0, +64,0,240,255,6,1,0,0,89,8,0,4,70,142,32,0, +0,0,0,0,38,0,0,0,95,0,0,3,114,16,16,0, +0,0,0,0,95,0,0,3,114,16,16,0,1,0,0,0, +95,0,0,3,114,16,16,0,3,0,0,0,95,0,0,3, +114,16,16,0,4,0,0,0,95,0,0,3,114,16,16,0, +5,0,0,0,101,0,0,3,114,32,16,0,0,0,0,0, +101,0,0,3,114,32,16,0,1,0,0,0,104,0,0,2, +3,0,0,0,54,0,0,5,114,0,16,0,0,0,0,0, +70,18,16,0,5,0,0,0,54,0,0,5,130,0,16,0, +0,0,0,0,1,64,0,0,0,0,0,0,48,0,0,1, +33,0,0,7,18,0,16,0,1,0,0,0,58,0,16,0, +0,0,0,0,1,64,0,0,3,0,0,0,3,0,4,3, +10,0,16,0,1,0,0,0,50,0,0,16,114,0,16,0, +1,0,0,0,70,18,16,128,65,0,0,0,0,0,0,0, +246,143,32,6,0,0,0,0,18,0,0,0,58,0,16,0, +0,0,0,0,70,130,32,6,0,0,0,0,18,0,0,0, +58,0,16,0,0,0,0,0,16,0,0,7,130,0,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,70,2,16,0, +1,0,0,0,50,0,0,12,18,0,16,0,2,0,0,0, +42,128,32,6,0,0,0,0,26,0,0,0,58,0,16,0, +0,0,0,0,58,0,16,0,1,0,0,0,1,64,0,0, +0,0,128,63,14,0,0,10,18,0,16,0,2,0,0,0, +2,64,0,0,0,0,128,63,0,0,128,63,0,0,128,63, +0,0,128,63,10,0,16,0,2,0,0,0,57,0,0,10, +34,0,16,0,2,0,0,0,1,64,0,0,0,0,0,0, +58,128,32,6,0,0,0,0,18,0,0,0,58,0,16,0, +0,0,0,0,49,0,0,10,66,0,16,0,2,0,0,0, +58,128,32,6,0,0,0,0,26,0,0,0,58,0,16,0, +0,0,0,0,58,0,16,0,1,0,0,0,1,0,0,7, +34,0,16,0,2,0,0,0,42,0,16,0,2,0,0,0, +26,0,16,0,2,0,0,0,55,0,0,9,18,0,16,0, +2,0,0,0,26,0,16,0,2,0,0,0,1,64,0,0, +0,0,0,0,10,0,16,0,2,0,0,0,68,0,0,5, +130,0,16,0,1,0,0,0,58,0,16,0,1,0,0,0, +56,0,0,7,114,0,16,0,1,0,0,0,246,15,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,16,0,0,10, +130,0,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +70,130,32,6,0,0,0,0,34,0,0,0,58,0,16,0, +0,0,0,0,52,0,0,7,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,1,64,0,0,0,0,0,0, +0,0,0,11,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,10,128,32,134,65,0,0,0,0,0,0,0, +26,0,0,0,58,0,16,0,0,0,0,0,56,32,0,10, +130,0,16,0,1,0,0,0,58,0,16,0,1,0,0,0, +26,128,32,6,0,0,0,0,26,0,0,0,58,0,16,0, +0,0,0,0,56,0,0,7,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,10,0,16,0,2,0,0,0, +16,0,0,7,18,0,16,0,1,0,0,0,70,18,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,52,0,0,7, +18,0,16,0,1,0,0,0,10,0,16,0,1,0,0,0, +1,64,0,0,0,0,0,0,56,0,0,7,114,0,16,0, +1,0,0,0,6,0,16,0,1,0,0,0,70,18,16,0, +3,0,0,0,56,0,0,10,114,0,16,0,1,0,0,0, +70,2,16,0,1,0,0,0,70,130,32,6,0,0,0,0, +10,0,0,0,58,0,16,0,0,0,0,0,56,0,0,7, +114,0,16,0,1,0,0,0,246,15,16,0,1,0,0,0, +70,2,16,0,1,0,0,0,51,0,0,10,114,0,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,2,64,0,0, +0,0,128,63,0,0,128,63,0,0,128,63,0,0,0,0, +0,0,0,7,114,0,16,0,0,0,0,0,70,2,16,0, +0,0,0,0,70,2,16,0,1,0,0,0,30,0,0,7, +130,0,16,0,0,0,0,0,58,0,16,0,0,0,0,0, +1,64,0,0,1,0,0,0,22,0,0,1,54,0,0,5, +114,32,16,0,0,0,0,0,70,2,16,0,0,0,0,0, +54,0,0,5,114,32,16,0,1,0,0,0,70,18,16,0, +4,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +32,0,0,0,3,0,0,0,0,0,0,0,7,0,0,0, +20,0,0,0,2,0,0,0,1,0,0,0,1,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,188,4,0,0,1,0,0,0, +108,0,0,0,1,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,142,4,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,85,110,105,116,121,70,70,86, +101,114,116,101,120,0,171,171,92,0,0,0,14,0,0,0, +132,0,0,0,240,3,0,0,0,0,0,0,0,0,0,0, +180,2,0,0,0,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,240,2,0,0,64,0,0,0, +64,0,0,0,0,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +253,2,0,0,128,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,56,3,0,0,144,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +71,3,0,0,160,0,0,0,128,0,0,0,2,0,0,0, +88,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,124,3,0,0,32,1,0,0, +128,0,0,0,2,0,0,0,140,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +176,3,0,0,160,1,0,0,128,0,0,0,2,0,0,0, +192,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,228,3,0,0,32,2,0,0, +128,0,0,0,2,0,0,0,244,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +24,4,0,0,160,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,39,4,0,0,176,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +54,4,0,0,192,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,66,4,0,0,208,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +82,4,0,0,224,2,0,0,0,1,0,0,0,0,0,0, +96,4,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,132,4,0,0,224,3,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +102,102,95,109,97,116,114,105,120,95,109,118,112,0,102,108, +111,97,116,52,120,52,0,171,3,0,3,0,4,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,194,2,0,0,102,102,95,109, +97,116,114,105,120,95,109,118,0,102,102,95,118,101,99,95, +99,111,108,111,114,0,102,108,111,97,116,52,0,171,171,171, +1,0,3,0,1,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,118,101,99,95,97,109,98,105,101, +110,116,0,102,102,95,108,105,103,104,116,95,99,111,108,111, +114,0,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,112,111,115,0,171,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,97,116,116,101,110,0,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,115,112,111,116,0,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,109,97,116,95,100,105,102,102,117, +115,101,0,102,102,95,109,97,116,95,97,109,98,105,101,110, +116,0,102,102,95,109,97,116,95,115,112,101,99,0,102,102, +95,109,97,116,95,101,109,105,115,115,105,111,110,0,102,102, +95,109,97,116,114,105,120,95,116,101,120,0,3,0,3,0, +4,0,4,0,4,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,194,2,0,0, +102,102,95,102,111,103,95,118,115,0,77,105,99,114,111,115, +111,102,116,32,40,82,41,32,72,76,83,76,32,83,104,97, +100,101,114,32,67,111,109,112,105,108,101,114,32,54,46,51, +46,57,52,49,53,46,48,0,76,70,83,48,164,1,0,0, +7,0,0,0,8,0,0,0,88,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,106,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,118,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,128,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,136,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,149,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,3,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,159,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,5,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,67,111,109,112,117,116,101,83, +112,111,116,76,105,103,104,116,51,0,101,121,101,80,111,115, +105,116,105,111,110,0,101,121,101,78,111,114,109,97,108,0, +118,105,101,119,68,105,114,0,100,105,102,102,117,115,101,67, +111,108,111,114,0,115,112,101,99,67,111,108,111,114,0,97, +109,98,0,171,76,73,66,70,80,16,0,0,68,88,66,67, +170,38,218,251,246,216,107,194,180,253,56,94,218,55,46,138, +1,0,0,0,80,16,0,0,5,0,0,0,52,0,0,0, +156,3,0,0,96,9,0,0,220,9,0,0,160,14,0,0, +65,111,110,57,96,3,0,0,96,3,0,0,0,2,86,76, +48,3,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,0,0,0,0, +45,0,0,0,0,0,0,0,0,2,86,76,81,0,0,5, +45,0,15,160,0,0,0,0,0,0,0,0,0,0,128,63, +0,0,0,0,48,0,0,5,0,0,15,240,3,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,2, +5,0,0,128,0,0,15,144,31,0,0,2,5,0,1,128, +1,0,15,144,31,0,0,2,5,0,2,128,2,0,15,144, +31,0,0,2,5,0,3,128,3,0,15,144,31,0,0,2, +5,0,4,128,4,0,15,144,31,0,0,2,5,0,5,128, +5,0,15,144,1,0,0,2,0,0,7,128,4,0,228,144, +1,0,0,2,1,0,7,128,5,0,228,144,27,0,0,2, +0,8,228,240,0,0,228,240,4,0,0,6,2,0,7,128, +0,0,228,144,18,32,255,161,0,8,228,240,18,32,228,160, +0,8,228,240,8,0,0,3,0,0,8,128,2,0,228,128, +2,0,228,128,7,0,0,2,1,0,8,128,0,0,255,128, +4,0,0,4,3,0,7,128,2,0,228,128,1,0,255,128, +2,0,228,144,36,0,0,2,4,0,7,128,3,0,228,128, +8,0,0,3,2,0,8,128,1,0,228,144,4,0,228,128, +5,0,0,5,3,0,1,128,18,32,255,160,0,8,228,240, +18,32,255,160,0,8,228,240,12,0,0,3,3,0,1,128, +3,0,0,129,3,0,0,128,12,0,0,4,3,0,2,128, +26,32,255,160,0,8,228,240,0,0,255,128,5,0,0,3, +3,0,1,128,3,0,85,128,3,0,0,128,5,0,0,4, +0,0,8,128,0,0,255,128,26,32,170,160,0,8,228,240, +2,0,0,3,0,0,8,128,0,0,255,128,45,0,170,160, +6,0,0,2,0,0,8,128,0,0,255,128,4,0,0,4, +0,0,8,128,3,0,0,128,0,0,255,129,0,0,255,128, +11,0,0,3,2,0,8,128,2,0,255,128,45,0,85,160, +32,0,0,3,3,0,1,128,2,0,255,128,44,0,255,160, +10,0,0,3,2,0,8,128,3,0,0,128,45,0,170,160, +5,0,0,3,2,0,7,128,1,0,255,128,2,0,228,128, +8,0,0,3,1,0,8,128,1,0,228,144,2,0,228,128, +8,0,0,4,2,0,1,128,2,0,228,128,34,32,228,160, +0,8,228,240,11,0,0,3,2,0,1,128,2,0,0,128, +45,0,85,160,2,0,0,4,2,0,1,128,2,0,0,128, +26,32,0,161,0,8,228,240,5,0,0,4,2,0,1,128, +2,0,0,128,26,32,85,160,0,8,228,240,11,0,0,3, +2,0,1,128,2,0,0,128,45,0,85,160,10,0,0,3, +2,0,1,128,2,0,0,128,45,0,170,160,5,0,0,3, +0,0,8,128,0,0,255,128,2,0,0,128,11,0,0,3, +1,0,8,128,1,0,255,128,45,0,85,160,12,0,0,3, +2,0,1,128,45,0,85,160,1,0,255,128,5,0,0,3, +2,0,2,128,2,0,255,128,0,0,255,128,5,0,0,4, +2,0,14,128,2,0,85,128,10,32,144,160,0,8,228,240, +4,0,0,4,0,0,7,128,2,0,0,128,2,0,249,128, +0,0,228,128,5,0,0,3,2,0,7,128,1,0,255,128, +3,0,228,144,5,0,0,4,2,0,7,128,2,0,228,128, +10,32,228,160,0,8,228,240,5,0,0,3,2,0,7,128, +0,0,255,128,2,0,228,128,10,0,0,3,2,0,7,128, +2,0,228,128,45,0,170,160,2,0,0,3,1,0,7,128, +1,0,228,128,2,0,228,128,29,0,0,0,1,0,0,2, +1,0,7,224,0,0,228,128,1,0,0,2,0,0,7,224, +1,0,228,128,255,255,0,0,83,72,68,82,188,5,0,0, +64,0,240,255,111,1,0,0,89,8,0,4,70,142,32,0, +0,0,0,0,45,0,0,0,95,0,0,3,114,16,16,0, +0,0,0,0,95,0,0,3,114,16,16,0,1,0,0,0, +95,0,0,3,114,16,16,0,2,0,0,0,95,0,0,3, +114,16,16,0,3,0,0,0,95,0,0,3,114,16,16,0, +4,0,0,0,95,0,0,3,114,16,16,0,5,0,0,0, +101,0,0,3,114,32,16,0,0,0,0,0,101,0,0,3, +114,32,16,0,1,0,0,0,104,0,0,2,4,0,0,0, +54,0,0,5,114,0,16,0,0,0,0,0,70,18,16,0, +4,0,0,0,54,0,0,5,114,0,16,0,1,0,0,0, +70,18,16,0,5,0,0,0,54,0,0,5,130,0,16,0, +0,0,0,0,1,64,0,0,0,0,0,0,48,0,0,1, +33,0,0,7,130,0,16,0,1,0,0,0,58,0,16,0, +0,0,0,0,1,64,0,0,3,0,0,0,3,0,4,3, +58,0,16,0,1,0,0,0,50,0,0,16,114,0,16,0, +2,0,0,0,70,18,16,128,65,0,0,0,0,0,0,0, +246,143,32,6,0,0,0,0,18,0,0,0,58,0,16,0, +0,0,0,0,70,130,32,6,0,0,0,0,18,0,0,0, +58,0,16,0,0,0,0,0,16,0,0,7,130,0,16,0, +1,0,0,0,70,2,16,0,2,0,0,0,70,2,16,0, +2,0,0,0,50,0,0,12,130,0,16,0,2,0,0,0, +42,128,32,6,0,0,0,0,26,0,0,0,58,0,16,0, +0,0,0,0,58,0,16,0,1,0,0,0,1,64,0,0, +0,0,128,63,14,0,0,10,130,0,16,0,2,0,0,0, +2,64,0,0,0,0,128,63,0,0,128,63,0,0,128,63, +0,0,128,63,58,0,16,0,2,0,0,0,57,0,0,10, +18,0,16,0,3,0,0,0,1,64,0,0,0,0,0,0, +58,128,32,6,0,0,0,0,18,0,0,0,58,0,16,0, +0,0,0,0,49,0,0,10,34,0,16,0,3,0,0,0, +58,128,32,6,0,0,0,0,26,0,0,0,58,0,16,0, +0,0,0,0,58,0,16,0,1,0,0,0,1,0,0,7, +18,0,16,0,3,0,0,0,26,0,16,0,3,0,0,0, +10,0,16,0,3,0,0,0,55,0,0,9,130,0,16,0, +2,0,0,0,10,0,16,0,3,0,0,0,1,64,0,0, +0,0,0,0,58,0,16,0,2,0,0,0,68,0,0,5, +130,0,16,0,1,0,0,0,58,0,16,0,1,0,0,0, +56,0,0,7,114,0,16,0,3,0,0,0,246,15,16,0, +1,0,0,0,70,2,16,0,2,0,0,0,16,0,0,10, +130,0,16,0,3,0,0,0,70,2,16,0,3,0,0,0, +70,130,32,6,0,0,0,0,34,0,0,0,58,0,16,0, +0,0,0,0,52,0,0,7,130,0,16,0,3,0,0,0, +58,0,16,0,3,0,0,0,1,64,0,0,0,0,0,0, +0,0,0,11,130,0,16,0,3,0,0,0,58,0,16,0, +3,0,0,0,10,128,32,134,65,0,0,0,0,0,0,0, +26,0,0,0,58,0,16,0,0,0,0,0,56,32,0,10, +130,0,16,0,3,0,0,0,58,0,16,0,3,0,0,0, +26,128,32,6,0,0,0,0,26,0,0,0,58,0,16,0, +0,0,0,0,56,0,0,7,130,0,16,0,2,0,0,0, +58,0,16,0,2,0,0,0,58,0,16,0,3,0,0,0, +16,0,0,7,18,0,16,0,3,0,0,0,70,18,16,0, +1,0,0,0,70,2,16,0,3,0,0,0,52,0,0,7, +18,0,16,0,3,0,0,0,10,0,16,0,3,0,0,0, +1,64,0,0,0,0,0,0,56,0,0,7,226,0,16,0, +3,0,0,0,6,0,16,0,3,0,0,0,6,25,16,0, +3,0,0,0,56,0,0,10,226,0,16,0,3,0,0,0, +86,14,16,0,3,0,0,0,6,137,32,6,0,0,0,0, +10,0,0,0,58,0,16,0,0,0,0,0,49,0,0,7, +18,0,16,0,3,0,0,0,1,64,0,0,0,0,0,0, +10,0,16,0,3,0,0,0,31,0,4,3,10,0,16,0, +3,0,0,0,50,0,0,9,114,0,16,0,2,0,0,0, +70,2,16,0,2,0,0,0,246,15,16,0,1,0,0,0, +70,18,16,0,2,0,0,0,16,0,0,7,130,0,16,0, +1,0,0,0,70,2,16,0,2,0,0,0,70,2,16,0, +2,0,0,0,68,0,0,5,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,56,0,0,7,114,0,16,0, +2,0,0,0,246,15,16,0,1,0,0,0,70,2,16,0, +2,0,0,0,16,0,0,7,130,0,16,0,1,0,0,0, +70,18,16,0,1,0,0,0,70,2,16,0,2,0,0,0, +52,0,0,7,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,1,64,0,0,0,0,0,0,47,0,0,5, +130,0,16,0,1,0,0,0,58,0,16,0,1,0,0,0, +56,0,0,8,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,58,128,32,0,0,0,0,0,44,0,0,0, +25,0,0,5,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,51,0,0,7,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,1,64,0,0,0,0,128,63, +56,0,0,7,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,58,0,16,0,2,0,0,0,50,0,0,12, +114,0,16,0,0,0,0,0,246,15,16,0,1,0,0,0, +70,130,32,6,0,0,0,0,10,0,0,0,58,0,16,0, +0,0,0,0,70,2,16,0,0,0,0,0,21,0,0,1, +56,0,0,7,114,0,16,0,2,0,0,0,246,15,16,0, +2,0,0,0,150,7,16,0,3,0,0,0,51,0,0,10, +114,0,16,0,2,0,0,0,70,2,16,0,2,0,0,0, +2,64,0,0,0,0,128,63,0,0,128,63,0,0,128,63, +0,0,0,0,0,0,0,7,114,0,16,0,1,0,0,0, +70,2,16,0,1,0,0,0,70,2,16,0,2,0,0,0, +30,0,0,7,130,0,16,0,0,0,0,0,58,0,16,0, +0,0,0,0,1,64,0,0,1,0,0,0,22,0,0,1, +54,0,0,5,114,32,16,0,1,0,0,0,70,2,16,0, +0,0,0,0,54,0,0,5,114,32,16,0,0,0,0,0, +70,2,16,0,1,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,48,0,0,0,4,0,0,0,0,0,0,0, +8,0,0,0,33,0,0,0,2,0,0,0,1,0,0,0, +1,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +5,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,188,4,0,0, +1,0,0,0,108,0,0,0,1,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,142,4,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,92,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,85,110,105,116, +121,70,70,86,101,114,116,101,120,0,171,171,92,0,0,0, +14,0,0,0,132,0,0,0,240,3,0,0,0,0,0,0, +0,0,0,0,180,2,0,0,0,0,0,0,64,0,0,0, +0,0,0,0,204,2,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,240,2,0,0, +64,0,0,0,64,0,0,0,0,0,0,0,204,2,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,253,2,0,0,128,0,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,56,3,0,0, +144,0,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,71,3,0,0,160,0,0,0,128,0,0,0, +2,0,0,0,88,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,124,3,0,0, +32,1,0,0,128,0,0,0,2,0,0,0,140,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,176,3,0,0,160,1,0,0,128,0,0,0, +2,0,0,0,192,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,228,3,0,0, +32,2,0,0,128,0,0,0,2,0,0,0,244,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,24,4,0,0,160,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,39,4,0,0, +176,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,54,4,0,0,192,2,0,0,16,0,0,0, +2,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,66,4,0,0, +208,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,82,4,0,0,224,2,0,0,0,1,0,0, +0,0,0,0,96,4,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,132,4,0,0, +224,3,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,102,102,95,109,97,116,114,105,120,95,109,118, +112,0,102,108,111,97,116,52,120,52,0,171,3,0,3,0, +4,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,194,2,0,0, +102,102,95,109,97,116,114,105,120,95,109,118,0,102,102,95, +118,101,99,95,99,111,108,111,114,0,102,108,111,97,116,52, +0,171,171,171,1,0,3,0,1,0,4,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,118,101,99,95,97, +109,98,105,101,110,116,0,102,102,95,108,105,103,104,116,95, +99,111,108,111,114,0,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,112,111,115,0,171,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,97,116,116,101,110,0,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,115,112,111, +116,0,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,109,97,116,95,100, +105,102,102,117,115,101,0,102,102,95,109,97,116,95,97,109, +98,105,101,110,116,0,102,102,95,109,97,116,95,115,112,101, +99,0,102,102,95,109,97,116,95,101,109,105,115,115,105,111, +110,0,102,102,95,109,97,116,114,105,120,95,116,101,120,0, +3,0,3,0,4,0,4,0,4,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +194,2,0,0,102,102,95,102,111,103,95,118,115,0,77,105, +99,114,111,115,111,102,116,32,40,82,41,32,72,76,83,76, +32,83,104,97,100,101,114,32,67,111,109,112,105,108,101,114, +32,54,46,51,46,57,52,49,53,46,48,0,76,70,83,48, +168,1,0,0,7,0,0,0,8,0,0,0,88,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,2,0,0,0,255,255,255,255, +255,255,255,255,0,0,0,0,0,0,0,0,110,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,122,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,132,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,140,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,153,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,3,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,163,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,5,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,67,111,109,112, +117,116,101,83,112,111,116,76,105,103,104,116,83,112,101,99, +51,0,101,121,101,80,111,115,105,116,105,111,110,0,101,121, +101,78,111,114,109,97,108,0,118,105,101,119,68,105,114,0, +100,105,102,102,117,115,101,67,111,108,111,114,0,115,112,101, +99,67,111,108,111,114,0,97,109,98,0,171,76,73,66,70, +48,18,0,0,68,88,66,67,2,125,230,23,98,206,70,179, +136,149,189,146,48,38,11,143,1,0,0,0,48,18,0,0, +5,0,0,0,52,0,0,0,36,7,0,0,68,11,0,0, +192,11,0,0,132,16,0,0,65,111,110,57,232,6,0,0, +232,6,0,0,0,2,86,76,148,6,0,0,84,0,0,0, +4,0,36,0,0,0,84,0,0,0,84,0,0,0,36,0, +0,0,84,0,0,0,10,0,4,0,0,0,0,0,0,0, +0,0,18,0,4,0,4,0,0,0,0,0,0,0,26,0, +4,0,8,0,0,0,0,0,0,0,34,0,4,0,12,0, +0,0,0,0,0,2,86,76,81,0,0,5,16,0,15,160, +0,0,128,63,0,0,0,0,0,0,0,0,0,0,0,0, +31,0,0,2,5,0,0,128,0,0,15,144,31,0,0,2, +5,0,1,128,1,0,15,144,31,0,0,2,5,0,3,128, +3,0,15,144,31,0,0,2,5,0,4,128,4,0,15,144, +31,0,0,2,5,0,5,128,5,0,15,144,5,0,0,3, +0,0,1,128,4,0,255,160,4,0,255,160,12,0,0,3, +0,0,1,128,0,0,0,129,0,0,0,128,4,0,0,4, +0,0,14,128,0,0,144,144,4,0,255,161,4,0,144,160, +8,0,0,3,1,0,1,128,0,0,249,128,0,0,249,128, +12,0,0,3,1,0,2,128,8,0,255,160,1,0,0,128, +5,0,0,3,0,0,1,128,0,0,0,128,1,0,85,128, +1,0,0,2,2,0,1,128,16,0,0,160,4,0,0,4, +1,0,2,128,8,0,170,160,1,0,0,128,2,0,0,128, +7,0,0,2,1,0,1,128,1,0,0,128,5,0,0,3, +0,0,14,128,0,0,228,128,1,0,0,128,6,0,0,2, +1,0,1,128,1,0,85,128,4,0,0,4,0,0,1,128, +0,0,0,128,1,0,0,129,1,0,0,128,8,0,0,3, +1,0,1,128,0,0,249,128,12,0,228,160,8,0,0,3, +0,0,2,128,1,0,228,144,0,0,249,128,11,0,0,3, +0,0,2,128,0,0,85,128,16,0,85,160,5,0,0,3, +0,0,14,128,0,0,85,128,3,0,144,144,5,0,0,3, +0,0,14,128,0,0,228,128,0,0,144,160,11,0,0,3, +1,0,1,128,1,0,0,128,16,0,85,160,2,0,0,3, +1,0,1,128,1,0,0,128,8,0,0,161,5,0,0,3, +1,0,1,128,1,0,0,128,8,0,85,160,11,0,0,3, +1,0,1,128,1,0,0,128,16,0,85,160,10,0,0,3, +1,0,1,128,1,0,0,128,16,0,0,160,5,0,0,3, +0,0,1,128,0,0,0,128,1,0,0,128,5,0,0,3, +0,0,7,128,0,0,0,128,0,0,249,128,10,0,0,3, +0,0,7,128,0,0,228,128,16,0,0,160,2,0,0,3, +0,0,7,128,0,0,228,128,5,0,228,144,5,0,0,3, +0,0,8,128,5,0,255,160,5,0,255,160,12,0,0,3, +0,0,8,128,0,0,255,129,0,0,255,128,4,0,0,4, +1,0,7,128,0,0,228,144,5,0,255,161,5,0,228,160, +8,0,0,3,1,0,8,128,1,0,228,128,1,0,228,128, +12,0,0,3,2,0,2,128,9,0,255,160,1,0,255,128, +5,0,0,3,0,0,8,128,0,0,255,128,2,0,85,128, +4,0,0,4,2,0,2,128,9,0,170,160,1,0,255,128, +2,0,0,128,7,0,0,2,1,0,8,128,1,0,255,128, +5,0,0,3,1,0,7,128,1,0,255,128,1,0,228,128, +6,0,0,2,1,0,8,128,2,0,85,128,4,0,0,4, +0,0,8,128,0,0,255,128,1,0,255,129,1,0,255,128, +8,0,0,3,1,0,8,128,1,0,228,128,13,0,228,160, +8,0,0,3,1,0,1,128,1,0,228,144,1,0,228,128, +11,0,0,3,1,0,9,128,1,0,228,128,16,0,85,160, +5,0,0,3,1,0,7,128,1,0,0,128,3,0,228,144, +5,0,0,3,1,0,7,128,1,0,228,128,1,0,228,160, +2,0,0,3,1,0,8,128,1,0,255,128,9,0,0,161, +5,0,0,3,1,0,8,128,1,0,255,128,9,0,85,160, +11,0,0,3,1,0,8,128,1,0,255,128,16,0,85,160, +10,0,0,3,1,0,8,128,1,0,255,128,16,0,0,160, +5,0,0,3,0,0,8,128,0,0,255,128,1,0,255,128, +5,0,0,3,1,0,7,128,0,0,255,128,1,0,228,128, +10,0,0,3,1,0,7,128,1,0,228,128,16,0,0,160, +2,0,0,3,0,0,7,128,0,0,228,128,1,0,228,128, +5,0,0,3,0,0,8,128,6,0,255,160,6,0,255,160, +12,0,0,3,0,0,8,128,0,0,255,129,0,0,255,128, +4,0,0,4,1,0,7,128,0,0,228,144,6,0,255,161, +6,0,228,160,8,0,0,3,1,0,8,128,1,0,228,128, +1,0,228,128,12,0,0,3,2,0,2,128,10,0,255,160, +1,0,255,128,5,0,0,3,0,0,8,128,0,0,255,128, +2,0,85,128,4,0,0,4,2,0,2,128,10,0,170,160, +1,0,255,128,2,0,0,128,7,0,0,2,1,0,8,128, +1,0,255,128,5,0,0,3,1,0,7,128,1,0,255,128, +1,0,228,128,6,0,0,2,1,0,8,128,2,0,85,128, +4,0,0,4,0,0,8,128,0,0,255,128,1,0,255,129, +1,0,255,128,8,0,0,3,1,0,8,128,1,0,228,128, +14,0,228,160,8,0,0,3,1,0,1,128,1,0,228,144, +1,0,228,128,11,0,0,3,1,0,9,128,1,0,228,128, +16,0,85,160,5,0,0,3,1,0,7,128,1,0,0,128, +3,0,228,144,5,0,0,3,1,0,7,128,1,0,228,128, +2,0,228,160,2,0,0,3,1,0,8,128,1,0,255,128, +10,0,0,161,5,0,0,3,1,0,8,128,1,0,255,128, +10,0,85,160,11,0,0,3,1,0,8,128,1,0,255,128, +16,0,85,160,10,0,0,3,1,0,8,128,1,0,255,128, +16,0,0,160,5,0,0,3,0,0,8,128,0,0,255,128, +1,0,255,128,5,0,0,3,1,0,7,128,0,0,255,128, +1,0,228,128,10,0,0,3,1,0,7,128,1,0,228,128, +16,0,0,160,2,0,0,3,0,0,7,128,0,0,228,128, +1,0,228,128,5,0,0,3,0,0,8,128,7,0,255,160, +7,0,255,160,12,0,0,3,0,0,8,128,0,0,255,129, +0,0,255,128,4,0,0,4,1,0,7,128,0,0,228,144, +7,0,255,161,7,0,228,160,8,0,0,3,1,0,8,128, +1,0,228,128,1,0,228,128,12,0,0,3,2,0,2,128, +11,0,255,160,1,0,255,128,5,0,0,3,0,0,8,128, +0,0,255,128,2,0,85,128,4,0,0,4,2,0,1,128, +11,0,170,160,1,0,255,128,2,0,0,128,7,0,0,2, +1,0,8,128,1,0,255,128,5,0,0,3,1,0,7,128, +1,0,255,128,1,0,228,128,6,0,0,2,1,0,8,128, +2,0,0,128,4,0,0,4,0,0,8,128,0,0,255,128, +1,0,255,129,1,0,255,128,8,0,0,3,1,0,8,128, +1,0,228,128,15,0,228,160,8,0,0,3,1,0,1,128, +1,0,228,144,1,0,228,128,11,0,0,3,1,0,9,128, +1,0,228,128,16,0,85,160,5,0,0,3,1,0,7,128, +1,0,0,128,3,0,228,144,5,0,0,3,1,0,7,128, +1,0,228,128,3,0,228,160,2,0,0,3,1,0,8,128, +1,0,255,128,11,0,0,161,5,0,0,3,1,0,8,128, +1,0,255,128,11,0,85,160,11,0,0,3,1,0,8,128, +1,0,255,128,16,0,85,160,10,0,0,3,1,0,8,128, +1,0,255,128,16,0,0,160,5,0,0,3,0,0,8,128, +0,0,255,128,1,0,255,128,5,0,0,3,1,0,7,128, +0,0,255,128,1,0,228,128,10,0,0,3,1,0,7,128, +1,0,228,128,16,0,0,160,2,0,0,3,0,0,7,224, +0,0,228,128,1,0,228,128,1,0,0,2,1,0,7,224, +4,0,228,144,255,255,0,0,83,72,68,82,24,4,0,0, +64,0,240,255,6,1,0,0,89,8,0,4,70,142,32,0, +0,0,0,0,39,0,0,0,95,0,0,3,114,16,16,0, +0,0,0,0,95,0,0,3,114,16,16,0,1,0,0,0, +95,0,0,3,114,16,16,0,3,0,0,0,95,0,0,3, +114,16,16,0,4,0,0,0,95,0,0,3,114,16,16,0, +5,0,0,0,101,0,0,3,114,32,16,0,0,0,0,0, +101,0,0,3,114,32,16,0,1,0,0,0,104,0,0,2, +3,0,0,0,54,0,0,5,114,0,16,0,0,0,0,0, +70,18,16,0,5,0,0,0,54,0,0,5,130,0,16,0, +0,0,0,0,1,64,0,0,0,0,0,0,48,0,0,1, +33,0,0,7,18,0,16,0,1,0,0,0,58,0,16,0, +0,0,0,0,1,64,0,0,4,0,0,0,3,0,4,3, +10,0,16,0,1,0,0,0,50,0,0,16,114,0,16,0, +1,0,0,0,70,18,16,128,65,0,0,0,0,0,0,0, +246,143,32,6,0,0,0,0,18,0,0,0,58,0,16,0, +0,0,0,0,70,130,32,6,0,0,0,0,18,0,0,0, +58,0,16,0,0,0,0,0,16,0,0,7,130,0,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,70,2,16,0, +1,0,0,0,50,0,0,12,18,0,16,0,2,0,0,0, +42,128,32,6,0,0,0,0,26,0,0,0,58,0,16,0, +0,0,0,0,58,0,16,0,1,0,0,0,1,64,0,0, +0,0,128,63,14,0,0,10,18,0,16,0,2,0,0,0, +2,64,0,0,0,0,128,63,0,0,128,63,0,0,128,63, +0,0,128,63,10,0,16,0,2,0,0,0,57,0,0,10, +34,0,16,0,2,0,0,0,1,64,0,0,0,0,0,0, +58,128,32,6,0,0,0,0,18,0,0,0,58,0,16,0, +0,0,0,0,49,0,0,10,66,0,16,0,2,0,0,0, +58,128,32,6,0,0,0,0,26,0,0,0,58,0,16,0, +0,0,0,0,58,0,16,0,1,0,0,0,1,0,0,7, +34,0,16,0,2,0,0,0,42,0,16,0,2,0,0,0, +26,0,16,0,2,0,0,0,55,0,0,9,18,0,16,0, +2,0,0,0,26,0,16,0,2,0,0,0,1,64,0,0, +0,0,0,0,10,0,16,0,2,0,0,0,68,0,0,5, +130,0,16,0,1,0,0,0,58,0,16,0,1,0,0,0, +56,0,0,7,114,0,16,0,1,0,0,0,246,15,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,16,0,0,10, +130,0,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +70,130,32,6,0,0,0,0,34,0,0,0,58,0,16,0, +0,0,0,0,52,0,0,7,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,1,64,0,0,0,0,0,0, +0,0,0,11,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,10,128,32,134,65,0,0,0,0,0,0,0, +26,0,0,0,58,0,16,0,0,0,0,0,56,32,0,10, +130,0,16,0,1,0,0,0,58,0,16,0,1,0,0,0, +26,128,32,6,0,0,0,0,26,0,0,0,58,0,16,0, +0,0,0,0,56,0,0,7,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,10,0,16,0,2,0,0,0, +16,0,0,7,18,0,16,0,1,0,0,0,70,18,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,52,0,0,7, +18,0,16,0,1,0,0,0,10,0,16,0,1,0,0,0, +1,64,0,0,0,0,0,0,56,0,0,7,114,0,16,0, +1,0,0,0,6,0,16,0,1,0,0,0,70,18,16,0, +3,0,0,0,56,0,0,10,114,0,16,0,1,0,0,0, +70,2,16,0,1,0,0,0,70,130,32,6,0,0,0,0, +10,0,0,0,58,0,16,0,0,0,0,0,56,0,0,7, +114,0,16,0,1,0,0,0,246,15,16,0,1,0,0,0, +70,2,16,0,1,0,0,0,51,0,0,10,114,0,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,2,64,0,0, +0,0,128,63,0,0,128,63,0,0,128,63,0,0,0,0, +0,0,0,7,114,0,16,0,0,0,0,0,70,2,16,0, +0,0,0,0,70,2,16,0,1,0,0,0,30,0,0,7, +130,0,16,0,0,0,0,0,58,0,16,0,0,0,0,0, +1,64,0,0,1,0,0,0,22,0,0,1,54,0,0,5, +114,32,16,0,0,0,0,0,70,2,16,0,0,0,0,0, +54,0,0,5,114,32,16,0,1,0,0,0,70,18,16,0, +4,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +32,0,0,0,3,0,0,0,0,0,0,0,7,0,0,0, +20,0,0,0,2,0,0,0,1,0,0,0,1,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,188,4,0,0,1,0,0,0, +108,0,0,0,1,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,142,4,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,85,110,105,116,121,70,70,86, +101,114,116,101,120,0,171,171,92,0,0,0,14,0,0,0, +132,0,0,0,240,3,0,0,0,0,0,0,0,0,0,0, +180,2,0,0,0,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,240,2,0,0,64,0,0,0, +64,0,0,0,0,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +253,2,0,0,128,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,56,3,0,0,144,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +71,3,0,0,160,0,0,0,128,0,0,0,2,0,0,0, +88,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,124,3,0,0,32,1,0,0, +128,0,0,0,2,0,0,0,140,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +176,3,0,0,160,1,0,0,128,0,0,0,2,0,0,0, +192,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,228,3,0,0,32,2,0,0, +128,0,0,0,2,0,0,0,244,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +24,4,0,0,160,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,39,4,0,0,176,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +54,4,0,0,192,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,66,4,0,0,208,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +82,4,0,0,224,2,0,0,0,1,0,0,0,0,0,0, +96,4,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,132,4,0,0,224,3,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +102,102,95,109,97,116,114,105,120,95,109,118,112,0,102,108, +111,97,116,52,120,52,0,171,3,0,3,0,4,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,194,2,0,0,102,102,95,109, +97,116,114,105,120,95,109,118,0,102,102,95,118,101,99,95, +99,111,108,111,114,0,102,108,111,97,116,52,0,171,171,171, +1,0,3,0,1,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,118,101,99,95,97,109,98,105,101, +110,116,0,102,102,95,108,105,103,104,116,95,99,111,108,111, +114,0,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,112,111,115,0,171,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,97,116,116,101,110,0,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,115,112,111,116,0,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,109,97,116,95,100,105,102,102,117, +115,101,0,102,102,95,109,97,116,95,97,109,98,105,101,110, +116,0,102,102,95,109,97,116,95,115,112,101,99,0,102,102, +95,109,97,116,95,101,109,105,115,115,105,111,110,0,102,102, +95,109,97,116,114,105,120,95,116,101,120,0,3,0,3,0, +4,0,4,0,4,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,194,2,0,0, +102,102,95,102,111,103,95,118,115,0,77,105,99,114,111,115, +111,102,116,32,40,82,41,32,72,76,83,76,32,83,104,97, +100,101,114,32,67,111,109,112,105,108,101,114,32,54,46,51, +46,57,52,49,53,46,48,0,76,70,83,48,164,1,0,0, +7,0,0,0,8,0,0,0,88,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,106,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,118,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,128,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,136,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,149,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,3,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,159,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,5,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,67,111,109,112,117,116,101,83, +112,111,116,76,105,103,104,116,52,0,101,121,101,80,111,115, +105,116,105,111,110,0,101,121,101,78,111,114,109,97,108,0, +118,105,101,119,68,105,114,0,100,105,102,102,117,115,101,67, +111,108,111,114,0,115,112,101,99,67,111,108,111,114,0,97, +109,98,0,171,76,73,66,70,80,16,0,0,68,88,66,67, +50,83,242,196,114,66,252,96,155,185,91,130,235,4,7,30, +1,0,0,0,80,16,0,0,5,0,0,0,52,0,0,0, +156,3,0,0,96,9,0,0,220,9,0,0,160,14,0,0, +65,111,110,57,96,3,0,0,96,3,0,0,0,2,86,76, +48,3,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,0,0,0,0, +45,0,0,0,0,0,0,0,0,2,86,76,81,0,0,5, +45,0,15,160,0,0,0,0,0,0,0,0,0,0,128,63, +0,0,0,0,48,0,0,5,0,0,15,240,4,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,2, +5,0,0,128,0,0,15,144,31,0,0,2,5,0,1,128, +1,0,15,144,31,0,0,2,5,0,2,128,2,0,15,144, +31,0,0,2,5,0,3,128,3,0,15,144,31,0,0,2, +5,0,4,128,4,0,15,144,31,0,0,2,5,0,5,128, +5,0,15,144,1,0,0,2,0,0,7,128,4,0,228,144, +1,0,0,2,1,0,7,128,5,0,228,144,27,0,0,2, +0,8,228,240,0,0,228,240,4,0,0,6,2,0,7,128, +0,0,228,144,18,32,255,161,0,8,228,240,18,32,228,160, +0,8,228,240,8,0,0,3,0,0,8,128,2,0,228,128, +2,0,228,128,7,0,0,2,1,0,8,128,0,0,255,128, +4,0,0,4,3,0,7,128,2,0,228,128,1,0,255,128, +2,0,228,144,36,0,0,2,4,0,7,128,3,0,228,128, +8,0,0,3,2,0,8,128,1,0,228,144,4,0,228,128, +5,0,0,5,3,0,1,128,18,32,255,160,0,8,228,240, +18,32,255,160,0,8,228,240,12,0,0,3,3,0,1,128, +3,0,0,129,3,0,0,128,12,0,0,4,3,0,2,128, +26,32,255,160,0,8,228,240,0,0,255,128,5,0,0,3, +3,0,1,128,3,0,85,128,3,0,0,128,5,0,0,4, +0,0,8,128,0,0,255,128,26,32,170,160,0,8,228,240, +2,0,0,3,0,0,8,128,0,0,255,128,45,0,170,160, +6,0,0,2,0,0,8,128,0,0,255,128,4,0,0,4, +0,0,8,128,3,0,0,128,0,0,255,129,0,0,255,128, +11,0,0,3,2,0,8,128,2,0,255,128,45,0,85,160, +32,0,0,3,3,0,1,128,2,0,255,128,44,0,255,160, +10,0,0,3,2,0,8,128,3,0,0,128,45,0,170,160, +5,0,0,3,2,0,7,128,1,0,255,128,2,0,228,128, +8,0,0,3,1,0,8,128,1,0,228,144,2,0,228,128, +8,0,0,4,2,0,1,128,2,0,228,128,34,32,228,160, +0,8,228,240,11,0,0,3,2,0,1,128,2,0,0,128, +45,0,85,160,2,0,0,4,2,0,1,128,2,0,0,128, +26,32,0,161,0,8,228,240,5,0,0,4,2,0,1,128, +2,0,0,128,26,32,85,160,0,8,228,240,11,0,0,3, +2,0,1,128,2,0,0,128,45,0,85,160,10,0,0,3, +2,0,1,128,2,0,0,128,45,0,170,160,5,0,0,3, +0,0,8,128,0,0,255,128,2,0,0,128,11,0,0,3, +1,0,8,128,1,0,255,128,45,0,85,160,12,0,0,3, +2,0,1,128,45,0,85,160,1,0,255,128,5,0,0,3, +2,0,2,128,2,0,255,128,0,0,255,128,5,0,0,4, +2,0,14,128,2,0,85,128,10,32,144,160,0,8,228,240, +4,0,0,4,0,0,7,128,2,0,0,128,2,0,249,128, +0,0,228,128,5,0,0,3,2,0,7,128,1,0,255,128, +3,0,228,144,5,0,0,4,2,0,7,128,2,0,228,128, +10,32,228,160,0,8,228,240,5,0,0,3,2,0,7,128, +0,0,255,128,2,0,228,128,10,0,0,3,2,0,7,128, +2,0,228,128,45,0,170,160,2,0,0,3,1,0,7,128, +1,0,228,128,2,0,228,128,29,0,0,0,1,0,0,2, +1,0,7,224,0,0,228,128,1,0,0,2,0,0,7,224, +1,0,228,128,255,255,0,0,83,72,68,82,188,5,0,0, +64,0,240,255,111,1,0,0,89,8,0,4,70,142,32,0, +0,0,0,0,45,0,0,0,95,0,0,3,114,16,16,0, +0,0,0,0,95,0,0,3,114,16,16,0,1,0,0,0, +95,0,0,3,114,16,16,0,2,0,0,0,95,0,0,3, +114,16,16,0,3,0,0,0,95,0,0,3,114,16,16,0, +4,0,0,0,95,0,0,3,114,16,16,0,5,0,0,0, +101,0,0,3,114,32,16,0,0,0,0,0,101,0,0,3, +114,32,16,0,1,0,0,0,104,0,0,2,4,0,0,0, +54,0,0,5,114,0,16,0,0,0,0,0,70,18,16,0, +4,0,0,0,54,0,0,5,114,0,16,0,1,0,0,0, +70,18,16,0,5,0,0,0,54,0,0,5,130,0,16,0, +0,0,0,0,1,64,0,0,0,0,0,0,48,0,0,1, +33,0,0,7,130,0,16,0,1,0,0,0,58,0,16,0, +0,0,0,0,1,64,0,0,4,0,0,0,3,0,4,3, +58,0,16,0,1,0,0,0,50,0,0,16,114,0,16,0, +2,0,0,0,70,18,16,128,65,0,0,0,0,0,0,0, +246,143,32,6,0,0,0,0,18,0,0,0,58,0,16,0, +0,0,0,0,70,130,32,6,0,0,0,0,18,0,0,0, +58,0,16,0,0,0,0,0,16,0,0,7,130,0,16,0, +1,0,0,0,70,2,16,0,2,0,0,0,70,2,16,0, +2,0,0,0,50,0,0,12,130,0,16,0,2,0,0,0, +42,128,32,6,0,0,0,0,26,0,0,0,58,0,16,0, +0,0,0,0,58,0,16,0,1,0,0,0,1,64,0,0, +0,0,128,63,14,0,0,10,130,0,16,0,2,0,0,0, +2,64,0,0,0,0,128,63,0,0,128,63,0,0,128,63, +0,0,128,63,58,0,16,0,2,0,0,0,57,0,0,10, +18,0,16,0,3,0,0,0,1,64,0,0,0,0,0,0, +58,128,32,6,0,0,0,0,18,0,0,0,58,0,16,0, +0,0,0,0,49,0,0,10,34,0,16,0,3,0,0,0, +58,128,32,6,0,0,0,0,26,0,0,0,58,0,16,0, +0,0,0,0,58,0,16,0,1,0,0,0,1,0,0,7, +18,0,16,0,3,0,0,0,26,0,16,0,3,0,0,0, +10,0,16,0,3,0,0,0,55,0,0,9,130,0,16,0, +2,0,0,0,10,0,16,0,3,0,0,0,1,64,0,0, +0,0,0,0,58,0,16,0,2,0,0,0,68,0,0,5, +130,0,16,0,1,0,0,0,58,0,16,0,1,0,0,0, +56,0,0,7,114,0,16,0,3,0,0,0,246,15,16,0, +1,0,0,0,70,2,16,0,2,0,0,0,16,0,0,10, +130,0,16,0,3,0,0,0,70,2,16,0,3,0,0,0, +70,130,32,6,0,0,0,0,34,0,0,0,58,0,16,0, +0,0,0,0,52,0,0,7,130,0,16,0,3,0,0,0, +58,0,16,0,3,0,0,0,1,64,0,0,0,0,0,0, +0,0,0,11,130,0,16,0,3,0,0,0,58,0,16,0, +3,0,0,0,10,128,32,134,65,0,0,0,0,0,0,0, +26,0,0,0,58,0,16,0,0,0,0,0,56,32,0,10, +130,0,16,0,3,0,0,0,58,0,16,0,3,0,0,0, +26,128,32,6,0,0,0,0,26,0,0,0,58,0,16,0, +0,0,0,0,56,0,0,7,130,0,16,0,2,0,0,0, +58,0,16,0,2,0,0,0,58,0,16,0,3,0,0,0, +16,0,0,7,18,0,16,0,3,0,0,0,70,18,16,0, +1,0,0,0,70,2,16,0,3,0,0,0,52,0,0,7, +18,0,16,0,3,0,0,0,10,0,16,0,3,0,0,0, +1,64,0,0,0,0,0,0,56,0,0,7,226,0,16,0, +3,0,0,0,6,0,16,0,3,0,0,0,6,25,16,0, +3,0,0,0,56,0,0,10,226,0,16,0,3,0,0,0, +86,14,16,0,3,0,0,0,6,137,32,6,0,0,0,0, +10,0,0,0,58,0,16,0,0,0,0,0,49,0,0,7, +18,0,16,0,3,0,0,0,1,64,0,0,0,0,0,0, +10,0,16,0,3,0,0,0,31,0,4,3,10,0,16,0, +3,0,0,0,50,0,0,9,114,0,16,0,2,0,0,0, +70,2,16,0,2,0,0,0,246,15,16,0,1,0,0,0, +70,18,16,0,2,0,0,0,16,0,0,7,130,0,16,0, +1,0,0,0,70,2,16,0,2,0,0,0,70,2,16,0, +2,0,0,0,68,0,0,5,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,56,0,0,7,114,0,16,0, +2,0,0,0,246,15,16,0,1,0,0,0,70,2,16,0, +2,0,0,0,16,0,0,7,130,0,16,0,1,0,0,0, +70,18,16,0,1,0,0,0,70,2,16,0,2,0,0,0, +52,0,0,7,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,1,64,0,0,0,0,0,0,47,0,0,5, +130,0,16,0,1,0,0,0,58,0,16,0,1,0,0,0, +56,0,0,8,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,58,128,32,0,0,0,0,0,44,0,0,0, +25,0,0,5,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,51,0,0,7,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,1,64,0,0,0,0,128,63, +56,0,0,7,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,58,0,16,0,2,0,0,0,50,0,0,12, +114,0,16,0,0,0,0,0,246,15,16,0,1,0,0,0, +70,130,32,6,0,0,0,0,10,0,0,0,58,0,16,0, +0,0,0,0,70,2,16,0,0,0,0,0,21,0,0,1, +56,0,0,7,114,0,16,0,2,0,0,0,246,15,16,0, +2,0,0,0,150,7,16,0,3,0,0,0,51,0,0,10, +114,0,16,0,2,0,0,0,70,2,16,0,2,0,0,0, +2,64,0,0,0,0,128,63,0,0,128,63,0,0,128,63, +0,0,0,0,0,0,0,7,114,0,16,0,1,0,0,0, +70,2,16,0,1,0,0,0,70,2,16,0,2,0,0,0, +30,0,0,7,130,0,16,0,0,0,0,0,58,0,16,0, +0,0,0,0,1,64,0,0,1,0,0,0,22,0,0,1, +54,0,0,5,114,32,16,0,1,0,0,0,70,2,16,0, +0,0,0,0,54,0,0,5,114,32,16,0,0,0,0,0, +70,2,16,0,1,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,48,0,0,0,4,0,0,0,0,0,0,0, +8,0,0,0,33,0,0,0,2,0,0,0,1,0,0,0, +1,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +5,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,188,4,0,0, +1,0,0,0,108,0,0,0,1,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,142,4,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,92,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,85,110,105,116, +121,70,70,86,101,114,116,101,120,0,171,171,92,0,0,0, +14,0,0,0,132,0,0,0,240,3,0,0,0,0,0,0, +0,0,0,0,180,2,0,0,0,0,0,0,64,0,0,0, +0,0,0,0,204,2,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,240,2,0,0, +64,0,0,0,64,0,0,0,0,0,0,0,204,2,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,253,2,0,0,128,0,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,56,3,0,0, +144,0,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,71,3,0,0,160,0,0,0,128,0,0,0, +2,0,0,0,88,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,124,3,0,0, +32,1,0,0,128,0,0,0,2,0,0,0,140,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,176,3,0,0,160,1,0,0,128,0,0,0, +2,0,0,0,192,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,228,3,0,0, +32,2,0,0,128,0,0,0,2,0,0,0,244,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,24,4,0,0,160,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,39,4,0,0, +176,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,54,4,0,0,192,2,0,0,16,0,0,0, +2,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,66,4,0,0, +208,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,82,4,0,0,224,2,0,0,0,1,0,0, +0,0,0,0,96,4,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,132,4,0,0, +224,3,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,102,102,95,109,97,116,114,105,120,95,109,118, +112,0,102,108,111,97,116,52,120,52,0,171,3,0,3,0, +4,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,194,2,0,0, +102,102,95,109,97,116,114,105,120,95,109,118,0,102,102,95, +118,101,99,95,99,111,108,111,114,0,102,108,111,97,116,52, +0,171,171,171,1,0,3,0,1,0,4,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,118,101,99,95,97, +109,98,105,101,110,116,0,102,102,95,108,105,103,104,116,95, +99,111,108,111,114,0,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,112,111,115,0,171,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,97,116,116,101,110,0,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,115,112,111, +116,0,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,109,97,116,95,100, +105,102,102,117,115,101,0,102,102,95,109,97,116,95,97,109, +98,105,101,110,116,0,102,102,95,109,97,116,95,115,112,101, +99,0,102,102,95,109,97,116,95,101,109,105,115,115,105,111, +110,0,102,102,95,109,97,116,114,105,120,95,116,101,120,0, +3,0,3,0,4,0,4,0,4,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +194,2,0,0,102,102,95,102,111,103,95,118,115,0,77,105, +99,114,111,115,111,102,116,32,40,82,41,32,72,76,83,76, +32,83,104,97,100,101,114,32,67,111,109,112,105,108,101,114, +32,54,46,51,46,57,52,49,53,46,48,0,76,70,83,48, +168,1,0,0,7,0,0,0,8,0,0,0,88,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,2,0,0,0,255,255,255,255, +255,255,255,255,0,0,0,0,0,0,0,0,110,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,122,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,132,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,140,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,153,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,3,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,163,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,5,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,67,111,109,112, +117,116,101,83,112,111,116,76,105,103,104,116,83,112,101,99, +52,0,101,121,101,80,111,115,105,116,105,111,110,0,101,121, +101,78,111,114,109,97,108,0,118,105,101,119,68,105,114,0, +100,105,102,102,117,115,101,67,111,108,111,114,0,115,112,101, +99,67,111,108,111,114,0,97,109,98,0,171,76,73,66,70, +180,19,0,0,68,88,66,67,240,160,5,118,168,200,121,161, +74,215,24,12,8,202,65,250,1,0,0,0,180,19,0,0, +5,0,0,0,52,0,0,0,168,8,0,0,200,12,0,0, +68,13,0,0,8,18,0,0,65,111,110,57,108,8,0,0, +108,8,0,0,0,2,86,76,24,8,0,0,84,0,0,0, +4,0,36,0,0,0,84,0,0,0,84,0,0,0,36,0, +0,0,84,0,0,0,10,0,5,0,0,0,0,0,0,0, +0,0,18,0,5,0,5,0,0,0,0,0,0,0,26,0, +5,0,10,0,0,0,0,0,0,0,34,0,5,0,15,0, +0,0,0,0,0,2,86,76,81,0,0,5,20,0,15,160, +0,0,128,63,0,0,0,0,0,0,0,0,0,0,0,0, +31,0,0,2,5,0,0,128,0,0,15,144,31,0,0,2, +5,0,1,128,1,0,15,144,31,0,0,2,5,0,3,128, +3,0,15,144,31,0,0,2,5,0,4,128,4,0,15,144, +31,0,0,2,5,0,5,128,5,0,15,144,5,0,0,3, +0,0,1,128,5,0,255,160,5,0,255,160,12,0,0,3, +0,0,1,128,0,0,0,129,0,0,0,128,4,0,0,4, +0,0,14,128,0,0,144,144,5,0,255,161,5,0,144,160, +8,0,0,3,1,0,1,128,0,0,249,128,0,0,249,128, +12,0,0,3,1,0,2,128,10,0,255,160,1,0,0,128, +5,0,0,3,0,0,1,128,0,0,0,128,1,0,85,128, +1,0,0,2,2,0,1,128,20,0,0,160,4,0,0,4, +1,0,2,128,10,0,170,160,1,0,0,128,2,0,0,128, +7,0,0,2,1,0,1,128,1,0,0,128,5,0,0,3, +0,0,14,128,0,0,228,128,1,0,0,128,6,0,0,2, +1,0,1,128,1,0,85,128,4,0,0,4,0,0,1,128, +0,0,0,128,1,0,0,129,1,0,0,128,8,0,0,3, +1,0,1,128,0,0,249,128,15,0,228,160,8,0,0,3, +0,0,2,128,1,0,228,144,0,0,249,128,11,0,0,3, +0,0,2,128,0,0,85,128,20,0,85,160,5,0,0,3, +0,0,14,128,0,0,85,128,3,0,144,144,5,0,0,3, +0,0,14,128,0,0,228,128,0,0,144,160,11,0,0,3, +1,0,1,128,1,0,0,128,20,0,85,160,2,0,0,3, +1,0,1,128,1,0,0,128,10,0,0,161,5,0,0,3, +1,0,1,128,1,0,0,128,10,0,85,160,11,0,0,3, +1,0,1,128,1,0,0,128,20,0,85,160,10,0,0,3, +1,0,1,128,1,0,0,128,20,0,0,160,5,0,0,3, +0,0,1,128,0,0,0,128,1,0,0,128,5,0,0,3, +0,0,7,128,0,0,0,128,0,0,249,128,10,0,0,3, +0,0,7,128,0,0,228,128,20,0,0,160,2,0,0,3, +0,0,7,128,0,0,228,128,5,0,228,144,5,0,0,3, +0,0,8,128,6,0,255,160,6,0,255,160,12,0,0,3, +0,0,8,128,0,0,255,129,0,0,255,128,4,0,0,4, +1,0,7,128,0,0,228,144,6,0,255,161,6,0,228,160, +8,0,0,3,1,0,8,128,1,0,228,128,1,0,228,128, +12,0,0,3,2,0,2,128,11,0,255,160,1,0,255,128, +5,0,0,3,0,0,8,128,0,0,255,128,2,0,85,128, +4,0,0,4,2,0,2,128,11,0,170,160,1,0,255,128, +2,0,0,128,7,0,0,2,1,0,8,128,1,0,255,128, +5,0,0,3,1,0,7,128,1,0,255,128,1,0,228,128, +6,0,0,2,1,0,8,128,2,0,85,128,4,0,0,4, +0,0,8,128,0,0,255,128,1,0,255,129,1,0,255,128, +8,0,0,3,1,0,8,128,1,0,228,128,16,0,228,160, +8,0,0,3,1,0,1,128,1,0,228,144,1,0,228,128, +11,0,0,3,1,0,9,128,1,0,228,128,20,0,85,160, +5,0,0,3,1,0,7,128,1,0,0,128,3,0,228,144, +5,0,0,3,1,0,7,128,1,0,228,128,1,0,228,160, +2,0,0,3,1,0,8,128,1,0,255,128,11,0,0,161, +5,0,0,3,1,0,8,128,1,0,255,128,11,0,85,160, +11,0,0,3,1,0,8,128,1,0,255,128,20,0,85,160, +10,0,0,3,1,0,8,128,1,0,255,128,20,0,0,160, +5,0,0,3,0,0,8,128,0,0,255,128,1,0,255,128, +5,0,0,3,1,0,7,128,0,0,255,128,1,0,228,128, +10,0,0,3,1,0,7,128,1,0,228,128,20,0,0,160, +2,0,0,3,0,0,7,128,0,0,228,128,1,0,228,128, +5,0,0,3,0,0,8,128,7,0,255,160,7,0,255,160, +12,0,0,3,0,0,8,128,0,0,255,129,0,0,255,128, +4,0,0,4,1,0,7,128,0,0,228,144,7,0,255,161, +7,0,228,160,8,0,0,3,1,0,8,128,1,0,228,128, +1,0,228,128,12,0,0,3,2,0,2,128,12,0,255,160, +1,0,255,128,5,0,0,3,0,0,8,128,0,0,255,128, +2,0,85,128,4,0,0,4,2,0,2,128,12,0,170,160, +1,0,255,128,2,0,0,128,7,0,0,2,1,0,8,128, +1,0,255,128,5,0,0,3,1,0,7,128,1,0,255,128, +1,0,228,128,6,0,0,2,1,0,8,128,2,0,85,128, +4,0,0,4,0,0,8,128,0,0,255,128,1,0,255,129, +1,0,255,128,8,0,0,3,1,0,8,128,1,0,228,128, +17,0,228,160,8,0,0,3,1,0,1,128,1,0,228,144, +1,0,228,128,11,0,0,3,1,0,9,128,1,0,228,128, +20,0,85,160,5,0,0,3,1,0,7,128,1,0,0,128, +3,0,228,144,5,0,0,3,1,0,7,128,1,0,228,128, +2,0,228,160,2,0,0,3,1,0,8,128,1,0,255,128, +12,0,0,161,5,0,0,3,1,0,8,128,1,0,255,128, +12,0,85,160,11,0,0,3,1,0,8,128,1,0,255,128, +20,0,85,160,10,0,0,3,1,0,8,128,1,0,255,128, +20,0,0,160,5,0,0,3,0,0,8,128,0,0,255,128, +1,0,255,128,5,0,0,3,1,0,7,128,0,0,255,128, +1,0,228,128,10,0,0,3,1,0,7,128,1,0,228,128, +20,0,0,160,2,0,0,3,0,0,7,128,0,0,228,128, +1,0,228,128,5,0,0,3,0,0,8,128,8,0,255,160, +8,0,255,160,12,0,0,3,0,0,8,128,0,0,255,129, +0,0,255,128,4,0,0,4,1,0,7,128,0,0,228,144, +8,0,255,161,8,0,228,160,8,0,0,3,1,0,8,128, +1,0,228,128,1,0,228,128,12,0,0,3,2,0,2,128, +13,0,255,160,1,0,255,128,5,0,0,3,0,0,8,128, +0,0,255,128,2,0,85,128,4,0,0,4,2,0,2,128, +13,0,170,160,1,0,255,128,2,0,0,128,7,0,0,2, +1,0,8,128,1,0,255,128,5,0,0,3,1,0,7,128, +1,0,255,128,1,0,228,128,6,0,0,2,1,0,8,128, +2,0,85,128,4,0,0,4,0,0,8,128,0,0,255,128, +1,0,255,129,1,0,255,128,8,0,0,3,1,0,8,128, +1,0,228,128,18,0,228,160,8,0,0,3,1,0,1,128, +1,0,228,144,1,0,228,128,11,0,0,3,1,0,9,128, +1,0,228,128,20,0,85,160,5,0,0,3,1,0,7,128, +1,0,0,128,3,0,228,144,5,0,0,3,1,0,7,128, +1,0,228,128,3,0,228,160,2,0,0,3,1,0,8,128, +1,0,255,128,13,0,0,161,5,0,0,3,1,0,8,128, +1,0,255,128,13,0,85,160,11,0,0,3,1,0,8,128, +1,0,255,128,20,0,85,160,10,0,0,3,1,0,8,128, +1,0,255,128,20,0,0,160,5,0,0,3,0,0,8,128, +0,0,255,128,1,0,255,128,5,0,0,3,1,0,7,128, +0,0,255,128,1,0,228,128,10,0,0,3,1,0,7,128, +1,0,228,128,20,0,0,160,2,0,0,3,0,0,7,128, +0,0,228,128,1,0,228,128,5,0,0,3,0,0,8,128, +9,0,255,160,9,0,255,160,12,0,0,3,0,0,8,128, +0,0,255,129,0,0,255,128,4,0,0,4,1,0,7,128, +0,0,228,144,9,0,255,161,9,0,228,160,8,0,0,3, +1,0,8,128,1,0,228,128,1,0,228,128,12,0,0,3, +2,0,2,128,14,0,255,160,1,0,255,128,5,0,0,3, +0,0,8,128,0,0,255,128,2,0,85,128,4,0,0,4, +2,0,1,128,14,0,170,160,1,0,255,128,2,0,0,128, +7,0,0,2,1,0,8,128,1,0,255,128,5,0,0,3, +1,0,7,128,1,0,255,128,1,0,228,128,6,0,0,2, +1,0,8,128,2,0,0,128,4,0,0,4,0,0,8,128, +0,0,255,128,1,0,255,129,1,0,255,128,8,0,0,3, +1,0,8,128,1,0,228,128,19,0,228,160,8,0,0,3, +1,0,1,128,1,0,228,144,1,0,228,128,11,0,0,3, +1,0,9,128,1,0,228,128,20,0,85,160,5,0,0,3, +1,0,7,128,1,0,0,128,3,0,228,144,5,0,0,3, +1,0,7,128,1,0,228,128,4,0,228,160,2,0,0,3, +1,0,8,128,1,0,255,128,14,0,0,161,5,0,0,3, +1,0,8,128,1,0,255,128,14,0,85,160,11,0,0,3, +1,0,8,128,1,0,255,128,20,0,85,160,10,0,0,3, +1,0,8,128,1,0,255,128,20,0,0,160,5,0,0,3, +0,0,8,128,0,0,255,128,1,0,255,128,5,0,0,3, +1,0,7,128,0,0,255,128,1,0,228,128,10,0,0,3, +1,0,7,128,1,0,228,128,20,0,0,160,2,0,0,3, +0,0,7,224,0,0,228,128,1,0,228,128,1,0,0,2, +1,0,7,224,4,0,228,144,255,255,0,0,83,72,68,82, +24,4,0,0,64,0,240,255,6,1,0,0,89,8,0,4, +70,142,32,0,0,0,0,0,40,0,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,95,0,0,3,114,16,16,0, +1,0,0,0,95,0,0,3,114,16,16,0,3,0,0,0, +95,0,0,3,114,16,16,0,4,0,0,0,95,0,0,3, +114,16,16,0,5,0,0,0,101,0,0,3,114,32,16,0, +0,0,0,0,101,0,0,3,114,32,16,0,1,0,0,0, +104,0,0,2,3,0,0,0,54,0,0,5,114,0,16,0, +0,0,0,0,70,18,16,0,5,0,0,0,54,0,0,5, +130,0,16,0,0,0,0,0,1,64,0,0,0,0,0,0, +48,0,0,1,33,0,0,7,18,0,16,0,1,0,0,0, +58,0,16,0,0,0,0,0,1,64,0,0,5,0,0,0, +3,0,4,3,10,0,16,0,1,0,0,0,50,0,0,16, +114,0,16,0,1,0,0,0,70,18,16,128,65,0,0,0, +0,0,0,0,246,143,32,6,0,0,0,0,18,0,0,0, +58,0,16,0,0,0,0,0,70,130,32,6,0,0,0,0, +18,0,0,0,58,0,16,0,0,0,0,0,16,0,0,7, +130,0,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +70,2,16,0,1,0,0,0,50,0,0,12,18,0,16,0, +2,0,0,0,42,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,58,0,16,0,1,0,0,0, +1,64,0,0,0,0,128,63,14,0,0,10,18,0,16,0, +2,0,0,0,2,64,0,0,0,0,128,63,0,0,128,63, +0,0,128,63,0,0,128,63,10,0,16,0,2,0,0,0, +57,0,0,10,34,0,16,0,2,0,0,0,1,64,0,0, +0,0,0,0,58,128,32,6,0,0,0,0,18,0,0,0, +58,0,16,0,0,0,0,0,49,0,0,10,66,0,16,0, +2,0,0,0,58,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,58,0,16,0,1,0,0,0, +1,0,0,7,34,0,16,0,2,0,0,0,42,0,16,0, +2,0,0,0,26,0,16,0,2,0,0,0,55,0,0,9, +18,0,16,0,2,0,0,0,26,0,16,0,2,0,0,0, +1,64,0,0,0,0,0,0,10,0,16,0,2,0,0,0, +68,0,0,5,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,56,0,0,7,114,0,16,0,1,0,0,0, +246,15,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +16,0,0,10,130,0,16,0,1,0,0,0,70,2,16,0, +1,0,0,0,70,130,32,6,0,0,0,0,34,0,0,0, +58,0,16,0,0,0,0,0,52,0,0,7,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,1,64,0,0, +0,0,0,0,0,0,0,11,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,10,128,32,134,65,0,0,0, +0,0,0,0,26,0,0,0,58,0,16,0,0,0,0,0, +56,32,0,10,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,26,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,56,0,0,7,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,10,0,16,0, +2,0,0,0,16,0,0,7,18,0,16,0,1,0,0,0, +70,18,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +52,0,0,7,18,0,16,0,1,0,0,0,10,0,16,0, +1,0,0,0,1,64,0,0,0,0,0,0,56,0,0,7, +114,0,16,0,1,0,0,0,6,0,16,0,1,0,0,0, +70,18,16,0,3,0,0,0,56,0,0,10,114,0,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,70,130,32,6, +0,0,0,0,10,0,0,0,58,0,16,0,0,0,0,0, +56,0,0,7,114,0,16,0,1,0,0,0,246,15,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,51,0,0,10, +114,0,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +2,64,0,0,0,0,128,63,0,0,128,63,0,0,128,63, +0,0,0,0,0,0,0,7,114,0,16,0,0,0,0,0, +70,2,16,0,0,0,0,0,70,2,16,0,1,0,0,0, +30,0,0,7,130,0,16,0,0,0,0,0,58,0,16,0, +0,0,0,0,1,64,0,0,1,0,0,0,22,0,0,1, +54,0,0,5,114,32,16,0,0,0,0,0,70,2,16,0, +0,0,0,0,54,0,0,5,114,32,16,0,1,0,0,0, +70,18,16,0,4,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,32,0,0,0,3,0,0,0,0,0,0,0, +7,0,0,0,20,0,0,0,2,0,0,0,1,0,0,0, +1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +4,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,188,4,0,0, +1,0,0,0,108,0,0,0,1,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,142,4,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,92,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,85,110,105,116, +121,70,70,86,101,114,116,101,120,0,171,171,92,0,0,0, +14,0,0,0,132,0,0,0,240,3,0,0,0,0,0,0, +0,0,0,0,180,2,0,0,0,0,0,0,64,0,0,0, +0,0,0,0,204,2,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,240,2,0,0, +64,0,0,0,64,0,0,0,0,0,0,0,204,2,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,253,2,0,0,128,0,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,56,3,0,0, +144,0,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,71,3,0,0,160,0,0,0,128,0,0,0, +2,0,0,0,88,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,124,3,0,0, +32,1,0,0,128,0,0,0,2,0,0,0,140,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,176,3,0,0,160,1,0,0,128,0,0,0, +2,0,0,0,192,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,228,3,0,0, +32,2,0,0,128,0,0,0,2,0,0,0,244,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,24,4,0,0,160,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,39,4,0,0, +176,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,54,4,0,0,192,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,66,4,0,0, +208,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,82,4,0,0,224,2,0,0,0,1,0,0, +0,0,0,0,96,4,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,132,4,0,0, +224,3,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,102,102,95,109,97,116,114,105,120,95,109,118, +112,0,102,108,111,97,116,52,120,52,0,171,3,0,3,0, +4,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,194,2,0,0, +102,102,95,109,97,116,114,105,120,95,109,118,0,102,102,95, +118,101,99,95,99,111,108,111,114,0,102,108,111,97,116,52, +0,171,171,171,1,0,3,0,1,0,4,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,118,101,99,95,97, +109,98,105,101,110,116,0,102,102,95,108,105,103,104,116,95, +99,111,108,111,114,0,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,112,111,115,0,171,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,97,116,116,101,110,0,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,115,112,111, +116,0,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,109,97,116,95,100, +105,102,102,117,115,101,0,102,102,95,109,97,116,95,97,109, +98,105,101,110,116,0,102,102,95,109,97,116,95,115,112,101, +99,0,102,102,95,109,97,116,95,101,109,105,115,115,105,111, +110,0,102,102,95,109,97,116,114,105,120,95,116,101,120,0, +3,0,3,0,4,0,4,0,4,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +194,2,0,0,102,102,95,102,111,103,95,118,115,0,77,105, +99,114,111,115,111,102,116,32,40,82,41,32,72,76,83,76, +32,83,104,97,100,101,114,32,67,111,109,112,105,108,101,114, +32,54,46,51,46,57,52,49,53,46,48,0,76,70,83,48, +164,1,0,0,7,0,0,0,8,0,0,0,88,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,2,0,0,0,255,255,255,255, +255,255,255,255,0,0,0,0,0,0,0,0,106,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,118,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,128,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,136,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,149,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,3,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,159,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,5,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,67,111,109,112, +117,116,101,83,112,111,116,76,105,103,104,116,53,0,101,121, +101,80,111,115,105,116,105,111,110,0,101,121,101,78,111,114, +109,97,108,0,118,105,101,119,68,105,114,0,100,105,102,102, +117,115,101,67,111,108,111,114,0,115,112,101,99,67,111,108, +111,114,0,97,109,98,0,171,76,73,66,70,80,16,0,0, +68,88,66,67,89,78,131,151,228,245,82,121,136,215,111,193, +160,210,121,165,1,0,0,0,80,16,0,0,5,0,0,0, +52,0,0,0,156,3,0,0,96,9,0,0,220,9,0,0, +160,14,0,0,65,111,110,57,96,3,0,0,96,3,0,0, +0,2,86,76,48,3,0,0,48,0,0,0,1,0,36,0, +0,0,48,0,0,0,48,0,0,0,36,0,0,0,48,0, +0,0,0,0,45,0,0,0,0,0,0,0,0,2,86,76, +81,0,0,5,45,0,15,160,0,0,0,0,0,0,0,0, +0,0,128,63,0,0,0,0,48,0,0,5,0,0,15,240, +5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +31,0,0,2,5,0,0,128,0,0,15,144,31,0,0,2, +5,0,1,128,1,0,15,144,31,0,0,2,5,0,2,128, +2,0,15,144,31,0,0,2,5,0,3,128,3,0,15,144, +31,0,0,2,5,0,4,128,4,0,15,144,31,0,0,2, +5,0,5,128,5,0,15,144,1,0,0,2,0,0,7,128, +4,0,228,144,1,0,0,2,1,0,7,128,5,0,228,144, +27,0,0,2,0,8,228,240,0,0,228,240,4,0,0,6, +2,0,7,128,0,0,228,144,18,32,255,161,0,8,228,240, +18,32,228,160,0,8,228,240,8,0,0,3,0,0,8,128, +2,0,228,128,2,0,228,128,7,0,0,2,1,0,8,128, +0,0,255,128,4,0,0,4,3,0,7,128,2,0,228,128, +1,0,255,128,2,0,228,144,36,0,0,2,4,0,7,128, +3,0,228,128,8,0,0,3,2,0,8,128,1,0,228,144, +4,0,228,128,5,0,0,5,3,0,1,128,18,32,255,160, +0,8,228,240,18,32,255,160,0,8,228,240,12,0,0,3, +3,0,1,128,3,0,0,129,3,0,0,128,12,0,0,4, +3,0,2,128,26,32,255,160,0,8,228,240,0,0,255,128, +5,0,0,3,3,0,1,128,3,0,85,128,3,0,0,128, +5,0,0,4,0,0,8,128,0,0,255,128,26,32,170,160, +0,8,228,240,2,0,0,3,0,0,8,128,0,0,255,128, +45,0,170,160,6,0,0,2,0,0,8,128,0,0,255,128, +4,0,0,4,0,0,8,128,3,0,0,128,0,0,255,129, +0,0,255,128,11,0,0,3,2,0,8,128,2,0,255,128, +45,0,85,160,32,0,0,3,3,0,1,128,2,0,255,128, +44,0,255,160,10,0,0,3,2,0,8,128,3,0,0,128, +45,0,170,160,5,0,0,3,2,0,7,128,1,0,255,128, +2,0,228,128,8,0,0,3,1,0,8,128,1,0,228,144, +2,0,228,128,8,0,0,4,2,0,1,128,2,0,228,128, +34,32,228,160,0,8,228,240,11,0,0,3,2,0,1,128, +2,0,0,128,45,0,85,160,2,0,0,4,2,0,1,128, +2,0,0,128,26,32,0,161,0,8,228,240,5,0,0,4, +2,0,1,128,2,0,0,128,26,32,85,160,0,8,228,240, +11,0,0,3,2,0,1,128,2,0,0,128,45,0,85,160, +10,0,0,3,2,0,1,128,2,0,0,128,45,0,170,160, +5,0,0,3,0,0,8,128,0,0,255,128,2,0,0,128, +11,0,0,3,1,0,8,128,1,0,255,128,45,0,85,160, +12,0,0,3,2,0,1,128,45,0,85,160,1,0,255,128, +5,0,0,3,2,0,2,128,2,0,255,128,0,0,255,128, +5,0,0,4,2,0,14,128,2,0,85,128,10,32,144,160, +0,8,228,240,4,0,0,4,0,0,7,128,2,0,0,128, +2,0,249,128,0,0,228,128,5,0,0,3,2,0,7,128, +1,0,255,128,3,0,228,144,5,0,0,4,2,0,7,128, +2,0,228,128,10,32,228,160,0,8,228,240,5,0,0,3, +2,0,7,128,0,0,255,128,2,0,228,128,10,0,0,3, +2,0,7,128,2,0,228,128,45,0,170,160,2,0,0,3, +1,0,7,128,1,0,228,128,2,0,228,128,29,0,0,0, +1,0,0,2,1,0,7,224,0,0,228,128,1,0,0,2, +0,0,7,224,1,0,228,128,255,255,0,0,83,72,68,82, +188,5,0,0,64,0,240,255,111,1,0,0,89,8,0,4, +70,142,32,0,0,0,0,0,45,0,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,95,0,0,3,114,16,16,0, +1,0,0,0,95,0,0,3,114,16,16,0,2,0,0,0, +95,0,0,3,114,16,16,0,3,0,0,0,95,0,0,3, +114,16,16,0,4,0,0,0,95,0,0,3,114,16,16,0, +5,0,0,0,101,0,0,3,114,32,16,0,0,0,0,0, +101,0,0,3,114,32,16,0,1,0,0,0,104,0,0,2, +4,0,0,0,54,0,0,5,114,0,16,0,0,0,0,0, +70,18,16,0,4,0,0,0,54,0,0,5,114,0,16,0, +1,0,0,0,70,18,16,0,5,0,0,0,54,0,0,5, +130,0,16,0,0,0,0,0,1,64,0,0,0,0,0,0, +48,0,0,1,33,0,0,7,130,0,16,0,1,0,0,0, +58,0,16,0,0,0,0,0,1,64,0,0,5,0,0,0, +3,0,4,3,58,0,16,0,1,0,0,0,50,0,0,16, +114,0,16,0,2,0,0,0,70,18,16,128,65,0,0,0, +0,0,0,0,246,143,32,6,0,0,0,0,18,0,0,0, +58,0,16,0,0,0,0,0,70,130,32,6,0,0,0,0, +18,0,0,0,58,0,16,0,0,0,0,0,16,0,0,7, +130,0,16,0,1,0,0,0,70,2,16,0,2,0,0,0, +70,2,16,0,2,0,0,0,50,0,0,12,130,0,16,0, +2,0,0,0,42,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,58,0,16,0,1,0,0,0, +1,64,0,0,0,0,128,63,14,0,0,10,130,0,16,0, +2,0,0,0,2,64,0,0,0,0,128,63,0,0,128,63, +0,0,128,63,0,0,128,63,58,0,16,0,2,0,0,0, +57,0,0,10,18,0,16,0,3,0,0,0,1,64,0,0, +0,0,0,0,58,128,32,6,0,0,0,0,18,0,0,0, +58,0,16,0,0,0,0,0,49,0,0,10,34,0,16,0, +3,0,0,0,58,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,58,0,16,0,1,0,0,0, +1,0,0,7,18,0,16,0,3,0,0,0,26,0,16,0, +3,0,0,0,10,0,16,0,3,0,0,0,55,0,0,9, +130,0,16,0,2,0,0,0,10,0,16,0,3,0,0,0, +1,64,0,0,0,0,0,0,58,0,16,0,2,0,0,0, +68,0,0,5,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,56,0,0,7,114,0,16,0,3,0,0,0, +246,15,16,0,1,0,0,0,70,2,16,0,2,0,0,0, +16,0,0,10,130,0,16,0,3,0,0,0,70,2,16,0, +3,0,0,0,70,130,32,6,0,0,0,0,34,0,0,0, +58,0,16,0,0,0,0,0,52,0,0,7,130,0,16,0, +3,0,0,0,58,0,16,0,3,0,0,0,1,64,0,0, +0,0,0,0,0,0,0,11,130,0,16,0,3,0,0,0, +58,0,16,0,3,0,0,0,10,128,32,134,65,0,0,0, +0,0,0,0,26,0,0,0,58,0,16,0,0,0,0,0, +56,32,0,10,130,0,16,0,3,0,0,0,58,0,16,0, +3,0,0,0,26,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,56,0,0,7,130,0,16,0, +2,0,0,0,58,0,16,0,2,0,0,0,58,0,16,0, +3,0,0,0,16,0,0,7,18,0,16,0,3,0,0,0, +70,18,16,0,1,0,0,0,70,2,16,0,3,0,0,0, +52,0,0,7,18,0,16,0,3,0,0,0,10,0,16,0, +3,0,0,0,1,64,0,0,0,0,0,0,56,0,0,7, +226,0,16,0,3,0,0,0,6,0,16,0,3,0,0,0, +6,25,16,0,3,0,0,0,56,0,0,10,226,0,16,0, +3,0,0,0,86,14,16,0,3,0,0,0,6,137,32,6, +0,0,0,0,10,0,0,0,58,0,16,0,0,0,0,0, +49,0,0,7,18,0,16,0,3,0,0,0,1,64,0,0, +0,0,0,0,10,0,16,0,3,0,0,0,31,0,4,3, +10,0,16,0,3,0,0,0,50,0,0,9,114,0,16,0, +2,0,0,0,70,2,16,0,2,0,0,0,246,15,16,0, +1,0,0,0,70,18,16,0,2,0,0,0,16,0,0,7, +130,0,16,0,1,0,0,0,70,2,16,0,2,0,0,0, +70,2,16,0,2,0,0,0,68,0,0,5,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,56,0,0,7, +114,0,16,0,2,0,0,0,246,15,16,0,1,0,0,0, +70,2,16,0,2,0,0,0,16,0,0,7,130,0,16,0, +1,0,0,0,70,18,16,0,1,0,0,0,70,2,16,0, +2,0,0,0,52,0,0,7,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,1,64,0,0,0,0,0,0, +47,0,0,5,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,56,0,0,8,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,58,128,32,0,0,0,0,0, +44,0,0,0,25,0,0,5,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,51,0,0,7,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,1,64,0,0, +0,0,128,63,56,0,0,7,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,58,0,16,0,2,0,0,0, +50,0,0,12,114,0,16,0,0,0,0,0,246,15,16,0, +1,0,0,0,70,130,32,6,0,0,0,0,10,0,0,0, +58,0,16,0,0,0,0,0,70,2,16,0,0,0,0,0, +21,0,0,1,56,0,0,7,114,0,16,0,2,0,0,0, +246,15,16,0,2,0,0,0,150,7,16,0,3,0,0,0, +51,0,0,10,114,0,16,0,2,0,0,0,70,2,16,0, +2,0,0,0,2,64,0,0,0,0,128,63,0,0,128,63, +0,0,128,63,0,0,0,0,0,0,0,7,114,0,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,70,2,16,0, +2,0,0,0,30,0,0,7,130,0,16,0,0,0,0,0, +58,0,16,0,0,0,0,0,1,64,0,0,1,0,0,0, +22,0,0,1,54,0,0,5,114,32,16,0,1,0,0,0, +70,2,16,0,0,0,0,0,54,0,0,5,114,32,16,0, +0,0,0,0,70,2,16,0,1,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,48,0,0,0,4,0,0,0, +0,0,0,0,8,0,0,0,33,0,0,0,2,0,0,0, +1,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,5,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +188,4,0,0,1,0,0,0,108,0,0,0,1,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,142,4,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +85,110,105,116,121,70,70,86,101,114,116,101,120,0,171,171, +92,0,0,0,14,0,0,0,132,0,0,0,240,3,0,0, +0,0,0,0,0,0,0,0,180,2,0,0,0,0,0,0, +64,0,0,0,0,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +240,2,0,0,64,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,253,2,0,0,128,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +56,3,0,0,144,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,71,3,0,0,160,0,0,0, +128,0,0,0,2,0,0,0,88,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +124,3,0,0,32,1,0,0,128,0,0,0,2,0,0,0, +140,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,176,3,0,0,160,1,0,0, +128,0,0,0,2,0,0,0,192,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +228,3,0,0,32,2,0,0,128,0,0,0,2,0,0,0, +244,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,24,4,0,0,160,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +39,4,0,0,176,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,54,4,0,0,192,2,0,0, +16,0,0,0,2,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +66,4,0,0,208,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,82,4,0,0,224,2,0,0, +0,1,0,0,0,0,0,0,96,4,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +132,4,0,0,224,3,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,102,102,95,109,97,116,114,105, +120,95,109,118,112,0,102,108,111,97,116,52,120,52,0,171, +3,0,3,0,4,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +194,2,0,0,102,102,95,109,97,116,114,105,120,95,109,118, +0,102,102,95,118,101,99,95,99,111,108,111,114,0,102,108, +111,97,116,52,0,171,171,171,1,0,3,0,1,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,118, +101,99,95,97,109,98,105,101,110,116,0,102,102,95,108,105, +103,104,116,95,99,111,108,111,114,0,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,112,111,115,0,171,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,97,116,116, +101,110,0,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,115,112,111,116,0,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,109, +97,116,95,100,105,102,102,117,115,101,0,102,102,95,109,97, +116,95,97,109,98,105,101,110,116,0,102,102,95,109,97,116, +95,115,112,101,99,0,102,102,95,109,97,116,95,101,109,105, +115,115,105,111,110,0,102,102,95,109,97,116,114,105,120,95, +116,101,120,0,3,0,3,0,4,0,4,0,4,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,194,2,0,0,102,102,95,102,111,103,95,118, +115,0,77,105,99,114,111,115,111,102,116,32,40,82,41,32, +72,76,83,76,32,83,104,97,100,101,114,32,67,111,109,112, +105,108,101,114,32,54,46,51,46,57,52,49,53,46,48,0, +76,70,83,48,168,1,0,0,7,0,0,0,8,0,0,0, +88,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,2,0,0,0, +255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0, +110,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +122,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,1,0,0,0, +1,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +132,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,1,0,0,0, +2,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +140,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +153,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,3,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +163,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,1,0,0,0, +5,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +67,111,109,112,117,116,101,83,112,111,116,76,105,103,104,116, +83,112,101,99,53,0,101,121,101,80,111,115,105,116,105,111, +110,0,101,121,101,78,111,114,109,97,108,0,118,105,101,119, +68,105,114,0,100,105,102,102,117,115,101,67,111,108,111,114, +0,115,112,101,99,67,111,108,111,114,0,97,109,98,0,171, +76,73,66,70,56,21,0,0,68,88,66,67,116,246,90,100, +53,210,241,155,159,216,173,93,60,139,208,144,1,0,0,0, +56,21,0,0,5,0,0,0,52,0,0,0,44,10,0,0, +76,14,0,0,200,14,0,0,140,19,0,0,65,111,110,57, +240,9,0,0,240,9,0,0,0,2,86,76,156,9,0,0, +84,0,0,0,4,0,36,0,0,0,84,0,0,0,84,0, +0,0,36,0,0,0,84,0,0,0,10,0,6,0,0,0, +0,0,0,0,0,0,18,0,6,0,6,0,0,0,0,0, +0,0,26,0,6,0,12,0,0,0,0,0,0,0,34,0, +6,0,18,0,0,0,0,0,0,2,86,76,81,0,0,5, +24,0,15,160,0,0,128,63,0,0,0,0,0,0,0,0, +0,0,0,0,31,0,0,2,5,0,0,128,0,0,15,144, +31,0,0,2,5,0,1,128,1,0,15,144,31,0,0,2, +5,0,3,128,3,0,15,144,31,0,0,2,5,0,4,128, +4,0,15,144,31,0,0,2,5,0,5,128,5,0,15,144, +5,0,0,3,0,0,1,128,6,0,255,160,6,0,255,160, +12,0,0,3,0,0,1,128,0,0,0,129,0,0,0,128, +4,0,0,4,0,0,14,128,0,0,144,144,6,0,255,161, +6,0,144,160,8,0,0,3,1,0,1,128,0,0,249,128, +0,0,249,128,12,0,0,3,1,0,2,128,12,0,255,160, +1,0,0,128,5,0,0,3,0,0,1,128,0,0,0,128, +1,0,85,128,1,0,0,2,2,0,1,128,24,0,0,160, +4,0,0,4,1,0,2,128,12,0,170,160,1,0,0,128, +2,0,0,128,7,0,0,2,1,0,1,128,1,0,0,128, +5,0,0,3,0,0,14,128,0,0,228,128,1,0,0,128, +6,0,0,2,1,0,1,128,1,0,85,128,4,0,0,4, +0,0,1,128,0,0,0,128,1,0,0,129,1,0,0,128, +8,0,0,3,1,0,1,128,0,0,249,128,18,0,228,160, +8,0,0,3,0,0,2,128,1,0,228,144,0,0,249,128, +11,0,0,3,0,0,2,128,0,0,85,128,24,0,85,160, +5,0,0,3,0,0,14,128,0,0,85,128,3,0,144,144, +5,0,0,3,0,0,14,128,0,0,228,128,0,0,144,160, +11,0,0,3,1,0,1,128,1,0,0,128,24,0,85,160, +2,0,0,3,1,0,1,128,1,0,0,128,12,0,0,161, +5,0,0,3,1,0,1,128,1,0,0,128,12,0,85,160, +11,0,0,3,1,0,1,128,1,0,0,128,24,0,85,160, +10,0,0,3,1,0,1,128,1,0,0,128,24,0,0,160, +5,0,0,3,0,0,1,128,0,0,0,128,1,0,0,128, +5,0,0,3,0,0,7,128,0,0,0,128,0,0,249,128, +10,0,0,3,0,0,7,128,0,0,228,128,24,0,0,160, +2,0,0,3,0,0,7,128,0,0,228,128,5,0,228,144, +5,0,0,3,0,0,8,128,7,0,255,160,7,0,255,160, +12,0,0,3,0,0,8,128,0,0,255,129,0,0,255,128, +4,0,0,4,1,0,7,128,0,0,228,144,7,0,255,161, +7,0,228,160,8,0,0,3,1,0,8,128,1,0,228,128, +1,0,228,128,12,0,0,3,2,0,2,128,13,0,255,160, +1,0,255,128,5,0,0,3,0,0,8,128,0,0,255,128, +2,0,85,128,4,0,0,4,2,0,2,128,13,0,170,160, +1,0,255,128,2,0,0,128,7,0,0,2,1,0,8,128, +1,0,255,128,5,0,0,3,1,0,7,128,1,0,255,128, +1,0,228,128,6,0,0,2,1,0,8,128,2,0,85,128, +4,0,0,4,0,0,8,128,0,0,255,128,1,0,255,129, +1,0,255,128,8,0,0,3,1,0,8,128,1,0,228,128, +19,0,228,160,8,0,0,3,1,0,1,128,1,0,228,144, +1,0,228,128,11,0,0,3,1,0,9,128,1,0,228,128, +24,0,85,160,5,0,0,3,1,0,7,128,1,0,0,128, +3,0,228,144,5,0,0,3,1,0,7,128,1,0,228,128, +1,0,228,160,2,0,0,3,1,0,8,128,1,0,255,128, +13,0,0,161,5,0,0,3,1,0,8,128,1,0,255,128, +13,0,85,160,11,0,0,3,1,0,8,128,1,0,255,128, +24,0,85,160,10,0,0,3,1,0,8,128,1,0,255,128, +24,0,0,160,5,0,0,3,0,0,8,128,0,0,255,128, +1,0,255,128,5,0,0,3,1,0,7,128,0,0,255,128, +1,0,228,128,10,0,0,3,1,0,7,128,1,0,228,128, +24,0,0,160,2,0,0,3,0,0,7,128,0,0,228,128, +1,0,228,128,5,0,0,3,0,0,8,128,8,0,255,160, +8,0,255,160,12,0,0,3,0,0,8,128,0,0,255,129, +0,0,255,128,4,0,0,4,1,0,7,128,0,0,228,144, +8,0,255,161,8,0,228,160,8,0,0,3,1,0,8,128, +1,0,228,128,1,0,228,128,12,0,0,3,2,0,2,128, +14,0,255,160,1,0,255,128,5,0,0,3,0,0,8,128, +0,0,255,128,2,0,85,128,4,0,0,4,2,0,2,128, +14,0,170,160,1,0,255,128,2,0,0,128,7,0,0,2, +1,0,8,128,1,0,255,128,5,0,0,3,1,0,7,128, +1,0,255,128,1,0,228,128,6,0,0,2,1,0,8,128, +2,0,85,128,4,0,0,4,0,0,8,128,0,0,255,128, +1,0,255,129,1,0,255,128,8,0,0,3,1,0,8,128, +1,0,228,128,20,0,228,160,8,0,0,3,1,0,1,128, +1,0,228,144,1,0,228,128,11,0,0,3,1,0,9,128, +1,0,228,128,24,0,85,160,5,0,0,3,1,0,7,128, +1,0,0,128,3,0,228,144,5,0,0,3,1,0,7,128, +1,0,228,128,2,0,228,160,2,0,0,3,1,0,8,128, +1,0,255,128,14,0,0,161,5,0,0,3,1,0,8,128, +1,0,255,128,14,0,85,160,11,0,0,3,1,0,8,128, +1,0,255,128,24,0,85,160,10,0,0,3,1,0,8,128, +1,0,255,128,24,0,0,160,5,0,0,3,0,0,8,128, +0,0,255,128,1,0,255,128,5,0,0,3,1,0,7,128, +0,0,255,128,1,0,228,128,10,0,0,3,1,0,7,128, +1,0,228,128,24,0,0,160,2,0,0,3,0,0,7,128, +0,0,228,128,1,0,228,128,5,0,0,3,0,0,8,128, +9,0,255,160,9,0,255,160,12,0,0,3,0,0,8,128, +0,0,255,129,0,0,255,128,4,0,0,4,1,0,7,128, +0,0,228,144,9,0,255,161,9,0,228,160,8,0,0,3, +1,0,8,128,1,0,228,128,1,0,228,128,12,0,0,3, +2,0,2,128,15,0,255,160,1,0,255,128,5,0,0,3, +0,0,8,128,0,0,255,128,2,0,85,128,4,0,0,4, +2,0,2,128,15,0,170,160,1,0,255,128,2,0,0,128, +7,0,0,2,1,0,8,128,1,0,255,128,5,0,0,3, +1,0,7,128,1,0,255,128,1,0,228,128,6,0,0,2, +1,0,8,128,2,0,85,128,4,0,0,4,0,0,8,128, +0,0,255,128,1,0,255,129,1,0,255,128,8,0,0,3, +1,0,8,128,1,0,228,128,21,0,228,160,8,0,0,3, +1,0,1,128,1,0,228,144,1,0,228,128,11,0,0,3, +1,0,9,128,1,0,228,128,24,0,85,160,5,0,0,3, +1,0,7,128,1,0,0,128,3,0,228,144,5,0,0,3, +1,0,7,128,1,0,228,128,3,0,228,160,2,0,0,3, +1,0,8,128,1,0,255,128,15,0,0,161,5,0,0,3, +1,0,8,128,1,0,255,128,15,0,85,160,11,0,0,3, +1,0,8,128,1,0,255,128,24,0,85,160,10,0,0,3, +1,0,8,128,1,0,255,128,24,0,0,160,5,0,0,3, +0,0,8,128,0,0,255,128,1,0,255,128,5,0,0,3, +1,0,7,128,0,0,255,128,1,0,228,128,10,0,0,3, +1,0,7,128,1,0,228,128,24,0,0,160,2,0,0,3, +0,0,7,128,0,0,228,128,1,0,228,128,5,0,0,3, +0,0,8,128,10,0,255,160,10,0,255,160,12,0,0,3, +0,0,8,128,0,0,255,129,0,0,255,128,4,0,0,4, +1,0,7,128,0,0,228,144,10,0,255,161,10,0,228,160, +8,0,0,3,1,0,8,128,1,0,228,128,1,0,228,128, +12,0,0,3,2,0,2,128,16,0,255,160,1,0,255,128, +5,0,0,3,0,0,8,128,0,0,255,128,2,0,85,128, +4,0,0,4,2,0,2,128,16,0,170,160,1,0,255,128, +2,0,0,128,7,0,0,2,1,0,8,128,1,0,255,128, +5,0,0,3,1,0,7,128,1,0,255,128,1,0,228,128, +6,0,0,2,1,0,8,128,2,0,85,128,4,0,0,4, +0,0,8,128,0,0,255,128,1,0,255,129,1,0,255,128, +8,0,0,3,1,0,8,128,1,0,228,128,22,0,228,160, +8,0,0,3,1,0,1,128,1,0,228,144,1,0,228,128, +11,0,0,3,1,0,9,128,1,0,228,128,24,0,85,160, +5,0,0,3,1,0,7,128,1,0,0,128,3,0,228,144, +5,0,0,3,1,0,7,128,1,0,228,128,4,0,228,160, +2,0,0,3,1,0,8,128,1,0,255,128,16,0,0,161, +5,0,0,3,1,0,8,128,1,0,255,128,16,0,85,160, +11,0,0,3,1,0,8,128,1,0,255,128,24,0,85,160, +10,0,0,3,1,0,8,128,1,0,255,128,24,0,0,160, +5,0,0,3,0,0,8,128,0,0,255,128,1,0,255,128, +5,0,0,3,1,0,7,128,0,0,255,128,1,0,228,128, +10,0,0,3,1,0,7,128,1,0,228,128,24,0,0,160, +2,0,0,3,0,0,7,128,0,0,228,128,1,0,228,128, +5,0,0,3,0,0,8,128,11,0,255,160,11,0,255,160, +12,0,0,3,0,0,8,128,0,0,255,129,0,0,255,128, +4,0,0,4,1,0,7,128,0,0,228,144,11,0,255,161, +11,0,228,160,8,0,0,3,1,0,8,128,1,0,228,128, +1,0,228,128,12,0,0,3,2,0,2,128,17,0,255,160, +1,0,255,128,5,0,0,3,0,0,8,128,0,0,255,128, +2,0,85,128,4,0,0,4,2,0,1,128,17,0,170,160, +1,0,255,128,2,0,0,128,7,0,0,2,1,0,8,128, +1,0,255,128,5,0,0,3,1,0,7,128,1,0,255,128, +1,0,228,128,6,0,0,2,1,0,8,128,2,0,0,128, +4,0,0,4,0,0,8,128,0,0,255,128,1,0,255,129, +1,0,255,128,8,0,0,3,1,0,8,128,1,0,228,128, +23,0,228,160,8,0,0,3,1,0,1,128,1,0,228,144, +1,0,228,128,11,0,0,3,1,0,9,128,1,0,228,128, +24,0,85,160,5,0,0,3,1,0,7,128,1,0,0,128, +3,0,228,144,5,0,0,3,1,0,7,128,1,0,228,128, +5,0,228,160,2,0,0,3,1,0,8,128,1,0,255,128, +17,0,0,161,5,0,0,3,1,0,8,128,1,0,255,128, +17,0,85,160,11,0,0,3,1,0,8,128,1,0,255,128, +24,0,85,160,10,0,0,3,1,0,8,128,1,0,255,128, +24,0,0,160,5,0,0,3,0,0,8,128,0,0,255,128, +1,0,255,128,5,0,0,3,1,0,7,128,0,0,255,128, +1,0,228,128,10,0,0,3,1,0,7,128,1,0,228,128, +24,0,0,160,2,0,0,3,0,0,7,224,0,0,228,128, +1,0,228,128,1,0,0,2,1,0,7,224,4,0,228,144, +255,255,0,0,83,72,68,82,24,4,0,0,64,0,240,255, +6,1,0,0,89,8,0,4,70,142,32,0,0,0,0,0, +41,0,0,0,95,0,0,3,114,16,16,0,0,0,0,0, +95,0,0,3,114,16,16,0,1,0,0,0,95,0,0,3, +114,16,16,0,3,0,0,0,95,0,0,3,114,16,16,0, +4,0,0,0,95,0,0,3,114,16,16,0,5,0,0,0, +101,0,0,3,114,32,16,0,0,0,0,0,101,0,0,3, +114,32,16,0,1,0,0,0,104,0,0,2,3,0,0,0, +54,0,0,5,114,0,16,0,0,0,0,0,70,18,16,0, +5,0,0,0,54,0,0,5,130,0,16,0,0,0,0,0, +1,64,0,0,0,0,0,0,48,0,0,1,33,0,0,7, +18,0,16,0,1,0,0,0,58,0,16,0,0,0,0,0, +1,64,0,0,6,0,0,0,3,0,4,3,10,0,16,0, +1,0,0,0,50,0,0,16,114,0,16,0,1,0,0,0, +70,18,16,128,65,0,0,0,0,0,0,0,246,143,32,6, +0,0,0,0,18,0,0,0,58,0,16,0,0,0,0,0, +70,130,32,6,0,0,0,0,18,0,0,0,58,0,16,0, +0,0,0,0,16,0,0,7,130,0,16,0,1,0,0,0, +70,2,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +50,0,0,12,18,0,16,0,2,0,0,0,42,128,32,6, +0,0,0,0,26,0,0,0,58,0,16,0,0,0,0,0, +58,0,16,0,1,0,0,0,1,64,0,0,0,0,128,63, +14,0,0,10,18,0,16,0,2,0,0,0,2,64,0,0, +0,0,128,63,0,0,128,63,0,0,128,63,0,0,128,63, +10,0,16,0,2,0,0,0,57,0,0,10,34,0,16,0, +2,0,0,0,1,64,0,0,0,0,0,0,58,128,32,6, +0,0,0,0,18,0,0,0,58,0,16,0,0,0,0,0, +49,0,0,10,66,0,16,0,2,0,0,0,58,128,32,6, +0,0,0,0,26,0,0,0,58,0,16,0,0,0,0,0, +58,0,16,0,1,0,0,0,1,0,0,7,34,0,16,0, +2,0,0,0,42,0,16,0,2,0,0,0,26,0,16,0, +2,0,0,0,55,0,0,9,18,0,16,0,2,0,0,0, +26,0,16,0,2,0,0,0,1,64,0,0,0,0,0,0, +10,0,16,0,2,0,0,0,68,0,0,5,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,56,0,0,7, +114,0,16,0,1,0,0,0,246,15,16,0,1,0,0,0, +70,2,16,0,1,0,0,0,16,0,0,10,130,0,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,70,130,32,6, +0,0,0,0,34,0,0,0,58,0,16,0,0,0,0,0, +52,0,0,7,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,1,64,0,0,0,0,0,0,0,0,0,11, +130,0,16,0,1,0,0,0,58,0,16,0,1,0,0,0, +10,128,32,134,65,0,0,0,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,56,32,0,10,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,26,128,32,6, +0,0,0,0,26,0,0,0,58,0,16,0,0,0,0,0, +56,0,0,7,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,10,0,16,0,2,0,0,0,16,0,0,7, +18,0,16,0,1,0,0,0,70,18,16,0,1,0,0,0, +70,2,16,0,1,0,0,0,52,0,0,7,18,0,16,0, +1,0,0,0,10,0,16,0,1,0,0,0,1,64,0,0, +0,0,0,0,56,0,0,7,114,0,16,0,1,0,0,0, +6,0,16,0,1,0,0,0,70,18,16,0,3,0,0,0, +56,0,0,10,114,0,16,0,1,0,0,0,70,2,16,0, +1,0,0,0,70,130,32,6,0,0,0,0,10,0,0,0, +58,0,16,0,0,0,0,0,56,0,0,7,114,0,16,0, +1,0,0,0,246,15,16,0,1,0,0,0,70,2,16,0, +1,0,0,0,51,0,0,10,114,0,16,0,1,0,0,0, +70,2,16,0,1,0,0,0,2,64,0,0,0,0,128,63, +0,0,128,63,0,0,128,63,0,0,0,0,0,0,0,7, +114,0,16,0,0,0,0,0,70,2,16,0,0,0,0,0, +70,2,16,0,1,0,0,0,30,0,0,7,130,0,16,0, +0,0,0,0,58,0,16,0,0,0,0,0,1,64,0,0, +1,0,0,0,22,0,0,1,54,0,0,5,114,32,16,0, +0,0,0,0,70,2,16,0,0,0,0,0,54,0,0,5, +114,32,16,0,1,0,0,0,70,18,16,0,4,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,32,0,0,0, +3,0,0,0,0,0,0,0,7,0,0,0,20,0,0,0, +2,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,4,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,188,4,0,0,1,0,0,0,108,0,0,0, +1,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +142,4,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,92,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,85,110,105,116,121,70,70,86,101,114,116,101, +120,0,171,171,92,0,0,0,14,0,0,0,132,0,0,0, +240,3,0,0,0,0,0,0,0,0,0,0,180,2,0,0, +0,0,0,0,64,0,0,0,0,0,0,0,204,2,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,240,2,0,0,64,0,0,0,64,0,0,0, +0,0,0,0,204,2,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,253,2,0,0, +128,0,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,56,3,0,0,144,0,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,71,3,0,0, +160,0,0,0,128,0,0,0,2,0,0,0,88,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,124,3,0,0,32,1,0,0,128,0,0,0, +2,0,0,0,140,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,176,3,0,0, +160,1,0,0,128,0,0,0,2,0,0,0,192,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,228,3,0,0,32,2,0,0,128,0,0,0, +2,0,0,0,244,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,24,4,0,0, +160,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,39,4,0,0,176,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,54,4,0,0, +192,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,66,4,0,0,208,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,82,4,0,0, +224,2,0,0,0,1,0,0,0,0,0,0,96,4,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,132,4,0,0,224,3,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,102,102,95,109, +97,116,114,105,120,95,109,118,112,0,102,108,111,97,116,52, +120,52,0,171,3,0,3,0,4,0,4,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,194,2,0,0,102,102,95,109,97,116,114,105, +120,95,109,118,0,102,102,95,118,101,99,95,99,111,108,111, +114,0,102,108,111,97,116,52,0,171,171,171,1,0,3,0, +1,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,118,101,99,95,97,109,98,105,101,110,116,0,102, +102,95,108,105,103,104,116,95,99,111,108,111,114,0,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,112,111,115, +0,171,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,97,116,116,101,110,0,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,115,112,111,116,0,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,109,97,116,95,100,105,102,102,117,115,101,0,102, +102,95,109,97,116,95,97,109,98,105,101,110,116,0,102,102, +95,109,97,116,95,115,112,101,99,0,102,102,95,109,97,116, +95,101,109,105,115,115,105,111,110,0,102,102,95,109,97,116, +114,105,120,95,116,101,120,0,3,0,3,0,4,0,4,0, +4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,194,2,0,0,102,102,95,102, +111,103,95,118,115,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,164,1,0,0,7,0,0,0, +8,0,0,0,88,1,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,106,1,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,118,1,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,1,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,128,1,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,2,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,136,1,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,149,1,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +3,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,159,1,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,5,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,67,111,109,112,117,116,101,83,112,111,116,76, +105,103,104,116,54,0,101,121,101,80,111,115,105,116,105,111, +110,0,101,121,101,78,111,114,109,97,108,0,118,105,101,119, +68,105,114,0,100,105,102,102,117,115,101,67,111,108,111,114, +0,115,112,101,99,67,111,108,111,114,0,97,109,98,0,171, +76,73,66,70,80,16,0,0,68,88,66,67,234,246,83,85, +128,3,122,132,33,202,50,54,82,138,167,19,1,0,0,0, +80,16,0,0,5,0,0,0,52,0,0,0,156,3,0,0, +96,9,0,0,220,9,0,0,160,14,0,0,65,111,110,57, +96,3,0,0,96,3,0,0,0,2,86,76,48,3,0,0, +48,0,0,0,1,0,36,0,0,0,48,0,0,0,48,0, +0,0,36,0,0,0,48,0,0,0,0,0,45,0,0,0, +0,0,0,0,0,2,86,76,81,0,0,5,45,0,15,160, +0,0,0,0,0,0,0,0,0,0,128,63,0,0,0,0, +48,0,0,5,0,0,15,240,6,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,31,0,0,2,5,0,0,128, +0,0,15,144,31,0,0,2,5,0,1,128,1,0,15,144, +31,0,0,2,5,0,2,128,2,0,15,144,31,0,0,2, +5,0,3,128,3,0,15,144,31,0,0,2,5,0,4,128, +4,0,15,144,31,0,0,2,5,0,5,128,5,0,15,144, +1,0,0,2,0,0,7,128,4,0,228,144,1,0,0,2, +1,0,7,128,5,0,228,144,27,0,0,2,0,8,228,240, +0,0,228,240,4,0,0,6,2,0,7,128,0,0,228,144, +18,32,255,161,0,8,228,240,18,32,228,160,0,8,228,240, +8,0,0,3,0,0,8,128,2,0,228,128,2,0,228,128, +7,0,0,2,1,0,8,128,0,0,255,128,4,0,0,4, +3,0,7,128,2,0,228,128,1,0,255,128,2,0,228,144, +36,0,0,2,4,0,7,128,3,0,228,128,8,0,0,3, +2,0,8,128,1,0,228,144,4,0,228,128,5,0,0,5, +3,0,1,128,18,32,255,160,0,8,228,240,18,32,255,160, +0,8,228,240,12,0,0,3,3,0,1,128,3,0,0,129, +3,0,0,128,12,0,0,4,3,0,2,128,26,32,255,160, +0,8,228,240,0,0,255,128,5,0,0,3,3,0,1,128, +3,0,85,128,3,0,0,128,5,0,0,4,0,0,8,128, +0,0,255,128,26,32,170,160,0,8,228,240,2,0,0,3, +0,0,8,128,0,0,255,128,45,0,170,160,6,0,0,2, +0,0,8,128,0,0,255,128,4,0,0,4,0,0,8,128, +3,0,0,128,0,0,255,129,0,0,255,128,11,0,0,3, +2,0,8,128,2,0,255,128,45,0,85,160,32,0,0,3, +3,0,1,128,2,0,255,128,44,0,255,160,10,0,0,3, +2,0,8,128,3,0,0,128,45,0,170,160,5,0,0,3, +2,0,7,128,1,0,255,128,2,0,228,128,8,0,0,3, +1,0,8,128,1,0,228,144,2,0,228,128,8,0,0,4, +2,0,1,128,2,0,228,128,34,32,228,160,0,8,228,240, +11,0,0,3,2,0,1,128,2,0,0,128,45,0,85,160, +2,0,0,4,2,0,1,128,2,0,0,128,26,32,0,161, +0,8,228,240,5,0,0,4,2,0,1,128,2,0,0,128, +26,32,85,160,0,8,228,240,11,0,0,3,2,0,1,128, +2,0,0,128,45,0,85,160,10,0,0,3,2,0,1,128, +2,0,0,128,45,0,170,160,5,0,0,3,0,0,8,128, +0,0,255,128,2,0,0,128,11,0,0,3,1,0,8,128, +1,0,255,128,45,0,85,160,12,0,0,3,2,0,1,128, +45,0,85,160,1,0,255,128,5,0,0,3,2,0,2,128, +2,0,255,128,0,0,255,128,5,0,0,4,2,0,14,128, +2,0,85,128,10,32,144,160,0,8,228,240,4,0,0,4, +0,0,7,128,2,0,0,128,2,0,249,128,0,0,228,128, +5,0,0,3,2,0,7,128,1,0,255,128,3,0,228,144, +5,0,0,4,2,0,7,128,2,0,228,128,10,32,228,160, +0,8,228,240,5,0,0,3,2,0,7,128,0,0,255,128, +2,0,228,128,10,0,0,3,2,0,7,128,2,0,228,128, +45,0,170,160,2,0,0,3,1,0,7,128,1,0,228,128, +2,0,228,128,29,0,0,0,1,0,0,2,1,0,7,224, +0,0,228,128,1,0,0,2,0,0,7,224,1,0,228,128, +255,255,0,0,83,72,68,82,188,5,0,0,64,0,240,255, +111,1,0,0,89,8,0,4,70,142,32,0,0,0,0,0, +45,0,0,0,95,0,0,3,114,16,16,0,0,0,0,0, +95,0,0,3,114,16,16,0,1,0,0,0,95,0,0,3, +114,16,16,0,2,0,0,0,95,0,0,3,114,16,16,0, +3,0,0,0,95,0,0,3,114,16,16,0,4,0,0,0, +95,0,0,3,114,16,16,0,5,0,0,0,101,0,0,3, +114,32,16,0,0,0,0,0,101,0,0,3,114,32,16,0, +1,0,0,0,104,0,0,2,4,0,0,0,54,0,0,5, +114,0,16,0,0,0,0,0,70,18,16,0,4,0,0,0, +54,0,0,5,114,0,16,0,1,0,0,0,70,18,16,0, +5,0,0,0,54,0,0,5,130,0,16,0,0,0,0,0, +1,64,0,0,0,0,0,0,48,0,0,1,33,0,0,7, +130,0,16,0,1,0,0,0,58,0,16,0,0,0,0,0, +1,64,0,0,6,0,0,0,3,0,4,3,58,0,16,0, +1,0,0,0,50,0,0,16,114,0,16,0,2,0,0,0, +70,18,16,128,65,0,0,0,0,0,0,0,246,143,32,6, +0,0,0,0,18,0,0,0,58,0,16,0,0,0,0,0, +70,130,32,6,0,0,0,0,18,0,0,0,58,0,16,0, +0,0,0,0,16,0,0,7,130,0,16,0,1,0,0,0, +70,2,16,0,2,0,0,0,70,2,16,0,2,0,0,0, +50,0,0,12,130,0,16,0,2,0,0,0,42,128,32,6, +0,0,0,0,26,0,0,0,58,0,16,0,0,0,0,0, +58,0,16,0,1,0,0,0,1,64,0,0,0,0,128,63, +14,0,0,10,130,0,16,0,2,0,0,0,2,64,0,0, +0,0,128,63,0,0,128,63,0,0,128,63,0,0,128,63, +58,0,16,0,2,0,0,0,57,0,0,10,18,0,16,0, +3,0,0,0,1,64,0,0,0,0,0,0,58,128,32,6, +0,0,0,0,18,0,0,0,58,0,16,0,0,0,0,0, +49,0,0,10,34,0,16,0,3,0,0,0,58,128,32,6, +0,0,0,0,26,0,0,0,58,0,16,0,0,0,0,0, +58,0,16,0,1,0,0,0,1,0,0,7,18,0,16,0, +3,0,0,0,26,0,16,0,3,0,0,0,10,0,16,0, +3,0,0,0,55,0,0,9,130,0,16,0,2,0,0,0, +10,0,16,0,3,0,0,0,1,64,0,0,0,0,0,0, +58,0,16,0,2,0,0,0,68,0,0,5,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,56,0,0,7, +114,0,16,0,3,0,0,0,246,15,16,0,1,0,0,0, +70,2,16,0,2,0,0,0,16,0,0,10,130,0,16,0, +3,0,0,0,70,2,16,0,3,0,0,0,70,130,32,6, +0,0,0,0,34,0,0,0,58,0,16,0,0,0,0,0, +52,0,0,7,130,0,16,0,3,0,0,0,58,0,16,0, +3,0,0,0,1,64,0,0,0,0,0,0,0,0,0,11, +130,0,16,0,3,0,0,0,58,0,16,0,3,0,0,0, +10,128,32,134,65,0,0,0,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,56,32,0,10,130,0,16,0, +3,0,0,0,58,0,16,0,3,0,0,0,26,128,32,6, +0,0,0,0,26,0,0,0,58,0,16,0,0,0,0,0, +56,0,0,7,130,0,16,0,2,0,0,0,58,0,16,0, +2,0,0,0,58,0,16,0,3,0,0,0,16,0,0,7, +18,0,16,0,3,0,0,0,70,18,16,0,1,0,0,0, +70,2,16,0,3,0,0,0,52,0,0,7,18,0,16,0, +3,0,0,0,10,0,16,0,3,0,0,0,1,64,0,0, +0,0,0,0,56,0,0,7,226,0,16,0,3,0,0,0, +6,0,16,0,3,0,0,0,6,25,16,0,3,0,0,0, +56,0,0,10,226,0,16,0,3,0,0,0,86,14,16,0, +3,0,0,0,6,137,32,6,0,0,0,0,10,0,0,0, +58,0,16,0,0,0,0,0,49,0,0,7,18,0,16,0, +3,0,0,0,1,64,0,0,0,0,0,0,10,0,16,0, +3,0,0,0,31,0,4,3,10,0,16,0,3,0,0,0, +50,0,0,9,114,0,16,0,2,0,0,0,70,2,16,0, +2,0,0,0,246,15,16,0,1,0,0,0,70,18,16,0, +2,0,0,0,16,0,0,7,130,0,16,0,1,0,0,0, +70,2,16,0,2,0,0,0,70,2,16,0,2,0,0,0, +68,0,0,5,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,56,0,0,7,114,0,16,0,2,0,0,0, +246,15,16,0,1,0,0,0,70,2,16,0,2,0,0,0, +16,0,0,7,130,0,16,0,1,0,0,0,70,18,16,0, +1,0,0,0,70,2,16,0,2,0,0,0,52,0,0,7, +130,0,16,0,1,0,0,0,58,0,16,0,1,0,0,0, +1,64,0,0,0,0,0,0,47,0,0,5,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,56,0,0,8, +130,0,16,0,1,0,0,0,58,0,16,0,1,0,0,0, +58,128,32,0,0,0,0,0,44,0,0,0,25,0,0,5, +130,0,16,0,1,0,0,0,58,0,16,0,1,0,0,0, +51,0,0,7,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,1,64,0,0,0,0,128,63,56,0,0,7, +130,0,16,0,1,0,0,0,58,0,16,0,1,0,0,0, +58,0,16,0,2,0,0,0,50,0,0,12,114,0,16,0, +0,0,0,0,246,15,16,0,1,0,0,0,70,130,32,6, +0,0,0,0,10,0,0,0,58,0,16,0,0,0,0,0, +70,2,16,0,0,0,0,0,21,0,0,1,56,0,0,7, +114,0,16,0,2,0,0,0,246,15,16,0,2,0,0,0, +150,7,16,0,3,0,0,0,51,0,0,10,114,0,16,0, +2,0,0,0,70,2,16,0,2,0,0,0,2,64,0,0, +0,0,128,63,0,0,128,63,0,0,128,63,0,0,0,0, +0,0,0,7,114,0,16,0,1,0,0,0,70,2,16,0, +1,0,0,0,70,2,16,0,2,0,0,0,30,0,0,7, +130,0,16,0,0,0,0,0,58,0,16,0,0,0,0,0, +1,64,0,0,1,0,0,0,22,0,0,1,54,0,0,5, +114,32,16,0,1,0,0,0,70,2,16,0,0,0,0,0, +54,0,0,5,114,32,16,0,0,0,0,0,70,2,16,0, +1,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +48,0,0,0,4,0,0,0,0,0,0,0,8,0,0,0, +33,0,0,0,2,0,0,0,1,0,0,0,1,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,188,4,0,0,1,0,0,0, +108,0,0,0,1,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,142,4,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,85,110,105,116,121,70,70,86, +101,114,116,101,120,0,171,171,92,0,0,0,14,0,0,0, +132,0,0,0,240,3,0,0,0,0,0,0,0,0,0,0, +180,2,0,0,0,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,240,2,0,0,64,0,0,0, +64,0,0,0,0,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +253,2,0,0,128,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,56,3,0,0,144,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +71,3,0,0,160,0,0,0,128,0,0,0,2,0,0,0, +88,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,124,3,0,0,32,1,0,0, +128,0,0,0,2,0,0,0,140,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +176,3,0,0,160,1,0,0,128,0,0,0,2,0,0,0, +192,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,228,3,0,0,32,2,0,0, +128,0,0,0,2,0,0,0,244,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +24,4,0,0,160,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,39,4,0,0,176,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +54,4,0,0,192,2,0,0,16,0,0,0,2,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,66,4,0,0,208,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +82,4,0,0,224,2,0,0,0,1,0,0,0,0,0,0, +96,4,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,132,4,0,0,224,3,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +102,102,95,109,97,116,114,105,120,95,109,118,112,0,102,108, +111,97,116,52,120,52,0,171,3,0,3,0,4,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,194,2,0,0,102,102,95,109, +97,116,114,105,120,95,109,118,0,102,102,95,118,101,99,95, +99,111,108,111,114,0,102,108,111,97,116,52,0,171,171,171, +1,0,3,0,1,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,118,101,99,95,97,109,98,105,101, +110,116,0,102,102,95,108,105,103,104,116,95,99,111,108,111, +114,0,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,112,111,115,0,171,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,97,116,116,101,110,0,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,115,112,111,116,0,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,109,97,116,95,100,105,102,102,117, +115,101,0,102,102,95,109,97,116,95,97,109,98,105,101,110, +116,0,102,102,95,109,97,116,95,115,112,101,99,0,102,102, +95,109,97,116,95,101,109,105,115,115,105,111,110,0,102,102, +95,109,97,116,114,105,120,95,116,101,120,0,3,0,3,0, +4,0,4,0,4,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,194,2,0,0, +102,102,95,102,111,103,95,118,115,0,77,105,99,114,111,115, +111,102,116,32,40,82,41,32,72,76,83,76,32,83,104,97, +100,101,114,32,67,111,109,112,105,108,101,114,32,54,46,51, +46,57,52,49,53,46,48,0,76,70,83,48,168,1,0,0, +7,0,0,0,8,0,0,0,88,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,110,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,122,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,132,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,140,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,153,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,3,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,163,1,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,5,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,67,111,109,112,117,116,101,83, +112,111,116,76,105,103,104,116,83,112,101,99,54,0,101,121, +101,80,111,115,105,116,105,111,110,0,101,121,101,78,111,114, +109,97,108,0,118,105,101,119,68,105,114,0,100,105,102,102, +117,115,101,67,111,108,111,114,0,115,112,101,99,67,111,108, +111,114,0,97,109,98,0,171,76,73,66,70,188,22,0,0, +68,88,66,67,203,163,211,164,74,232,227,110,255,5,54,13, +127,129,226,75,1,0,0,0,188,22,0,0,5,0,0,0, +52,0,0,0,176,11,0,0,208,15,0,0,76,16,0,0, +16,21,0,0,65,111,110,57,116,11,0,0,116,11,0,0, +0,2,86,76,32,11,0,0,84,0,0,0,4,0,36,0, +0,0,84,0,0,0,84,0,0,0,36,0,0,0,84,0, +0,0,10,0,7,0,0,0,0,0,0,0,0,0,18,0, +7,0,7,0,0,0,0,0,0,0,26,0,7,0,14,0, +0,0,0,0,0,0,34,0,7,0,21,0,0,0,0,0, +0,2,86,76,81,0,0,5,28,0,15,160,0,0,128,63, +0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,2, +5,0,0,128,0,0,15,144,31,0,0,2,5,0,1,128, +1,0,15,144,31,0,0,2,5,0,3,128,3,0,15,144, +31,0,0,2,5,0,4,128,4,0,15,144,31,0,0,2, +5,0,5,128,5,0,15,144,5,0,0,3,0,0,1,128, +7,0,255,160,7,0,255,160,12,0,0,3,0,0,1,128, +0,0,0,129,0,0,0,128,4,0,0,4,0,0,14,128, +0,0,144,144,7,0,255,161,7,0,144,160,8,0,0,3, +1,0,1,128,0,0,249,128,0,0,249,128,12,0,0,3, +1,0,2,128,14,0,255,160,1,0,0,128,5,0,0,3, +0,0,1,128,0,0,0,128,1,0,85,128,1,0,0,2, +2,0,1,128,28,0,0,160,4,0,0,4,1,0,2,128, +14,0,170,160,1,0,0,128,2,0,0,128,7,0,0,2, +1,0,1,128,1,0,0,128,5,0,0,3,0,0,14,128, +0,0,228,128,1,0,0,128,6,0,0,2,1,0,1,128, +1,0,85,128,4,0,0,4,0,0,1,128,0,0,0,128, +1,0,0,129,1,0,0,128,8,0,0,3,1,0,1,128, +0,0,249,128,21,0,228,160,8,0,0,3,0,0,2,128, +1,0,228,144,0,0,249,128,11,0,0,3,0,0,2,128, +0,0,85,128,28,0,85,160,5,0,0,3,0,0,14,128, +0,0,85,128,3,0,144,144,5,0,0,3,0,0,14,128, +0,0,228,128,0,0,144,160,11,0,0,3,1,0,1,128, +1,0,0,128,28,0,85,160,2,0,0,3,1,0,1,128, +1,0,0,128,14,0,0,161,5,0,0,3,1,0,1,128, +1,0,0,128,14,0,85,160,11,0,0,3,1,0,1,128, +1,0,0,128,28,0,85,160,10,0,0,3,1,0,1,128, +1,0,0,128,28,0,0,160,5,0,0,3,0,0,1,128, +0,0,0,128,1,0,0,128,5,0,0,3,0,0,7,128, +0,0,0,128,0,0,249,128,10,0,0,3,0,0,7,128, +0,0,228,128,28,0,0,160,2,0,0,3,0,0,7,128, +0,0,228,128,5,0,228,144,5,0,0,3,0,0,8,128, +8,0,255,160,8,0,255,160,12,0,0,3,0,0,8,128, +0,0,255,129,0,0,255,128,4,0,0,4,1,0,7,128, +0,0,228,144,8,0,255,161,8,0,228,160,8,0,0,3, +1,0,8,128,1,0,228,128,1,0,228,128,12,0,0,3, +2,0,2,128,15,0,255,160,1,0,255,128,5,0,0,3, +0,0,8,128,0,0,255,128,2,0,85,128,4,0,0,4, +2,0,2,128,15,0,170,160,1,0,255,128,2,0,0,128, +7,0,0,2,1,0,8,128,1,0,255,128,5,0,0,3, +1,0,7,128,1,0,255,128,1,0,228,128,6,0,0,2, +1,0,8,128,2,0,85,128,4,0,0,4,0,0,8,128, +0,0,255,128,1,0,255,129,1,0,255,128,8,0,0,3, +1,0,8,128,1,0,228,128,22,0,228,160,8,0,0,3, +1,0,1,128,1,0,228,144,1,0,228,128,11,0,0,3, +1,0,9,128,1,0,228,128,28,0,85,160,5,0,0,3, +1,0,7,128,1,0,0,128,3,0,228,144,5,0,0,3, +1,0,7,128,1,0,228,128,1,0,228,160,2,0,0,3, +1,0,8,128,1,0,255,128,15,0,0,161,5,0,0,3, +1,0,8,128,1,0,255,128,15,0,85,160,11,0,0,3, +1,0,8,128,1,0,255,128,28,0,85,160,10,0,0,3, +1,0,8,128,1,0,255,128,28,0,0,160,5,0,0,3, +0,0,8,128,0,0,255,128,1,0,255,128,5,0,0,3, +1,0,7,128,0,0,255,128,1,0,228,128,10,0,0,3, +1,0,7,128,1,0,228,128,28,0,0,160,2,0,0,3, +0,0,7,128,0,0,228,128,1,0,228,128,5,0,0,3, +0,0,8,128,9,0,255,160,9,0,255,160,12,0,0,3, +0,0,8,128,0,0,255,129,0,0,255,128,4,0,0,4, +1,0,7,128,0,0,228,144,9,0,255,161,9,0,228,160, +8,0,0,3,1,0,8,128,1,0,228,128,1,0,228,128, +12,0,0,3,2,0,2,128,16,0,255,160,1,0,255,128, +5,0,0,3,0,0,8,128,0,0,255,128,2,0,85,128, +4,0,0,4,2,0,2,128,16,0,170,160,1,0,255,128, +2,0,0,128,7,0,0,2,1,0,8,128,1,0,255,128, +5,0,0,3,1,0,7,128,1,0,255,128,1,0,228,128, +6,0,0,2,1,0,8,128,2,0,85,128,4,0,0,4, +0,0,8,128,0,0,255,128,1,0,255,129,1,0,255,128, +8,0,0,3,1,0,8,128,1,0,228,128,23,0,228,160, +8,0,0,3,1,0,1,128,1,0,228,144,1,0,228,128, +11,0,0,3,1,0,9,128,1,0,228,128,28,0,85,160, +5,0,0,3,1,0,7,128,1,0,0,128,3,0,228,144, +5,0,0,3,1,0,7,128,1,0,228,128,2,0,228,160, +2,0,0,3,1,0,8,128,1,0,255,128,16,0,0,161, +5,0,0,3,1,0,8,128,1,0,255,128,16,0,85,160, +11,0,0,3,1,0,8,128,1,0,255,128,28,0,85,160, +10,0,0,3,1,0,8,128,1,0,255,128,28,0,0,160, +5,0,0,3,0,0,8,128,0,0,255,128,1,0,255,128, +5,0,0,3,1,0,7,128,0,0,255,128,1,0,228,128, +10,0,0,3,1,0,7,128,1,0,228,128,28,0,0,160, +2,0,0,3,0,0,7,128,0,0,228,128,1,0,228,128, +5,0,0,3,0,0,8,128,10,0,255,160,10,0,255,160, +12,0,0,3,0,0,8,128,0,0,255,129,0,0,255,128, +4,0,0,4,1,0,7,128,0,0,228,144,10,0,255,161, +10,0,228,160,8,0,0,3,1,0,8,128,1,0,228,128, +1,0,228,128,12,0,0,3,2,0,2,128,17,0,255,160, +1,0,255,128,5,0,0,3,0,0,8,128,0,0,255,128, +2,0,85,128,4,0,0,4,2,0,2,128,17,0,170,160, +1,0,255,128,2,0,0,128,7,0,0,2,1,0,8,128, +1,0,255,128,5,0,0,3,1,0,7,128,1,0,255,128, +1,0,228,128,6,0,0,2,1,0,8,128,2,0,85,128, +4,0,0,4,0,0,8,128,0,0,255,128,1,0,255,129, +1,0,255,128,8,0,0,3,1,0,8,128,1,0,228,128, +24,0,228,160,8,0,0,3,1,0,1,128,1,0,228,144, +1,0,228,128,11,0,0,3,1,0,9,128,1,0,228,128, +28,0,85,160,5,0,0,3,1,0,7,128,1,0,0,128, +3,0,228,144,5,0,0,3,1,0,7,128,1,0,228,128, +3,0,228,160,2,0,0,3,1,0,8,128,1,0,255,128, +17,0,0,161,5,0,0,3,1,0,8,128,1,0,255,128, +17,0,85,160,11,0,0,3,1,0,8,128,1,0,255,128, +28,0,85,160,10,0,0,3,1,0,8,128,1,0,255,128, +28,0,0,160,5,0,0,3,0,0,8,128,0,0,255,128, +1,0,255,128,5,0,0,3,1,0,7,128,0,0,255,128, +1,0,228,128,10,0,0,3,1,0,7,128,1,0,228,128, +28,0,0,160,2,0,0,3,0,0,7,128,0,0,228,128, +1,0,228,128,5,0,0,3,0,0,8,128,11,0,255,160, +11,0,255,160,12,0,0,3,0,0,8,128,0,0,255,129, +0,0,255,128,4,0,0,4,1,0,7,128,0,0,228,144, +11,0,255,161,11,0,228,160,8,0,0,3,1,0,8,128, +1,0,228,128,1,0,228,128,12,0,0,3,2,0,2,128, +18,0,255,160,1,0,255,128,5,0,0,3,0,0,8,128, +0,0,255,128,2,0,85,128,4,0,0,4,2,0,2,128, +18,0,170,160,1,0,255,128,2,0,0,128,7,0,0,2, +1,0,8,128,1,0,255,128,5,0,0,3,1,0,7,128, +1,0,255,128,1,0,228,128,6,0,0,2,1,0,8,128, +2,0,85,128,4,0,0,4,0,0,8,128,0,0,255,128, +1,0,255,129,1,0,255,128,8,0,0,3,1,0,8,128, +1,0,228,128,25,0,228,160,8,0,0,3,1,0,1,128, +1,0,228,144,1,0,228,128,11,0,0,3,1,0,9,128, +1,0,228,128,28,0,85,160,5,0,0,3,1,0,7,128, +1,0,0,128,3,0,228,144,5,0,0,3,1,0,7,128, +1,0,228,128,4,0,228,160,2,0,0,3,1,0,8,128, +1,0,255,128,18,0,0,161,5,0,0,3,1,0,8,128, +1,0,255,128,18,0,85,160,11,0,0,3,1,0,8,128, +1,0,255,128,28,0,85,160,10,0,0,3,1,0,8,128, +1,0,255,128,28,0,0,160,5,0,0,3,0,0,8,128, +0,0,255,128,1,0,255,128,5,0,0,3,1,0,7,128, +0,0,255,128,1,0,228,128,10,0,0,3,1,0,7,128, +1,0,228,128,28,0,0,160,2,0,0,3,0,0,7,128, +0,0,228,128,1,0,228,128,5,0,0,3,0,0,8,128, +12,0,255,160,12,0,255,160,12,0,0,3,0,0,8,128, +0,0,255,129,0,0,255,128,4,0,0,4,1,0,7,128, +0,0,228,144,12,0,255,161,12,0,228,160,8,0,0,3, +1,0,8,128,1,0,228,128,1,0,228,128,12,0,0,3, +2,0,2,128,19,0,255,160,1,0,255,128,5,0,0,3, +0,0,8,128,0,0,255,128,2,0,85,128,4,0,0,4, +2,0,2,128,19,0,170,160,1,0,255,128,2,0,0,128, +7,0,0,2,1,0,8,128,1,0,255,128,5,0,0,3, +1,0,7,128,1,0,255,128,1,0,228,128,6,0,0,2, +1,0,8,128,2,0,85,128,4,0,0,4,0,0,8,128, +0,0,255,128,1,0,255,129,1,0,255,128,8,0,0,3, +1,0,8,128,1,0,228,128,26,0,228,160,8,0,0,3, +1,0,1,128,1,0,228,144,1,0,228,128,11,0,0,3, +1,0,9,128,1,0,228,128,28,0,85,160,5,0,0,3, +1,0,7,128,1,0,0,128,3,0,228,144,5,0,0,3, +1,0,7,128,1,0,228,128,5,0,228,160,2,0,0,3, +1,0,8,128,1,0,255,128,19,0,0,161,5,0,0,3, +1,0,8,128,1,0,255,128,19,0,85,160,11,0,0,3, +1,0,8,128,1,0,255,128,28,0,85,160,10,0,0,3, +1,0,8,128,1,0,255,128,28,0,0,160,5,0,0,3, +0,0,8,128,0,0,255,128,1,0,255,128,5,0,0,3, +1,0,7,128,0,0,255,128,1,0,228,128,10,0,0,3, +1,0,7,128,1,0,228,128,28,0,0,160,2,0,0,3, +0,0,7,128,0,0,228,128,1,0,228,128,5,0,0,3, +0,0,8,128,13,0,255,160,13,0,255,160,12,0,0,3, +0,0,8,128,0,0,255,129,0,0,255,128,4,0,0,4, +1,0,7,128,0,0,228,144,13,0,255,161,13,0,228,160, +8,0,0,3,1,0,8,128,1,0,228,128,1,0,228,128, +12,0,0,3,2,0,2,128,20,0,255,160,1,0,255,128, +5,0,0,3,0,0,8,128,0,0,255,128,2,0,85,128, +4,0,0,4,2,0,1,128,20,0,170,160,1,0,255,128, +2,0,0,128,7,0,0,2,1,0,8,128,1,0,255,128, +5,0,0,3,1,0,7,128,1,0,255,128,1,0,228,128, +6,0,0,2,1,0,8,128,2,0,0,128,4,0,0,4, +0,0,8,128,0,0,255,128,1,0,255,129,1,0,255,128, +8,0,0,3,1,0,8,128,1,0,228,128,27,0,228,160, +8,0,0,3,1,0,1,128,1,0,228,144,1,0,228,128, +11,0,0,3,1,0,9,128,1,0,228,128,28,0,85,160, +5,0,0,3,1,0,7,128,1,0,0,128,3,0,228,144, +5,0,0,3,1,0,7,128,1,0,228,128,6,0,228,160, +2,0,0,3,1,0,8,128,1,0,255,128,20,0,0,161, +5,0,0,3,1,0,8,128,1,0,255,128,20,0,85,160, +11,0,0,3,1,0,8,128,1,0,255,128,28,0,85,160, +10,0,0,3,1,0,8,128,1,0,255,128,28,0,0,160, +5,0,0,3,0,0,8,128,0,0,255,128,1,0,255,128, +5,0,0,3,1,0,7,128,0,0,255,128,1,0,228,128, +10,0,0,3,1,0,7,128,1,0,228,128,28,0,0,160, +2,0,0,3,0,0,7,224,0,0,228,128,1,0,228,128, +1,0,0,2,1,0,7,224,4,0,228,144,255,255,0,0, +83,72,68,82,24,4,0,0,64,0,240,255,6,1,0,0, +89,8,0,4,70,142,32,0,0,0,0,0,42,0,0,0, +95,0,0,3,114,16,16,0,0,0,0,0,95,0,0,3, +114,16,16,0,1,0,0,0,95,0,0,3,114,16,16,0, +3,0,0,0,95,0,0,3,114,16,16,0,4,0,0,0, +95,0,0,3,114,16,16,0,5,0,0,0,101,0,0,3, +114,32,16,0,0,0,0,0,101,0,0,3,114,32,16,0, +1,0,0,0,104,0,0,2,3,0,0,0,54,0,0,5, +114,0,16,0,0,0,0,0,70,18,16,0,5,0,0,0, +54,0,0,5,130,0,16,0,0,0,0,0,1,64,0,0, +0,0,0,0,48,0,0,1,33,0,0,7,18,0,16,0, +1,0,0,0,58,0,16,0,0,0,0,0,1,64,0,0, +7,0,0,0,3,0,4,3,10,0,16,0,1,0,0,0, +50,0,0,16,114,0,16,0,1,0,0,0,70,18,16,128, +65,0,0,0,0,0,0,0,246,143,32,6,0,0,0,0, +18,0,0,0,58,0,16,0,0,0,0,0,70,130,32,6, +0,0,0,0,18,0,0,0,58,0,16,0,0,0,0,0, +16,0,0,7,130,0,16,0,1,0,0,0,70,2,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,50,0,0,12, +18,0,16,0,2,0,0,0,42,128,32,6,0,0,0,0, +26,0,0,0,58,0,16,0,0,0,0,0,58,0,16,0, +1,0,0,0,1,64,0,0,0,0,128,63,14,0,0,10, +18,0,16,0,2,0,0,0,2,64,0,0,0,0,128,63, +0,0,128,63,0,0,128,63,0,0,128,63,10,0,16,0, +2,0,0,0,57,0,0,10,34,0,16,0,2,0,0,0, +1,64,0,0,0,0,0,0,58,128,32,6,0,0,0,0, +18,0,0,0,58,0,16,0,0,0,0,0,49,0,0,10, +66,0,16,0,2,0,0,0,58,128,32,6,0,0,0,0, +26,0,0,0,58,0,16,0,0,0,0,0,58,0,16,0, +1,0,0,0,1,0,0,7,34,0,16,0,2,0,0,0, +42,0,16,0,2,0,0,0,26,0,16,0,2,0,0,0, +55,0,0,9,18,0,16,0,2,0,0,0,26,0,16,0, +2,0,0,0,1,64,0,0,0,0,0,0,10,0,16,0, +2,0,0,0,68,0,0,5,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,56,0,0,7,114,0,16,0, +1,0,0,0,246,15,16,0,1,0,0,0,70,2,16,0, +1,0,0,0,16,0,0,10,130,0,16,0,1,0,0,0, +70,2,16,0,1,0,0,0,70,130,32,6,0,0,0,0, +34,0,0,0,58,0,16,0,0,0,0,0,52,0,0,7, +130,0,16,0,1,0,0,0,58,0,16,0,1,0,0,0, +1,64,0,0,0,0,0,0,0,0,0,11,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,10,128,32,134, +65,0,0,0,0,0,0,0,26,0,0,0,58,0,16,0, +0,0,0,0,56,32,0,10,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,26,128,32,6,0,0,0,0, +26,0,0,0,58,0,16,0,0,0,0,0,56,0,0,7, +130,0,16,0,1,0,0,0,58,0,16,0,1,0,0,0, +10,0,16,0,2,0,0,0,16,0,0,7,18,0,16,0, +1,0,0,0,70,18,16,0,1,0,0,0,70,2,16,0, +1,0,0,0,52,0,0,7,18,0,16,0,1,0,0,0, +10,0,16,0,1,0,0,0,1,64,0,0,0,0,0,0, +56,0,0,7,114,0,16,0,1,0,0,0,6,0,16,0, +1,0,0,0,70,18,16,0,3,0,0,0,56,0,0,10, +114,0,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +70,130,32,6,0,0,0,0,10,0,0,0,58,0,16,0, +0,0,0,0,56,0,0,7,114,0,16,0,1,0,0,0, +246,15,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +51,0,0,10,114,0,16,0,1,0,0,0,70,2,16,0, +1,0,0,0,2,64,0,0,0,0,128,63,0,0,128,63, +0,0,128,63,0,0,0,0,0,0,0,7,114,0,16,0, +0,0,0,0,70,2,16,0,0,0,0,0,70,2,16,0, +1,0,0,0,30,0,0,7,130,0,16,0,0,0,0,0, +58,0,16,0,0,0,0,0,1,64,0,0,1,0,0,0, +22,0,0,1,54,0,0,5,114,32,16,0,0,0,0,0, +70,2,16,0,0,0,0,0,54,0,0,5,114,32,16,0, +1,0,0,0,70,18,16,0,4,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,32,0,0,0,3,0,0,0, +0,0,0,0,7,0,0,0,20,0,0,0,2,0,0,0, +1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,4,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +188,4,0,0,1,0,0,0,108,0,0,0,1,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,142,4,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +85,110,105,116,121,70,70,86,101,114,116,101,120,0,171,171, +92,0,0,0,14,0,0,0,132,0,0,0,240,3,0,0, +0,0,0,0,0,0,0,0,180,2,0,0,0,0,0,0, +64,0,0,0,0,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +240,2,0,0,64,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,253,2,0,0,128,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +56,3,0,0,144,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,71,3,0,0,160,0,0,0, +128,0,0,0,2,0,0,0,88,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +124,3,0,0,32,1,0,0,128,0,0,0,2,0,0,0, +140,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,176,3,0,0,160,1,0,0, +128,0,0,0,2,0,0,0,192,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +228,3,0,0,32,2,0,0,128,0,0,0,2,0,0,0, +244,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,24,4,0,0,160,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +39,4,0,0,176,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,54,4,0,0,192,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +66,4,0,0,208,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,82,4,0,0,224,2,0,0, +0,1,0,0,0,0,0,0,96,4,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +132,4,0,0,224,3,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,102,102,95,109,97,116,114,105, +120,95,109,118,112,0,102,108,111,97,116,52,120,52,0,171, +3,0,3,0,4,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +194,2,0,0,102,102,95,109,97,116,114,105,120,95,109,118, +0,102,102,95,118,101,99,95,99,111,108,111,114,0,102,108, +111,97,116,52,0,171,171,171,1,0,3,0,1,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,118, +101,99,95,97,109,98,105,101,110,116,0,102,102,95,108,105, +103,104,116,95,99,111,108,111,114,0,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,112,111,115,0,171,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,97,116,116, +101,110,0,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,115,112,111,116,0,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,109, +97,116,95,100,105,102,102,117,115,101,0,102,102,95,109,97, +116,95,97,109,98,105,101,110,116,0,102,102,95,109,97,116, +95,115,112,101,99,0,102,102,95,109,97,116,95,101,109,105, +115,115,105,111,110,0,102,102,95,109,97,116,114,105,120,95, +116,101,120,0,3,0,3,0,4,0,4,0,4,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,194,2,0,0,102,102,95,102,111,103,95,118, +115,0,77,105,99,114,111,115,111,102,116,32,40,82,41,32, +72,76,83,76,32,83,104,97,100,101,114,32,67,111,109,112, +105,108,101,114,32,54,46,51,46,57,52,49,53,46,48,0, +76,70,83,48,164,1,0,0,7,0,0,0,8,0,0,0, +88,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,2,0,0,0, +255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0, +106,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +118,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,1,0,0,0, +1,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +128,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,1,0,0,0, +2,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +136,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +149,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,3,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +159,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,1,0,0,0, +5,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +67,111,109,112,117,116,101,83,112,111,116,76,105,103,104,116, +55,0,101,121,101,80,111,115,105,116,105,111,110,0,101,121, +101,78,111,114,109,97,108,0,118,105,101,119,68,105,114,0, +100,105,102,102,117,115,101,67,111,108,111,114,0,115,112,101, +99,67,111,108,111,114,0,97,109,98,0,171,76,73,66,70, +80,16,0,0,68,88,66,67,54,132,209,166,254,167,118,10, +196,111,133,126,129,212,65,104,1,0,0,0,80,16,0,0, +5,0,0,0,52,0,0,0,156,3,0,0,96,9,0,0, +220,9,0,0,160,14,0,0,65,111,110,57,96,3,0,0, +96,3,0,0,0,2,86,76,48,3,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,0,0,0,0,45,0,0,0,0,0,0,0, +0,2,86,76,81,0,0,5,45,0,15,160,0,0,0,0, +0,0,0,0,0,0,128,63,0,0,0,0,48,0,0,5, +0,0,15,240,7,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,31,0,0,2,5,0,0,128,0,0,15,144, +31,0,0,2,5,0,1,128,1,0,15,144,31,0,0,2, +5,0,2,128,2,0,15,144,31,0,0,2,5,0,3,128, +3,0,15,144,31,0,0,2,5,0,4,128,4,0,15,144, +31,0,0,2,5,0,5,128,5,0,15,144,1,0,0,2, +0,0,7,128,4,0,228,144,1,0,0,2,1,0,7,128, +5,0,228,144,27,0,0,2,0,8,228,240,0,0,228,240, +4,0,0,6,2,0,7,128,0,0,228,144,18,32,255,161, +0,8,228,240,18,32,228,160,0,8,228,240,8,0,0,3, +0,0,8,128,2,0,228,128,2,0,228,128,7,0,0,2, +1,0,8,128,0,0,255,128,4,0,0,4,3,0,7,128, +2,0,228,128,1,0,255,128,2,0,228,144,36,0,0,2, +4,0,7,128,3,0,228,128,8,0,0,3,2,0,8,128, +1,0,228,144,4,0,228,128,5,0,0,5,3,0,1,128, +18,32,255,160,0,8,228,240,18,32,255,160,0,8,228,240, +12,0,0,3,3,0,1,128,3,0,0,129,3,0,0,128, +12,0,0,4,3,0,2,128,26,32,255,160,0,8,228,240, +0,0,255,128,5,0,0,3,3,0,1,128,3,0,85,128, +3,0,0,128,5,0,0,4,0,0,8,128,0,0,255,128, +26,32,170,160,0,8,228,240,2,0,0,3,0,0,8,128, +0,0,255,128,45,0,170,160,6,0,0,2,0,0,8,128, +0,0,255,128,4,0,0,4,0,0,8,128,3,0,0,128, +0,0,255,129,0,0,255,128,11,0,0,3,2,0,8,128, +2,0,255,128,45,0,85,160,32,0,0,3,3,0,1,128, +2,0,255,128,44,0,255,160,10,0,0,3,2,0,8,128, +3,0,0,128,45,0,170,160,5,0,0,3,2,0,7,128, +1,0,255,128,2,0,228,128,8,0,0,3,1,0,8,128, +1,0,228,144,2,0,228,128,8,0,0,4,2,0,1,128, +2,0,228,128,34,32,228,160,0,8,228,240,11,0,0,3, +2,0,1,128,2,0,0,128,45,0,85,160,2,0,0,4, +2,0,1,128,2,0,0,128,26,32,0,161,0,8,228,240, +5,0,0,4,2,0,1,128,2,0,0,128,26,32,85,160, +0,8,228,240,11,0,0,3,2,0,1,128,2,0,0,128, +45,0,85,160,10,0,0,3,2,0,1,128,2,0,0,128, +45,0,170,160,5,0,0,3,0,0,8,128,0,0,255,128, +2,0,0,128,11,0,0,3,1,0,8,128,1,0,255,128, +45,0,85,160,12,0,0,3,2,0,1,128,45,0,85,160, +1,0,255,128,5,0,0,3,2,0,2,128,2,0,255,128, +0,0,255,128,5,0,0,4,2,0,14,128,2,0,85,128, +10,32,144,160,0,8,228,240,4,0,0,4,0,0,7,128, +2,0,0,128,2,0,249,128,0,0,228,128,5,0,0,3, +2,0,7,128,1,0,255,128,3,0,228,144,5,0,0,4, +2,0,7,128,2,0,228,128,10,32,228,160,0,8,228,240, +5,0,0,3,2,0,7,128,0,0,255,128,2,0,228,128, +10,0,0,3,2,0,7,128,2,0,228,128,45,0,170,160, +2,0,0,3,1,0,7,128,1,0,228,128,2,0,228,128, +29,0,0,0,1,0,0,2,1,0,7,224,0,0,228,128, +1,0,0,2,0,0,7,224,1,0,228,128,255,255,0,0, +83,72,68,82,188,5,0,0,64,0,240,255,111,1,0,0, +89,8,0,4,70,142,32,0,0,0,0,0,45,0,0,0, +95,0,0,3,114,16,16,0,0,0,0,0,95,0,0,3, +114,16,16,0,1,0,0,0,95,0,0,3,114,16,16,0, +2,0,0,0,95,0,0,3,114,16,16,0,3,0,0,0, +95,0,0,3,114,16,16,0,4,0,0,0,95,0,0,3, +114,16,16,0,5,0,0,0,101,0,0,3,114,32,16,0, +0,0,0,0,101,0,0,3,114,32,16,0,1,0,0,0, +104,0,0,2,4,0,0,0,54,0,0,5,114,0,16,0, +0,0,0,0,70,18,16,0,4,0,0,0,54,0,0,5, +114,0,16,0,1,0,0,0,70,18,16,0,5,0,0,0, +54,0,0,5,130,0,16,0,0,0,0,0,1,64,0,0, +0,0,0,0,48,0,0,1,33,0,0,7,130,0,16,0, +1,0,0,0,58,0,16,0,0,0,0,0,1,64,0,0, +7,0,0,0,3,0,4,3,58,0,16,0,1,0,0,0, +50,0,0,16,114,0,16,0,2,0,0,0,70,18,16,128, +65,0,0,0,0,0,0,0,246,143,32,6,0,0,0,0, +18,0,0,0,58,0,16,0,0,0,0,0,70,130,32,6, +0,0,0,0,18,0,0,0,58,0,16,0,0,0,0,0, +16,0,0,7,130,0,16,0,1,0,0,0,70,2,16,0, +2,0,0,0,70,2,16,0,2,0,0,0,50,0,0,12, +130,0,16,0,2,0,0,0,42,128,32,6,0,0,0,0, +26,0,0,0,58,0,16,0,0,0,0,0,58,0,16,0, +1,0,0,0,1,64,0,0,0,0,128,63,14,0,0,10, +130,0,16,0,2,0,0,0,2,64,0,0,0,0,128,63, +0,0,128,63,0,0,128,63,0,0,128,63,58,0,16,0, +2,0,0,0,57,0,0,10,18,0,16,0,3,0,0,0, +1,64,0,0,0,0,0,0,58,128,32,6,0,0,0,0, +18,0,0,0,58,0,16,0,0,0,0,0,49,0,0,10, +34,0,16,0,3,0,0,0,58,128,32,6,0,0,0,0, +26,0,0,0,58,0,16,0,0,0,0,0,58,0,16,0, +1,0,0,0,1,0,0,7,18,0,16,0,3,0,0,0, +26,0,16,0,3,0,0,0,10,0,16,0,3,0,0,0, +55,0,0,9,130,0,16,0,2,0,0,0,10,0,16,0, +3,0,0,0,1,64,0,0,0,0,0,0,58,0,16,0, +2,0,0,0,68,0,0,5,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,56,0,0,7,114,0,16,0, +3,0,0,0,246,15,16,0,1,0,0,0,70,2,16,0, +2,0,0,0,16,0,0,10,130,0,16,0,3,0,0,0, +70,2,16,0,3,0,0,0,70,130,32,6,0,0,0,0, +34,0,0,0,58,0,16,0,0,0,0,0,52,0,0,7, +130,0,16,0,3,0,0,0,58,0,16,0,3,0,0,0, +1,64,0,0,0,0,0,0,0,0,0,11,130,0,16,0, +3,0,0,0,58,0,16,0,3,0,0,0,10,128,32,134, +65,0,0,0,0,0,0,0,26,0,0,0,58,0,16,0, +0,0,0,0,56,32,0,10,130,0,16,0,3,0,0,0, +58,0,16,0,3,0,0,0,26,128,32,6,0,0,0,0, +26,0,0,0,58,0,16,0,0,0,0,0,56,0,0,7, +130,0,16,0,2,0,0,0,58,0,16,0,2,0,0,0, +58,0,16,0,3,0,0,0,16,0,0,7,18,0,16,0, +3,0,0,0,70,18,16,0,1,0,0,0,70,2,16,0, +3,0,0,0,52,0,0,7,18,0,16,0,3,0,0,0, +10,0,16,0,3,0,0,0,1,64,0,0,0,0,0,0, +56,0,0,7,226,0,16,0,3,0,0,0,6,0,16,0, +3,0,0,0,6,25,16,0,3,0,0,0,56,0,0,10, +226,0,16,0,3,0,0,0,86,14,16,0,3,0,0,0, +6,137,32,6,0,0,0,0,10,0,0,0,58,0,16,0, +0,0,0,0,49,0,0,7,18,0,16,0,3,0,0,0, +1,64,0,0,0,0,0,0,10,0,16,0,3,0,0,0, +31,0,4,3,10,0,16,0,3,0,0,0,50,0,0,9, +114,0,16,0,2,0,0,0,70,2,16,0,2,0,0,0, +246,15,16,0,1,0,0,0,70,18,16,0,2,0,0,0, +16,0,0,7,130,0,16,0,1,0,0,0,70,2,16,0, +2,0,0,0,70,2,16,0,2,0,0,0,68,0,0,5, +130,0,16,0,1,0,0,0,58,0,16,0,1,0,0,0, +56,0,0,7,114,0,16,0,2,0,0,0,246,15,16,0, +1,0,0,0,70,2,16,0,2,0,0,0,16,0,0,7, +130,0,16,0,1,0,0,0,70,18,16,0,1,0,0,0, +70,2,16,0,2,0,0,0,52,0,0,7,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,1,64,0,0, +0,0,0,0,47,0,0,5,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,56,0,0,8,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,58,128,32,0, +0,0,0,0,44,0,0,0,25,0,0,5,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,51,0,0,7, +130,0,16,0,1,0,0,0,58,0,16,0,1,0,0,0, +1,64,0,0,0,0,128,63,56,0,0,7,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,58,0,16,0, +2,0,0,0,50,0,0,12,114,0,16,0,0,0,0,0, +246,15,16,0,1,0,0,0,70,130,32,6,0,0,0,0, +10,0,0,0,58,0,16,0,0,0,0,0,70,2,16,0, +0,0,0,0,21,0,0,1,56,0,0,7,114,0,16,0, +2,0,0,0,246,15,16,0,2,0,0,0,150,7,16,0, +3,0,0,0,51,0,0,10,114,0,16,0,2,0,0,0, +70,2,16,0,2,0,0,0,2,64,0,0,0,0,128,63, +0,0,128,63,0,0,128,63,0,0,0,0,0,0,0,7, +114,0,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +70,2,16,0,2,0,0,0,30,0,0,7,130,0,16,0, +0,0,0,0,58,0,16,0,0,0,0,0,1,64,0,0, +1,0,0,0,22,0,0,1,54,0,0,5,114,32,16,0, +1,0,0,0,70,2,16,0,0,0,0,0,54,0,0,5, +114,32,16,0,0,0,0,0,70,2,16,0,1,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,48,0,0,0, +4,0,0,0,0,0,0,0,8,0,0,0,33,0,0,0, +2,0,0,0,1,0,0,0,1,0,0,0,2,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,5,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,188,4,0,0,1,0,0,0,108,0,0,0, +1,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +142,4,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,92,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,85,110,105,116,121,70,70,86,101,114,116,101, +120,0,171,171,92,0,0,0,14,0,0,0,132,0,0,0, +240,3,0,0,0,0,0,0,0,0,0,0,180,2,0,0, +0,0,0,0,64,0,0,0,0,0,0,0,204,2,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,240,2,0,0,64,0,0,0,64,0,0,0, +0,0,0,0,204,2,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,253,2,0,0, +128,0,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,56,3,0,0,144,0,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,71,3,0,0, +160,0,0,0,128,0,0,0,2,0,0,0,88,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,124,3,0,0,32,1,0,0,128,0,0,0, +2,0,0,0,140,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,176,3,0,0, +160,1,0,0,128,0,0,0,2,0,0,0,192,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,228,3,0,0,32,2,0,0,128,0,0,0, +2,0,0,0,244,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,24,4,0,0, +160,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,39,4,0,0,176,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,54,4,0,0, +192,2,0,0,16,0,0,0,2,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,66,4,0,0,208,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,82,4,0,0, +224,2,0,0,0,1,0,0,0,0,0,0,96,4,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,132,4,0,0,224,3,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,102,102,95,109, +97,116,114,105,120,95,109,118,112,0,102,108,111,97,116,52, +120,52,0,171,3,0,3,0,4,0,4,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,194,2,0,0,102,102,95,109,97,116,114,105, +120,95,109,118,0,102,102,95,118,101,99,95,99,111,108,111, +114,0,102,108,111,97,116,52,0,171,171,171,1,0,3,0, +1,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,118,101,99,95,97,109,98,105,101,110,116,0,102, +102,95,108,105,103,104,116,95,99,111,108,111,114,0,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,112,111,115, +0,171,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,97,116,116,101,110,0,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,115,112,111,116,0,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,109,97,116,95,100,105,102,102,117,115,101,0,102, +102,95,109,97,116,95,97,109,98,105,101,110,116,0,102,102, +95,109,97,116,95,115,112,101,99,0,102,102,95,109,97,116, +95,101,109,105,115,115,105,111,110,0,102,102,95,109,97,116, +114,105,120,95,116,101,120,0,3,0,3,0,4,0,4,0, +4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,194,2,0,0,102,102,95,102, +111,103,95,118,115,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,168,1,0,0,7,0,0,0, +8,0,0,0,88,1,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,110,1,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,122,1,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,1,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,132,1,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,2,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,140,1,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,153,1,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +3,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,163,1,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,5,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,67,111,109,112,117,116,101,83,112,111,116,76, +105,103,104,116,83,112,101,99,55,0,101,121,101,80,111,115, +105,116,105,111,110,0,101,121,101,78,111,114,109,97,108,0, +118,105,101,119,68,105,114,0,100,105,102,102,117,115,101,67, +111,108,111,114,0,115,112,101,99,67,111,108,111,114,0,97, +109,98,0,171,76,73,66,70,28,24,0,0,68,88,66,67, +86,133,213,195,182,2,158,132,118,12,245,138,38,54,53,58, +1,0,0,0,28,24,0,0,5,0,0,0,52,0,0,0, +16,13,0,0,48,17,0,0,172,17,0,0,112,22,0,0, +65,111,110,57,212,12,0,0,212,12,0,0,0,2,86,76, +164,12,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,0,0,10,0, +32,0,0,0,0,0,0,0,0,2,86,76,81,0,0,5, +32,0,15,160,0,0,128,63,0,0,0,0,0,0,0,0, +0,0,0,0,31,0,0,2,5,0,0,128,0,0,15,144, +31,0,0,2,5,0,1,128,1,0,15,144,31,0,0,2, +5,0,3,128,3,0,15,144,31,0,0,2,5,0,4,128, +4,0,15,144,31,0,0,2,5,0,5,128,5,0,15,144, +5,0,0,3,0,0,1,128,8,0,255,160,8,0,255,160, +12,0,0,3,0,0,1,128,0,0,0,129,0,0,0,128, +4,0,0,4,0,0,14,128,0,0,144,144,8,0,255,161, +8,0,144,160,8,0,0,3,1,0,1,128,0,0,249,128, +0,0,249,128,12,0,0,3,1,0,2,128,16,0,255,160, +1,0,0,128,5,0,0,3,0,0,1,128,0,0,0,128, +1,0,85,128,1,0,0,2,2,0,1,128,32,0,0,160, +4,0,0,4,1,0,2,128,16,0,170,160,1,0,0,128, +2,0,0,128,7,0,0,2,1,0,1,128,1,0,0,128, +5,0,0,3,0,0,14,128,0,0,228,128,1,0,0,128, +6,0,0,2,1,0,1,128,1,0,85,128,4,0,0,4, +0,0,1,128,0,0,0,128,1,0,0,129,1,0,0,128, +8,0,0,3,1,0,1,128,0,0,249,128,24,0,228,160, +8,0,0,3,0,0,2,128,1,0,228,144,0,0,249,128, +11,0,0,3,0,0,2,128,0,0,85,128,32,0,85,160, +5,0,0,3,0,0,14,128,0,0,85,128,3,0,144,144, +5,0,0,3,0,0,14,128,0,0,228,128,0,0,144,160, +11,0,0,3,1,0,1,128,1,0,0,128,32,0,85,160, +2,0,0,3,1,0,1,128,1,0,0,128,16,0,0,161, +5,0,0,3,1,0,1,128,1,0,0,128,16,0,85,160, +11,0,0,3,1,0,1,128,1,0,0,128,32,0,85,160, +10,0,0,3,1,0,1,128,1,0,0,128,32,0,0,160, +5,0,0,3,0,0,1,128,0,0,0,128,1,0,0,128, +5,0,0,3,0,0,7,128,0,0,0,128,0,0,249,128, +10,0,0,3,0,0,7,128,0,0,228,128,32,0,0,160, +2,0,0,3,0,0,7,128,0,0,228,128,5,0,228,144, +5,0,0,3,0,0,8,128,9,0,255,160,9,0,255,160, +12,0,0,3,0,0,8,128,0,0,255,129,0,0,255,128, +4,0,0,4,1,0,7,128,0,0,228,144,9,0,255,161, +9,0,228,160,8,0,0,3,1,0,8,128,1,0,228,128, +1,0,228,128,12,0,0,3,2,0,2,128,17,0,255,160, +1,0,255,128,5,0,0,3,0,0,8,128,0,0,255,128, +2,0,85,128,4,0,0,4,2,0,2,128,17,0,170,160, +1,0,255,128,2,0,0,128,7,0,0,2,1,0,8,128, +1,0,255,128,5,0,0,3,1,0,7,128,1,0,255,128, +1,0,228,128,6,0,0,2,1,0,8,128,2,0,85,128, +4,0,0,4,0,0,8,128,0,0,255,128,1,0,255,129, +1,0,255,128,8,0,0,3,1,0,8,128,1,0,228,128, +25,0,228,160,8,0,0,3,1,0,1,128,1,0,228,144, +1,0,228,128,11,0,0,3,1,0,9,128,1,0,228,128, +32,0,85,160,5,0,0,3,1,0,7,128,1,0,0,128, +3,0,228,144,5,0,0,3,1,0,7,128,1,0,228,128, +1,0,228,160,2,0,0,3,1,0,8,128,1,0,255,128, +17,0,0,161,5,0,0,3,1,0,8,128,1,0,255,128, +17,0,85,160,11,0,0,3,1,0,8,128,1,0,255,128, +32,0,85,160,10,0,0,3,1,0,8,128,1,0,255,128, +32,0,0,160,5,0,0,3,0,0,8,128,0,0,255,128, +1,0,255,128,5,0,0,3,1,0,7,128,0,0,255,128, +1,0,228,128,10,0,0,3,1,0,7,128,1,0,228,128, +32,0,0,160,2,0,0,3,0,0,7,128,0,0,228,128, +1,0,228,128,5,0,0,3,0,0,8,128,10,0,255,160, +10,0,255,160,12,0,0,3,0,0,8,128,0,0,255,129, +0,0,255,128,4,0,0,4,1,0,7,128,0,0,228,144, +10,0,255,161,10,0,228,160,8,0,0,3,1,0,8,128, +1,0,228,128,1,0,228,128,12,0,0,3,2,0,2,128, +18,0,255,160,1,0,255,128,5,0,0,3,0,0,8,128, +0,0,255,128,2,0,85,128,4,0,0,4,2,0,2,128, +18,0,170,160,1,0,255,128,2,0,0,128,7,0,0,2, +1,0,8,128,1,0,255,128,5,0,0,3,1,0,7,128, +1,0,255,128,1,0,228,128,6,0,0,2,1,0,8,128, +2,0,85,128,4,0,0,4,0,0,8,128,0,0,255,128, +1,0,255,129,1,0,255,128,8,0,0,3,1,0,8,128, +1,0,228,128,26,0,228,160,8,0,0,3,1,0,1,128, +1,0,228,144,1,0,228,128,11,0,0,3,1,0,9,128, +1,0,228,128,32,0,85,160,5,0,0,3,1,0,7,128, +1,0,0,128,3,0,228,144,5,0,0,3,1,0,7,128, +1,0,228,128,2,0,228,160,2,0,0,3,1,0,8,128, +1,0,255,128,18,0,0,161,5,0,0,3,1,0,8,128, +1,0,255,128,18,0,85,160,11,0,0,3,1,0,8,128, +1,0,255,128,32,0,85,160,10,0,0,3,1,0,8,128, +1,0,255,128,32,0,0,160,5,0,0,3,0,0,8,128, +0,0,255,128,1,0,255,128,5,0,0,3,1,0,7,128, +0,0,255,128,1,0,228,128,10,0,0,3,1,0,7,128, +1,0,228,128,32,0,0,160,2,0,0,3,0,0,7,128, +0,0,228,128,1,0,228,128,5,0,0,3,0,0,8,128, +11,0,255,160,11,0,255,160,12,0,0,3,0,0,8,128, +0,0,255,129,0,0,255,128,4,0,0,4,1,0,7,128, +0,0,228,144,11,0,255,161,11,0,228,160,8,0,0,3, +1,0,8,128,1,0,228,128,1,0,228,128,12,0,0,3, +2,0,2,128,19,0,255,160,1,0,255,128,5,0,0,3, +0,0,8,128,0,0,255,128,2,0,85,128,4,0,0,4, +2,0,2,128,19,0,170,160,1,0,255,128,2,0,0,128, +7,0,0,2,1,0,8,128,1,0,255,128,5,0,0,3, +1,0,7,128,1,0,255,128,1,0,228,128,6,0,0,2, +1,0,8,128,2,0,85,128,4,0,0,4,0,0,8,128, +0,0,255,128,1,0,255,129,1,0,255,128,8,0,0,3, +1,0,8,128,1,0,228,128,27,0,228,160,8,0,0,3, +1,0,1,128,1,0,228,144,1,0,228,128,11,0,0,3, +1,0,9,128,1,0,228,128,32,0,85,160,5,0,0,3, +1,0,7,128,1,0,0,128,3,0,228,144,5,0,0,3, +1,0,7,128,1,0,228,128,3,0,228,160,2,0,0,3, +1,0,8,128,1,0,255,128,19,0,0,161,5,0,0,3, +1,0,8,128,1,0,255,128,19,0,85,160,11,0,0,3, +1,0,8,128,1,0,255,128,32,0,85,160,10,0,0,3, +1,0,8,128,1,0,255,128,32,0,0,160,5,0,0,3, +0,0,8,128,0,0,255,128,1,0,255,128,5,0,0,3, +1,0,7,128,0,0,255,128,1,0,228,128,10,0,0,3, +1,0,7,128,1,0,228,128,32,0,0,160,2,0,0,3, +0,0,7,128,0,0,228,128,1,0,228,128,5,0,0,3, +0,0,8,128,12,0,255,160,12,0,255,160,12,0,0,3, +0,0,8,128,0,0,255,129,0,0,255,128,4,0,0,4, +1,0,7,128,0,0,228,144,12,0,255,161,12,0,228,160, +8,0,0,3,1,0,8,128,1,0,228,128,1,0,228,128, +12,0,0,3,2,0,2,128,20,0,255,160,1,0,255,128, +5,0,0,3,0,0,8,128,0,0,255,128,2,0,85,128, +4,0,0,4,2,0,2,128,20,0,170,160,1,0,255,128, +2,0,0,128,7,0,0,2,1,0,8,128,1,0,255,128, +5,0,0,3,1,0,7,128,1,0,255,128,1,0,228,128, +6,0,0,2,1,0,8,128,2,0,85,128,4,0,0,4, +0,0,8,128,0,0,255,128,1,0,255,129,1,0,255,128, +8,0,0,3,1,0,8,128,1,0,228,128,28,0,228,160, +8,0,0,3,1,0,1,128,1,0,228,144,1,0,228,128, +11,0,0,3,1,0,9,128,1,0,228,128,32,0,85,160, +5,0,0,3,1,0,7,128,1,0,0,128,3,0,228,144, +5,0,0,3,1,0,7,128,1,0,228,128,4,0,228,160, +2,0,0,3,1,0,8,128,1,0,255,128,20,0,0,161, +5,0,0,3,1,0,8,128,1,0,255,128,20,0,85,160, +11,0,0,3,1,0,8,128,1,0,255,128,32,0,85,160, +10,0,0,3,1,0,8,128,1,0,255,128,32,0,0,160, +5,0,0,3,0,0,8,128,0,0,255,128,1,0,255,128, +5,0,0,3,1,0,7,128,0,0,255,128,1,0,228,128, +10,0,0,3,1,0,7,128,1,0,228,128,32,0,0,160, +2,0,0,3,0,0,7,128,0,0,228,128,1,0,228,128, +5,0,0,3,0,0,8,128,13,0,255,160,13,0,255,160, +12,0,0,3,0,0,8,128,0,0,255,129,0,0,255,128, +4,0,0,4,1,0,7,128,0,0,228,144,13,0,255,161, +13,0,228,160,8,0,0,3,1,0,8,128,1,0,228,128, +1,0,228,128,12,0,0,3,2,0,2,128,21,0,255,160, +1,0,255,128,5,0,0,3,0,0,8,128,0,0,255,128, +2,0,85,128,4,0,0,4,2,0,2,128,21,0,170,160, +1,0,255,128,2,0,0,128,7,0,0,2,1,0,8,128, +1,0,255,128,5,0,0,3,1,0,7,128,1,0,255,128, +1,0,228,128,6,0,0,2,1,0,8,128,2,0,85,128, +4,0,0,4,0,0,8,128,0,0,255,128,1,0,255,129, +1,0,255,128,8,0,0,3,1,0,8,128,1,0,228,128, +29,0,228,160,8,0,0,3,1,0,1,128,1,0,228,144, +1,0,228,128,11,0,0,3,1,0,9,128,1,0,228,128, +32,0,85,160,5,0,0,3,1,0,7,128,1,0,0,128, +3,0,228,144,5,0,0,3,1,0,7,128,1,0,228,128, +5,0,228,160,2,0,0,3,1,0,8,128,1,0,255,128, +21,0,0,161,5,0,0,3,1,0,8,128,1,0,255,128, +21,0,85,160,11,0,0,3,1,0,8,128,1,0,255,128, +32,0,85,160,10,0,0,3,1,0,8,128,1,0,255,128, +32,0,0,160,5,0,0,3,0,0,8,128,0,0,255,128, +1,0,255,128,5,0,0,3,1,0,7,128,0,0,255,128, +1,0,228,128,10,0,0,3,1,0,7,128,1,0,228,128, +32,0,0,160,2,0,0,3,0,0,7,128,0,0,228,128, +1,0,228,128,5,0,0,3,0,0,8,128,14,0,255,160, +14,0,255,160,12,0,0,3,0,0,8,128,0,0,255,129, +0,0,255,128,4,0,0,4,1,0,7,128,0,0,228,144, +14,0,255,161,14,0,228,160,8,0,0,3,1,0,8,128, +1,0,228,128,1,0,228,128,12,0,0,3,2,0,2,128, +22,0,255,160,1,0,255,128,5,0,0,3,0,0,8,128, +0,0,255,128,2,0,85,128,4,0,0,4,2,0,2,128, +22,0,170,160,1,0,255,128,2,0,0,128,7,0,0,2, +1,0,8,128,1,0,255,128,5,0,0,3,1,0,7,128, +1,0,255,128,1,0,228,128,6,0,0,2,1,0,8,128, +2,0,85,128,4,0,0,4,0,0,8,128,0,0,255,128, +1,0,255,129,1,0,255,128,8,0,0,3,1,0,8,128, +1,0,228,128,30,0,228,160,8,0,0,3,1,0,1,128, +1,0,228,144,1,0,228,128,11,0,0,3,1,0,9,128, +1,0,228,128,32,0,85,160,5,0,0,3,1,0,7,128, +1,0,0,128,3,0,228,144,5,0,0,3,1,0,7,128, +1,0,228,128,6,0,228,160,2,0,0,3,1,0,8,128, +1,0,255,128,22,0,0,161,5,0,0,3,1,0,8,128, +1,0,255,128,22,0,85,160,11,0,0,3,1,0,8,128, +1,0,255,128,32,0,85,160,10,0,0,3,1,0,8,128, +1,0,255,128,32,0,0,160,5,0,0,3,0,0,8,128, +0,0,255,128,1,0,255,128,5,0,0,3,1,0,7,128, +0,0,255,128,1,0,228,128,10,0,0,3,1,0,7,128, +1,0,228,128,32,0,0,160,2,0,0,3,0,0,7,128, +0,0,228,128,1,0,228,128,5,0,0,3,0,0,8,128, +15,0,255,160,15,0,255,160,12,0,0,3,0,0,8,128, +0,0,255,129,0,0,255,128,4,0,0,4,1,0,7,128, +0,0,228,144,15,0,255,161,15,0,228,160,8,0,0,3, +1,0,8,128,1,0,228,128,1,0,228,128,12,0,0,3, +2,0,2,128,23,0,255,160,1,0,255,128,5,0,0,3, +0,0,8,128,0,0,255,128,2,0,85,128,4,0,0,4, +2,0,1,128,23,0,170,160,1,0,255,128,2,0,0,128, +7,0,0,2,1,0,8,128,1,0,255,128,5,0,0,3, +1,0,7,128,1,0,255,128,1,0,228,128,6,0,0,2, +1,0,8,128,2,0,0,128,4,0,0,4,0,0,8,128, +0,0,255,128,1,0,255,129,1,0,255,128,8,0,0,3, +1,0,8,128,1,0,228,128,31,0,228,160,8,0,0,3, +1,0,1,128,1,0,228,144,1,0,228,128,11,0,0,3, +1,0,9,128,1,0,228,128,32,0,85,160,5,0,0,3, +1,0,7,128,1,0,0,128,3,0,228,144,5,0,0,3, +1,0,7,128,1,0,228,128,7,0,228,160,2,0,0,3, +1,0,8,128,1,0,255,128,23,0,0,161,5,0,0,3, +1,0,8,128,1,0,255,128,23,0,85,160,11,0,0,3, +1,0,8,128,1,0,255,128,32,0,85,160,10,0,0,3, +1,0,8,128,1,0,255,128,32,0,0,160,5,0,0,3, +0,0,8,128,0,0,255,128,1,0,255,128,5,0,0,3, +1,0,7,128,0,0,255,128,1,0,228,128,10,0,0,3, +1,0,7,128,1,0,228,128,32,0,0,160,2,0,0,3, +0,0,7,224,0,0,228,128,1,0,228,128,1,0,0,2, +1,0,7,224,4,0,228,144,255,255,0,0,83,72,68,82, +24,4,0,0,64,0,240,255,6,1,0,0,89,8,0,4, +70,142,32,0,0,0,0,0,42,0,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,95,0,0,3,114,16,16,0, +1,0,0,0,95,0,0,3,114,16,16,0,3,0,0,0, +95,0,0,3,114,16,16,0,4,0,0,0,95,0,0,3, +114,16,16,0,5,0,0,0,101,0,0,3,114,32,16,0, +0,0,0,0,101,0,0,3,114,32,16,0,1,0,0,0, +104,0,0,2,3,0,0,0,54,0,0,5,114,0,16,0, +0,0,0,0,70,18,16,0,5,0,0,0,54,0,0,5, +130,0,16,0,0,0,0,0,1,64,0,0,0,0,0,0, +48,0,0,1,33,0,0,7,18,0,16,0,1,0,0,0, +58,0,16,0,0,0,0,0,1,64,0,0,8,0,0,0, +3,0,4,3,10,0,16,0,1,0,0,0,50,0,0,16, +114,0,16,0,1,0,0,0,70,18,16,128,65,0,0,0, +0,0,0,0,246,143,32,6,0,0,0,0,18,0,0,0, +58,0,16,0,0,0,0,0,70,130,32,6,0,0,0,0, +18,0,0,0,58,0,16,0,0,0,0,0,16,0,0,7, +130,0,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +70,2,16,0,1,0,0,0,50,0,0,12,18,0,16,0, +2,0,0,0,42,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,58,0,16,0,1,0,0,0, +1,64,0,0,0,0,128,63,14,0,0,10,18,0,16,0, +2,0,0,0,2,64,0,0,0,0,128,63,0,0,128,63, +0,0,128,63,0,0,128,63,10,0,16,0,2,0,0,0, +57,0,0,10,34,0,16,0,2,0,0,0,1,64,0,0, +0,0,0,0,58,128,32,6,0,0,0,0,18,0,0,0, +58,0,16,0,0,0,0,0,49,0,0,10,66,0,16,0, +2,0,0,0,58,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,58,0,16,0,1,0,0,0, +1,0,0,7,34,0,16,0,2,0,0,0,42,0,16,0, +2,0,0,0,26,0,16,0,2,0,0,0,55,0,0,9, +18,0,16,0,2,0,0,0,26,0,16,0,2,0,0,0, +1,64,0,0,0,0,0,0,10,0,16,0,2,0,0,0, +68,0,0,5,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,56,0,0,7,114,0,16,0,1,0,0,0, +246,15,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +16,0,0,10,130,0,16,0,1,0,0,0,70,2,16,0, +1,0,0,0,70,130,32,6,0,0,0,0,34,0,0,0, +58,0,16,0,0,0,0,0,52,0,0,7,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,1,64,0,0, +0,0,0,0,0,0,0,11,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,10,128,32,134,65,0,0,0, +0,0,0,0,26,0,0,0,58,0,16,0,0,0,0,0, +56,32,0,10,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,26,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,56,0,0,7,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,10,0,16,0, +2,0,0,0,16,0,0,7,18,0,16,0,1,0,0,0, +70,18,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +52,0,0,7,18,0,16,0,1,0,0,0,10,0,16,0, +1,0,0,0,1,64,0,0,0,0,0,0,56,0,0,7, +114,0,16,0,1,0,0,0,6,0,16,0,1,0,0,0, +70,18,16,0,3,0,0,0,56,0,0,10,114,0,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,70,130,32,6, +0,0,0,0,10,0,0,0,58,0,16,0,0,0,0,0, +56,0,0,7,114,0,16,0,1,0,0,0,246,15,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,51,0,0,10, +114,0,16,0,1,0,0,0,70,2,16,0,1,0,0,0, +2,64,0,0,0,0,128,63,0,0,128,63,0,0,128,63, +0,0,0,0,0,0,0,7,114,0,16,0,0,0,0,0, +70,2,16,0,0,0,0,0,70,2,16,0,1,0,0,0, +30,0,0,7,130,0,16,0,0,0,0,0,58,0,16,0, +0,0,0,0,1,64,0,0,1,0,0,0,22,0,0,1, +54,0,0,5,114,32,16,0,0,0,0,0,70,2,16,0, +0,0,0,0,54,0,0,5,114,32,16,0,1,0,0,0, +70,18,16,0,4,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,32,0,0,0,3,0,0,0,0,0,0,0, +7,0,0,0,20,0,0,0,2,0,0,0,1,0,0,0, +1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +4,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,188,4,0,0, +1,0,0,0,108,0,0,0,1,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,142,4,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,92,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,85,110,105,116, +121,70,70,86,101,114,116,101,120,0,171,171,92,0,0,0, +14,0,0,0,132,0,0,0,240,3,0,0,0,0,0,0, +0,0,0,0,180,2,0,0,0,0,0,0,64,0,0,0, +0,0,0,0,204,2,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,240,2,0,0, +64,0,0,0,64,0,0,0,0,0,0,0,204,2,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,253,2,0,0,128,0,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,56,3,0,0, +144,0,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,71,3,0,0,160,0,0,0,128,0,0,0, +2,0,0,0,88,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,124,3,0,0, +32,1,0,0,128,0,0,0,2,0,0,0,140,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,176,3,0,0,160,1,0,0,128,0,0,0, +2,0,0,0,192,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,228,3,0,0, +32,2,0,0,128,0,0,0,2,0,0,0,244,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,24,4,0,0,160,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,39,4,0,0, +176,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,54,4,0,0,192,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,66,4,0,0, +208,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,82,4,0,0,224,2,0,0,0,1,0,0, +0,0,0,0,96,4,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,132,4,0,0, +224,3,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,102,102,95,109,97,116,114,105,120,95,109,118, +112,0,102,108,111,97,116,52,120,52,0,171,3,0,3,0, +4,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,194,2,0,0, +102,102,95,109,97,116,114,105,120,95,109,118,0,102,102,95, +118,101,99,95,99,111,108,111,114,0,102,108,111,97,116,52, +0,171,171,171,1,0,3,0,1,0,4,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,118,101,99,95,97, +109,98,105,101,110,116,0,102,102,95,108,105,103,104,116,95, +99,111,108,111,114,0,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,112,111,115,0,171,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,97,116,116,101,110,0,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,115,112,111, +116,0,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,109,97,116,95,100, +105,102,102,117,115,101,0,102,102,95,109,97,116,95,97,109, +98,105,101,110,116,0,102,102,95,109,97,116,95,115,112,101, +99,0,102,102,95,109,97,116,95,101,109,105,115,115,105,111, +110,0,102,102,95,109,97,116,114,105,120,95,116,101,120,0, +3,0,3,0,4,0,4,0,4,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +194,2,0,0,102,102,95,102,111,103,95,118,115,0,77,105, +99,114,111,115,111,102,116,32,40,82,41,32,72,76,83,76, +32,83,104,97,100,101,114,32,67,111,109,112,105,108,101,114, +32,54,46,51,46,57,52,49,53,46,48,0,76,70,83,48, +164,1,0,0,7,0,0,0,8,0,0,0,88,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,2,0,0,0,255,255,255,255, +255,255,255,255,0,0,0,0,0,0,0,0,106,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,118,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,128,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,136,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,149,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,3,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,159,1,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,5,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,67,111,109,112, +117,116,101,83,112,111,116,76,105,103,104,116,56,0,101,121, +101,80,111,115,105,116,105,111,110,0,101,121,101,78,111,114, +109,97,108,0,118,105,101,119,68,105,114,0,100,105,102,102, +117,115,101,67,111,108,111,114,0,115,112,101,99,67,111,108, +111,114,0,97,109,98,0,171,76,73,66,70,80,16,0,0, +68,88,66,67,235,115,185,156,43,13,47,75,143,138,114,228, +61,12,79,253,1,0,0,0,80,16,0,0,5,0,0,0, +52,0,0,0,156,3,0,0,96,9,0,0,220,9,0,0, +160,14,0,0,65,111,110,57,96,3,0,0,96,3,0,0, +0,2,86,76,48,3,0,0,48,0,0,0,1,0,36,0, +0,0,48,0,0,0,48,0,0,0,36,0,0,0,48,0, +0,0,0,0,45,0,0,0,0,0,0,0,0,2,86,76, +81,0,0,5,45,0,15,160,0,0,0,0,0,0,0,0, +0,0,128,63,0,0,0,0,48,0,0,5,0,0,15,240, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +31,0,0,2,5,0,0,128,0,0,15,144,31,0,0,2, +5,0,1,128,1,0,15,144,31,0,0,2,5,0,2,128, +2,0,15,144,31,0,0,2,5,0,3,128,3,0,15,144, +31,0,0,2,5,0,4,128,4,0,15,144,31,0,0,2, +5,0,5,128,5,0,15,144,1,0,0,2,0,0,7,128, +4,0,228,144,1,0,0,2,1,0,7,128,5,0,228,144, +27,0,0,2,0,8,228,240,0,0,228,240,4,0,0,6, +2,0,7,128,0,0,228,144,18,32,255,161,0,8,228,240, +18,32,228,160,0,8,228,240,8,0,0,3,0,0,8,128, +2,0,228,128,2,0,228,128,7,0,0,2,1,0,8,128, +0,0,255,128,4,0,0,4,3,0,7,128,2,0,228,128, +1,0,255,128,2,0,228,144,36,0,0,2,4,0,7,128, +3,0,228,128,8,0,0,3,2,0,8,128,1,0,228,144, +4,0,228,128,5,0,0,5,3,0,1,128,18,32,255,160, +0,8,228,240,18,32,255,160,0,8,228,240,12,0,0,3, +3,0,1,128,3,0,0,129,3,0,0,128,12,0,0,4, +3,0,2,128,26,32,255,160,0,8,228,240,0,0,255,128, +5,0,0,3,3,0,1,128,3,0,85,128,3,0,0,128, +5,0,0,4,0,0,8,128,0,0,255,128,26,32,170,160, +0,8,228,240,2,0,0,3,0,0,8,128,0,0,255,128, +45,0,170,160,6,0,0,2,0,0,8,128,0,0,255,128, +4,0,0,4,0,0,8,128,3,0,0,128,0,0,255,129, +0,0,255,128,11,0,0,3,2,0,8,128,2,0,255,128, +45,0,85,160,32,0,0,3,3,0,1,128,2,0,255,128, +44,0,255,160,10,0,0,3,2,0,8,128,3,0,0,128, +45,0,170,160,5,0,0,3,2,0,7,128,1,0,255,128, +2,0,228,128,8,0,0,3,1,0,8,128,1,0,228,144, +2,0,228,128,8,0,0,4,2,0,1,128,2,0,228,128, +34,32,228,160,0,8,228,240,11,0,0,3,2,0,1,128, +2,0,0,128,45,0,85,160,2,0,0,4,2,0,1,128, +2,0,0,128,26,32,0,161,0,8,228,240,5,0,0,4, +2,0,1,128,2,0,0,128,26,32,85,160,0,8,228,240, +11,0,0,3,2,0,1,128,2,0,0,128,45,0,85,160, +10,0,0,3,2,0,1,128,2,0,0,128,45,0,170,160, +5,0,0,3,0,0,8,128,0,0,255,128,2,0,0,128, +11,0,0,3,1,0,8,128,1,0,255,128,45,0,85,160, +12,0,0,3,2,0,1,128,45,0,85,160,1,0,255,128, +5,0,0,3,2,0,2,128,2,0,255,128,0,0,255,128, +5,0,0,4,2,0,14,128,2,0,85,128,10,32,144,160, +0,8,228,240,4,0,0,4,0,0,7,128,2,0,0,128, +2,0,249,128,0,0,228,128,5,0,0,3,2,0,7,128, +1,0,255,128,3,0,228,144,5,0,0,4,2,0,7,128, +2,0,228,128,10,32,228,160,0,8,228,240,5,0,0,3, +2,0,7,128,0,0,255,128,2,0,228,128,10,0,0,3, +2,0,7,128,2,0,228,128,45,0,170,160,2,0,0,3, +1,0,7,128,1,0,228,128,2,0,228,128,29,0,0,0, +1,0,0,2,1,0,7,224,0,0,228,128,1,0,0,2, +0,0,7,224,1,0,228,128,255,255,0,0,83,72,68,82, +188,5,0,0,64,0,240,255,111,1,0,0,89,8,0,4, +70,142,32,0,0,0,0,0,45,0,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,95,0,0,3,114,16,16,0, +1,0,0,0,95,0,0,3,114,16,16,0,2,0,0,0, +95,0,0,3,114,16,16,0,3,0,0,0,95,0,0,3, +114,16,16,0,4,0,0,0,95,0,0,3,114,16,16,0, +5,0,0,0,101,0,0,3,114,32,16,0,0,0,0,0, +101,0,0,3,114,32,16,0,1,0,0,0,104,0,0,2, +4,0,0,0,54,0,0,5,114,0,16,0,0,0,0,0, +70,18,16,0,4,0,0,0,54,0,0,5,114,0,16,0, +1,0,0,0,70,18,16,0,5,0,0,0,54,0,0,5, +130,0,16,0,0,0,0,0,1,64,0,0,0,0,0,0, +48,0,0,1,33,0,0,7,130,0,16,0,1,0,0,0, +58,0,16,0,0,0,0,0,1,64,0,0,8,0,0,0, +3,0,4,3,58,0,16,0,1,0,0,0,50,0,0,16, +114,0,16,0,2,0,0,0,70,18,16,128,65,0,0,0, +0,0,0,0,246,143,32,6,0,0,0,0,18,0,0,0, +58,0,16,0,0,0,0,0,70,130,32,6,0,0,0,0, +18,0,0,0,58,0,16,0,0,0,0,0,16,0,0,7, +130,0,16,0,1,0,0,0,70,2,16,0,2,0,0,0, +70,2,16,0,2,0,0,0,50,0,0,12,130,0,16,0, +2,0,0,0,42,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,58,0,16,0,1,0,0,0, +1,64,0,0,0,0,128,63,14,0,0,10,130,0,16,0, +2,0,0,0,2,64,0,0,0,0,128,63,0,0,128,63, +0,0,128,63,0,0,128,63,58,0,16,0,2,0,0,0, +57,0,0,10,18,0,16,0,3,0,0,0,1,64,0,0, +0,0,0,0,58,128,32,6,0,0,0,0,18,0,0,0, +58,0,16,0,0,0,0,0,49,0,0,10,34,0,16,0, +3,0,0,0,58,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,58,0,16,0,1,0,0,0, +1,0,0,7,18,0,16,0,3,0,0,0,26,0,16,0, +3,0,0,0,10,0,16,0,3,0,0,0,55,0,0,9, +130,0,16,0,2,0,0,0,10,0,16,0,3,0,0,0, +1,64,0,0,0,0,0,0,58,0,16,0,2,0,0,0, +68,0,0,5,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,56,0,0,7,114,0,16,0,3,0,0,0, +246,15,16,0,1,0,0,0,70,2,16,0,2,0,0,0, +16,0,0,10,130,0,16,0,3,0,0,0,70,2,16,0, +3,0,0,0,70,130,32,6,0,0,0,0,34,0,0,0, +58,0,16,0,0,0,0,0,52,0,0,7,130,0,16,0, +3,0,0,0,58,0,16,0,3,0,0,0,1,64,0,0, +0,0,0,0,0,0,0,11,130,0,16,0,3,0,0,0, +58,0,16,0,3,0,0,0,10,128,32,134,65,0,0,0, +0,0,0,0,26,0,0,0,58,0,16,0,0,0,0,0, +56,32,0,10,130,0,16,0,3,0,0,0,58,0,16,0, +3,0,0,0,26,128,32,6,0,0,0,0,26,0,0,0, +58,0,16,0,0,0,0,0,56,0,0,7,130,0,16,0, +2,0,0,0,58,0,16,0,2,0,0,0,58,0,16,0, +3,0,0,0,16,0,0,7,18,0,16,0,3,0,0,0, +70,18,16,0,1,0,0,0,70,2,16,0,3,0,0,0, +52,0,0,7,18,0,16,0,3,0,0,0,10,0,16,0, +3,0,0,0,1,64,0,0,0,0,0,0,56,0,0,7, +226,0,16,0,3,0,0,0,6,0,16,0,3,0,0,0, +6,25,16,0,3,0,0,0,56,0,0,10,226,0,16,0, +3,0,0,0,86,14,16,0,3,0,0,0,6,137,32,6, +0,0,0,0,10,0,0,0,58,0,16,0,0,0,0,0, +49,0,0,7,18,0,16,0,3,0,0,0,1,64,0,0, +0,0,0,0,10,0,16,0,3,0,0,0,31,0,4,3, +10,0,16,0,3,0,0,0,50,0,0,9,114,0,16,0, +2,0,0,0,70,2,16,0,2,0,0,0,246,15,16,0, +1,0,0,0,70,18,16,0,2,0,0,0,16,0,0,7, +130,0,16,0,1,0,0,0,70,2,16,0,2,0,0,0, +70,2,16,0,2,0,0,0,68,0,0,5,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,56,0,0,7, +114,0,16,0,2,0,0,0,246,15,16,0,1,0,0,0, +70,2,16,0,2,0,0,0,16,0,0,7,130,0,16,0, +1,0,0,0,70,18,16,0,1,0,0,0,70,2,16,0, +2,0,0,0,52,0,0,7,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,1,64,0,0,0,0,0,0, +47,0,0,5,130,0,16,0,1,0,0,0,58,0,16,0, +1,0,0,0,56,0,0,8,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,58,128,32,0,0,0,0,0, +44,0,0,0,25,0,0,5,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,51,0,0,7,130,0,16,0, +1,0,0,0,58,0,16,0,1,0,0,0,1,64,0,0, +0,0,128,63,56,0,0,7,130,0,16,0,1,0,0,0, +58,0,16,0,1,0,0,0,58,0,16,0,2,0,0,0, +50,0,0,12,114,0,16,0,0,0,0,0,246,15,16,0, +1,0,0,0,70,130,32,6,0,0,0,0,10,0,0,0, +58,0,16,0,0,0,0,0,70,2,16,0,0,0,0,0, +21,0,0,1,56,0,0,7,114,0,16,0,2,0,0,0, +246,15,16,0,2,0,0,0,150,7,16,0,3,0,0,0, +51,0,0,10,114,0,16,0,2,0,0,0,70,2,16,0, +2,0,0,0,2,64,0,0,0,0,128,63,0,0,128,63, +0,0,128,63,0,0,0,0,0,0,0,7,114,0,16,0, +1,0,0,0,70,2,16,0,1,0,0,0,70,2,16,0, +2,0,0,0,30,0,0,7,130,0,16,0,0,0,0,0, +58,0,16,0,0,0,0,0,1,64,0,0,1,0,0,0, +22,0,0,1,54,0,0,5,114,32,16,0,1,0,0,0, +70,2,16,0,0,0,0,0,54,0,0,5,114,32,16,0, +0,0,0,0,70,2,16,0,1,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,48,0,0,0,4,0,0,0, +0,0,0,0,8,0,0,0,33,0,0,0,2,0,0,0, +1,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,5,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +188,4,0,0,1,0,0,0,108,0,0,0,1,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,142,4,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +85,110,105,116,121,70,70,86,101,114,116,101,120,0,171,171, +92,0,0,0,14,0,0,0,132,0,0,0,240,3,0,0, +0,0,0,0,0,0,0,0,180,2,0,0,0,0,0,0, +64,0,0,0,0,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +240,2,0,0,64,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,253,2,0,0,128,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +56,3,0,0,144,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,71,3,0,0,160,0,0,0, +128,0,0,0,2,0,0,0,88,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +124,3,0,0,32,1,0,0,128,0,0,0,2,0,0,0, +140,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,176,3,0,0,160,1,0,0, +128,0,0,0,2,0,0,0,192,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +228,3,0,0,32,2,0,0,128,0,0,0,2,0,0,0, +244,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,24,4,0,0,160,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +39,4,0,0,176,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,54,4,0,0,192,2,0,0, +16,0,0,0,2,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +66,4,0,0,208,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,82,4,0,0,224,2,0,0, +0,1,0,0,0,0,0,0,96,4,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +132,4,0,0,224,3,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,102,102,95,109,97,116,114,105, +120,95,109,118,112,0,102,108,111,97,116,52,120,52,0,171, +3,0,3,0,4,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +194,2,0,0,102,102,95,109,97,116,114,105,120,95,109,118, +0,102,102,95,118,101,99,95,99,111,108,111,114,0,102,108, +111,97,116,52,0,171,171,171,1,0,3,0,1,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,118, +101,99,95,97,109,98,105,101,110,116,0,102,102,95,108,105, +103,104,116,95,99,111,108,111,114,0,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,112,111,115,0,171,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,97,116,116, +101,110,0,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,115,112,111,116,0,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,109, +97,116,95,100,105,102,102,117,115,101,0,102,102,95,109,97, +116,95,97,109,98,105,101,110,116,0,102,102,95,109,97,116, +95,115,112,101,99,0,102,102,95,109,97,116,95,101,109,105, +115,115,105,111,110,0,102,102,95,109,97,116,114,105,120,95, +116,101,120,0,3,0,3,0,4,0,4,0,4,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,194,2,0,0,102,102,95,102,111,103,95,118, +115,0,77,105,99,114,111,115,111,102,116,32,40,82,41,32, +72,76,83,76,32,83,104,97,100,101,114,32,67,111,109,112, +105,108,101,114,32,54,46,51,46,57,52,49,53,46,48,0, +76,70,83,48,168,1,0,0,7,0,0,0,8,0,0,0, +88,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,2,0,0,0, +255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0, +110,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +122,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,1,0,0,0, +1,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +132,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,1,0,0,0, +2,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +140,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +3,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +153,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,3,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +163,1,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,1,0,0,0, +5,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +67,111,109,112,117,116,101,83,112,111,116,76,105,103,104,116, +83,112,101,99,56,0,101,121,101,80,111,115,105,116,105,111, +110,0,101,121,101,78,111,114,109,97,108,0,118,105,101,119, +68,105,114,0,100,105,102,102,117,115,101,67,111,108,111,114, +0,115,112,101,99,67,111,108,111,114,0,97,109,98,0,171, +76,73,66,70,32,3,0,0,68,88,66,67,131,242,33,177, +67,199,181,81,188,12,223,170,153,36,248,104,1,0,0,0, +32,3,0,0,6,0,0,0,56,0,0,0,156,0,0,0, +12,1,0,0,108,1,0,0,232,1,0,0,92,2,0,0, +65,111,110,57,92,0,0,0,92,0,0,0,0,2,86,76, +56,0,0,0,36,0,0,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,2,86,76, +31,0,0,2,5,0,0,128,0,0,15,144,31,0,0,2, +5,0,1,128,1,0,15,144,1,0,0,2,0,0,7,224, +0,0,228,144,1,0,0,2,0,0,8,224,1,0,255,144, +255,255,0,0,65,111,110,57,104,0,0,0,104,0,0,0, +0,2,80,76,68,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,80,76,31,0,0,2,0,0,0,128,0,0,7,176, +31,0,0,2,0,0,0,128,1,0,8,176,1,0,0,2, +0,0,7,128,0,0,228,176,1,0,0,2,0,0,8,128, +1,0,255,176,1,0,0,2,0,0,15,224,0,0,228,128, +255,255,0,0,83,72,68,82,88,0,0,0,64,0,240,255, +22,0,0,0,95,0,0,3,114,16,16,0,0,0,0,0, +95,0,0,3,130,16,16,0,1,0,0,0,101,0,0,3, +242,32,16,0,0,0,0,0,54,0,0,5,114,32,16,0, +0,0,0,0,70,18,16,0,0,0,0,0,54,0,0,5, +130,32,16,0,0,0,0,0,58,16,16,0,1,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,3,0,0,0, +0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,108,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +60,0,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,171,171,76,70,83,48,188,0,0,0,3,0,0,0, +8,0,0,0,152,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,170,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,177,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,1,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,76,105,103,104,116,105,110,103, +67,111,108,111,114,0,108,99,111,108,111,114,0,100,105,102, +102,99,111,108,111,114,0,171,76,73,66,70,24,8,0,0, +68,88,66,67,172,130,85,234,66,7,19,66,150,202,205,16, +164,226,78,167,1,0,0,0,24,8,0,0,6,0,0,0, +56,0,0,0,208,0,0,0,116,1,0,0,80,2,0,0, +204,2,0,0,144,7,0,0,65,111,110,57,144,0,0,0, +144,0,0,0,0,2,86,76,96,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,0,0,0,0,4,0,0,0,0,0,0,0, +0,2,86,76,31,0,0,2,5,0,0,128,0,0,15,144, +5,0,0,3,0,0,15,128,0,0,85,144,1,0,228,160, +4,0,0,4,0,0,15,128,0,0,228,160,0,0,0,144, +0,0,228,128,4,0,0,4,0,0,15,128,2,0,228,160, +0,0,170,144,0,0,228,128,4,0,0,4,0,0,15,224, +3,0,228,160,0,0,255,144,0,0,228,128,255,255,0,0, +65,111,110,57,156,0,0,0,156,0,0,0,0,2,80,76, +108,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,0,0,0,0, +4,0,0,0,0,0,0,0,0,2,80,76,31,0,0,2, +0,0,0,128,0,0,15,176,5,0,0,3,0,0,15,128, +0,0,85,176,1,0,228,160,4,0,0,4,0,0,15,128, +0,0,228,160,0,0,0,176,0,0,228,128,4,0,0,4, +0,0,15,128,2,0,228,160,0,0,170,176,0,0,228,128, +4,0,0,4,0,0,15,128,3,0,228,160,0,0,255,176, +0,0,228,128,1,0,0,2,0,0,15,224,0,0,228,128, +255,255,0,0,83,72,68,82,212,0,0,0,64,0,240,255, +53,0,0,0,89,0,0,4,70,142,32,0,0,0,0,0, +4,0,0,0,95,0,0,3,242,16,16,0,0,0,0,0, +101,0,0,3,242,32,16,0,0,0,0,0,104,0,0,2, +1,0,0,0,56,0,0,8,242,0,16,0,0,0,0,0, +86,21,16,0,0,0,0,0,70,142,32,0,0,0,0,0, +1,0,0,0,50,0,0,10,242,0,16,0,0,0,0,0, +70,142,32,0,0,0,0,0,0,0,0,0,6,16,16,0, +0,0,0,0,70,14,16,0,0,0,0,0,50,0,0,10, +242,0,16,0,0,0,0,0,70,142,32,0,0,0,0,0, +2,0,0,0,166,26,16,0,0,0,0,0,70,14,16,0, +0,0,0,0,50,0,0,10,242,32,16,0,0,0,0,0, +70,142,32,0,0,0,0,0,3,0,0,0,246,31,16,0, +0,0,0,0,70,14,16,0,0,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,5,0,0,0,1,0,0,0, +0,0,0,0,2,0,0,0,4,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +188,4,0,0,1,0,0,0,108,0,0,0,1,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,142,4,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +85,110,105,116,121,70,70,86,101,114,116,101,120,0,171,171, +92,0,0,0,14,0,0,0,132,0,0,0,240,3,0,0, +0,0,0,0,0,0,0,0,180,2,0,0,0,0,0,0, +64,0,0,0,2,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +240,2,0,0,64,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,253,2,0,0,128,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +56,3,0,0,144,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,71,3,0,0,160,0,0,0, +128,0,0,0,0,0,0,0,88,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +124,3,0,0,32,1,0,0,128,0,0,0,0,0,0,0, +140,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,176,3,0,0,160,1,0,0, +128,0,0,0,0,0,0,0,192,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +228,3,0,0,32,2,0,0,128,0,0,0,0,0,0,0, +244,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,24,4,0,0,160,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +39,4,0,0,176,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,54,4,0,0,192,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +66,4,0,0,208,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,82,4,0,0,224,2,0,0, +0,1,0,0,0,0,0,0,96,4,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +132,4,0,0,224,3,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,102,102,95,109,97,116,114,105, +120,95,109,118,112,0,102,108,111,97,116,52,120,52,0,171, +3,0,3,0,4,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +194,2,0,0,102,102,95,109,97,116,114,105,120,95,109,118, +0,102,102,95,118,101,99,95,99,111,108,111,114,0,102,108, +111,97,116,52,0,171,171,171,1,0,3,0,1,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,118, +101,99,95,97,109,98,105,101,110,116,0,102,102,95,108,105, +103,104,116,95,99,111,108,111,114,0,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,112,111,115,0,171,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,97,116,116, +101,110,0,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,115,112,111,116,0,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,109, +97,116,95,100,105,102,102,117,115,101,0,102,102,95,109,97, +116,95,97,109,98,105,101,110,116,0,102,102,95,109,97,116, +95,115,112,101,99,0,102,102,95,109,97,116,95,101,109,105, +115,115,105,111,110,0,102,102,95,109,97,116,114,105,120,95, +116,101,120,0,3,0,3,0,4,0,4,0,4,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,194,2,0,0,102,102,95,102,111,103,95,118, +115,0,77,105,99,114,111,115,111,102,116,32,40,82,41,32, +72,76,83,76,32,83,104,97,100,101,114,32,67,111,109,112, +105,108,101,114,32,54,46,51,46,57,52,49,53,46,48,0, +76,70,83,48,128,0,0,0,2,0,0,0,8,0,0,0, +104,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,2,0,0,0, +255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0, +120,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +84,114,97,110,115,102,111,114,109,86,101,114,116,101,120,0, +118,101,114,116,101,120,0,171,76,73,66,70,180,2,0,0, +68,88,66,67,62,110,178,176,113,161,39,113,135,74,135,255, +184,2,122,27,1,0,0,0,180,2,0,0,6,0,0,0, +56,0,0,0,176,0,0,0,8,1,0,0,72,1,0,0, +196,1,0,0,56,2,0,0,65,111,110,57,112,0,0,0, +112,0,0,0,0,2,86,76,76,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,86,76,81,0,0,5,0,0,15,160, +0,0,0,0,0,0,128,63,0,0,0,0,0,0,0,0, +31,0,0,2,5,0,0,128,0,0,15,144,11,0,0,3, +0,0,15,128,0,0,228,144,0,0,0,160,10,0,0,3, +0,0,15,224,0,0,228,128,0,0,85,160,255,255,0,0, +65,111,110,57,80,0,0,0,80,0,0,0,0,2,80,76, +44,0,0,0,36,0,0,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,2,80,76, +31,0,0,2,0,0,0,128,0,0,15,176,1,0,0,2, +0,0,31,128,0,0,228,176,1,0,0,2,0,0,15,224, +0,0,228,128,255,255,0,0,83,72,68,82,56,0,0,0, +64,0,240,255,14,0,0,0,95,0,0,3,242,16,16,0, +0,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +54,32,0,5,242,32,16,0,0,0,0,0,70,30,16,0, +0,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,108,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,60,0,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,77,105,99,114,111,115,111,102, +116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101, +114,32,67,111,109,112,105,108,101,114,32,54,46,51,46,57, +52,49,53,46,48,0,171,171,76,70,83,48,116,0,0,0, +2,0,0,0,8,0,0,0,104,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,114,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,83,97,116,117,114,97,116,101, +52,0,99,0,76,73,66,70,180,2,0,0,68,88,66,67, +240,200,99,27,197,129,185,234,49,50,47,69,172,40,172,184, +1,0,0,0,180,2,0,0,6,0,0,0,56,0,0,0, +176,0,0,0,8,1,0,0,72,1,0,0,196,1,0,0, +56,2,0,0,65,111,110,57,112,0,0,0,112,0,0,0, +0,2,86,76,76,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,86,76,81,0,0,5,0,0,15,160,0,0,0,0, +0,0,128,63,0,0,0,0,0,0,0,0,31,0,0,2, +5,0,0,128,0,0,15,144,11,0,0,3,0,0,7,128, +0,0,228,144,0,0,0,160,10,0,0,3,0,0,7,224, +0,0,228,128,0,0,85,160,255,255,0,0,65,111,110,57, +80,0,0,0,80,0,0,0,0,2,80,76,44,0,0,0, +36,0,0,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,2,80,76,31,0,0,2, +0,0,0,128,0,0,7,176,1,0,0,2,0,0,23,128, +0,0,228,176,1,0,0,2,0,0,7,224,0,0,228,128, +255,255,0,0,83,72,68,82,56,0,0,0,64,0,240,255, +14,0,0,0,95,0,0,3,114,16,16,0,0,0,0,0, +101,0,0,3,114,32,16,0,0,0,0,0,54,32,0,5, +114,32,16,0,0,0,0,0,70,18,16,0,0,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,2,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,108,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +60,0,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,171,171,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,114,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,83,97,116,117,114,97,116,101,51,0,99,0, +76,73,66,70,120,2,0,0,68,88,66,67,138,49,223,44, +107,242,58,167,5,75,190,32,216,167,145,36,1,0,0,0, +120,2,0,0,6,0,0,0,56,0,0,0,132,0,0,0, +208,0,0,0,16,1,0,0,140,1,0,0,0,2,0,0, +65,111,110,57,68,0,0,0,68,0,0,0,0,2,86,76, +32,0,0,0,36,0,0,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,2,86,76, +31,0,0,2,5,0,0,128,0,0,15,144,1,0,0,2, +0,0,7,224,0,0,228,144,255,255,0,0,65,111,110,57, +68,0,0,0,68,0,0,0,0,2,80,76,32,0,0,0, +36,0,0,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,2,80,76,31,0,0,2, +0,0,0,128,0,0,7,176,1,0,0,2,0,0,7,224, +0,0,228,176,255,255,0,0,83,72,68,82,56,0,0,0, +64,0,240,255,14,0,0,0,95,0,0,3,114,16,16,0, +0,0,0,0,101,0,0,3,114,32,16,0,0,0,0,0, +54,0,0,5,114,32,16,0,0,0,0,0,70,18,16,0, +0,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,108,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,60,0,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,77,105,99,114,111,115,111,102, +116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101, +114,32,67,111,109,112,105,108,101,114,32,54,46,51,46,57, +52,49,53,46,48,0,171,171,76,70,83,48,112,0,0,0, +2,0,0,0,8,0,0,0,104,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,110,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,76,111,97,100,51,0,99,0, +76,73,66,70,24,7,0,0,68,88,66,67,113,18,103,154, +83,56,52,120,187,13,106,3,58,124,196,9,1,0,0,0, +24,7,0,0,6,0,0,0,56,0,0,0,148,0,0,0, +252,0,0,0,88,1,0,0,212,1,0,0,152,6,0,0, +65,111,110,57,84,0,0,0,84,0,0,0,0,2,86,76, +36,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,0,0,44,0, +1,0,0,0,0,0,0,0,0,2,86,76,31,0,0,2, +5,0,0,128,0,0,15,144,5,0,0,3,0,0,7,224, +0,0,228,144,0,0,228,160,255,255,0,0,65,111,110,57, +96,0,0,0,96,0,0,0,0,2,80,76,48,0,0,0, +48,0,0,0,1,0,36,0,0,0,48,0,0,0,48,0, +0,0,36,0,0,0,48,0,0,0,44,0,1,0,0,0, +0,0,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,5,0,0,3,0,0,7,128,0,0,228,176, +0,0,228,160,1,0,0,2,0,0,7,224,0,0,228,128, +255,255,0,0,83,72,68,82,84,0,0,0,64,0,240,255, +21,0,0,0,89,0,0,4,70,142,32,0,0,0,0,0, +45,0,0,0,95,0,0,3,114,16,16,0,0,0,0,0, +101,0,0,3,114,32,16,0,0,0,0,0,56,0,0,8, +114,32,16,0,0,0,0,0,70,18,16,0,0,0,0,0, +70,130,32,0,0,0,0,0,44,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,2,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +188,4,0,0,1,0,0,0,108,0,0,0,1,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,142,4,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +85,110,105,116,121,70,70,86,101,114,116,101,120,0,171,171, +92,0,0,0,14,0,0,0,132,0,0,0,240,3,0,0, +0,0,0,0,0,0,0,0,180,2,0,0,0,0,0,0, +64,0,0,0,0,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +240,2,0,0,64,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,253,2,0,0,128,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +56,3,0,0,144,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,71,3,0,0,160,0,0,0, +128,0,0,0,0,0,0,0,88,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +124,3,0,0,32,1,0,0,128,0,0,0,0,0,0,0, +140,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,176,3,0,0,160,1,0,0, +128,0,0,0,0,0,0,0,192,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +228,3,0,0,32,2,0,0,128,0,0,0,0,0,0,0, +244,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,24,4,0,0,160,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +39,4,0,0,176,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,54,4,0,0,192,2,0,0, +16,0,0,0,2,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +66,4,0,0,208,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,82,4,0,0,224,2,0,0, +0,1,0,0,0,0,0,0,96,4,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +132,4,0,0,224,3,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,102,102,95,109,97,116,114,105, +120,95,109,118,112,0,102,108,111,97,116,52,120,52,0,171, +3,0,3,0,4,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +194,2,0,0,102,102,95,109,97,116,114,105,120,95,109,118, +0,102,102,95,118,101,99,95,99,111,108,111,114,0,102,108, +111,97,116,52,0,171,171,171,1,0,3,0,1,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,118, +101,99,95,97,109,98,105,101,110,116,0,102,102,95,108,105, +103,104,116,95,99,111,108,111,114,0,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,112,111,115,0,171,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,97,116,116, +101,110,0,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,115,112,111,116,0,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,109, +97,116,95,100,105,102,102,117,115,101,0,102,102,95,109,97, +116,95,97,109,98,105,101,110,116,0,102,102,95,109,97,116, +95,115,112,101,99,0,102,102,95,109,97,116,95,101,109,105, +115,115,105,111,110,0,102,102,95,109,97,116,114,105,120,95, +116,101,120,0,3,0,3,0,4,0,4,0,4,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,194,2,0,0,102,102,95,102,111,103,95,118, +115,0,77,105,99,114,111,115,111,102,116,32,40,82,41,32, +72,76,83,76,32,83,104,97,100,101,114,32,67,111,109,112, +105,108,101,114,32,54,46,51,46,57,52,49,53,46,48,0, +76,70,83,48,120,0,0,0,2,0,0,0,8,0,0,0, +104,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,2,0,0,0, +255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0, +117,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,3,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +77,111,100,117,108,97,116,101,83,112,101,99,0,99,0,171, +76,73,66,70,16,8,0,0,68,88,66,67,38,168,251,188, +91,77,207,32,129,166,165,241,221,147,229,117,1,0,0,0, +16,8,0,0,6,0,0,0,56,0,0,0,208,0,0,0, +116,1,0,0,80,2,0,0,204,2,0,0,144,7,0,0, +65,111,110,57,144,0,0,0,144,0,0,0,0,2,86,76, +96,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,0,0,46,0, +4,0,0,0,0,0,0,0,0,2,86,76,31,0,0,2, +5,0,0,128,0,0,15,144,5,0,0,3,0,0,15,128, +0,0,85,144,1,0,228,160,4,0,0,4,0,0,15,128, +0,0,228,160,0,0,0,144,0,0,228,128,4,0,0,4, +0,0,15,128,2,0,228,160,0,0,170,144,0,0,228,128, +4,0,0,4,0,0,15,224,3,0,228,160,0,0,255,144, +0,0,228,128,255,255,0,0,65,111,110,57,156,0,0,0, +156,0,0,0,0,2,80,76,108,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,0,0,46,0,4,0,0,0,0,0,0,0, +0,2,80,76,31,0,0,2,0,0,0,128,0,0,15,176, +5,0,0,3,0,0,15,128,0,0,85,176,1,0,228,160, +4,0,0,4,0,0,15,128,0,0,228,160,0,0,0,176, +0,0,228,128,4,0,0,4,0,0,15,128,2,0,228,160, +0,0,170,176,0,0,228,128,4,0,0,4,0,0,15,128, +3,0,228,160,0,0,255,176,0,0,228,128,1,0,0,2, +0,0,15,224,0,0,228,128,255,255,0,0,83,72,68,82, +212,0,0,0,64,0,240,255,53,0,0,0,89,0,0,4, +70,142,32,0,0,0,0,0,50,0,0,0,95,0,0,3, +242,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,104,0,0,2,1,0,0,0,56,0,0,8, +242,0,16,0,0,0,0,0,86,21,16,0,0,0,0,0, +70,142,32,0,0,0,0,0,47,0,0,0,50,0,0,10, +242,0,16,0,0,0,0,0,70,142,32,0,0,0,0,0, +46,0,0,0,6,16,16,0,0,0,0,0,70,14,16,0, +0,0,0,0,50,0,0,10,242,0,16,0,0,0,0,0, +70,142,32,0,0,0,0,0,48,0,0,0,166,26,16,0, +0,0,0,0,70,14,16,0,0,0,0,0,50,0,0,10, +242,32,16,0,0,0,0,0,70,142,32,0,0,0,0,0, +49,0,0,0,246,31,16,0,0,0,0,0,70,14,16,0, +0,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +5,0,0,0,1,0,0,0,0,0,0,0,2,0,0,0, +4,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,188,4,0,0,1,0,0,0, +108,0,0,0,1,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,142,4,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,85,110,105,116,121,70,70,86, +101,114,116,101,120,0,171,171,92,0,0,0,14,0,0,0, +132,0,0,0,240,3,0,0,0,0,0,0,0,0,0,0, +180,2,0,0,0,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,240,2,0,0,64,0,0,0, +64,0,0,0,0,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +253,2,0,0,128,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,56,3,0,0,144,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +71,3,0,0,160,0,0,0,128,0,0,0,0,0,0,0, +88,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,124,3,0,0,32,1,0,0, +128,0,0,0,0,0,0,0,140,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +176,3,0,0,160,1,0,0,128,0,0,0,0,0,0,0, +192,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,228,3,0,0,32,2,0,0, +128,0,0,0,0,0,0,0,244,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +24,4,0,0,160,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,39,4,0,0,176,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +54,4,0,0,192,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,66,4,0,0,208,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +82,4,0,0,224,2,0,0,0,1,0,0,2,0,0,0, +96,4,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,132,4,0,0,224,3,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +102,102,95,109,97,116,114,105,120,95,109,118,112,0,102,108, +111,97,116,52,120,52,0,171,3,0,3,0,4,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,194,2,0,0,102,102,95,109, +97,116,114,105,120,95,109,118,0,102,102,95,118,101,99,95, +99,111,108,111,114,0,102,108,111,97,116,52,0,171,171,171, +1,0,3,0,1,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,118,101,99,95,97,109,98,105,101, +110,116,0,102,102,95,108,105,103,104,116,95,99,111,108,111, +114,0,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,112,111,115,0,171,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,97,116,116,101,110,0,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,115,112,111,116,0,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,109,97,116,95,100,105,102,102,117, +115,101,0,102,102,95,109,97,116,95,97,109,98,105,101,110, +116,0,102,102,95,109,97,116,95,115,112,101,99,0,102,102, +95,109,97,116,95,101,109,105,115,115,105,111,110,0,102,102, +95,109,97,116,114,105,120,95,116,101,120,0,3,0,3,0, +4,0,4,0,4,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,194,2,0,0, +102,102,95,102,111,103,95,118,115,0,77,105,99,114,111,115, +111,102,116,32,40,82,41,32,72,76,83,76,32,83,104,97, +100,101,114,32,67,111,109,112,105,108,101,114,32,54,46,51, +46,57,52,49,53,46,48,0,76,70,83,48,120,0,0,0, +2,0,0,0,8,0,0,0,104,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,116,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,77,117,108,116,105,112,108,121, +85,86,48,0,117,118,0,171,76,73,66,70,16,8,0,0, +68,88,66,67,89,231,147,186,246,126,177,127,29,163,1,103, +12,212,226,6,1,0,0,0,16,8,0,0,6,0,0,0, +56,0,0,0,208,0,0,0,116,1,0,0,80,2,0,0, +204,2,0,0,144,7,0,0,65,111,110,57,144,0,0,0, +144,0,0,0,0,2,86,76,96,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,0,0,50,0,4,0,0,0,0,0,0,0, +0,2,86,76,31,0,0,2,5,0,0,128,0,0,15,144, +5,0,0,3,0,0,15,128,0,0,85,144,1,0,228,160, +4,0,0,4,0,0,15,128,0,0,228,160,0,0,0,144, +0,0,228,128,4,0,0,4,0,0,15,128,2,0,228,160, +0,0,170,144,0,0,228,128,4,0,0,4,0,0,15,224, +3,0,228,160,0,0,255,144,0,0,228,128,255,255,0,0, +65,111,110,57,156,0,0,0,156,0,0,0,0,2,80,76, +108,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,0,0,50,0, +4,0,0,0,0,0,0,0,0,2,80,76,31,0,0,2, +0,0,0,128,0,0,15,176,5,0,0,3,0,0,15,128, +0,0,85,176,1,0,228,160,4,0,0,4,0,0,15,128, +0,0,228,160,0,0,0,176,0,0,228,128,4,0,0,4, +0,0,15,128,2,0,228,160,0,0,170,176,0,0,228,128, +4,0,0,4,0,0,15,128,3,0,228,160,0,0,255,176, +0,0,228,128,1,0,0,2,0,0,15,224,0,0,228,128, +255,255,0,0,83,72,68,82,212,0,0,0,64,0,240,255, +53,0,0,0,89,0,0,4,70,142,32,0,0,0,0,0, +54,0,0,0,95,0,0,3,242,16,16,0,0,0,0,0, +101,0,0,3,242,32,16,0,0,0,0,0,104,0,0,2, +1,0,0,0,56,0,0,8,242,0,16,0,0,0,0,0, +86,21,16,0,0,0,0,0,70,142,32,0,0,0,0,0, +51,0,0,0,50,0,0,10,242,0,16,0,0,0,0,0, +70,142,32,0,0,0,0,0,50,0,0,0,6,16,16,0, +0,0,0,0,70,14,16,0,0,0,0,0,50,0,0,10, +242,0,16,0,0,0,0,0,70,142,32,0,0,0,0,0, +52,0,0,0,166,26,16,0,0,0,0,0,70,14,16,0, +0,0,0,0,50,0,0,10,242,32,16,0,0,0,0,0, +70,142,32,0,0,0,0,0,53,0,0,0,246,31,16,0, +0,0,0,0,70,14,16,0,0,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,5,0,0,0,1,0,0,0, +0,0,0,0,2,0,0,0,4,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +188,4,0,0,1,0,0,0,108,0,0,0,1,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,142,4,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +85,110,105,116,121,70,70,86,101,114,116,101,120,0,171,171, +92,0,0,0,14,0,0,0,132,0,0,0,240,3,0,0, +0,0,0,0,0,0,0,0,180,2,0,0,0,0,0,0, +64,0,0,0,0,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +240,2,0,0,64,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,253,2,0,0,128,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +56,3,0,0,144,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,71,3,0,0,160,0,0,0, +128,0,0,0,0,0,0,0,88,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +124,3,0,0,32,1,0,0,128,0,0,0,0,0,0,0, +140,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,176,3,0,0,160,1,0,0, +128,0,0,0,0,0,0,0,192,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +228,3,0,0,32,2,0,0,128,0,0,0,0,0,0,0, +244,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,24,4,0,0,160,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +39,4,0,0,176,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,54,4,0,0,192,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +66,4,0,0,208,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,82,4,0,0,224,2,0,0, +0,1,0,0,2,0,0,0,96,4,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +132,4,0,0,224,3,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,102,102,95,109,97,116,114,105, +120,95,109,118,112,0,102,108,111,97,116,52,120,52,0,171, +3,0,3,0,4,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +194,2,0,0,102,102,95,109,97,116,114,105,120,95,109,118, +0,102,102,95,118,101,99,95,99,111,108,111,114,0,102,108, +111,97,116,52,0,171,171,171,1,0,3,0,1,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,118, +101,99,95,97,109,98,105,101,110,116,0,102,102,95,108,105, +103,104,116,95,99,111,108,111,114,0,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,112,111,115,0,171,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,97,116,116, +101,110,0,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,115,112,111,116,0,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,109, +97,116,95,100,105,102,102,117,115,101,0,102,102,95,109,97, +116,95,97,109,98,105,101,110,116,0,102,102,95,109,97,116, +95,115,112,101,99,0,102,102,95,109,97,116,95,101,109,105, +115,115,105,111,110,0,102,102,95,109,97,116,114,105,120,95, +116,101,120,0,3,0,3,0,4,0,4,0,4,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,194,2,0,0,102,102,95,102,111,103,95,118, +115,0,77,105,99,114,111,115,111,102,116,32,40,82,41,32, +72,76,83,76,32,83,104,97,100,101,114,32,67,111,109,112, +105,108,101,114,32,54,46,51,46,57,52,49,53,46,48,0, +76,70,83,48,120,0,0,0,2,0,0,0,8,0,0,0, +104,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,2,0,0,0, +255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0, +116,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +77,117,108,116,105,112,108,121,85,86,49,0,117,118,0,171, +76,73,66,70,16,8,0,0,68,88,66,67,41,244,254,181, +196,180,14,116,129,203,162,222,199,240,214,248,1,0,0,0, +16,8,0,0,6,0,0,0,56,0,0,0,208,0,0,0, +116,1,0,0,80,2,0,0,204,2,0,0,144,7,0,0, +65,111,110,57,144,0,0,0,144,0,0,0,0,2,86,76, +96,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,0,0,54,0, +4,0,0,0,0,0,0,0,0,2,86,76,31,0,0,2, +5,0,0,128,0,0,15,144,5,0,0,3,0,0,15,128, +0,0,85,144,1,0,228,160,4,0,0,4,0,0,15,128, +0,0,228,160,0,0,0,144,0,0,228,128,4,0,0,4, +0,0,15,128,2,0,228,160,0,0,170,144,0,0,228,128, +4,0,0,4,0,0,15,224,3,0,228,160,0,0,255,144, +0,0,228,128,255,255,0,0,65,111,110,57,156,0,0,0, +156,0,0,0,0,2,80,76,108,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,0,0,54,0,4,0,0,0,0,0,0,0, +0,2,80,76,31,0,0,2,0,0,0,128,0,0,15,176, +5,0,0,3,0,0,15,128,0,0,85,176,1,0,228,160, +4,0,0,4,0,0,15,128,0,0,228,160,0,0,0,176, +0,0,228,128,4,0,0,4,0,0,15,128,2,0,228,160, +0,0,170,176,0,0,228,128,4,0,0,4,0,0,15,128, +3,0,228,160,0,0,255,176,0,0,228,128,1,0,0,2, +0,0,15,224,0,0,228,128,255,255,0,0,83,72,68,82, +212,0,0,0,64,0,240,255,53,0,0,0,89,0,0,4, +70,142,32,0,0,0,0,0,58,0,0,0,95,0,0,3, +242,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,104,0,0,2,1,0,0,0,56,0,0,8, +242,0,16,0,0,0,0,0,86,21,16,0,0,0,0,0, +70,142,32,0,0,0,0,0,55,0,0,0,50,0,0,10, +242,0,16,0,0,0,0,0,70,142,32,0,0,0,0,0, +54,0,0,0,6,16,16,0,0,0,0,0,70,14,16,0, +0,0,0,0,50,0,0,10,242,0,16,0,0,0,0,0, +70,142,32,0,0,0,0,0,56,0,0,0,166,26,16,0, +0,0,0,0,70,14,16,0,0,0,0,0,50,0,0,10, +242,32,16,0,0,0,0,0,70,142,32,0,0,0,0,0, +57,0,0,0,246,31,16,0,0,0,0,0,70,14,16,0, +0,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +5,0,0,0,1,0,0,0,0,0,0,0,2,0,0,0, +4,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,188,4,0,0,1,0,0,0, +108,0,0,0,1,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,142,4,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,85,110,105,116,121,70,70,86, +101,114,116,101,120,0,171,171,92,0,0,0,14,0,0,0, +132,0,0,0,240,3,0,0,0,0,0,0,0,0,0,0, +180,2,0,0,0,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,240,2,0,0,64,0,0,0, +64,0,0,0,0,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +253,2,0,0,128,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,56,3,0,0,144,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +71,3,0,0,160,0,0,0,128,0,0,0,0,0,0,0, +88,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,124,3,0,0,32,1,0,0, +128,0,0,0,0,0,0,0,140,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +176,3,0,0,160,1,0,0,128,0,0,0,0,0,0,0, +192,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,228,3,0,0,32,2,0,0, +128,0,0,0,0,0,0,0,244,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +24,4,0,0,160,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,39,4,0,0,176,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +54,4,0,0,192,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,66,4,0,0,208,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +82,4,0,0,224,2,0,0,0,1,0,0,2,0,0,0, +96,4,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,132,4,0,0,224,3,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +102,102,95,109,97,116,114,105,120,95,109,118,112,0,102,108, +111,97,116,52,120,52,0,171,3,0,3,0,4,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,194,2,0,0,102,102,95,109, +97,116,114,105,120,95,109,118,0,102,102,95,118,101,99,95, +99,111,108,111,114,0,102,108,111,97,116,52,0,171,171,171, +1,0,3,0,1,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,118,101,99,95,97,109,98,105,101, +110,116,0,102,102,95,108,105,103,104,116,95,99,111,108,111, +114,0,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,112,111,115,0,171,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,97,116,116,101,110,0,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,115,112,111,116,0,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,109,97,116,95,100,105,102,102,117, +115,101,0,102,102,95,109,97,116,95,97,109,98,105,101,110, +116,0,102,102,95,109,97,116,95,115,112,101,99,0,102,102, +95,109,97,116,95,101,109,105,115,115,105,111,110,0,102,102, +95,109,97,116,114,105,120,95,116,101,120,0,3,0,3,0, +4,0,4,0,4,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,194,2,0,0, +102,102,95,102,111,103,95,118,115,0,77,105,99,114,111,115, +111,102,116,32,40,82,41,32,72,76,83,76,32,83,104,97, +100,101,114,32,67,111,109,112,105,108,101,114,32,54,46,51, +46,57,52,49,53,46,48,0,76,70,83,48,120,0,0,0, +2,0,0,0,8,0,0,0,104,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,116,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,77,117,108,116,105,112,108,121, +85,86,50,0,117,118,0,171,76,73,66,70,16,8,0,0, +68,88,66,67,79,24,223,202,176,61,38,187,194,246,39,54, +93,187,78,10,1,0,0,0,16,8,0,0,6,0,0,0, +56,0,0,0,208,0,0,0,116,1,0,0,80,2,0,0, +204,2,0,0,144,7,0,0,65,111,110,57,144,0,0,0, +144,0,0,0,0,2,86,76,96,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,0,0,58,0,4,0,0,0,0,0,0,0, +0,2,86,76,31,0,0,2,5,0,0,128,0,0,15,144, +5,0,0,3,0,0,15,128,0,0,85,144,1,0,228,160, +4,0,0,4,0,0,15,128,0,0,228,160,0,0,0,144, +0,0,228,128,4,0,0,4,0,0,15,128,2,0,228,160, +0,0,170,144,0,0,228,128,4,0,0,4,0,0,15,224, +3,0,228,160,0,0,255,144,0,0,228,128,255,255,0,0, +65,111,110,57,156,0,0,0,156,0,0,0,0,2,80,76, +108,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,0,0,58,0, +4,0,0,0,0,0,0,0,0,2,80,76,31,0,0,2, +0,0,0,128,0,0,15,176,5,0,0,3,0,0,15,128, +0,0,85,176,1,0,228,160,4,0,0,4,0,0,15,128, +0,0,228,160,0,0,0,176,0,0,228,128,4,0,0,4, +0,0,15,128,2,0,228,160,0,0,170,176,0,0,228,128, +4,0,0,4,0,0,15,128,3,0,228,160,0,0,255,176, +0,0,228,128,1,0,0,2,0,0,15,224,0,0,228,128, +255,255,0,0,83,72,68,82,212,0,0,0,64,0,240,255, +53,0,0,0,89,0,0,4,70,142,32,0,0,0,0,0, +62,0,0,0,95,0,0,3,242,16,16,0,0,0,0,0, +101,0,0,3,242,32,16,0,0,0,0,0,104,0,0,2, +1,0,0,0,56,0,0,8,242,0,16,0,0,0,0,0, +86,21,16,0,0,0,0,0,70,142,32,0,0,0,0,0, +59,0,0,0,50,0,0,10,242,0,16,0,0,0,0,0, +70,142,32,0,0,0,0,0,58,0,0,0,6,16,16,0, +0,0,0,0,70,14,16,0,0,0,0,0,50,0,0,10, +242,0,16,0,0,0,0,0,70,142,32,0,0,0,0,0, +60,0,0,0,166,26,16,0,0,0,0,0,70,14,16,0, +0,0,0,0,50,0,0,10,242,32,16,0,0,0,0,0, +70,142,32,0,0,0,0,0,61,0,0,0,246,31,16,0, +0,0,0,0,70,14,16,0,0,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,5,0,0,0,1,0,0,0, +0,0,0,0,2,0,0,0,4,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +188,4,0,0,1,0,0,0,108,0,0,0,1,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,142,4,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +85,110,105,116,121,70,70,86,101,114,116,101,120,0,171,171, +92,0,0,0,14,0,0,0,132,0,0,0,240,3,0,0, +0,0,0,0,0,0,0,0,180,2,0,0,0,0,0,0, +64,0,0,0,0,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +240,2,0,0,64,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,253,2,0,0,128,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +56,3,0,0,144,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,71,3,0,0,160,0,0,0, +128,0,0,0,0,0,0,0,88,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +124,3,0,0,32,1,0,0,128,0,0,0,0,0,0,0, +140,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,176,3,0,0,160,1,0,0, +128,0,0,0,0,0,0,0,192,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +228,3,0,0,32,2,0,0,128,0,0,0,0,0,0,0, +244,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,24,4,0,0,160,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +39,4,0,0,176,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,54,4,0,0,192,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +66,4,0,0,208,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,82,4,0,0,224,2,0,0, +0,1,0,0,2,0,0,0,96,4,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +132,4,0,0,224,3,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,102,102,95,109,97,116,114,105, +120,95,109,118,112,0,102,108,111,97,116,52,120,52,0,171, +3,0,3,0,4,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +194,2,0,0,102,102,95,109,97,116,114,105,120,95,109,118, +0,102,102,95,118,101,99,95,99,111,108,111,114,0,102,108, +111,97,116,52,0,171,171,171,1,0,3,0,1,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,118, +101,99,95,97,109,98,105,101,110,116,0,102,102,95,108,105, +103,104,116,95,99,111,108,111,114,0,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,112,111,115,0,171,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,97,116,116, +101,110,0,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,115,112,111,116,0,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,109, +97,116,95,100,105,102,102,117,115,101,0,102,102,95,109,97, +116,95,97,109,98,105,101,110,116,0,102,102,95,109,97,116, +95,115,112,101,99,0,102,102,95,109,97,116,95,101,109,105, +115,115,105,111,110,0,102,102,95,109,97,116,114,105,120,95, +116,101,120,0,3,0,3,0,4,0,4,0,4,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,194,2,0,0,102,102,95,102,111,103,95,118, +115,0,77,105,99,114,111,115,111,102,116,32,40,82,41,32, +72,76,83,76,32,83,104,97,100,101,114,32,67,111,109,112, +105,108,101,114,32,54,46,51,46,57,52,49,53,46,48,0, +76,70,83,48,120,0,0,0,2,0,0,0,8,0,0,0, +104,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,2,0,0,0, +255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0, +116,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +77,117,108,116,105,112,108,121,85,86,51,0,117,118,0,171, +76,73,66,70,128,2,0,0,68,88,66,67,70,241,160,65, +61,184,241,235,1,168,145,104,13,89,175,213,1,0,0,0, +128,2,0,0,6,0,0,0,56,0,0,0,132,0,0,0, +208,0,0,0,16,1,0,0,140,1,0,0,0,2,0,0, +65,111,110,57,68,0,0,0,68,0,0,0,0,2,86,76, +32,0,0,0,36,0,0,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,2,86,76, +31,0,0,2,5,0,0,128,0,0,15,144,1,0,0,2, +0,0,15,224,0,0,228,144,255,255,0,0,65,111,110,57, +68,0,0,0,68,0,0,0,0,2,80,76,32,0,0,0, +36,0,0,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,2,80,76,31,0,0,2, +0,0,0,128,0,0,15,176,1,0,0,2,0,0,15,224, +0,0,228,176,255,255,0,0,83,72,68,82,56,0,0,0, +64,0,240,255,14,0,0,0,95,0,0,3,242,16,16,0, +0,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +54,0,0,5,242,32,16,0,0,0,0,0,70,30,16,0, +0,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,108,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,60,0,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,77,105,99,114,111,115,111,102, +116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101, +114,32,67,111,109,112,105,108,101,114,32,54,46,51,46,57, +52,49,53,46,48,0,171,171,76,70,83,48,120,0,0,0, +2,0,0,0,8,0,0,0,104,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,116,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,77,117,108,116,105,112,108,121, +85,86,52,0,117,118,0,171,76,73,66,70,128,2,0,0, +68,88,66,67,121,42,193,146,188,175,215,160,65,233,118,29, +149,27,229,44,1,0,0,0,128,2,0,0,6,0,0,0, +56,0,0,0,132,0,0,0,208,0,0,0,16,1,0,0, +140,1,0,0,0,2,0,0,65,111,110,57,68,0,0,0, +68,0,0,0,0,2,86,76,32,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,86,76,31,0,0,2,5,0,0,128, +0,0,15,144,1,0,0,2,0,0,15,224,0,0,228,144, +255,255,0,0,65,111,110,57,68,0,0,0,68,0,0,0, +0,2,80,76,32,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,80,76,31,0,0,2,0,0,0,128,0,0,15,176, +1,0,0,2,0,0,15,224,0,0,228,176,255,255,0,0, +83,72,68,82,56,0,0,0,64,0,240,255,14,0,0,0, +95,0,0,3,242,16,16,0,0,0,0,0,101,0,0,3, +242,32,16,0,0,0,0,0,54,0,0,5,242,32,16,0, +0,0,0,0,70,30,16,0,0,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +108,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,60,0,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +77,105,99,114,111,115,111,102,116,32,40,82,41,32,72,76, +83,76,32,83,104,97,100,101,114,32,67,111,109,112,105,108, +101,114,32,54,46,51,46,57,52,49,53,46,48,0,171,171, +76,70,83,48,120,0,0,0,2,0,0,0,8,0,0,0, +104,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,2,0,0,0, +255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0, +116,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +77,117,108,116,105,112,108,121,85,86,53,0,117,118,0,171, +76,73,66,70,128,2,0,0,68,88,66,67,43,144,230,30, +211,110,217,234,138,146,61,118,62,126,189,42,1,0,0,0, +128,2,0,0,6,0,0,0,56,0,0,0,132,0,0,0, +208,0,0,0,16,1,0,0,140,1,0,0,0,2,0,0, +65,111,110,57,68,0,0,0,68,0,0,0,0,2,86,76, +32,0,0,0,36,0,0,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,2,86,76, +31,0,0,2,5,0,0,128,0,0,15,144,1,0,0,2, +0,0,15,224,0,0,228,144,255,255,0,0,65,111,110,57, +68,0,0,0,68,0,0,0,0,2,80,76,32,0,0,0, +36,0,0,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,2,80,76,31,0,0,2, +0,0,0,128,0,0,15,176,1,0,0,2,0,0,15,224, +0,0,228,176,255,255,0,0,83,72,68,82,56,0,0,0, +64,0,240,255,14,0,0,0,95,0,0,3,242,16,16,0, +0,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +54,0,0,5,242,32,16,0,0,0,0,0,70,30,16,0, +0,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,108,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,60,0,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,77,105,99,114,111,115,111,102, +116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101, +114,32,67,111,109,112,105,108,101,114,32,54,46,51,46,57, +52,49,53,46,48,0,171,171,76,70,83,48,120,0,0,0, +2,0,0,0,8,0,0,0,104,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,116,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,77,117,108,116,105,112,108,121, +85,86,54,0,117,118,0,171,76,73,66,70,128,2,0,0, +68,88,66,67,225,123,250,221,76,72,10,52,198,89,252,247, +202,18,5,35,1,0,0,0,128,2,0,0,6,0,0,0, +56,0,0,0,132,0,0,0,208,0,0,0,16,1,0,0, +140,1,0,0,0,2,0,0,65,111,110,57,68,0,0,0, +68,0,0,0,0,2,86,76,32,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,86,76,31,0,0,2,5,0,0,128, +0,0,15,144,1,0,0,2,0,0,15,224,0,0,228,144, +255,255,0,0,65,111,110,57,68,0,0,0,68,0,0,0, +0,2,80,76,32,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,80,76,31,0,0,2,0,0,0,128,0,0,15,176, +1,0,0,2,0,0,15,224,0,0,228,176,255,255,0,0, +83,72,68,82,56,0,0,0,64,0,240,255,14,0,0,0, +95,0,0,3,242,16,16,0,0,0,0,0,101,0,0,3, +242,32,16,0,0,0,0,0,54,0,0,5,242,32,16,0, +0,0,0,0,70,30,16,0,0,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +108,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,60,0,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +77,105,99,114,111,115,111,102,116,32,40,82,41,32,72,76, +83,76,32,83,104,97,100,101,114,32,67,111,109,112,105,108, +101,114,32,54,46,51,46,57,52,49,53,46,48,0,171,171, +76,70,83,48,120,0,0,0,2,0,0,0,8,0,0,0, +104,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,2,0,0,0, +255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0, +116,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +77,117,108,116,105,112,108,121,85,86,55,0,117,118,0,171, +76,73,66,70,192,4,0,0,68,88,66,67,55,177,167,35, +230,168,3,26,213,51,153,178,57,116,234,20,1,0,0,0, +192,4,0,0,6,0,0,0,56,0,0,0,40,1,0,0, +40,2,0,0,76,3,0,0,200,3,0,0,60,4,0,0, +65,111,110,57,232,0,0,0,232,0,0,0,0,2,86,76, +196,0,0,0,36,0,0,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,2,86,76, +81,0,0,5,0,0,15,160,0,0,128,63,0,0,0,63, +0,0,0,0,0,0,0,0,31,0,0,2,5,0,0,128, +0,0,15,144,5,0,0,3,0,0,3,128,0,0,228,144, +0,0,228,144,2,0,0,3,0,0,1,128,0,0,85,128, +0,0,0,128,2,0,0,3,0,0,2,128,0,0,170,144, +0,0,0,160,4,0,0,4,0,0,1,128,0,0,85,128, +0,0,85,128,0,0,0,128,7,0,0,2,0,0,1,128, +0,0,0,128,6,0,0,2,0,0,1,128,0,0,0,128, +2,0,0,3,0,0,1,128,0,0,0,128,0,0,0,128, +6,0,0,2,0,0,1,128,0,0,0,128,4,0,0,4, +0,0,3,224,0,0,228,144,0,0,0,128,0,0,85,160, +1,0,0,2,0,0,12,224,0,0,36,160,255,255,0,0, +65,111,110,57,248,0,0,0,248,0,0,0,0,2,80,76, +212,0,0,0,36,0,0,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,2,80,76, +81,0,0,5,0,0,15,160,0,0,128,63,0,0,0,63, +0,0,0,0,0,0,128,63,31,0,0,2,0,0,0,128, +0,0,7,176,5,0,0,3,0,0,8,128,0,0,85,176, +0,0,85,176,4,0,0,4,0,0,1,128,0,0,0,176, +0,0,0,176,0,0,255,128,2,0,0,3,0,0,2,128, +0,0,170,176,0,0,0,160,4,0,0,4,0,0,1,128, +0,0,85,128,0,0,85,128,0,0,0,128,7,0,0,2, +0,0,1,128,0,0,0,128,6,0,0,2,0,0,1,128, +0,0,0,128,2,0,0,3,0,0,1,128,0,0,0,128, +0,0,0,128,6,0,0,2,0,0,1,128,0,0,0,128, +4,0,0,4,0,0,3,128,0,0,228,176,0,0,0,128, +0,0,85,160,1,0,0,2,0,0,12,128,0,0,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,28,1,0,0,64,0,240,255,71,0,0,0, +95,0,0,3,114,16,16,0,0,0,0,0,101,0,0,3, +242,32,16,0,0,0,0,0,104,0,0,2,1,0,0,0, +15,0,0,7,18,0,16,0,0,0,0,0,70,16,16,0, +0,0,0,0,70,16,16,0,0,0,0,0,0,0,0,7, +34,0,16,0,0,0,0,0,42,16,16,0,0,0,0,0, +1,64,0,0,0,0,128,63,50,0,0,9,18,0,16,0, +0,0,0,0,26,0,16,0,0,0,0,0,26,0,16,0, +0,0,0,0,10,0,16,0,0,0,0,0,75,0,0,5, +18,0,16,0,0,0,0,0,10,0,16,0,0,0,0,0, +0,0,0,7,18,0,16,0,0,0,0,0,10,0,16,0, +0,0,0,0,10,0,16,0,0,0,0,0,14,0,0,7, +50,0,16,0,0,0,0,0,70,16,16,0,0,0,0,0, +6,0,16,0,0,0,0,0,0,0,0,10,50,32,16,0, +0,0,0,0,70,0,16,0,0,0,0,0,2,64,0,0, +0,0,0,63,0,0,0,63,0,0,0,0,0,0,0,0, +54,0,0,8,194,32,16,0,0,0,0,0,2,64,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,63, +62,0,0,1,83,84,65,84,116,0,0,0,9,0,0,0, +1,0,0,0,0,0,0,0,2,0,0,0,7,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,108,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +60,0,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,171,171,76,70,83,48,124,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,116,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,85,86,83,112,104,101,114,101,77,97,112,0, +101,121,101,82,101,102,108,0,76,73,66,70,224,2,0,0, +68,88,66,67,230,26,65,230,192,146,124,110,146,230,36,50, +205,51,213,62,1,0,0,0,224,2,0,0,6,0,0,0, +56,0,0,0,164,0,0,0,32,1,0,0,116,1,0,0, +240,1,0,0,100,2,0,0,65,111,110,57,100,0,0,0, +100,0,0,0,0,2,86,76,64,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,86,76,81,0,0,5,0,0,15,160, +0,0,128,63,0,0,0,0,0,0,0,0,0,0,0,0, +31,0,0,2,5,0,0,128,0,0,15,144,4,0,0,4, +0,0,15,224,0,0,36,144,0,0,64,160,0,0,21,160, +255,255,0,0,65,111,110,57,116,0,0,0,116,0,0,0, +0,2,80,76,80,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,80,76,81,0,0,5,0,0,15,160,0,0,128,63, +0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,2, +0,0,0,128,0,0,7,176,1,0,0,2,0,0,7,128, +0,0,228,176,1,0,0,2,0,0,8,128,0,0,0,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,76,0,0,0,64,0,240,255,19,0,0,0, +95,0,0,3,114,16,16,0,0,0,0,0,101,0,0,3, +242,32,16,0,0,0,0,0,54,0,0,5,114,32,16,0, +0,0,0,0,70,18,16,0,0,0,0,0,54,0,0,5, +130,32,16,0,0,0,0,0,1,64,0,0,0,0,128,63, +62,0,0,1,83,84,65,84,116,0,0,0,3,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,108,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +60,0,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,171,171,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,114,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,70,108,111,97,116,51,116,111,52,0,118,0, +76,73,66,70,192,3,0,0,68,88,66,67,70,116,161,59, +42,125,161,227,92,25,246,147,196,134,44,94,1,0,0,0, +192,3,0,0,6,0,0,0,56,0,0,0,132,0,0,0, +208,0,0,0,24,1,0,0,148,1,0,0,108,3,0,0, +65,111,110,57,68,0,0,0,68,0,0,0,0,2,86,76, +20,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,1,0,0,0, +1,0,0,0,0,0,0,0,0,2,86,76,1,0,0,2, +0,0,15,224,0,0,228,160,255,255,0,0,65,111,110,57, +68,0,0,0,68,0,0,0,0,2,80,76,20,0,0,0, +48,0,0,0,1,0,36,0,0,0,48,0,0,0,48,0, +0,0,36,0,0,0,48,0,1,0,0,0,1,0,0,0, +0,0,0,0,0,2,80,76,1,0,0,2,0,0,15,224, +0,0,228,160,255,255,0,0,83,72,68,82,64,0,0,0, +64,0,240,255,16,0,0,0,89,0,0,4,70,142,32,0, +1,0,0,0,1,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,54,0,0,6,242,32,16,0,0,0,0,0, +70,142,32,0,1,0,0,0,0,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +208,1,0,0,1,0,0,0,108,0,0,0,1,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,160,1,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0, +85,110,105,116,121,70,70,80,105,120,101,108,0,171,171,171, +92,0,0,0,3,0,0,0,132,0,0,0,160,0,0,0, +0,0,0,0,0,0,0,0,252,0,0,0,0,0,0,0, +128,0,0,0,2,0,0,0,20,1,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +56,1,0,0,128,0,0,0,4,0,0,0,0,0,0,0, +76,1,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,112,1,0,0,144,0,0,0, +16,0,0,0,0,0,0,0,124,1,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +102,102,95,118,101,99,95,99,111,108,111,114,115,0,102,108, +111,97,116,52,0,171,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,1,0,0,102,102,95,97, +108,112,104,97,95,114,101,102,0,102,108,111,97,116,0,171, +0,0,3,0,1,0,1,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +69,1,0,0,102,102,95,102,111,103,95,112,115,0,171,171, +1,0,3,0,1,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,1,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,171,171,76,70,83,48,76,0,0,0,1,0,0,0, +8,0,0,0,56,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,76,111,97,100,67,111,110,115,116,97,110,116, +67,111,108,111,114,48,0,171,76,73,66,70,192,3,0,0, +68,88,66,67,20,238,20,114,172,178,29,247,21,3,60,240, +206,249,78,81,1,0,0,0,192,3,0,0,6,0,0,0, +56,0,0,0,132,0,0,0,208,0,0,0,24,1,0,0, +148,1,0,0,108,3,0,0,65,111,110,57,68,0,0,0, +68,0,0,0,0,2,86,76,20,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,1,0,1,0,1,0,0,0,0,0,0,0, +0,2,86,76,1,0,0,2,0,0,15,224,0,0,228,160, +255,255,0,0,65,111,110,57,68,0,0,0,68,0,0,0, +0,2,80,76,20,0,0,0,48,0,0,0,1,0,36,0, +0,0,48,0,0,0,48,0,0,0,36,0,0,0,48,0, +1,0,1,0,1,0,0,0,0,0,0,0,0,2,80,76, +1,0,0,2,0,0,15,224,0,0,228,160,255,255,0,0, +83,72,68,82,64,0,0,0,64,0,240,255,16,0,0,0, +89,0,0,4,70,142,32,0,1,0,0,0,2,0,0,0, +101,0,0,3,242,32,16,0,0,0,0,0,54,0,0,6, +242,32,16,0,0,0,0,0,70,142,32,0,1,0,0,0, +1,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,208,1,0,0,1,0,0,0, +108,0,0,0,1,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,160,1,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +1,0,0,0,0,0,0,0,85,110,105,116,121,70,70,80, +105,120,101,108,0,171,171,171,92,0,0,0,3,0,0,0, +132,0,0,0,160,0,0,0,0,0,0,0,0,0,0,0, +252,0,0,0,0,0,0,0,128,0,0,0,2,0,0,0, +20,1,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,56,1,0,0,128,0,0,0, +4,0,0,0,0,0,0,0,76,1,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +112,1,0,0,144,0,0,0,16,0,0,0,0,0,0,0, +124,1,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,102,102,95,118,101,99,95,99, +111,108,111,114,115,0,102,108,111,97,116,52,0,171,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,1,0,0,102,102,95,97,108,112,104,97,95,114,101,102, +0,102,108,111,97,116,0,171,0,0,3,0,1,0,1,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,69,1,0,0,102,102,95,102, +111,103,95,112,115,0,171,171,1,0,3,0,1,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,1,0,0,77,105,99,114, +111,115,111,102,116,32,40,82,41,32,72,76,83,76,32,83, +104,97,100,101,114,32,67,111,109,112,105,108,101,114,32,54, +46,51,46,57,52,49,53,46,48,0,171,171,76,70,83,48, +76,0,0,0,1,0,0,0,8,0,0,0,56,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,2,0,0,0,255,255,255,255, +255,255,255,255,0,0,0,0,0,0,0,0,76,111,97,100, +67,111,110,115,116,97,110,116,67,111,108,111,114,49,0,171, +76,73,66,70,192,3,0,0,68,88,66,67,116,104,252,128, +151,194,73,196,15,52,199,114,96,200,114,242,1,0,0,0, +192,3,0,0,6,0,0,0,56,0,0,0,132,0,0,0, +208,0,0,0,24,1,0,0,148,1,0,0,108,3,0,0, +65,111,110,57,68,0,0,0,68,0,0,0,0,2,86,76, +20,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,1,0,2,0, +1,0,0,0,0,0,0,0,0,2,86,76,1,0,0,2, +0,0,15,224,0,0,228,160,255,255,0,0,65,111,110,57, +68,0,0,0,68,0,0,0,0,2,80,76,20,0,0,0, +48,0,0,0,1,0,36,0,0,0,48,0,0,0,48,0, +0,0,36,0,0,0,48,0,1,0,2,0,1,0,0,0, +0,0,0,0,0,2,80,76,1,0,0,2,0,0,15,224, +0,0,228,160,255,255,0,0,83,72,68,82,64,0,0,0, +64,0,240,255,16,0,0,0,89,0,0,4,70,142,32,0, +1,0,0,0,3,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,54,0,0,6,242,32,16,0,0,0,0,0, +70,142,32,0,1,0,0,0,2,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +208,1,0,0,1,0,0,0,108,0,0,0,1,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,160,1,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0, +85,110,105,116,121,70,70,80,105,120,101,108,0,171,171,171, +92,0,0,0,3,0,0,0,132,0,0,0,160,0,0,0, +0,0,0,0,0,0,0,0,252,0,0,0,0,0,0,0, +128,0,0,0,2,0,0,0,20,1,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +56,1,0,0,128,0,0,0,4,0,0,0,0,0,0,0, +76,1,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,112,1,0,0,144,0,0,0, +16,0,0,0,0,0,0,0,124,1,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +102,102,95,118,101,99,95,99,111,108,111,114,115,0,102,108, +111,97,116,52,0,171,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,1,0,0,102,102,95,97, +108,112,104,97,95,114,101,102,0,102,108,111,97,116,0,171, +0,0,3,0,1,0,1,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +69,1,0,0,102,102,95,102,111,103,95,112,115,0,171,171, +1,0,3,0,1,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,1,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,171,171,76,70,83,48,76,0,0,0,1,0,0,0, +8,0,0,0,56,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,76,111,97,100,67,111,110,115,116,97,110,116, +67,111,108,111,114,50,0,171,76,73,66,70,192,3,0,0, +68,88,66,67,131,41,35,159,159,146,237,240,170,111,184,2, +39,243,88,214,1,0,0,0,192,3,0,0,6,0,0,0, +56,0,0,0,132,0,0,0,208,0,0,0,24,1,0,0, +148,1,0,0,108,3,0,0,65,111,110,57,68,0,0,0, +68,0,0,0,0,2,86,76,20,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,1,0,3,0,1,0,0,0,0,0,0,0, +0,2,86,76,1,0,0,2,0,0,15,224,0,0,228,160, +255,255,0,0,65,111,110,57,68,0,0,0,68,0,0,0, +0,2,80,76,20,0,0,0,48,0,0,0,1,0,36,0, +0,0,48,0,0,0,48,0,0,0,36,0,0,0,48,0, +1,0,3,0,1,0,0,0,0,0,0,0,0,2,80,76, +1,0,0,2,0,0,15,224,0,0,228,160,255,255,0,0, +83,72,68,82,64,0,0,0,64,0,240,255,16,0,0,0, +89,0,0,4,70,142,32,0,1,0,0,0,4,0,0,0, +101,0,0,3,242,32,16,0,0,0,0,0,54,0,0,6, +242,32,16,0,0,0,0,0,70,142,32,0,1,0,0,0, +3,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,208,1,0,0,1,0,0,0, +108,0,0,0,1,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,160,1,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +1,0,0,0,0,0,0,0,85,110,105,116,121,70,70,80, +105,120,101,108,0,171,171,171,92,0,0,0,3,0,0,0, +132,0,0,0,160,0,0,0,0,0,0,0,0,0,0,0, +252,0,0,0,0,0,0,0,128,0,0,0,2,0,0,0, +20,1,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,56,1,0,0,128,0,0,0, +4,0,0,0,0,0,0,0,76,1,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +112,1,0,0,144,0,0,0,16,0,0,0,0,0,0,0, +124,1,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,102,102,95,118,101,99,95,99, +111,108,111,114,115,0,102,108,111,97,116,52,0,171,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,1,0,0,102,102,95,97,108,112,104,97,95,114,101,102, +0,102,108,111,97,116,0,171,0,0,3,0,1,0,1,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,69,1,0,0,102,102,95,102, +111,103,95,112,115,0,171,171,1,0,3,0,1,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,1,0,0,77,105,99,114, +111,115,111,102,116,32,40,82,41,32,72,76,83,76,32,83, +104,97,100,101,114,32,67,111,109,112,105,108,101,114,32,54, +46,51,46,57,52,49,53,46,48,0,171,171,76,70,83,48, +76,0,0,0,1,0,0,0,8,0,0,0,56,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,2,0,0,0,255,255,255,255, +255,255,255,255,0,0,0,0,0,0,0,0,76,111,97,100, +67,111,110,115,116,97,110,116,67,111,108,111,114,51,0,171, +76,73,66,70,192,3,0,0,68,88,66,67,3,40,62,77, +224,140,92,152,89,140,38,56,207,39,135,89,1,0,0,0, +192,3,0,0,6,0,0,0,56,0,0,0,132,0,0,0, +208,0,0,0,24,1,0,0,148,1,0,0,108,3,0,0, +65,111,110,57,68,0,0,0,68,0,0,0,0,2,86,76, +20,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,1,0,4,0, +1,0,0,0,0,0,0,0,0,2,86,76,1,0,0,2, +0,0,15,224,0,0,228,160,255,255,0,0,65,111,110,57, +68,0,0,0,68,0,0,0,0,2,80,76,20,0,0,0, +48,0,0,0,1,0,36,0,0,0,48,0,0,0,48,0, +0,0,36,0,0,0,48,0,1,0,4,0,1,0,0,0, +0,0,0,0,0,2,80,76,1,0,0,2,0,0,15,224, +0,0,228,160,255,255,0,0,83,72,68,82,64,0,0,0, +64,0,240,255,16,0,0,0,89,0,0,4,70,142,32,0, +1,0,0,0,5,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,54,0,0,6,242,32,16,0,0,0,0,0, +70,142,32,0,1,0,0,0,4,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +208,1,0,0,1,0,0,0,108,0,0,0,1,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,160,1,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0, +85,110,105,116,121,70,70,80,105,120,101,108,0,171,171,171, +92,0,0,0,3,0,0,0,132,0,0,0,160,0,0,0, +0,0,0,0,0,0,0,0,252,0,0,0,0,0,0,0, +128,0,0,0,2,0,0,0,20,1,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +56,1,0,0,128,0,0,0,4,0,0,0,0,0,0,0, +76,1,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,112,1,0,0,144,0,0,0, +16,0,0,0,0,0,0,0,124,1,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +102,102,95,118,101,99,95,99,111,108,111,114,115,0,102,108, +111,97,116,52,0,171,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,1,0,0,102,102,95,97, +108,112,104,97,95,114,101,102,0,102,108,111,97,116,0,171, +0,0,3,0,1,0,1,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +69,1,0,0,102,102,95,102,111,103,95,112,115,0,171,171, +1,0,3,0,1,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,1,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,171,171,76,70,83,48,76,0,0,0,1,0,0,0, +8,0,0,0,56,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,76,111,97,100,67,111,110,115,116,97,110,116, +67,111,108,111,114,52,0,171,76,73,66,70,192,3,0,0, +68,88,66,67,247,173,93,73,196,111,229,44,163,237,132,230, +106,105,144,109,1,0,0,0,192,3,0,0,6,0,0,0, +56,0,0,0,132,0,0,0,208,0,0,0,24,1,0,0, +148,1,0,0,108,3,0,0,65,111,110,57,68,0,0,0, +68,0,0,0,0,2,86,76,20,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,1,0,5,0,1,0,0,0,0,0,0,0, +0,2,86,76,1,0,0,2,0,0,15,224,0,0,228,160, +255,255,0,0,65,111,110,57,68,0,0,0,68,0,0,0, +0,2,80,76,20,0,0,0,48,0,0,0,1,0,36,0, +0,0,48,0,0,0,48,0,0,0,36,0,0,0,48,0, +1,0,5,0,1,0,0,0,0,0,0,0,0,2,80,76, +1,0,0,2,0,0,15,224,0,0,228,160,255,255,0,0, +83,72,68,82,64,0,0,0,64,0,240,255,16,0,0,0, +89,0,0,4,70,142,32,0,1,0,0,0,6,0,0,0, +101,0,0,3,242,32,16,0,0,0,0,0,54,0,0,6, +242,32,16,0,0,0,0,0,70,142,32,0,1,0,0,0, +5,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,208,1,0,0,1,0,0,0, +108,0,0,0,1,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,160,1,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +1,0,0,0,0,0,0,0,85,110,105,116,121,70,70,80, +105,120,101,108,0,171,171,171,92,0,0,0,3,0,0,0, +132,0,0,0,160,0,0,0,0,0,0,0,0,0,0,0, +252,0,0,0,0,0,0,0,128,0,0,0,2,0,0,0, +20,1,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,56,1,0,0,128,0,0,0, +4,0,0,0,0,0,0,0,76,1,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +112,1,0,0,144,0,0,0,16,0,0,0,0,0,0,0, +124,1,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,102,102,95,118,101,99,95,99, +111,108,111,114,115,0,102,108,111,97,116,52,0,171,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,1,0,0,102,102,95,97,108,112,104,97,95,114,101,102, +0,102,108,111,97,116,0,171,0,0,3,0,1,0,1,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,69,1,0,0,102,102,95,102, +111,103,95,112,115,0,171,171,1,0,3,0,1,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,1,0,0,77,105,99,114, +111,115,111,102,116,32,40,82,41,32,72,76,83,76,32,83, +104,97,100,101,114,32,67,111,109,112,105,108,101,114,32,54, +46,51,46,57,52,49,53,46,48,0,171,171,76,70,83,48, +76,0,0,0,1,0,0,0,8,0,0,0,56,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,2,0,0,0,255,255,255,255, +255,255,255,255,0,0,0,0,0,0,0,0,76,111,97,100, +67,111,110,115,116,97,110,116,67,111,108,111,114,53,0,171, +76,73,66,70,192,3,0,0,68,88,66,67,48,33,196,39, +86,158,25,201,60,227,193,209,75,77,76,7,1,0,0,0, +192,3,0,0,6,0,0,0,56,0,0,0,132,0,0,0, +208,0,0,0,24,1,0,0,148,1,0,0,108,3,0,0, +65,111,110,57,68,0,0,0,68,0,0,0,0,2,86,76, +20,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,1,0,6,0, +1,0,0,0,0,0,0,0,0,2,86,76,1,0,0,2, +0,0,15,224,0,0,228,160,255,255,0,0,65,111,110,57, +68,0,0,0,68,0,0,0,0,2,80,76,20,0,0,0, +48,0,0,0,1,0,36,0,0,0,48,0,0,0,48,0, +0,0,36,0,0,0,48,0,1,0,6,0,1,0,0,0, +0,0,0,0,0,2,80,76,1,0,0,2,0,0,15,224, +0,0,228,160,255,255,0,0,83,72,68,82,64,0,0,0, +64,0,240,255,16,0,0,0,89,0,0,4,70,142,32,0, +1,0,0,0,7,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,54,0,0,6,242,32,16,0,0,0,0,0, +70,142,32,0,1,0,0,0,6,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +208,1,0,0,1,0,0,0,108,0,0,0,1,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,160,1,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0, +85,110,105,116,121,70,70,80,105,120,101,108,0,171,171,171, +92,0,0,0,3,0,0,0,132,0,0,0,160,0,0,0, +0,0,0,0,0,0,0,0,252,0,0,0,0,0,0,0, +128,0,0,0,2,0,0,0,20,1,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +56,1,0,0,128,0,0,0,4,0,0,0,0,0,0,0, +76,1,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,112,1,0,0,144,0,0,0, +16,0,0,0,0,0,0,0,124,1,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +102,102,95,118,101,99,95,99,111,108,111,114,115,0,102,108, +111,97,116,52,0,171,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,1,0,0,102,102,95,97, +108,112,104,97,95,114,101,102,0,102,108,111,97,116,0,171, +0,0,3,0,1,0,1,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +69,1,0,0,102,102,95,102,111,103,95,112,115,0,171,171, +1,0,3,0,1,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,1,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,171,171,76,70,83,48,76,0,0,0,1,0,0,0, +8,0,0,0,56,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,76,111,97,100,67,111,110,115,116,97,110,116, +67,111,108,111,114,54,0,171,76,73,66,70,192,3,0,0, +68,88,66,67,169,198,138,5,205,98,94,205,122,79,240,230, +184,15,46,76,1,0,0,0,192,3,0,0,6,0,0,0, +56,0,0,0,132,0,0,0,208,0,0,0,24,1,0,0, +148,1,0,0,108,3,0,0,65,111,110,57,68,0,0,0, +68,0,0,0,0,2,86,76,20,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,1,0,7,0,1,0,0,0,0,0,0,0, +0,2,86,76,1,0,0,2,0,0,15,224,0,0,228,160, +255,255,0,0,65,111,110,57,68,0,0,0,68,0,0,0, +0,2,80,76,20,0,0,0,48,0,0,0,1,0,36,0, +0,0,48,0,0,0,48,0,0,0,36,0,0,0,48,0, +1,0,7,0,1,0,0,0,0,0,0,0,0,2,80,76, +1,0,0,2,0,0,15,224,0,0,228,160,255,255,0,0, +83,72,68,82,64,0,0,0,64,0,240,255,16,0,0,0, +89,0,0,4,70,142,32,0,1,0,0,0,8,0,0,0, +101,0,0,3,242,32,16,0,0,0,0,0,54,0,0,6, +242,32,16,0,0,0,0,0,70,142,32,0,1,0,0,0, +7,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,208,1,0,0,1,0,0,0, +108,0,0,0,1,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,160,1,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +1,0,0,0,0,0,0,0,85,110,105,116,121,70,70,80, +105,120,101,108,0,171,171,171,92,0,0,0,3,0,0,0, +132,0,0,0,160,0,0,0,0,0,0,0,0,0,0,0, +252,0,0,0,0,0,0,0,128,0,0,0,2,0,0,0, +20,1,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,56,1,0,0,128,0,0,0, +4,0,0,0,0,0,0,0,76,1,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +112,1,0,0,144,0,0,0,16,0,0,0,0,0,0,0, +124,1,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,102,102,95,118,101,99,95,99, +111,108,111,114,115,0,102,108,111,97,116,52,0,171,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,1,0,0,102,102,95,97,108,112,104,97,95,114,101,102, +0,102,108,111,97,116,0,171,0,0,3,0,1,0,1,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,69,1,0,0,102,102,95,102, +111,103,95,112,115,0,171,171,1,0,3,0,1,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,1,0,0,77,105,99,114, +111,115,111,102,116,32,40,82,41,32,72,76,83,76,32,83, +104,97,100,101,114,32,67,111,109,112,105,108,101,114,32,54, +46,51,46,57,52,49,53,46,48,0,171,171,76,70,83,48, +76,0,0,0,1,0,0,0,8,0,0,0,56,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,2,0,0,0,255,255,255,255, +255,255,255,255,0,0,0,0,0,0,0,0,76,111,97,100, +67,111,110,115,116,97,110,116,67,111,108,111,114,55,0,171, +76,73,66,70,204,2,0,0,68,88,66,67,45,108,242,17, +41,178,132,75,103,221,15,167,11,128,240,127,1,0,0,0, +204,2,0,0,6,0,0,0,56,0,0,0,160,0,0,0, +20,1,0,0,96,1,0,0,220,1,0,0,80,2,0,0, +65,111,110,57,96,0,0,0,96,0,0,0,0,2,86,76, +60,0,0,0,36,0,0,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,2,86,76, +81,0,0,5,0,0,15,160,0,0,128,63,0,0,0,0, +0,0,0,0,0,0,0,0,31,0,0,2,5,0,0,128, +0,0,15,144,2,0,0,3,0,0,1,224,0,0,0,145, +0,0,0,160,255,255,0,0,65,111,110,57,108,0,0,0, +108,0,0,0,0,2,80,76,72,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,80,76,81,0,0,5,0,0,15,160, +0,0,128,63,0,0,0,0,0,0,0,0,0,0,0,0, +31,0,0,2,0,0,0,128,0,0,1,176,2,0,0,3, +0,0,8,128,0,0,0,177,0,0,0,160,1,0,0,2, +0,0,1,224,0,0,255,128,255,255,0,0,83,72,68,82, +68,0,0,0,64,0,240,255,17,0,0,0,95,0,0,3, +18,16,16,0,0,0,0,0,101,0,0,3,18,32,16,0, +0,0,0,0,0,0,0,8,18,32,16,0,0,0,0,0, +10,16,16,128,65,0,0,0,0,0,0,0,1,64,0,0, +0,0,128,63,62,0,0,1,83,84,65,84,116,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,108,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,60,0,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,77,105,99,114,111,115,111,102, +116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101, +114,32,67,111,109,112,105,108,101,114,32,54,46,51,46,57, +52,49,53,46,48,0,171,171,76,70,83,48,116,0,0,0, +2,0,0,0,8,0,0,0,104,0,0,0,0,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,114,0,0,0,0,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,79,110,101,77,105,110,117,115, +49,0,118,0,76,73,66,70,216,2,0,0,68,88,66,67, +158,168,1,106,99,49,31,82,200,140,198,11,9,75,78,147, +1,0,0,0,216,2,0,0,6,0,0,0,56,0,0,0, +160,0,0,0,20,1,0,0,108,1,0,0,232,1,0,0, +92,2,0,0,65,111,110,57,96,0,0,0,96,0,0,0, +0,2,86,76,60,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,86,76,81,0,0,5,0,0,15,160,0,0,128,63, +0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,2, +5,0,0,128,0,0,15,144,2,0,0,3,0,0,7,224, +0,0,228,145,0,0,0,160,255,255,0,0,65,111,110,57, +108,0,0,0,108,0,0,0,0,2,80,76,72,0,0,0, +36,0,0,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,2,80,76,81,0,0,5, +0,0,15,160,0,0,128,63,0,0,0,0,0,0,0,0, +0,0,0,0,31,0,0,2,0,0,0,128,0,0,7,176, +2,0,0,3,0,0,7,128,0,0,228,177,0,0,0,160, +1,0,0,2,0,0,7,224,0,0,228,128,255,255,0,0, +83,72,68,82,80,0,0,0,64,0,240,255,20,0,0,0, +95,0,0,3,114,16,16,0,0,0,0,0,101,0,0,3, +114,32,16,0,0,0,0,0,0,0,0,11,114,32,16,0, +0,0,0,0,70,18,16,128,65,0,0,0,0,0,0,0, +2,64,0,0,0,0,128,63,0,0,128,63,0,0,128,63, +0,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,108,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,60,0,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,77,105,99,114,111,115,111,102, +116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101, +114,32,67,111,109,112,105,108,101,114,32,54,46,51,46,57, +52,49,53,46,48,0,171,171,76,70,83,48,116,0,0,0, +2,0,0,0,8,0,0,0,104,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,114,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,79,110,101,77,105,110,117,115, +51,0,118,0,76,73,66,70,216,2,0,0,68,88,66,67, +11,213,169,220,3,17,184,207,196,164,42,102,227,86,202,46, +1,0,0,0,216,2,0,0,6,0,0,0,56,0,0,0, +160,0,0,0,20,1,0,0,108,1,0,0,232,1,0,0, +92,2,0,0,65,111,110,57,96,0,0,0,96,0,0,0, +0,2,86,76,60,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,86,76,81,0,0,5,0,0,15,160,0,0,128,63, +0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,2, +5,0,0,128,0,0,15,144,2,0,0,3,0,0,15,224, +0,0,228,145,0,0,0,160,255,255,0,0,65,111,110,57, +108,0,0,0,108,0,0,0,0,2,80,76,72,0,0,0, +36,0,0,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,2,80,76,81,0,0,5, +0,0,15,160,0,0,128,63,0,0,0,0,0,0,0,0, +0,0,0,0,31,0,0,2,0,0,0,128,0,0,15,176, +2,0,0,3,0,0,15,128,0,0,228,177,0,0,0,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,80,0,0,0,64,0,240,255,20,0,0,0, +95,0,0,3,242,16,16,0,0,0,0,0,101,0,0,3, +242,32,16,0,0,0,0,0,0,0,0,11,242,32,16,0, +0,0,0,0,70,30,16,128,65,0,0,0,0,0,0,0, +2,64,0,0,0,0,128,63,0,0,128,63,0,0,128,63, +0,0,128,63,62,0,0,1,83,84,65,84,116,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,108,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,60,0,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,77,105,99,114,111,115,111,102, +116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101, +114,32,67,111,109,112,105,108,101,114,32,54,46,51,46,57, +52,49,53,46,48,0,171,171,76,70,83,48,116,0,0,0, +2,0,0,0,8,0,0,0,104,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,114,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,79,110,101,77,105,110,117,115, +52,0,118,0,76,73,66,70,128,2,0,0,68,88,66,67, +187,71,126,136,198,179,185,17,98,92,175,72,62,254,64,135, +1,0,0,0,128,2,0,0,6,0,0,0,56,0,0,0, +132,0,0,0,208,0,0,0,16,1,0,0,140,1,0,0, +0,2,0,0,65,111,110,57,68,0,0,0,68,0,0,0, +0,2,86,76,32,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,86,76,31,0,0,2,5,0,0,128,0,0,15,144, +1,0,0,2,0,0,15,224,0,0,228,144,255,255,0,0, +65,111,110,57,68,0,0,0,68,0,0,0,0,2,80,76, +32,0,0,0,36,0,0,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,2,80,76, +31,0,0,2,0,0,0,128,0,0,15,176,1,0,0,2, +0,0,15,224,0,0,228,176,255,255,0,0,83,72,68,82, +56,0,0,0,64,0,240,255,14,0,0,0,95,0,0,3, +242,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,54,0,0,5,242,32,16,0,0,0,0,0, +70,30,16,0,0,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,108,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,60,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,77,105,99,114, +111,115,111,102,116,32,40,82,41,32,72,76,83,76,32,83, +104,97,100,101,114,32,67,111,109,112,105,108,101,114,32,54, +46,51,46,57,52,49,53,46,48,0,171,171,76,70,83,48, +120,0,0,0,2,0,0,0,8,0,0,0,104,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,2,0,0,0,255,255,255,255, +255,255,255,255,0,0,0,0,0,0,0,0,116,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,67,111,109,98, +82,101,112,108,97,99,101,0,97,0,171,171,76,73,66,70, +12,3,0,0,68,88,66,67,149,143,87,109,142,38,148,229, +142,231,17,129,220,71,27,94,1,0,0,0,12,3,0,0, +6,0,0,0,56,0,0,0,160,0,0,0,20,1,0,0, +104,1,0,0,228,1,0,0,88,2,0,0,65,111,110,57, +96,0,0,0,96,0,0,0,0,2,86,76,60,0,0,0, +36,0,0,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,2,86,76,31,0,0,2, +5,0,0,128,0,0,15,144,31,0,0,2,5,0,1,128, +1,0,15,144,1,0,0,2,0,0,15,128,0,0,228,144, +5,0,0,3,0,0,15,224,0,0,228,128,1,0,228,144, +255,255,0,0,65,111,110,57,108,0,0,0,108,0,0,0, +0,2,80,76,72,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,80,76,31,0,0,2,0,0,0,128,0,0,15,176, +31,0,0,2,0,0,0,128,1,0,15,176,1,0,0,2, +0,0,15,128,0,0,228,176,5,0,0,3,0,0,15,128, +0,0,228,128,1,0,228,176,1,0,0,2,0,0,15,224, +0,0,228,128,255,255,0,0,83,72,68,82,76,0,0,0, +64,0,240,255,19,0,0,0,95,0,0,3,242,16,16,0, +0,0,0,0,95,0,0,3,242,16,16,0,1,0,0,0, +101,0,0,3,242,32,16,0,0,0,0,0,56,0,0,7, +242,32,16,0,0,0,0,0,70,30,16,0,0,0,0,0, +70,30,16,0,1,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,108,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,60,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,77,105,99,114, +111,115,111,102,116,32,40,82,41,32,72,76,83,76,32,83, +104,97,100,101,114,32,67,111,109,112,105,108,101,114,32,54, +46,51,46,57,52,49,53,46,48,0,171,171,76,70,83,48, +172,0,0,0,3,0,0,0,8,0,0,0,152,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,2,0,0,0,255,255,255,255, +255,255,255,255,0,0,0,0,0,0,0,0,165,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,167,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,67,111,109,98, +77,111,100,117,108,97,116,101,0,97,0,98,0,171,171,171, +76,73,66,70,4,3,0,0,68,88,66,67,230,76,60,128, +196,190,237,250,58,85,119,85,43,12,167,22,1,0,0,0, +4,3,0,0,6,0,0,0,56,0,0,0,160,0,0,0, +20,1,0,0,104,1,0,0,228,1,0,0,88,2,0,0, +65,111,110,57,96,0,0,0,96,0,0,0,0,2,86,76, +60,0,0,0,36,0,0,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,2,86,76, +31,0,0,2,5,0,0,128,0,0,15,144,31,0,0,2, +5,0,1,128,1,0,15,144,1,0,0,2,0,0,15,128, +0,0,228,144,2,0,0,3,0,0,15,224,0,0,228,128, +1,0,228,144,255,255,0,0,65,111,110,57,108,0,0,0, +108,0,0,0,0,2,80,76,72,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,15,176,31,0,0,2,0,0,0,128,1,0,15,176, +1,0,0,2,0,0,15,128,0,0,228,176,2,0,0,3, +0,0,15,128,0,0,228,128,1,0,228,176,1,0,0,2, +0,0,15,224,0,0,228,128,255,255,0,0,83,72,68,82, +76,0,0,0,64,0,240,255,19,0,0,0,95,0,0,3, +242,16,16,0,0,0,0,0,95,0,0,3,242,16,16,0, +1,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +0,0,0,7,242,32,16,0,0,0,0,0,70,30,16,0, +0,0,0,0,70,30,16,0,1,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +108,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,60,0,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +77,105,99,114,111,115,111,102,116,32,40,82,41,32,72,76, +83,76,32,83,104,97,100,101,114,32,67,111,109,112,105,108, +101,114,32,54,46,51,46,57,52,49,53,46,48,0,171,171, +76,70,83,48,164,0,0,0,3,0,0,0,8,0,0,0, +152,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,2,0,0,0, +255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0, +160,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +162,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +1,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +67,111,109,98,65,100,100,0,97,0,98,0,76,73,66,70, +140,3,0,0,68,88,66,67,152,199,141,230,40,126,172,158, +226,182,226,112,150,175,84,205,1,0,0,0,140,3,0,0, +6,0,0,0,56,0,0,0,200,0,0,0,100,1,0,0, +232,1,0,0,100,2,0,0,216,2,0,0,65,111,110,57, +136,0,0,0,136,0,0,0,0,2,86,76,100,0,0,0, +36,0,0,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,2,86,76,81,0,0,5, +0,0,15,160,0,0,0,191,0,0,0,0,0,0,0,0, +0,0,0,0,31,0,0,2,5,0,0,128,0,0,15,144, +31,0,0,2,5,0,1,128,1,0,15,144,1,0,0,2, +0,0,15,128,0,0,228,144,2,0,0,3,0,0,15,128, +0,0,228,128,1,0,228,144,2,0,0,3,0,0,15,224, +0,0,228,128,0,0,0,160,255,255,0,0,65,111,110,57, +148,0,0,0,148,0,0,0,0,2,80,76,112,0,0,0, +36,0,0,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,2,80,76,81,0,0,5, +0,0,15,160,0,0,0,191,0,0,0,0,0,0,0,0, +0,0,0,0,31,0,0,2,0,0,0,128,0,0,15,176, +31,0,0,2,0,0,0,128,1,0,15,176,1,0,0,2, +0,0,15,128,0,0,228,176,2,0,0,3,0,0,15,128, +0,0,228,128,1,0,228,176,2,0,0,3,0,0,15,128, +0,0,228,128,0,0,0,160,1,0,0,2,0,0,15,224, +0,0,228,128,255,255,0,0,83,72,68,82,124,0,0,0, +64,0,240,255,31,0,0,0,95,0,0,3,242,16,16,0, +0,0,0,0,95,0,0,3,242,16,16,0,1,0,0,0, +101,0,0,3,242,32,16,0,0,0,0,0,104,0,0,2, +1,0,0,0,0,0,0,7,242,0,16,0,0,0,0,0, +70,30,16,0,0,0,0,0,70,30,16,0,1,0,0,0, +0,0,0,10,242,32,16,0,0,0,0,0,70,14,16,0, +0,0,0,0,2,64,0,0,0,0,0,191,0,0,0,191, +0,0,0,191,0,0,0,191,62,0,0,1,83,84,65,84, +116,0,0,0,3,0,0,0,1,0,0,0,0,0,0,0, +3,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,108,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,60,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,77,105,99,114, +111,115,111,102,116,32,40,82,41,32,72,76,83,76,32,83, +104,97,100,101,114,32,67,111,109,112,105,108,101,114,32,54, +46,51,46,57,52,49,53,46,48,0,171,171,76,70,83,48, +172,0,0,0,3,0,0,0,8,0,0,0,152,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,2,0,0,0,255,255,255,255, +255,255,255,255,0,0,0,0,0,0,0,0,166,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,168,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,67,111,109,98, +65,100,100,83,105,103,110,101,100,0,97,0,98,0,171,171, +76,73,66,70,16,3,0,0,68,88,66,67,183,114,174,20, +132,250,51,162,45,140,19,76,71,64,111,25,1,0,0,0, +16,3,0,0,6,0,0,0,56,0,0,0,160,0,0,0, +20,1,0,0,108,1,0,0,232,1,0,0,92,2,0,0, +65,111,110,57,96,0,0,0,96,0,0,0,0,2,86,76, +60,0,0,0,36,0,0,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,2,86,76, +31,0,0,2,5,0,0,128,0,0,15,144,31,0,0,2, +5,0,1,128,1,0,15,144,1,0,0,2,0,0,15,128, +0,0,228,144,2,0,0,3,0,0,15,224,0,0,228,128, +1,0,228,145,255,255,0,0,65,111,110,57,108,0,0,0, +108,0,0,0,0,2,80,76,72,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,15,176,31,0,0,2,0,0,0,128,1,0,15,176, +1,0,0,2,0,0,15,128,0,0,228,176,2,0,0,3, +0,0,15,128,0,0,228,128,1,0,228,177,1,0,0,2, +0,0,15,224,0,0,228,128,255,255,0,0,83,72,68,82, +80,0,0,0,64,0,240,255,20,0,0,0,95,0,0,3, +242,16,16,0,0,0,0,0,95,0,0,3,242,16,16,0, +1,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +0,0,0,8,242,32,16,0,0,0,0,0,70,30,16,0, +0,0,0,0,70,30,16,128,65,0,0,0,1,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,2,0,0,0, +0,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,108,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +60,0,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,171,171,76,70,83,48,172,0,0,0,3,0,0,0, +8,0,0,0,152,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,165,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,167,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,1,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,67,111,109,98,83,117,98,116,114,97,99,116, +0,97,0,98,0,171,171,171,76,73,66,70,180,3,0,0, +68,88,66,67,152,163,17,37,211,107,50,197,55,83,131,3, +147,212,251,180,1,0,0,0,180,3,0,0,6,0,0,0, +56,0,0,0,192,0,0,0,84,1,0,0,228,1,0,0, +96,2,0,0,212,2,0,0,65,111,110,57,128,0,0,0, +128,0,0,0,0,2,86,76,92,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,86,76,31,0,0,2,5,0,0,128, +0,0,15,144,31,0,0,2,5,0,1,128,1,0,15,144, +31,0,0,2,5,0,2,128,2,0,15,144,1,0,0,2, +0,0,15,128,1,0,228,144,2,0,0,3,1,0,15,128, +0,0,228,129,0,0,228,144,4,0,0,4,0,0,15,224, +2,0,255,144,1,0,228,128,0,0,228,128,255,255,0,0, +65,111,110,57,140,0,0,0,140,0,0,0,0,2,80,76, +104,0,0,0,36,0,0,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,2,80,76, +31,0,0,2,0,0,0,128,0,0,15,176,31,0,0,2, +0,0,0,128,1,0,15,176,31,0,0,2,0,0,0,128, +2,0,8,176,1,0,0,2,0,0,15,128,1,0,228,176, +2,0,0,3,1,0,15,128,0,0,228,129,0,0,228,176, +4,0,0,4,0,0,15,128,2,0,255,176,1,0,228,128, +0,0,228,128,1,0,0,2,0,0,15,224,0,0,228,128, +255,255,0,0,83,72,68,82,136,0,0,0,64,0,240,255, +34,0,0,0,95,0,0,3,242,16,16,0,0,0,0,0, +95,0,0,3,242,16,16,0,1,0,0,0,95,0,0,3, +130,16,16,0,2,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,104,0,0,2,1,0,0,0,0,0,0,8, +242,0,16,0,0,0,0,0,70,30,16,0,0,0,0,0, +70,30,16,128,65,0,0,0,1,0,0,0,50,0,0,9, +242,32,16,0,0,0,0,0,246,31,16,0,2,0,0,0, +70,14,16,0,0,0,0,0,70,30,16,0,1,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,3,0,0,0, +1,0,0,0,0,0,0,0,4,0,0,0,2,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,108,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +60,0,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,171,171,76,70,83,48,216,0,0,0,4,0,0,0, +8,0,0,0,200,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,209,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,211,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,1,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,213,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,2,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,67,111,109,98,76,101,114,112,0,97,0,98, +0,99,0,171,76,73,66,70,44,4,0,0,68,88,66,67, +51,90,121,247,48,76,173,77,104,101,2,120,144,179,245,77, +1,0,0,0,44,4,0,0,6,0,0,0,56,0,0,0, +232,0,0,0,164,1,0,0,140,2,0,0,8,3,0,0, +124,3,0,0,65,111,110,57,168,0,0,0,168,0,0,0, +0,2,86,76,132,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,86,76,81,0,0,5,0,0,15,160,0,0,0,191, +0,0,128,64,0,0,0,0,0,0,0,0,31,0,0,2, +5,0,0,128,0,0,15,144,31,0,0,2,5,0,1,128, +1,0,15,144,2,0,0,3,0,0,7,128,0,0,228,144, +0,0,0,160,2,0,0,3,1,0,7,128,1,0,228,144, +0,0,0,160,8,0,0,3,0,0,1,128,0,0,228,128, +1,0,228,128,5,0,0,3,0,0,7,224,0,0,0,128, +0,0,85,160,1,0,0,2,0,0,8,224,0,0,255,144, +255,255,0,0,65,111,110,57,180,0,0,0,180,0,0,0, +0,2,80,76,144,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,80,76,81,0,0,5,0,0,15,160,0,0,0,191, +0,0,128,64,0,0,0,0,0,0,0,0,31,0,0,2, +0,0,0,128,0,0,15,176,31,0,0,2,0,0,0,128, +1,0,7,176,2,0,0,3,0,0,7,128,0,0,228,176, +0,0,0,160,2,0,0,3,1,0,7,128,1,0,228,176, +0,0,0,160,8,0,0,3,0,0,1,128,0,0,228,128, +1,0,228,128,5,0,0,3,0,0,7,128,0,0,0,128, +0,0,85,160,1,0,0,2,0,0,8,128,0,0,255,176, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,224,0,0,0,64,0,240,255,56,0,0,0, +95,0,0,3,242,16,16,0,0,0,0,0,95,0,0,3, +114,16,16,0,1,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,104,0,0,2,2,0,0,0,0,0,0,10, +114,0,16,0,0,0,0,0,70,18,16,0,0,0,0,0, +2,64,0,0,0,0,0,191,0,0,0,191,0,0,0,191, +0,0,0,0,0,0,0,10,114,0,16,0,1,0,0,0, +70,18,16,0,1,0,0,0,2,64,0,0,0,0,0,191, +0,0,0,191,0,0,0,191,0,0,0,0,16,0,0,7, +18,0,16,0,0,0,0,0,70,2,16,0,0,0,0,0, +70,2,16,0,1,0,0,0,56,0,0,10,114,32,16,0, +0,0,0,0,6,0,16,0,0,0,0,0,2,64,0,0, +0,0,128,64,0,0,128,64,0,0,128,64,0,0,0,0, +54,0,0,5,130,32,16,0,0,0,0,0,58,16,16,0, +0,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +6,0,0,0,2,0,0,0,0,0,0,0,3,0,0,0, +4,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,108,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,60,0,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,77,105,99,114,111,115,111,102, +116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101, +114,32,67,111,109,112,105,108,101,114,32,54,46,51,46,57, +52,49,53,46,48,0,171,171,76,70,83,48,168,0,0,0, +3,0,0,0,8,0,0,0,152,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,161,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,163,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,67,111,109,98,68,111,116,51, +0,97,0,98,0,171,171,171,76,73,66,70,4,4,0,0, +68,88,66,67,136,183,202,100,86,249,89,61,211,252,59,81, +134,90,81,47,1,0,0,0,4,4,0,0,6,0,0,0, +56,0,0,0,220,0,0,0,140,1,0,0,96,2,0,0, +220,2,0,0,80,3,0,0,65,111,110,57,156,0,0,0, +156,0,0,0,0,2,86,76,120,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,86,76,81,0,0,5,0,0,15,160, +0,0,0,191,0,0,128,64,0,0,0,0,0,0,0,0, +31,0,0,2,5,0,0,128,0,0,15,144,31,0,0,2, +5,0,1,128,1,0,15,144,2,0,0,3,0,0,7,128, +0,0,228,144,0,0,0,160,2,0,0,3,1,0,7,128, +1,0,228,144,0,0,0,160,8,0,0,3,0,0,1,128, +0,0,228,128,1,0,228,128,5,0,0,3,0,0,15,224, +0,0,0,128,0,0,85,160,255,255,0,0,65,111,110,57, +168,0,0,0,168,0,0,0,0,2,80,76,132,0,0,0, +36,0,0,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,2,80,76,81,0,0,5, +0,0,15,160,0,0,0,191,0,0,128,64,0,0,0,0, +0,0,0,0,31,0,0,2,0,0,0,128,0,0,7,176, +31,0,0,2,0,0,0,128,1,0,7,176,2,0,0,3, +0,0,7,128,0,0,228,176,0,0,0,160,2,0,0,3, +1,0,7,128,1,0,228,176,0,0,0,160,8,0,0,3, +0,0,1,128,0,0,228,128,1,0,228,128,5,0,0,3, +0,0,15,128,0,0,0,128,0,0,85,160,1,0,0,2, +0,0,15,224,0,0,228,128,255,255,0,0,83,72,68,82, +204,0,0,0,64,0,240,255,51,0,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,95,0,0,3,114,16,16,0, +1,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +104,0,0,2,2,0,0,0,0,0,0,10,114,0,16,0, +0,0,0,0,70,18,16,0,0,0,0,0,2,64,0,0, +0,0,0,191,0,0,0,191,0,0,0,191,0,0,0,0, +0,0,0,10,114,0,16,0,1,0,0,0,70,18,16,0, +1,0,0,0,2,64,0,0,0,0,0,191,0,0,0,191, +0,0,0,191,0,0,0,0,16,0,0,7,18,0,16,0, +0,0,0,0,70,2,16,0,0,0,0,0,70,2,16,0, +1,0,0,0,56,0,0,10,242,32,16,0,0,0,0,0, +6,0,16,0,0,0,0,0,2,64,0,0,0,0,128,64, +0,0,128,64,0,0,128,64,0,0,128,64,62,0,0,1, +83,84,65,84,116,0,0,0,5,0,0,0,2,0,0,0, +0,0,0,0,3,0,0,0,4,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +108,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,60,0,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +77,105,99,114,111,115,111,102,116,32,40,82,41,32,72,76, +83,76,32,83,104,97,100,101,114,32,67,111,109,112,105,108, +101,114,32,54,46,51,46,57,52,49,53,46,48,0,171,171, +76,70,83,48,172,0,0,0,3,0,0,0,8,0,0,0, +152,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,2,0,0,0, +255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0, +165,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +167,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +1,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +67,111,109,98,68,111,116,51,114,103,98,97,0,97,0,98, +0,171,171,171,76,73,66,70,136,3,0,0,68,88,66,67, +31,76,227,248,96,59,115,47,100,193,168,174,45,34,12,208, +1,0,0,0,136,3,0,0,6,0,0,0,56,0,0,0, +188,0,0,0,76,1,0,0,180,1,0,0,48,2,0,0, +164,2,0,0,65,111,110,57,124,0,0,0,124,0,0,0, +0,2,86,76,88,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,86,76,31,0,0,2,5,0,0,128,0,0,15,144, +31,0,0,2,5,0,1,128,1,0,15,144,31,0,0,2, +5,0,2,128,2,0,15,144,1,0,0,2,0,0,15,128, +0,0,228,144,1,0,0,2,1,0,8,128,2,0,255,144, +4,0,0,4,0,0,15,224,0,0,228,128,1,0,255,128, +1,0,228,144,255,255,0,0,65,111,110,57,136,0,0,0, +136,0,0,0,0,2,80,76,100,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,15,176,31,0,0,2,0,0,0,128,1,0,15,176, +31,0,0,2,0,0,0,128,2,0,8,176,1,0,0,2, +0,0,15,128,0,0,228,176,1,0,0,2,1,0,8,128, +2,0,255,176,4,0,0,4,0,0,15,128,0,0,228,128, +1,0,255,128,1,0,228,176,1,0,0,2,0,0,15,224, +0,0,228,128,255,255,0,0,83,72,68,82,96,0,0,0, +64,0,240,255,24,0,0,0,95,0,0,3,242,16,16,0, +0,0,0,0,95,0,0,3,242,16,16,0,1,0,0,0, +95,0,0,3,130,16,16,0,2,0,0,0,101,0,0,3, +242,32,16,0,0,0,0,0,50,0,0,9,242,32,16,0, +0,0,0,0,70,30,16,0,0,0,0,0,246,31,16,0, +2,0,0,0,70,30,16,0,1,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,4,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +108,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,60,0,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +77,105,99,114,111,115,111,102,116,32,40,82,41,32,72,76, +83,76,32,83,104,97,100,101,114,32,67,111,109,112,105,108, +101,114,32,54,46,51,46,57,52,49,53,46,48,0,171,171, +76,70,83,48,220,0,0,0,4,0,0,0,8,0,0,0, +200,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,2,0,0,0, +255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0, +211,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +213,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +1,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +215,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +2,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +67,111,109,98,77,117,108,65,100,100,0,97,0,98,0,99, +0,171,171,171,76,73,66,70,140,3,0,0,68,88,66,67, +127,205,158,183,165,163,232,169,189,8,89,19,233,185,188,242, +1,0,0,0,140,3,0,0,6,0,0,0,56,0,0,0, +188,0,0,0,76,1,0,0,184,1,0,0,52,2,0,0, +168,2,0,0,65,111,110,57,124,0,0,0,124,0,0,0, +0,2,86,76,88,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,86,76,31,0,0,2,5,0,0,128,0,0,15,144, +31,0,0,2,5,0,1,128,1,0,15,144,31,0,0,2, +5,0,2,128,2,0,15,144,1,0,0,2,0,0,15,128, +0,0,228,144,1,0,0,2,1,0,8,128,2,0,255,144, +4,0,0,4,0,0,15,224,0,0,228,128,1,0,255,128, +1,0,228,145,255,255,0,0,65,111,110,57,136,0,0,0, +136,0,0,0,0,2,80,76,100,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,15,176,31,0,0,2,0,0,0,128,1,0,15,176, +31,0,0,2,0,0,0,128,2,0,8,176,1,0,0,2, +0,0,15,128,0,0,228,176,1,0,0,2,1,0,8,128, +2,0,255,176,4,0,0,4,0,0,15,128,0,0,228,128, +1,0,255,128,1,0,228,177,1,0,0,2,0,0,15,224, +0,0,228,128,255,255,0,0,83,72,68,82,100,0,0,0, +64,0,240,255,25,0,0,0,95,0,0,3,242,16,16,0, +0,0,0,0,95,0,0,3,242,16,16,0,1,0,0,0, +95,0,0,3,130,16,16,0,2,0,0,0,101,0,0,3, +242,32,16,0,0,0,0,0,50,0,0,10,242,32,16,0, +0,0,0,0,70,30,16,0,0,0,0,0,246,31,16,0, +2,0,0,0,70,30,16,128,65,0,0,0,1,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,2,0,0,0, +0,0,0,0,0,0,0,0,4,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,108,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +60,0,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,171,171,76,70,83,48,220,0,0,0,4,0,0,0, +8,0,0,0,200,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,211,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,213,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,1,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,215,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,2,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,67,111,109,98,77,117,108,83,117,98,0,97, +0,98,0,99,0,171,171,171,76,73,66,70,12,4,0,0, +68,88,66,67,83,111,20,102,197,156,233,182,54,7,106,223, +34,245,237,46,1,0,0,0,12,4,0,0,6,0,0,0, +56,0,0,0,228,0,0,0,156,1,0,0,52,2,0,0, +176,2,0,0,36,3,0,0,65,111,110,57,164,0,0,0, +164,0,0,0,0,2,86,76,128,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,86,76,81,0,0,5,0,0,15,160, +0,0,0,191,0,0,0,0,0,0,0,0,0,0,0,0, +31,0,0,2,5,0,0,128,0,0,15,144,31,0,0,2, +5,0,1,128,1,0,15,144,31,0,0,2,5,0,2,128, +2,0,15,144,1,0,0,2,0,0,15,128,0,0,228,144, +1,0,0,2,1,0,8,128,2,0,255,144,4,0,0,4, +0,0,15,128,0,0,228,128,1,0,255,128,1,0,228,144, +2,0,0,3,0,0,15,224,0,0,228,128,0,0,0,160, +255,255,0,0,65,111,110,57,176,0,0,0,176,0,0,0, +0,2,80,76,140,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,80,76,81,0,0,5,0,0,15,160,0,0,0,191, +0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,2, +0,0,0,128,0,0,15,176,31,0,0,2,0,0,0,128, +1,0,15,176,31,0,0,2,0,0,0,128,2,0,8,176, +1,0,0,2,0,0,15,128,0,0,228,176,1,0,0,2, +1,0,8,128,2,0,255,176,4,0,0,4,0,0,15,128, +0,0,228,128,1,0,255,128,1,0,228,176,2,0,0,3, +0,0,15,128,0,0,228,128,0,0,0,160,1,0,0,2, +0,0,15,224,0,0,228,128,255,255,0,0,83,72,68,82, +144,0,0,0,64,0,240,255,36,0,0,0,95,0,0,3, +242,16,16,0,0,0,0,0,95,0,0,3,242,16,16,0, +1,0,0,0,95,0,0,3,130,16,16,0,2,0,0,0, +101,0,0,3,242,32,16,0,0,0,0,0,104,0,0,2, +1,0,0,0,50,0,0,9,242,0,16,0,0,0,0,0, +70,30,16,0,0,0,0,0,246,31,16,0,2,0,0,0, +70,30,16,0,1,0,0,0,0,0,0,10,242,32,16,0, +0,0,0,0,70,14,16,0,0,0,0,0,2,64,0,0, +0,0,0,191,0,0,0,191,0,0,0,191,0,0,0,191, +62,0,0,1,83,84,65,84,116,0,0,0,3,0,0,0, +1,0,0,0,0,0,0,0,4,0,0,0,2,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,108,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +60,0,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,171,171,76,70,83,48,224,0,0,0,4,0,0,0, +8,0,0,0,200,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,217,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,219,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,1,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,221,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,2,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,67,111,109,98,77,117,108,65,100,100,83,105, +103,110,101,100,0,97,0,98,0,99,0,171,76,73,66,70, +152,2,0,0,68,88,66,67,104,50,51,52,155,142,16,144, +69,96,27,4,5,193,22,178,1,0,0,0,152,2,0,0, +6,0,0,0,56,0,0,0,136,0,0,0,228,0,0,0, +44,1,0,0,168,1,0,0,28,2,0,0,65,111,110,57, +72,0,0,0,72,0,0,0,0,2,86,76,36,0,0,0, +36,0,0,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,2,86,76,31,0,0,2, +5,0,0,128,0,0,15,144,2,0,0,3,0,0,15,224, +0,0,228,144,0,0,228,144,255,255,0,0,65,111,110,57, +84,0,0,0,84,0,0,0,0,2,80,76,48,0,0,0, +36,0,0,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,2,80,76,31,0,0,2, +0,0,0,128,0,0,15,176,2,0,0,3,0,0,15,128, +0,0,228,176,0,0,228,176,1,0,0,2,0,0,15,224, +0,0,228,128,255,255,0,0,83,72,68,82,64,0,0,0, +64,0,240,255,16,0,0,0,95,0,0,3,242,16,16,0, +0,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +0,0,0,7,242,32,16,0,0,0,0,0,70,30,16,0, +0,0,0,0,70,30,16,0,0,0,0,0,62,0,0,1, +83,84,65,84,116,0,0,0,2,0,0,0,0,0,0,0, +0,0,0,0,2,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,82,68,69,70, +108,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +60,0,0,0,0,4,70,76,0,129,0,0,60,0,0,0, +82,68,49,49,60,0,0,0,24,0,0,0,32,0,0,0, +40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0, +77,105,99,114,111,115,111,102,116,32,40,82,41,32,72,76, +83,76,32,83,104,97,100,101,114,32,67,111,109,112,105,108, +101,114,32,54,46,51,46,57,52,49,53,46,48,0,171,171, +76,70,83,48,116,0,0,0,2,0,0,0,8,0,0,0, +104,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,2,0,0,0, +255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0, +111,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +83,99,97,108,101,50,0,97,0,171,171,171,76,73,66,70, +212,2,0,0,68,88,66,67,57,34,29,67,178,80,106,40, +94,22,39,177,107,192,81,162,1,0,0,0,212,2,0,0, +6,0,0,0,56,0,0,0,160,0,0,0,20,1,0,0, +104,1,0,0,228,1,0,0,88,2,0,0,65,111,110,57, +96,0,0,0,96,0,0,0,0,2,86,76,60,0,0,0, +36,0,0,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,2,86,76,81,0,0,5, +0,0,15,160,0,0,128,64,0,0,0,0,0,0,0,0, +0,0,0,0,31,0,0,2,5,0,0,128,0,0,15,144, +5,0,0,3,0,0,15,224,0,0,228,144,0,0,0,160, +255,255,0,0,65,111,110,57,108,0,0,0,108,0,0,0, +0,2,80,76,72,0,0,0,36,0,0,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,2,80,76,81,0,0,5,0,0,15,160,0,0,128,64, +0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,2, +0,0,0,128,0,0,15,176,5,0,0,3,0,0,15,128, +0,0,228,176,0,0,0,160,1,0,0,2,0,0,15,224, +0,0,228,128,255,255,0,0,83,72,68,82,76,0,0,0, +64,0,240,255,19,0,0,0,95,0,0,3,242,16,16,0, +0,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +56,0,0,10,242,32,16,0,0,0,0,0,70,30,16,0, +0,0,0,0,2,64,0,0,0,0,128,64,0,0,128,64, +0,0,128,64,0,0,128,64,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,108,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,60,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,77,105,99,114, +111,115,111,102,116,32,40,82,41,32,72,76,83,76,32,83, +104,97,100,101,114,32,67,111,109,112,105,108,101,114,32,54, +46,51,46,57,52,49,53,46,48,0,171,171,76,70,83,48, +116,0,0,0,2,0,0,0,8,0,0,0,104,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,2,0,0,0,255,255,255,255, +255,255,255,255,0,0,0,0,0,0,0,0,111,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,83,99,97,108, +101,52,0,97,0,171,171,171,76,73,66,70,56,3,0,0, +68,88,66,67,20,232,184,35,253,143,9,50,109,2,17,57, +26,201,43,39,1,0,0,0,56,3,0,0,6,0,0,0, +56,0,0,0,172,0,0,0,44,1,0,0,148,1,0,0, +16,2,0,0,132,2,0,0,65,111,110,57,108,0,0,0, +108,0,0,0,0,2,86,76,72,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,86,76,31,0,0,2,5,0,0,128, +0,0,15,144,31,0,0,2,5,0,1,128,1,0,15,144, +1,0,0,2,0,0,7,128,0,0,228,144,2,0,0,3, +0,0,7,224,0,0,228,128,1,0,228,144,1,0,0,2, +0,0,8,224,0,0,255,144,255,255,0,0,65,111,110,57, +120,0,0,0,120,0,0,0,0,2,80,76,84,0,0,0, +36,0,0,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,2,80,76,31,0,0,2, +0,0,0,128,0,0,15,176,31,0,0,2,0,0,0,128, +1,0,7,176,1,0,0,2,0,0,7,128,0,0,228,176, +2,0,0,3,0,0,7,128,0,0,228,128,1,0,228,176, +1,0,0,2,0,0,8,128,0,0,255,176,1,0,0,2, +0,0,15,224,0,0,228,128,255,255,0,0,83,72,68,82, +96,0,0,0,64,0,240,255,24,0,0,0,95,0,0,3, +242,16,16,0,0,0,0,0,95,0,0,3,114,16,16,0, +1,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +0,0,0,7,114,32,16,0,0,0,0,0,70,18,16,0, +0,0,0,0,70,18,16,0,1,0,0,0,54,0,0,5, +130,32,16,0,0,0,0,0,58,16,16,0,0,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,3,0,0,0, +0,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,108,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +60,0,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,171,171,76,70,83,48,172,0,0,0,3,0,0,0, +8,0,0,0,152,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,160,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,164,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,1,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,65,100,100,83,112,101,99,0,99,111,108,0, +115,112,101,99,0,171,171,171,76,73,66,70,16,3,0,0, +68,88,66,67,32,99,27,168,13,179,154,91,100,39,27,10, +175,105,117,37,1,0,0,0,16,3,0,0,6,0,0,0, +56,0,0,0,156,0,0,0,12,1,0,0,108,1,0,0, +232,1,0,0,92,2,0,0,65,111,110,57,92,0,0,0, +92,0,0,0,0,2,86,76,56,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,86,76,31,0,0,2,5,0,0,128, +0,0,15,144,31,0,0,2,5,0,1,128,1,0,15,144, +1,0,0,2,0,0,7,224,0,0,228,144,1,0,0,2, +0,0,8,224,1,0,255,144,255,255,0,0,65,111,110,57, +104,0,0,0,104,0,0,0,0,2,80,76,68,0,0,0, +36,0,0,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,0,36,0,0,2,80,76,31,0,0,2, +0,0,0,128,0,0,7,176,31,0,0,2,0,0,0,128, +1,0,8,176,1,0,0,2,0,0,7,128,0,0,228,176, +1,0,0,2,0,0,8,128,1,0,255,176,1,0,0,2, +0,0,15,224,0,0,228,128,255,255,0,0,83,72,68,82, +88,0,0,0,64,0,240,255,22,0,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,95,0,0,3,130,16,16,0, +1,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +54,0,0,5,114,32,16,0,0,0,0,0,70,18,16,0, +0,0,0,0,54,0,0,5,130,32,16,0,0,0,0,0, +58,16,16,0,1,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,108,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,60,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,77,105,99,114, +111,115,111,102,116,32,40,82,41,32,72,76,83,76,32,83, +104,97,100,101,114,32,67,111,109,112,105,108,101,114,32,54, +46,51,46,57,52,49,53,46,48,0,171,171,76,70,83,48, +172,0,0,0,3,0,0,0,8,0,0,0,152,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,2,0,0,0,255,255,255,255, +255,255,255,255,0,0,0,0,0,0,0,0,165,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,167,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,67,111,109,98, +105,110,101,65,108,112,104,97,0,99,0,97,0,171,171,171, +76,73,66,70,240,7,0,0,68,88,66,67,140,46,150,255, +109,51,190,32,65,61,106,69,213,176,193,187,1,0,0,0, +240,7,0,0,6,0,0,0,56,0,0,0,248,0,0,0, +140,1,0,0,44,2,0,0,168,2,0,0,108,7,0,0, +65,111,110,57,184,0,0,0,184,0,0,0,0,2,86,76, +136,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,0,0,62,0, +1,0,0,0,0,0,0,0,0,2,86,76,81,0,0,5, +1,0,15,160,0,0,0,0,0,0,128,63,0,0,0,0, +0,0,0,0,31,0,0,2,5,0,0,128,0,0,15,144, +8,0,0,3,0,0,1,128,0,0,228,144,0,0,228,144, +7,0,0,2,0,0,1,128,0,0,0,128,6,0,0,2, +0,0,1,128,0,0,0,128,4,0,0,4,0,0,1,128, +0,0,0,128,0,0,170,160,0,0,255,160,11,0,0,3, +0,0,1,128,0,0,0,128,1,0,0,160,10,0,0,3, +0,0,1,224,0,0,0,128,1,0,85,160,255,255,0,0, +65,111,110,57,140,0,0,0,140,0,0,0,0,2,80,76, +92,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,0,0,62,0, +1,0,0,0,0,0,0,0,0,2,80,76,31,0,0,2, +0,0,0,128,0,0,7,176,8,0,0,3,0,0,8,128, +0,0,228,176,0,0,228,176,7,0,0,2,0,0,1,128, +0,0,255,128,6,0,0,2,0,0,1,128,0,0,0,128, +4,0,0,4,0,0,17,128,0,0,0,128,0,0,170,160, +0,0,255,160,1,0,0,2,0,0,1,224,0,0,0,128, +255,255,0,0,83,72,68,82,152,0,0,0,64,0,240,255, +38,0,0,0,89,0,0,4,70,142,32,0,0,0,0,0, +63,0,0,0,95,0,0,3,114,16,16,0,0,0,0,0, +101,0,0,3,18,32,16,0,0,0,0,0,104,0,0,2, +1,0,0,0,16,0,0,7,18,0,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,70,18,16,0,0,0,0,0, +75,0,0,5,18,0,16,0,0,0,0,0,10,0,16,0, +0,0,0,0,50,32,0,11,18,32,16,0,0,0,0,0, +10,0,16,0,0,0,0,0,42,128,32,0,0,0,0,0, +62,0,0,0,58,128,32,0,0,0,0,0,62,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,4,0,0,0, +1,0,0,0,0,0,0,0,2,0,0,0,3,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,188,4,0,0,1,0,0,0,108,0,0,0, +1,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +142,4,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,92,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,85,110,105,116,121,70,70,86,101,114,116,101, +120,0,171,171,92,0,0,0,14,0,0,0,132,0,0,0, +240,3,0,0,0,0,0,0,0,0,0,0,180,2,0,0, +0,0,0,0,64,0,0,0,0,0,0,0,204,2,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,240,2,0,0,64,0,0,0,64,0,0,0, +0,0,0,0,204,2,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,253,2,0,0, +128,0,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,56,3,0,0,144,0,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,71,3,0,0, +160,0,0,0,128,0,0,0,0,0,0,0,88,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,124,3,0,0,32,1,0,0,128,0,0,0, +0,0,0,0,140,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,176,3,0,0, +160,1,0,0,128,0,0,0,0,0,0,0,192,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,228,3,0,0,32,2,0,0,128,0,0,0, +0,0,0,0,244,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,24,4,0,0, +160,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,39,4,0,0,176,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,54,4,0,0, +192,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,66,4,0,0,208,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,82,4,0,0, +224,2,0,0,0,1,0,0,0,0,0,0,96,4,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,132,4,0,0,224,3,0,0,16,0,0,0, +2,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,102,102,95,109, +97,116,114,105,120,95,109,118,112,0,102,108,111,97,116,52, +120,52,0,171,3,0,3,0,4,0,4,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,194,2,0,0,102,102,95,109,97,116,114,105, +120,95,109,118,0,102,102,95,118,101,99,95,99,111,108,111, +114,0,102,108,111,97,116,52,0,171,171,171,1,0,3,0, +1,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,118,101,99,95,97,109,98,105,101,110,116,0,102, +102,95,108,105,103,104,116,95,99,111,108,111,114,0,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,112,111,115, +0,171,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,97,116,116,101,110,0,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,115,112,111,116,0,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,109,97,116,95,100,105,102,102,117,115,101,0,102, +102,95,109,97,116,95,97,109,98,105,101,110,116,0,102,102, +95,109,97,116,95,115,112,101,99,0,102,102,95,109,97,116, +95,101,109,105,115,115,105,111,110,0,102,102,95,109,97,116, +114,105,120,95,116,101,120,0,3,0,3,0,4,0,4,0, +4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,194,2,0,0,102,102,95,102, +111,103,95,118,115,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,124,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,114,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,70,111,103,76,105,110,101,97,114,0,101,121, +101,80,111,115,0,171,171,171,76,73,66,70,20,8,0,0, +68,88,66,67,214,169,140,84,231,146,163,76,182,11,101,69, +234,130,85,253,1,0,0,0,20,8,0,0,6,0,0,0, +56,0,0,0,240,0,0,0,140,1,0,0,84,2,0,0, +208,2,0,0,148,7,0,0,65,111,110,57,176,0,0,0, +176,0,0,0,0,2,86,76,128,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,0,0,62,0,1,0,0,0,0,0,0,0, +0,2,86,76,81,0,0,5,1,0,15,160,0,0,128,63, +0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,2, +5,0,0,128,0,0,15,144,8,0,0,3,0,0,1,128, +0,0,228,144,0,0,228,144,7,0,0,2,0,0,1,128, +0,0,0,128,6,0,0,2,0,0,1,128,0,0,0,128, +5,0,0,3,0,0,1,128,0,0,0,128,0,0,85,160, +14,0,0,2,0,0,1,128,0,0,0,129,10,0,0,3, +0,0,1,224,0,0,0,128,1,0,0,160,255,255,0,0, +65,111,110,57,148,0,0,0,148,0,0,0,0,2,80,76, +100,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,0,0,62,0, +1,0,0,0,0,0,0,0,0,2,80,76,31,0,0,2, +0,0,0,128,0,0,7,176,8,0,0,3,0,0,8,128, +0,0,228,176,0,0,228,176,7,0,0,2,0,0,1,128, +0,0,255,128,6,0,0,2,0,0,1,128,0,0,0,128, +5,0,0,3,0,0,1,128,0,0,0,128,0,0,85,160, +14,0,0,2,0,0,17,128,0,0,0,129,1,0,0,2, +0,0,1,224,0,0,0,128,255,255,0,0,83,72,68,82, +192,0,0,0,64,0,240,255,48,0,0,0,89,0,0,4, +70,142,32,0,0,0,0,0,63,0,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,18,32,16,0, +0,0,0,0,104,0,0,2,1,0,0,0,16,0,0,7, +18,0,16,0,0,0,0,0,70,18,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,75,0,0,5,18,0,16,0, +0,0,0,0,10,0,16,0,0,0,0,0,56,0,0,8, +18,0,16,0,0,0,0,0,10,0,16,0,0,0,0,0, +26,128,32,0,0,0,0,0,62,0,0,0,25,0,0,6, +18,0,16,0,0,0,0,0,10,0,16,128,65,0,0,0, +0,0,0,0,51,0,0,7,18,32,16,0,0,0,0,0, +10,0,16,0,0,0,0,0,1,64,0,0,0,0,128,63, +62,0,0,1,83,84,65,84,116,0,0,0,6,0,0,0, +1,0,0,0,0,0,0,0,2,0,0,0,5,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,188,4,0,0,1,0,0,0,108,0,0,0, +1,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +142,4,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,92,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,85,110,105,116,121,70,70,86,101,114,116,101, +120,0,171,171,92,0,0,0,14,0,0,0,132,0,0,0, +240,3,0,0,0,0,0,0,0,0,0,0,180,2,0,0, +0,0,0,0,64,0,0,0,0,0,0,0,204,2,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,240,2,0,0,64,0,0,0,64,0,0,0, +0,0,0,0,204,2,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,253,2,0,0, +128,0,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,56,3,0,0,144,0,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,71,3,0,0, +160,0,0,0,128,0,0,0,0,0,0,0,88,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,124,3,0,0,32,1,0,0,128,0,0,0, +0,0,0,0,140,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,176,3,0,0, +160,1,0,0,128,0,0,0,0,0,0,0,192,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,228,3,0,0,32,2,0,0,128,0,0,0, +0,0,0,0,244,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,24,4,0,0, +160,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,39,4,0,0,176,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,54,4,0,0, +192,2,0,0,16,0,0,0,0,0,0,0,20,3,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,66,4,0,0,208,2,0,0,16,0,0,0, +0,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,82,4,0,0, +224,2,0,0,0,1,0,0,0,0,0,0,96,4,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,132,4,0,0,224,3,0,0,16,0,0,0, +2,0,0,0,20,3,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,102,102,95,109, +97,116,114,105,120,95,109,118,112,0,102,108,111,97,116,52, +120,52,0,171,3,0,3,0,4,0,4,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,194,2,0,0,102,102,95,109,97,116,114,105, +120,95,109,118,0,102,102,95,118,101,99,95,99,111,108,111, +114,0,102,108,111,97,116,52,0,171,171,171,1,0,3,0, +1,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,118,101,99,95,97,109,98,105,101,110,116,0,102, +102,95,108,105,103,104,116,95,99,111,108,111,114,0,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,108,105,103,104,116,95,112,111,115, +0,171,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,97,116,116,101,110,0,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,115,112,111,116,0,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,109,97,116,95,100,105,102,102,117,115,101,0,102, +102,95,109,97,116,95,97,109,98,105,101,110,116,0,102,102, +95,109,97,116,95,115,112,101,99,0,102,102,95,109,97,116, +95,101,109,105,115,115,105,111,110,0,102,102,95,109,97,116, +114,105,120,95,116,101,120,0,3,0,3,0,4,0,4,0, +4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,194,2,0,0,102,102,95,102, +111,103,95,118,115,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,120,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,111,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,70,111,103,69,120,112,0,101,121,101,80,111, +115,0,171,171,76,73,66,70,12,8,0,0,68,88,66,67, +220,44,237,65,218,78,106,179,241,49,18,96,157,132,44,139, +1,0,0,0,12,8,0,0,6,0,0,0,56,0,0,0, +216,0,0,0,132,1,0,0,76,2,0,0,200,2,0,0, +140,7,0,0,65,111,110,57,152,0,0,0,152,0,0,0, +0,2,86,76,104,0,0,0,48,0,0,0,1,0,36,0, +0,0,48,0,0,0,48,0,0,0,36,0,0,0,48,0, +0,0,62,0,1,0,0,0,0,0,0,0,0,2,86,76, +31,0,0,2,5,0,0,128,0,0,15,144,8,0,0,3, +0,0,1,128,0,0,228,144,0,0,228,144,7,0,0,2, +0,0,1,128,0,0,0,128,6,0,0,2,0,0,1,128, +0,0,0,128,5,0,0,3,0,0,1,128,0,0,0,128, +0,0,85,160,5,0,0,3,0,0,1,128,0,0,0,128, +0,0,0,129,14,0,0,2,0,0,1,224,0,0,0,128, +255,255,0,0,65,111,110,57,164,0,0,0,164,0,0,0, +0,2,80,76,116,0,0,0,48,0,0,0,1,0,36,0, +0,0,48,0,0,0,48,0,0,0,36,0,0,0,48,0, +0,0,62,0,1,0,0,0,0,0,0,0,0,2,80,76, +31,0,0,2,0,0,0,128,0,0,7,176,8,0,0,3, +0,0,8,128,0,0,228,176,0,0,228,176,7,0,0,2, +0,0,1,128,0,0,255,128,6,0,0,2,0,0,1,128, +0,0,0,128,5,0,0,3,0,0,1,128,0,0,0,128, +0,0,85,160,5,0,0,3,0,0,1,128,0,0,0,128, +0,0,0,129,14,0,0,2,0,0,1,128,0,0,0,128, +1,0,0,2,0,0,1,224,0,0,0,128,255,255,0,0, +83,72,68,82,192,0,0,0,64,0,240,255,48,0,0,0, +89,0,0,4,70,142,32,0,0,0,0,0,63,0,0,0, +95,0,0,3,114,16,16,0,0,0,0,0,101,0,0,3, +18,32,16,0,0,0,0,0,104,0,0,2,1,0,0,0, +16,0,0,7,18,0,16,0,0,0,0,0,70,18,16,0, +0,0,0,0,70,18,16,0,0,0,0,0,75,0,0,5, +18,0,16,0,0,0,0,0,10,0,16,0,0,0,0,0, +56,0,0,8,18,0,16,0,0,0,0,0,10,0,16,0, +0,0,0,0,26,128,32,0,0,0,0,0,62,0,0,0, +56,0,0,8,18,0,16,0,0,0,0,0,10,0,16,0, +0,0,0,0,10,0,16,128,65,0,0,0,0,0,0,0, +25,0,0,5,18,32,16,0,0,0,0,0,10,0,16,0, +0,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +6,0,0,0,1,0,0,0,0,0,0,0,2,0,0,0, +5,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,188,4,0,0,1,0,0,0, +108,0,0,0,1,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,142,4,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,85,110,105,116,121,70,70,86, +101,114,116,101,120,0,171,171,92,0,0,0,14,0,0,0, +132,0,0,0,240,3,0,0,0,0,0,0,0,0,0,0, +180,2,0,0,0,0,0,0,64,0,0,0,0,0,0,0, +204,2,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,240,2,0,0,64,0,0,0, +64,0,0,0,0,0,0,0,204,2,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +253,2,0,0,128,0,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,56,3,0,0,144,0,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +71,3,0,0,160,0,0,0,128,0,0,0,0,0,0,0, +88,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,124,3,0,0,32,1,0,0, +128,0,0,0,0,0,0,0,140,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +176,3,0,0,160,1,0,0,128,0,0,0,0,0,0,0, +192,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,228,3,0,0,32,2,0,0, +128,0,0,0,0,0,0,0,244,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +24,4,0,0,160,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,39,4,0,0,176,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +54,4,0,0,192,2,0,0,16,0,0,0,0,0,0,0, +20,3,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,66,4,0,0,208,2,0,0, +16,0,0,0,0,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +82,4,0,0,224,2,0,0,0,1,0,0,0,0,0,0, +96,4,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,132,4,0,0,224,3,0,0, +16,0,0,0,2,0,0,0,20,3,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +102,102,95,109,97,116,114,105,120,95,109,118,112,0,102,108, +111,97,116,52,120,52,0,171,3,0,3,0,4,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,194,2,0,0,102,102,95,109, +97,116,114,105,120,95,109,118,0,102,102,95,118,101,99,95, +99,111,108,111,114,0,102,108,111,97,116,52,0,171,171,171, +1,0,3,0,1,0,4,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,118,101,99,95,97,109,98,105,101, +110,116,0,102,102,95,108,105,103,104,116,95,99,111,108,111, +114,0,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,3,0,0,102,102,95,108,105,103,104,116, +95,112,111,115,0,171,171,171,1,0,3,0,1,0,4,0, +8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,3,0,0,102,102,95,108, +105,103,104,116,95,97,116,116,101,110,0,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,3,0,0, +102,102,95,108,105,103,104,116,95,115,112,111,116,0,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,3,0,0,102,102,95,109,97,116,95,100,105,102,102,117, +115,101,0,102,102,95,109,97,116,95,97,109,98,105,101,110, +116,0,102,102,95,109,97,116,95,115,112,101,99,0,102,102, +95,109,97,116,95,101,109,105,115,115,105,111,110,0,102,102, +95,109,97,116,114,105,120,95,116,101,120,0,3,0,3,0, +4,0,4,0,4,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,194,2,0,0, +102,102,95,102,111,103,95,118,115,0,77,105,99,114,111,115, +111,102,116,32,40,82,41,32,72,76,83,76,32,83,104,97, +100,101,114,32,67,111,109,112,105,108,101,114,32,54,46,51, +46,57,52,49,53,46,48,0,76,70,83,48,120,0,0,0, +2,0,0,0,8,0,0,0,104,0,0,0,0,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,112,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,3,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,70,111,103,69,120,112,50,0, +101,121,101,80,111,115,0,171,76,73,66,70,12,5,0,0, +68,88,66,67,43,165,60,118,238,80,194,137,137,145,19,237, +8,42,67,215,1,0,0,0,12,5,0,0,6,0,0,0, +56,0,0,0,192,0,0,0,84,1,0,0,4,2,0,0, +128,2,0,0,88,4,0,0,65,111,110,57,128,0,0,0, +128,0,0,0,0,2,86,76,80,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,1,0,9,0,1,0,0,0,0,0,0,0, +0,2,86,76,31,0,0,2,5,0,0,128,0,0,15,144, +31,0,0,2,5,0,1,128,1,0,15,144,2,0,0,3, +0,0,7,128,0,0,228,144,0,0,228,161,4,0,0,4, +0,0,7,224,1,0,0,144,0,0,228,128,0,0,228,160, +1,0,0,2,0,0,8,224,0,0,255,144,255,255,0,0, +65,111,110,57,140,0,0,0,140,0,0,0,0,2,80,76, +92,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,1,0,9,0, +1,0,0,0,0,0,0,0,0,2,80,76,31,0,0,2, +0,0,0,128,0,0,15,176,31,0,0,2,0,0,0,128, +1,0,1,176,2,0,0,3,0,0,7,128,0,0,228,176, +0,0,228,161,4,0,0,4,0,0,7,128,1,0,0,176, +0,0,228,128,0,0,228,160,1,0,0,2,0,0,8,128, +0,0,255,176,1,0,0,2,0,0,15,224,0,0,228,128, +255,255,0,0,83,72,68,82,168,0,0,0,64,0,240,255, +42,0,0,0,89,0,0,4,70,142,32,0,1,0,0,0, +10,0,0,0,95,0,0,3,242,16,16,0,0,0,0,0, +95,0,0,3,18,16,16,0,1,0,0,0,101,0,0,3, +242,32,16,0,0,0,0,0,104,0,0,2,1,0,0,0, +0,0,0,9,114,0,16,0,0,0,0,0,70,18,16,0, +0,0,0,0,70,130,32,128,65,0,0,0,1,0,0,0, +9,0,0,0,50,0,0,10,114,32,16,0,0,0,0,0, +6,16,16,0,1,0,0,0,70,2,16,0,0,0,0,0, +70,130,32,0,1,0,0,0,9,0,0,0,54,0,0,5, +130,32,16,0,0,0,0,0,58,16,16,0,0,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,4,0,0,0, +1,0,0,0,0,0,0,0,3,0,0,0,2,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,208,1,0,0,1,0,0,0,108,0,0,0, +1,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +160,1,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,92,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,85,110,105,116,121,70,70,80,105,120,101,108, +0,171,171,171,92,0,0,0,3,0,0,0,132,0,0,0, +160,0,0,0,0,0,0,0,0,0,0,0,252,0,0,0, +0,0,0,0,128,0,0,0,0,0,0,0,20,1,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,56,1,0,0,128,0,0,0,4,0,0,0, +0,0,0,0,76,1,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,112,1,0,0, +144,0,0,0,16,0,0,0,2,0,0,0,124,1,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,102,102,95,118,101,99,95,99,111,108,111,114, +115,0,102,108,111,97,116,52,0,171,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,1,0,0, +102,102,95,97,108,112,104,97,95,114,101,102,0,102,108,111, +97,116,0,171,0,0,3,0,1,0,1,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,69,1,0,0,102,102,95,102,111,103,95,112, +115,0,171,171,1,0,3,0,1,0,4,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,1,0,0,77,105,99,114,111,115,111,102, +116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101, +114,32,67,111,109,112,105,108,101,114,32,54,46,51,46,57, +52,49,53,46,48,0,171,171,76,70,83,48,172,0,0,0, +3,0,0,0,8,0,0,0,152,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,161,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,165,0,0,0,0,0,0,0, +3,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,65,112,112,108,121,70,111,103, +0,99,111,108,0,105,102,111,103,0,171,171,76,73,66,70, +120,2,0,0,68,88,66,67,228,129,43,236,118,165,218,53, +151,25,162,98,135,202,141,31,1,0,0,0,120,2,0,0, +5,0,0,0,52,0,0,0,184,0,0,0,4,1,0,0, +128,1,0,0,244,1,0,0,65,111,110,57,124,0,0,0, +124,0,0,0,0,2,80,76,88,0,0,0,36,0,0,0, +0,0,36,0,0,0,36,0,0,0,36,0,0,0,36,0, +0,0,36,0,0,2,80,76,81,0,0,5,0,0,15,160, +0,0,128,191,0,0,0,0,0,0,0,0,0,0,0,0, +31,0,0,2,0,0,0,128,0,0,15,176,1,0,0,2, +0,0,15,128,0,0,0,160,65,0,0,1,0,0,15,128, +1,0,0,2,0,0,15,128,0,0,228,176,1,0,0,2, +0,0,15,224,0,0,228,128,255,255,0,0,83,72,68,82, +68,0,0,0,64,0,240,255,17,0,0,0,95,0,0,3, +242,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,13,0,4,3,1,64,0,0,255,255,255,255, +54,0,0,5,242,32,16,0,0,0,0,0,70,30,16,0, +0,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,108,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,60,0,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,77,105,99,114,111,115,111,102, +116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101, +114,32,67,111,109,112,105,108,101,114,32,54,46,51,46,57, +52,49,53,46,48,0,171,171,76,70,83,48,124,0,0,0, +2,0,0,0,8,0,0,0,104,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,119,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,65,108,112,104,97,84,101,115, +116,78,101,118,101,114,0,99,111,108,0,171,76,73,66,70, +56,4,0,0,68,88,66,67,217,165,212,19,118,106,154,93, +60,2,230,192,32,38,222,58,1,0,0,0,56,4,0,0, +5,0,0,0,52,0,0,0,220,0,0,0,96,1,0,0, +220,1,0,0,180,3,0,0,65,111,110,57,160,0,0,0, +160,0,0,0,0,2,80,76,112,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,1,0,8,0,1,0,0,0,0,0,0,0, +0,2,80,76,81,0,0,5,1,0,15,160,0,0,128,191, +0,0,0,128,0,0,0,0,0,0,0,0,31,0,0,2, +0,0,0,128,0,0,15,176,2,0,0,3,0,0,8,128, +0,0,255,176,0,0,0,161,88,0,0,4,0,0,15,128, +0,0,255,128,1,0,0,160,1,0,85,160,65,0,0,1, +0,0,15,128,1,0,0,2,0,0,15,128,0,0,228,176, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,124,0,0,0,64,0,240,255,31,0,0,0, +89,0,0,4,70,142,32,0,1,0,0,0,9,0,0,0, +95,0,0,3,242,16,16,0,0,0,0,0,101,0,0,3, +242,32,16,0,0,0,0,0,104,0,0,2,1,0,0,0, +29,0,0,8,18,0,16,0,0,0,0,0,58,16,16,0, +0,0,0,0,10,128,32,0,1,0,0,0,8,0,0,0, +13,0,4,3,10,0,16,0,0,0,0,0,54,0,0,5, +242,32,16,0,0,0,0,0,70,30,16,0,0,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,4,0,0,0, +1,0,0,0,0,0,0,0,2,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,208,1,0,0,1,0,0,0,108,0,0,0, +1,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +160,1,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,92,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,85,110,105,116,121,70,70,80,105,120,101,108, +0,171,171,171,92,0,0,0,3,0,0,0,132,0,0,0, +160,0,0,0,0,0,0,0,0,0,0,0,252,0,0,0, +0,0,0,0,128,0,0,0,0,0,0,0,20,1,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,56,1,0,0,128,0,0,0,4,0,0,0, +2,0,0,0,76,1,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,112,1,0,0, +144,0,0,0,16,0,0,0,0,0,0,0,124,1,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,102,102,95,118,101,99,95,99,111,108,111,114, +115,0,102,108,111,97,116,52,0,171,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,1,0,0, +102,102,95,97,108,112,104,97,95,114,101,102,0,102,108,111, +97,116,0,171,0,0,3,0,1,0,1,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,69,1,0,0,102,102,95,102,111,103,95,112, +115,0,171,171,1,0,3,0,1,0,4,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,1,0,0,77,105,99,114,111,115,111,102, +116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101, +114,32,67,111,109,112,105,108,101,114,32,54,46,51,46,57, +52,49,53,46,48,0,171,171,76,70,83,48,124,0,0,0, +2,0,0,0,8,0,0,0,104,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,118,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,65,108,112,104,97,84,101,115, +116,76,101,115,115,0,99,111,108,0,171,171,76,73,66,70, +72,4,0,0,68,88,66,67,9,212,183,148,40,9,204,128, +14,203,169,16,22,156,51,83,1,0,0,0,72,4,0,0, +5,0,0,0,52,0,0,0,236,0,0,0,112,1,0,0, +236,1,0,0,196,3,0,0,65,111,110,57,176,0,0,0, +176,0,0,0,0,2,80,76,128,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,1,0,8,0,1,0,0,0,0,0,0,0, +0,2,80,76,81,0,0,5,1,0,15,160,0,0,0,128, +0,0,128,191,0,0,0,0,0,0,0,0,31,0,0,2, +0,0,0,128,0,0,15,176,2,0,0,3,0,0,8,128, +0,0,255,176,0,0,0,161,5,0,0,3,0,0,1,128, +0,0,255,128,0,0,255,128,88,0,0,4,0,0,15,128, +0,0,0,129,1,0,0,160,1,0,85,160,65,0,0,1, +0,0,15,128,1,0,0,2,0,0,15,128,0,0,228,176, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,124,0,0,0,64,0,240,255,31,0,0,0, +89,0,0,4,70,142,32,0,1,0,0,0,9,0,0,0, +95,0,0,3,242,16,16,0,0,0,0,0,101,0,0,3, +242,32,16,0,0,0,0,0,104,0,0,2,1,0,0,0, +57,0,0,8,18,0,16,0,0,0,0,0,58,16,16,0, +0,0,0,0,10,128,32,0,1,0,0,0,8,0,0,0, +13,0,4,3,10,0,16,0,0,0,0,0,54,0,0,5, +242,32,16,0,0,0,0,0,70,30,16,0,0,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,4,0,0,0, +1,0,0,0,0,0,0,0,2,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,208,1,0,0,1,0,0,0,108,0,0,0, +1,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +160,1,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,92,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,85,110,105,116,121,70,70,80,105,120,101,108, +0,171,171,171,92,0,0,0,3,0,0,0,132,0,0,0, +160,0,0,0,0,0,0,0,0,0,0,0,252,0,0,0, +0,0,0,0,128,0,0,0,0,0,0,0,20,1,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,56,1,0,0,128,0,0,0,4,0,0,0, +2,0,0,0,76,1,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,112,1,0,0, +144,0,0,0,16,0,0,0,0,0,0,0,124,1,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,102,102,95,118,101,99,95,99,111,108,111,114, +115,0,102,108,111,97,116,52,0,171,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,1,0,0, +102,102,95,97,108,112,104,97,95,114,101,102,0,102,108,111, +97,116,0,171,0,0,3,0,1,0,1,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,69,1,0,0,102,102,95,102,111,103,95,112, +115,0,171,171,1,0,3,0,1,0,4,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,1,0,0,77,105,99,114,111,115,111,102, +116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101, +114,32,67,111,109,112,105,108,101,114,32,54,46,51,46,57, +52,49,53,46,48,0,171,171,76,70,83,48,124,0,0,0, +2,0,0,0,8,0,0,0,104,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,119,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,65,108,112,104,97,84,101,115, +116,69,113,117,97,108,0,99,111,108,0,171,76,73,66,70, +56,4,0,0,68,88,66,67,49,14,159,37,228,78,150,41, +132,60,204,137,11,50,70,216,1,0,0,0,56,4,0,0, +5,0,0,0,52,0,0,0,220,0,0,0,96,1,0,0, +220,1,0,0,180,3,0,0,65,111,110,57,160,0,0,0, +160,0,0,0,0,2,80,76,112,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,1,0,8,0,1,0,0,0,0,0,0,0, +0,2,80,76,81,0,0,5,1,0,15,160,0,0,0,128, +0,0,128,191,0,0,0,0,0,0,0,0,31,0,0,2, +0,0,0,128,0,0,15,176,2,0,0,3,0,0,8,128, +0,0,255,177,0,0,0,160,88,0,0,4,0,0,15,128, +0,0,255,128,1,0,0,160,1,0,85,160,65,0,0,1, +0,0,15,128,1,0,0,2,0,0,15,128,0,0,228,176, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,124,0,0,0,64,0,240,255,31,0,0,0, +89,0,0,4,70,142,32,0,1,0,0,0,9,0,0,0, +95,0,0,3,242,16,16,0,0,0,0,0,101,0,0,3, +242,32,16,0,0,0,0,0,104,0,0,2,1,0,0,0, +49,0,0,8,18,0,16,0,0,0,0,0,10,128,32,0, +1,0,0,0,8,0,0,0,58,16,16,0,0,0,0,0, +13,0,4,3,10,0,16,0,0,0,0,0,54,0,0,5, +242,32,16,0,0,0,0,0,70,30,16,0,0,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,4,0,0,0, +1,0,0,0,0,0,0,0,2,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,208,1,0,0,1,0,0,0,108,0,0,0, +1,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +160,1,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,92,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,85,110,105,116,121,70,70,80,105,120,101,108, +0,171,171,171,92,0,0,0,3,0,0,0,132,0,0,0, +160,0,0,0,0,0,0,0,0,0,0,0,252,0,0,0, +0,0,0,0,128,0,0,0,0,0,0,0,20,1,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,56,1,0,0,128,0,0,0,4,0,0,0, +2,0,0,0,76,1,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,112,1,0,0, +144,0,0,0,16,0,0,0,0,0,0,0,124,1,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,102,102,95,118,101,99,95,99,111,108,111,114, +115,0,102,108,111,97,116,52,0,171,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,1,0,0, +102,102,95,97,108,112,104,97,95,114,101,102,0,102,108,111, +97,116,0,171,0,0,3,0,1,0,1,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,69,1,0,0,102,102,95,102,111,103,95,112, +115,0,171,171,1,0,3,0,1,0,4,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,1,0,0,77,105,99,114,111,115,111,102, +116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101, +114,32,67,111,109,112,105,108,101,114,32,54,46,51,46,57, +52,49,53,46,48,0,171,171,76,70,83,48,124,0,0,0, +2,0,0,0,8,0,0,0,104,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,120,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,65,108,112,104,97,84,101,115, +116,76,69,113,117,97,108,0,99,111,108,0,76,73,66,70, +60,4,0,0,68,88,66,67,144,90,107,7,148,126,119,93, +47,65,200,242,161,144,148,20,1,0,0,0,60,4,0,0, +5,0,0,0,52,0,0,0,220,0,0,0,96,1,0,0, +220,1,0,0,180,3,0,0,65,111,110,57,160,0,0,0, +160,0,0,0,0,2,80,76,112,0,0,0,48,0,0,0, +1,0,36,0,0,0,48,0,0,0,48,0,0,0,36,0, +0,0,48,0,1,0,8,0,1,0,0,0,0,0,0,0, +0,2,80,76,81,0,0,5,1,0,15,160,0,0,128,191, +0,0,0,128,0,0,0,0,0,0,0,0,31,0,0,2, +0,0,0,128,0,0,15,176,2,0,0,3,0,0,8,128, +0,0,255,177,0,0,0,160,88,0,0,4,0,0,15,128, +0,0,255,128,1,0,0,160,1,0,85,160,65,0,0,1, +0,0,15,128,1,0,0,2,0,0,15,128,0,0,228,176, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,124,0,0,0,64,0,240,255,31,0,0,0, +89,0,0,4,70,142,32,0,1,0,0,0,9,0,0,0, +95,0,0,3,242,16,16,0,0,0,0,0,101,0,0,3, +242,32,16,0,0,0,0,0,104,0,0,2,1,0,0,0, +29,0,0,8,18,0,16,0,0,0,0,0,10,128,32,0, +1,0,0,0,8,0,0,0,58,16,16,0,0,0,0,0, +13,0,4,3,10,0,16,0,0,0,0,0,54,0,0,5, +242,32,16,0,0,0,0,0,70,30,16,0,0,0,0,0, +62,0,0,1,83,84,65,84,116,0,0,0,4,0,0,0, +1,0,0,0,0,0,0,0,2,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +82,68,69,70,208,1,0,0,1,0,0,0,108,0,0,0, +1,0,0,0,60,0,0,0,0,4,70,76,0,129,0,0, +160,1,0,0,82,68,49,49,60,0,0,0,24,0,0,0, +32,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0, +0,0,0,0,92,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0, +0,0,0,0,85,110,105,116,121,70,70,80,105,120,101,108, +0,171,171,171,92,0,0,0,3,0,0,0,132,0,0,0, +160,0,0,0,0,0,0,0,0,0,0,0,252,0,0,0, +0,0,0,0,128,0,0,0,0,0,0,0,20,1,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,56,1,0,0,128,0,0,0,4,0,0,0, +2,0,0,0,76,1,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,112,1,0,0, +144,0,0,0,16,0,0,0,0,0,0,0,124,1,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,102,102,95,118,101,99,95,99,111,108,111,114, +115,0,102,108,111,97,116,52,0,171,171,171,1,0,3,0, +1,0,4,0,8,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,1,0,0, +102,102,95,97,108,112,104,97,95,114,101,102,0,102,108,111, +97,116,0,171,0,0,3,0,1,0,1,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,69,1,0,0,102,102,95,102,111,103,95,112, +115,0,171,171,1,0,3,0,1,0,4,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,1,0,0,77,105,99,114,111,115,111,102, +116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101, +114,32,67,111,109,112,105,108,101,114,32,54,46,51,46,57, +52,49,53,46,48,0,171,171,76,70,83,48,128,0,0,0, +2,0,0,0,8,0,0,0,104,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,2,0,0,0,255,255,255,255,255,255,255,255, +0,0,0,0,0,0,0,0,121,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,4,0,0,0, +0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +255,255,255,255,255,255,255,255,65,108,112,104,97,84,101,115, +116,71,114,101,97,116,101,114,0,99,111,108,0,171,171,171, +76,73,66,70,76,4,0,0,68,88,66,67,197,56,7,226, +68,202,40,47,130,164,2,187,83,69,103,33,1,0,0,0, +76,4,0,0,5,0,0,0,52,0,0,0,236,0,0,0, +112,1,0,0,236,1,0,0,196,3,0,0,65,111,110,57, +176,0,0,0,176,0,0,0,0,2,80,76,128,0,0,0, +48,0,0,0,1,0,36,0,0,0,48,0,0,0,48,0, +0,0,36,0,0,0,48,0,1,0,8,0,1,0,0,0, +0,0,0,0,0,2,80,76,81,0,0,5,1,0,15,160, +0,0,128,191,0,0,0,128,0,0,0,0,0,0,0,0, +31,0,0,2,0,0,0,128,0,0,15,176,2,0,0,3, +0,0,8,128,0,0,255,176,0,0,0,161,5,0,0,3, +0,0,1,128,0,0,255,128,0,0,255,128,88,0,0,4, +0,0,15,128,0,0,0,129,1,0,0,160,1,0,85,160, +65,0,0,1,0,0,15,128,1,0,0,2,0,0,15,128, +0,0,228,176,1,0,0,2,0,0,15,224,0,0,228,128, +255,255,0,0,83,72,68,82,124,0,0,0,64,0,240,255, +31,0,0,0,89,0,0,4,70,142,32,0,1,0,0,0, +9,0,0,0,95,0,0,3,242,16,16,0,0,0,0,0, +101,0,0,3,242,32,16,0,0,0,0,0,104,0,0,2, +1,0,0,0,24,0,0,8,18,0,16,0,0,0,0,0, +58,16,16,0,0,0,0,0,10,128,32,0,1,0,0,0, +8,0,0,0,13,0,4,3,10,0,16,0,0,0,0,0, +54,0,0,5,242,32,16,0,0,0,0,0,70,30,16,0, +0,0,0,0,62,0,0,1,83,84,65,84,116,0,0,0, +4,0,0,0,1,0,0,0,0,0,0,0,2,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,82,68,69,70,208,1,0,0,1,0,0,0, +108,0,0,0,1,0,0,0,60,0,0,0,0,4,70,76, +0,129,0,0,160,1,0,0,82,68,49,49,60,0,0,0, +24,0,0,0,32,0,0,0,40,0,0,0,36,0,0,0, +12,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +1,0,0,0,0,0,0,0,85,110,105,116,121,70,70,80, +105,120,101,108,0,171,171,171,92,0,0,0,3,0,0,0, +132,0,0,0,160,0,0,0,0,0,0,0,0,0,0,0, +252,0,0,0,0,0,0,0,128,0,0,0,0,0,0,0, +20,1,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,56,1,0,0,128,0,0,0, +4,0,0,0,2,0,0,0,76,1,0,0,0,0,0,0, +255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0, +112,1,0,0,144,0,0,0,16,0,0,0,0,0,0,0, +124,1,0,0,0,0,0,0,255,255,255,255,0,0,0,0, +255,255,255,255,0,0,0,0,102,102,95,118,101,99,95,99, +111,108,111,114,115,0,102,108,111,97,116,52,0,171,171,171, +1,0,3,0,1,0,4,0,8,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +10,1,0,0,102,102,95,97,108,112,104,97,95,114,101,102, +0,102,108,111,97,116,0,171,0,0,3,0,1,0,1,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,69,1,0,0,102,102,95,102, +111,103,95,112,115,0,171,171,1,0,3,0,1,0,4,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,10,1,0,0,77,105,99,114, +111,115,111,102,116,32,40,82,41,32,72,76,83,76,32,83, +104,97,100,101,114,32,67,111,109,112,105,108,101,114,32,54, +46,51,46,57,52,49,53,46,48,0,171,171,76,70,83,48, +128,0,0,0,2,0,0,0,8,0,0,0,104,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,2,0,0,0,255,255,255,255, +255,255,255,255,0,0,0,0,0,0,0,0,122,0,0,0, +0,0,0,0,3,0,0,0,1,0,0,0,1,0,0,0, +4,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, +0,0,0,0,255,255,255,255,255,255,255,255,65,108,112,104, +97,84,101,115,116,78,111,116,69,113,117,97,108,0,99,111, +108,0,171,171,76,73,66,70,56,4,0,0,68,88,66,67, +115,13,35,167,25,6,43,221,107,197,197,253,203,93,251,92, +1,0,0,0,56,4,0,0,5,0,0,0,52,0,0,0, +220,0,0,0,96,1,0,0,220,1,0,0,180,3,0,0, +65,111,110,57,160,0,0,0,160,0,0,0,0,2,80,76, +112,0,0,0,48,0,0,0,1,0,36,0,0,0,48,0, +0,0,48,0,0,0,36,0,0,0,48,0,1,0,8,0, +1,0,0,0,0,0,0,0,0,2,80,76,81,0,0,5, +1,0,15,160,0,0,0,128,0,0,128,191,0,0,0,0, +0,0,0,0,31,0,0,2,0,0,0,128,0,0,15,176, +2,0,0,3,0,0,8,128,0,0,255,176,0,0,0,161, +88,0,0,4,0,0,15,128,0,0,255,128,1,0,0,160, +1,0,85,160,65,0,0,1,0,0,15,128,1,0,0,2, +0,0,15,128,0,0,228,176,1,0,0,2,0,0,15,224, +0,0,228,128,255,255,0,0,83,72,68,82,124,0,0,0, +64,0,240,255,31,0,0,0,89,0,0,4,70,142,32,0, +1,0,0,0,9,0,0,0,95,0,0,3,242,16,16,0, +0,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +104,0,0,2,1,0,0,0,49,0,0,8,18,0,16,0, +0,0,0,0,58,16,16,0,0,0,0,0,10,128,32,0, +1,0,0,0,8,0,0,0,13,0,4,3,10,0,16,0, +0,0,0,0,54,0,0,5,242,32,16,0,0,0,0,0, +70,30,16,0,0,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,4,0,0,0,1,0,0,0,0,0,0,0, +2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,208,1,0,0, +1,0,0,0,108,0,0,0,1,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,160,1,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,92,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,1,0,0,0,0,0,0,0,85,110,105,116, +121,70,70,80,105,120,101,108,0,171,171,171,92,0,0,0, +3,0,0,0,132,0,0,0,160,0,0,0,0,0,0,0, +0,0,0,0,252,0,0,0,0,0,0,0,128,0,0,0, +0,0,0,0,20,1,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,56,1,0,0, +128,0,0,0,4,0,0,0,2,0,0,0,76,1,0,0, +0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255, +0,0,0,0,112,1,0,0,144,0,0,0,16,0,0,0, +0,0,0,0,124,1,0,0,0,0,0,0,255,255,255,255, +0,0,0,0,255,255,255,255,0,0,0,0,102,102,95,118, +101,99,95,99,111,108,111,114,115,0,102,108,111,97,116,52, +0,171,171,171,1,0,3,0,1,0,4,0,8,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,10,1,0,0,102,102,95,97,108,112,104,97, +95,114,101,102,0,102,108,111,97,116,0,171,0,0,3,0, +1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,69,1,0,0, +102,102,95,102,111,103,95,112,115,0,171,171,1,0,3,0, +1,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,10,1,0,0, +77,105,99,114,111,115,111,102,116,32,40,82,41,32,72,76, +83,76,32,83,104,97,100,101,114,32,67,111,109,112,105,108, +101,114,32,54,46,51,46,57,52,49,53,46,48,0,171,171, +76,70,83,48,124,0,0,0,2,0,0,0,8,0,0,0, +104,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,2,0,0,0, +255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0, +120,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0, +1,0,0,0,4,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255, +65,108,112,104,97,84,101,115,116,71,69,113,117,97,108,0, +99,111,108,0,76,73,66,72,137,7,0,0,1,0,0,0, +164,2,0,0,0,0,0,0,82,0,0,0,20,0,0,0, +3,0,0,0,210,2,0,0,3,0,0,0,226,2,0,0, +3,0,0,0,249,2,0,0,3,0,0,0,4,3,0,0, +3,0,0,0,18,3,0,0,3,0,0,0,27,3,0,0, +3,0,0,0,39,3,0,0,3,0,0,0,51,3,0,0, +3,0,0,0,68,3,0,0,3,0,0,0,85,3,0,0, +3,0,0,0,103,3,0,0,3,0,0,0,118,3,0,0, +3,0,0,0,136,3,0,0,3,0,0,0,158,3,0,0, +3,0,0,0,176,3,0,0,3,0,0,0,198,3,0,0, +1,0,0,0,216,3,0,0,1,0,0,0,238,3,0,0, +1,0,0,0,0,4,0,0,1,0,0,0,22,4,0,0, +1,0,0,0,40,4,0,0,1,0,0,0,62,4,0,0, +1,0,0,0,80,4,0,0,1,0,0,0,102,4,0,0, +1,0,0,0,120,4,0,0,1,0,0,0,142,4,0,0, +1,0,0,0,160,4,0,0,1,0,0,0,182,4,0,0, +1,0,0,0,200,4,0,0,3,0,0,0,222,4,0,0, +3,0,0,0,240,4,0,0,3,0,0,0,0,5,0,0, +3,0,0,0,10,5,0,0,3,0,0,0,20,5,0,0, +3,0,0,0,26,5,0,0,3,0,0,0,39,5,0,0, +3,0,0,0,51,5,0,0,3,0,0,0,63,5,0,0, +3,0,0,0,75,5,0,0,3,0,0,0,87,5,0,0, +3,0,0,0,99,5,0,0,3,0,0,0,111,5,0,0, +3,0,0,0,123,5,0,0,3,0,0,0,135,5,0,0, +3,0,0,0,147,5,0,0,3,0,0,0,157,5,0,0, +3,0,0,0,176,5,0,0,3,0,0,0,195,5,0,0, +3,0,0,0,214,5,0,0,3,0,0,0,233,5,0,0, +3,0,0,0,252,5,0,0,3,0,0,0,15,6,0,0, +3,0,0,0,34,6,0,0,3,0,0,0,53,6,0,0, +3,0,0,0,63,6,0,0,3,0,0,0,73,6,0,0, +3,0,0,0,83,6,0,0,3,0,0,0,95,6,0,0, +3,0,0,0,108,6,0,0,3,0,0,0,116,6,0,0, +3,0,0,0,130,6,0,0,3,0,0,0,143,6,0,0, +3,0,0,0,152,6,0,0,3,0,0,0,161,6,0,0, +3,0,0,0,174,6,0,0,3,0,0,0,185,6,0,0, +3,0,0,0,196,6,0,0,3,0,0,0,213,6,0,0, +3,0,0,0,220,6,0,0,3,0,0,0,227,6,0,0, +3,0,0,0,235,6,0,0,3,0,0,0,248,6,0,0, +3,0,0,0,2,7,0,0,3,0,0,0,9,7,0,0, +3,0,0,0,17,7,0,0,2,0,0,0,26,7,0,0, +2,0,0,0,41,7,0,0,2,0,0,0,55,7,0,0, +2,0,0,0,70,7,0,0,2,0,0,0,86,7,0,0, +2,0,0,0,103,7,0,0,2,0,0,0,121,7,0,0, +77,105,99,114,111,115,111,102,116,32,40,82,41,32,72,76, +83,76,32,83,104,97,100,101,114,32,67,111,109,112,105,108, +101,114,32,54,46,51,46,57,52,49,53,46,48,0,76,111, +97,100,86,101,114,116,101,120,67,111,108,111,114,0,76,111, +97,100,86,101,114,116,101,120,67,111,108,111,114,85,110,105, +102,111,114,109,0,76,111,97,100,69,121,101,80,111,115,0, +76,111,97,100,69,121,101,78,111,114,109,97,108,0,76,111, +97,100,90,101,114,111,0,76,111,97,100,86,105,101,119,68, +105,114,0,76,111,97,100,69,121,101,82,101,102,108,0,76, +111,97,100,65,109,98,105,101,110,116,67,111,108,111,114,0, +76,111,97,100,68,105,102,102,117,115,101,67,111,108,111,114, +0,76,111,97,100,69,109,105,115,115,105,111,110,67,111,108, +111,114,0,73,110,105,116,76,105,103,104,116,67,111,108,111, +114,0,67,111,109,112,117,116,101,83,112,111,116,76,105,103, +104,116,48,0,67,111,109,112,117,116,101,83,112,111,116,76, +105,103,104,116,83,112,101,99,48,0,67,111,109,112,117,116, +101,83,112,111,116,76,105,103,104,116,49,0,67,111,109,112, +117,116,101,83,112,111,116,76,105,103,104,116,83,112,101,99, +49,0,67,111,109,112,117,116,101,83,112,111,116,76,105,103, +104,116,50,0,67,111,109,112,117,116,101,83,112,111,116,76, +105,103,104,116,83,112,101,99,50,0,67,111,109,112,117,116, +101,83,112,111,116,76,105,103,104,116,51,0,67,111,109,112, +117,116,101,83,112,111,116,76,105,103,104,116,83,112,101,99, +51,0,67,111,109,112,117,116,101,83,112,111,116,76,105,103, +104,116,52,0,67,111,109,112,117,116,101,83,112,111,116,76, +105,103,104,116,83,112,101,99,52,0,67,111,109,112,117,116, +101,83,112,111,116,76,105,103,104,116,53,0,67,111,109,112, +117,116,101,83,112,111,116,76,105,103,104,116,83,112,101,99, +53,0,67,111,109,112,117,116,101,83,112,111,116,76,105,103, +104,116,54,0,67,111,109,112,117,116,101,83,112,111,116,76, +105,103,104,116,83,112,101,99,54,0,67,111,109,112,117,116, +101,83,112,111,116,76,105,103,104,116,55,0,67,111,109,112, +117,116,101,83,112,111,116,76,105,103,104,116,83,112,101,99, +55,0,67,111,109,112,117,116,101,83,112,111,116,76,105,103, +104,116,56,0,67,111,109,112,117,116,101,83,112,111,116,76, +105,103,104,116,83,112,101,99,56,0,76,111,97,100,76,105, +103,104,116,105,110,103,67,111,108,111,114,0,84,114,97,110, +115,102,111,114,109,86,101,114,116,101,120,0,83,97,116,117, +114,97,116,101,52,0,83,97,116,117,114,97,116,101,51,0, +76,111,97,100,51,0,77,111,100,117,108,97,116,101,83,112, +101,99,0,77,117,108,116,105,112,108,121,85,86,48,0,77, +117,108,116,105,112,108,121,85,86,49,0,77,117,108,116,105, +112,108,121,85,86,50,0,77,117,108,116,105,112,108,121,85, +86,51,0,77,117,108,116,105,112,108,121,85,86,52,0,77, +117,108,116,105,112,108,121,85,86,53,0,77,117,108,116,105, +112,108,121,85,86,54,0,77,117,108,116,105,112,108,121,85, +86,55,0,85,86,83,112,104,101,114,101,77,97,112,0,70, +108,111,97,116,51,116,111,52,0,76,111,97,100,67,111,110, +115,116,97,110,116,67,111,108,111,114,48,0,76,111,97,100, +67,111,110,115,116,97,110,116,67,111,108,111,114,49,0,76, +111,97,100,67,111,110,115,116,97,110,116,67,111,108,111,114, +50,0,76,111,97,100,67,111,110,115,116,97,110,116,67,111, +108,111,114,51,0,76,111,97,100,67,111,110,115,116,97,110, +116,67,111,108,111,114,52,0,76,111,97,100,67,111,110,115, +116,97,110,116,67,111,108,111,114,53,0,76,111,97,100,67, +111,110,115,116,97,110,116,67,111,108,111,114,54,0,76,111, +97,100,67,111,110,115,116,97,110,116,67,111,108,111,114,55, +0,79,110,101,77,105,110,117,115,49,0,79,110,101,77,105, +110,117,115,51,0,79,110,101,77,105,110,117,115,52,0,67, +111,109,98,82,101,112,108,97,99,101,0,67,111,109,98,77, +111,100,117,108,97,116,101,0,67,111,109,98,65,100,100,0, +67,111,109,98,65,100,100,83,105,103,110,101,100,0,67,111, +109,98,83,117,98,116,114,97,99,116,0,67,111,109,98,76, +101,114,112,0,67,111,109,98,68,111,116,51,0,67,111,109, +98,68,111,116,51,114,103,98,97,0,67,111,109,98,77,117, +108,65,100,100,0,67,111,109,98,77,117,108,83,117,98,0, +67,111,109,98,77,117,108,65,100,100,83,105,103,110,101,100, +0,83,99,97,108,101,50,0,83,99,97,108,101,52,0,65, +100,100,83,112,101,99,0,67,111,109,98,105,110,101,65,108, +112,104,97,0,70,111,103,76,105,110,101,97,114,0,70,111, +103,69,120,112,0,70,111,103,69,120,112,50,0,65,112,112, +108,121,70,111,103,0,65,108,112,104,97,84,101,115,116,78, +101,118,101,114,0,65,108,112,104,97,84,101,115,116,76,101, +115,115,0,65,108,112,104,97,84,101,115,116,69,113,117,97, +108,0,65,108,112,104,97,84,101,115,116,76,69,113,117,97, +108,0,65,108,112,104,97,84,101,115,116,71,114,101,97,116, +101,114,0,65,108,112,104,97,84,101,115,116,78,111,116,69, +113,117,97,108,0,65,108,112,104,97,84,101,115,116,71,69, +113,117,97,108,0 +}; +const BYTE g_FFSampleTex2D0[] = { +68,88,66,67,186,190,133,217,122,113,117,157,223,22,77,225, +182,226,68,58,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,167,63,28,244,217,66,235,37,252,144,14,203, +197,4,28,142,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +0,0,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,3,176,31,0,0,2,0,0,0,144,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,0,0,0,0,88,24,0,4, +0,112,16,0,0,0,0,0,85,85,0,0,95,0,0,3, +50,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,16,16,0,0,0,0,0,70,126,16,0,0,0,0,0, +0,96,16,0,0,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,4,0,0,0,255,255,255,255, +0,0,0,0,1,0,0,0,13,0,0,0,83,109,112,48, +0,84,101,120,48,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,48,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,48,0 +}; +const BYTE g_FFSampleTex2D1[] = { +68,88,66,67,47,67,190,161,200,111,42,45,200,138,126,191, +157,88,130,65,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,254,4,120,248,75,193,95,168,115,4,59,237, +17,210,26,42,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +1,1,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,3,176,31,0,0,2,0,0,0,144,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,1,0,0,0,88,24,0,4, +0,112,16,0,1,0,0,0,85,85,0,0,95,0,0,3, +50,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,16,16,0,0,0,0,0,70,126,16,0,1,0,0,0, +0,96,16,0,1,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,4,0,0,0,255,255,255,255, +1,0,0,0,1,0,0,0,13,0,0,0,83,109,112,49, +0,84,101,120,49,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,49,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,49,0 +}; +const BYTE g_FFSampleTex2D2[] = { +68,88,66,67,180,208,133,71,201,51,63,167,99,13,252,147, +105,15,242,34,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,162,103,158,112,144,136,184,255,249,212,11,72, +140,25,192,113,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +2,2,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,3,176,31,0,0,2,0,0,0,144,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,2,0,0,0,88,24,0,4, +0,112,16,0,2,0,0,0,85,85,0,0,95,0,0,3, +50,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,16,16,0,0,0,0,0,70,126,16,0,2,0,0,0, +0,96,16,0,2,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,4,0,0,0,255,255,255,255, +2,0,0,0,1,0,0,0,13,0,0,0,83,109,112,50, +0,84,101,120,50,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,50,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,50,0 +}; +const BYTE g_FFSampleTex2D3[] = { +68,88,66,67,149,238,135,1,0,112,221,254,146,94,115,12, +68,5,172,135,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,196,71,209,198,86,237,243,139,237,193,9,14, +69,112,32,203,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +3,3,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,3,176,31,0,0,2,0,0,0,144,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,3,0,0,0,88,24,0,4, +0,112,16,0,3,0,0,0,85,85,0,0,95,0,0,3, +50,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,16,16,0,0,0,0,0,70,126,16,0,3,0,0,0, +0,96,16,0,3,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,4,0,0,0,255,255,255,255, +3,0,0,0,1,0,0,0,13,0,0,0,83,109,112,51, +0,84,101,120,51,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,51,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,51,0 +}; +const BYTE g_FFSampleTex2D4[] = { +68,88,66,67,1,143,168,112,164,72,178,93,61,206,79,16, +192,187,155,32,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,209,234,176,153,155,94,152,9,241,37,65,106, +131,216,55,96,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +4,4,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,3,176,31,0,0,2,0,0,0,144,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,4,0,0,0,88,24,0,4, +0,112,16,0,4,0,0,0,85,85,0,0,95,0,0,3, +50,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,16,16,0,0,0,0,0,70,126,16,0,4,0,0,0, +0,96,16,0,4,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +4,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,4,0,0,0,255,255,255,255, +4,0,0,0,1,0,0,0,13,0,0,0,83,109,112,52, +0,84,101,120,52,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,52,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,52,0 +}; +const BYTE g_FFSampleTex2D5[] = { +68,88,66,67,146,103,79,44,172,131,19,17,83,225,225,20, +193,21,8,43,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,121,249,154,239,231,85,182,236,126,123,45,2, +117,82,141,241,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +5,5,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,3,176,31,0,0,2,0,0,0,144,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,5,0,0,0,88,24,0,4, +0,112,16,0,5,0,0,0,85,85,0,0,95,0,0,3, +50,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,16,16,0,0,0,0,0,70,126,16,0,5,0,0,0, +0,96,16,0,5,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +5,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,4,0,0,0,255,255,255,255, +5,0,0,0,1,0,0,0,13,0,0,0,83,109,112,53, +0,84,101,120,53,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,53,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,53,0 +}; +const BYTE g_FFSampleTex2D6[] = { +68,88,66,67,240,29,95,192,17,112,54,92,138,198,156,88, +34,54,205,170,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,66,194,12,143,10,1,221,231,219,62,49,251, +254,63,175,14,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +6,6,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,3,176,31,0,0,2,0,0,0,144,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,6,0,0,0,88,24,0,4, +0,112,16,0,6,0,0,0,85,85,0,0,95,0,0,3, +50,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,16,16,0,0,0,0,0,70,126,16,0,6,0,0,0, +0,96,16,0,6,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +6,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,4,0,0,0,255,255,255,255, +6,0,0,0,1,0,0,0,13,0,0,0,83,109,112,54, +0,84,101,120,54,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,54,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,54,0 +}; +const BYTE g_FFSampleTex2D7[] = { +68,88,66,67,128,254,127,89,212,237,60,112,109,237,190,159, +68,41,91,237,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,26,171,200,29,118,90,223,37,168,34,191,21, +246,151,59,230,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +7,7,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,3,176,31,0,0,2,0,0,0,144,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,7,0,0,0,88,24,0,4, +0,112,16,0,7,0,0,0,85,85,0,0,95,0,0,3, +50,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,16,16,0,0,0,0,0,70,126,16,0,7,0,0,0, +0,96,16,0,7,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +7,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,4,0,0,0,255,255,255,255, +7,0,0,0,1,0,0,0,13,0,0,0,83,109,112,55, +0,84,101,120,55,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,55,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,55,0 +}; +const BYTE g_FFSampleTexProj0[] = { +68,88,66,67,237,34,106,171,253,60,160,245,196,118,246,108, +124,200,6,0,1,0,0,0,139,3,0,0,2,0,0,0, +40,0,0,0,48,3,0,0,76,73,66,70,0,3,0,0, +68,88,66,67,230,60,101,10,132,76,15,42,191,248,157,64, +112,9,91,75,1,0,0,0,0,3,0,0,5,0,0,0, +52,0,0,0,188,0,0,0,76,1,0,0,200,1,0,0, +132,2,0,0,65,111,110,57,128,0,0,0,128,0,0,0, +0,2,80,76,88,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +0,0,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,11,176,31,0,0,2,0,0,0,144,0,8,15,160, +6,0,0,2,0,0,8,128,0,0,255,176,5,0,0,3, +0,0,3,128,0,0,255,128,0,0,228,176,66,0,0,3, +0,0,15,128,0,0,228,128,0,8,228,160,1,0,0,2, +0,0,15,224,0,0,228,128,255,255,0,0,83,72,68,82, +136,0,0,0,64,0,240,255,34,0,0,0,90,0,0,3, +0,96,16,0,0,0,0,0,88,24,0,4,0,112,16,0, +0,0,0,0,85,85,0,0,95,0,0,3,178,16,16,0, +0,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +104,0,0,2,1,0,0,0,14,0,0,7,50,0,16,0, +0,0,0,0,70,16,16,0,0,0,0,0,246,31,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,0,16,0,0,0,0,0,70,126,16,0,0,0,0,0, +0,96,16,0,0,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,3,0,0,0,1,0,0,0,0,0,0,0, +2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,4,0,0,0,255,255,255,255, +0,0,0,0,1,0,0,0,13,0,0,0,83,109,112,48, +0,84,101,120,48,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,48,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,48,0 +}; +const BYTE g_FFSampleTexProj1[] = { +68,88,66,67,4,136,237,251,219,54,28,116,17,188,142,117, +202,37,0,216,1,0,0,0,139,3,0,0,2,0,0,0, +40,0,0,0,48,3,0,0,76,73,66,70,0,3,0,0, +68,88,66,67,227,64,211,49,27,178,55,234,32,218,202,171, +120,32,81,116,1,0,0,0,0,3,0,0,5,0,0,0, +52,0,0,0,188,0,0,0,76,1,0,0,200,1,0,0, +132,2,0,0,65,111,110,57,128,0,0,0,128,0,0,0, +0,2,80,76,88,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +1,1,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,11,176,31,0,0,2,0,0,0,144,0,8,15,160, +6,0,0,2,0,0,8,128,0,0,255,176,5,0,0,3, +0,0,3,128,0,0,255,128,0,0,228,176,66,0,0,3, +0,0,15,128,0,0,228,128,0,8,228,160,1,0,0,2, +0,0,15,224,0,0,228,128,255,255,0,0,83,72,68,82, +136,0,0,0,64,0,240,255,34,0,0,0,90,0,0,3, +0,96,16,0,1,0,0,0,88,24,0,4,0,112,16,0, +1,0,0,0,85,85,0,0,95,0,0,3,178,16,16,0, +0,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +104,0,0,2,1,0,0,0,14,0,0,7,50,0,16,0, +0,0,0,0,70,16,16,0,0,0,0,0,246,31,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,0,16,0,0,0,0,0,70,126,16,0,1,0,0,0, +0,96,16,0,1,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,3,0,0,0,1,0,0,0,0,0,0,0, +2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,4,0,0,0,255,255,255,255, +1,0,0,0,1,0,0,0,13,0,0,0,83,109,112,49, +0,84,101,120,49,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,49,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,49,0 +}; +const BYTE g_FFSampleTexProj2[] = { +68,88,66,67,2,30,122,43,115,147,198,113,36,147,136,65, +91,229,165,118,1,0,0,0,139,3,0,0,2,0,0,0, +40,0,0,0,48,3,0,0,76,73,66,70,0,3,0,0, +68,88,66,67,158,195,81,208,65,178,14,56,95,97,26,50, +228,55,13,138,1,0,0,0,0,3,0,0,5,0,0,0, +52,0,0,0,188,0,0,0,76,1,0,0,200,1,0,0, +132,2,0,0,65,111,110,57,128,0,0,0,128,0,0,0, +0,2,80,76,88,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +2,2,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,11,176,31,0,0,2,0,0,0,144,0,8,15,160, +6,0,0,2,0,0,8,128,0,0,255,176,5,0,0,3, +0,0,3,128,0,0,255,128,0,0,228,176,66,0,0,3, +0,0,15,128,0,0,228,128,0,8,228,160,1,0,0,2, +0,0,15,224,0,0,228,128,255,255,0,0,83,72,68,82, +136,0,0,0,64,0,240,255,34,0,0,0,90,0,0,3, +0,96,16,0,2,0,0,0,88,24,0,4,0,112,16,0, +2,0,0,0,85,85,0,0,95,0,0,3,178,16,16,0, +0,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +104,0,0,2,1,0,0,0,14,0,0,7,50,0,16,0, +0,0,0,0,70,16,16,0,0,0,0,0,246,31,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,0,16,0,0,0,0,0,70,126,16,0,2,0,0,0, +0,96,16,0,2,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,3,0,0,0,1,0,0,0,0,0,0,0, +2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,4,0,0,0,255,255,255,255, +2,0,0,0,1,0,0,0,13,0,0,0,83,109,112,50, +0,84,101,120,50,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,50,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,50,0 +}; +const BYTE g_FFSampleTexProj3[] = { +68,88,66,67,198,103,138,26,135,26,62,28,241,113,110,230, +103,182,28,127,1,0,0,0,139,3,0,0,2,0,0,0, +40,0,0,0,48,3,0,0,76,73,66,70,0,3,0,0, +68,88,66,67,190,50,195,62,15,53,121,224,115,82,118,6, +11,177,14,169,1,0,0,0,0,3,0,0,5,0,0,0, +52,0,0,0,188,0,0,0,76,1,0,0,200,1,0,0, +132,2,0,0,65,111,110,57,128,0,0,0,128,0,0,0, +0,2,80,76,88,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +3,3,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,11,176,31,0,0,2,0,0,0,144,0,8,15,160, +6,0,0,2,0,0,8,128,0,0,255,176,5,0,0,3, +0,0,3,128,0,0,255,128,0,0,228,176,66,0,0,3, +0,0,15,128,0,0,228,128,0,8,228,160,1,0,0,2, +0,0,15,224,0,0,228,128,255,255,0,0,83,72,68,82, +136,0,0,0,64,0,240,255,34,0,0,0,90,0,0,3, +0,96,16,0,3,0,0,0,88,24,0,4,0,112,16,0, +3,0,0,0,85,85,0,0,95,0,0,3,178,16,16,0, +0,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +104,0,0,2,1,0,0,0,14,0,0,7,50,0,16,0, +0,0,0,0,70,16,16,0,0,0,0,0,246,31,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,0,16,0,0,0,0,0,70,126,16,0,3,0,0,0, +0,96,16,0,3,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,3,0,0,0,1,0,0,0,0,0,0,0, +2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,4,0,0,0,255,255,255,255, +3,0,0,0,1,0,0,0,13,0,0,0,83,109,112,51, +0,84,101,120,51,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,51,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,51,0 +}; +const BYTE g_FFSampleTexProj4[] = { +68,88,66,67,214,247,95,61,160,17,24,2,54,171,136,221, +162,93,207,123,1,0,0,0,139,3,0,0,2,0,0,0, +40,0,0,0,48,3,0,0,76,73,66,70,0,3,0,0, +68,88,66,67,230,212,227,79,165,100,103,2,70,84,103,231, +199,191,4,95,1,0,0,0,0,3,0,0,5,0,0,0, +52,0,0,0,188,0,0,0,76,1,0,0,200,1,0,0, +132,2,0,0,65,111,110,57,128,0,0,0,128,0,0,0, +0,2,80,76,88,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +4,4,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,11,176,31,0,0,2,0,0,0,144,0,8,15,160, +6,0,0,2,0,0,8,128,0,0,255,176,5,0,0,3, +0,0,3,128,0,0,255,128,0,0,228,176,66,0,0,3, +0,0,15,128,0,0,228,128,0,8,228,160,1,0,0,2, +0,0,15,224,0,0,228,128,255,255,0,0,83,72,68,82, +136,0,0,0,64,0,240,255,34,0,0,0,90,0,0,3, +0,96,16,0,4,0,0,0,88,24,0,4,0,112,16,0, +4,0,0,0,85,85,0,0,95,0,0,3,178,16,16,0, +0,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +104,0,0,2,1,0,0,0,14,0,0,7,50,0,16,0, +0,0,0,0,70,16,16,0,0,0,0,0,246,31,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,0,16,0,0,0,0,0,70,126,16,0,4,0,0,0, +0,96,16,0,4,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,3,0,0,0,1,0,0,0,0,0,0,0, +2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +4,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,4,0,0,0,255,255,255,255, +4,0,0,0,1,0,0,0,13,0,0,0,83,109,112,52, +0,84,101,120,52,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,52,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,52,0 +}; +const BYTE g_FFSampleTexProj5[] = { +68,88,66,67,66,189,97,195,183,152,219,151,58,228,33,211, +23,65,5,98,1,0,0,0,139,3,0,0,2,0,0,0, +40,0,0,0,48,3,0,0,76,73,66,70,0,3,0,0, +68,88,66,67,161,32,90,6,181,122,141,232,231,32,178,86, +153,147,189,100,1,0,0,0,0,3,0,0,5,0,0,0, +52,0,0,0,188,0,0,0,76,1,0,0,200,1,0,0, +132,2,0,0,65,111,110,57,128,0,0,0,128,0,0,0, +0,2,80,76,88,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +5,5,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,11,176,31,0,0,2,0,0,0,144,0,8,15,160, +6,0,0,2,0,0,8,128,0,0,255,176,5,0,0,3, +0,0,3,128,0,0,255,128,0,0,228,176,66,0,0,3, +0,0,15,128,0,0,228,128,0,8,228,160,1,0,0,2, +0,0,15,224,0,0,228,128,255,255,0,0,83,72,68,82, +136,0,0,0,64,0,240,255,34,0,0,0,90,0,0,3, +0,96,16,0,5,0,0,0,88,24,0,4,0,112,16,0, +5,0,0,0,85,85,0,0,95,0,0,3,178,16,16,0, +0,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +104,0,0,2,1,0,0,0,14,0,0,7,50,0,16,0, +0,0,0,0,70,16,16,0,0,0,0,0,246,31,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,0,16,0,0,0,0,0,70,126,16,0,5,0,0,0, +0,96,16,0,5,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,3,0,0,0,1,0,0,0,0,0,0,0, +2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +5,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,4,0,0,0,255,255,255,255, +5,0,0,0,1,0,0,0,13,0,0,0,83,109,112,53, +0,84,101,120,53,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,53,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,53,0 +}; +const BYTE g_FFSampleTexProj6[] = { +68,88,66,67,153,221,7,160,36,89,179,148,98,194,126,246, +177,187,106,246,1,0,0,0,139,3,0,0,2,0,0,0, +40,0,0,0,48,3,0,0,76,73,66,70,0,3,0,0, +68,88,66,67,46,167,174,151,195,138,31,77,170,240,199,31, +49,127,212,92,1,0,0,0,0,3,0,0,5,0,0,0, +52,0,0,0,188,0,0,0,76,1,0,0,200,1,0,0, +132,2,0,0,65,111,110,57,128,0,0,0,128,0,0,0, +0,2,80,76,88,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +6,6,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,11,176,31,0,0,2,0,0,0,144,0,8,15,160, +6,0,0,2,0,0,8,128,0,0,255,176,5,0,0,3, +0,0,3,128,0,0,255,128,0,0,228,176,66,0,0,3, +0,0,15,128,0,0,228,128,0,8,228,160,1,0,0,2, +0,0,15,224,0,0,228,128,255,255,0,0,83,72,68,82, +136,0,0,0,64,0,240,255,34,0,0,0,90,0,0,3, +0,96,16,0,6,0,0,0,88,24,0,4,0,112,16,0, +6,0,0,0,85,85,0,0,95,0,0,3,178,16,16,0, +0,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +104,0,0,2,1,0,0,0,14,0,0,7,50,0,16,0, +0,0,0,0,70,16,16,0,0,0,0,0,246,31,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,0,16,0,0,0,0,0,70,126,16,0,6,0,0,0, +0,96,16,0,6,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,3,0,0,0,1,0,0,0,0,0,0,0, +2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +6,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,4,0,0,0,255,255,255,255, +6,0,0,0,1,0,0,0,13,0,0,0,83,109,112,54, +0,84,101,120,54,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,54,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,54,0 +}; +const BYTE g_FFSampleTexProj7[] = { +68,88,66,67,54,198,9,208,91,47,140,152,149,52,162,217, +161,54,143,152,1,0,0,0,139,3,0,0,2,0,0,0, +40,0,0,0,48,3,0,0,76,73,66,70,0,3,0,0, +68,88,66,67,2,126,106,25,61,155,75,228,172,90,27,233, +211,161,173,74,1,0,0,0,0,3,0,0,5,0,0,0, +52,0,0,0,188,0,0,0,76,1,0,0,200,1,0,0, +132,2,0,0,65,111,110,57,128,0,0,0,128,0,0,0, +0,2,80,76,88,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +7,7,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,11,176,31,0,0,2,0,0,0,144,0,8,15,160, +6,0,0,2,0,0,8,128,0,0,255,176,5,0,0,3, +0,0,3,128,0,0,255,128,0,0,228,176,66,0,0,3, +0,0,15,128,0,0,228,128,0,8,228,160,1,0,0,2, +0,0,15,224,0,0,228,128,255,255,0,0,83,72,68,82, +136,0,0,0,64,0,240,255,34,0,0,0,90,0,0,3, +0,96,16,0,7,0,0,0,88,24,0,4,0,112,16,0, +7,0,0,0,85,85,0,0,95,0,0,3,178,16,16,0, +0,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0, +104,0,0,2,1,0,0,0,14,0,0,7,50,0,16,0, +0,0,0,0,70,16,16,0,0,0,0,0,246,31,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,0,16,0,0,0,0,0,70,126,16,0,7,0,0,0, +0,96,16,0,7,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,3,0,0,0,1,0,0,0,0,0,0,0, +2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +7,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,4,0,0,0,255,255,255,255, +7,0,0,0,1,0,0,0,13,0,0,0,83,109,112,55, +0,84,101,120,55,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,55,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,55,0 +}; +const BYTE g_FFSampleTex3D0[] = { +68,88,66,67,206,176,17,24,163,228,56,124,213,217,89,247, +168,217,106,41,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,14,80,190,175,153,165,204,147,108,17,98,29, +189,179,225,238,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +0,0,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,31,0,0,2,0,0,0,160,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,0,0,0,0,88,40,0,4, +0,112,16,0,0,0,0,0,85,85,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,70,126,16,0,0,0,0,0, +0,96,16,0,0,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,8,0,0,0,255,255,255,255, +0,0,0,0,1,0,0,0,13,0,0,0,83,109,112,48, +0,84,101,120,48,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,48,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,48,0 +}; +const BYTE g_FFSampleTex3D1[] = { +68,88,66,67,54,231,211,65,158,32,30,68,185,17,249,76, +2,7,22,248,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,171,59,174,152,183,87,216,198,114,154,0,113, +150,163,208,243,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +1,1,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,31,0,0,2,0,0,0,160,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,1,0,0,0,88,40,0,4, +0,112,16,0,1,0,0,0,85,85,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,70,126,16,0,1,0,0,0, +0,96,16,0,1,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,8,0,0,0,255,255,255,255, +1,0,0,0,1,0,0,0,13,0,0,0,83,109,112,49, +0,84,101,120,49,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,49,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,49,0 +}; +const BYTE g_FFSampleTex3D2[] = { +68,88,66,67,153,118,160,252,192,90,141,221,27,255,54,21, +121,98,195,236,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,201,9,226,184,184,198,44,161,181,91,189,22, +164,160,102,27,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +2,2,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,31,0,0,2,0,0,0,160,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,2,0,0,0,88,40,0,4, +0,112,16,0,2,0,0,0,85,85,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,70,126,16,0,2,0,0,0, +0,96,16,0,2,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,8,0,0,0,255,255,255,255, +2,0,0,0,1,0,0,0,13,0,0,0,83,109,112,50, +0,84,101,120,50,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,50,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,50,0 +}; +const BYTE g_FFSampleTex3D3[] = { +68,88,66,67,115,199,248,60,148,239,79,221,248,116,74,189, +183,197,234,230,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,184,154,16,255,1,250,209,159,118,180,70,123, +159,161,218,107,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +3,3,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,31,0,0,2,0,0,0,160,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,3,0,0,0,88,40,0,4, +0,112,16,0,3,0,0,0,85,85,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,70,126,16,0,3,0,0,0, +0,96,16,0,3,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,8,0,0,0,255,255,255,255, +3,0,0,0,1,0,0,0,13,0,0,0,83,109,112,51, +0,84,101,120,51,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,51,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,51,0 +}; +const BYTE g_FFSampleTex3D4[] = { +68,88,66,67,175,88,14,186,68,209,197,62,115,210,225,43, +70,17,156,98,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,141,231,106,237,112,235,84,199,112,98,106,110, +179,136,3,131,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +4,4,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,31,0,0,2,0,0,0,160,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,4,0,0,0,88,40,0,4, +0,112,16,0,4,0,0,0,85,85,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,70,126,16,0,4,0,0,0, +0,96,16,0,4,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +4,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,8,0,0,0,255,255,255,255, +4,0,0,0,1,0,0,0,13,0,0,0,83,109,112,52, +0,84,101,120,52,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,52,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,52,0 +}; +const BYTE g_FFSampleTex3D5[] = { +68,88,66,67,21,86,181,156,18,14,15,61,232,192,100,191, +113,227,128,184,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,175,14,52,173,92,80,63,137,150,55,52,202, +102,138,186,177,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +5,5,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,31,0,0,2,0,0,0,160,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,5,0,0,0,88,40,0,4, +0,112,16,0,5,0,0,0,85,85,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,70,126,16,0,5,0,0,0, +0,96,16,0,5,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +5,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,8,0,0,0,255,255,255,255, +5,0,0,0,1,0,0,0,13,0,0,0,83,109,112,53, +0,84,101,120,53,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,53,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,53,0 +}; +const BYTE g_FFSampleTex3D6[] = { +68,88,66,67,238,177,249,89,9,22,115,2,214,9,191,51, +202,23,0,173,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,213,181,254,210,42,235,198,99,147,100,249,38, +66,54,186,94,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +6,6,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,31,0,0,2,0,0,0,160,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,6,0,0,0,88,40,0,4, +0,112,16,0,6,0,0,0,85,85,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,70,126,16,0,6,0,0,0, +0,96,16,0,6,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +6,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,8,0,0,0,255,255,255,255, +6,0,0,0,1,0,0,0,13,0,0,0,83,109,112,54, +0,84,101,120,54,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,54,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,54,0 +}; +const BYTE g_FFSampleTex3D7[] = { +68,88,66,67,125,134,173,155,128,60,127,159,47,32,107,157, +237,228,160,55,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,207,197,246,6,50,87,29,171,224,83,43,237, +229,87,179,100,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +7,7,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,31,0,0,2,0,0,0,160,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,7,0,0,0,88,40,0,4, +0,112,16,0,7,0,0,0,85,85,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,70,126,16,0,7,0,0,0, +0,96,16,0,7,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +7,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,8,0,0,0,255,255,255,255, +7,0,0,0,1,0,0,0,13,0,0,0,83,109,112,55, +0,84,101,120,55,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,55,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,55,0 +}; +const BYTE g_FFSampleTexCube0[] = { +68,88,66,67,33,244,32,125,20,149,175,63,113,66,150,137, +236,158,74,161,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,113,62,226,192,223,150,191,199,17,37,188,138, +110,126,21,124,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +0,0,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,31,0,0,2,0,0,0,152,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,0,0,0,0,88,48,0,4, +0,112,16,0,0,0,0,0,85,85,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,70,126,16,0,0,0,0,0, +0,96,16,0,0,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,9,0,0,0,255,255,255,255, +0,0,0,0,1,0,0,0,13,0,0,0,83,109,112,48, +0,84,101,120,48,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,48,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,48,0 +}; +const BYTE g_FFSampleTexCube1[] = { +68,88,66,67,22,79,13,114,141,19,54,166,178,73,140,214, +63,36,100,186,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,70,89,149,240,122,13,155,26,14,223,34,217, +148,48,93,72,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +1,1,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,31,0,0,2,0,0,0,152,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,1,0,0,0,88,48,0,4, +0,112,16,0,1,0,0,0,85,85,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,70,126,16,0,1,0,0,0, +0,96,16,0,1,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,9,0,0,0,255,255,255,255, +1,0,0,0,1,0,0,0,13,0,0,0,83,109,112,49, +0,84,101,120,49,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,49,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,49,0 +}; +const BYTE g_FFSampleTexCube2[] = { +68,88,66,67,7,165,35,142,143,214,18,167,193,132,142,213, +160,150,93,133,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,98,252,179,13,153,4,140,224,14,185,204,193, +153,209,189,169,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +2,2,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,31,0,0,2,0,0,0,152,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,2,0,0,0,88,48,0,4, +0,112,16,0,2,0,0,0,85,85,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,70,126,16,0,2,0,0,0, +0,96,16,0,2,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,9,0,0,0,255,255,255,255, +2,0,0,0,1,0,0,0,13,0,0,0,83,109,112,50, +0,84,101,120,50,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,50,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,50,0 +}; +const BYTE g_FFSampleTexCube3[] = { +68,88,66,67,70,205,12,245,181,82,205,63,112,32,70,85, +27,139,180,41,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,180,171,156,216,69,235,175,170,109,153,73,113, +56,216,63,162,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +3,3,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,31,0,0,2,0,0,0,152,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,3,0,0,0,88,48,0,4, +0,112,16,0,3,0,0,0,85,85,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,70,126,16,0,3,0,0,0, +0,96,16,0,3,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +3,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,9,0,0,0,255,255,255,255, +3,0,0,0,1,0,0,0,13,0,0,0,83,109,112,51, +0,84,101,120,51,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,51,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,51,0 +}; +const BYTE g_FFSampleTexCube4[] = { +68,88,66,67,135,31,144,5,60,204,204,187,32,54,117,90, +26,33,4,165,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,221,103,249,252,98,213,207,165,83,169,29,179, +159,36,23,98,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +4,4,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,31,0,0,2,0,0,0,152,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,4,0,0,0,88,48,0,4, +0,112,16,0,4,0,0,0,85,85,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,70,126,16,0,4,0,0,0, +0,96,16,0,4,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +4,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,9,0,0,0,255,255,255,255, +4,0,0,0,1,0,0,0,13,0,0,0,83,109,112,52, +0,84,101,120,52,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,52,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,52,0 +}; +const BYTE g_FFSampleTexCube5[] = { +68,88,66,67,9,169,174,254,19,74,128,174,170,108,76,74, +237,75,117,36,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,50,41,254,184,236,74,224,61,194,211,228,155, +17,193,157,56,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +5,5,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,31,0,0,2,0,0,0,152,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,5,0,0,0,88,48,0,4, +0,112,16,0,5,0,0,0,85,85,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,70,126,16,0,5,0,0,0, +0,96,16,0,5,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +5,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,9,0,0,0,255,255,255,255, +5,0,0,0,1,0,0,0,13,0,0,0,83,109,112,53, +0,84,101,120,53,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,53,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,53,0 +}; +const BYTE g_FFSampleTexCube6[] = { +68,88,66,67,91,64,54,105,105,23,11,213,252,58,251,141, +250,247,181,206,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,123,101,100,54,254,198,63,167,228,138,15,149, +11,230,115,30,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +6,6,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,31,0,0,2,0,0,0,152,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,6,0,0,0,88,48,0,4, +0,112,16,0,6,0,0,0,85,85,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,70,126,16,0,6,0,0,0, +0,96,16,0,6,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +6,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,9,0,0,0,255,255,255,255, +6,0,0,0,1,0,0,0,13,0,0,0,83,109,112,54, +0,84,101,120,54,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,54,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,54,0 +}; +const BYTE g_FFSampleTexCube7[] = { +68,88,66,67,188,238,36,82,77,132,123,123,98,251,103,197, +127,182,224,79,1,0,0,0,75,3,0,0,2,0,0,0, +40,0,0,0,240,2,0,0,76,73,66,70,192,2,0,0, +68,88,66,67,221,32,245,102,89,40,196,37,67,14,199,175, +106,249,102,241,1,0,0,0,192,2,0,0,5,0,0,0, +52,0,0,0,160,0,0,0,12,1,0,0,136,1,0,0, +68,2,0,0,65,111,110,57,100,0,0,0,100,0,0,0, +0,2,80,76,60,0,0,0,40,0,0,0,0,0,40,0, +0,0,40,0,0,0,40,0,1,0,36,0,0,0,40,0, +7,7,0,0,0,2,80,76,31,0,0,2,0,0,0,128, +0,0,7,176,31,0,0,2,0,0,0,152,0,8,15,160, +66,0,0,3,0,0,15,128,0,0,228,176,0,8,228,160, +1,0,0,2,0,0,15,224,0,0,228,128,255,255,0,0, +83,72,68,82,100,0,0,0,64,0,240,255,25,0,0,0, +90,0,0,3,0,96,16,0,7,0,0,0,88,48,0,4, +0,112,16,0,7,0,0,0,85,85,0,0,95,0,0,3, +114,16,16,0,0,0,0,0,101,0,0,3,242,32,16,0, +0,0,0,0,69,0,0,9,242,32,16,0,0,0,0,0, +70,18,16,0,0,0,0,0,70,126,16,0,7,0,0,0, +0,96,16,0,7,0,0,0,62,0,0,1,83,84,65,84, +116,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0, +2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,82,68,69,70,180,0,0,0, +0,0,0,0,0,0,0,0,2,0,0,0,60,0,0,0, +0,4,70,76,0,129,0,0,134,0,0,0,82,68,49,49, +60,0,0,0,24,0,0,0,32,0,0,0,40,0,0,0, +36,0,0,0,12,0,0,0,0,0,0,0,124,0,0,0, +3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +7,0,0,0,1,0,0,0,1,0,0,0,129,0,0,0, +2,0,0,0,5,0,0,0,9,0,0,0,255,255,255,255, +7,0,0,0,1,0,0,0,13,0,0,0,83,109,112,55, +0,84,101,120,55,0,77,105,99,114,111,115,111,102,116,32, +40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32, +67,111,109,112,105,108,101,114,32,54,46,51,46,57,52,49, +53,46,48,0,76,70,83,48,116,0,0,0,2,0,0,0, +8,0,0,0,104,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0, +2,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0, +0,0,0,0,113,0,0,0,0,0,0,0,3,0,0,0, +1,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0, +1,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255, +255,255,255,255,76,111,97,100,84,101,120,55,0,117,118,0, +76,73,66,72,83,0,0,0,1,0,0,0,28,0,0,0, +0,0,0,0,1,0,0,0,20,0,0,0,2,0,0,0, +74,0,0,0,77,105,99,114,111,115,111,102,116,32,40,82, +41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111, +109,112,105,108,101,114,32,54,46,51,46,57,52,49,53,46, +48,0,76,111,97,100,84,101,120,55,0 +}; +const BYTE* g_FFSampleTexLib[] = { +g_FFSampleTex2D0, +g_FFSampleTex2D1, +g_FFSampleTex2D2, +g_FFSampleTex2D3, +g_FFSampleTex2D4, +g_FFSampleTex2D5, +g_FFSampleTex2D6, +g_FFSampleTex2D7, +g_FFSampleTexProj0, +g_FFSampleTexProj1, +g_FFSampleTexProj2, +g_FFSampleTexProj3, +g_FFSampleTexProj4, +g_FFSampleTexProj5, +g_FFSampleTexProj6, +g_FFSampleTexProj7, +g_FFSampleTex3D0, +g_FFSampleTex3D1, +g_FFSampleTex3D2, +g_FFSampleTex3D3, +g_FFSampleTex3D4, +g_FFSampleTex3D5, +g_FFSampleTex3D6, +g_FFSampleTex3D7, +g_FFSampleTexCube0, +g_FFSampleTexCube1, +g_FFSampleTexCube2, +g_FFSampleTexCube3, +g_FFSampleTexCube4, +g_FFSampleTexCube5, +g_FFSampleTexCube6, +g_FFSampleTexCube7, +}; +const size_t g_FFSampleTexLibSize[] = { +sizeof(g_FFSampleTex2D0), +sizeof(g_FFSampleTex2D1), +sizeof(g_FFSampleTex2D2), +sizeof(g_FFSampleTex2D3), +sizeof(g_FFSampleTex2D4), +sizeof(g_FFSampleTex2D5), +sizeof(g_FFSampleTex2D6), +sizeof(g_FFSampleTex2D7), +sizeof(g_FFSampleTexProj0), +sizeof(g_FFSampleTexProj1), +sizeof(g_FFSampleTexProj2), +sizeof(g_FFSampleTexProj3), +sizeof(g_FFSampleTexProj4), +sizeof(g_FFSampleTexProj5), +sizeof(g_FFSampleTexProj6), +sizeof(g_FFSampleTexProj7), +sizeof(g_FFSampleTex3D0), +sizeof(g_FFSampleTex3D1), +sizeof(g_FFSampleTex3D2), +sizeof(g_FFSampleTex3D3), +sizeof(g_FFSampleTex3D4), +sizeof(g_FFSampleTex3D5), +sizeof(g_FFSampleTex3D6), +sizeof(g_FFSampleTex3D7), +sizeof(g_FFSampleTexCube0), +sizeof(g_FFSampleTexCube1), +sizeof(g_FFSampleTexCube2), +sizeof(g_FFSampleTexCube3), +sizeof(g_FFSampleTexCube4), +sizeof(g_FFSampleTexCube5), +sizeof(g_FFSampleTexCube6), +sizeof(g_FFSampleTexCube7), +}; diff --git a/Runtime/GfxDevice/d3d11/InternalShaders/FFShaderLib.hlsl b/Runtime/GfxDevice/d3d11/InternalShaders/FFShaderLib.hlsl new file mode 100644 index 0000000..fa2a89a --- /dev/null +++ b/Runtime/GfxDevice/d3d11/InternalShaders/FFShaderLib.hlsl @@ -0,0 +1,172 @@ + +cbuffer UnityFFVertex { + float4x4 ff_matrix_mvp; // 0 + float4x4 ff_matrix_mv; // 4 + float4 ff_vec_color; // 8 + float4 ff_vec_ambient; // 9 + float4 ff_light_color[8]; // 10 + float4 ff_light_pos[8]; // 18 + float4 ff_light_atten[8]; // 26 + float4 ff_light_spot[8]; // 34 + float4 ff_mat_diffuse; // 42 + float4 ff_mat_ambient; // 43 + float4 ff_mat_spec; // 44 + float4 ff_mat_emission; // 45 + float4x4 ff_matrix_tex[4]; // 46 + float4 ff_fog_vs; // 62 +}; // 62 + +cbuffer UnityFFPixel { + float4 ff_vec_colors[8]; // 0 + float ff_alpha_ref; // 8 + float4 ff_fog_ps; // 9 +}; + + +export float4 LoadVertexColor(float4 vc) { return vc; } +export float4 LoadVertexColorUniform() { return ff_vec_color; } +export float3 LoadEyePos(float4 vertex) { return mul (ff_matrix_mv, vertex).xyz; } +export float3 LoadEyeNormal(float3 normal) { return normalize (mul ((float3x3)ff_matrix_mv, normal).xyz); } //@TODO: proper normal matrix +export float3 LoadZero() { return 0.0; } +export float3 LoadViewDir(float3 eyePos) { return -normalize(eyePos); } +export float3 LoadEyeRefl(float3 viewDir, float3 eyeNormal) { return 2.0f * dot (viewDir, eyeNormal) * eyeNormal - viewDir; } +export float4 LoadAmbientColor() { return ff_mat_ambient; } +export float4 LoadDiffuseColor() { return ff_mat_diffuse; } +export float4 LoadEmissionColor() { return ff_mat_emission; } + +export float3 InitLightColor(float4 emission, float4 ambient) { return emission.rgb + ambient.rgb * ff_vec_ambient.rgb; } + +float3 ComputeLighting (int idx, float3 dirToLight, float3 eyeNormal, float3 viewDir, float4 diffuseColor, float atten, inout float3 specColor) { + float NdotL = max(dot(eyeNormal, dirToLight), 0.0); + float3 color = NdotL * diffuseColor.rgb * ff_light_color[idx].rgb; + return color * atten; +} +float3 ComputeLightingSpec (int idx, float3 dirToLight, float3 eyeNormal, float3 viewDir, float4 diffuseColor, float atten, inout float3 specColor) { + float NdotL = max(dot(eyeNormal, dirToLight), 0.0); + float3 color = NdotL * diffuseColor.rgb * ff_light_color[idx].rgb; + if (NdotL > 0.0) { + float3 h = normalize(dirToLight + viewDir); + float HdotN = max(dot(eyeNormal, h), 0.0); + float sp = saturate(pow(HdotN, ff_mat_spec.w)); + specColor += atten * sp * ff_light_color[idx].rgb; + } + return color * atten; +} +float3 ComputeSpotLight(int idx, float3 eyePosition, float3 eyeNormal, float3 viewDir, float4 diffuseColor, inout float3 specColor) { + float3 dirToLight = ff_light_pos[idx].xyz - eyePosition * ff_light_pos[idx].w; + float distSqr = dot(dirToLight, dirToLight); + float att = 1.0 / (1.0 + ff_light_atten[idx].z * distSqr); + if (ff_light_pos[idx].w != 0 && distSqr > ff_light_atten[idx].w) att = 0.0; // set to 0 if outside of range + dirToLight *= rsqrt(distSqr); + float rho = max(dot(dirToLight, ff_light_spot[idx].xyz), 0.0); + float spotAtt = (rho - ff_light_atten[idx].x) * ff_light_atten[idx].y; + spotAtt = saturate(spotAtt); + return min (ComputeLighting (idx, dirToLight, eyeNormal, viewDir, diffuseColor, att*spotAtt, specColor), 1.0); +} +float3 ComputeSpotLightSpec(int idx, float3 eyePosition, float3 eyeNormal, float3 viewDir, float4 diffuseColor, inout float3 specColor) { + float3 dirToLight = ff_light_pos[idx].xyz - eyePosition * ff_light_pos[idx].w; + float distSqr = dot(dirToLight, dirToLight); + float att = 1.0 / (1.0 + ff_light_atten[idx].z * distSqr); + if (ff_light_pos[idx].w != 0 && distSqr > ff_light_atten[idx].w) att = 0.0; // set to 0 if outside of range + dirToLight *= rsqrt(distSqr); + float rho = max(dot(dirToLight, ff_light_spot[idx].xyz), 0.0); + float spotAtt = (rho - ff_light_atten[idx].x) * ff_light_atten[idx].y; + spotAtt = saturate(spotAtt); + return min (ComputeLightingSpec (idx, dirToLight, eyeNormal, viewDir, diffuseColor, att*spotAtt, specColor), 1.0); +} +#define SPOT_LIGHT(n) \ +export float3 ComputeSpotLight##n(float3 eyePosition, float3 eyeNormal, float3 viewDir, float4 diffuseColor, inout float3 specColor, float3 amb) { \ + float3 l = amb; \ + for (int i = 0; i < n; ++i) \ + l += ComputeSpotLight(i, eyePosition, eyeNormal, viewDir, diffuseColor, specColor); \ + return l; \ +} \ +export float3 ComputeSpotLightSpec##n(float3 eyePosition, float3 eyeNormal, float3 viewDir, float4 diffuseColor, inout float3 specColor, float3 amb) { \ + float3 l = amb; \ + for (int i = 0; i < n; ++i) \ + l += ComputeSpotLightSpec(i, eyePosition, eyeNormal, viewDir, diffuseColor, specColor); \ + return l; \ +} +SPOT_LIGHT(0) +SPOT_LIGHT(1) +SPOT_LIGHT(2) +SPOT_LIGHT(3) +SPOT_LIGHT(4) +SPOT_LIGHT(5) +SPOT_LIGHT(6) +SPOT_LIGHT(7) +SPOT_LIGHT(8) + +export float4 LoadLightingColor(float3 lcolor, float4 diffcolor) { return float4(lcolor.rgb, diffcolor.a); } + +export float4 TransformVertex(float4 vertex) { return mul (ff_matrix_mvp, vertex); } + +export float4 Saturate4(float4 c) { return saturate(c); } +export float3 Saturate3(float3 c) { return saturate(c); } +export float3 Load3(float3 c) { return c; } +export float3 ModulateSpec(float3 c) { return c * ff_mat_spec.rgb; } + +export float4 MultiplyUV0(float4 uv) { return mul(ff_matrix_tex[0], uv); } +export float4 MultiplyUV1(float4 uv) { return mul(ff_matrix_tex[1], uv); } +export float4 MultiplyUV2(float4 uv) { return mul(ff_matrix_tex[2], uv); } +export float4 MultiplyUV3(float4 uv) { return mul(ff_matrix_tex[3], uv); } +export float4 MultiplyUV4(float4 uv) { return uv; } +export float4 MultiplyUV5(float4 uv) { return uv; } +export float4 MultiplyUV6(float4 uv) { return uv; } +export float4 MultiplyUV7(float4 uv) { return uv; } + +export float4 UVSphereMap(float3 eyeRefl) { return float4(eyeRefl.xy / (2.0*sqrt(eyeRefl.x*eyeRefl.x + eyeRefl.y*eyeRefl.y + (eyeRefl.z+1)*(eyeRefl.z+1))) + 0.5, 0, 1); } +export float4 Float3to4(float3 v) { return float4(v.xyz,1); } + +export float4 LoadConstantColor0() { return ff_vec_colors[0]; } +export float4 LoadConstantColor1() { return ff_vec_colors[1]; } +export float4 LoadConstantColor2() { return ff_vec_colors[2]; } +export float4 LoadConstantColor3() { return ff_vec_colors[3]; } +export float4 LoadConstantColor4() { return ff_vec_colors[4]; } +export float4 LoadConstantColor5() { return ff_vec_colors[5]; } +export float4 LoadConstantColor6() { return ff_vec_colors[6]; } +export float4 LoadConstantColor7() { return ff_vec_colors[7]; } + +export float OneMinus1(float v) { return 1.0-v; } +export float3 OneMinus3(float3 v) { return 1.0-v; } +export float4 OneMinus4(float4 v) { return 1.0-v; } + +export float4 CombReplace (float4 a) { return a; } +export float4 CombModulate (float4 a, float4 b) { return a * b; } +export float4 CombAdd (float4 a, float4 b) { return a + b; } +export float4 CombAddSigned(float4 a, float4 b) { return a + b - 0.5; } +export float4 CombSubtract (float4 a, float4 b) { return a - b; } +export float4 CombLerp (float4 a, float4 b, float4 c) { return lerp(b, a, c.a); } +export float4 CombDot3 (float4 a, float4 b) { float3 r = 4.0 * dot(a.rgb-0.5, b.rgb-0.5); return float4(r, a.a); } +export float4 CombDot3rgba (float4 a, float4 b) { return 4.0 * dot(a.rgb-0.5, b.rgb-0.5); } +export float4 CombMulAdd (float4 a, float4 b, float4 c) { return a * c.a + b; } +export float4 CombMulSub (float4 a, float4 b, float4 c) { return a * c.a - b; } +export float4 CombMulAddSigned(float4 a, float4 b, float4 c) { return a * c.a + b - 0.5; } + +export float4 Scale2(float4 a) { return a + a; } +export float4 Scale4(float4 a) { return a * 4; } + +export float4 AddSpec(float4 col, float3 spec) { col.rgb += spec; return col; } +export float4 CombineAlpha(float4 c, float4 a) { return float4(c.rgb, a.a); } + +export float FogLinear(float3 eyePos) { + return saturate(length(eyePos) * ff_fog_vs.z + ff_fog_vs.w); +} +export float FogExp(float3 eyePos) { + return saturate(exp2(-(length(eyePos) * ff_fog_vs.y))); +} +export float FogExp2(float3 eyePos) { + float f = length(eyePos) * ff_fog_vs.y; + return saturate(exp2(-f * f)); +} +export float4 ApplyFog(float4 col, float ifog) { + return float4(lerp(ff_fog_ps.rgb, col.rgb, ifog), col.a); +} + +export float4 AlphaTestNever(float4 col) { discard; return col; } +export float4 AlphaTestLess(float4 col) { if (!(col.a < ff_alpha_ref)) discard; return col; } +export float4 AlphaTestEqual(float4 col) { if (!(col.a == ff_alpha_ref)) discard; return col; } +export float4 AlphaTestLEqual(float4 col) { if (!(col.a <= ff_alpha_ref)) discard; return col; } +export float4 AlphaTestGreater(float4 col) { if (!(col.a > ff_alpha_ref)) discard; return col; } +export float4 AlphaTestNotEqual(float4 col) { if (!(col.a != ff_alpha_ref)) discard; return col; } +export float4 AlphaTestGEqual(float4 col) { if (!(col.a >= ff_alpha_ref)) discard; return col; } diff --git a/Runtime/GfxDevice/d3d11/InternalShaders/builtin.h b/Runtime/GfxDevice/d3d11/InternalShaders/builtin.h new file mode 100644 index 0000000..737bd42 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/InternalShaders/builtin.h @@ -0,0 +1,19755 @@ +// +// +// Autogenerated file. Do not modify! +// +// +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_1_32 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_1_32._fxctmp +// /EStreamOutSkinVS_Position_1_32 /D BONESPERVERTEX=1 /D BONECOUNT=32 +// internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[32]; // Offset: 0 Size: 1536 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[96], dynamicIndexed +dcl_input v0.xyz +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +imul null, r0.x, v3.x, l(3) +mov r1.xyz, v0.xyzx +mov r1.w, l(1.000000) +dp4 o0.x, r1.xyzw, cb0[r0.x + 0].xyzw +dp4 o0.y, r1.xyzw, cb0[r0.x + 1].xyzw +dp4 o0.z, r1.xyzw, cb0[r0.x + 2].xyzw +mov o1.xyz, l(0,0,0,0) +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_1_32[] = +{ + 68, 88, 66, 67, 172, 110, + 173, 231, 150, 179, 82, 99, + 5, 94, 37, 107, 119, 107, + 152, 219, 1, 0, 0, 0, + 220, 3, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 96, 3, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 6, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 32, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 92, 1, 0, 0, + 64, 0, 1, 0, 87, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 96, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 38, 0, 0, 8, + 0, 208, 0, 0, 18, 0, + 16, 0, 0, 0, 0, 0, + 10, 16, 16, 0, 3, 0, + 0, 0, 1, 64, 0, 0, + 3, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 1, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 1, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 54, 0, 0, 8, 242, 32, + 16, 0, 2, 0, 0, 0, + 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 9, 0, 0, 0, + 2, 0, 0, 0, 0, 0, + 0, 0, 5, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_2_32 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_2_32._fxctmp +// /EStreamOutSkinVS_Position_2_32 /D BONESPERVERTEX=2 /D BONECOUNT=32 +// internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[32]; // Offset: 0 Size: 1536 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[96], dynamicIndexed +dcl_input v0.xyz +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 3 +imul null, r0.xy, v4.xyxx, l(3, 3, 0, 0) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r1.xyzw +dp4 o0.y, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r0.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r1.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +mov o1.xyz, l(0,0,0,0) +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 15 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_2_32[] = +{ + 68, 88, 66, 67, 78, 255, + 107, 230, 57, 57, 29, 189, + 107, 149, 130, 121, 255, 237, + 206, 251, 1, 0, 0, 0, + 252, 4, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 128, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 6, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 32, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 84, 2, 0, 0, 64, 0, + 1, 0, 149, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 96, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 3, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 50, 0, 16, 0, + 0, 0, 0, 0, 70, 16, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 2, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 1, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 26, 0, 16, 0, + 0, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 17, 0, + 0, 7, 34, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 0, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 0, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 54, 0, 0, 8, 242, 32, + 16, 0, 2, 0, 0, 0, + 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 15, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, + 6, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_4_32 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_4_32._fxctmp +// /EStreamOutSkinVS_Position_4_32 /D BONESPERVERTEX=4 /D BONECOUNT=32 +// internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[32]; // Offset: 0 Size: 1536 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[96], dynamicIndexed +dcl_input v0.xyz +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 3 +imul null, r0.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mad r1.xyzw, v3.zzzz, cb0[r0.z + 0].xyzw, r1.xyzw +mad r1.xyzw, v3.wwww, cb0[r0.w + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r1.xyzw +mad r1.xyzw, v3.zzzz, cb0[r0.z + 1].xyzw, r1.xyzw +mad r1.xyzw, v3.wwww, cb0[r0.w + 1].xyzw, r1.xyzw +dp4 o0.y, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r1.xyzw +mad r1.xyzw, v3.zzzz, cb0[r0.z + 2].xyzw, r1.xyzw +mad r0.xyzw, v3.wwww, cb0[r0.w + 2].xyzw, r1.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +mov o1.xyz, l(0,0,0,0) +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 21 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_4_32[] = +{ + 68, 88, 66, 67, 190, 235, + 32, 161, 70, 54, 170, 157, + 239, 18, 118, 92, 60, 255, + 126, 161, 1, 0, 0, 0, + 20, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 152, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 6, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 32, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 108, 3, 0, 0, 64, 0, + 1, 0, 219, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 96, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 3, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 242, 0, 16, 0, + 0, 0, 0, 0, 70, 30, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 1, 0, 0, 0, 166, 26, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 42, 0, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 1, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 2, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 2, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 1, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 1, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 42, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 1, 0, + 0, 0, 246, 31, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 1, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 26, 0, 16, 0, + 0, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 166, 26, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 42, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 0, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 58, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 17, 0, + 0, 7, 66, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 8, + 114, 32, 16, 0, 1, 0, + 0, 0, 2, 64, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 242, 32, 16, 0, + 2, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 21, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 6, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_1_64 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_1_64._fxctmp +// /EStreamOutSkinVS_Position_1_64 /D BONESPERVERTEX=1 /D BONECOUNT=64 +// internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[64]; // Offset: 0 Size: 3072 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[192], dynamicIndexed +dcl_input v0.xyz +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +imul null, r0.x, v3.x, l(3) +mov r1.xyz, v0.xyzx +mov r1.w, l(1.000000) +dp4 o0.x, r1.xyzw, cb0[r0.x + 0].xyzw +dp4 o0.y, r1.xyzw, cb0[r0.x + 1].xyzw +dp4 o0.z, r1.xyzw, cb0[r0.x + 2].xyzw +mov o1.xyz, l(0,0,0,0) +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_1_64[] = +{ + 68, 88, 66, 67, 147, 148, + 150, 219, 6, 76, 210, 165, + 175, 243, 177, 17, 178, 32, + 216, 209, 1, 0, 0, 0, + 220, 3, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 96, 3, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 12, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 12, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 64, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 92, 1, 0, 0, + 64, 0, 1, 0, 87, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 192, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 38, 0, 0, 8, + 0, 208, 0, 0, 18, 0, + 16, 0, 0, 0, 0, 0, + 10, 16, 16, 0, 3, 0, + 0, 0, 1, 64, 0, 0, + 3, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 1, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 1, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 54, 0, 0, 8, 242, 32, + 16, 0, 2, 0, 0, 0, + 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 9, 0, 0, 0, + 2, 0, 0, 0, 0, 0, + 0, 0, 5, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_2_64 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_2_64._fxctmp +// /EStreamOutSkinVS_Position_2_64 /D BONESPERVERTEX=2 /D BONECOUNT=64 +// internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[64]; // Offset: 0 Size: 3072 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[192], dynamicIndexed +dcl_input v0.xyz +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 3 +imul null, r0.xy, v4.xyxx, l(3, 3, 0, 0) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r1.xyzw +dp4 o0.y, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r0.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r1.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +mov o1.xyz, l(0,0,0,0) +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 15 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_2_64[] = +{ + 68, 88, 66, 67, 2, 81, + 122, 207, 247, 163, 197, 92, + 153, 201, 157, 75, 235, 157, + 250, 13, 1, 0, 0, 0, + 252, 4, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 128, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 12, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 12, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 64, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 84, 2, 0, 0, 64, 0, + 1, 0, 149, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 192, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 3, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 50, 0, 16, 0, + 0, 0, 0, 0, 70, 16, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 2, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 1, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 26, 0, 16, 0, + 0, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 17, 0, + 0, 7, 34, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 0, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 0, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 54, 0, 0, 8, 242, 32, + 16, 0, 2, 0, 0, 0, + 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 15, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, + 6, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_4_64 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_4_64._fxctmp +// /EStreamOutSkinVS_Position_4_64 /D BONESPERVERTEX=4 /D BONECOUNT=64 +// internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[64]; // Offset: 0 Size: 3072 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[192], dynamicIndexed +dcl_input v0.xyz +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 3 +imul null, r0.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mad r1.xyzw, v3.zzzz, cb0[r0.z + 0].xyzw, r1.xyzw +mad r1.xyzw, v3.wwww, cb0[r0.w + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r1.xyzw +mad r1.xyzw, v3.zzzz, cb0[r0.z + 1].xyzw, r1.xyzw +mad r1.xyzw, v3.wwww, cb0[r0.w + 1].xyzw, r1.xyzw +dp4 o0.y, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r1.xyzw +mad r1.xyzw, v3.zzzz, cb0[r0.z + 2].xyzw, r1.xyzw +mad r0.xyzw, v3.wwww, cb0[r0.w + 2].xyzw, r1.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +mov o1.xyz, l(0,0,0,0) +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 21 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_4_64[] = +{ + 68, 88, 66, 67, 11, 70, + 190, 106, 178, 229, 109, 109, + 89, 69, 130, 9, 207, 137, + 221, 41, 1, 0, 0, 0, + 20, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 152, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 12, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 12, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 64, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 108, 3, 0, 0, 64, 0, + 1, 0, 219, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 192, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 3, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 242, 0, 16, 0, + 0, 0, 0, 0, 70, 30, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 1, 0, 0, 0, 166, 26, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 42, 0, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 1, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 2, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 2, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 1, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 1, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 42, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 1, 0, + 0, 0, 246, 31, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 1, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 26, 0, 16, 0, + 0, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 166, 26, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 42, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 0, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 58, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 17, 0, + 0, 7, 66, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 8, + 114, 32, 16, 0, 1, 0, + 0, 0, 2, 64, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 242, 32, 16, 0, + 2, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 21, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 6, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_1_128 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_1_128._fxctmp +// /EStreamOutSkinVS_Position_1_128 /D BONESPERVERTEX=1 /D BONECOUNT=128 +// internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[128]; // Offset: 0 Size: 6144 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[384], dynamicIndexed +dcl_input v0.xyz +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +imul null, r0.x, v3.x, l(3) +mov r1.xyz, v0.xyzx +mov r1.w, l(1.000000) +dp4 o0.x, r1.xyzw, cb0[r0.x + 0].xyzw +dp4 o0.y, r1.xyzw, cb0[r0.x + 1].xyzw +dp4 o0.z, r1.xyzw, cb0[r0.x + 2].xyzw +mov o1.xyz, l(0,0,0,0) +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_1_128[] = +{ + 68, 88, 66, 67, 7, 222, + 0, 205, 11, 21, 104, 139, + 8, 62, 57, 246, 1, 70, + 233, 230, 1, 0, 0, 0, + 220, 3, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 96, 3, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 24, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 24, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 128, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 92, 1, 0, 0, + 64, 0, 1, 0, 87, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 128, 1, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 38, 0, 0, 8, + 0, 208, 0, 0, 18, 0, + 16, 0, 0, 0, 0, 0, + 10, 16, 16, 0, 3, 0, + 0, 0, 1, 64, 0, 0, + 3, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 1, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 1, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 54, 0, 0, 8, 242, 32, + 16, 0, 2, 0, 0, 0, + 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 9, 0, 0, 0, + 2, 0, 0, 0, 0, 0, + 0, 0, 5, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_2_128 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_2_128._fxctmp +// /EStreamOutSkinVS_Position_2_128 /D BONESPERVERTEX=2 /D BONECOUNT=128 +// internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[128]; // Offset: 0 Size: 6144 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[384], dynamicIndexed +dcl_input v0.xyz +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 3 +imul null, r0.xy, v4.xyxx, l(3, 3, 0, 0) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r1.xyzw +dp4 o0.y, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r0.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r1.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +mov o1.xyz, l(0,0,0,0) +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 15 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_2_128[] = +{ + 68, 88, 66, 67, 131, 165, + 122, 210, 205, 5, 71, 238, + 145, 203, 104, 57, 229, 1, + 240, 89, 1, 0, 0, 0, + 252, 4, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 128, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 24, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 24, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 128, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 84, 2, 0, 0, 64, 0, + 1, 0, 149, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 128, 1, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 3, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 50, 0, 16, 0, + 0, 0, 0, 0, 70, 16, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 2, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 1, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 26, 0, 16, 0, + 0, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 17, 0, + 0, 7, 34, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 0, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 0, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 54, 0, 0, 8, 242, 32, + 16, 0, 2, 0, 0, 0, + 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 15, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, + 6, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_4_128 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_4_128._fxctmp +// /EStreamOutSkinVS_Position_4_128 /D BONESPERVERTEX=4 /D BONECOUNT=128 +// internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[128]; // Offset: 0 Size: 6144 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[384], dynamicIndexed +dcl_input v0.xyz +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 3 +imul null, r0.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mad r1.xyzw, v3.zzzz, cb0[r0.z + 0].xyzw, r1.xyzw +mad r1.xyzw, v3.wwww, cb0[r0.w + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r1.xyzw +mad r1.xyzw, v3.zzzz, cb0[r0.z + 1].xyzw, r1.xyzw +mad r1.xyzw, v3.wwww, cb0[r0.w + 1].xyzw, r1.xyzw +dp4 o0.y, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r1.xyzw +mad r1.xyzw, v3.zzzz, cb0[r0.z + 2].xyzw, r1.xyzw +mad r0.xyzw, v3.wwww, cb0[r0.w + 2].xyzw, r1.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +mov o1.xyz, l(0,0,0,0) +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 21 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_4_128[] = +{ + 68, 88, 66, 67, 57, 216, + 246, 73, 126, 196, 169, 105, + 89, 156, 29, 146, 202, 235, + 72, 227, 1, 0, 0, 0, + 20, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 152, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 24, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 24, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 128, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 108, 3, 0, 0, 64, 0, + 1, 0, 219, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 128, 1, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 3, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 242, 0, 16, 0, + 0, 0, 0, 0, 70, 30, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 1, 0, 0, 0, 166, 26, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 42, 0, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 1, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 2, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 2, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 1, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 1, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 42, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 1, 0, + 0, 0, 246, 31, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 1, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 26, 0, 16, 0, + 0, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 166, 26, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 42, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 0, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 58, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 17, 0, + 0, 7, 66, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 8, + 114, 32, 16, 0, 1, 0, + 0, 0, 2, 64, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 242, 32, 16, 0, + 2, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 21, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 6, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_1_512 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_1_512._fxctmp +// /EStreamOutSkinVS_Position_1_512 /D BONESPERVERTEX=1 /D BONECOUNT=512 +// internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[512]; // Offset: 0 Size: 24576 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[1536], dynamicIndexed +dcl_input v0.xyz +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +imul null, r0.x, v3.x, l(3) +mov r1.xyz, v0.xyzx +mov r1.w, l(1.000000) +dp4 o0.x, r1.xyzw, cb0[r0.x + 0].xyzw +dp4 o0.y, r1.xyzw, cb0[r0.x + 1].xyzw +dp4 o0.z, r1.xyzw, cb0[r0.x + 2].xyzw +mov o1.xyz, l(0,0,0,0) +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_1_512[] = +{ + 68, 88, 66, 67, 109, 180, + 27, 53, 43, 110, 111, 181, + 254, 232, 170, 150, 51, 248, + 173, 45, 1, 0, 0, 0, + 220, 3, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 96, 3, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 96, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 96, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 2, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 92, 1, 0, 0, + 64, 0, 1, 0, 87, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 0, 6, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 38, 0, 0, 8, + 0, 208, 0, 0, 18, 0, + 16, 0, 0, 0, 0, 0, + 10, 16, 16, 0, 3, 0, + 0, 0, 1, 64, 0, 0, + 3, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 1, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 1, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 54, 0, 0, 8, 242, 32, + 16, 0, 2, 0, 0, 0, + 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 9, 0, 0, 0, + 2, 0, 0, 0, 0, 0, + 0, 0, 5, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_2_512 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_2_512._fxctmp +// /EStreamOutSkinVS_Position_2_512 /D BONESPERVERTEX=2 /D BONECOUNT=512 +// internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[512]; // Offset: 0 Size: 24576 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[1536], dynamicIndexed +dcl_input v0.xyz +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 3 +imul null, r0.xy, v4.xyxx, l(3, 3, 0, 0) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r1.xyzw +dp4 o0.y, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r0.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r1.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +mov o1.xyz, l(0,0,0,0) +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 15 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_2_512[] = +{ + 68, 88, 66, 67, 191, 248, + 159, 81, 159, 73, 255, 194, + 53, 47, 141, 25, 191, 205, + 45, 208, 1, 0, 0, 0, + 252, 4, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 128, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 96, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 96, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 2, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 84, 2, 0, 0, 64, 0, + 1, 0, 149, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 0, 6, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 3, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 50, 0, 16, 0, + 0, 0, 0, 0, 70, 16, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 2, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 1, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 26, 0, 16, 0, + 0, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 17, 0, + 0, 7, 34, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 0, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 0, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 54, 0, 0, 8, 242, 32, + 16, 0, 2, 0, 0, 0, + 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 15, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, + 6, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_4_512 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_4_512._fxctmp +// /EStreamOutSkinVS_Position_4_512 /D BONESPERVERTEX=4 /D BONECOUNT=512 +// internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[512]; // Offset: 0 Size: 24576 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[1536], dynamicIndexed +dcl_input v0.xyz +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 3 +imul null, r0.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mad r1.xyzw, v3.zzzz, cb0[r0.z + 0].xyzw, r1.xyzw +mad r1.xyzw, v3.wwww, cb0[r0.w + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r1.xyzw +mad r1.xyzw, v3.zzzz, cb0[r0.z + 1].xyzw, r1.xyzw +mad r1.xyzw, v3.wwww, cb0[r0.w + 1].xyzw, r1.xyzw +dp4 o0.y, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r1.xyzw +mad r1.xyzw, v3.zzzz, cb0[r0.z + 2].xyzw, r1.xyzw +mad r0.xyzw, v3.wwww, cb0[r0.w + 2].xyzw, r1.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +mov o1.xyz, l(0,0,0,0) +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 21 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_4_512[] = +{ + 68, 88, 66, 67, 70, 119, + 204, 225, 31, 226, 142, 0, + 115, 56, 144, 156, 34, 203, + 86, 29, 1, 0, 0, 0, + 20, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 152, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 96, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 96, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 2, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 108, 3, 0, 0, 64, 0, + 1, 0, 219, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 0, 6, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 3, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 242, 0, 16, 0, + 0, 0, 0, 0, 70, 30, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 1, 0, 0, 0, 166, 26, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 42, 0, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 1, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 2, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 2, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 1, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 1, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 42, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 1, 0, + 0, 0, 246, 31, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 1, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 26, 0, 16, 0, + 0, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 166, 26, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 42, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 0, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 58, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 17, 0, + 0, 7, 66, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 8, + 114, 32, 16, 0, 1, 0, + 0, 0, 2, 64, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 242, 32, 16, 0, + 2, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 21, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 6, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_1_1024 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_1_1024._fxctmp +// /EStreamOutSkinVS_Position_1_1024 /D BONESPERVERTEX=1 /D BONECOUNT=1024 +// internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[1024]; // Offset: 0 Size: 49152 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[3072], dynamicIndexed +dcl_input v0.xyz +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +imul null, r0.x, v3.x, l(3) +mov r1.xyz, v0.xyzx +mov r1.w, l(1.000000) +dp4 o0.x, r1.xyzw, cb0[r0.x + 0].xyzw +dp4 o0.y, r1.xyzw, cb0[r0.x + 1].xyzw +dp4 o0.z, r1.xyzw, cb0[r0.x + 2].xyzw +mov o1.xyz, l(0,0,0,0) +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_1_1024[] = +{ + 68, 88, 66, 67, 117, 227, + 218, 150, 67, 53, 102, 246, + 156, 73, 114, 242, 63, 65, + 53, 148, 1, 0, 0, 0, + 220, 3, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 96, 3, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 192, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 192, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 4, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 92, 1, 0, 0, + 64, 0, 1, 0, 87, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 0, 12, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 38, 0, 0, 8, + 0, 208, 0, 0, 18, 0, + 16, 0, 0, 0, 0, 0, + 10, 16, 16, 0, 3, 0, + 0, 0, 1, 64, 0, 0, + 3, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 1, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 1, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 54, 0, 0, 8, 242, 32, + 16, 0, 2, 0, 0, 0, + 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 9, 0, 0, 0, + 2, 0, 0, 0, 0, 0, + 0, 0, 5, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_2_1024 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_2_1024._fxctmp +// /EStreamOutSkinVS_Position_2_1024 /D BONESPERVERTEX=2 /D BONECOUNT=1024 +// internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[1024]; // Offset: 0 Size: 49152 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[3072], dynamicIndexed +dcl_input v0.xyz +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 3 +imul null, r0.xy, v4.xyxx, l(3, 3, 0, 0) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r1.xyzw +dp4 o0.y, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r0.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r1.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +mov o1.xyz, l(0,0,0,0) +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 15 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_2_1024[] = +{ + 68, 88, 66, 67, 13, 71, + 157, 50, 29, 201, 82, 174, + 198, 214, 113, 46, 102, 98, + 97, 207, 1, 0, 0, 0, + 252, 4, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 128, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 192, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 192, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 4, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 84, 2, 0, 0, 64, 0, + 1, 0, 149, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 0, 12, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 3, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 50, 0, 16, 0, + 0, 0, 0, 0, 70, 16, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 2, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 1, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 26, 0, 16, 0, + 0, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 17, 0, + 0, 7, 34, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 0, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 0, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 54, 0, 0, 8, 242, 32, + 16, 0, 2, 0, 0, 0, + 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 15, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, + 6, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_4_1024 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_4_1024._fxctmp +// /EStreamOutSkinVS_Position_4_1024 /D BONESPERVERTEX=4 /D BONECOUNT=1024 +// internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[1024]; // Offset: 0 Size: 49152 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[3072], dynamicIndexed +dcl_input v0.xyz +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 3 +imul null, r0.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mad r1.xyzw, v3.zzzz, cb0[r0.z + 0].xyzw, r1.xyzw +mad r1.xyzw, v3.wwww, cb0[r0.w + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r1.xyzw +mad r1.xyzw, v3.zzzz, cb0[r0.z + 1].xyzw, r1.xyzw +mad r1.xyzw, v3.wwww, cb0[r0.w + 1].xyzw, r1.xyzw +dp4 o0.y, r2.xyzw, r1.xyzw +mul r1.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r1.xyzw +mad r1.xyzw, v3.zzzz, cb0[r0.z + 2].xyzw, r1.xyzw +mad r0.xyzw, v3.wwww, cb0[r0.w + 2].xyzw, r1.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +mov o1.xyz, l(0,0,0,0) +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 21 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_4_1024[] = +{ + 68, 88, 66, 67, 204, 116, + 52, 195, 65, 155, 137, 172, + 38, 110, 158, 215, 19, 229, + 210, 140, 1, 0, 0, 0, + 20, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 152, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 192, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 192, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 4, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 108, 3, 0, 0, 64, 0, + 1, 0, 219, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 0, 12, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 3, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 242, 0, 16, 0, + 0, 0, 0, 0, 70, 30, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 1, 0, 0, 0, 166, 26, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 42, 0, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 1, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 2, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 2, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 1, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 1, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 42, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 1, 0, + 0, 0, 246, 31, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 1, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 26, 0, 16, 0, + 0, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 166, 26, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 42, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 0, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 58, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 17, 0, + 0, 7, 66, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 8, + 114, 32, 16, 0, 1, 0, + 0, 0, 2, 64, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 242, 32, 16, 0, + 2, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 21, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 6, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_1_32 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Normal_1_32._fxctmp +// /EStreamOutSkinVS_Position_Normal_1_32 /D BONESPERVERTEX=1 /D +// BONECOUNT=32 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[32]; // Offset: 0 Size: 1536 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[96], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.x, v3.x, l(3) +dp4 o0.x, r0.xyzw, cb0[r1.x + 0].xyzw +dp4 o0.y, r0.xyzw, cb0[r1.x + 1].xyzw +dp4 o0.z, r0.xyzw, cb0[r1.x + 2].xyzw +dp3 r0.x, v1.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v1.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v1.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 14 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_1_32[] = +{ + 68, 88, 66, 67, 37, 181, + 180, 243, 4, 107, 240, 75, + 171, 127, 67, 83, 143, 167, + 109, 6, 1, 0, 0, 0, + 136, 4, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 12, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 6, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 32, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 8, 2, 0, 0, + 64, 0, 1, 0, 130, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 96, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 1, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 38, 0, 0, 8, 0, 208, + 0, 0, 18, 0, 16, 0, + 1, 0, 0, 0, 10, 16, + 16, 0, 3, 0, 0, 0, + 1, 64, 0, 0, 3, 0, + 0, 0, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 9, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 4, 0, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 10, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 130, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 130, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 68, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 1, 0, 0, 0, + 246, 15, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 242, 32, 16, 0, + 2, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 14, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 9, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_2_32 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Normal_2_32._fxctmp +// /EStreamOutSkinVS_Position_Normal_2_32 /D BONESPERVERTEX=2 /D +// BONECOUNT=32 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[32]; // Offset: 0 Size: 1536 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[96], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +imul null, r0.xy, v4.xyxx, l(3, 3, 0, 0) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +dp3 r1.x, v1.xyzx, r1.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r3.xyzw +dp4 o0.y, r2.xyzw, r3.xyzw +dp3 r1.y, v1.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r0.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r3.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +dp3 r1.z, v1.xyzx, r0.xyzx +dp3 r0.x, r1.xyzx, r1.xyzx +rsq r0.x, r0.x +mul o1.xyz, r0.xxxx, r1.xyzx +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 20 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_2_32[] = +{ + 68, 88, 66, 67, 80, 207, + 201, 191, 158, 92, 237, 100, + 214, 39, 226, 181, 219, 93, + 192, 204, 1, 0, 0, 0, + 136, 5, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 12, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 6, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 32, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 224, 2, 0, 0, 64, 0, + 1, 0, 184, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 96, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 50, 0, 16, 0, + 0, 0, 0, 0, 70, 16, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 2, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 16, 0, 0, 7, 34, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 3, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 0, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 66, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 68, 0, 0, 5, + 18, 0, 16, 0, 0, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 56, 0, + 0, 7, 114, 32, 16, 0, + 1, 0, 0, 0, 6, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 8, + 242, 32, 16, 0, 2, 0, + 0, 0, 2, 64, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, + 116, 0, 0, 0, 20, 0, + 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 7, 0, + 0, 0, 12, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_4_32 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Normal_4_32._fxctmp +// /EStreamOutSkinVS_Position_Normal_4_32 /D BONESPERVERTEX=4 /D +// BONECOUNT=32 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[32]; // Offset: 0 Size: 1536 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[96], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.zzzz, cb0[r1.z + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.wwww, cb0[r1.w + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +dp3 r2.x, v1.xyzx, r2.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.wwww, cb0[r1.w + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +dp3 r2.y, v1.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 2].xyzw, r3.xyzw +mad r1.xyzw, v3.wwww, cb0[r1.w + 2].xyzw, r3.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r2.z, v1.xyzx, r1.xyzx +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o1.xyz, r0.xxxx, r2.xyzx +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 26 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_4_32[] = +{ + 68, 88, 66, 67, 206, 29, + 212, 36, 176, 114, 235, 5, + 52, 112, 248, 230, 26, 143, + 41, 13, 1, 0, 0, 0, + 160, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 36, 6, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 6, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 32, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 248, 3, 0, 0, 64, 0, + 1, 0, 254, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 96, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 242, 0, 16, 0, 1, 0, + 0, 0, 70, 30, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 2, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 2, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 34, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 3, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 1, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 66, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 68, 0, 0, 5, 18, 0, + 16, 0, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 1, 0, + 0, 0, 6, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 54, 0, 0, 8, 242, 32, + 16, 0, 2, 0, 0, 0, + 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 26, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, + 12, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_1_64 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Normal_1_64._fxctmp +// /EStreamOutSkinVS_Position_Normal_1_64 /D BONESPERVERTEX=1 /D +// BONECOUNT=64 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[64]; // Offset: 0 Size: 3072 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[192], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.x, v3.x, l(3) +dp4 o0.x, r0.xyzw, cb0[r1.x + 0].xyzw +dp4 o0.y, r0.xyzw, cb0[r1.x + 1].xyzw +dp4 o0.z, r0.xyzw, cb0[r1.x + 2].xyzw +dp3 r0.x, v1.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v1.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v1.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 14 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_1_64[] = +{ + 68, 88, 66, 67, 50, 106, + 7, 74, 77, 162, 98, 80, + 50, 217, 99, 60, 79, 64, + 217, 67, 1, 0, 0, 0, + 136, 4, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 12, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 12, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 12, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 64, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 8, 2, 0, 0, + 64, 0, 1, 0, 130, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 192, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 1, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 38, 0, 0, 8, 0, 208, + 0, 0, 18, 0, 16, 0, + 1, 0, 0, 0, 10, 16, + 16, 0, 3, 0, 0, 0, + 1, 64, 0, 0, 3, 0, + 0, 0, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 9, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 4, 0, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 10, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 130, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 130, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 68, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 1, 0, 0, 0, + 246, 15, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 242, 32, 16, 0, + 2, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 14, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 9, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_2_64 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Normal_2_64._fxctmp +// /EStreamOutSkinVS_Position_Normal_2_64 /D BONESPERVERTEX=2 /D +// BONECOUNT=64 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[64]; // Offset: 0 Size: 3072 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[192], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +imul null, r0.xy, v4.xyxx, l(3, 3, 0, 0) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +dp3 r1.x, v1.xyzx, r1.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r3.xyzw +dp4 o0.y, r2.xyzw, r3.xyzw +dp3 r1.y, v1.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r0.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r3.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +dp3 r1.z, v1.xyzx, r0.xyzx +dp3 r0.x, r1.xyzx, r1.xyzx +rsq r0.x, r0.x +mul o1.xyz, r0.xxxx, r1.xyzx +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 20 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_2_64[] = +{ + 68, 88, 66, 67, 249, 238, + 191, 110, 90, 243, 91, 253, + 39, 115, 116, 175, 14, 174, + 116, 168, 1, 0, 0, 0, + 136, 5, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 12, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 12, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 12, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 64, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 224, 2, 0, 0, 64, 0, + 1, 0, 184, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 192, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 50, 0, 16, 0, + 0, 0, 0, 0, 70, 16, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 2, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 16, 0, 0, 7, 34, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 3, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 0, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 66, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 68, 0, 0, 5, + 18, 0, 16, 0, 0, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 56, 0, + 0, 7, 114, 32, 16, 0, + 1, 0, 0, 0, 6, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 8, + 242, 32, 16, 0, 2, 0, + 0, 0, 2, 64, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, + 116, 0, 0, 0, 20, 0, + 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 7, 0, + 0, 0, 12, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_4_64 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Normal_4_64._fxctmp +// /EStreamOutSkinVS_Position_Normal_4_64 /D BONESPERVERTEX=4 /D +// BONECOUNT=64 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[64]; // Offset: 0 Size: 3072 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[192], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.zzzz, cb0[r1.z + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.wwww, cb0[r1.w + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +dp3 r2.x, v1.xyzx, r2.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.wwww, cb0[r1.w + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +dp3 r2.y, v1.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 2].xyzw, r3.xyzw +mad r1.xyzw, v3.wwww, cb0[r1.w + 2].xyzw, r3.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r2.z, v1.xyzx, r1.xyzx +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o1.xyz, r0.xxxx, r2.xyzx +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 26 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_4_64[] = +{ + 68, 88, 66, 67, 205, 190, + 48, 68, 39, 226, 36, 48, + 236, 161, 124, 195, 48, 97, + 86, 179, 1, 0, 0, 0, + 160, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 36, 6, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 12, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 12, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 64, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 248, 3, 0, 0, 64, 0, + 1, 0, 254, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 192, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 242, 0, 16, 0, 1, 0, + 0, 0, 70, 30, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 2, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 2, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 34, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 3, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 1, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 66, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 68, 0, 0, 5, 18, 0, + 16, 0, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 1, 0, + 0, 0, 6, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 54, 0, 0, 8, 242, 32, + 16, 0, 2, 0, 0, 0, + 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 26, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, + 12, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_1_128 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Normal_1_128._fxctmp +// /EStreamOutSkinVS_Position_Normal_1_128 /D BONESPERVERTEX=1 /D +// BONECOUNT=128 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[128]; // Offset: 0 Size: 6144 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[384], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.x, v3.x, l(3) +dp4 o0.x, r0.xyzw, cb0[r1.x + 0].xyzw +dp4 o0.y, r0.xyzw, cb0[r1.x + 1].xyzw +dp4 o0.z, r0.xyzw, cb0[r1.x + 2].xyzw +dp3 r0.x, v1.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v1.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v1.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 14 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_1_128[] = +{ + 68, 88, 66, 67, 238, 117, + 193, 23, 105, 229, 96, 236, + 185, 115, 197, 17, 52, 153, + 70, 113, 1, 0, 0, 0, + 136, 4, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 12, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 24, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 24, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 128, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 8, 2, 0, 0, + 64, 0, 1, 0, 130, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 128, 1, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 1, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 38, 0, 0, 8, 0, 208, + 0, 0, 18, 0, 16, 0, + 1, 0, 0, 0, 10, 16, + 16, 0, 3, 0, 0, 0, + 1, 64, 0, 0, 3, 0, + 0, 0, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 9, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 4, 0, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 10, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 130, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 130, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 68, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 1, 0, 0, 0, + 246, 15, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 242, 32, 16, 0, + 2, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 14, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 9, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_2_128 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Normal_2_128._fxctmp +// /EStreamOutSkinVS_Position_Normal_2_128 /D BONESPERVERTEX=2 /D +// BONECOUNT=128 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[128]; // Offset: 0 Size: 6144 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[384], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +imul null, r0.xy, v4.xyxx, l(3, 3, 0, 0) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +dp3 r1.x, v1.xyzx, r1.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r3.xyzw +dp4 o0.y, r2.xyzw, r3.xyzw +dp3 r1.y, v1.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r0.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r3.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +dp3 r1.z, v1.xyzx, r0.xyzx +dp3 r0.x, r1.xyzx, r1.xyzx +rsq r0.x, r0.x +mul o1.xyz, r0.xxxx, r1.xyzx +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 20 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_2_128[] = +{ + 68, 88, 66, 67, 166, 32, + 136, 74, 54, 144, 150, 156, + 117, 193, 191, 235, 43, 166, + 113, 77, 1, 0, 0, 0, + 136, 5, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 12, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 24, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 24, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 128, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 224, 2, 0, 0, 64, 0, + 1, 0, 184, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 128, 1, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 50, 0, 16, 0, + 0, 0, 0, 0, 70, 16, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 2, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 16, 0, 0, 7, 34, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 3, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 0, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 66, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 68, 0, 0, 5, + 18, 0, 16, 0, 0, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 56, 0, + 0, 7, 114, 32, 16, 0, + 1, 0, 0, 0, 6, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 8, + 242, 32, 16, 0, 2, 0, + 0, 0, 2, 64, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, + 116, 0, 0, 0, 20, 0, + 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 7, 0, + 0, 0, 12, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_4_128 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Normal_4_128._fxctmp +// /EStreamOutSkinVS_Position_Normal_4_128 /D BONESPERVERTEX=4 /D +// BONECOUNT=128 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[128]; // Offset: 0 Size: 6144 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[384], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.zzzz, cb0[r1.z + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.wwww, cb0[r1.w + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +dp3 r2.x, v1.xyzx, r2.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.wwww, cb0[r1.w + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +dp3 r2.y, v1.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 2].xyzw, r3.xyzw +mad r1.xyzw, v3.wwww, cb0[r1.w + 2].xyzw, r3.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r2.z, v1.xyzx, r1.xyzx +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o1.xyz, r0.xxxx, r2.xyzx +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 26 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_4_128[] = +{ + 68, 88, 66, 67, 60, 35, + 123, 52, 14, 142, 67, 125, + 230, 117, 131, 72, 141, 182, + 246, 69, 1, 0, 0, 0, + 160, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 36, 6, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 24, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 24, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 128, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 248, 3, 0, 0, 64, 0, + 1, 0, 254, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 128, 1, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 242, 0, 16, 0, 1, 0, + 0, 0, 70, 30, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 2, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 2, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 34, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 3, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 1, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 66, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 68, 0, 0, 5, 18, 0, + 16, 0, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 1, 0, + 0, 0, 6, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 54, 0, 0, 8, 242, 32, + 16, 0, 2, 0, 0, 0, + 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 26, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, + 12, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_1_512 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Normal_1_512._fxctmp +// /EStreamOutSkinVS_Position_Normal_1_512 /D BONESPERVERTEX=1 /D +// BONECOUNT=512 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[512]; // Offset: 0 Size: 24576 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[1536], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.x, v3.x, l(3) +dp4 o0.x, r0.xyzw, cb0[r1.x + 0].xyzw +dp4 o0.y, r0.xyzw, cb0[r1.x + 1].xyzw +dp4 o0.z, r0.xyzw, cb0[r1.x + 2].xyzw +dp3 r0.x, v1.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v1.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v1.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 14 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_1_512[] = +{ + 68, 88, 66, 67, 212, 203, + 229, 99, 44, 100, 72, 180, + 127, 187, 124, 99, 124, 29, + 226, 208, 1, 0, 0, 0, + 136, 4, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 12, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 96, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 96, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 2, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 8, 2, 0, 0, + 64, 0, 1, 0, 130, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 0, 6, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 1, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 38, 0, 0, 8, 0, 208, + 0, 0, 18, 0, 16, 0, + 1, 0, 0, 0, 10, 16, + 16, 0, 3, 0, 0, 0, + 1, 64, 0, 0, 3, 0, + 0, 0, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 9, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 4, 0, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 10, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 130, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 130, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 68, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 1, 0, 0, 0, + 246, 15, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 242, 32, 16, 0, + 2, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 14, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 9, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_2_512 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Normal_2_512._fxctmp +// /EStreamOutSkinVS_Position_Normal_2_512 /D BONESPERVERTEX=2 /D +// BONECOUNT=512 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[512]; // Offset: 0 Size: 24576 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[1536], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +imul null, r0.xy, v4.xyxx, l(3, 3, 0, 0) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +dp3 r1.x, v1.xyzx, r1.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r3.xyzw +dp4 o0.y, r2.xyzw, r3.xyzw +dp3 r1.y, v1.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r0.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r3.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +dp3 r1.z, v1.xyzx, r0.xyzx +dp3 r0.x, r1.xyzx, r1.xyzx +rsq r0.x, r0.x +mul o1.xyz, r0.xxxx, r1.xyzx +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 20 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_2_512[] = +{ + 68, 88, 66, 67, 204, 75, + 190, 164, 162, 21, 187, 0, + 156, 250, 209, 189, 194, 167, + 84, 205, 1, 0, 0, 0, + 136, 5, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 12, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 96, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 96, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 2, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 224, 2, 0, 0, 64, 0, + 1, 0, 184, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 0, 6, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 50, 0, 16, 0, + 0, 0, 0, 0, 70, 16, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 2, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 16, 0, 0, 7, 34, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 3, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 0, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 66, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 68, 0, 0, 5, + 18, 0, 16, 0, 0, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 56, 0, + 0, 7, 114, 32, 16, 0, + 1, 0, 0, 0, 6, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 8, + 242, 32, 16, 0, 2, 0, + 0, 0, 2, 64, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, + 116, 0, 0, 0, 20, 0, + 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 7, 0, + 0, 0, 12, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_4_512 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Normal_4_512._fxctmp +// /EStreamOutSkinVS_Position_Normal_4_512 /D BONESPERVERTEX=4 /D +// BONECOUNT=512 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[512]; // Offset: 0 Size: 24576 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[1536], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.zzzz, cb0[r1.z + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.wwww, cb0[r1.w + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +dp3 r2.x, v1.xyzx, r2.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.wwww, cb0[r1.w + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +dp3 r2.y, v1.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 2].xyzw, r3.xyzw +mad r1.xyzw, v3.wwww, cb0[r1.w + 2].xyzw, r3.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r2.z, v1.xyzx, r1.xyzx +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o1.xyz, r0.xxxx, r2.xyzx +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 26 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_4_512[] = +{ + 68, 88, 66, 67, 167, 117, + 189, 161, 236, 51, 44, 164, + 35, 250, 193, 15, 208, 58, + 236, 51, 1, 0, 0, 0, + 160, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 36, 6, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 96, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 96, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 2, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 248, 3, 0, 0, 64, 0, + 1, 0, 254, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 0, 6, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 242, 0, 16, 0, 1, 0, + 0, 0, 70, 30, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 2, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 2, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 34, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 3, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 1, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 66, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 68, 0, 0, 5, 18, 0, + 16, 0, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 1, 0, + 0, 0, 6, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 54, 0, 0, 8, 242, 32, + 16, 0, 2, 0, 0, 0, + 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 26, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, + 12, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_1_1024 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Normal_1_1024._fxctmp +// /EStreamOutSkinVS_Position_Normal_1_1024 /D BONESPERVERTEX=1 /D +// BONECOUNT=1024 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[1024]; // Offset: 0 Size: 49152 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[3072], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.x, v3.x, l(3) +dp4 o0.x, r0.xyzw, cb0[r1.x + 0].xyzw +dp4 o0.y, r0.xyzw, cb0[r1.x + 1].xyzw +dp4 o0.z, r0.xyzw, cb0[r1.x + 2].xyzw +dp3 r0.x, v1.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v1.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v1.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 14 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_1_1024[] = +{ + 68, 88, 66, 67, 133, 164, + 172, 63, 67, 0, 73, 148, + 24, 137, 147, 85, 55, 244, + 27, 171, 1, 0, 0, 0, + 136, 4, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 12, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 192, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 192, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 4, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 8, 2, 0, 0, + 64, 0, 1, 0, 130, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 0, 12, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 1, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 38, 0, 0, 8, 0, 208, + 0, 0, 18, 0, 16, 0, + 1, 0, 0, 0, 10, 16, + 16, 0, 3, 0, 0, 0, + 1, 64, 0, 0, 3, 0, + 0, 0, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 9, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 4, 0, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 10, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 130, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 130, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 68, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 1, 0, 0, 0, + 246, 15, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 242, 32, 16, 0, + 2, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 14, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 9, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_2_1024 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Normal_2_1024._fxctmp +// /EStreamOutSkinVS_Position_Normal_2_1024 /D BONESPERVERTEX=2 /D +// BONECOUNT=1024 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[1024]; // Offset: 0 Size: 49152 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[3072], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +imul null, r0.xy, v4.xyxx, l(3, 3, 0, 0) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +dp3 r1.x, v1.xyzx, r1.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r3.xyzw +dp4 o0.y, r2.xyzw, r3.xyzw +dp3 r1.y, v1.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r0.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r3.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +dp3 r1.z, v1.xyzx, r0.xyzx +dp3 r0.x, r1.xyzx, r1.xyzx +rsq r0.x, r0.x +mul o1.xyz, r0.xxxx, r1.xyzx +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 20 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_2_1024[] = +{ + 68, 88, 66, 67, 130, 225, + 168, 26, 4, 102, 26, 127, + 102, 67, 185, 3, 166, 201, + 236, 118, 1, 0, 0, 0, + 136, 5, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 12, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 192, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 192, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 4, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 224, 2, 0, 0, 64, 0, + 1, 0, 184, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 0, 12, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 50, 0, 16, 0, + 0, 0, 0, 0, 70, 16, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 2, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 16, 0, 0, 7, 34, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 3, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 0, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 66, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 68, 0, 0, 5, + 18, 0, 16, 0, 0, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 56, 0, + 0, 7, 114, 32, 16, 0, + 1, 0, 0, 0, 6, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 8, + 242, 32, 16, 0, 2, 0, + 0, 0, 2, 64, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, + 116, 0, 0, 0, 20, 0, + 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 7, 0, + 0, 0, 12, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_4_1024 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Normal_4_1024._fxctmp +// /EStreamOutSkinVS_Position_Normal_4_1024 /D BONESPERVERTEX=4 /D +// BONECOUNT=1024 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[1024]; // Offset: 0 Size: 49152 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[3072], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.zzzz, cb0[r1.z + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.wwww, cb0[r1.w + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +dp3 r2.x, v1.xyzx, r2.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.wwww, cb0[r1.w + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +dp3 r2.y, v1.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 2].xyzw, r3.xyzw +mad r1.xyzw, v3.wwww, cb0[r1.w + 2].xyzw, r3.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r2.z, v1.xyzx, r1.xyzx +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o1.xyz, r0.xxxx, r2.xyzx +mov o2.xyzw, l(0,0,0,0) +ret +// Approximately 26 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_4_1024[] = +{ + 68, 88, 66, 67, 32, 205, + 153, 254, 94, 143, 155, 24, + 190, 41, 240, 122, 149, 200, + 107, 78, 1, 0, 0, 0, + 160, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 36, 6, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 192, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 192, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 4, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 248, 3, 0, 0, 64, 0, + 1, 0, 254, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 0, 12, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 242, 0, 16, 0, 1, 0, + 0, 0, 70, 30, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 2, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 2, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 34, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 3, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 1, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 66, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 68, 0, 0, 5, 18, 0, + 16, 0, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 1, 0, + 0, 0, 6, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 54, 0, 0, 8, 242, 32, + 16, 0, 2, 0, 0, 0, + 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 26, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, + 12, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_Tangent_1_32 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 +// /FhStreamOutSkinVS_Position_Normal_Tangent_1_32._fxctmp +// /EStreamOutSkinVS_Position_Normal_Tangent_1_32 /D BONESPERVERTEX=1 /D +// BONECOUNT=32 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[32]; // Offset: 0 Size: 1536 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float xyzw +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[96], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v2.xyzw +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.x, v3.x, l(3) +dp4 o0.x, r0.xyzw, cb0[r1.x + 0].xyzw +dp4 o0.y, r0.xyzw, cb0[r1.x + 1].xyzw +dp4 o0.z, r0.xyzw, cb0[r1.x + 2].xyzw +dp3 r0.x, v1.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v1.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v1.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +dp3 r0.x, v2.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v2.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v2.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o2.xyz, r0.wwww, r0.xyzx +mov o2.w, v2.w +ret +// Approximately 20 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_Tangent_1_32[] = +{ + 68, 88, 66, 67, 183, 181, + 30, 175, 253, 170, 103, 5, + 88, 56, 199, 145, 45, 171, + 177, 63, 1, 0, 0, 0, + 72, 5, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 204, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 6, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 32, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 200, 2, 0, 0, + 64, 0, 1, 0, 178, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 96, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 1, 0, 0, 0, + 95, 0, 0, 3, 242, 16, + 16, 0, 2, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 38, 0, 0, 8, 0, 208, + 0, 0, 18, 0, 16, 0, + 1, 0, 0, 0, 10, 16, + 16, 0, 3, 0, 0, 0, + 1, 64, 0, 0, 3, 0, + 0, 0, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 9, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 4, 0, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 10, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 130, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 130, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 68, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 1, 0, 0, 0, + 246, 15, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 16, 0, + 0, 9, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 130, 32, 4, 0, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 10, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 2, 0, 0, 0, 70, 130, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 130, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 68, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 2, 0, 0, 0, + 246, 15, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, + 2, 0, 0, 0, 58, 16, + 16, 0, 2, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 20, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 15, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_Tangent_2_32 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 +// /FhStreamOutSkinVS_Position_Normal_Tangent_2_32._fxctmp +// /EStreamOutSkinVS_Position_Normal_Tangent_2_32 /D BONESPERVERTEX=2 /D +// BONECOUNT=32 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[32]; // Offset: 0 Size: 1536 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[96], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v2.xyzw +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 5 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xy, v4.xyxx, l(3, 3, 0, 0) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +mul r4.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r1.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r4.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r0.x, v1.xyzx, r2.xyzx +dp3 r2.x, v2.xyzx, r2.xyzx +dp3 r0.y, v1.xyzx, r3.xyzx +dp3 r2.y, v2.xyzx, r3.xyzx +dp3 r0.z, v1.xyzx, r1.xyzx +dp3 r2.z, v2.xyzx, r1.xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r2.xyzx +mov o2.w, v2.w +ret +// Approximately 26 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_Tangent_2_32[] = +{ + 68, 88, 66, 67, 181, 251, + 117, 126, 214, 41, 151, 11, + 206, 111, 25, 183, 118, 223, + 26, 216, 1, 0, 0, 0, + 40, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 172, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 6, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 32, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 128, 3, 0, 0, 64, 0, + 1, 0, 224, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 96, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 5, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 50, 0, 16, 0, 1, 0, + 0, 0, 70, 16, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 3, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 26, 0, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 3, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 3, 0, 0, 0, 17, 0, + 0, 7, 34, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 4, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 1, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 4, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 2, 0, + 0, 0, 70, 18, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 16, 0, 0, 7, 34, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 3, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 16, 0, 0, 7, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 2, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 2, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 130, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 68, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 58, 0, 16, 0, + 0, 0, 0, 0, 56, 0, + 0, 7, 114, 32, 16, 0, + 1, 0, 0, 0, 246, 15, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 68, 0, 0, 5, 18, 0, + 16, 0, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 2, 0, + 0, 0, 6, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 54, 0, 0, 5, 130, 32, + 16, 0, 2, 0, 0, 0, + 58, 16, 16, 0, 2, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 26, 0, 0, 0, + 5, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 0, + 18, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_Tangent_4_32 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 +// /FhStreamOutSkinVS_Position_Normal_Tangent_4_32._fxctmp +// /EStreamOutSkinVS_Position_Normal_Tangent_4_32 /D BONESPERVERTEX=4 /D +// BONECOUNT=32 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[32]; // Offset: 0 Size: 1536 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[96], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v2.xyzw +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 5 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.zzzz, cb0[r1.z + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.wwww, cb0[r1.w + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.wwww, cb0[r1.w + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +mul r4.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r4.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r4.xyzw +mad r4.xyzw, v3.zzzz, cb0[r1.z + 2].xyzw, r4.xyzw +mad r1.xyzw, v3.wwww, cb0[r1.w + 2].xyzw, r4.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r0.x, v1.xyzx, r2.xyzx +dp3 r2.x, v2.xyzx, r2.xyzx +dp3 r0.y, v1.xyzx, r3.xyzx +dp3 r2.y, v2.xyzx, r3.xyzx +dp3 r0.z, v1.xyzx, r1.xyzx +dp3 r2.z, v2.xyzx, r1.xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r2.xyzx +mov o2.w, v2.w +ret +// Approximately 32 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_Tangent_4_32[] = +{ + 68, 88, 66, 67, 19, 221, + 121, 113, 127, 28, 29, 87, + 46, 3, 179, 249, 93, 103, + 188, 212, 1, 0, 0, 0, + 64, 7, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 196, 6, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 6, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 32, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 152, 4, 0, 0, 64, 0, + 1, 0, 38, 1, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 96, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 5, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 242, 0, 16, 0, 1, 0, + 0, 0, 70, 30, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 2, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 2, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 1, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 42, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 246, 31, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 58, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 4, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 26, 0, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 4, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 4, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 4, 0, 0, 0, 166, 26, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 4, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 58, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 4, 0, 0, 0, 17, 0, + 0, 7, 66, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 2, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 16, 0, 0, 7, + 34, 0, 16, 0, 2, 0, + 0, 0, 70, 18, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 3, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 66, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 130, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 68, 0, 0, 5, 130, 0, + 16, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 1, 0, + 0, 0, 246, 15, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 68, 0, + 0, 5, 18, 0, 16, 0, + 0, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 2, 0, 0, 0, + 6, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, + 2, 0, 0, 0, 58, 16, + 16, 0, 2, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 32, 0, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 18, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_Tangent_1_64 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 +// /FhStreamOutSkinVS_Position_Normal_Tangent_1_64._fxctmp +// /EStreamOutSkinVS_Position_Normal_Tangent_1_64 /D BONESPERVERTEX=1 /D +// BONECOUNT=64 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[64]; // Offset: 0 Size: 3072 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float xyzw +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[192], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v2.xyzw +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.x, v3.x, l(3) +dp4 o0.x, r0.xyzw, cb0[r1.x + 0].xyzw +dp4 o0.y, r0.xyzw, cb0[r1.x + 1].xyzw +dp4 o0.z, r0.xyzw, cb0[r1.x + 2].xyzw +dp3 r0.x, v1.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v1.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v1.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +dp3 r0.x, v2.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v2.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v2.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o2.xyz, r0.wwww, r0.xyzx +mov o2.w, v2.w +ret +// Approximately 20 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_Tangent_1_64[] = +{ + 68, 88, 66, 67, 67, 223, + 94, 248, 228, 40, 152, 39, + 164, 84, 254, 169, 168, 108, + 132, 56, 1, 0, 0, 0, + 72, 5, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 204, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 12, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 12, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 64, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 200, 2, 0, 0, + 64, 0, 1, 0, 178, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 192, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 1, 0, 0, 0, + 95, 0, 0, 3, 242, 16, + 16, 0, 2, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 38, 0, 0, 8, 0, 208, + 0, 0, 18, 0, 16, 0, + 1, 0, 0, 0, 10, 16, + 16, 0, 3, 0, 0, 0, + 1, 64, 0, 0, 3, 0, + 0, 0, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 9, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 4, 0, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 10, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 130, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 130, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 68, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 1, 0, 0, 0, + 246, 15, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 16, 0, + 0, 9, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 130, 32, 4, 0, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 10, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 2, 0, 0, 0, 70, 130, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 130, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 68, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 2, 0, 0, 0, + 246, 15, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, + 2, 0, 0, 0, 58, 16, + 16, 0, 2, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 20, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 15, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_Tangent_2_64 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 +// /FhStreamOutSkinVS_Position_Normal_Tangent_2_64._fxctmp +// /EStreamOutSkinVS_Position_Normal_Tangent_2_64 /D BONESPERVERTEX=2 /D +// BONECOUNT=64 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[64]; // Offset: 0 Size: 3072 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[192], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v2.xyzw +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 5 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xy, v4.xyxx, l(3, 3, 0, 0) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +mul r4.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r1.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r4.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r0.x, v1.xyzx, r2.xyzx +dp3 r2.x, v2.xyzx, r2.xyzx +dp3 r0.y, v1.xyzx, r3.xyzx +dp3 r2.y, v2.xyzx, r3.xyzx +dp3 r0.z, v1.xyzx, r1.xyzx +dp3 r2.z, v2.xyzx, r1.xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r2.xyzx +mov o2.w, v2.w +ret +// Approximately 26 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_Tangent_2_64[] = +{ + 68, 88, 66, 67, 91, 181, + 220, 66, 242, 236, 115, 101, + 110, 154, 12, 56, 22, 247, + 167, 255, 1, 0, 0, 0, + 40, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 172, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 12, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 12, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 64, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 128, 3, 0, 0, 64, 0, + 1, 0, 224, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 192, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 5, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 50, 0, 16, 0, 1, 0, + 0, 0, 70, 16, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 3, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 26, 0, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 3, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 3, 0, 0, 0, 17, 0, + 0, 7, 34, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 4, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 1, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 4, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 2, 0, + 0, 0, 70, 18, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 16, 0, 0, 7, 34, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 3, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 16, 0, 0, 7, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 2, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 2, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 130, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 68, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 58, 0, 16, 0, + 0, 0, 0, 0, 56, 0, + 0, 7, 114, 32, 16, 0, + 1, 0, 0, 0, 246, 15, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 68, 0, 0, 5, 18, 0, + 16, 0, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 2, 0, + 0, 0, 6, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 54, 0, 0, 5, 130, 32, + 16, 0, 2, 0, 0, 0, + 58, 16, 16, 0, 2, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 26, 0, 0, 0, + 5, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 0, + 18, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_Tangent_4_64 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 +// /FhStreamOutSkinVS_Position_Normal_Tangent_4_64._fxctmp +// /EStreamOutSkinVS_Position_Normal_Tangent_4_64 /D BONESPERVERTEX=4 /D +// BONECOUNT=64 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[64]; // Offset: 0 Size: 3072 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[192], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v2.xyzw +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 5 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.zzzz, cb0[r1.z + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.wwww, cb0[r1.w + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.wwww, cb0[r1.w + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +mul r4.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r4.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r4.xyzw +mad r4.xyzw, v3.zzzz, cb0[r1.z + 2].xyzw, r4.xyzw +mad r1.xyzw, v3.wwww, cb0[r1.w + 2].xyzw, r4.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r0.x, v1.xyzx, r2.xyzx +dp3 r2.x, v2.xyzx, r2.xyzx +dp3 r0.y, v1.xyzx, r3.xyzx +dp3 r2.y, v2.xyzx, r3.xyzx +dp3 r0.z, v1.xyzx, r1.xyzx +dp3 r2.z, v2.xyzx, r1.xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r2.xyzx +mov o2.w, v2.w +ret +// Approximately 32 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_Tangent_4_64[] = +{ + 68, 88, 66, 67, 119, 209, + 156, 16, 140, 0, 156, 224, + 87, 117, 200, 45, 39, 172, + 135, 2, 1, 0, 0, 0, + 64, 7, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 196, 6, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 12, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 12, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 64, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 152, 4, 0, 0, 64, 0, + 1, 0, 38, 1, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 192, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 5, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 242, 0, 16, 0, 1, 0, + 0, 0, 70, 30, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 2, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 2, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 1, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 42, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 246, 31, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 58, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 4, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 26, 0, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 4, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 4, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 4, 0, 0, 0, 166, 26, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 4, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 58, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 4, 0, 0, 0, 17, 0, + 0, 7, 66, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 2, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 16, 0, 0, 7, + 34, 0, 16, 0, 2, 0, + 0, 0, 70, 18, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 3, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 66, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 130, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 68, 0, 0, 5, 130, 0, + 16, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 1, 0, + 0, 0, 246, 15, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 68, 0, + 0, 5, 18, 0, 16, 0, + 0, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 2, 0, 0, 0, + 6, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, + 2, 0, 0, 0, 58, 16, + 16, 0, 2, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 32, 0, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 18, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_Tangent_1_128 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 +// /FhStreamOutSkinVS_Position_Normal_Tangent_1_128._fxctmp +// /EStreamOutSkinVS_Position_Normal_Tangent_1_128 /D BONESPERVERTEX=1 /D +// BONECOUNT=128 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[128]; // Offset: 0 Size: 6144 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float xyzw +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[384], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v2.xyzw +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.x, v3.x, l(3) +dp4 o0.x, r0.xyzw, cb0[r1.x + 0].xyzw +dp4 o0.y, r0.xyzw, cb0[r1.x + 1].xyzw +dp4 o0.z, r0.xyzw, cb0[r1.x + 2].xyzw +dp3 r0.x, v1.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v1.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v1.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +dp3 r0.x, v2.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v2.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v2.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o2.xyz, r0.wwww, r0.xyzx +mov o2.w, v2.w +ret +// Approximately 20 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_Tangent_1_128[] = +{ + 68, 88, 66, 67, 209, 116, + 248, 215, 32, 190, 187, 116, + 43, 145, 110, 83, 6, 70, + 244, 224, 1, 0, 0, 0, + 72, 5, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 204, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 24, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 24, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 128, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 200, 2, 0, 0, + 64, 0, 1, 0, 178, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 128, 1, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 1, 0, 0, 0, + 95, 0, 0, 3, 242, 16, + 16, 0, 2, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 38, 0, 0, 8, 0, 208, + 0, 0, 18, 0, 16, 0, + 1, 0, 0, 0, 10, 16, + 16, 0, 3, 0, 0, 0, + 1, 64, 0, 0, 3, 0, + 0, 0, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 9, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 4, 0, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 10, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 130, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 130, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 68, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 1, 0, 0, 0, + 246, 15, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 16, 0, + 0, 9, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 130, 32, 4, 0, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 10, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 2, 0, 0, 0, 70, 130, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 130, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 68, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 2, 0, 0, 0, + 246, 15, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, + 2, 0, 0, 0, 58, 16, + 16, 0, 2, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 20, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 15, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_Tangent_2_128 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 +// /FhStreamOutSkinVS_Position_Normal_Tangent_2_128._fxctmp +// /EStreamOutSkinVS_Position_Normal_Tangent_2_128 /D BONESPERVERTEX=2 /D +// BONECOUNT=128 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[128]; // Offset: 0 Size: 6144 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[384], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v2.xyzw +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 5 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xy, v4.xyxx, l(3, 3, 0, 0) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +mul r4.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r1.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r4.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r0.x, v1.xyzx, r2.xyzx +dp3 r2.x, v2.xyzx, r2.xyzx +dp3 r0.y, v1.xyzx, r3.xyzx +dp3 r2.y, v2.xyzx, r3.xyzx +dp3 r0.z, v1.xyzx, r1.xyzx +dp3 r2.z, v2.xyzx, r1.xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r2.xyzx +mov o2.w, v2.w +ret +// Approximately 26 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_Tangent_2_128[] = +{ + 68, 88, 66, 67, 240, 99, + 184, 65, 42, 15, 79, 214, + 188, 103, 143, 167, 243, 249, + 180, 251, 1, 0, 0, 0, + 40, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 172, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 24, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 24, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 128, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 128, 3, 0, 0, 64, 0, + 1, 0, 224, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 128, 1, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 5, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 50, 0, 16, 0, 1, 0, + 0, 0, 70, 16, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 3, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 26, 0, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 3, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 3, 0, 0, 0, 17, 0, + 0, 7, 34, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 4, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 1, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 4, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 2, 0, + 0, 0, 70, 18, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 16, 0, 0, 7, 34, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 3, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 16, 0, 0, 7, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 2, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 2, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 130, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 68, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 58, 0, 16, 0, + 0, 0, 0, 0, 56, 0, + 0, 7, 114, 32, 16, 0, + 1, 0, 0, 0, 246, 15, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 68, 0, 0, 5, 18, 0, + 16, 0, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 2, 0, + 0, 0, 6, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 54, 0, 0, 5, 130, 32, + 16, 0, 2, 0, 0, 0, + 58, 16, 16, 0, 2, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 26, 0, 0, 0, + 5, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 0, + 18, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_Tangent_4_128 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 +// /FhStreamOutSkinVS_Position_Normal_Tangent_4_128._fxctmp +// /EStreamOutSkinVS_Position_Normal_Tangent_4_128 /D BONESPERVERTEX=4 /D +// BONECOUNT=128 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[128]; // Offset: 0 Size: 6144 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[384], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v2.xyzw +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 5 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.zzzz, cb0[r1.z + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.wwww, cb0[r1.w + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.wwww, cb0[r1.w + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +mul r4.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r4.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r4.xyzw +mad r4.xyzw, v3.zzzz, cb0[r1.z + 2].xyzw, r4.xyzw +mad r1.xyzw, v3.wwww, cb0[r1.w + 2].xyzw, r4.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r0.x, v1.xyzx, r2.xyzx +dp3 r2.x, v2.xyzx, r2.xyzx +dp3 r0.y, v1.xyzx, r3.xyzx +dp3 r2.y, v2.xyzx, r3.xyzx +dp3 r0.z, v1.xyzx, r1.xyzx +dp3 r2.z, v2.xyzx, r1.xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r2.xyzx +mov o2.w, v2.w +ret +// Approximately 32 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_Tangent_4_128[] = +{ + 68, 88, 66, 67, 186, 105, + 76, 213, 38, 43, 19, 216, + 240, 103, 215, 141, 162, 38, + 94, 232, 1, 0, 0, 0, + 64, 7, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 196, 6, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 24, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 24, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 128, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 152, 4, 0, 0, 64, 0, + 1, 0, 38, 1, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 128, 1, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 5, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 242, 0, 16, 0, 1, 0, + 0, 0, 70, 30, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 2, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 2, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 1, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 42, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 246, 31, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 58, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 4, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 26, 0, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 4, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 4, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 4, 0, 0, 0, 166, 26, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 4, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 58, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 4, 0, 0, 0, 17, 0, + 0, 7, 66, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 2, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 16, 0, 0, 7, + 34, 0, 16, 0, 2, 0, + 0, 0, 70, 18, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 3, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 66, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 130, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 68, 0, 0, 5, 130, 0, + 16, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 1, 0, + 0, 0, 246, 15, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 68, 0, + 0, 5, 18, 0, 16, 0, + 0, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 2, 0, 0, 0, + 6, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, + 2, 0, 0, 0, 58, 16, + 16, 0, 2, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 32, 0, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 18, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_Tangent_1_512 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 +// /FhStreamOutSkinVS_Position_Normal_Tangent_1_512._fxctmp +// /EStreamOutSkinVS_Position_Normal_Tangent_1_512 /D BONESPERVERTEX=1 /D +// BONECOUNT=512 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[512]; // Offset: 0 Size: 24576 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float xyzw +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[1536], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v2.xyzw +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.x, v3.x, l(3) +dp4 o0.x, r0.xyzw, cb0[r1.x + 0].xyzw +dp4 o0.y, r0.xyzw, cb0[r1.x + 1].xyzw +dp4 o0.z, r0.xyzw, cb0[r1.x + 2].xyzw +dp3 r0.x, v1.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v1.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v1.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +dp3 r0.x, v2.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v2.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v2.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o2.xyz, r0.wwww, r0.xyzx +mov o2.w, v2.w +ret +// Approximately 20 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_Tangent_1_512[] = +{ + 68, 88, 66, 67, 248, 168, + 89, 63, 27, 139, 214, 175, + 110, 127, 239, 55, 216, 27, + 36, 163, 1, 0, 0, 0, + 72, 5, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 204, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 96, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 96, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 2, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 200, 2, 0, 0, + 64, 0, 1, 0, 178, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 0, 6, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 1, 0, 0, 0, + 95, 0, 0, 3, 242, 16, + 16, 0, 2, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 38, 0, 0, 8, 0, 208, + 0, 0, 18, 0, 16, 0, + 1, 0, 0, 0, 10, 16, + 16, 0, 3, 0, 0, 0, + 1, 64, 0, 0, 3, 0, + 0, 0, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 9, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 4, 0, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 10, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 130, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 130, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 68, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 1, 0, 0, 0, + 246, 15, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 16, 0, + 0, 9, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 130, 32, 4, 0, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 10, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 2, 0, 0, 0, 70, 130, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 130, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 68, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 2, 0, 0, 0, + 246, 15, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, + 2, 0, 0, 0, 58, 16, + 16, 0, 2, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 20, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 15, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_Tangent_2_512 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 +// /FhStreamOutSkinVS_Position_Normal_Tangent_2_512._fxctmp +// /EStreamOutSkinVS_Position_Normal_Tangent_2_512 /D BONESPERVERTEX=2 /D +// BONECOUNT=512 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[512]; // Offset: 0 Size: 24576 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[1536], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v2.xyzw +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 5 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xy, v4.xyxx, l(3, 3, 0, 0) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +mul r4.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r1.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r4.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r0.x, v1.xyzx, r2.xyzx +dp3 r2.x, v2.xyzx, r2.xyzx +dp3 r0.y, v1.xyzx, r3.xyzx +dp3 r2.y, v2.xyzx, r3.xyzx +dp3 r0.z, v1.xyzx, r1.xyzx +dp3 r2.z, v2.xyzx, r1.xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r2.xyzx +mov o2.w, v2.w +ret +// Approximately 26 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_Tangent_2_512[] = +{ + 68, 88, 66, 67, 106, 64, + 83, 181, 46, 115, 93, 157, + 45, 156, 32, 62, 119, 179, + 192, 138, 1, 0, 0, 0, + 40, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 172, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 96, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 96, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 2, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 128, 3, 0, 0, 64, 0, + 1, 0, 224, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 0, 6, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 5, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 50, 0, 16, 0, 1, 0, + 0, 0, 70, 16, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 3, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 26, 0, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 3, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 3, 0, 0, 0, 17, 0, + 0, 7, 34, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 4, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 1, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 4, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 2, 0, + 0, 0, 70, 18, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 16, 0, 0, 7, 34, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 3, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 16, 0, 0, 7, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 2, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 2, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 130, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 68, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 58, 0, 16, 0, + 0, 0, 0, 0, 56, 0, + 0, 7, 114, 32, 16, 0, + 1, 0, 0, 0, 246, 15, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 68, 0, 0, 5, 18, 0, + 16, 0, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 2, 0, + 0, 0, 6, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 54, 0, 0, 5, 130, 32, + 16, 0, 2, 0, 0, 0, + 58, 16, 16, 0, 2, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 26, 0, 0, 0, + 5, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 0, + 18, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_Tangent_4_512 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 +// /FhStreamOutSkinVS_Position_Normal_Tangent_4_512._fxctmp +// /EStreamOutSkinVS_Position_Normal_Tangent_4_512 /D BONESPERVERTEX=4 /D +// BONECOUNT=512 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[512]; // Offset: 0 Size: 24576 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[1536], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v2.xyzw +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 5 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.zzzz, cb0[r1.z + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.wwww, cb0[r1.w + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.wwww, cb0[r1.w + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +mul r4.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r4.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r4.xyzw +mad r4.xyzw, v3.zzzz, cb0[r1.z + 2].xyzw, r4.xyzw +mad r1.xyzw, v3.wwww, cb0[r1.w + 2].xyzw, r4.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r0.x, v1.xyzx, r2.xyzx +dp3 r2.x, v2.xyzx, r2.xyzx +dp3 r0.y, v1.xyzx, r3.xyzx +dp3 r2.y, v2.xyzx, r3.xyzx +dp3 r0.z, v1.xyzx, r1.xyzx +dp3 r2.z, v2.xyzx, r1.xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r2.xyzx +mov o2.w, v2.w +ret +// Approximately 32 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_Tangent_4_512[] = +{ + 68, 88, 66, 67, 87, 16, + 47, 46, 228, 240, 151, 146, + 31, 201, 168, 179, 229, 105, + 94, 127, 1, 0, 0, 0, + 64, 7, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 196, 6, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 96, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 96, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 2, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 152, 4, 0, 0, 64, 0, + 1, 0, 38, 1, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 0, 6, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 5, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 242, 0, 16, 0, 1, 0, + 0, 0, 70, 30, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 2, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 2, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 1, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 42, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 246, 31, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 58, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 4, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 26, 0, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 4, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 4, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 4, 0, 0, 0, 166, 26, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 4, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 58, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 4, 0, 0, 0, 17, 0, + 0, 7, 66, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 2, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 16, 0, 0, 7, + 34, 0, 16, 0, 2, 0, + 0, 0, 70, 18, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 3, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 66, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 130, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 68, 0, 0, 5, 130, 0, + 16, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 1, 0, + 0, 0, 246, 15, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 68, 0, + 0, 5, 18, 0, 16, 0, + 0, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 2, 0, 0, 0, + 6, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, + 2, 0, 0, 0, 58, 16, + 16, 0, 2, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 32, 0, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 18, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_Tangent_1_1024 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 +// /FhStreamOutSkinVS_Position_Normal_Tangent_1_1024._fxctmp +// /EStreamOutSkinVS_Position_Normal_Tangent_1_1024 /D BONESPERVERTEX=1 /D +// BONECOUNT=1024 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[1024]; // Offset: 0 Size: 49152 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float xyzw +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[3072], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v2.xyzw +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.x, v3.x, l(3) +dp4 o0.x, r0.xyzw, cb0[r1.x + 0].xyzw +dp4 o0.y, r0.xyzw, cb0[r1.x + 1].xyzw +dp4 o0.z, r0.xyzw, cb0[r1.x + 2].xyzw +dp3 r0.x, v1.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v1.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v1.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +dp3 r0.x, v2.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v2.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v2.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o2.xyz, r0.wwww, r0.xyzx +mov o2.w, v2.w +ret +// Approximately 20 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_Tangent_1_1024[] = +{ + 68, 88, 66, 67, 77, 124, + 209, 92, 234, 48, 143, 191, + 150, 28, 205, 73, 128, 69, + 35, 47, 1, 0, 0, 0, + 72, 5, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 204, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 192, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 192, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 4, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 200, 2, 0, 0, + 64, 0, 1, 0, 178, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 0, 12, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 1, 0, 0, 0, + 95, 0, 0, 3, 242, 16, + 16, 0, 2, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 38, 0, 0, 8, 0, 208, + 0, 0, 18, 0, 16, 0, + 1, 0, 0, 0, 10, 16, + 16, 0, 3, 0, 0, 0, + 1, 64, 0, 0, 3, 0, + 0, 0, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 9, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 4, 0, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 10, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 130, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 130, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 68, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 1, 0, 0, 0, + 246, 15, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 16, 0, + 0, 9, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 130, 32, 4, 0, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 10, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 2, 0, 0, 0, 70, 130, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 130, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 68, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 2, 0, 0, 0, + 246, 15, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, + 2, 0, 0, 0, 58, 16, + 16, 0, 2, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 20, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 15, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_Tangent_2_1024 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 +// /FhStreamOutSkinVS_Position_Normal_Tangent_2_1024._fxctmp +// /EStreamOutSkinVS_Position_Normal_Tangent_2_1024 /D BONESPERVERTEX=2 /D +// BONECOUNT=1024 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[1024]; // Offset: 0 Size: 49152 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[3072], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v2.xyzw +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 5 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xy, v4.xyxx, l(3, 3, 0, 0) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +mul r4.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r1.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r4.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r0.x, v1.xyzx, r2.xyzx +dp3 r2.x, v2.xyzx, r2.xyzx +dp3 r0.y, v1.xyzx, r3.xyzx +dp3 r2.y, v2.xyzx, r3.xyzx +dp3 r0.z, v1.xyzx, r1.xyzx +dp3 r2.z, v2.xyzx, r1.xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r2.xyzx +mov o2.w, v2.w +ret +// Approximately 26 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_Tangent_2_1024[] = +{ + 68, 88, 66, 67, 141, 10, + 58, 114, 205, 161, 106, 233, + 192, 250, 130, 22, 138, 17, + 51, 208, 1, 0, 0, 0, + 40, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 172, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 192, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 192, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 4, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 128, 3, 0, 0, 64, 0, + 1, 0, 224, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 0, 12, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 5, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 50, 0, 16, 0, 1, 0, + 0, 0, 70, 16, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 3, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 26, 0, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 3, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 3, 0, 0, 0, 17, 0, + 0, 7, 34, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 4, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 1, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 4, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 2, 0, + 0, 0, 70, 18, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 16, 0, 0, 7, 34, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 3, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 16, 0, 0, 7, + 66, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 2, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 2, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 130, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 68, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 58, 0, 16, 0, + 0, 0, 0, 0, 56, 0, + 0, 7, 114, 32, 16, 0, + 1, 0, 0, 0, 246, 15, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 68, 0, 0, 5, 18, 0, + 16, 0, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 2, 0, + 0, 0, 6, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 54, 0, 0, 5, 130, 32, + 16, 0, 2, 0, 0, 0, + 58, 16, 16, 0, 2, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 26, 0, 0, 0, + 5, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 0, + 18, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Normal_Tangent_4_1024 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 +// /FhStreamOutSkinVS_Position_Normal_Tangent_4_1024._fxctmp +// /EStreamOutSkinVS_Position_Normal_Tangent_4_1024 /D BONESPERVERTEX=4 /D +// BONECOUNT=1024 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[1024]; // Offset: 0 Size: 49152 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float xyz +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[3072], dynamicIndexed +dcl_input v0.xyz +dcl_input v1.xyz +dcl_input v2.xyzw +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 5 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.zzzz, cb0[r1.z + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.wwww, cb0[r1.w + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.wwww, cb0[r1.w + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +mul r4.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r4.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r4.xyzw +mad r4.xyzw, v3.zzzz, cb0[r1.z + 2].xyzw, r4.xyzw +mad r1.xyzw, v3.wwww, cb0[r1.w + 2].xyzw, r4.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r0.x, v1.xyzx, r2.xyzx +dp3 r2.x, v2.xyzx, r2.xyzx +dp3 r0.y, v1.xyzx, r3.xyzx +dp3 r2.y, v2.xyzx, r3.xyzx +dp3 r0.z, v1.xyzx, r1.xyzx +dp3 r2.z, v2.xyzx, r1.xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o1.xyz, r0.wwww, r0.xyzx +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r2.xyzx +mov o2.w, v2.w +ret +// Approximately 32 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Normal_Tangent_4_1024[] = +{ + 68, 88, 66, 67, 235, 12, + 76, 146, 76, 200, 134, 63, + 160, 113, 162, 246, 112, 11, + 54, 15, 1, 0, 0, 0, + 64, 7, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 196, 6, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 192, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 192, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 4, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 7, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 152, 4, 0, 0, 64, 0, + 1, 0, 38, 1, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 0, 12, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 1, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 5, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 242, 0, 16, 0, 1, 0, + 0, 0, 70, 30, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 2, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 2, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 1, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 42, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 246, 31, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 58, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 56, 0, 0, 10, 242, 0, + 16, 0, 4, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 26, 0, 16, 0, + 1, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 4, 0, 0, 0, 6, 16, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 4, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 4, 0, 0, 0, 166, 26, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 4, 0, 0, 0, 50, 0, + 0, 12, 242, 0, 16, 0, + 1, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 58, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 4, 0, 0, 0, 17, 0, + 0, 7, 66, 32, 16, 0, + 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 18, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 1, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 2, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 1, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 16, 0, 0, 7, + 34, 0, 16, 0, 2, 0, + 0, 0, 70, 18, 16, 0, + 2, 0, 0, 0, 70, 2, + 16, 0, 3, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 66, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 130, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 68, 0, 0, 5, 130, 0, + 16, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 1, 0, + 0, 0, 246, 15, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 68, 0, + 0, 5, 18, 0, 16, 0, + 0, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 2, 0, 0, 0, + 6, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 2, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, + 2, 0, 0, 0, 58, 16, + 16, 0, 2, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 32, 0, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 18, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Tangent_1_32 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Tangent_1_32._fxctmp +// /EStreamOutSkinVS_Position_Tangent_1_32 /D BONESPERVERTEX=1 /D +// BONECOUNT=32 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[32]; // Offset: 0 Size: 1536 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float xyzw +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[96], dynamicIndexed +dcl_input v0.xyz +dcl_input v2.xyzw +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.x, v3.x, l(3) +dp4 o0.x, r0.xyzw, cb0[r1.x + 0].xyzw +dp4 o0.y, r0.xyzw, cb0[r1.x + 1].xyzw +dp4 o0.z, r0.xyzw, cb0[r1.x + 2].xyzw +mov o1.xyz, l(0,0,0,0) +dp3 r0.x, v2.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v2.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v2.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o2.xyz, r0.wwww, r0.xyzx +mov o2.w, v2.w +ret +// Approximately 15 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Tangent_1_32[] = +{ + 68, 88, 66, 67, 155, 136, + 95, 216, 115, 102, 245, 76, + 254, 126, 247, 116, 91, 41, + 64, 92, 1, 0, 0, 0, + 156, 4, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 32, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 6, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 32, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 28, 2, 0, 0, + 64, 0, 1, 0, 135, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 96, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 242, 16, + 16, 0, 2, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 38, 0, 0, 8, 0, 208, + 0, 0, 18, 0, 16, 0, + 1, 0, 0, 0, 10, 16, + 16, 0, 3, 0, 0, 0, + 1, 64, 0, 0, 3, 0, + 0, 0, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 16, 0, 0, 9, 18, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 130, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 10, 34, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 130, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 66, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 130, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 68, 0, 0, 5, 130, 0, + 16, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 2, 0, + 0, 0, 246, 15, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 32, + 16, 0, 2, 0, 0, 0, + 58, 16, 16, 0, 2, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 15, 0, 0, 0, + 2, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, + 9, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Tangent_2_32 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Tangent_2_32._fxctmp +// /EStreamOutSkinVS_Position_Tangent_2_32 /D BONESPERVERTEX=2 /D +// BONECOUNT=32 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[32]; // Offset: 0 Size: 1536 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[96], dynamicIndexed +dcl_input v0.xyz +dcl_input v2.xyzw +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +imul null, r0.xy, v4.xyxx, l(3, 3, 0, 0) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +dp3 r1.x, v2.xyzx, r1.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r3.xyzw +dp4 o0.y, r2.xyzw, r3.xyzw +dp3 r1.y, v2.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r0.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r3.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +dp3 r1.z, v2.xyzx, r0.xyzx +mov o1.xyz, l(0,0,0,0) +dp3 r0.x, r1.xyzx, r1.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r1.xyzx +mov o2.w, v2.w +ret +// Approximately 21 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Tangent_2_32[] = +{ + 68, 88, 66, 67, 74, 166, + 39, 5, 4, 115, 242, 165, + 31, 126, 146, 216, 128, 93, + 62, 203, 1, 0, 0, 0, + 156, 5, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 32, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 6, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 32, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 244, 2, 0, 0, 64, 0, + 1, 0, 189, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 96, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 50, 0, 16, 0, + 0, 0, 0, 0, 70, 16, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 2, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 16, 0, 0, 7, 34, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 3, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 0, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 66, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 68, 0, + 0, 5, 18, 0, 16, 0, + 0, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 2, 0, 0, 0, + 6, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, + 2, 0, 0, 0, 58, 16, + 16, 0, 2, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 21, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 12, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Tangent_4_32 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Tangent_4_32._fxctmp +// /EStreamOutSkinVS_Position_Tangent_4_32 /D BONESPERVERTEX=4 /D +// BONECOUNT=32 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[32]; // Offset: 0 Size: 1536 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[96], dynamicIndexed +dcl_input v0.xyz +dcl_input v2.xyzw +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.zzzz, cb0[r1.z + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.wwww, cb0[r1.w + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +dp3 r2.x, v2.xyzx, r2.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.wwww, cb0[r1.w + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +dp3 r2.y, v2.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 2].xyzw, r3.xyzw +mad r1.xyzw, v3.wwww, cb0[r1.w + 2].xyzw, r3.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r2.z, v2.xyzx, r1.xyzx +mov o1.xyz, l(0,0,0,0) +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r2.xyzx +mov o2.w, v2.w +ret +// Approximately 27 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Tangent_4_32[] = +{ + 68, 88, 66, 67, 101, 9, + 26, 176, 87, 130, 115, 71, + 112, 118, 24, 231, 13, 111, + 146, 143, 1, 0, 0, 0, + 180, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 56, 6, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 6, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 32, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 12, 4, 0, 0, 64, 0, + 1, 0, 3, 1, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 96, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 242, 0, 16, 0, 1, 0, + 0, 0, 70, 30, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 2, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 2, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 34, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 3, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 1, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 66, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 8, + 114, 32, 16, 0, 1, 0, + 0, 0, 2, 64, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 68, 0, 0, 5, + 18, 0, 16, 0, 0, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 56, 0, + 0, 7, 114, 32, 16, 0, + 2, 0, 0, 0, 6, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 54, 0, 0, 5, + 130, 32, 16, 0, 2, 0, + 0, 0, 58, 16, 16, 0, + 2, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, + 116, 0, 0, 0, 27, 0, + 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 7, 0, + 0, 0, 12, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Tangent_1_64 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Tangent_1_64._fxctmp +// /EStreamOutSkinVS_Position_Tangent_1_64 /D BONESPERVERTEX=1 /D +// BONECOUNT=64 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[64]; // Offset: 0 Size: 3072 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float xyzw +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[192], dynamicIndexed +dcl_input v0.xyz +dcl_input v2.xyzw +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.x, v3.x, l(3) +dp4 o0.x, r0.xyzw, cb0[r1.x + 0].xyzw +dp4 o0.y, r0.xyzw, cb0[r1.x + 1].xyzw +dp4 o0.z, r0.xyzw, cb0[r1.x + 2].xyzw +mov o1.xyz, l(0,0,0,0) +dp3 r0.x, v2.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v2.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v2.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o2.xyz, r0.wwww, r0.xyzx +mov o2.w, v2.w +ret +// Approximately 15 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Tangent_1_64[] = +{ + 68, 88, 66, 67, 223, 179, + 178, 177, 55, 242, 85, 24, + 184, 123, 141, 221, 32, 76, + 190, 235, 1, 0, 0, 0, + 156, 4, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 32, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 12, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 12, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 64, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 28, 2, 0, 0, + 64, 0, 1, 0, 135, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 192, 0, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 242, 16, + 16, 0, 2, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 38, 0, 0, 8, 0, 208, + 0, 0, 18, 0, 16, 0, + 1, 0, 0, 0, 10, 16, + 16, 0, 3, 0, 0, 0, + 1, 64, 0, 0, 3, 0, + 0, 0, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 16, 0, 0, 9, 18, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 130, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 10, 34, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 130, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 66, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 130, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 68, 0, 0, 5, 130, 0, + 16, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 2, 0, + 0, 0, 246, 15, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 32, + 16, 0, 2, 0, 0, 0, + 58, 16, 16, 0, 2, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 15, 0, 0, 0, + 2, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, + 9, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Tangent_2_64 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Tangent_2_64._fxctmp +// /EStreamOutSkinVS_Position_Tangent_2_64 /D BONESPERVERTEX=2 /D +// BONECOUNT=64 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[64]; // Offset: 0 Size: 3072 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[192], dynamicIndexed +dcl_input v0.xyz +dcl_input v2.xyzw +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +imul null, r0.xy, v4.xyxx, l(3, 3, 0, 0) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +dp3 r1.x, v2.xyzx, r1.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r3.xyzw +dp4 o0.y, r2.xyzw, r3.xyzw +dp3 r1.y, v2.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r0.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r3.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +dp3 r1.z, v2.xyzx, r0.xyzx +mov o1.xyz, l(0,0,0,0) +dp3 r0.x, r1.xyzx, r1.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r1.xyzx +mov o2.w, v2.w +ret +// Approximately 21 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Tangent_2_64[] = +{ + 68, 88, 66, 67, 17, 28, + 161, 25, 179, 10, 98, 159, + 87, 246, 21, 62, 158, 233, + 50, 151, 1, 0, 0, 0, + 156, 5, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 32, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 12, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 12, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 64, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 244, 2, 0, 0, 64, 0, + 1, 0, 189, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 192, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 50, 0, 16, 0, + 0, 0, 0, 0, 70, 16, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 2, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 16, 0, 0, 7, 34, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 3, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 0, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 66, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 68, 0, + 0, 5, 18, 0, 16, 0, + 0, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 2, 0, 0, 0, + 6, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, + 2, 0, 0, 0, 58, 16, + 16, 0, 2, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 21, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 12, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Tangent_4_64 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Tangent_4_64._fxctmp +// /EStreamOutSkinVS_Position_Tangent_4_64 /D BONESPERVERTEX=4 /D +// BONECOUNT=64 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[64]; // Offset: 0 Size: 3072 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[192], dynamicIndexed +dcl_input v0.xyz +dcl_input v2.xyzw +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.zzzz, cb0[r1.z + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.wwww, cb0[r1.w + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +dp3 r2.x, v2.xyzx, r2.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.wwww, cb0[r1.w + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +dp3 r2.y, v2.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 2].xyzw, r3.xyzw +mad r1.xyzw, v3.wwww, cb0[r1.w + 2].xyzw, r3.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r2.z, v2.xyzx, r1.xyzx +mov o1.xyz, l(0,0,0,0) +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r2.xyzx +mov o2.w, v2.w +ret +// Approximately 27 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Tangent_4_64[] = +{ + 68, 88, 66, 67, 229, 79, + 236, 197, 243, 207, 198, 124, + 162, 172, 47, 223, 207, 244, + 139, 83, 1, 0, 0, 0, + 180, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 56, 6, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 12, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 12, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 64, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 12, 4, 0, 0, 64, 0, + 1, 0, 3, 1, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 192, 0, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 242, 0, 16, 0, 1, 0, + 0, 0, 70, 30, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 2, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 2, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 34, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 3, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 1, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 66, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 8, + 114, 32, 16, 0, 1, 0, + 0, 0, 2, 64, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 68, 0, 0, 5, + 18, 0, 16, 0, 0, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 56, 0, + 0, 7, 114, 32, 16, 0, + 2, 0, 0, 0, 6, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 54, 0, 0, 5, + 130, 32, 16, 0, 2, 0, + 0, 0, 58, 16, 16, 0, + 2, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, + 116, 0, 0, 0, 27, 0, + 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 7, 0, + 0, 0, 12, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Tangent_1_128 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Tangent_1_128._fxctmp +// /EStreamOutSkinVS_Position_Tangent_1_128 /D BONESPERVERTEX=1 /D +// BONECOUNT=128 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[128]; // Offset: 0 Size: 6144 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float xyzw +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[384], dynamicIndexed +dcl_input v0.xyz +dcl_input v2.xyzw +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.x, v3.x, l(3) +dp4 o0.x, r0.xyzw, cb0[r1.x + 0].xyzw +dp4 o0.y, r0.xyzw, cb0[r1.x + 1].xyzw +dp4 o0.z, r0.xyzw, cb0[r1.x + 2].xyzw +mov o1.xyz, l(0,0,0,0) +dp3 r0.x, v2.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v2.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v2.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o2.xyz, r0.wwww, r0.xyzx +mov o2.w, v2.w +ret +// Approximately 15 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Tangent_1_128[] = +{ + 68, 88, 66, 67, 155, 62, + 239, 20, 245, 251, 229, 47, + 64, 93, 111, 50, 202, 43, + 65, 96, 1, 0, 0, 0, + 156, 4, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 32, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 24, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 24, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 128, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 28, 2, 0, 0, + 64, 0, 1, 0, 135, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 128, 1, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 242, 16, + 16, 0, 2, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 38, 0, 0, 8, 0, 208, + 0, 0, 18, 0, 16, 0, + 1, 0, 0, 0, 10, 16, + 16, 0, 3, 0, 0, 0, + 1, 64, 0, 0, 3, 0, + 0, 0, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 16, 0, 0, 9, 18, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 130, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 10, 34, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 130, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 66, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 130, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 68, 0, 0, 5, 130, 0, + 16, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 2, 0, + 0, 0, 246, 15, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 32, + 16, 0, 2, 0, 0, 0, + 58, 16, 16, 0, 2, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 15, 0, 0, 0, + 2, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, + 9, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Tangent_2_128 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Tangent_2_128._fxctmp +// /EStreamOutSkinVS_Position_Tangent_2_128 /D BONESPERVERTEX=2 /D +// BONECOUNT=128 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[128]; // Offset: 0 Size: 6144 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[384], dynamicIndexed +dcl_input v0.xyz +dcl_input v2.xyzw +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +imul null, r0.xy, v4.xyxx, l(3, 3, 0, 0) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +dp3 r1.x, v2.xyzx, r1.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r3.xyzw +dp4 o0.y, r2.xyzw, r3.xyzw +dp3 r1.y, v2.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r0.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r3.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +dp3 r1.z, v2.xyzx, r0.xyzx +mov o1.xyz, l(0,0,0,0) +dp3 r0.x, r1.xyzx, r1.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r1.xyzx +mov o2.w, v2.w +ret +// Approximately 21 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Tangent_2_128[] = +{ + 68, 88, 66, 67, 62, 144, + 168, 178, 158, 150, 177, 42, + 146, 79, 210, 175, 39, 30, + 191, 85, 1, 0, 0, 0, + 156, 5, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 32, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 24, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 24, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 128, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 244, 2, 0, 0, 64, 0, + 1, 0, 189, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 128, 1, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 50, 0, 16, 0, + 0, 0, 0, 0, 70, 16, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 2, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 16, 0, 0, 7, 34, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 3, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 0, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 66, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 68, 0, + 0, 5, 18, 0, 16, 0, + 0, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 2, 0, 0, 0, + 6, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, + 2, 0, 0, 0, 58, 16, + 16, 0, 2, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 21, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 12, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Tangent_4_128 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Tangent_4_128._fxctmp +// /EStreamOutSkinVS_Position_Tangent_4_128 /D BONESPERVERTEX=4 /D +// BONECOUNT=128 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[128]; // Offset: 0 Size: 6144 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[384], dynamicIndexed +dcl_input v0.xyz +dcl_input v2.xyzw +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.zzzz, cb0[r1.z + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.wwww, cb0[r1.w + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +dp3 r2.x, v2.xyzx, r2.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.wwww, cb0[r1.w + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +dp3 r2.y, v2.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 2].xyzw, r3.xyzw +mad r1.xyzw, v3.wwww, cb0[r1.w + 2].xyzw, r3.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r2.z, v2.xyzx, r1.xyzx +mov o1.xyz, l(0,0,0,0) +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r2.xyzx +mov o2.w, v2.w +ret +// Approximately 27 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Tangent_4_128[] = +{ + 68, 88, 66, 67, 137, 190, + 252, 77, 211, 109, 185, 9, + 192, 197, 98, 56, 223, 218, + 111, 4, 1, 0, 0, 0, + 180, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 56, 6, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 24, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 24, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 128, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 12, 4, 0, 0, 64, 0, + 1, 0, 3, 1, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 128, 1, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 242, 0, 16, 0, 1, 0, + 0, 0, 70, 30, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 2, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 2, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 34, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 3, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 1, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 66, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 8, + 114, 32, 16, 0, 1, 0, + 0, 0, 2, 64, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 68, 0, 0, 5, + 18, 0, 16, 0, 0, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 56, 0, + 0, 7, 114, 32, 16, 0, + 2, 0, 0, 0, 6, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 54, 0, 0, 5, + 130, 32, 16, 0, 2, 0, + 0, 0, 58, 16, 16, 0, + 2, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, + 116, 0, 0, 0, 27, 0, + 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 7, 0, + 0, 0, 12, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Tangent_1_512 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Tangent_1_512._fxctmp +// /EStreamOutSkinVS_Position_Tangent_1_512 /D BONESPERVERTEX=1 /D +// BONECOUNT=512 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[512]; // Offset: 0 Size: 24576 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float xyzw +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[1536], dynamicIndexed +dcl_input v0.xyz +dcl_input v2.xyzw +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.x, v3.x, l(3) +dp4 o0.x, r0.xyzw, cb0[r1.x + 0].xyzw +dp4 o0.y, r0.xyzw, cb0[r1.x + 1].xyzw +dp4 o0.z, r0.xyzw, cb0[r1.x + 2].xyzw +mov o1.xyz, l(0,0,0,0) +dp3 r0.x, v2.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v2.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v2.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o2.xyz, r0.wwww, r0.xyzx +mov o2.w, v2.w +ret +// Approximately 15 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Tangent_1_512[] = +{ + 68, 88, 66, 67, 129, 231, + 80, 65, 53, 30, 137, 110, + 197, 69, 143, 55, 142, 52, + 43, 188, 1, 0, 0, 0, + 156, 4, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 32, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 96, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 96, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 2, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 28, 2, 0, 0, + 64, 0, 1, 0, 135, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 0, 6, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 242, 16, + 16, 0, 2, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 38, 0, 0, 8, 0, 208, + 0, 0, 18, 0, 16, 0, + 1, 0, 0, 0, 10, 16, + 16, 0, 3, 0, 0, 0, + 1, 64, 0, 0, 3, 0, + 0, 0, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 16, 0, 0, 9, 18, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 130, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 10, 34, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 130, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 66, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 130, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 68, 0, 0, 5, 130, 0, + 16, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 2, 0, + 0, 0, 246, 15, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 32, + 16, 0, 2, 0, 0, 0, + 58, 16, 16, 0, 2, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 15, 0, 0, 0, + 2, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, + 9, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Tangent_2_512 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Tangent_2_512._fxctmp +// /EStreamOutSkinVS_Position_Tangent_2_512 /D BONESPERVERTEX=2 /D +// BONECOUNT=512 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[512]; // Offset: 0 Size: 24576 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[1536], dynamicIndexed +dcl_input v0.xyz +dcl_input v2.xyzw +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +imul null, r0.xy, v4.xyxx, l(3, 3, 0, 0) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +dp3 r1.x, v2.xyzx, r1.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r3.xyzw +dp4 o0.y, r2.xyzw, r3.xyzw +dp3 r1.y, v2.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r0.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r3.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +dp3 r1.z, v2.xyzx, r0.xyzx +mov o1.xyz, l(0,0,0,0) +dp3 r0.x, r1.xyzx, r1.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r1.xyzx +mov o2.w, v2.w +ret +// Approximately 21 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Tangent_2_512[] = +{ + 68, 88, 66, 67, 113, 49, + 101, 137, 248, 85, 224, 14, + 56, 186, 158, 161, 211, 124, + 112, 55, 1, 0, 0, 0, + 156, 5, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 32, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 96, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 96, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 2, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 244, 2, 0, 0, 64, 0, + 1, 0, 189, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 0, 6, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 50, 0, 16, 0, + 0, 0, 0, 0, 70, 16, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 2, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 16, 0, 0, 7, 34, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 3, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 0, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 66, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 68, 0, + 0, 5, 18, 0, 16, 0, + 0, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 2, 0, 0, 0, + 6, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, + 2, 0, 0, 0, 58, 16, + 16, 0, 2, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 21, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 12, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Tangent_4_512 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Tangent_4_512._fxctmp +// /EStreamOutSkinVS_Position_Tangent_4_512 /D BONESPERVERTEX=4 /D +// BONECOUNT=512 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[512]; // Offset: 0 Size: 24576 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[1536], dynamicIndexed +dcl_input v0.xyz +dcl_input v2.xyzw +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.zzzz, cb0[r1.z + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.wwww, cb0[r1.w + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +dp3 r2.x, v2.xyzx, r2.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.wwww, cb0[r1.w + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +dp3 r2.y, v2.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 2].xyzw, r3.xyzw +mad r1.xyzw, v3.wwww, cb0[r1.w + 2].xyzw, r3.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r2.z, v2.xyzx, r1.xyzx +mov o1.xyz, l(0,0,0,0) +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r2.xyzx +mov o2.w, v2.w +ret +// Approximately 27 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Tangent_4_512[] = +{ + 68, 88, 66, 67, 123, 183, + 28, 216, 174, 74, 90, 228, + 114, 33, 239, 11, 70, 207, + 115, 126, 1, 0, 0, 0, + 180, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 56, 6, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 96, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 96, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 2, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 12, 4, 0, 0, 64, 0, + 1, 0, 3, 1, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 0, 6, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 242, 0, 16, 0, 1, 0, + 0, 0, 70, 30, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 2, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 2, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 34, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 3, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 1, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 66, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 8, + 114, 32, 16, 0, 1, 0, + 0, 0, 2, 64, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 68, 0, 0, 5, + 18, 0, 16, 0, 0, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 56, 0, + 0, 7, 114, 32, 16, 0, + 2, 0, 0, 0, 6, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 54, 0, 0, 5, + 130, 32, 16, 0, 2, 0, + 0, 0, 58, 16, 16, 0, + 2, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, + 116, 0, 0, 0, 27, 0, + 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 7, 0, + 0, 0, 12, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Tangent_1_1024 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Tangent_1_1024._fxctmp +// /EStreamOutSkinVS_Position_Tangent_1_1024 /D BONESPERVERTEX=1 /D +// BONECOUNT=1024 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[1024]; // Offset: 0 Size: 49152 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float xyzw +// BONEINDEX 0 x 3 NONE int x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[3072], dynamicIndexed +dcl_input v0.xyz +dcl_input v2.xyzw +dcl_input v3.x +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 2 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.x, v3.x, l(3) +dp4 o0.x, r0.xyzw, cb0[r1.x + 0].xyzw +dp4 o0.y, r0.xyzw, cb0[r1.x + 1].xyzw +dp4 o0.z, r0.xyzw, cb0[r1.x + 2].xyzw +mov o1.xyz, l(0,0,0,0) +dp3 r0.x, v2.xyzx, cb0[r1.x + 0].xyzx +dp3 r0.y, v2.xyzx, cb0[r1.x + 1].xyzx +dp3 r0.z, v2.xyzx, cb0[r1.x + 2].xyzx +dp3 r0.w, r0.xyzx, r0.xyzx +rsq r0.w, r0.w +mul o2.xyz, r0.wwww, r0.xyzx +mov o2.w, v2.w +ret +// Approximately 15 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Tangent_1_1024[] = +{ + 68, 88, 66, 67, 38, 248, + 167, 170, 23, 21, 153, 218, + 35, 216, 26, 106, 21, 87, + 80, 123, 1, 0, 0, 0, + 156, 4, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 144, 1, + 0, 0, 252, 1, 0, 0, + 32, 4, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 192, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 192, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 4, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 140, 0, + 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 113, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 120, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 3, 0, 0, 0, + 1, 1, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 79, + 78, 69, 73, 78, 68, 69, + 88, 0, 171, 171, 79, 83, + 71, 78, 100, 0, 0, 0, + 3, 0, 0, 0, 8, 0, + 0, 0, 80, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 7, 8, + 0, 0, 89, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, + 2, 0, 0, 0, 15, 0, + 0, 0, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, + 69, 88, 67, 79, 79, 82, + 68, 0, 171, 171, 83, 72, + 68, 82, 28, 2, 0, 0, + 64, 0, 1, 0, 135, 0, + 0, 0, 89, 8, 0, 4, + 70, 142, 32, 0, 0, 0, + 0, 0, 0, 12, 0, 0, + 95, 0, 0, 3, 114, 16, + 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 242, 16, + 16, 0, 2, 0, 0, 0, + 95, 0, 0, 3, 18, 16, + 16, 0, 3, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 0, 0, 0, 0, + 101, 0, 0, 3, 114, 32, + 16, 0, 1, 0, 0, 0, + 101, 0, 0, 3, 242, 32, + 16, 0, 2, 0, 0, 0, + 104, 0, 0, 2, 2, 0, + 0, 0, 54, 0, 0, 5, + 114, 0, 16, 0, 0, 0, + 0, 0, 70, 18, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 5, 130, 0, 16, 0, + 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, + 38, 0, 0, 8, 0, 208, + 0, 0, 18, 0, 16, 0, + 1, 0, 0, 0, 10, 16, + 16, 0, 3, 0, 0, 0, + 1, 64, 0, 0, 3, 0, + 0, 0, 17, 0, 0, 9, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 17, 0, 0, 10, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 17, 0, 0, 10, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 16, 0, 0, 9, 18, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 130, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 10, 34, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 130, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 10, 66, 0, 16, 0, + 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 130, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 10, 0, 16, 0, 1, 0, + 0, 0, 16, 0, 0, 7, + 130, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 68, 0, 0, 5, 130, 0, + 16, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, + 114, 32, 16, 0, 2, 0, + 0, 0, 246, 15, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 32, + 16, 0, 2, 0, 0, 0, + 58, 16, 16, 0, 2, 0, + 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, + 0, 0, 15, 0, 0, 0, + 2, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, + 9, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Tangent_2_1024 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Tangent_2_1024._fxctmp +// /EStreamOutSkinVS_Position_Tangent_2_1024 /D BONESPERVERTEX=2 /D +// BONECOUNT=1024 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[1024]; // Offset: 0 Size: 49152 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xy 3 NONE float xy +// BLENDINDICES 0 xy 4 NONE int xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[3072], dynamicIndexed +dcl_input v0.xyz +dcl_input v2.xyzw +dcl_input v3.xy +dcl_input v4.xy +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +imul null, r0.xy, v4.xyxx, l(3, 3, 0, 0) +mul r1.xyzw, v3.yyyy, cb0[r0.y + 0].xyzw +mad r1.xyzw, v3.xxxx, cb0[r0.x + 0].xyzw, r1.xyzw +mov r2.xyz, v0.xyzx +mov r2.w, l(1.000000) +dp4 o0.x, r2.xyzw, r1.xyzw +dp3 r1.x, v2.xyzx, r1.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r0.x + 1].xyzw, r3.xyzw +dp4 o0.y, r2.xyzw, r3.xyzw +dp3 r1.y, v2.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r0.y + 2].xyzw +mad r0.xyzw, v3.xxxx, cb0[r0.x + 2].xyzw, r3.xyzw +dp4 o0.z, r2.xyzw, r0.xyzw +dp3 r1.z, v2.xyzx, r0.xyzx +mov o1.xyz, l(0,0,0,0) +dp3 r0.x, r1.xyzx, r1.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r1.xyzx +mov o2.w, v2.w +ret +// Approximately 21 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Tangent_2_1024[] = +{ + 68, 88, 66, 67, 145, 156, + 116, 21, 77, 210, 128, 144, + 84, 248, 102, 43, 138, 123, + 120, 5, 1, 0, 0, 0, + 156, 5, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 32, 5, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 192, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 192, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 4, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 3, 3, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 3, 3, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 244, 2, 0, 0, 64, 0, + 1, 0, 189, 0, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 0, 12, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 50, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 38, 0, 0, 11, 0, 208, + 0, 0, 50, 0, 16, 0, + 0, 0, 0, 0, 70, 16, + 16, 0, 4, 0, 0, 0, + 2, 64, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 56, 0, 0, 9, + 242, 0, 16, 0, 1, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 1, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 114, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, + 16, 0, 2, 0, 0, 0, + 1, 64, 0, 0, 0, 0, + 128, 63, 17, 0, 0, 7, + 18, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 1, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 1, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 3, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 34, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 16, 0, 0, 7, 34, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 3, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, + 3, 0, 0, 0, 86, 21, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 6, 0, 0, + 0, 0, 2, 0, 0, 0, + 26, 0, 16, 0, 0, 0, + 0, 0, 50, 0, 0, 12, + 242, 0, 16, 0, 0, 0, + 0, 0, 6, 16, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 3, 0, + 0, 0, 17, 0, 0, 7, + 66, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 66, 0, + 16, 0, 1, 0, 0, 0, + 70, 18, 16, 0, 2, 0, + 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 54, 0, + 0, 8, 114, 32, 16, 0, + 1, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 16, 0, 0, 7, 18, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 68, 0, + 0, 5, 18, 0, 16, 0, + 0, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, + 56, 0, 0, 7, 114, 32, + 16, 0, 2, 0, 0, 0, + 6, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, + 1, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, + 2, 0, 0, 0, 58, 16, + 16, 0, 2, 0, 0, 0, + 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, + 21, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 12, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0 +}; +//-------------------------------------------------------------- +// StreamOutSkinVS_Position_Tangent_4_1024 +//-------------------------------------------------------------- +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111 +// +// +// fxc /nologo /T vs_4_0 /FhStreamOutSkinVS_Position_Tangent_4_1024._fxctmp +// /EStreamOutSkinVS_Position_Tangent_4_1024 /D BONESPERVERTEX=4 /D +// BONECOUNT=1024 internalshaders.hlsl +// +// +// Buffer Definitions: +// +// cbuffer cbBones +// { +// +// float4x3 bones[1024]; // Offset: 0 Size: 49152 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// cbBones cbuffer NA NA 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// NORMAL 0 xyz 1 NONE float +// TANGENT 0 xyzw 2 NONE float xyzw +// BLENDWEIGHT 0 xyzw 3 NONE float xyzw +// BLENDINDICES 0 xyzw 4 NONE int xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------ ------ +// POSITION 0 xyz 0 NONE float xyz +// TEXCOORD 0 xyz 1 NONE float xyz +// TEXCOORD 1 xyzw 2 NONE float xyzw +// +vs_4_0 +dcl_constantbuffer cb0[3072], dynamicIndexed +dcl_input v0.xyz +dcl_input v2.xyzw +dcl_input v3.xyzw +dcl_input v4.xyzw +dcl_output o0.xyz +dcl_output o1.xyz +dcl_output o2.xyzw +dcl_temps 4 +mov r0.xyz, v0.xyzx +mov r0.w, l(1.000000) +imul null, r1.xyzw, v4.xyzw, l(3, 3, 3, 3) +mul r2.xyzw, v3.yyyy, cb0[r1.y + 0].xyzw +mad r2.xyzw, v3.xxxx, cb0[r1.x + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.zzzz, cb0[r1.z + 0].xyzw, r2.xyzw +mad r2.xyzw, v3.wwww, cb0[r1.w + 0].xyzw, r2.xyzw +dp4 o0.x, r0.xyzw, r2.xyzw +dp3 r2.x, v2.xyzx, r2.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 1].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 1].xyzw, r3.xyzw +mad r3.xyzw, v3.wwww, cb0[r1.w + 1].xyzw, r3.xyzw +dp4 o0.y, r0.xyzw, r3.xyzw +dp3 r2.y, v2.xyzx, r3.xyzx +mul r3.xyzw, v3.yyyy, cb0[r1.y + 2].xyzw +mad r3.xyzw, v3.xxxx, cb0[r1.x + 2].xyzw, r3.xyzw +mad r3.xyzw, v3.zzzz, cb0[r1.z + 2].xyzw, r3.xyzw +mad r1.xyzw, v3.wwww, cb0[r1.w + 2].xyzw, r3.xyzw +dp4 o0.z, r0.xyzw, r1.xyzw +dp3 r2.z, v2.xyzx, r1.xyzx +mov o1.xyz, l(0,0,0,0) +dp3 r0.x, r2.xyzx, r2.xyzx +rsq r0.x, r0.x +mul o2.xyz, r0.xxxx, r2.xyzx +mov o2.w, v2.w +ret +// Approximately 27 instruction slots used +#endif + +const BYTE g_StreamOutSkinVS_Position_Tangent_4_1024[] = +{ + 68, 88, 66, 67, 134, 193, + 76, 236, 200, 241, 162, 242, + 117, 255, 185, 145, 58, 140, + 105, 114, 1, 0, 0, 0, + 180, 6, 0, 0, 5, 0, + 0, 0, 52, 0, 0, 0, + 252, 0, 0, 0, 184, 1, + 0, 0, 36, 2, 0, 0, + 56, 6, 0, 0, 82, 68, + 69, 70, 192, 0, 0, 0, + 1, 0, 0, 0, 68, 0, + 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, + 140, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 99, 98, 66, 111, 110, 101, + 115, 0, 60, 0, 0, 0, + 1, 0, 0, 0, 92, 0, + 0, 0, 0, 192, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 192, + 0, 0, 2, 0, 0, 0, + 124, 0, 0, 0, 0, 0, + 0, 0, 98, 111, 110, 101, + 115, 0, 171, 171, 3, 0, + 3, 0, 4, 0, 3, 0, + 0, 4, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, + 32, 57, 46, 50, 57, 46, + 57, 53, 50, 46, 51, 49, + 49, 49, 0, 171, 171, 171, + 73, 83, 71, 78, 180, 0, + 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, + 7, 7, 0, 0, 137, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, + 7, 0, 0, 0, 144, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 2, 0, 0, 0, + 15, 15, 0, 0, 152, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 15, 15, 0, 0, 164, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, + 15, 15, 0, 0, 80, 79, + 83, 73, 84, 73, 79, 78, + 0, 78, 79, 82, 77, 65, + 76, 0, 84, 65, 78, 71, + 69, 78, 84, 0, 66, 76, + 69, 78, 68, 87, 69, 73, + 71, 72, 84, 0, 66, 76, + 69, 78, 68, 73, 78, 68, + 73, 67, 69, 83, 0, 171, + 171, 171, 79, 83, 71, 78, + 100, 0, 0, 0, 3, 0, + 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, + 0, 0, 7, 8, 0, 0, + 89, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, + 0, 0, 15, 0, 0, 0, + 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, + 171, 171, 83, 72, 68, 82, + 12, 4, 0, 0, 64, 0, + 1, 0, 3, 1, 0, 0, + 89, 8, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, + 0, 12, 0, 0, 95, 0, + 0, 3, 114, 16, 16, 0, + 0, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 2, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 3, 0, 0, 0, 95, 0, + 0, 3, 242, 16, 16, 0, + 4, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 0, 0, 0, 0, 101, 0, + 0, 3, 114, 32, 16, 0, + 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 104, 0, + 0, 2, 4, 0, 0, 0, + 54, 0, 0, 5, 114, 0, + 16, 0, 0, 0, 0, 0, + 70, 18, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, + 130, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 38, 0, + 0, 11, 0, 208, 0, 0, + 242, 0, 16, 0, 1, 0, + 0, 0, 70, 30, 16, 0, + 4, 0, 0, 0, 2, 64, + 0, 0, 3, 0, 0, 0, + 3, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, + 56, 0, 0, 9, 242, 0, + 16, 0, 2, 0, 0, 0, + 86, 21, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 11, 242, 0, + 16, 0, 2, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 4, + 0, 0, 0, 0, 10, 0, + 16, 0, 1, 0, 0, 0, + 70, 14, 16, 0, 2, 0, + 0, 0, 50, 0, 0, 11, + 242, 0, 16, 0, 2, 0, + 0, 0, 166, 26, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 4, 0, 0, 0, 0, + 42, 0, 16, 0, 1, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 50, 0, + 0, 11, 242, 0, 16, 0, + 2, 0, 0, 0, 246, 31, + 16, 0, 3, 0, 0, 0, + 70, 142, 32, 4, 0, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 2, 0, 0, 0, + 17, 0, 0, 7, 18, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 2, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 1, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 1, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 34, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 3, 0, 0, 0, 16, 0, + 0, 7, 34, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 3, 0, + 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 3, 0, + 0, 0, 86, 21, 16, 0, + 3, 0, 0, 0, 70, 142, + 32, 6, 0, 0, 0, 0, + 2, 0, 0, 0, 26, 0, + 16, 0, 1, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 6, 16, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 10, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 3, 0, 0, 0, + 166, 26, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 42, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 50, 0, 0, 12, 242, 0, + 16, 0, 1, 0, 0, 0, + 246, 31, 16, 0, 3, 0, + 0, 0, 70, 142, 32, 6, + 0, 0, 0, 0, 2, 0, + 0, 0, 58, 0, 16, 0, + 1, 0, 0, 0, 70, 14, + 16, 0, 3, 0, 0, 0, + 17, 0, 0, 7, 66, 32, + 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, + 1, 0, 0, 0, 16, 0, + 0, 7, 66, 0, 16, 0, + 2, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 8, + 114, 32, 16, 0, 1, 0, + 0, 0, 2, 64, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 16, 0, + 0, 7, 18, 0, 16, 0, + 0, 0, 0, 0, 70, 2, + 16, 0, 2, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 68, 0, 0, 5, + 18, 0, 16, 0, 0, 0, + 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 56, 0, + 0, 7, 114, 32, 16, 0, + 2, 0, 0, 0, 6, 0, + 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 2, 0, + 0, 0, 54, 0, 0, 5, + 130, 32, 16, 0, 2, 0, + 0, 0, 58, 16, 16, 0, + 2, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, + 116, 0, 0, 0, 27, 0, + 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 7, 0, + 0, 0, 12, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0 +}; +const BYTE * g_StreamOutShaders[4][5][3] = { +{ +{ +g_StreamOutSkinVS_Position_1_32, +g_StreamOutSkinVS_Position_2_32, +g_StreamOutSkinVS_Position_4_32, +}, +{ +g_StreamOutSkinVS_Position_1_64, +g_StreamOutSkinVS_Position_2_64, +g_StreamOutSkinVS_Position_4_64, +}, +{ +g_StreamOutSkinVS_Position_1_128, +g_StreamOutSkinVS_Position_2_128, +g_StreamOutSkinVS_Position_4_128, +}, +{ +g_StreamOutSkinVS_Position_1_512, +g_StreamOutSkinVS_Position_2_512, +g_StreamOutSkinVS_Position_4_512, +}, +{ +g_StreamOutSkinVS_Position_1_1024, +g_StreamOutSkinVS_Position_2_1024, +g_StreamOutSkinVS_Position_4_1024, +}, +}, +{ +{ +g_StreamOutSkinVS_Position_Normal_1_32, +g_StreamOutSkinVS_Position_Normal_2_32, +g_StreamOutSkinVS_Position_Normal_4_32, +}, +{ +g_StreamOutSkinVS_Position_Normal_1_64, +g_StreamOutSkinVS_Position_Normal_2_64, +g_StreamOutSkinVS_Position_Normal_4_64, +}, +{ +g_StreamOutSkinVS_Position_Normal_1_128, +g_StreamOutSkinVS_Position_Normal_2_128, +g_StreamOutSkinVS_Position_Normal_4_128, +}, +{ +g_StreamOutSkinVS_Position_Normal_1_512, +g_StreamOutSkinVS_Position_Normal_2_512, +g_StreamOutSkinVS_Position_Normal_4_512, +}, +{ +g_StreamOutSkinVS_Position_Normal_1_1024, +g_StreamOutSkinVS_Position_Normal_2_1024, +g_StreamOutSkinVS_Position_Normal_4_1024, +}, +}, +{ +{ +g_StreamOutSkinVS_Position_Normal_Tangent_1_32, +g_StreamOutSkinVS_Position_Normal_Tangent_2_32, +g_StreamOutSkinVS_Position_Normal_Tangent_4_32, +}, +{ +g_StreamOutSkinVS_Position_Normal_Tangent_1_64, +g_StreamOutSkinVS_Position_Normal_Tangent_2_64, +g_StreamOutSkinVS_Position_Normal_Tangent_4_64, +}, +{ +g_StreamOutSkinVS_Position_Normal_Tangent_1_128, +g_StreamOutSkinVS_Position_Normal_Tangent_2_128, +g_StreamOutSkinVS_Position_Normal_Tangent_4_128, +}, +{ +g_StreamOutSkinVS_Position_Normal_Tangent_1_512, +g_StreamOutSkinVS_Position_Normal_Tangent_2_512, +g_StreamOutSkinVS_Position_Normal_Tangent_4_512, +}, +{ +g_StreamOutSkinVS_Position_Normal_Tangent_1_1024, +g_StreamOutSkinVS_Position_Normal_Tangent_2_1024, +g_StreamOutSkinVS_Position_Normal_Tangent_4_1024, +}, +}, +{ +{ +g_StreamOutSkinVS_Position_Tangent_1_32, +g_StreamOutSkinVS_Position_Tangent_2_32, +g_StreamOutSkinVS_Position_Tangent_4_32, +}, +{ +g_StreamOutSkinVS_Position_Tangent_1_64, +g_StreamOutSkinVS_Position_Tangent_2_64, +g_StreamOutSkinVS_Position_Tangent_4_64, +}, +{ +g_StreamOutSkinVS_Position_Tangent_1_128, +g_StreamOutSkinVS_Position_Tangent_2_128, +g_StreamOutSkinVS_Position_Tangent_4_128, +}, +{ +g_StreamOutSkinVS_Position_Tangent_1_512, +g_StreamOutSkinVS_Position_Tangent_2_512, +g_StreamOutSkinVS_Position_Tangent_4_512, +}, +{ +g_StreamOutSkinVS_Position_Tangent_1_1024, +g_StreamOutSkinVS_Position_Tangent_2_1024, +g_StreamOutSkinVS_Position_Tangent_4_1024, +}, +}, +}; +const size_t g_StreamOutShaderSizes[4][5][3] = { +{ +{ +sizeof(g_StreamOutSkinVS_Position_1_32), +sizeof(g_StreamOutSkinVS_Position_2_32), +sizeof(g_StreamOutSkinVS_Position_4_32), +}, +{ +sizeof(g_StreamOutSkinVS_Position_1_64), +sizeof(g_StreamOutSkinVS_Position_2_64), +sizeof(g_StreamOutSkinVS_Position_4_64), +}, +{ +sizeof(g_StreamOutSkinVS_Position_1_128), +sizeof(g_StreamOutSkinVS_Position_2_128), +sizeof(g_StreamOutSkinVS_Position_4_128), +}, +{ +sizeof(g_StreamOutSkinVS_Position_1_512), +sizeof(g_StreamOutSkinVS_Position_2_512), +sizeof(g_StreamOutSkinVS_Position_4_512), +}, +{ +sizeof(g_StreamOutSkinVS_Position_1_1024), +sizeof(g_StreamOutSkinVS_Position_2_1024), +sizeof(g_StreamOutSkinVS_Position_4_1024), +}, +}, +{ +{ +sizeof(g_StreamOutSkinVS_Position_Normal_1_32), +sizeof(g_StreamOutSkinVS_Position_Normal_2_32), +sizeof(g_StreamOutSkinVS_Position_Normal_4_32), +}, +{ +sizeof(g_StreamOutSkinVS_Position_Normal_1_64), +sizeof(g_StreamOutSkinVS_Position_Normal_2_64), +sizeof(g_StreamOutSkinVS_Position_Normal_4_64), +}, +{ +sizeof(g_StreamOutSkinVS_Position_Normal_1_128), +sizeof(g_StreamOutSkinVS_Position_Normal_2_128), +sizeof(g_StreamOutSkinVS_Position_Normal_4_128), +}, +{ +sizeof(g_StreamOutSkinVS_Position_Normal_1_512), +sizeof(g_StreamOutSkinVS_Position_Normal_2_512), +sizeof(g_StreamOutSkinVS_Position_Normal_4_512), +}, +{ +sizeof(g_StreamOutSkinVS_Position_Normal_1_1024), +sizeof(g_StreamOutSkinVS_Position_Normal_2_1024), +sizeof(g_StreamOutSkinVS_Position_Normal_4_1024), +}, +}, +{ +{ +sizeof(g_StreamOutSkinVS_Position_Normal_Tangent_1_32), +sizeof(g_StreamOutSkinVS_Position_Normal_Tangent_2_32), +sizeof(g_StreamOutSkinVS_Position_Normal_Tangent_4_32), +}, +{ +sizeof(g_StreamOutSkinVS_Position_Normal_Tangent_1_64), +sizeof(g_StreamOutSkinVS_Position_Normal_Tangent_2_64), +sizeof(g_StreamOutSkinVS_Position_Normal_Tangent_4_64), +}, +{ +sizeof(g_StreamOutSkinVS_Position_Normal_Tangent_1_128), +sizeof(g_StreamOutSkinVS_Position_Normal_Tangent_2_128), +sizeof(g_StreamOutSkinVS_Position_Normal_Tangent_4_128), +}, +{ +sizeof(g_StreamOutSkinVS_Position_Normal_Tangent_1_512), +sizeof(g_StreamOutSkinVS_Position_Normal_Tangent_2_512), +sizeof(g_StreamOutSkinVS_Position_Normal_Tangent_4_512), +}, +{ +sizeof(g_StreamOutSkinVS_Position_Normal_Tangent_1_1024), +sizeof(g_StreamOutSkinVS_Position_Normal_Tangent_2_1024), +sizeof(g_StreamOutSkinVS_Position_Normal_Tangent_4_1024), +}, +}, +{ +{ +sizeof(g_StreamOutSkinVS_Position_Tangent_1_32), +sizeof(g_StreamOutSkinVS_Position_Tangent_2_32), +sizeof(g_StreamOutSkinVS_Position_Tangent_4_32), +}, +{ +sizeof(g_StreamOutSkinVS_Position_Tangent_1_64), +sizeof(g_StreamOutSkinVS_Position_Tangent_2_64), +sizeof(g_StreamOutSkinVS_Position_Tangent_4_64), +}, +{ +sizeof(g_StreamOutSkinVS_Position_Tangent_1_128), +sizeof(g_StreamOutSkinVS_Position_Tangent_2_128), +sizeof(g_StreamOutSkinVS_Position_Tangent_4_128), +}, +{ +sizeof(g_StreamOutSkinVS_Position_Tangent_1_512), +sizeof(g_StreamOutSkinVS_Position_Tangent_2_512), +sizeof(g_StreamOutSkinVS_Position_Tangent_4_512), +}, +{ +sizeof(g_StreamOutSkinVS_Position_Tangent_1_1024), +sizeof(g_StreamOutSkinVS_Position_Tangent_2_1024), +sizeof(g_StreamOutSkinVS_Position_Tangent_4_1024), +}, +}, +}; diff --git a/Runtime/GfxDevice/d3d11/InternalShaders/compile_all.bat b/Runtime/GfxDevice/d3d11/InternalShaders/compile_all.bat new file mode 100644 index 0000000..055f100 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/InternalShaders/compile_all.bat @@ -0,0 +1,82 @@ +@echo off +del FFShaderLib.h +call "CompileShaderLib\CompileShaderLib.exe" FFShaderLib.hlsl FFShaderLib.h + +del builtin.h + +echo // > builtin.h +echo // >> builtin.h +echo // Autogenerated file. Do not modify! >> builtin.h +echo // >> builtin.h +echo // >> builtin.h + +echo const BYTE * g_StreamOutShaders[4][5][3] = { >tmp.h +echo const size_t g_StreamOutShaderSizes[4][5][3] = { >tmp2.h + +call:compile StreamOutSkinVS_Position +call:compile StreamOutSkinVS_Position_Normal +call:compile StreamOutSkinVS_Position_Normal_Tangent +call:compile StreamOutSkinVS_Position_Tangent + +echo }; >>tmp.h +echo }; >>tmp2.h + +type tmp.h >>builtin.h +type tmp2.h >>builtin.h + +del tmp.h +del tmp2.h + +goto:eof + +:compile + +echo { >>tmp.h +echo { >>tmp2.h + +call:compilecbvariants %~1 32 +call:compilecbvariants %~1 64 +call:compilecbvariants %~1 128 +call:compilecbvariants %~1 512 +call:compilecbvariants %~1 1024 + +echo }, >>tmp.h +echo }, >>tmp2.h + + +goto:eof + +::- Compiles all variants for a given bone constant buffer size +::- Arguments: %~1 = entrypoint name, %~2 = max bone count +:compilecbvariants + +echo { >>tmp.h +echo { >>tmp2.h + +call:compilevariant %~1 1 %~2 +call:compilevariant %~1 2 %~2 +call:compilevariant %~1 4 %~2 + +echo },>>tmp.h +echo },>>tmp2.h + + +goto:eof + +::- Compiles a single shader variant +::- Arguments: %~1 = entrypoint name %~2 = bones per vertex %~3 = max bone count +:compilevariant + +call "%DXSDK_DIR%\Utilities\bin\x64\fxc.exe" /nologo /T vs_4_0 /Fh%~1_%~2_%~3._fxctmp /E%~1_%~2_%~3 /D BONESPERVERTEX=%~2 /D BONECOUNT=%~3 internalshaders.hlsl + +echo //-------------------------------------------------------------- >> builtin.h +echo // %~1_%~2_%~3 >> builtin.h +echo //-------------------------------------------------------------- >> builtin.h + +type %~1_%~2_%~3._fxctmp >> builtin.h +del %~1_%~2_%~3._fxctmp + +echo g_%~1_%~2_%~3, >>tmp.h +echo sizeof(g_%~1_%~2_%~3), >> tmp2.h + +goto:eof diff --git a/Runtime/GfxDevice/d3d11/InternalShaders/internalshaders.hlsl b/Runtime/GfxDevice/d3d11/InternalShaders/internalshaders.hlsl new file mode 100644 index 0000000..2dce211 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/InternalShaders/internalshaders.hlsl @@ -0,0 +1,119 @@ +//-------------------------------------------------------------------------------------- +// Vertex shaders for stream-out GPU skinning. +//-------------------------------------------------------------------------------------- + +//-------------------------------------------------------------------------------------- +// Globals +//-------------------------------------------------------------------------------------- +cbuffer cbBones : register ( b0 ) +{ + float4x3 bones[BONECOUNT]; +} + +//-------------------------------------------------------------------------------------- +// Input / Output structures +//-------------------------------------------------------------------------------------- +struct VS_IN_MEX +{ + // Stream 0 + float3 Position : POSITION; + float3 Normal : NORMAL; + float4 Tangent : TANGENT; + + // Stream 1 +#if BONESPERVERTEX == 4 + float4 BoneWeights : BLENDWEIGHT; + int4 BoneIndices : BLENDINDICES; + +#elif BONESPERVERTEX == 2 + float2 BoneWeights : BLENDWEIGHT; + int2 BoneIndices : BLENDINDICES; + +#else // 1 bone per vertex + int BoneIndices : BONEINDEX; + +#endif +}; + +struct VS_OUTPUT +{ + float3 vPosition : POSITION; + float3 vNormal : TEXCOORD0; + float4 vTangent : TEXCOORD1; +}; + +// --- Bones --- +inline float4x3 FetchBoneMatrix( int boneIndex ) +{ + return (float4x3)(bones[boneIndex]); +} +//-------------------------------------------------------------------------------------- +// Vertex Shader +//-------------------------------------------------------------------------------------- +VS_OUTPUT VSMain( VS_IN_MEX Input, uniform bool useNormal, uniform bool useTangent) +{ + VS_OUTPUT Output = (VS_OUTPUT)0; + +#if BONESPERVERTEX == 4 + float boneWeights[4] = (float[4])Input.BoneWeights; + int boneIndices[4] = (int[4])Input.BoneIndices; + + float4x3 localToWorldMatrix = boneWeights[0] * FetchBoneMatrix(boneIndices[0]) + + boneWeights[1] * FetchBoneMatrix(boneIndices[1]) + + boneWeights[2] * FetchBoneMatrix(boneIndices[2]) + + boneWeights[3] * FetchBoneMatrix(boneIndices[3]); + +#elif BONESPERVERTEX == 2 + float boneWeights[2] = (float[2])Input.BoneWeights; + int boneIndices[2] = (int[2])Input.BoneIndices; + + float4x3 localToWorldMatrix = boneWeights[0] * FetchBoneMatrix(boneIndices[0]) + + boneWeights[1] * FetchBoneMatrix(boneIndices[1]); + + +#else // 1 + int boneIndex = Input.BoneIndices; + + float4x3 localToWorldMatrix = FetchBoneMatrix(boneIndex); +#endif + + // Position + Output.vPosition = mul( float4(Input.Position.xyz, 1.0), localToWorldMatrix ).xyz; + if (useNormal) + { + Output.vNormal = normalize( mul( float4(Input.Normal.xyz,0.0f), localToWorldMatrix ) ).xyz; + } + + // Tangent + if (useTangent) + { + float3 outTangent3 = normalize( mul( float4(Input.Tangent.xyz,0.0f), localToWorldMatrix ) ).xyz; + Output.vTangent = float4(outTangent3, Input.Tangent.w); + } + + return Output; +} + +// Functions are named StreamOutSkinVS_<components>_<bonespervertex>_<maxbonecount> + +#define MERGE(a, b, c, delim) a##delim##b##delim##c + +VS_OUTPUT MERGE(StreamOutSkinVS_Position,BONESPERVERTEX,BONECOUNT,_)(VS_IN_MEX Input) +{ + return VSMain(Input, false, false); +} + +VS_OUTPUT MERGE(StreamOutSkinVS_Position_Normal,BONESPERVERTEX,BONECOUNT,_)(VS_IN_MEX Input) +{ + return VSMain(Input, true, false); +} + +VS_OUTPUT MERGE(StreamOutSkinVS_Position_Normal_Tangent,BONESPERVERTEX,BONECOUNT,_)(VS_IN_MEX Input) +{ + return VSMain(Input, true, true); +} + +VS_OUTPUT MERGE(StreamOutSkinVS_Position_Tangent,BONESPERVERTEX,BONECOUNT,_)(VS_IN_MEX Input) +{ + return VSMain(Input, false, true); +} diff --git a/Runtime/GfxDevice/d3d11/RenderTextureD3D11.cpp b/Runtime/GfxDevice/d3d11/RenderTextureD3D11.cpp new file mode 100644 index 0000000..9c50172 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/RenderTextureD3D11.cpp @@ -0,0 +1,805 @@ +#include "UnityPrefix.h" +#include "Runtime/GfxDevice/GfxDevice.h" +#include "Runtime/Shaders/GraphicsCaps.h" +#include "Runtime/Graphics/Image.h" +#include "Runtime/Utilities/ArrayUtility.h" +#include "D3D11Context.h" +#include "D3D11Utils.h" +#include "TexturesD3D11.h" + +void UnbindTextureD3D11 (TextureID texture); + +//Resource format +DXGI_FORMAT kD3D11RenderResourceFormats[kRTFormatCount] = { + DXGI_FORMAT_R8G8B8A8_TYPELESS, + DXGI_FORMAT_R24G8_TYPELESS, + DXGI_FORMAT_R16G16B16A16_TYPELESS, + DXGI_FORMAT_R16_TYPELESS, + (DXGI_FORMAT)-1, // RGB565, unsupported + (DXGI_FORMAT)-1, // ARGB4444, unsupported + (DXGI_FORMAT)-1, // ARGB1555, unsupported + (DXGI_FORMAT)-1, // Default + DXGI_FORMAT_R10G10B10A2_TYPELESS, + (DXGI_FORMAT)-1, // DefaultHDR + DXGI_FORMAT_R16G16B16A16_TYPELESS, + DXGI_FORMAT_R32G32B32A32_TYPELESS, + DXGI_FORMAT_R32G32_TYPELESS, + DXGI_FORMAT_R16G16_TYPELESS, + DXGI_FORMAT_R32_TYPELESS, + DXGI_FORMAT_R16_TYPELESS, + DXGI_FORMAT_R8_TYPELESS, // R8 + DXGI_FORMAT_R32G32B32A32_TYPELESS, // ARGBInt + DXGI_FORMAT_R32G32_TYPELESS, // RGInt + DXGI_FORMAT_R32_TYPELESS, // RInt + DXGI_FORMAT_B8G8R8A8_TYPELESS, +}; + +//Standard view +DXGI_FORMAT kD3D11RenderTextureFormatsNorm[kRTFormatCount] = { + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_D16_UNORM, + (DXGI_FORMAT)-1, // RGB565, unsupported + (DXGI_FORMAT)-1, // ARGB4444, unsupported + (DXGI_FORMAT)-1, // ARGB1555, unsupported + (DXGI_FORMAT)-1, // Default + DXGI_FORMAT_R10G10B10A2_UNORM, + (DXGI_FORMAT)-1, // DefaultHDR + DXGI_FORMAT_R16G16B16A16_UNORM, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32_FLOAT, + DXGI_FORMAT_R16G16_FLOAT, + DXGI_FORMAT_R32_FLOAT, + DXGI_FORMAT_R16_FLOAT, + DXGI_FORMAT_R8_UNORM, // R8 + DXGI_FORMAT_R32G32B32A32_SINT, // ARGBInt + DXGI_FORMAT_R32G32_SINT, // RGInt + DXGI_FORMAT_R32_SINT, // RInt + DXGI_FORMAT_B8G8R8A8_UNORM, // BGRA32 +}; + +// SRGBView... only used for RGBA8 buffers really. +DXGI_FORMAT kD3D11RenderTextureFormatsSRGB[kRTFormatCount] = { + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_D16_UNORM, + (DXGI_FORMAT)-1, // RGB565, unsupported + (DXGI_FORMAT)-1, // ARGB4444, unsupported + (DXGI_FORMAT)-1, // ARGB1555, unsupported + (DXGI_FORMAT)-1, // Default + DXGI_FORMAT_R10G10B10A2_UNORM, + (DXGI_FORMAT)-1, // DefaultHDR + DXGI_FORMAT_R16G16B16A16_UNORM, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32_FLOAT, + DXGI_FORMAT_R16G16_FLOAT, + DXGI_FORMAT_R32_FLOAT, + DXGI_FORMAT_R16_FLOAT, + DXGI_FORMAT_R8_UNORM, // R8 + DXGI_FORMAT_R32G32B32A32_SINT, // ARGBInt + DXGI_FORMAT_R32G32_SINT, // RGInt + DXGI_FORMAT_R32_SINT, // RInt + DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, +}; + +DXGI_FORMAT GetRenderTextureFormat (RenderTextureFormat format, bool sRGB) +{ + return sRGB ? kD3D11RenderTextureFormatsSRGB[format] : kD3D11RenderTextureFormatsNorm[format]; +} + +DXGI_FORMAT GetShaderResourceViewFormat (RenderTextureFormat format, bool sRGB) +{ + if (format == kRTFormatDepth) + { + return DXGI_FORMAT_R24_UNORM_X8_TYPELESS; + } + else if (format == kRTFormatShadowMap) + { + return DXGI_FORMAT_R16_UNORM; + } + else + { + return sRGB ? kD3D11RenderTextureFormatsSRGB[format] : kD3D11RenderTextureFormatsNorm[format]; + } +} + + +static ID3D11Resource* CreateTextureD3D11 (int width, int height, int depth, int mipLevels, DXGI_FORMAT format, UINT bindFlags, TextureDimension dim, int antiAlias) +{ + if (dim == kTexDim3D) + { + if (gGraphicsCaps.buggyMipmapped3DTextures) + mipLevels = 1; + D3D11_TEXTURE3D_DESC desc; + desc.Width = width; + desc.Height = height; + desc.Depth = depth; + desc.MipLevels = mipLevels; + desc.Format = format; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = bindFlags; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + if (mipLevels > 1) desc.MiscFlags |= D3D11_RESOURCE_MISC_GENERATE_MIPS; + ID3D11Texture3D* res = NULL; + HRESULT hr = GetD3D11Device()->CreateTexture3D (&desc, NULL, &res); + Assert (SUCCEEDED(hr)); + SetDebugNameD3D11 (res, Format("RenderTexture-3D-%dx%dx%d", width, height, depth)); + return res; + } + else + { + if (dim == kTexDimCUBE && gGraphicsCaps.buggyMipmappedCubemaps) + mipLevels = 1; + D3D11_TEXTURE2D_DESC desc; + desc.Width = width; + desc.Height = height; + desc.MipLevels = mipLevels; + desc.ArraySize = dim==kTexDimCUBE ? 6 : 1; + desc.Format = format; + desc.SampleDesc.Count = antiAlias; + desc.SampleDesc.Quality = 0; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = bindFlags; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + if (dim == kTexDimCUBE) desc.MiscFlags |= D3D11_RESOURCE_MISC_TEXTURECUBE; + if (mipLevels > 1) desc.MiscFlags |= D3D11_RESOURCE_MISC_GENERATE_MIPS; + ID3D11Texture2D* res = NULL; + HRESULT hr = GetD3D11Device()->CreateTexture2D (&desc, NULL, &res); + Assert (SUCCEEDED(hr)); + SetDebugNameD3D11 (res, Format("RenderTexture-2D-%dx%d", width, height)); + return res; + } +} + + +static bool InitD3D11RenderColorSurface (RenderColorSurfaceD3D11& rs, TexturesD3D11& textures) +{ + HRESULT hr; + ID3D11Device* dev = GetD3D11Device(); + + bool sRGBPrimary = (rs.flags & kSurfaceCreateSRGB); + + UINT bindFlags = 0; + if (!IsDepthRTFormat (rs.format)) + bindFlags |= D3D11_BIND_RENDER_TARGET; + if (rs.textureID.m_ID) + bindFlags |= D3D11_BIND_SHADER_RESOURCE; + if (rs.flags & kSurfaceCreateRandomWrite && gGraphicsCaps.d3d11.featureLevel >= kDX11Level11_0) + bindFlags |= D3D11_BIND_UNORDERED_ACCESS; + int mipLevels = 1; + int accessibleMipLevels = 1; + if ((rs.flags & kSurfaceCreateMipmap) && !IsDepthRTFormat(rs.format)) + { + mipLevels = CalculateMipMapCount3D (rs.width, rs.height, rs.depth); + if (!(rs.flags & kSurfaceCreateAutoGenMips)) + accessibleMipLevels = mipLevels; + } + const DXGI_FORMAT texFormat = (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0 ? kD3D11RenderResourceFormats[rs.format] : kD3D11RenderTextureFormatsNorm[rs.format]); + if (bindFlags != 0) + rs.m_Texture = CreateTextureD3D11 (rs.width, rs.height, rs.depth, mipLevels, texFormat, bindFlags, rs.dim, rs.samples); + else + rs.m_Texture = NULL; + // Render Target View + if (!IsDepthRTFormat (rs.format)) + { + D3D11_RENDER_TARGET_VIEW_DESC desc, descSecondary; + desc.Format = GetRenderTextureFormat (rs.format, gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0 ? sRGBPrimary : false); + descSecondary.Format = GetRenderTextureFormat (rs.format, gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0 ? !sRGBPrimary : false); + ID3D11RenderTargetView* rtv = NULL; + if (rs.dim == kTexDim2D) + { + desc.ViewDimension = descSecondary.ViewDimension = rs.samples > 1 ? D3D11_RTV_DIMENSION_TEXTURE2DMS : D3D11_RTV_DIMENSION_TEXTURE2D; + for (int im = 0; im < accessibleMipLevels; ++im) + { + desc.Texture2D.MipSlice = descSecondary.Texture2D.MipSlice = im; + hr = dev->CreateRenderTargetView (rs.m_Texture, &desc, &rtv); + Assert (SUCCEEDED(hr)); + rs.SetRTV (0, im, false, rtv); + hr = dev->CreateRenderTargetView (rs.m_Texture, &descSecondary, &rtv); + Assert (SUCCEEDED(hr)); + rs.SetRTV (0, im, true, rtv); + } + } + else if (rs.dim == kTexDimCUBE) + { + desc.ViewDimension = descSecondary.ViewDimension = rs.samples > 1 ? D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY : D3D11_RTV_DIMENSION_TEXTURE2DARRAY; + desc.Texture2DArray.ArraySize = descSecondary.Texture2DArray.ArraySize = 1; + for (int im = 0; im < accessibleMipLevels; ++im) + { + desc.Texture2DArray.MipSlice = descSecondary.Texture2DArray.MipSlice = im; + for (int i = 0; i < 6; ++i) + { + desc.Texture2DArray.FirstArraySlice = descSecondary.Texture2DArray.FirstArraySlice = i; + hr = dev->CreateRenderTargetView (rs.m_Texture, &desc, &rtv); + Assert (SUCCEEDED(hr)); + rs.SetRTV (i, im, false, rtv); + + hr = dev->CreateRenderTargetView (rs.m_Texture, &descSecondary, &rtv); + Assert (SUCCEEDED(hr)); + rs.SetRTV (i, im, true, rtv); + } + } + } + else if (rs.dim == kTexDim3D) + { + desc.ViewDimension = descSecondary.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D; + desc.Texture3D.MipSlice = descSecondary.Texture3D.MipSlice = 0; + desc.Texture3D.FirstWSlice = descSecondary.Texture3D.FirstWSlice = 0; + desc.Texture3D.WSize = descSecondary.Texture3D.WSize = -1; + hr = dev->CreateRenderTargetView (rs.m_Texture, &desc, &rtv); + Assert (SUCCEEDED(hr)); + rs.SetRTV (0, 0, false, rtv); + + hr = dev->CreateRenderTargetView (rs.m_Texture, &descSecondary, &rtv); + Assert (SUCCEEDED(hr)); + rs.SetRTV (0, 0, true, rtv); + } + } + + // Shader Resource View if needed + if (rs.textureID.m_ID) + { + D3D11_SHADER_RESOURCE_VIEW_DESC desc; + desc.Format = GetShaderResourceViewFormat (rs.format, (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0) ? sRGBPrimary : false); + switch (rs.dim) { + case kTexDimCUBE: desc.ViewDimension = rs.samples > 1 ? D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY : D3D11_SRV_DIMENSION_TEXTURECUBE; break; + case kTexDim3D: desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D; break; + default: desc.ViewDimension = rs.samples > 1 ? D3D11_SRV_DIMENSION_TEXTURE2DMS : D3D11_SRV_DIMENSION_TEXTURE2D; break; + } + desc.Texture2D.MostDetailedMip = 0; + desc.Texture2D.MipLevels = mipLevels; + + ID3D11ShaderResourceView* srView = NULL; + hr = dev->CreateShaderResourceView (rs.m_Texture, &desc, &rs.m_SRView); + Assert (SUCCEEDED(hr)); + + SetDebugNameD3D11 (rs.m_SRView, Format("RenderTexture-SRV-%d-color-%dx%d", rs.textureID.m_ID, rs.width, rs.height)); + + // If we need to generate mips, create view without sRGB format. Seems like some drivers + // have slow paths for updating sRGB formats, and from reading the docs, it's not clear if + // mip update for sRGB formats is supported everywhere. + if (mipLevels > 1) + { + desc.Format = GetShaderResourceViewFormat (rs.format, false); + hr = dev->CreateShaderResourceView (rs.m_Texture, &desc, &rs.m_SRViewForMips); + Assert (SUCCEEDED(hr)); + SetDebugNameD3D11 (rs.m_SRViewForMips, Format("RenderTexture-SRV-%d-color-%dx%d-mips", rs.textureID.m_ID, rs.width, rs.height)); + } + } + + // UAV if needed + if (rs.flags & kSurfaceCreateRandomWrite && gGraphicsCaps.d3d11.featureLevel >= kDX11Level11_0) + { + D3D11_UNORDERED_ACCESS_VIEW_DESC desc; + desc.Format = GetShaderResourceViewFormat (rs.format, false); // UAV formats don't support sRGB + if (rs.dim == kTexDim3D) + { + desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE3D; + desc.Texture3D.MipSlice = 0; + desc.Texture3D.FirstWSlice = 0; + desc.Texture3D.WSize = -1; + } + else + { + desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2D; + desc.Texture2D.MipSlice = 0; + } + + hr = dev->CreateUnorderedAccessView (rs.m_Texture, &desc, &rs.m_UAView); + Assert (SUCCEEDED(hr)); + SetDebugNameD3D11 (rs.m_UAView, Format("RenderTexture-UAV-%d-color-%dx%d", rs.textureID.m_ID, rs.width, rs.height)); + } + + // add to textures map + if (rs.textureID.m_ID) + { + textures.AddTexture (rs.textureID, rs.m_Texture, rs.m_SRView, rs.m_UAView, false); + } + + return true; +} + +bool InitD3D11RenderDepthSurface (RenderDepthSurfaceD3D11& rs, TexturesD3D11* textures, bool sampleOnly) +{ + HRESULT hr; + ID3D11Device* dev = GetD3D11Device(); + + const bool shadowMap = rs.flags & kSurfaceCreateShadowmap; + const bool useTypeless = (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0 || gGraphicsCaps.d3d11.hasShadows10Level9); + const bool createZ = (rs.depthFormat != kDepthFormatNone); + + rs.m_Texture = NULL; + rs.m_DSView = NULL; + rs.m_SRView = NULL; + + DXGI_FORMAT formatResource; + DXGI_FORMAT formatDSV; + DXGI_FORMAT formatSRV; + if (shadowMap) + { + formatResource = DXGI_FORMAT_R16_TYPELESS; + formatDSV = DXGI_FORMAT_D16_UNORM; + formatSRV = DXGI_FORMAT_R16_UNORM; + } + else if (rs.depthFormat == kDepthFormat16) + { + formatResource = useTypeless ? DXGI_FORMAT_R16_TYPELESS : DXGI_FORMAT_D16_UNORM; + formatDSV = DXGI_FORMAT_D16_UNORM; + formatSRV = useTypeless ? DXGI_FORMAT_R16_UNORM : DXGI_FORMAT_D16_UNORM; + } + else + { + formatResource = useTypeless ? DXGI_FORMAT_R24G8_TYPELESS : DXGI_FORMAT_D24_UNORM_S8_UINT; + formatDSV = DXGI_FORMAT_D24_UNORM_S8_UINT; + formatSRV = useTypeless ? DXGI_FORMAT_R24_UNORM_X8_TYPELESS : DXGI_FORMAT_D24_UNORM_S8_UINT; + } + + // Pre-DX11 feature level hardware can't do depth buffer sampling & have it as a depth stencil, + // but DX11 can. + if (gGraphicsCaps.d3d11.featureLevel >= kDX11Level11_0) + sampleOnly = false; + + if (rs.dim != kTexDim2D) + { + // Starting with 10.1 level, we can have a cubemap color surface and a regular 2D depth surface. Before that, + // have to create the depth surface as a fake cubemap as well. Leave dimension as cubemap only when + // cubemap was requested AND we're below 10.1 + if (rs.dim != kTexDimCUBE || gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_1) + rs.dim = kTexDim2D; + } + + if (createZ) + { + UINT bindFlags = sampleOnly ? 0 : D3D11_BIND_DEPTH_STENCIL; + if (rs.textureID.m_ID && (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0 || gGraphicsCaps.d3d11.hasShadows10Level9)) + bindFlags |= D3D11_BIND_SHADER_RESOURCE; + rs.m_Texture = CreateTextureD3D11 (rs.width, rs.height, 1, 1, formatResource, bindFlags, rs.dim, rs.samples); + } + + // Depth Stencil view if needed + if (createZ && !sampleOnly) + { + D3D11_DEPTH_STENCIL_VIEW_DESC desc; + desc.Format = formatDSV; + desc.ViewDimension = rs.samples > 1 ? D3D11_DSV_DIMENSION_TEXTURE2DMS : D3D11_DSV_DIMENSION_TEXTURE2D; + desc.Flags = 0; + desc.Texture2D.MipSlice = 0; + hr = dev->CreateDepthStencilView (rs.m_Texture, &desc, &rs.m_DSView); + Assert (SUCCEEDED(hr)); + } + + // Shader Resource View if needed + if (createZ && rs.textureID.m_ID && (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0 || gGraphicsCaps.d3d11.hasShadows10Level9)) + { + D3D11_SHADER_RESOURCE_VIEW_DESC desc; + desc.Format = formatSRV; + desc.ViewDimension = rs.samples > 1 ? D3D11_SRV_DIMENSION_TEXTURE2DMS : D3D11_SRV_DIMENSION_TEXTURE2D; + desc.Texture2D.MostDetailedMip = 0; + desc.Texture2D.MipLevels = 1; + + ID3D11ShaderResourceView* srView = NULL; + hr = dev->CreateShaderResourceView (rs.m_Texture, &desc, &rs.m_SRView); + Assert (SUCCEEDED(hr)); + SetDebugNameD3D11 (rs.m_SRView, Format("RenderTexture-SRV-%d-depth-%dx%d", rs.textureID.m_ID, rs.width, rs.height)); + } + + if (createZ && rs.textureID.m_ID && textures) + textures->AddTexture (rs.textureID, rs.m_Texture, rs.m_SRView, rs.m_UAView, rs.flags & kSurfaceCreateShadowmap); + + return true; +} + +static RenderColorSurfaceD3D11* s_ActiveColorTargets[kMaxSupportedRenderTargets]; +static int s_ActiveColorTargetCount; +static bool s_SRGBWrite; +static RenderDepthSurfaceD3D11* s_ActiveDepthTarget = NULL; +static CubemapFace s_ActiveFace = kCubeFaceUnknown; +static int s_ActiveMip = 0; + +static RenderColorSurfaceD3D11* s_ActiveColorBackBuffer = NULL; +static RenderDepthSurfaceD3D11* s_ActiveDepthBackBuffer = NULL; + +// on dx editor we can switch swapchain underneath +// so lets do smth like gl's default FBO +// it will be used only from "user" code and we will select proper swap chain here +static RenderColorSurfaceD3D11* s_DummyColorBackBuffer = NULL; +static RenderDepthSurfaceD3D11* s_DummyDepthBackBuffer = NULL; + +RenderSurfaceBase* DummyColorBackBuferD3D11() +{ + if(s_DummyColorBackBuffer == 0) + { + static RenderColorSurfaceD3D11 __bb; + RenderSurfaceBase_InitColor(__bb); + __bb.backBuffer = true; + + s_DummyColorBackBuffer = &__bb; + } + return s_DummyColorBackBuffer; +} + +RenderSurfaceBase* DummyDepthBackBuferD3D11() +{ + if(s_DummyDepthBackBuffer == 0) + { + static RenderDepthSurfaceD3D11 __bb; + RenderSurfaceBase_InitDepth(__bb); + __bb.backBuffer = true; + + s_DummyDepthBackBuffer = &__bb; + } + return s_DummyDepthBackBuffer; +} + + +static int s_UAVMaxIndex = -1; +static TextureID s_UAVTextures[kMaxSupportedRenderTargets]; +static ComputeBufferID s_UAVBuffers[kMaxSupportedRenderTargets]; + + + +static bool SetRenderTargetD3D11Internal (int count, RenderColorSurfaceD3D11** colorSurfaces, RenderDepthSurfaceD3D11* depthSurface, int mipLevel, CubemapFace face, int* outTargetWidth, int* outTargetHeight, TexturesD3D11* textures, bool forceRebind) +{ + RenderColorSurfaceD3D11* rcolorZero = colorSurfaces[0]; + + // check context is created + ID3D11DeviceContext* ctx = GetD3D11Context(); + if (!ctx) + { + Assert (!rcolorZero && !depthSurface); + return false; + } + + bool sRGBWriteDesired = GetRealGfxDevice().GetSRGBWrite(); + + // Exit if nothing to do + if (!forceRebind && count == s_ActiveColorTargetCount && sRGBWriteDesired == s_SRGBWrite && s_ActiveDepthTarget == depthSurface && s_ActiveFace == face && s_ActiveMip == mipLevel) + { + bool colorsSame = true; + for (int i = 0; i < count; ++i) + { + if (s_ActiveColorTargets[i] != colorSurfaces[i]) + colorsSame = false; + } + if (colorsSame) + { + if (rcolorZero != s_DummyColorBackBuffer) + { + if (outTargetWidth) *outTargetWidth = rcolorZero->width; + if (outTargetHeight) *outTargetHeight = rcolorZero->height; + } + return false; + } + } + + Assert(rcolorZero->backBuffer == depthSurface->backBuffer); + bool isBackBuffer = rcolorZero->backBuffer; + + + GfxDevice& device = GetRealGfxDevice(); + if (!isBackBuffer) + device.GetFrameStats().AddRenderTextureChange(); // stats + + if(rcolorZero->backBuffer && rcolorZero == s_DummyColorBackBuffer) + rcolorZero = colorSurfaces[0] = s_ActiveColorBackBuffer; + if(depthSurface->backBuffer && depthSurface == s_DummyDepthBackBuffer) + depthSurface = s_ActiveDepthBackBuffer; + + + HRESULT hr; + + if (rcolorZero) + { + if (depthSurface && depthSurface->textureID.m_ID) + UnbindTextureD3D11 (depthSurface->textureID); + + Assert (rcolorZero->colorSurface); + Assert (!depthSurface || !depthSurface->colorSurface); + + int faceIndex = clamp<int>(face, 0, 5); + ID3D11RenderTargetView* rtvs[kMaxSupportedRenderTargets]; + for (int i = 0; i < count; ++i) + { + RenderColorSurfaceD3D11* rcolor = colorSurfaces[i]; + if (rcolor->textureID.m_ID) + UnbindTextureD3D11 (rcolor->textureID); + + bool wantSecondaryView = ((rcolor->flags & kSurfaceCreateSRGB) != 0) != sRGBWriteDesired; + rtvs[i] = rcolor->GetRTV(faceIndex, mipLevel, wantSecondaryView); + } + + const int uavCount = s_UAVMaxIndex - (count-1); + if (uavCount <= 0) + { + // set render targets + ctx->OMSetRenderTargets (count, rtvs, depthSurface ? depthSurface->m_DSView : NULL); + } + else + { + DebugAssert (uavCount > 0 && uavCount <= kMaxSupportedRenderTargets); + // set render targets and UAVs + ID3D11UnorderedAccessView* uavs[kMaxSupportedRenderTargets]; + for (int i = 0; i < uavCount; ++i) + { + int idx = i + count; + DebugAssert (idx >= 0 && idx < kMaxSupportedRenderTargets); + ID3D11UnorderedAccessView* uav = NULL; + if (s_UAVTextures[idx].m_ID && textures) + { + TexturesD3D11::D3D11Texture* tex = textures->GetTexture (s_UAVTextures[idx]); + if (tex) + uav = tex->m_UAV; + } + else if (s_UAVBuffers[idx].IsValid() && textures) + { + ComputeBuffer11* cb = textures->GetComputeBuffer (s_UAVBuffers[idx]); + if (cb) + uav = cb->uav; + } + uavs[i] = uav; + } + UINT uavInitialCounts[kMaxSupportedRenderTargets]; + for (int i = 0; i < kMaxSupportedRenderTargets; ++i) + uavInitialCounts[i] = 0; // reset offsets for Countable/Appendable/Consumeable UAVs + ctx->OMSetRenderTargetsAndUnorderedAccessViews (count, rtvs, depthSurface ? depthSurface->m_DSView : NULL, count, uavCount, uavs, uavInitialCounts); + } + + g_D3D11CurrRT = rtvs[0]; + g_D3D11CurrColorRT = rcolorZero; + g_D3D11CurrDS = depthSurface ? depthSurface->m_DSView : NULL; + g_D3D11CurrDepthRT = depthSurface; + if (outTargetWidth) *outTargetWidth = rcolorZero->width; + if (outTargetHeight)*outTargetHeight = rcolorZero->height; + } + + // If we previously had a mip-mapped render texture, generate mip levels for it now. + RenderColorSurfaceD3D11* prevRT = s_ActiveColorTargets[0]; + RenderColorSurfaceD3D11* currRT = colorSurfaces[0]; + if (prevRT && + (prevRT->flags & kSurfaceCreateMipmap) && + (prevRT->flags & kSurfaceCreateAutoGenMips) && + prevRT->m_SRViewForMips && + currRT != prevRT) + { + ctx->GenerateMips (prevRT->m_SRViewForMips); + } + + for (int i = 0; i < count; ++i) + s_ActiveColorTargets[i] = colorSurfaces[i]; + + s_ActiveColorTargetCount = count; + s_ActiveDepthTarget = depthSurface; + s_ActiveFace = face; + s_ActiveMip = mipLevel; + + if (isBackBuffer) + { + s_ActiveColorBackBuffer = rcolorZero; + s_ActiveDepthBackBuffer = depthSurface; + + // we are rendering to "default FBO", so current target is dummy + // as a side effect, if we change swap chain, it will be set correctly, and active remain valid + s_ActiveColorTargets[0] = s_DummyColorBackBuffer; + s_ActiveDepthTarget = s_DummyDepthBackBuffer; + } + + s_SRGBWrite = sRGBWriteDesired; + return true; +} + +bool SetRenderTargetD3D11 (int count, RenderSurfaceHandle* colorHandles, RenderSurfaceHandle depthHandle, int mipLevel, CubemapFace face, int* outTargetWidth, int* outTargetHeight, TexturesD3D11* textures) +{ + RenderColorSurfaceD3D11* colorTargets[kMaxSupportedRenderTargets]; + RenderDepthSurfaceD3D11* rdepth = reinterpret_cast<RenderDepthSurfaceD3D11*>( depthHandle.object ); + for (int i = 0; i < count; ++i) + { + colorTargets[i] = reinterpret_cast<RenderColorSurfaceD3D11*>(colorHandles[i].object); + } + + return SetRenderTargetD3D11Internal (count, colorTargets, rdepth, mipLevel, face, outTargetWidth, outTargetHeight, textures, false); +} + +bool RebindActiveRenderTargets(TexturesD3D11* textures) +{ + int width, height; + return SetRenderTargetD3D11Internal (s_ActiveColorTargetCount, s_ActiveColorTargets, s_ActiveDepthTarget, s_ActiveMip, s_ActiveFace, &width, &height, textures, true); +} + + +void SetRandomWriteTargetTextureD3D11 (int index, TextureID tid) +{ + Assert (index >= 0 && index < ARRAY_SIZE(s_UAVTextures)); + s_UAVMaxIndex = std::max (s_UAVMaxIndex, index); + s_UAVTextures[index] = tid; + s_UAVBuffers[index] = ComputeBufferID(); +} + +void SetRandomWriteTargetBufferD3D11 (int index, ComputeBufferID bufferHandle) +{ + Assert (index >= 0 && index < ARRAY_SIZE(s_UAVBuffers)); + s_UAVMaxIndex = std::max (s_UAVMaxIndex, index); + s_UAVBuffers[index] = bufferHandle; + s_UAVTextures[index].m_ID = 0; +} + +void ClearRandomWriteTargetsD3D11 (TexturesD3D11* textures) +{ + const bool resetRenderTargets = (s_UAVMaxIndex != -1); + + s_UAVMaxIndex = -1; + for (int i = 0; i < ARRAY_SIZE(s_UAVTextures); ++i) + s_UAVTextures[i].m_ID = 0; + for (int i = 0; i < ARRAY_SIZE(s_UAVBuffers); ++i) + s_UAVBuffers[i] = ComputeBufferID(); + + if (resetRenderTargets) + RebindActiveRenderTargets (textures); +} + + +RenderSurfaceHandle GetActiveRenderColorSurfaceD3D11(int index) +{ + return RenderSurfaceHandle(s_ActiveColorTargets[index]); +} +RenderSurfaceHandle GetActiveRenderDepthSurfaceD3D11() +{ + return RenderSurfaceHandle(s_ActiveDepthTarget); +} + +RenderSurfaceHandle GetActiveRenderColorSurfaceBBD3D11() +{ + RenderColorSurfaceD3D11* ret = s_ActiveColorTargets[0]; + if(ret == s_DummyColorBackBuffer) + ret = s_ActiveColorBackBuffer; + + return RenderSurfaceHandle(ret); +} + +bool IsActiveRenderTargetWithColorD3D11() +{ + return !s_ActiveColorTargets[0] || s_ActiveColorTargets[0]->backBuffer || s_ActiveColorTargets[0]->m_Texture; +} + +RenderSurfaceHandle CreateRenderColorSurfaceD3D11 (TextureID textureID, int width, int height, int samples, int depth, TextureDimension dim, UInt32 createFlags, RenderTextureFormat format, TexturesD3D11& textures) +{ + RenderSurfaceHandle rsHandle; + + if( !gGraphicsCaps.hasRenderToTexture ) + return rsHandle; + if( !gGraphicsCaps.supportsRenderTextureFormat[format] ) + return rsHandle; + + RenderColorSurfaceD3D11* rs = new RenderColorSurfaceD3D11; + rs->width = width; + rs->height = height; + rs->samples = samples; + rs->depth = depth; + rs->format = format; + rs->textureID = textureID; + rs->dim = dim; + rs->flags = createFlags; + + // Create it + if (!InitD3D11RenderColorSurface(*rs, textures)) + { + delete rs; + return rsHandle; + } + + rsHandle.object = rs; + return rsHandle; +} + +RenderSurfaceHandle CreateRenderDepthSurfaceD3D11 (TextureID textureID, int width, int height, int samples, TextureDimension dim, DepthBufferFormat depthFormat, UInt32 createFlags, TexturesD3D11& textures) +{ + RenderSurfaceHandle rsHandle; + + if( !gGraphicsCaps.hasRenderToTexture ) + return rsHandle; + + RenderDepthSurfaceD3D11* rs = new RenderDepthSurfaceD3D11; + rs->width = width; + rs->height = height; + rs->samples = samples; + rs->dim = dim; + rs->depthFormat = depthFormat; + rs->textureID = textureID; + rs->flags = createFlags; + + // Create it + bool sampleOnly = (createFlags & kSurfaceCreateSampleOnly) != 0; + if (!InitD3D11RenderDepthSurface (*rs, &textures, sampleOnly)) + { + delete rs; + return rsHandle; + } + + rsHandle.object = rs; + return rsHandle; +} + +void InternalDestroyRenderSurfaceD3D11 (RenderSurfaceD3D11* rs, TexturesD3D11* textures) +{ + AssertIf( !rs ); + + if(rs == s_ActiveColorBackBuffer || rs == s_ActiveDepthBackBuffer) + { + s_ActiveColorBackBuffer = NULL; + s_ActiveDepthBackBuffer = NULL; + } + + RenderSurfaceHandle defaultColor(s_DummyColorBackBuffer); + RenderSurfaceHandle defaultDepth(s_DummyDepthBackBuffer); + + for (int i = 0; i < s_ActiveColorTargetCount; ++i) + { + if (s_ActiveColorTargets[i] == rs) + { + ErrorString( "RenderTexture warning: Destroying active render texture. Switching to main context." ); + SetRenderTargetD3D11 (1, &defaultColor, defaultDepth, 0, kCubeFaceUnknown, NULL, NULL, textures); + } + } + if (s_ActiveDepthTarget == rs) + { + ErrorString( "RenderTexture warning: Destroying active render texture. Switching to main context." ); + SetRenderTargetD3D11 (1, &defaultColor, defaultDepth, 0, kCubeFaceUnknown, NULL, NULL, textures); + } + + if (rs->m_Texture || rs->textureID.m_ID) + { + UnbindTextureD3D11 (rs->textureID); + if (textures) + textures->RemoveTexture (rs->textureID); + } + + REGISTER_EXTERNAL_GFX_DEALLOCATION(rs->m_Texture); + if (rs->colorSurface) + { + RenderColorSurfaceD3D11* colorRS = static_cast<RenderColorSurfaceD3D11*>(rs); + colorRS->Reset(); + } + else + { + RenderDepthSurfaceD3D11* depthRS = static_cast<RenderDepthSurfaceD3D11*>(rs); + depthRS->Reset(); + } +} + +void DestroyRenderSurfaceD3D11 (RenderSurfaceHandle& rsHandle, TexturesD3D11& textures) +{ + if( !rsHandle.IsValid() ) + return; + + RenderSurfaceD3D11* rs = reinterpret_cast<RenderSurfaceD3D11*>( rsHandle.object ); + InternalDestroyRenderSurfaceD3D11 (rs, &textures); + delete rs; + rsHandle.object = NULL; +} + + + +// -------------------------------------------------------------------------- + + +#if ENABLE_UNIT_TESTS +#include "External/UnitTest++/src/UnitTest++.h" + +SUITE (RenderTextureD3D11Tests) +{ +TEST(RenderTextureD3D11_FormatTableCorrect) +{ + // checks that you did not forget to update format table when adding a new format :) + for (int i = 0; i < kRTFormatCount; ++i) + { + CHECK(kD3D11RenderResourceFormats[i] != 0); + CHECK(kD3D11RenderTextureFormatsNorm[i] != 0); + CHECK(kD3D11RenderTextureFormatsSRGB[i] != 0); + } +} +} + +#endif diff --git a/Runtime/GfxDevice/d3d11/ShaderGeneratorD3D11.cpp b/Runtime/GfxDevice/d3d11/ShaderGeneratorD3D11.cpp new file mode 100644 index 0000000..4752142 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/ShaderGeneratorD3D11.cpp @@ -0,0 +1,1504 @@ +#include "UnityPrefix.h" +#include "ShaderGeneratorD3D11.h" +#include "FixedFunctionStateD3D11.h" +#include "ConstantBuffersD3D11.h" +#include "D3D11Context.h" +#include "Runtime/GfxDevice/GpuProgram.h" +#include "External/shaderlab/Library/TextureBinding.h" +#include "Runtime/GfxDevice/GfxDevice.h" +#include "D3D11ByteCode.h" + +#define DEBUG_D3D11_FF_SHADERS (!UNITY_RELEASE && 0) +#define DEBUG_D3D11_COMPARE_WITH_HLSL (DEBUG_D3D11_FF_SHADERS && 0) + +ConstantBuffersD3D11& GetD3D11ConstantBuffers (GfxDevice& device); + + +// --- Debugging --------------------------------------------------------------------------------- + + +#if DEBUG_D3D11_FF_SHADERS + +#include "Runtime/GfxDevice/d3d11/D3D11Compiler.h" +#if UNITY_WINRT +#include "PlatformDependent/MetroPlayer/MetroUtils.h" +#endif + +static D3D11Compiler s_Compiler; + +static bool HasD3D11Compiler() +{ + static bool initialized = false; + if (!initialized) + { + //s_Compiler.Initialize (kD3D11CompilerDLL); + const char* dllName = kD3D11CompilerDLL; + s_Compiler.compileFunc = NULL; + s_Compiler.stripShaderFunc = NULL; + s_Compiler.reflectFunc = NULL; + s_Compiler.disassembleFunc = NULL; + s_Compiler.createBlobFunc = NULL; + + #if UNITY_WINRT + HMODULE dll = LoadPackagedLibrary (ConvertToWindowsPath(dllName)->Data(), 0); + #else + HMODULE dll = LoadLibraryA (dllName); + #endif + if (dll) + { + s_Compiler.compileFunc = (D3D11Compiler::D3DCompileFunc) GetProcAddress (dll, "D3DCompile"); + s_Compiler.stripShaderFunc = (D3D11Compiler::D3DStripShaderFunc) GetProcAddress (dll, "D3DStripShader"); + s_Compiler.reflectFunc = (D3D11Compiler::D3DReflectFunc) GetProcAddress (dll, "D3DReflect"); + s_Compiler.disassembleFunc = (D3D11Compiler::D3DDisassembleFunc) GetProcAddress (dll, "D3DDisassemble"); + s_Compiler.createBlobFunc = (D3D11Compiler::D3DCreateBlobFunc) GetProcAddress (dll, "D3DCreateBlob"); + } + } + return s_Compiler.IsValid(); +} + +#endif // #if DEBUG_D3D11_FF_SHADERS + + +#if DEBUG_D3D11_COMPARE_WITH_HLSL + +enum D3DCOMPILER_STRIP_FLAGS +{ + D3DCOMPILER_STRIP_REFLECTION_DATA = 1, + D3DCOMPILER_STRIP_DEBUG_INFO = 2, + D3DCOMPILER_STRIP_TEST_BLOBS = 4, + D3DCOMPILER_STRIP_FORCE_DWORD = 0x7fffffff, +}; + +#define D3D_DISASM_ENABLE_COLOR_CODE 1 +#define D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTS 2 +#define D3D_DISASM_ENABLE_INSTRUCTION_NUMBERING 4 +#define D3D_DISASM_ENABLE_INSTRUCTION_CYCLE 8 + +static void DebugCompileHLSLShaderD3D11 (const std::string& source, bool vertex) +{ + if (!HasD3D11Compiler()) + return; + + ID3D10Blob* shader = NULL; + ID3D10Blob* errors; + Assert (s_Compiler.compileFunc); + HRESULT hr = s_Compiler.compileFunc ( + source.c_str(), + source.size(), + "source", + NULL, + NULL, + "main", + gGraphicsCaps.d3d11.featureLevel < kDX11Level10_0 + ? (vertex ? "vs_4_0_level_9_3" : "ps_4_0_level_9_3") + : (vertex ? "vs_4_0" : "ps_4_0"), + 0, + 0, + &shader, + &errors); + + if (FAILED(hr)) + { + printf_console ("Failed to compile D3D11 shader:\n%s\n", source.c_str()); + if (errors) + { + std::string msg (reinterpret_cast<const char*>(errors->GetBufferPointer()), errors->GetBufferSize()); + printf_console ("\nErrors:\n%s\n", msg.c_str()); + errors->Release(); + } + else + { + printf_console ("\nErrors unknown!\n"); + } + AssertString ("Failed to compile fixed function D3D11 shader"); + return; + } + + if (shader && s_Compiler.stripShaderFunc) + { + ID3D10Blob* strippedShader = NULL; + + hr = s_Compiler.stripShaderFunc (shader->GetBufferPointer(), shader->GetBufferSize(), D3DCOMPILER_STRIP_REFLECTION_DATA | D3DCOMPILER_STRIP_DEBUG_INFO | D3DCOMPILER_STRIP_TEST_BLOBS, &strippedShader); + if (SUCCEEDED(hr)) + { + SAFE_RELEASE(shader); + shader = strippedShader; + } + } + + SAFE_RELEASE(errors); + + if (shader && s_Compiler.disassembleFunc) + { + ID3D10Blob* disasm = NULL; + hr = s_Compiler.disassembleFunc (shader->GetBufferPointer(), shader->GetBufferSize(), D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTS, NULL, &disasm); + if (SUCCEEDED(hr) && disasm) + { + printf_console ("disasm:\n%s\n\n", disasm->GetBufferPointer()); + } + SAFE_RELEASE(disasm); + } + + SAFE_RELEASE(shader); +} + +static inline void AddToStringList (std::string& str, const char* s) +{ + if (!str.empty()) + str += ','; + str += s; +} + +#endif // #if DEBUG_D3D11_COMPARE_WITH_HLSL + + + +// --- Constant buffers & utilities -------------------------------------------------------------- + + +static const char* kD3D11VertexCB = "UnityFFVertex"; +static const char* kD3D11PixelCB = "UnityFFPixel"; + +enum { + k11VertexMVP = 0, + k11VertexMV = 4, + k11VertexColor = 8, + k11VertexAmbient = 9, + k11VertexLightColor = 10, + k11VertexLightPos = 18, + k11VertexLightAtten = 26, + k11VertexLightSpot = 34, + k11VertexMatDiffuse = 42, + k11VertexMatAmbient = 43, + k11VertexMatSpec = 44, + k11VertexMatEmission = 45, + k11VertexTex = 46, + k11VertexFog = 62, + k11VertexSize = 63, + k11VertexPosOffset9x = k11VertexSize+1, +}; +//k11VertexPosOffset9x will be used like that: +// mad oPos.xy, v0.w, c63, v0 +// mov oPos.zw, v0 + +#if DEBUG_D3D11_COMPARE_WITH_HLSL +static const char* kD3D11VertexPrefix = + "cbuffer UnityFFVertex {\n" + " float4x4 ff_matrix_mvp;\n" // 0 + " float4x4 ff_matrix_mv;\n" // 4 + " float4 ff_vec_color;\n" // 8 + " float4 ff_vec_ambient;\n" // 9 + " float4 ff_light_color[8];\n" // 10 + " float4 ff_light_pos[8];\n" // 18 + " float4 ff_light_atten[8];\n" // 26 + " float4 ff_light_spot[8];\n" // 34 + " float4 ff_mat_diffuse;\n" // 42 + " float4 ff_mat_ambient;\n" // 43 + " float4 ff_mat_spec;\n" // 44 + " float4 ff_mat_emission;\n" // 45 + " float4x4 ff_matrix_tex[4];\n" // 46 + " float4 ff_fog;\n" // 62 + "};\n"; // 62 +#endif // #if DEBUG_D3D11_COMPARE_WITH_HLSL + + +enum { + k11PixelColors = 0, + k11PixelAlphaRef = 8, + k11PixelFog = 9, + k11PixelSize = 10 +}; +#if DEBUG_D3D11_COMPARE_WITH_HLSL +static const char* kD3D11PixelPrefix = +"cbuffer UnityFFPixel {\n" +" float4 ff_vec_colors[8];\n" // 0 +" float ff_alpha_ref;\n" // 8 +" float4 ff_fog;\n" // 9 +"};\n" +"float4 main (\n "; +#endif // # if DEBUG_D3D11_COMPARE_WITH_HLSL + + +static void* BuildShaderD3D11 (DXBCBuilder* builder, size_t& outSize) +{ + Assert(builder); + + void* dxbc = dxb_build (builder, outSize); + Assert(dxbc); + dxb_destroy (builder); + + #if DEBUG_D3D11_FF_SHADERS + if (HasD3D11Compiler() && s_Compiler.disassembleFunc) + { + ID3D10Blob* disasm = NULL; + HRESULT hr = s_Compiler.disassembleFunc (dxbc, outSize, D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTS, NULL, &disasm); + if (SUCCEEDED(hr) && disasm) + { + printf_console ("disasm dxbc:\n%s\n\n", disasm->GetBufferPointer()); + } + SAFE_RELEASE(disasm); + } + #endif + + return dxbc; +} + + +// --- VERTEX program ---------------------------------------------------------------------------- + + +static void EmitMatrixMul(DXBCBuilderStream& bld, int cbIndex, char srcType, int srcIndex, char dstType, int dstIndex, int tmpIndex, bool wAlways1) +{ + bld.op(kSM4Op_MUL).reg('r',tmpIndex).swz(srcType,srcIndex,kSM4SwzRepY).swz('c',cbIndex+1); + bld.op(kSM4Op_MAD).reg('r',tmpIndex).swz('c',cbIndex+0).swz(srcType,srcIndex,kSM4SwzRepX).swz('r',tmpIndex); + bld.op(kSM4Op_MAD).reg('r',tmpIndex).swz('c',cbIndex+2).swz(srcType,srcIndex,kSM4SwzRepZ).swz('r',tmpIndex); + if (!wAlways1) + bld.op(kSM4Op_MAD).reg(dstType,dstIndex).swz('c',cbIndex+3).swz(srcType,srcIndex,kSM4SwzRepW).swz('r',tmpIndex); + else + bld.op(kSM4Op_ADD).reg(dstType,dstIndex).swz('c',cbIndex+3).swz('r',tmpIndex); +} + + +void* BuildVertexShaderD3D11 (const FixedFunctionStateD3D11& state, FixedFunctionProgramD3D11::ValueParameters& params, BuiltinShaderParamIndices& matrices, size_t& outSize) +{ + ShaderLab::FastPropertyName cbName; cbName.SetName(kD3D11VertexCB); + GetD3D11ConstantBuffers(GetRealGfxDevice()).SetCBInfo (cbName.index, k11VertexSize*16); + params.m_CBID = cbName.index; params.m_CBSize = k11VertexSize*16; + + DXBCBuilder* builder = dxb_create(4, 0, kSM4Shader_Vertex); + DXBCBuilderStream bld(builder); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + std::string helpers, inputs, outputs, code; + #endif + + bool hasLights = (state.lightingEnabled && state.lightCount > 0); + + bool eyePositionRequired = + hasLights || + (state.fogMode != kFogDisabled); + bool eyeNormalRequired = hasLights; + bool viewDirRequired = hasLights && state.specularEnabled; + bool eyeReflRequired = false; + { + UInt64 texSources = state.texUnitSources; + for (int i = 0; i < state.texUnitCount; i++) + { + UInt32 uvSource = texSources & 0xF; + if (uvSource == kTexSourceEyeLinear) + eyePositionRequired = true; + if (uvSource == kTexSourceCubeNormal) + eyeNormalRequired = true; + if (uvSource == kTexSourceCubeReflect || uvSource == kTexSourceSphereMap) + eyeReflRequired = viewDirRequired = eyePositionRequired = eyeNormalRequired = true; + texSources >>= 4; + } + } + if (eyePositionRequired || eyeNormalRequired || eyeReflRequired) + { + matrices.mat[kShaderInstanceMatMV].gpuIndex = k11VertexMV*16; + matrices.mat[kShaderInstanceMatMV].rows = 4; + matrices.mat[kShaderInstanceMatMV].cols = 4; + matrices.mat[kShaderInstanceMatMV].cbID = params.m_CBID; + } + + dxb_dcl_cb(builder, 0, k11VertexSize); + + int inputRegCounter = 0, outputRegCounter = 0, tempRegCounter = 0; + int inPosReg = 0, inColorReg = 0, inNormalReg = 0; + int inUVReg[8] = {0}; + int outColor0Reg = 0, outColor1Reg = 0, outPosReg = 0; + int outUVReg[8] = {0}; + int eyePosReg = 0, eyeNormalReg = 0, viewDirReg = 0, eyeReflReg = 0, lcolorReg = 0, specColorReg = 0; + + dxb_dcl_input(builder, "POSITION", 0, inPosReg = inputRegCounter++); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (inputs, "float4 vertex : POSITION"); + #endif + + // color = Vertex or uniform color + char inColorType; + if (state.useUniformInsteadOfVertexColor) + { + params.AddVectorParam (k11VertexColor*16, 4, kShaderVecFFColor); + inColorType = 'c'; + inColorReg = k11VertexColor; + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "float4 color = ff_vec_color;\n"; + #endif + } + else + { + inColorType = 'v'; + dxb_dcl_input(builder, "COLOR", 0, inColorReg = inputRegCounter++); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (inputs, "float4 vertexColor : COLOR"); + code += "float4 color = vertexColor;\n"; + #endif + } + + // eyePos = eye position + if (eyePositionRequired) + { + eyePosReg = tempRegCounter++; + EmitMatrixMul (bld, k11VertexMV, 'v',inPosReg, 'r',eyePosReg, eyePosReg, false); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "float3 eyePos = mul (ff_matrix_mv, vertex).xyz;\n"; + #endif + } + + // eyeNormal = normalize(normalMatrix * normal) + if (eyeNormalRequired) + { + dxb_dcl_input(builder, "NORMAL", 0, inNormalReg = inputRegCounter++, 0x7); + eyeNormalReg = tempRegCounter++; + // mul + bld.op(kSM4Op_MUL).reg('r',eyeNormalReg,7).swz('v',inNormalReg,kSM4SwzRepY).swz('c',k11VertexMV+1); + bld.op(kSM4Op_MAD).reg('r',eyeNormalReg,7).swz('c',k11VertexMV+0).swz('v',inNormalReg,kSM4SwzRepX).swz('r',eyeNormalReg); + bld.op(kSM4Op_MAD).reg('r',eyeNormalReg,7).swz('c',k11VertexMV+2).swz('v',inNormalReg,kSM4SwzRepZ).swz('r',eyeNormalReg); + // normalize + bld.op(kSM4Op_DP3).reg('r',eyeNormalReg,8).swz('r',eyeNormalReg,kSM4SwzNone).swz('r',eyeNormalReg,kSM4SwzNone); + bld.op(kSM4Op_RSQ).reg('r',eyeNormalReg,8).swz('r',eyeNormalReg,kSM4SwzRepW); + bld.op(kSM4Op_MUL).reg('r',eyeNormalReg,7).swz('r',eyeNormalReg,kSM4SwzRepW).swz('r',eyeNormalReg,kSM4SwzXYZX); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (inputs, "float3 normal : NORMAL"); + code += "float3 eyeNormal = normalize (mul ((float3x3)ff_matrix_mv, normal).xyz);\n"; //@TODO: proper normal matrix + #endif + } + + // view dir + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "float3 viewDir = 0.0;"; + #endif + if (viewDirRequired) + { + // viewDir = normalized vertex-to-eye + viewDirReg = tempRegCounter++; + // -normalize + bld.op(kSM4Op_DP3).reg('r',viewDirReg,8).swz('r',eyePosReg,kSM4SwzNone).swz('r',eyePosReg,kSM4SwzNone); + bld.op(kSM4Op_RSQ).reg('r',viewDirReg,8).swz('r',viewDirReg,kSM4SwzRepW); + bld.op(kSM4Op_MUL).reg('r',viewDirReg,7).swz('r',viewDirReg,kSM4SwzRepW).swz('r',eyePosReg,kSM4SwzXYZX,true); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "viewDir = -normalize (eyePos);\n"; + #endif + } + + // eyeRefl + if (eyeReflRequired) + { + DebugAssert (viewDirRequired); + // eyeRefl = reflection vector, 2*dot(V,N)*N-V + eyeReflReg = tempRegCounter++; + bld.op(kSM4Op_DP3).reg('r',eyeReflReg,8).swz('r',viewDirReg,kSM4SwzNone).swz('r',eyeNormalReg,kSM4SwzNone); + bld.op(kSM4Op_ADD).reg('r',eyeReflReg,8).swz('r',eyeReflReg,kSM4SwzRepW).swz('r',eyeReflReg,kSM4SwzRepW); + bld.op(kSM4Op_MAD).reg('r',eyeReflReg,7).swz('r',eyeReflReg,kSM4SwzRepW).swz('r',eyeNormalReg,kSM4SwzXYZX).swz('r',viewDirReg,kSM4SwzXYZX,true); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "float3 eyeRefl = 2.0f * dot (viewDir, eyeNormal) * eyeNormal - viewDir;\n"; + #endif + } + + // Lighting + if (state.lightingEnabled) + { + char ambientType, diffuseType, emissionType; + int ambientReg, diffuseReg, emissionReg; + if (state.colorMaterial==kColorMatAmbientAndDiffuse) + { + ambientType = diffuseType = inColorType; + ambientReg = diffuseReg = inColorReg; + } + else + { + ambientType = diffuseType = 'c'; + ambientReg = k11VertexMatAmbient; + diffuseReg = k11VertexMatDiffuse; + } + if (state.colorMaterial==kColorMatEmission) + { + emissionType = inColorType; + emissionReg = inColorReg; + } + else + { + emissionType = 'c'; + emissionReg = k11VertexMatEmission; + } + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + std::string ambientColor = (state.colorMaterial==kColorMatAmbientAndDiffuse) ? "color" : "ff_mat_ambient"; + std::string diffuseColor = (state.colorMaterial==kColorMatAmbientAndDiffuse) ? "color" : "ff_mat_diffuse"; + std::string emissionColor = (state.colorMaterial==kColorMatEmission) ? "color" : "ff_mat_emission"; + #endif + + params.AddVectorParam (k11VertexAmbient*16, 4, kShaderVecLightModelAmbient); + params.AddVectorParam (k11VertexMatAmbient*16, 4, kShaderVecFFMatAmbient); + params.AddVectorParam (k11VertexMatDiffuse*16, 4, kShaderVecFFMatDiffuse); + params.AddVectorParam (k11VertexMatSpec*16, 4, kShaderVecFFMatSpecular); + params.AddVectorParam (k11VertexMatEmission*16, 4, kShaderVecFFMatEmission); + + lcolorReg = tempRegCounter++; + bld.op(kSM4Op_MAD).reg('r',lcolorReg,7).swz(ambientType,ambientReg,kSM4SwzXYZX).swz('c',k11VertexAmbient,kSM4SwzXYZX).swz(emissionType,emissionReg,kSM4SwzXYZX); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "float3 lcolor = " + emissionColor + ".rgb + " + ambientColor + ".rgb * ff_vec_ambient.rgb;\n"; + code += "float3 specColor = 0.0;\n"; + if (state.lightCount > 0) + { + helpers += "float3 computeLighting (int idx, float3 dirToLight, float3 eyeNormal, float3 viewDir, float4 diffuseColor, float atten, inout float3 specColor) {\n"; + helpers += " float NdotL = max(dot(eyeNormal, dirToLight), 0.0);\n"; + helpers += " float3 color = NdotL * diffuseColor.rgb * ff_light_color[idx].rgb;\n"; + if (state.specularEnabled) + { + helpers += " if (NdotL > 0.0) {\n"; + helpers += " float3 h = normalize(dirToLight + viewDir);\n"; + helpers += " float HdotN = max(dot(eyeNormal, h), 0.0);\n"; + helpers += " float sp = saturate(pow(HdotN, ff_mat_spec.w));\n"; + helpers += " specColor += atten * sp * ff_light_color[idx].rgb;\n"; + helpers += " }\n"; + } + helpers += " return color * atten;\n"; + helpers += "}\n"; + + helpers += "float3 computeSpotLight(int idx, float3 eyePosition, float3 eyeNormal, float3 viewDir, float4 diffuseColor, inout float3 specColor) {\n"; + helpers += " float3 dirToLight = ff_light_pos[idx].xyz - eyePosition * ff_light_pos[idx].w;\n"; + helpers += " float distSqr = dot(dirToLight, dirToLight);\n"; + helpers += " float att = 1.0 / (1.0 + ff_light_atten[idx].z * distSqr);\n"; + helpers += " if (ff_light_pos[idx].w != 0 && distSqr > ff_light_atten[idx].w) att = 0.0;\n"; // set to 0 if outside of range + helpers += " dirToLight *= rsqrt(distSqr);\n"; + + helpers += " float rho = max(dot(dirToLight, ff_light_spot[idx].xyz), 0.0);\n"; + helpers += " float spotAtt = (rho - ff_light_atten[idx].x) * ff_light_atten[idx].y;\n"; + helpers += " spotAtt = saturate(spotAtt);\n"; + helpers += " return min (computeLighting (idx, dirToLight, eyeNormal, viewDir, diffuseColor, att*spotAtt, specColor), 1.0);\n"; + helpers += "}\n"; + } + #endif // DEBUG_D3D11_COMPARE_WITH_HLSL + + if (state.specularEnabled) + { + specColorReg = tempRegCounter++; + bld.op(kSM4Op_MOV).reg('r',specColorReg,7).float4(0,0,0,0); + } + + for (int i = 0; i < state.lightCount; ++i) + { + params.AddVectorParam ((k11VertexLightPos+i)*16, 4, BuiltinShaderVectorParam(kShaderVecLight0Position+i)); + params.AddVectorParam ((k11VertexLightAtten+i)*16, 4, BuiltinShaderVectorParam(kShaderVecLight0Atten+i)); + params.AddVectorParam ((k11VertexLightColor+i)*16, 4, BuiltinShaderVectorParam(kShaderVecLight0Diffuse+i)); + params.AddVectorParam ((k11VertexLightSpot+i)*16, 4, BuiltinShaderVectorParam(kShaderVecLight0SpotDirection+i)); + + Assert(eyePositionRequired); + Assert(eyeNormalRequired); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "lcolor += computeSpotLight(" + IntToString(i) + ", eyePos, eyeNormal, viewDir, " + diffuseColor + ", specColor);\n"; + #endif + + int ldirReg = tempRegCounter; + int miscReg = tempRegCounter+1; + int diffReg = tempRegCounter+2; + + // + // attenuation + + // float3 dirToLight = ff_light_pos[idx].xyz - eyePosition * ff_light_pos[idx].w; + // float distSqr = dot(dirToLight, dirToLight); + // float att = 1.0 / (1.0 + ff_light_atten[idx].z * distSqr); + // if (ff_light_pos[idx].w != 0 && distSqr > ff_light_atten[idx].w) att = 0.0; + // dirToLight *= rsqrt(distSqr); + // float rho = max(dot(dirToLight, ff_light_spot[idx].xyz), 0.0); + // float spotAtt = (rho - ff_light_atten[idx].x) * ff_light_atten[idx].y; + // spotAtt = saturate(spotAtt); + + // dirToLight = ff_light_pos[idx].xyz - eyePosition * ff_light_pos[idx].w + bld.op(kSM4Op_MAD).reg('r',ldirReg,7).swz('r',eyePosReg,kSM4SwzXYZX,true).swz('c',k11VertexLightPos+i,kSM4SwzRepW).swz('c',k11VertexLightPos+i,kSM4SwzXYZX); + // normalize, distSqr in miscReg.w + bld.op(kSM4Op_DP3).reg('r',miscReg,8).swz('r',ldirReg,kSM4SwzNone).swz('r',ldirReg,kSM4SwzNone); + bld.op(kSM4Op_RSQ).reg('r',ldirReg,8).swz('r',miscReg,kSM4SwzRepW); + bld.op(kSM4Op_MUL).reg('r',ldirReg,7).swz('r',ldirReg,kSM4SwzRepW).swz('r',ldirReg,kSM4SwzXYZX); + + // miscReg.z = float rho = max(dot(dirToLight, ff_light_spot[idx].xyz), 0.0) + bld.op(kSM4Op_DP3).reg('r',miscReg,4).swz('r',ldirReg,kSM4SwzNone).swz('c',k11VertexLightSpot+i,kSM4SwzNone); + bld.op(kSM4Op_MAX).reg('r',miscReg,4).swz('r',miscReg,kSM4SwzRepZ).float1(0.0f); + // miscReg.z = spotAtt = saturate ( (rho - ff_light_atten[idx].x) * ff_light_atten[idx].y ) + bld.op(kSM4Op_ADD).reg('r',miscReg,4).swz('r',miscReg,kSM4SwzRepZ).swz('c',k11VertexLightAtten+i,kSM4SwzRepX,true); + bld.op_sat(kSM4Op_MUL,miscReg).reg('r',miscReg,4).swz('r',miscReg,kSM4SwzRepZ).swz('c',k11VertexLightAtten+i,kSM4SwzRepY); + + // miscReg.y = float att = 1.0 / (1.0 + ff_light_atten[idx].z * distSqr) + bld.op(kSM4Op_MAD).reg('r',miscReg,2).swz('c',k11VertexLightAtten+i,kSM4SwzRepZ).swz('r',miscReg,kSM4SwzRepW).float1(1.0f); + bld.noAutoSM2(); + bld.op(kSM4Op_DIV).reg('r',miscReg,2).float4(1,1,1,1).swz('r',miscReg,kSM4SwzRepY); + bld.op2(kSM2Op_RCP).reg2('r',miscReg,2).swz2('r',miscReg,kSM4SwzRepY); + bld.autoSM2(); + + // miscReg.y = att * spotAtt + bld.op(kSM4Op_MUL).reg('r',miscReg,2).swz('r',miscReg,kSM4SwzRepY).swz('r',miscReg,kSM4SwzRepZ); + // if (ff_light_pos[idx].w != 0 && distSqr > ff_light_atten[idx].w) att = 0.0 + bld.noAutoSM2(); + bld.op(kSM4Op_LT).reg('r',miscReg,1).swz('c',k11VertexLightAtten+i,kSM4SwzRepW).swz('r',miscReg,kSM4SwzRepW); + bld.op(kSM4Op_NE).reg('r',miscReg,4).swz('c',k11VertexLightPos+i,kSM4SwzRepW).float1(0.0); + bld.op(kSM4Op_AND).reg('r',miscReg,1).swz('r',miscReg,kSM4SwzRepX).swz('r',miscReg,kSM4SwzRepZ); + bld.op(kSM4Op_MOVC).reg('r',miscReg,2).swz('r',miscReg,kSM4SwzRepX).float1(0.0).swz('r',miscReg,kSM4SwzRepY); + //SM2 + bld.op2(kSM2Op_SLT).reg2('r',miscReg,1).swz2('c',k11VertexLightAtten+i,kSM4SwzRepW).swz2('r',miscReg,kSM4SwzRepW); + bld.op2(kSM2Op_MUL).reg2('r',miscReg,4).swz2('c',k11VertexLightPos+i,kSM4SwzRepW).swz2('c',k11VertexLightPos+i,kSM4SwzRepW); + bld.op2(kSM2Op_SLT).reg2('r',miscReg,4).swz2('r',miscReg,kSM4SwzRepZ,true).swz2('r',miscReg,kSM4SwzRepZ); + bld.op2(kSM2Op_MUL).reg2('r',miscReg,1).swz2('r',miscReg,kSM4SwzRepX).swz2('r',miscReg,kSM4SwzRepZ); + bld.op2(kSM2Op_MAD).reg2('r',miscReg,2).swz2('r',miscReg,kSM4SwzRepX).swz2('r',miscReg,kSM4SwzRepY,true).swz2('r',miscReg,kSM4SwzRepY); + bld.autoSM2(); + + // + // diffuse + + // float NdotL = max(dot(eyeNormal, dirToLight), 0.0); + // float3 color = NdotL * diffuseColor.rgb * ff_light_color[idx].rgb; + // lcolor += color * atten + + // miscReg.z = float NdotL = max(dot(eyeNormal, dirToLight), 0.0) + bld.op(kSM4Op_DP3).reg('r',miscReg,4).swz('r',eyeNormalReg,kSM4SwzNone).swz('r',ldirReg,kSM4SwzNone); + bld.op(kSM4Op_MAX).reg('r',miscReg,4).swz('r',miscReg,kSM4SwzRepZ).float1(0.0f); + // diffReg.xyz = float3 color = NdotL * diffuseColor.rgb * ff_light_color[idx].rgb + bld.op(kSM4Op_MUL).reg('r',diffReg,7).swz('r',miscReg,kSM4SwzRepZ).swz(diffuseType,diffuseReg,kSM4SwzXYZX); + bld.op(kSM4Op_MUL).reg('r',diffReg,7).swz('r',diffReg,kSM4SwzXYZX).swz('c',k11VertexLightColor+i,kSM4SwzXYZX); + // diffReg.xyz = saturate(color*atten, 1) + bld.op_sat(kSM4Op_MUL,diffReg).reg('r',diffReg,7).swz('r',diffReg,kSM4SwzXYZX).swz('r',miscReg,kSM4SwzRepY); + // lcolor += diffReg + bld.op(kSM4Op_ADD).reg('r',lcolorReg,7).swz('r',lcolorReg,kSM4SwzXYZX).swz('r',diffReg,kSM4SwzXYZX); + + // + // specular + + if (state.specularEnabled) + { + // if (NdotL > 0.0) { + // float3 h = normalize(dirToLight + viewDir); + // float HdotN = max(dot(eyeNormal, h), 0.0); + // float sp = saturate(pow(HdotN, ff_mat_spec.w)); + // specColor += atten * sp * ff_light_color[idx].rgb; + // } + + // ldirReg.xyz = h = normalize(dirToLight + viewDir) + bld.op(kSM4Op_ADD).reg('r',ldirReg,7).swz('r',ldirReg,kSM4SwzXYZX).swz('r',viewDirReg,kSM4SwzXYZX); + bld.op(kSM4Op_DP3).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzNone).swz('r',ldirReg,kSM4SwzNone); + bld.op(kSM4Op_RSQ).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzRepW); + bld.op(kSM4Op_MUL).reg('r',ldirReg,7).swz('r',ldirReg,kSM4SwzXYZX).swz('r',ldirReg,kSM4SwzRepW); + // ldirReg.w = HdotN = max(dot(eyeNormal,h),0) + bld.op(kSM4Op_DP3).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzNone).swz('r',eyeNormalReg,kSM4SwzNone); + bld.op(kSM4Op_MAX).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzRepW).float1(0.0f); + // float sp = saturate(pow(HdotN, ff_mat_spec.w)) + bld.op(kSM4Op_LOG).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzRepW); + bld.op(kSM4Op_MUL).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzRepW).swz('c',k11VertexMatSpec,kSM4SwzRepW); + bld.op(kSM4Op_EXP).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzRepW); + bld.op(kSM4Op_MIN).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzRepW).float1(1.0f); + // atten * sp * ff_light_color[idx].rgb + bld.op(kSM4Op_MUL).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzRepW).swz('r',miscReg,kSM4SwzRepY); + bld.op(kSM4Op_MUL).reg('r',diffReg,7).swz('r',ldirReg,kSM4SwzRepW).swz('c',k11VertexLightColor+i,kSM4SwzXYZX); + // nuke specular if NdotL <= 0 + bld.op(kSM4Op_LT).reg('r',miscReg,1).float1(0.0).swz('r',miscReg,kSM4SwzRepZ); + bld.noAutoSM2(); + bld.op(kSM4Op_AND).reg('r',diffReg,7).swz('r',diffReg,kSM4SwzXYZX).swz('r',miscReg,kSM4SwzRepX); + bld.op2(kSM2Op_MUL).reg2('r',diffReg,7).swz2('r',diffReg,kSM4SwzXYZX).swz2('r',miscReg,kSM4SwzRepX); + bld.autoSM2(); + // specColor += computed spec color + bld.op(kSM4Op_ADD).reg('r',specColorReg,7).swz('r',specColorReg,kSM4SwzXYZX).swz('r',diffReg,kSM4SwzXYZX); + } + } + + bld.op(kSM4Op_MOV).reg('r',lcolorReg,8).swz(diffuseType,diffuseReg,kSM4SwzRepW); + inColorReg = lcolorReg; + inColorType = 'r'; + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "color.rgb = lcolor.rgb;\n"; + code += "color.a = " + diffuseColor + ".a;\n"; + #endif + + if (state.specularEnabled) + { + bld.op(kSM4Op_MUL).reg('r',specColorReg,7).swz('r',specColorReg,kSM4SwzXYZX).swz('c',k11VertexMatSpec,kSM4SwzXYZX); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "specColor *= ff_mat_spec.rgb;\n"; + #endif + } + } + + // Output final color + dxb_dcl_output(builder, "COLOR", 0, outColor0Reg = outputRegCounter++); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (outputs, "out float4 ocolor : COLOR0"); + #endif + + bld.op_sat(kSM4Op_MOV,tempRegCounter).reg('o',outColor0Reg).swz(inColorType,inColorReg); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ocolor = saturate(color);\n"; + #endif + + if (state.lightingEnabled && state.specularEnabled) + { + dxb_dcl_output(builder, "COLOR", 1, outColor1Reg = outputRegCounter++, 0x7); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (outputs, "out float3 ospec : COLOR1"); + #endif + + bld.op_sat(kSM4Op_MOV,tempRegCounter).reg('o',outColor1Reg,7).swz('r',specColorReg,kSM4SwzXYZX); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ospec = saturate(specColor);\n"; + #endif + } + + // we don't need temporary registers from lighting calculations anymore after this point + if (state.lightingEnabled) + --tempRegCounter; + + + // Pass & transform texture coordinates + UInt32 gotInputs = 0; + UInt32 gotOutputs = 0; + UInt64 texSources = state.texUnitSources; + for (int i = 0; i < state.texUnitCount; i++) + { + matrices.mat[kShaderInstanceMatTexture0+i].gpuIndex = (k11VertexTex+i*4)*16; + matrices.mat[kShaderInstanceMatTexture0+i].rows = 4; + matrices.mat[kShaderInstanceMatTexture0+i].cols = 4; + matrices.mat[kShaderInstanceMatTexture0+i].cbID = params.m_CBID; + + std::string iname = IntToString(i); + dxb_dcl_output(builder, "TEXCOORD", i, outUVReg[i] = outputRegCounter++); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (outputs, ("out float4 ouv" + iname + " : TEXCOORD" + iname).c_str()); + #endif + + UInt32 uvSource = texSources & 0xF; + if (uvSource >= kTexSourceUV0 && uvSource <= kTexSourceUV7) + { + unsigned uv = uvSource-kTexSourceUV0; + std::string uvStr = IntToString(uv); + if (!(gotInputs & (1<<uv))) + { + dxb_dcl_input(builder, "TEXCOORD", uv, inUVReg[uv] = inputRegCounter++); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (inputs, ("float4 uv"+uvStr+" : TEXCOORD"+uvStr).c_str()); + #endif + gotInputs |= (1<<uv); + } + EmitMatrixMul (bld, k11VertexTex+4*i, 'v',inUVReg[uv], 'o',outUVReg[i], tempRegCounter, false); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ouv"+iname + " = mul(ff_matrix_tex["+iname + "], uv"+uvStr+");\n"; + #endif + } + else if (uvSource == kTexSourceSphereMap) + { + // m = 2*sqrt(Rx*Rx + Ry*Ry + (Rz+1)*(Rz+1)) + // SPHR = Rx/m + 0.5, Ry/m + 0.5 + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ouv"+iname + " = mul(ff_matrix_tex["+iname +"], float4(\n"; + code += " eyeRefl.xy / (2.0*sqrt(eyeRefl.x*eyeRefl.x + eyeRefl.y*eyeRefl.y + (eyeRefl.z+1)*(eyeRefl.z+1))) + 0.5,\n"; + code += " 0,1));\n"; + #endif + + // HLSL generates code like: + // dp2 r0.w, r0.xyxx, r0.xyxx + // add r0.z, r0.z, l(1.0) + // mad r0.z, r0.z, r0.z, r0.w + // sqrt r0.z, r0.z + // add r0.z, r0.z, r0.z + // div r0.xy, r0.xyxx, r0.zzzz + // add r0.xy, r0.xyxx, l(0.5, 0.5, 0.0, 0.0) +#if 0 + bld.op(kSM4Op_DP2).reg('r',tempRegCounter,8).swz('r',eyeReflReg,kSM4SwzXYXX).swz('r',eyeReflReg,kSM4SwzXYXX); + bld.op(kSM4Op_ADD).reg('r',tempRegCounter,4).swz('r',eyeReflReg,kSM4SwzRepZ).float1(1.0); + bld.op(kSM4Op_MAD).reg('r',tempRegCounter,4).swz('r',tempRegCounter,kSM4SwzRepZ).swz('r',tempRegCounter,kSM4SwzRepZ).swz('r',tempRegCounter,kSM4SwzRepW); + bld.op(kSM4Op_SQRT).reg('r',tempRegCounter,4).swz('r',tempRegCounter,kSM4SwzRepZ); + bld.op(kSM4Op_ADD).reg('r',tempRegCounter,4).swz('r',tempRegCounter,kSM4SwzRepZ).swz('r',tempRegCounter,kSM4SwzRepZ); + bld.op(kSM4Op_DIV).reg('r',tempRegCounter,3).swz('r',eyeReflReg,kSM4SwzXYXX).swz('r',tempRegCounter,kSM4SwzRepZ); + bld.op(kSM4Op_ADD).reg('r',tempRegCounter,3).swz('r',tempRegCounter,kSM4SwzXYXX).float4(0.5f,0.5f,0,0); +#else + //SM2 compatible + bld.op(kSM4Op_ADD).reg('r',tempRegCounter,7).swz('r',eyeReflReg,kSM4SwzXYZX).float4(0.0f,0.0f,1.0f,0.0f); + bld.op(kSM4Op_DP3).reg('r',tempRegCounter,8).swz('r',tempRegCounter,kSM4SwzNone).swz('r',tempRegCounter,kSM4SwzNone); + bld.op(kSM4Op_RSQ).reg('r',tempRegCounter,8).swz('r',tempRegCounter,kSM4SwzRepW); + bld.op(kSM4Op_MUL).reg('r',tempRegCounter,8).swz('r',tempRegCounter,kSM4SwzRepW).float4(0.5f,0.5f,0.5f,0.5f); + bld.op(kSM4Op_MAD).reg('r',tempRegCounter,3).swz('r',eyeReflReg,kSM4SwzXYXX).swz('r',tempRegCounter,kSM4SwzRepW).float4(0.5f,0.5f,0.5f,0.5f); +#endif + EmitMatrixMul (bld, k11VertexTex+4*i, 'r',tempRegCounter, 'o',outUVReg[i], tempRegCounter+1, true); + } + else if (uvSource == kTexSourceObject) + { + EmitMatrixMul (bld, k11VertexTex+4*i, 'v',inPosReg, 'o',outUVReg[i], tempRegCounter, false); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ouv"+iname + " = mul(ff_matrix_tex["+iname +"], vertex);\n"; + #endif + } + else if (uvSource == kTexSourceEyeLinear) + { + EmitMatrixMul (bld, k11VertexTex+4*i, 'r',eyePosReg, 'o',outUVReg[i], tempRegCounter, true); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ouv"+iname + " = mul(ff_matrix_tex["+iname +"], float4(eyePos,1.0));\n"; + #endif + } + else if (uvSource == kTexSourceCubeNormal) + { + EmitMatrixMul (bld, k11VertexTex+4*i, 'r',eyeNormalReg, 'o',outUVReg[i], tempRegCounter, true); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ouv"+iname + " = mul(ff_matrix_tex["+iname +"], float4(eyeNormal,1.0));\n"; + #endif + } + else if (uvSource == kTexSourceCubeReflect) + { + EmitMatrixMul (bld, k11VertexTex+4*i, 'r',eyeReflReg, 'o',outUVReg[i], tempRegCounter, true); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ouv"+iname + " = mul(ff_matrix_tex["+iname +"], float4(eyeRefl,1.0));\n"; + #endif + } + else + { + AssertString("Unknown texgen mode"); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ouv"+iname + " = 0.5;\n"; + #endif + } + texSources >>= 4; + } + + // fog if we have a spare varying + if (state.fogMode != kFogDisabled && outputRegCounter < 8) + { + Assert(eyePositionRequired); + int outFogReg; + dxb_dcl_output(builder, "FOG", 0, outFogReg = outputRegCounter++, 0x1); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (outputs, "out float ofog : FOG0"); + #endif + + params.AddVectorParam (k11VertexFog*16, 4, kShaderVecFFFogParams); + + int fogReg = tempRegCounter++; + + // fogCoord = length(eyePosition.xyz), for radial fog + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "float fogCoord = length(eyePos.xyz);\n"; + #endif + + bld.op(kSM4Op_DP3).reg('r',fogReg,1).swz('r',eyePosReg,kSM4SwzNone).swz('r',eyePosReg,kSM4SwzNone); +#if 0 + bld.op(kSM4Op_SQRT).reg('r',fogReg,1).swz('r',fogReg,kSM4SwzRepX); +#else + //SM2 compatible + bld.op(kSM4Op_RSQ).reg('r',fogReg,1).swz('r',fogReg,kSM4SwzRepX); + bld.op(kSM4Op_RCP).reg('r',fogReg,1).swz('r',fogReg,kSM4SwzRepX); +#endif + if (state.fogMode == kFogLinear) + { + // fogParams.z * fogCoord + fogParams.w + bld.op_sat(kSM4Op_MAD,tempRegCounter).reg('o',outFogReg,1).swz('r',fogReg,kSM4SwzRepX).swz('c',k11VertexFog,kSM4SwzRepZ).swz('c',k11VertexFog,kSM4SwzRepW); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ofog = saturate(fogCoord * ff_fog.z + ff_fog.w);\n"; + #endif + } + else if (state.fogMode == kFogExp) + { + // fogArg = fogParams.y * fogCoord + // exp2(-fogArg) + bld.op(kSM4Op_MUL).reg('r',fogReg,1).swz('r',fogReg,kSM4SwzRepX).swz('c',k11VertexFog,kSM4SwzRepY); + bld.op_sat(kSM4Op_EXP,tempRegCounter).reg('o',outFogReg,1).swz('r',fogReg,kSM4SwzRepX,true); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ofog = saturate(exp2(-(fogCoord * ff_fog.y)));\n"; + #endif + } + else if (state.fogMode == kFogExp2) + { + // fogArg = fogParams.y * fogCoord + // exp2(-fogArg*fogArg) + bld.op(kSM4Op_MUL).reg('r',fogReg,1).swz('r',fogReg,kSM4SwzRepX).swz('c',k11VertexFog,kSM4SwzRepY); + bld.op(kSM4Op_MUL).reg('r',fogReg,1).swz('r',fogReg,kSM4SwzRepX).swz('r',fogReg,kSM4SwzRepX); + bld.op_sat(kSM4Op_EXP,tempRegCounter).reg('o',outFogReg,1).swz('r',fogReg,kSM4SwzRepX,true); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "fogCoord = fogCoord * ff_fog.y;\n"; + code += "ofog = saturate(exp2(-fogCoord * fogCoord));\n"; + #endif + } + --tempRegCounter; + } + + dxb_dcl_output(builder, "SV_POSITION", 0, outPosReg = outputRegCounter++); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (outputs, "out float4 overtex : SV_POSITION"); + #endif + + // Vertex transformation + matrices.mat[kShaderInstanceMatMVP].gpuIndex = k11VertexMVP*16; + matrices.mat[kShaderInstanceMatMVP].rows = 4; + matrices.mat[kShaderInstanceMatMVP].cols = 4; + matrices.mat[kShaderInstanceMatMVP].cbID = params.m_CBID; + bld.op(kSM4Op_MUL).reg('r',0).swz('v',inPosReg,kSM4SwzRepY).swz('c',k11VertexMVP+1); + bld.op(kSM4Op_MAD).reg('r',0).swz('c',k11VertexMVP+0).swz('v',inPosReg,kSM4SwzRepX).swz('r',0); + bld.op(kSM4Op_MAD).reg('r',0).swz('c',k11VertexMVP+2).swz('v',inPosReg,kSM4SwzRepZ).swz('r',0); + bld.op(kSM4Op_MAD).reg('r',0).swz('c',k11VertexMVP+3).swz('v',inPosReg,kSM4SwzRepW).swz('r',0); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "overtex = mul (ff_matrix_mvp, vertex);\n"; + #endif + + //correct output pos with Vertex Shader position offset + //mad oPos.xy, v0.w, c63, v0 + bld.op2(kSM2Op_MAD).reg2('o',outPosReg,3).swz2('r',0,kSM4SwzRepW).swz2('c',k11VertexPosOffset9x).swz2('r',0); + //mov oPos.zw, v0 + bld.op2(kSM2Op_MOV).reg2('o',outPosReg,12).swz2('r',0); + + //copy output pos for sm40 + bld.noAutoSM2(); + bld.op(kSM4Op_MOV).reg('o',outPosReg).swz('r',0); + bld.autoSM2(); + + bld.op(kSM4Op_RET); + + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + std::string src = + kD3D11VertexPrefix + + helpers + '\n' + + "void main (\n " + + inputs + ",\n " + + outputs + ") {\n" + + code + "\n}"; + printf_console ("d3d11 FF VS HLSL:\n%s\n", src.c_str()); + DebugCompileHLSLShaderD3D11 (src, true); + #endif + + + void* blob = BuildShaderD3D11 (builder, outSize); + return blob; +} + + +// --- FRAGMENT program ---------------------------------------------------------------------------- + +enum CombinerWriteMask { kCombWriteRGBA, kCombWriteRGB, kCombWriteA }; + +static bool EmitCombinerMath11 ( + int stage, + UInt32 combiner, + CombinerWriteMask writeMaskMode, + int texUnitCount, + DXBCBuilderStream& bld + #if DEBUG_D3D11_COMPARE_WITH_HLSL + , std::string& code + #endif +) +{ + Assert (texUnitCount < 10 && stage < 10); + + combiner::Source sources[3]; + combiner::Operand operands[3]; + combiner::Operation op; + int scale; + combiner::DecodeTextureCombinerDescriptor (combiner, op, sources, operands, scale, true); + + // dot3 and dot3rgba write into RGBA; alpha combiner is always ignored + if (op == combiner::kOpDot3RGB || op == combiner::kOpDot3RGBA) + { + if (writeMaskMode == kCombWriteA) + return false; + writeMaskMode = kCombWriteRGBA; + } + + unsigned tmpIdx = 1; + + bool usedConstant = false; + char regFile[3]; + unsigned regIdx[3]; + unsigned regSrcAlphaSwz[3]; + #if DEBUG_D3D11_COMPARE_WITH_HLSL + std::string reg[3]; + #endif + for (int r = 0; r < 3; ++r) + { + combiner::Source source = sources[r]; + regSrcAlphaSwz[r] = kSM4SwzRepW; + if (stage == 0 && source == combiner::kSrcPrevious) + source = combiner::kSrcPrimaryColor; // first stage, "previous" the same as "primary" + switch (source) + { + case combiner::kSrcPrimaryColor: + regFile[r] = 'v'; regIdx[r] = 0; + #if DEBUG_D3D11_COMPARE_WITH_HLSL + reg[r] = "icolor"; + #endif + break; + case combiner::kSrcPrevious: + regFile[r] = 'r'; regIdx[r] = 0; + #if DEBUG_D3D11_COMPARE_WITH_HLSL + reg[r] = "col"; + #endif + break; + case combiner::kSrcTexture: + regFile[r] = 'r'; regIdx[r] = 1; tmpIdx = 2; + regSrcAlphaSwz[r] = kSM4SwzRepW; + #if DEBUG_D3D11_COMPARE_WITH_HLSL + reg[r] = "tex"; + #endif + break; + case combiner::kSrcConstant: + usedConstant |= true; regFile[r] = 'c'; regIdx[r] = stage; + #if DEBUG_D3D11_COMPARE_WITH_HLSL + reg[r] = std::string("ff_vec_colors[") + char('0'+stage) + ']'; + #endif + break; + default: + AssertString("unknown source"); //reg[r] = "foo"; + } + } + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + const char* writeMask = ""; + #endif + unsigned writeMaskBin = 0xF; // rgba + if (writeMaskMode == kCombWriteRGB) + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + writeMask = ".rgb"; + #endif + writeMaskBin = 0x7; // rgb + } + else if (writeMaskMode == kCombWriteA) + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + writeMask = ".a"; + #endif + writeMaskBin = 0x8; // a + } + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + const char* regSwizzle[3]; + #endif + unsigned regSwizzleBin[3]; + for (int r = 0; r < 3; ++r) + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + regSwizzle[r] = ""; + #endif + regSwizzleBin[r] = kSM4SwzNone; + // 1-x: into tmpN and use that + if (operands[r] == combiner::kOperOneMinusSrcColor || operands[r] == combiner::kOperOneMinusSrcAlpha) + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("tmp")+char('0'+r)+" = 1.0 - " + reg[r]+regSwizzle[r] + ";\n"; + reg[r] = std::string("tmp")+char('0'+r); + #endif + bld.op(kSM4Op_ADD).reg('r', tmpIdx, writeMaskBin).swz(regFile[r], regIdx[r], regSwizzleBin[r], true).float1(1.0f); + regFile[r] = 'r'; + regIdx[r] = tmpIdx; + ++tmpIdx; + } + // replicate alpha swizzle? + if (operands[r] == combiner::kOperSrcAlpha || operands[r] == combiner::kOperOneMinusSrcAlpha) + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + regSwizzle[r] = ".a"; + #endif + regSwizzleBin[r] = kSM4SwzRepW; + } + } + switch (op) + { + case combiner::kOpReplace: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + ";\n"; + #endif + bld.op(kSM4Op_MOV).reg('r', 0, writeMaskBin).swz(regFile[0], regIdx[0], regSwizzleBin[0]); + break; + case combiner::kOpModulate: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + " * " + reg[1]+regSwizzle[1] + ";\n"; + #endif + bld.op(kSM4Op_MUL); + bld.reg('r', 0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1]); + break; + case combiner::kOpAdd: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + " + " + reg[1]+regSwizzle[1] + ";\n"; + #endif + bld.op(kSM4Op_ADD); + bld.reg('r', 0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1]); + break; + case combiner::kOpAddSigned: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + " + " + reg[1]+regSwizzle[1] + " - 0.5;\n"; + #endif + bld.op(kSM4Op_ADD); + bld.reg('r', 0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1]); + bld.op(kSM4Op_ADD); + bld.reg('r', 0, writeMaskBin); + bld.swz('r', 0); + bld.float4(-.5f,-.5f,-.5f,-.5f); + break; + case combiner::kOpSubtract: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + " - " + reg[1]+regSwizzle[1] + ";\n"; + #endif + bld.op(kSM4Op_ADD); + bld.reg('r', 0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1], true); + break; + case combiner::kOpLerp: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = lerp (" + reg[1]+regSwizzle[1] + ", " + reg[0]+regSwizzle[0] + ", " + reg[2]+ ".a);\n"; + #endif + // tmp = r0-r1 + // res = tmp * r2 + r1 + bld.op(kSM4Op_ADD); + bld.reg('r', tmpIdx, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1], true); + bld.op(kSM4Op_MAD); + bld.reg('r', 0, writeMaskBin); + bld.swz('r', tmpIdx); + bld.swz(regFile[2], regIdx[2], regSrcAlphaSwz[2]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1]); + ++tmpIdx; + break; + case combiner::kOpDot3RGB: + DebugAssert(writeMaskMode == kCombWriteRGBA); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col.rgb = 4.0 * dot ((") + reg[0]+regSwizzle[0] + ")-0.5, (" + reg[1]+regSwizzle[1] + ")-0.5);\n"; + code += std::string("col.a = ") + reg[0]+".a;\n"; + #endif + + // tmp+0 = r0-0.5 + bld.op(kSM4Op_ADD); + bld.reg('r', tmpIdx+0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.float4(-.5f,-.5f,-.5f,-.5f); + // tmp+1 = r1-0.5 + bld.op(kSM4Op_ADD); + bld.reg('r', tmpIdx+1, writeMaskBin); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1]); + bld.float4(-.5f,-.5f,-.5f,-.5f); + // tmp0.rgb = dp4(tmp+0, tmp+1) + bld.op(kSM4Op_DP3); + bld.reg('r', 0, 0x7); + bld.swz('r', tmpIdx+0); + bld.swz('r', tmpIdx+1); + // tmp0.rgb *= 4 + bld.op(kSM4Op_MUL); + bld.reg('r', 0, 0x7); + bld.swz('r', 0); + bld.float4(4.0f,4.0f,4.0f,4.0f); + // tmp0.a = r0.a + bld.op(kSM4Op_MOV); + bld.reg('r', 0, 0x8); + bld.swz(regFile[0], regIdx[0], kSM4SwzRepW); + tmpIdx += 2; + break; + case combiner::kOpDot3RGBA: + DebugAssert(writeMaskMode == kCombWriteRGBA); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = 4.0 * dot ((" + reg[0]+regSwizzle[0] + ")-0.5, (" + reg[1]+regSwizzle[1] + ")-0.5);\n"; + #endif + // tmp+0 = r0-0.5 + bld.op(kSM4Op_ADD); + bld.reg('r', tmpIdx+0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.float4(-.5f,-.5f,-.5f,-.5f); + // tmp+1 = r1-0.5 + bld.op(kSM4Op_ADD); + bld.reg('r', tmpIdx+1, writeMaskBin); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1]); + bld.float4(-.5f,-.5f,-.5f,-.5f); + // tmp0 = dp4(tmp+0, tmp+1) + bld.op(kSM4Op_DP3); + bld.reg('r', 0, writeMaskBin); + bld.swz('r', tmpIdx+0); + bld.swz('r', tmpIdx+1); + // tmp0 *= 4 + bld.op(kSM4Op_MUL); + bld.reg('r', 0, writeMaskBin); + bld.swz('r', 0); + bld.float4(4.0f,4.0f,4.0f,4.0f); + tmpIdx += 2; + break; + case combiner::kOpMulAdd: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + " * " + reg[2]+".a + " + reg[1]+regSwizzle[1] + ";\n"; + #endif + bld.op(kSM4Op_MAD); + bld.reg('r', 0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.swz(regFile[2], regIdx[2], regSrcAlphaSwz[2]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1]); + break; + case combiner::kOpMulSub: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + " * " + reg[2]+".a - " + reg[1]+regSwizzle[1] + ";\n"; + #endif + bld.op(kSM4Op_MAD); + bld.reg('r', 0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.swz(regFile[2], regIdx[2], regSrcAlphaSwz[2]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1], true); + break; + case combiner::kOpMulAddSigned: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + " * " + reg[2]+".a + " + reg[1]+regSwizzle[1] + " - 0.5;\n"; + #endif + bld.op(kSM4Op_MAD); + bld.reg('r', 0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.swz(regFile[2], regIdx[2], regSrcAlphaSwz[2]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1]); + bld.op(kSM4Op_ADD); + bld.reg('r', 0, writeMaskBin); + bld.swz('r', 0); + bld.float4(-.5f,-.5f,-.5f,-.5f); + break; + default: + AssertString ("Unknown combiner op!"); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + ";\n"; + #endif + break; + } + + // scale + if (scale > 1) + { + DebugAssert (scale == 2 || scale == 4); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col *= ") + char('0'+scale) + ".0;\n"; + #endif + if (scale == 2) + { + bld.op(kSM4Op_ADD); + bld.reg('r', 0, writeMaskBin); + bld.swz('r', 0); + bld.swz('r', 0); + } + else if (scale == 4) + { + bld.op(kSM4Op_MUL); + bld.reg('r', 0, writeMaskBin); + bld.swz('r', 0); + bld.float4(4.0f,4.0f,4.0f,4.0f); + } + } + + return usedConstant; +} + +void* BuildFragmentShaderD3D11 (const FixedFunctionStateD3D11& state, FixedFunctionProgramD3D11::ValueParameters& params, size_t& outSize) +{ + ShaderLab::FastPropertyName cbName; cbName.SetName(kD3D11PixelCB); + GetD3D11ConstantBuffers(GetRealGfxDevice()).SetCBInfo (cbName.index, k11PixelSize*16); + params.m_CBID = cbName.index; params.m_CBSize = k11PixelSize*16; + + DXBCBuilder* builder = dxb_create(4, 0, kSM4Shader_Pixel); + DXBCBuilderStream bld(builder); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + std::string textures, inputs, code; + #endif + + dxb_dcl_output(builder, "SV_Target", 0, 0); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (inputs, "float4 icolor : COLOR0"); + #endif + int inputRegCounter = 0; + dxb_dcl_input(builder, "COLOR", 0, inputRegCounter++); + + if (state.lightingEnabled && state.specularEnabled) + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (inputs, "float3 ispec : COLOR1"); + #endif + dxb_dcl_input(builder, "COLOR", 1, inputRegCounter++, 0x7); + } + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "float4 col;\n"; + #endif + + if (state.texUnitCount == 0) + { + // No combiners is special case: output primary color + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "col = icolor;\n"; + #endif + bld.op(kSM4Op_MOV).reg('r', 0).swz('v', 0); + + // BUG, using for ex., + // SubShader { Pass { Color (1,0,0,0) } } + // produces white color instead of red on IvyBridge UltraBook + } + else + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "float4 tex, tmp0, tmp1, tmp2;\n"; + #endif + for (int i = 0; i < state.texUnitCount; i++) + { + std::string iname = IntToString(i); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (inputs, ("float4 iuv"+iname + " : TEXCOORD"+iname).c_str()); + textures += "SamplerState ff_smp"+iname + " : register(s"+iname+");\n"; + #endif + + // sample the texture into tmp1 + if (state.texUnit3D & (1<<i)) // 3D + { + dxb_dcl_input(builder, "TEXCOORD", i, inputRegCounter,0x7); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + textures += "Texture3D ff_tex"+iname + " : register(t"+iname+");\n"; + code += "tex = ff_tex"+iname + ".Sample(ff_smp"+iname + ", iuv"+iname + ".xyz);\n"; + #endif + + dxb_dcl_tex(builder, i, kSM4Target_TEXTURE3D); + bld.op(kSM4Op_SAMPLE).reg('r', 1).swz('v', inputRegCounter, kSM4SwzXYZX).swz('t', i).reg('s', i); + } + else if (state.texUnitCube & (1<<i)) // cubemap + { + dxb_dcl_input(builder, "TEXCOORD", i, inputRegCounter,0x7); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + textures += "TextureCube ff_tex"+iname + " : register(t"+iname+");\n"; + code += "tex = ff_tex"+iname + ".Sample(ff_smp"+iname + ", iuv"+iname + ".xyz);\n"; + #endif + + dxb_dcl_tex(builder, i, kSM4Target_TEXTURECUBE); + bld.op(kSM4Op_SAMPLE).reg('r', 1).swz('v', inputRegCounter, kSM4SwzXYZX).swz('t', i).reg('s', i); + } + else if (state.texUnitProjected & (1<<i)) // projected sample + { + dxb_dcl_input(builder, "TEXCOORD", i, inputRegCounter,0xB); // xyw mask + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + textures += "Texture2D ff_tex"+iname + " : register(t"+iname+");\n"; + code += "tex = ff_tex"+iname + ".Sample(ff_smp"+iname + ", iuv"+iname + ".xy / iuv"+iname + ".w);\n"; + #endif + + dxb_dcl_tex(builder, i, kSM4Target_TEXTURE2D); + + // SM4: use DIV; Intel IvyBridge seems to prefer that + bld.noAutoSM2(); + bld.op(kSM4Op_DIV).reg('r', 1, 0x3).swz('v', inputRegCounter, kSM4SwzXYXX).swz('v', inputRegCounter, kSM4SwzRepW); + bld.autoSM2(); + + // SM2: use RCP+MUL + bld.op2(kSM2Op_RCP).reg2('r', 1, 8).swz2('v', inputRegCounter, kSM4SwzRepW); + bld.op2(kSM2Op_MUL).reg2('r', 1, 0x3).swz2('v', inputRegCounter, kSM4SwzXYXX).swz2('r',1, kSM4SwzRepW); + + bld.op(kSM4Op_SAMPLE).reg('r', 1).swz('r', 1, kSM4SwzXYXX).swz('t', i).reg('s', i); + } + else // regular sample + { + dxb_dcl_input(builder, "TEXCOORD", i, inputRegCounter,0x3); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + textures += "Texture2D ff_tex"+iname + " : register(t"+iname+");\n"; + code += "tex = ff_tex"+iname + ".Sample(ff_smp"+iname + ", iuv"+iname + ".xy);\n"; + #endif + + dxb_dcl_tex(builder, i, kSM4Target_TEXTURE2D); + bld.op(kSM4Op_SAMPLE).reg('r', 1).swz('v', inputRegCounter, kSM4SwzXYXX).swz('t', i).reg('s', i); + } + + // emit color & alpha combiners; result in tmp0 + UInt32 colorComb = state.texUnitColorCombiner[i]; + UInt32 alphaComb = state.texUnitAlphaCombiner[i]; + bool usedConstant = false; + if (colorComb == alphaComb) + { + usedConstant |= EmitCombinerMath11 (i, colorComb, kCombWriteRGBA, state.texUnitCount, bld + #if DEBUG_D3D11_COMPARE_WITH_HLSL + , code + #endif + ); + } + else + { + usedConstant |= EmitCombinerMath11 (i, colorComb, kCombWriteRGB, state.texUnitCount, bld + #if DEBUG_D3D11_COMPARE_WITH_HLSL + , code + #endif + ); + usedConstant |= EmitCombinerMath11 (i, alphaComb, kCombWriteA, state.texUnitCount, bld + #if DEBUG_D3D11_COMPARE_WITH_HLSL + , code + #endif + ); + } + + if (usedConstant) + params.AddVectorParam ((k11PixelColors+i)*16, 4, BuiltinShaderVectorParam(kShaderVecFFTextureEnvColor0+i)); + ++inputRegCounter; + } + } + + // alpha test + if (state.alphaTest != kFuncDisabled && state.alphaTest != kFuncAlways) + { + params.AddVectorParam (k11PixelAlphaRef*16, 1, kShaderVecFFAlphaTestRef); + if (state.alphaTest == kFuncNever) + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "discard;\n"; + #endif + bld.op(kSM4Op_DISCARD).float1(-1); // int is not sm20 compatible; old comment: HLSL emits 'l(-1)' for plain discard; with the value being integer -1 (all bits set) + } + else + { + // Reverse logic because we're using here 'discard' + #if DEBUG_D3D11_COMPARE_WITH_HLSL + static const char* kCmpOps[] = + { + "", // kFuncDisabled + "", // kFuncNever + ">=", // kFuncLess + "!=", // kFuncEqual + ">", // kFuncLEqual + "<=", // kFuncGreater + "==", // kFuncNotEqual + "<", // kFuncGEqual + "", // kFuncAlways + }; + #endif // #if DEBUG_D3D11_COMPARE_WITH_HLSL + static SM4Opcode kCmpOpcodes[] = + { + kSM4Op_ADD, // kFuncDisabled + kSM4Op_ADD, // kFuncNever + kSM4Op_GE, // kFuncLess + kSM4Op_NE, // kFuncEqual + kSM4Op_LT, // kFuncLEqual + kSM4Op_GE, // kFuncGreater + kSM4Op_EQ, // kFuncNotEqual + kSM4Op_LT, // kFuncGEqual + kSM4Op_ADD, // kFuncAlways + }; + static bool kCmpOrder[] = + { + false, // kFuncDisabled + false, // kFuncNever + true, // kFuncLess + true, // kFuncEqual + false, // kFuncLEqual + false, // kFuncGreater + true, // kFuncNotEqual + true, // kFuncGEqual + false, // kFuncAlways + }; + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("if (col.a ") + kCmpOps[state.alphaTest] + " ff_alpha_ref) discard;\n"; + #endif + + bld.noAutoSM2(); + bld.op(kCmpOpcodes[state.alphaTest]).reg('r', 1, 0x1); + if (kCmpOrder[state.alphaTest]) + { + bld.swz('r', 0, kSM4SwzRepW); + bld.swz('c', k11PixelAlphaRef, kSM4SwzRepX); + } + else + { + bld.swz('c', k11PixelAlphaRef, kSM4SwzRepX); + bld.swz('r', 0, kSM4SwzRepW); + } + bld.op(kSM4Op_DISCARD).reg('r', 1, 1); + bld.autoSM2(); + + //SM20 + static float bConst[][2] = + { + {0,0}, + {0,0}, + + {0,-1}, + {0,-1}, + {-1,0}, + {0,-1}, + {-1,0}, + {-1,0}, + + {0,0}, + }; + static bool bRefSign[] = + { + false, + false, + + false, + true, + true, + true, + true, + false, + false, + }; + + bld.op2(kSM2Op_ADD). + reg2('r',1,1). + swz2('c',k11PixelAlphaRef, kSM4SwzRepX,bRefSign[state.alphaTest]). + swz2('r', 0, kSM4SwzRepW,!bRefSign[state.alphaTest]); + if (state.alphaTest == kFuncEqual || state.alphaTest == kFuncNotEqual) + bld.op2(kSM2Op_MUL).reg2('r',1,1).swz2('r',1,kSM4SwzRepX).swz2('r',1,kSM4SwzRepX); + bld.op2(kSM2Op_CMP).reg2('r',1). + swz2('r',1,kSM4SwzRepX,state.alphaTest == kFuncEqual || state.alphaTest == kFuncNotEqual). + float1_2(bConst[state.alphaTest][0]). + float1_2(bConst[state.alphaTest][1]); + bld.op2(kSM2Op_TEXKILL).reg2('r', 1); + } + } + + // add specular + if (state.lightingEnabled && state.specularEnabled) + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "col.rgb += ispec;\n"; + #endif + // add r0.xyz, r0.xyz, v1.xyz + bld.op(kSM4Op_ADD).reg('r', 0, 0x7).swz('r', 0, kSM4SwzXYZX).swz('v', 1, kSM4SwzXYZX); + } + + // fog + if (state.fogMode != kFogDisabled && inputRegCounter < 8) + { + int fogVar = inputRegCounter; + dxb_dcl_input(builder, "FOG", 0, fogVar, 0x1); + params.AddVectorParam (k11PixelFog*16, 4, kShaderVecFFFogColor); + // color.rgb = lerp (fogColor.rgb, color.rgb, fogVar) = + // (color.rgb-fogColor.rgb) * fogVar + fogColor.rgb + bld.op(kSM4Op_ADD).reg('r',0,7).swz('r',0,kSM4SwzXYZX).swz('c',k11PixelFog,kSM4SwzXYZX, true); + bld.op(kSM4Op_MAD).reg('r',0,7).swz('r',0,kSM4SwzXYZX).swz('v',fogVar,kSM4SwzRepX).swz('c',k11PixelFog,kSM4SwzXYZX); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (inputs, "float ifog : FOG"); + code += "col.rgb = lerp (ff_fog.rgb, col.rgb, ifog);\n"; + #endif + } + + if (params.HasVectorParams()) + dxb_dcl_cb(builder, 0, k11PixelSize); + + // mov o0.xyzw, r0.xyzw + bld.op(kSM4Op_MOV).reg('o', 0).swz('r', 0); + // ret + bld.op(kSM4Op_RET); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "return col;\n"; + std::string src = textures + kD3D11PixelPrefix + inputs + ") : SV_TARGET {\n" + code + "\n}"; + printf_console ("d3d11 FF PS HLSL:\n%s\n", src.c_str()); + DebugCompileHLSLShaderD3D11 (src, false); + #endif + + void* blob = BuildShaderD3D11 (builder, outSize); + return blob; +} diff --git a/Runtime/GfxDevice/d3d11/ShaderGeneratorD3D11.h b/Runtime/GfxDevice/d3d11/ShaderGeneratorD3D11.h new file mode 100644 index 0000000..6316275 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/ShaderGeneratorD3D11.h @@ -0,0 +1,10 @@ +#pragma once + +#include "D3D11Includes.h" +#include "GpuProgramsD3D11.h" + + +struct FixedFunctionStateD3D11; + +void* BuildVertexShaderD3D11 (const FixedFunctionStateD3D11& state, FixedFunctionProgramD3D11::ValueParameters& params, BuiltinShaderParamIndices& matrices, size_t& outSize); +void* BuildFragmentShaderD3D11 (const FixedFunctionStateD3D11& state, FixedFunctionProgramD3D11::ValueParameters& params, size_t& outSize); diff --git a/Runtime/GfxDevice/d3d11/ShaderGeneratorLinkD3D11.cpp b/Runtime/GfxDevice/d3d11/ShaderGeneratorLinkD3D11.cpp new file mode 100644 index 0000000..eb64cfd --- /dev/null +++ b/Runtime/GfxDevice/d3d11/ShaderGeneratorLinkD3D11.cpp @@ -0,0 +1,985 @@ +#include "UnityPrefix.h" + +#if UNITY_METRO_VS2013 || (UNITY_WIN && !UNITY_WINRT) + +#include "ShaderGeneratorD3D11.h" +#include "FixedFunctionStateD3D11.h" +#include "ConstantBuffersD3D11.h" +#include "Runtime/GfxDevice/GpuProgram.h" +#include "External/shaderlab/Library/TextureBinding.h" +#include "Runtime/GfxDevice/GfxDevice.h" +#include "PlatformDependent/Win/SmartComPointer.h" +#include "Runtime/Utilities/File.h" + +#include "Runtime/GfxDevice/d3d11/InternalShaders/FFShaderLib.h" + +#if UNITY_WINRT +#include <D3DCompiler.h> +#endif + +ConstantBuffersD3D11& GetD3D11ConstantBuffers (GfxDevice& device); + + +typedef SmartComPointer<ID3D11LinkingNode> NodePtr; +typedef SmartComPointer<ID3D11ModuleInstance> ModuleInstancePtr; +typedef SmartComPointer<ID3D11Module> ModulePtr; +typedef SmartComPointer<ID3D11Linker> LinkerPtr; +typedef SmartComPointer<ID3D11FunctionLinkingGraph> FLGPtr; +typedef SmartComPointer<ID3DBlob> BlobPtr; + +const int kMaxSignatureParams = 12; +const int kSamplingModuleCount = 32; + + +struct D3D11ShaderLinker +{ + D3D11ShaderLinker() + : createLinkerFunc(0) + , loadModuleFunc(0) + , createFunctionLinkingGraphFunc(0) + , m_Dll(0) + , m_Initialized(false) + , m_Valid(false) + { + } + + ~D3D11ShaderLinker() + { + m_Module.Release(); + m_ModuleInstanceVS.Release(); + m_ModuleInstancePS.Release(); + + for (int i = 0; i < kSamplingModuleCount; ++i) + { + m_SamplingModules[i].Release(); + m_SamplingModuleInstances[i].Release(); + } + + if (m_Dll) + FreeLibrary(m_Dll); + } + + void Initialize ( + const char* dllName, + const BYTE* shaderLibraryCode, size_t shaderLibrarySize, + const BYTE** samplingLibraryCodes, const size_t* samplingLibrarySizes); + + typedef HRESULT (WINAPI *D3DCreateLinkerFunc)(ID3D11Linker **ppLinker); + typedef HRESULT (WINAPI *D3DLoadModuleFunc)( + const void* srcData, + SIZE_T srcDataSize, + ID3D11Module** ppModule); + typedef HRESULT (WINAPI *D3DCreateFunctionLinkingGraphFunc)( + UINT uFlags, + ID3D11FunctionLinkingGraph **ppFunctionLinkingGraph); + + D3DCreateLinkerFunc createLinkerFunc; + D3DLoadModuleFunc loadModuleFunc; + D3DCreateFunctionLinkingGraphFunc createFunctionLinkingGraphFunc; + + HMODULE m_Dll; + bool m_Initialized; + bool m_Valid; + + ModulePtr m_Module; + ModuleInstancePtr m_ModuleInstanceVS, m_ModuleInstancePS; + + ModulePtr m_SamplingModules[kSamplingModuleCount]; + ModuleInstancePtr m_SamplingModuleInstances[kSamplingModuleCount]; +}; + +static D3D11ShaderLinker s_Linker; + +void D3D11ShaderLinker::Initialize ( + const char* dllName, + const BYTE* shaderLibraryCode, size_t shaderLibrarySize, + const BYTE** samplingLibraryCodes, const size_t* samplingLibrarySizes) +{ + if (m_Initialized) + return; + + m_Valid = false; + m_Initialized = true; + + // Load DLL + #if UNITY_WINRT + // We use a proper linked library on Metro Blue + //m_Dll = LoadPackagedLibrary (ConvertToWindowsPath(dllName)->Data(), 0); + #else + m_Dll = LoadLibraryA (dllName); + if (!m_Dll) + return; + #endif + + // Get functions +#if UNITY_WINRT + createLinkerFunc = (D3DCreateLinkerFunc)&D3DCreateLinker; + loadModuleFunc = (D3DLoadModuleFunc)&D3DLoadModule; + createFunctionLinkingGraphFunc = (D3DCreateFunctionLinkingGraphFunc)&D3DCreateFunctionLinkingGraph; +#else + createLinkerFunc = (D3DCreateLinkerFunc) GetProcAddress (m_Dll, "D3DCreateLinker"); + loadModuleFunc = (D3DLoadModuleFunc) GetProcAddress (m_Dll, "D3DLoadModule"); + createFunctionLinkingGraphFunc = (D3DCreateFunctionLinkingGraphFunc) GetProcAddress (m_Dll, "D3DCreateFunctionLinkingGraph"); +#endif + + if (createLinkerFunc == 0 || loadModuleFunc == 0 || createFunctionLinkingGraphFunc == 0) + return; + + HRESULT hr = loadModuleFunc(shaderLibraryCode, shaderLibrarySize, &m_Module); + if (FAILED(hr)) + { + printf("DX11: Failed to load compiled library: 0x%x\n", hr); + return; + } + + // Setup HLSL linker + hr = m_Module->CreateInstance ("", &m_ModuleInstanceVS); + if (FAILED(hr)) + { + printf("DX11: Failed to create compiled library instance: 0x%x\n", hr); + return; + } + hr = m_ModuleInstanceVS->BindConstantBufferByName("UnityFFVertex",0,0); + + hr = m_Module->CreateInstance ("", &m_ModuleInstancePS); + if (FAILED(hr)) + { + printf("DX11: Failed to create compiled library instance: 0x%x\n", hr); + return; + } + hr = m_ModuleInstancePS->BindConstantBufferByName("UnityFFPixel",0,0); + + + // Setup sampling modules + for (int i = 0; i < kSamplingModuleCount; ++i) + { + hr = loadModuleFunc(samplingLibraryCodes[i], samplingLibrarySizes[i], &m_SamplingModules[i]); + AssertIf(FAILED(hr)); + hr = m_SamplingModules[i]->CreateInstance ("", &m_SamplingModuleInstances[i]); + AssertIf(FAILED(hr)); + + int unit = i % 8; + hr = m_SamplingModuleInstances[i]->BindResource(unit, unit, 1); + hr = m_SamplingModuleInstances[i]->BindSampler(unit, unit, 1); + } + + m_Valid = true; +} + +bool HasD3D11Linker() +{ + const char* dllName = "D3DCompiler_47.dll"; + s_Linker.Initialize(dllName, g_FFShaderLibrary, sizeof(g_FFShaderLibrary), g_FFSampleTexLib, g_FFSampleTexLibSize); + return s_Linker.m_Valid; +} + + +// --- Constant buffers & utilities -------------------------------------------------------------- + + +static const char* kD3D11VertexCB = "UnityFFVertex"; +static const char* kD3D11PixelCB = "UnityFFPixel"; + +enum { + k11VertexMVP = 0, + k11VertexMV = 4, + k11VertexColor = 8, + k11VertexAmbient = 9, + k11VertexLightColor = 10, + k11VertexLightPos = 18, + k11VertexLightAtten = 26, + k11VertexLightSpot = 34, + k11VertexMatDiffuse = 42, + k11VertexMatAmbient = 43, + k11VertexMatSpec = 44, + k11VertexMatEmission = 45, + k11VertexTex = 46, + k11VertexFog = 62, + k11VertexSize = 63, +}; +enum { + k11PixelColors = 0, + k11PixelAlphaRef = 8, + k11PixelFog = 9, + k11PixelSize = 10 +}; + + +// --- VERTEX program ---------------------------------------------------------------------------- + + +static D3D11_PARAMETER_DESC CreateParamDesc(const char* name, const char* sem, int dim) +{ + D3D11_PARAMETER_DESC desc = { + name, + sem, + D3D_SVT_FLOAT, + dim == 1 ? D3D_SVC_SCALAR : D3D_SVC_VECTOR, + 1, + dim, + D3D_INTERPOLATION_UNDEFINED, + D3D_PF_NONE, + 0, 0, 0, 0 + }; + return desc; +} + + +void* BuildVertexShaderD3D11_Link (const FixedFunctionStateD3D11& state, FixedFunctionProgramD3D11::ValueParameters& params, BuiltinShaderParamIndices& matrices, size_t& outSize) +{ + ShaderLab::FastPropertyName cbName; cbName.SetName(kD3D11VertexCB); + GetD3D11ConstantBuffers(GetRealGfxDevice()).SetCBInfo (cbName.index, k11VertexSize*16); + params.m_CBID = cbName.index; params.m_CBSize = k11VertexSize*16; + + HRESULT hr = S_OK; + const bool hasLinker = HasD3D11Linker(); + Assert(hasLinker); + FLGPtr flg; + s_Linker.createFunctionLinkingGraphFunc (0, &flg); + D3D11_PARAMETER_DESC inputSig[kMaxSignatureParams]; + D3D11_PARAMETER_DESC outputSig[kMaxSignatureParams]; + + bool hasLights = (state.lightingEnabled && state.lightCount > 0); + + bool eyePositionRequired = + hasLights || + (state.fogMode != kFogDisabled); + bool eyeNormalRequired = hasLights; + bool viewDirRequired = hasLights && state.specularEnabled; + bool eyeReflRequired = false; + { + UInt64 texSources = state.texUnitSources; + for (int i = 0; i < state.texUnitCount; i++) + { + UInt32 uvSource = texSources & 0xF; + if (uvSource == kTexSourceEyeLinear) + eyePositionRequired = true; + if (uvSource == kTexSourceCubeNormal) + eyeNormalRequired = true; + if (uvSource == kTexSourceCubeReflect || uvSource == kTexSourceSphereMap) + eyeReflRequired = viewDirRequired = eyePositionRequired = eyeNormalRequired = true; + texSources >>= 4; + } + } + if (eyePositionRequired || eyeNormalRequired || eyeReflRequired) + { + matrices.mat[kShaderInstanceMatMV].gpuIndex = k11VertexMV*16; + matrices.mat[kShaderInstanceMatMV].rows = 4; + matrices.mat[kShaderInstanceMatMV].cols = 4; + matrices.mat[kShaderInstanceMatMV].cbID = params.m_CBID; + } + + int inputRegCounter = 0, outputRegCounter = 0; + int inPosReg = 0, inColorReg = 0, inNormalReg = 0; + int inUVReg[8] = {0}; + int outColor0Reg = 0, outColor1Reg = 0, outPosReg = 0; + int outUVReg[8] = {0}; + int outFogReg = -1; + + + // ---- Figure out input signature ---------------------------------------- + + // Position + inputSig[inPosReg = inputRegCounter++] = CreateParamDesc("vertex", "POSITION", 4); + // Vertex color + if (!state.useUniformInsteadOfVertexColor) + inputSig[inColorReg = inputRegCounter++] = CreateParamDesc("vertexColor", "COLOR", 4); + // Normal + if (eyeNormalRequired) + inputSig[inNormalReg = inputRegCounter++] = CreateParamDesc("normal", "NORMAL", 3); + // UVs + UInt32 gotInputs = 0; + static const char* kUVNames[kMaxSupportedTextureCoords] = {"uv0","uv1","uv2","uv3","uv4","uv5","uv6","uv7"}; + static const char* kUVOutNames[kMaxSupportedTextureCoords] = {"ouv0","ouv1","ouv2","ouv3","ouv4","ouv5","ouv6","ouv7"}; + static const char* kUVSemantics[kMaxSupportedTextureCoords] = {"TEXCOORD0","TEXCOORD1","TEXCOORD2","TEXCOORD3","TEXCOORD4","TEXCOORD5","TEXCOORD6","TEXCOORD7"}; + UInt64 texSources = state.texUnitSources; + for (int i = 0; i < state.texUnitCount; i++) + { + UInt32 uvSource = texSources & 0xF; + if (uvSource >= kTexSourceUV0 && uvSource <= kTexSourceUV7) + { + unsigned uv = uvSource-kTexSourceUV0; + if (!(gotInputs & (1<<uv))) + { + inputSig[inUVReg[uv] = inputRegCounter++] = CreateParamDesc(kUVNames[uv], kUVSemantics[uv], 4); + gotInputs |= (1<<uv); + } + } + texSources >>= 4; + } + + NodePtr inputNode; + Assert(inputRegCounter <= kMaxSignatureParams); + hr = flg->SetInputSignature(inputSig, inputRegCounter, &inputNode); + + + // ---- Figure out output signature --------------------------------------- + + // color + outputSig[outColor0Reg = outputRegCounter++] = CreateParamDesc("ocolor", "COLOR0", 4); + // spec color + if (state.lightingEnabled && state.specularEnabled) + outputSig[outColor1Reg = outputRegCounter++] = CreateParamDesc("ospec", "COLOR1", 3); + // UVs + for (int i = 0; i < state.texUnitCount; i++) + outputSig[outUVReg[i] = outputRegCounter++] = CreateParamDesc(kUVOutNames[i], kUVSemantics[i], 4); + // Fog + if (state.fogMode != kFogDisabled && outputRegCounter < 8) + outputSig[outFogReg = outputRegCounter++] = CreateParamDesc("ofog", "FOG0", 1); + // position + outputSig[outPosReg = outputRegCounter++] = CreateParamDesc("overtex", "SV_POSITION", 4); + + // ---- Build code -------------------------------------------------------- + + + NodePtr colorNode, eyePosNode, eyeNormalNode, viewDirNode, eyeReflNode; + NodePtr ambientNode, diffuseNode, emissionNode; + NodePtr ambientNodeToUse, diffuseNodeToUse, emissionNodeToUse; + NodePtr lightNode, specNode, fogNode; + + // color = Vertex or uniform color + if (state.useUniformInsteadOfVertexColor) + { + params.AddVectorParam (k11VertexColor*16, 4, kShaderVecFFColor); + hr = flg->CallFunction("", s_Linker.m_Module, "LoadVertexColorUniform", &colorNode); + } + else + { + hr = flg->CallFunction("", s_Linker.m_Module, "LoadVertexColor", &colorNode); + hr = flg->PassValue(inputNode, inColorReg, colorNode, 0); + } + + // eyePos = eye position + if (eyePositionRequired) + { + hr = flg->CallFunction("", s_Linker.m_Module, "LoadEyePos", &eyePosNode); + hr = flg->PassValue(inputNode, inPosReg, eyePosNode, 0); + } + + // eyeNormal = normalize(normalMatrix * normal) + if (eyeNormalRequired) + { + hr = flg->CallFunction("", s_Linker.m_Module, "LoadEyeNormal", &eyeNormalNode); + hr = flg->PassValue(inputNode, inNormalReg, eyeNormalNode, 0); + } + + // view dir + if (viewDirRequired) + { + Assert(eyePosNode); + hr = flg->CallFunction("", s_Linker.m_Module, "LoadViewDir", &viewDirNode); + hr = flg->PassValue(eyePosNode, D3D_RETURN_PARAMETER_INDEX, viewDirNode, 0); + } + else + { + hr = flg->CallFunction("", s_Linker.m_Module, "LoadZero", &viewDirNode); + } + + // eyeRefl + if (eyeReflRequired) + { + DebugAssert (viewDirRequired); + // eyeRefl = reflection vector, 2*dot(V,N)*N-V + Assert(eyeNormalNode); + Assert(viewDirNode); + hr = flg->CallFunction("", s_Linker.m_Module, "LoadEyeRefl", &eyeReflNode); + hr = flg->PassValue(viewDirNode, D3D_RETURN_PARAMETER_INDEX, eyeReflNode, 0); + hr = flg->PassValue(eyeNormalNode, D3D_RETURN_PARAMETER_INDEX, eyeReflNode, 1); + } + + // Lighting + if (state.lightingEnabled) + { + if (state.colorMaterial==kColorMatAmbientAndDiffuse) + { + ambientNodeToUse = colorNode; + diffuseNodeToUse = colorNode; + } + else + { + hr = flg->CallFunction("", s_Linker.m_Module, "LoadAmbientColor", &ambientNode); + ambientNodeToUse = ambientNode; + hr = flg->CallFunction("", s_Linker.m_Module, "LoadDiffuseColor", &diffuseNode); + diffuseNodeToUse = diffuseNode; + } + if (state.colorMaterial==kColorMatEmission) + { + emissionNodeToUse = colorNode; + } + else + { + hr = flg->CallFunction("", s_Linker.m_Module, "LoadEmissionColor", &emissionNode); + emissionNodeToUse = emissionNode; + } + + params.AddVectorParam (k11VertexAmbient*16, 4, kShaderVecLightModelAmbient); + params.AddVectorParam (k11VertexMatAmbient*16, 4, kShaderVecFFMatAmbient); + params.AddVectorParam (k11VertexMatDiffuse*16, 4, kShaderVecFFMatDiffuse); + params.AddVectorParam (k11VertexMatSpec*16, 4, kShaderVecFFMatSpecular); + params.AddVectorParam (k11VertexMatEmission*16, 4, kShaderVecFFMatEmission); + + Assert(emissionNodeToUse); + Assert(ambientNodeToUse); + hr = flg->CallFunction("", s_Linker.m_Module, "InitLightColor", &lightNode); + hr = flg->PassValue(emissionNodeToUse, D3D_RETURN_PARAMETER_INDEX, lightNode, 0); + hr = flg->PassValue(ambientNodeToUse, D3D_RETURN_PARAMETER_INDEX, lightNode, 1); + hr = flg->CallFunction("", s_Linker.m_Module, "LoadZero", &specNode); + if (state.lightCount > 0) + { + NodePtr lightCallNode; + std::string lightFuncName = state.specularEnabled ? "ComputeSpotLightSpec" : "ComputeSpotLight"; + lightFuncName += ('0' + state.lightCount); + hr = flg->CallFunction("", s_Linker.m_Module, lightFuncName.c_str(), &lightCallNode); + hr = flg->PassValue(eyePosNode, D3D_RETURN_PARAMETER_INDEX, lightCallNode, 0); + hr = flg->PassValue(eyeNormalNode, D3D_RETURN_PARAMETER_INDEX, lightCallNode, 1); + hr = flg->PassValue(viewDirNode, D3D_RETURN_PARAMETER_INDEX, lightCallNode, 2); + hr = flg->PassValue(diffuseNodeToUse, D3D_RETURN_PARAMETER_INDEX, lightCallNode, 3); + hr = flg->PassValue(specNode, D3D_RETURN_PARAMETER_INDEX, lightCallNode, 4); + hr = flg->PassValue(lightNode, D3D_RETURN_PARAMETER_INDEX, lightCallNode, 5); + + NodePtr specMoveNode; + hr = flg->CallFunction("", s_Linker.m_Module, "Load3", &specMoveNode); + hr = flg->PassValue(lightCallNode, 4, specMoveNode, 0); + specNode = specMoveNode; + + lightNode = lightCallNode; + } + + for (int i = 0; i < state.lightCount; ++i) + { + params.AddVectorParam ((k11VertexLightPos+i)*16, 4, BuiltinShaderVectorParam(kShaderVecLight0Position+i)); + params.AddVectorParam ((k11VertexLightAtten+i)*16, 4, BuiltinShaderVectorParam(kShaderVecLight0Atten+i)); + params.AddVectorParam ((k11VertexLightColor+i)*16, 4, BuiltinShaderVectorParam(kShaderVecLight0Diffuse+i)); + params.AddVectorParam ((k11VertexLightSpot+i)*16, 4, BuiltinShaderVectorParam(kShaderVecLight0SpotDirection+i)); + } + + NodePtr finalLightColor; + hr = flg->CallFunction("", s_Linker.m_Module, "LoadLightingColor", &finalLightColor); + hr = flg->PassValue(lightNode, D3D_RETURN_PARAMETER_INDEX, finalLightColor, 0); + hr = flg->PassValue(diffuseNodeToUse, D3D_RETURN_PARAMETER_INDEX, finalLightColor, 1); + colorNode = finalLightColor; + + if (state.specularEnabled) + { + NodePtr finalSpecColor; + hr = flg->CallFunction("", s_Linker.m_Module, "ModulateSpec", &finalSpecColor); + hr = flg->PassValue(specNode, D3D_RETURN_PARAMETER_INDEX, finalSpecColor, 0); + specNode = finalSpecColor; + } + } + + // Output final color + NodePtr saturatedColorNode; + NodePtr saturatedSpecNode; + hr = flg->CallFunction("", s_Linker.m_Module, "Saturate4", &saturatedColorNode); + hr = flg->PassValue(colorNode, D3D_RETURN_PARAMETER_INDEX, saturatedColorNode, 0); + + if (state.lightingEnabled && state.specularEnabled) + { + Assert(specNode); + hr = flg->CallFunction("", s_Linker.m_Module, "Saturate3", &saturatedSpecNode); + hr = flg->PassValue(specNode, D3D_RETURN_PARAMETER_INDEX, saturatedSpecNode, 0); + } + + // Pass & transform texture coordinates + NodePtr texNodes[kMaxSupportedTextureCoords] = {0}; + + texSources = state.texUnitSources; + for (int i = 0; i < state.texUnitCount; i++) + { + matrices.mat[kShaderInstanceMatTexture0+i].gpuIndex = (k11VertexTex+i*4)*16; + matrices.mat[kShaderInstanceMatTexture0+i].rows = 4; + matrices.mat[kShaderInstanceMatTexture0+i].cols = 4; + matrices.mat[kShaderInstanceMatTexture0+i].cbID = params.m_CBID; + + std::string iname = IntToString(i); + std::string texFuncName = "MultiplyUV"; + texFuncName += iname; + + UInt32 uvSource = texSources & 0xF; + if (uvSource >= kTexSourceUV0 && uvSource <= kTexSourceUV7) + { + unsigned uv = uvSource-kTexSourceUV0; + hr = flg->CallFunction("", s_Linker.m_Module, texFuncName.c_str(), &texNodes[i]); + hr = flg->PassValue(inputNode, inUVReg[uv], texNodes[i], 0); + } + else if (uvSource == kTexSourceSphereMap) + { + // m = 2*sqrt(Rx*Rx + Ry*Ry + (Rz+1)*(Rz+1)) + // SPHR = Rx/m + 0.5, Ry/m + 0.5 + NodePtr texGenNode; + hr = flg->CallFunction("", s_Linker.m_Module, "UVSphereMap", &texGenNode); + hr = flg->PassValue(eyeReflNode, D3D_RETURN_PARAMETER_INDEX, texGenNode, 0); + hr = flg->CallFunction("", s_Linker.m_Module, texFuncName.c_str(), &texNodes[i]); + hr = flg->PassValue(texGenNode, D3D_RETURN_PARAMETER_INDEX, texNodes[i], 0); + } + else if (uvSource == kTexSourceObject) + { + NodePtr texGenNode; + hr = flg->CallFunction("", s_Linker.m_Module, texFuncName.c_str(), &texNodes[i]); + hr = flg->PassValue(inputNode, inPosReg, texNodes[i], 0); + } + else if (uvSource == kTexSourceEyeLinear) + { + NodePtr texGenNode; + hr = flg->CallFunction("", s_Linker.m_Module, "Float3to4", &texGenNode); + hr = flg->PassValue(eyePosNode, D3D_RETURN_PARAMETER_INDEX, texGenNode, 0); + hr = flg->CallFunction("", s_Linker.m_Module, texFuncName.c_str(), &texNodes[i]); + hr = flg->PassValue(texGenNode, D3D_RETURN_PARAMETER_INDEX, texNodes[i], 0); + } + else if (uvSource == kTexSourceCubeNormal) + { + NodePtr texGenNode; + hr = flg->CallFunction("", s_Linker.m_Module, "Float3to4", &texGenNode); + hr = flg->PassValue(eyeNormalNode, D3D_RETURN_PARAMETER_INDEX, texGenNode, 0); + hr = flg->CallFunction("", s_Linker.m_Module, texFuncName.c_str(), &texNodes[i]); + hr = flg->PassValue(texGenNode, D3D_RETURN_PARAMETER_INDEX, texNodes[i], 0); + } + else if (uvSource == kTexSourceCubeReflect) + { + NodePtr texGenNode; + hr = flg->CallFunction("", s_Linker.m_Module, "Float3to4", &texGenNode); + hr = flg->PassValue(eyeReflNode, D3D_RETURN_PARAMETER_INDEX, texGenNode, 0); + hr = flg->CallFunction("", s_Linker.m_Module, texFuncName.c_str(), &texNodes[i]); + hr = flg->PassValue(texGenNode, D3D_RETURN_PARAMETER_INDEX, texNodes[i], 0); + } + else + { + AssertString("Unknown texgen mode"); + } + texSources >>= 4; + } + + // fog if we have a spare varying + if (state.fogMode != kFogDisabled && outFogReg != -1) + { + Assert(eyePositionRequired); + + params.AddVectorParam (k11VertexFog*16, 4, kShaderVecFFFogParams); + + static const char* kFogFunction[] = + { + "", // kFogDisabled + "FogLinear", // kFogLinear + "FogExp", // kFogExp + "FogExp2" // kFogExp2 + }; + + hr = flg->CallFunction("", s_Linker.m_Module, kFogFunction[state.fogMode], &fogNode); + hr = flg->PassValue(eyePosNode, D3D_RETURN_PARAMETER_INDEX, fogNode, 0); + } + + // Vertex transformation + matrices.mat[kShaderInstanceMatMVP].gpuIndex = k11VertexMVP*16; + matrices.mat[kShaderInstanceMatMVP].rows = 4; + matrices.mat[kShaderInstanceMatMVP].cols = 4; + matrices.mat[kShaderInstanceMatMVP].cbID = params.m_CBID; + NodePtr vertexNode; + hr = flg->CallFunction("", s_Linker.m_Module, "TransformVertex", &vertexNode); + hr = flg->PassValue(inputNode, inPosReg, vertexNode, 0); + + + NodePtr outputNode; + Assert(outputRegCounter <= kMaxSignatureParams); + hr = flg->SetOutputSignature(outputSig, outputRegCounter, &outputNode); + + hr = flg->PassValue(vertexNode, D3D_RETURN_PARAMETER_INDEX, outputNode, outPosReg); + hr = flg->PassValue(saturatedColorNode, D3D_RETURN_PARAMETER_INDEX, outputNode, outColor0Reg); + if (saturatedSpecNode) + hr = flg->PassValue(saturatedSpecNode, D3D_RETURN_PARAMETER_INDEX, outputNode, outColor1Reg); + for (int i = 0; i < state.texUnitCount; i++) + { + if (texNodes[i]) + hr = flg->PassValue(texNodes[i], D3D_RETURN_PARAMETER_INDEX, outputNode, outUVReg[i]); + } + if (state.fogMode != kFogDisabled && outFogReg != -1) + { + hr = flg->PassValue(fogNode, D3D_RETURN_PARAMETER_INDEX, outputNode, outFogReg); + } + + #if 0 + // Print generated hlsl for debugging + BlobPtr hlslOutput; + hr = flg->GenerateHlsl(0, &hlslOutput); + if (SUCCEEDED(hr)) + { + printf_console("DX11 debug linked VS:\n%s\n", hlslOutput->GetBufferPointer()); + } + #endif + + + ModuleInstancePtr flgModule; + BlobPtr flgErrors; + hr = flg->CreateModuleInstance(&flgModule, &flgErrors); + if (FAILED(hr)) + { + const char* errorMsg = (const char*)flgErrors->GetBufferPointer(); + printf_console("DX11: Failed to create FF VS module: %s\n", errorMsg); + } + + LinkerPtr linker; + hr = s_Linker.createLinkerFunc(&linker); + hr = linker->UseLibrary (s_Linker.m_ModuleInstanceVS); + + + #if UNITY_WINRT + const char* target = "vs_4_0_level_9_1"; + #else + const char* target = "vs_4_0"; + #endif + + BlobPtr linkedCode; + BlobPtr linkedErrors; + hr = linker->Link(flgModule, "main", target, 0, &linkedCode, &linkedErrors); + if (FAILED(hr)) + { + const char* errorMsg = (const char*)linkedErrors->GetBufferPointer(); + printf_console("\nDX11: Failed to link FF VS: %s\n", errorMsg); + } + + if (!linkedCode) + { + outSize = 0; + return NULL; + } + outSize = linkedCode->GetBufferSize(); + void* finalCode = malloc(outSize); + memcpy (finalCode, linkedCode->GetBufferPointer(), outSize); + return finalCode; +} + + + +// --- FRAGMENT program ---------------------------------------------------------------------------- + + +enum CombinerWriteMask { kCombWriteRGBA, kCombWriteRGB, kCombWriteA }; +static const char* k11LinkCombOpNames[combiner::kCombinerOpCount] = { + "CombReplace", "CombModulate", "CombAdd", "CombAddSigned", "CombSubtract", "CombLerp", "CombDot3", "CombDot3rgba", "CombMulAdd", "CombMulSub", "CombMulAddSigned" +}; +static int k11LinkCompOpArgs[combiner::kCombinerOpCount] = { + 1, 2, 2, 2, 2, 3, 2, 2, 3, 3, 3 +}; + +static bool EmitCombinerMath11Link ( + int stage, + UInt32 combiner, + CombinerWriteMask writeMaskMode, + int texUnitCount, + FLGPtr& flg, + NodePtr& inputNode, NodePtr& prevNode, NodePtr& texNode, + NodePtr& outNewNode) +{ + Assert (texUnitCount < 10 && stage < 10); + + HRESULT hr = S_OK; + + combiner::Source sources[3]; + combiner::Operand operands[3]; + combiner::Operation op; + int scale; + combiner::DecodeTextureCombinerDescriptor (combiner, op, sources, operands, scale, true); + + // dot3 and dot3rgba write into RGBA; alpha combiner is always ignored + if (op == combiner::kOpDot3RGB || op == combiner::kOpDot3RGBA) + { + if (writeMaskMode == kCombWriteA) + { + outNewNode.Release(); + return false; + } + writeMaskMode = kCombWriteRGBA; + } + + bool usedConstant = false; + NodePtr reg[3]; + int regIndex[3] = {D3D_RETURN_PARAMETER_INDEX, D3D_RETURN_PARAMETER_INDEX, D3D_RETURN_PARAMETER_INDEX}; + for (int r = 0; r < 3; ++r) + { + combiner::Source source = sources[r]; + if (stage == 0 && source == combiner::kSrcPrevious) + source = combiner::kSrcPrimaryColor; // first stage, "previous" the same as "primary" + switch (source) + { + case combiner::kSrcPrimaryColor: + reg[r] = inputNode; + regIndex[r] = 0; + break; + case combiner::kSrcPrevious: + reg[r] = prevNode; + break; + case combiner::kSrcTexture: + reg[r] = texNode; + break; + case combiner::kSrcConstant: + usedConstant |= true; + { + std::string funcName = "LoadConstantColor"; + funcName += ('0'+stage); + hr = flg->CallFunction("", s_Linker.m_Module, funcName.c_str(), ®[r]); + } + break; + default: + AssertString("unknown source"); //reg[r] = "foo"; + } + } + + const char* regSwizzle[3]; + for (int r = 0; r < 3; ++r) + { + regSwizzle[r] = "rgba"; + // 1-x: into tmpN and use that + if (operands[r] == combiner::kOperOneMinusSrcColor || operands[r] == combiner::kOperOneMinusSrcAlpha) + { + NodePtr tmpNode; + hr = flg->CallFunction("", s_Linker.m_Module, "OneMinus4", &tmpNode); + hr = flg->PassValue(reg[r], regIndex[r], tmpNode, 0); + reg[r] = tmpNode; + regIndex[r] = D3D_RETURN_PARAMETER_INDEX; + } + // replicate alpha swizzle? + if (operands[r] == combiner::kOperSrcAlpha || operands[r] == combiner::kOperOneMinusSrcAlpha) + { + regSwizzle[r] = "aaaa"; + } + } + + // combiner op + NodePtr opNode; + hr = flg->CallFunction("", s_Linker.m_Module, k11LinkCombOpNames[op], &opNode); + for (int i = 0; i < k11LinkCompOpArgs[op]; ++i) + hr = flg->PassValueWithSwizzle(reg[i], regIndex[i], regSwizzle[i], opNode, i, "rgba"); + + // scale + if (scale > 1) + { + DebugAssert (scale == 2 || scale == 4); + NodePtr scaleNode; + hr = flg->CallFunction("", s_Linker.m_Module, scale == 2 ? "Scale2" : "Scale4", &scaleNode); + hr = flg->PassValue(opNode, D3D_RETURN_PARAMETER_INDEX, scaleNode, 0); + opNode = scaleNode; + } + + outNewNode = opNode; + return usedConstant; +} + + +void* BuildFragmentShaderD3D11_Link (const FixedFunctionStateD3D11& state, FixedFunctionProgramD3D11::ValueParameters& params, size_t& outSize) +{ + ShaderLab::FastPropertyName cbName; cbName.SetName(kD3D11PixelCB); + GetD3D11ConstantBuffers(GetRealGfxDevice()).SetCBInfo (cbName.index, k11PixelSize*16); + params.m_CBID = cbName.index; params.m_CBSize = k11PixelSize*16; + + HRESULT hr = S_OK; + const bool hasLinker = HasD3D11Linker(); + Assert(hasLinker); + + FLGPtr flg; + s_Linker.createFunctionLinkingGraphFunc (0, &flg); + + LinkerPtr linker; + hr = s_Linker.createLinkerFunc(&linker); + + // ---- Figure out input signature ---------------------------------------- + + D3D11_PARAMETER_DESC inputSig[kMaxSignatureParams]; + int inputRegCounter = 0; + int inColorReg = 0, inSpecReg = 0, inFogReg = 0; + int inUVReg[kMaxSupportedTextureCoords] = {0}; + static const char* kUVNames[kMaxSupportedTextureCoords] = {"uv0","uv1","uv2","uv3","uv4","uv5","uv6","uv7"}; + static const char* kUVSemantics[kMaxSupportedTextureCoords] = {"TEXCOORD0","TEXCOORD1","TEXCOORD2","TEXCOORD3","TEXCOORD4","TEXCOORD5","TEXCOORD6","TEXCOORD7"}; + + inputSig[inColorReg = inputRegCounter++] = CreateParamDesc("icolor", "COLOR0", 4); + if (state.lightingEnabled && state.specularEnabled) + inputSig[inSpecReg = inputRegCounter++] = CreateParamDesc("ispec", "COLOR1", 3); + for (int i = 0; i < state.texUnitCount; i++) + inputSig[inUVReg[i] = inputRegCounter++] = CreateParamDesc(kUVNames[i], kUVSemantics[i], 4); + if (state.fogMode != kFogDisabled && inputRegCounter < 8) + inputSig[inFogReg = inputRegCounter++] = CreateParamDesc("ifog", "FOG0", 1); + + NodePtr inputNode; + Assert(inputRegCounter <= kMaxSignatureParams); + hr = flg->SetInputSignature(inputSig, inputRegCounter, &inputNode); + + + // ---- Figure out output signature --------------------------------------- + + D3D11_PARAMETER_DESC outputSig[kMaxSignatureParams]; + int outputRegCounter = 0; + int outColorReg = 0; + + outputSig[outColorReg = outputRegCounter++] = CreateParamDesc("ocolor", "SV_Target", 4); + + + // ---- Build code -------------------------------------------------------- + + NodePtr colorNode; + + if (state.texUnitCount == 0) + { + // No combiners is special case: output primary color + flg->CallFunction("", s_Linker.m_Module, "LoadVertexColor", &colorNode); + flg->PassValue(inputNode, inColorReg, colorNode, 0); + } + else + { + for (int i = 0; i < state.texUnitCount; i++) + { + std::string funcName = "LoadTex"; + funcName += ('0'+i); + + // type: 0 - 2d, 1 - 2d proj, 2 - 3d, 3 - cube + int type = 0; + if (state.texUnit3D & (1<<i)) + type = 2; + else if (state.texUnitCube & (1<<i)) + type = 3; + else if (state.texUnitProjected & (1<<i)) + type = 1; + + // Sampling modules are layed out by InternalShader/CompileShaderLib/CompileShaderLib.cpp + int samplingModule = 8 * type + i; + + hr = linker->UseLibrary(s_Linker.m_SamplingModuleInstances[samplingModule]); + AssertIf(FAILED(hr)); + + NodePtr texNode; + hr = flg->CallFunction("", s_Linker.m_SamplingModules[samplingModule], funcName.c_str(), &texNode); + AssertIf(FAILED(hr)); + hr = flg->PassValue(inputNode, inUVReg[i], texNode, 0); + AssertIf(FAILED(hr)); + + // emit color & alpha combiners + NodePtr newColorNode; + UInt32 colorComb = state.texUnitColorCombiner[i]; + UInt32 alphaComb = state.texUnitAlphaCombiner[i]; + bool usedConstant = false; + if (colorComb == alphaComb) + { + usedConstant |= EmitCombinerMath11Link (i, colorComb, kCombWriteRGBA, state.texUnitCount, flg, inputNode, colorNode, texNode, newColorNode); + } + else + { + usedConstant |= EmitCombinerMath11Link (i, colorComb, kCombWriteRGB, state.texUnitCount, flg, inputNode, colorNode, texNode, newColorNode); + NodePtr newAlphaNode; + usedConstant |= EmitCombinerMath11Link (i, alphaComb, kCombWriteA, state.texUnitCount, flg, inputNode, colorNode, texNode, newAlphaNode); + if (newAlphaNode) + { + NodePtr combinedNode; + flg->CallFunction("", s_Linker.m_Module, "CombineAlpha", &combinedNode); + flg->PassValue(newColorNode, D3D_RETURN_PARAMETER_INDEX, combinedNode, 0); + flg->PassValue(newAlphaNode, D3D_RETURN_PARAMETER_INDEX, combinedNode, 1); + newColorNode = combinedNode; + } + } + + if (usedConstant) + params.AddVectorParam ((k11PixelColors+i)*16, 4, BuiltinShaderVectorParam(kShaderVecFFTextureEnvColor0+i)); + + colorNode = newColorNode; + } + } + + if (state.alphaTest != kFuncDisabled && state.alphaTest != kFuncAlways) + { + params.AddVectorParam (k11PixelAlphaRef*16, 1, kShaderVecFFAlphaTestRef); + + static const char* kCmpFunc[] = + { + "", // kFuncDisabled + "AlphaTestNever", // kFuncNever + "AlphaTestLess", // kFuncLess + "AlphaTestEqual", // kFuncEqual + "AlphaTestLEqual", // kFuncLEqual + "AlphaTestGreater", // kFuncGreater + "AlphaTestNotEqual", // kFuncNotEqual + "AlphaTestGEqual", // kFuncGEqual + "", // kFuncAlways + }; + + NodePtr alphaTestNode; + flg->CallFunction("", s_Linker.m_Module, kCmpFunc[state.alphaTest], &alphaTestNode); + flg->PassValue(colorNode, D3D_RETURN_PARAMETER_INDEX, alphaTestNode, 0); + colorNode = alphaTestNode; + } + + // add specular + if (state.lightingEnabled && state.specularEnabled) + { + NodePtr specNode; + flg->CallFunction("", s_Linker.m_Module, "AddSpec", &specNode); + flg->PassValue(colorNode, D3D_RETURN_PARAMETER_INDEX, specNode, 0); + flg->PassValue(inputNode, inSpecReg, specNode, 1); + colorNode = specNode; + } + + // fog + if (state.fogMode != kFogDisabled && inputRegCounter < 8) + { + + params.AddVectorParam (k11PixelFog*16, 4, kShaderVecFFFogColor); + + NodePtr fogNode; + flg->CallFunction("", s_Linker.m_Module, "ApplyFog", &fogNode); + flg->PassValue(colorNode, D3D_RETURN_PARAMETER_INDEX, fogNode, 0); + flg->PassValue(inputNode, inFogReg, fogNode, 1); + colorNode = fogNode; + } + + // ---- final steps + + NodePtr outputNode; + Assert(outputRegCounter <= kMaxSignatureParams); + hr = flg->SetOutputSignature(outputSig, outputRegCounter, &outputNode); + + hr = flg->PassValue(colorNode, D3D_RETURN_PARAMETER_INDEX, outputNode, outColorReg); + + #if 0 + // Print generated hlsl for debugging + BlobPtr hlslOutput; + hr = flg->GenerateHlsl(0, &hlslOutput); + if (SUCCEEDED(hr)) + { + printf_console("DX11 debug linked PS:\n%s\n", hlslOutput->GetBufferPointer()); + } + #endif + + ModuleInstancePtr flgModule; + BlobPtr flgErrors; + hr = flg->CreateModuleInstance(&flgModule, &flgErrors); + if (FAILED(hr)) + { + const char* errorMsg = (const char*)flgErrors->GetBufferPointer(); + printf_console("DX11: Failed to create FF PS module: %s\n", errorMsg); + } + + hr = linker->UseLibrary (s_Linker.m_ModuleInstancePS); + + #if UNITY_WINRT + const char* target = "ps_4_0_level_9_1"; + #else + const char* target = "ps_4_0"; + #endif + + BlobPtr linkedCode; + BlobPtr linkedErrors; + hr = linker->Link(flgModule, "main", target, 0, &linkedCode, &linkedErrors); + if (FAILED(hr)) + { + const char* errorMsg = (const char*)linkedErrors->GetBufferPointer(); + printf_console("\nDX11: Failed to link FF PS: %s\n", errorMsg); + } + + if (!linkedCode) + { + outSize = 0; + return NULL; + } + outSize = linkedCode->GetBufferSize(); + void* finalCode = malloc(outSize); + memcpy (finalCode, linkedCode->GetBufferPointer(), outSize); + return finalCode; +} + +#endif diff --git a/Runtime/GfxDevice/d3d11/ShaderPatchingD3D11.cpp b/Runtime/GfxDevice/d3d11/ShaderPatchingD3D11.cpp new file mode 100644 index 0000000..01d9f69 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/ShaderPatchingD3D11.cpp @@ -0,0 +1,702 @@ +#include "UnityPrefix.h" +#include "ShaderPatchingD3D11.h" +#include "D3D11ByteCode.h" +#include "External/DirectX/builds/dx9include/d3d9.h" + + +#define DEBUG_D3D11_SHADER_PATCHING 0 + + +// Vertex & pixel shaders might have different set of interpolated registers, so hard to adaptively +// pick register that would always fit. So instead always put fog into this register; and in case of +// shaders already using this one, we'll just fail and there will be no fog. +// SM4 has 16 output registers, let's use second-to-last. +const int kFogInterpRegister = 14; + + +// ------------------------------------------------------------------- + +#if DEBUG_D3D11_SHADER_PATCHING +struct D3D10BlobHack +{ + virtual HRESULT WINAPI QueryInterface(const int& iid, void** ppv) = 0; + virtual ULONG WINAPI AddRef() = 0; + virtual ULONG WINAPI Release() = 0; + virtual void* WINAPI GetBufferPointer() = 0; + virtual SIZE_T WINAPI GetBufferSize() = 0; +}; + +typedef HRESULT (WINAPI *D3DDisassembleFunc)(const void* pSrcData, SIZE_T SrcDataSize, UINT Flags, const char* szComments, D3D10BlobHack** ppDisassembly); + +static void DisassembleShader(const char* name, const void* data, size_t size) +{ + static D3DDisassembleFunc func = NULL; + if (!func) + { + HMODULE dll; +#if !UNITY_METRO + dll = LoadLibraryA("d3dcompiler_43.dll"); +#else + dll = LoadPackagedLibrary(L"d3dcompiler_46.dll", 0); // _46.dll is ARM +#endif + if (!dll) + { + printf_console("--- Failed to load d3dcompiler dll - error code: %d", GetLastError()); + return; + } + func = (D3DDisassembleFunc)GetProcAddress(dll,"D3DDisassemble"); + if (!func) + return; + } + D3D10BlobHack* blob = NULL; + HRESULT hr = func(data, size, 0, NULL, &blob); + if (FAILED(hr)) + { + printf_console("Failed to disasm shader!\n"); + } + if (blob) + { + std::string str((const char*)blob->GetBufferPointer(), blob->GetBufferSize()); + printf_console("==== %s:\n%s\n", name, str.c_str()); + blob->Release(); + } +} +#endif // #if DEBUG_D3D11_SHADER_PATCHING + + + +// ------------------------------------------------------------------- + + + +static DXBCChunkSig* AddFogToSignatureChunk (const DXBCChunkSig* in) +{ + // check for max number of registers used + UInt32 maxRegNum = 0; + for (int i = 0; i < in->count; ++i) + maxRegNum = std::max(maxRegNum, in->elements[i].register_num); + if (maxRegNum >= kFogInterpRegister) + return NULL; + + //@TODO: check for FOG already being used? + const char* kFogName = "FOG"; + + // size = header + existing size + one more DXBCSignatureElement + name + unsigned size = sizeof(DXBCChunkHeader) + in->size + sizeof(DXBCSignatureElement); + const unsigned nameOffset = size; + size += strlen(kFogName)+1; + size = (size + 3) & ~3; // align to next dword + + UInt8* buf = (UInt8*)malloc(size); + DXBCChunkSig* chunk = (DXBCChunkSig*)buf; + memset (chunk, 0xAB, size); + chunk->fourcc = in->fourcc; + chunk->size = size - 8; + chunk->count = in->count + 1; + chunk->unk8 = in->unk8; + // copy existing signature elements + memcpy (chunk->elements, in->elements, sizeof(chunk->elements[0]) * in->count); + // move name offsets + for (int i = 0; i < in->count; ++i) + chunk->elements[i].name_offset += sizeof(DXBCSignatureElement); + + // add our signature element + DXBCSignatureElement& el = chunk->elements[in->count]; + el.name_offset = nameOffset - 8; + el.semantic_index = 0; + el.system_value_type = 0; + el.component_type = 3; // float + el.register_num = kFogInterpRegister; + el.mask = 1; + el.read_write_mask = (in->fourcc == kFOURCC_ISGN) ? 1 : (~1 & 0xF); + el.stream = 0; + el.unused = 0; + + // copy old names + const unsigned oldNamesOffset = sizeof(DXBCChunkHeader) + 8 + sizeof(DXBCSignatureElement) * in->count; + const unsigned newNamesOffset = oldNamesOffset + sizeof(DXBCSignatureElement); + memcpy (buf + newNamesOffset, ((const char*)in) + oldNamesOffset, nameOffset - newNamesOffset); + + // add our name + memcpy (buf + nameOffset, kFogName, strlen(kFogName)+1); + + return chunk; +} + + +static bool IsDclOpcode (SM4Opcode op) +{ + return + op >= kSM4Op_DCL_RESOURCE && op <= kSM4Op_DCL_GLOBAL_FLAGS || + op >= kSM4Op_DCL_STREAM && op <= kSM4Op_DCL_RESOURCE_STRUCTURED || + op == kSM4Op_DCL_GS_INSTANCE_COUNT; +} + + +static int FindOutputRegister(const dynamic_array<UInt32>& tokens, bool vertex) +{ + SM4TokInstruction instr; + instr.dword = 0; + for (size_t idx = 0; idx < tokens.size(); idx += instr.length) + { + instr.dword = tokens[idx]; + if (vertex && instr.opcode == kSM4Op_DCL_OUTPUT_SIV && instr.length == 4) + { + UInt32 siv = tokens[idx+3]; + if (siv == 1) // D3D10_NAME_POSITION + return tokens[idx+2]; + } + if (!vertex && instr.opcode == kSM4Op_DCL_OUTPUT && instr.length == 3) + { + //@TODO: what happens when shader writes to both color & depth, in various orderings? + return tokens[idx+2]; + } + } + return -1; +} + + +static size_t FindAfterLastDclPos(const dynamic_array<UInt32>& tokens) +{ + SM4TokInstruction instr; + instr.dword = 0; + size_t afterLastDclPos = 0; + for (size_t idx = 0; idx < tokens.size(); idx += instr.length) + { + instr.dword = tokens[idx]; + if (IsDclOpcode((SM4Opcode)instr.opcode)) + afterLastDclPos = idx + instr.length; + else + break; + } + return afterLastDclPos; +} + + +static int AddTempRegisters(dynamic_array<UInt32>& tokens, int tempsToAdd) +{ + size_t afterLastDclPos = FindAfterLastDclPos(tokens); + + SM4TokInstruction instr; + instr.dword = 0; + for (size_t idx = 0; idx < afterLastDclPos; idx += instr.length) + { + instr.dword = tokens[idx]; + if (instr.opcode == kSM4Op_DCL_TEMPS && instr.length == 2) + { + int tempsCount = tokens[idx+1]; + tokens[idx+1] += tempsToAdd; + return tempsCount; + } + } + + // no temps used, insert dcl_temps after all other declaration statements + SM4TokInstruction tok; + tok.dword = 0; + tok.opcode = kSM4Op_DCL_TEMPS; + tok.length = 2; + tokens.insert(tokens.begin()+(afterLastDclPos++), tok.dword); + tokens.insert(tokens.begin()+(afterLastDclPos++), tempsToAdd); + + return 0; +} + + +static void AddFogRegister(dynamic_array<UInt32>& tokens, bool output) +{ + size_t afterLastDclPos = FindAfterLastDclPos(tokens); + + // add dcl statement for fog register after all other declarations + SM4TokInstruction dcl; + dcl.dword = 0; + dcl.opcode = output ? kSM4Op_DCL_OUTPUT : kSM4Op_DCL_INPUT_PS; + if (dcl.opcode == kSM4Op_DCL_INPUT_PS) + dcl.dcl_input_ps.interpolation = kSM4Interp_LINEAR; + dcl.length = 3; + SM4TokOperand op; + op.dword = 0; + op.comps_enum = kSM4OperComp4; + op.mode = SM4_OPERAND_MODE_MASK; + op.sel = 1; + op.file = output ? kSM4File_OUTPUT : kSM4File_INPUT; + op.num_indices = 1; + op.index0_repr = SM4_OPERAND_INDEX_REPR_IMM32; + + tokens.insert(tokens.begin()+(afterLastDclPos++), dcl.dword); + tokens.insert(tokens.begin()+(afterLastDclPos++), op.dword); + tokens.insert(tokens.begin()+(afterLastDclPos++), kFogInterpRegister); +} + + +static bool AddConstantBufferRegister(dynamic_array<UInt32>& tokens) +{ + size_t afterLastDclPos = FindAfterLastDclPos(tokens); + + // are we already using the needed CB bind point? + SM4TokInstruction instr; + instr.dword = 0; + for (size_t idx = 0; idx < afterLastDclPos; idx += instr.length) + { + instr.dword = tokens[idx]; + if (instr.opcode == kSM4Op_DCL_CONSTANT_BUFFER && instr.length == 4) + if (tokens[idx+2] == k11FogConstantBufferBind) + return false; + } + + // add dcl statement for constant buffer after all other declarations + SM4TokInstruction dcl; + dcl.dword = 0; + dcl.opcode = kSM4Op_DCL_CONSTANT_BUFFER; + dcl.length = 4; + SM4TokOperand op; + op.dword = 0; + op.comps_enum = kSM4OperComp4; + op.file = kSM4File_CONSTANT_BUFFER; + op.num_indices = 2; + + tokens.insert(tokens.begin()+(afterLastDclPos++), dcl.dword); + tokens.insert(tokens.begin()+(afterLastDclPos++), op.dword); + tokens.insert(tokens.begin()+(afterLastDclPos++), k11FogConstantBufferBind); + tokens.insert(tokens.begin()+(afterLastDclPos++), k11FogSize); + + return true; +} + + + +static bool SupportedIndexRepr(SM4OperIndexRepr repr) +{ + return repr == SM4_OPERAND_INDEX_REPR_IMM32 || repr == SM4_OPERAND_INDEX_REPR_REG_IMM32; +} + +static void RemapRegisterToTemp(dynamic_array<UInt32>& tokens, SM4RegFile type, int num, int tempNum) +{ + SM4TokInstruction instr; + instr.dword = 0; + for (size_t idx = 0; idx < tokens.size(); idx += instr.length) + { + instr.dword = tokens[idx]; + if (IsDclOpcode((SM4Opcode)instr.opcode) || instr.opcode == kSM4Op_CUSTOMDATA) + continue; + + size_t idxEnd = idx + instr.length; + + // skip over extended tokens + size_t jj = idx; + SM4TokInstructionEx exttok; + exttok.dword = instr.dword; + while (exttok.extended) + exttok.dword = tokens[++jj]; + Assert(jj < idxEnd); + + // go over operands + while (jj+1 < idxEnd) + { + SM4TokOperand optok; + optok.dword = tokens[++jj]; + size_t opIdx = jj; + if (optok.extended) + ++jj; + + // only remap simple register references: needed file, one simple index + if (optok.file == type && optok.num_indices == 1) + { + if (optok.index0_repr == SM4_OPERAND_INDEX_REPR_IMM32 || optok.index0_repr == SM4_OPERAND_INDEX_REPR_REG_IMM32) + { + if (tokens[jj+1] == num) + { + optok.file = kSM4File_TEMP; + tokens[opIdx] = optok.dword; + tokens[jj+1] = tempNum; + } + } + } + + // skip over data for this operand + if (optok.num_indices >= 1) { + if (!SupportedIndexRepr((SM4OperIndexRepr)optok.index0_repr)) + break; + ++jj; + } + if (optok.num_indices >= 2) { + if (!SupportedIndexRepr((SM4OperIndexRepr)optok.index1_repr)) + break; + ++jj; + } + if (optok.num_indices >= 3) { + if (!SupportedIndexRepr((SM4OperIndexRepr)optok.index2_repr)) + break; + ++jj; + } + if (optok.file == kSM4File_IMMEDIATE32) + ++jj; + if (optok.file == kSM4File_IMMEDIATE64) + jj += 2; + } + } +} + + +static void RemoveRetFromEnd (dynamic_array<UInt32>& tokens) +{ + if (tokens.empty()) + return; + + SM4TokInstruction instr; + instr.dword = tokens.back(); + if (instr.opcode == kSM4Op_RET && instr.length == 1) + tokens.pop_back(); +} + + +static DXBCChunkCode* AddFogToVertexCodeChunk (const DXBCChunkCode* in) +{ + const UInt32* inTokens = (const UInt32*)&in->version; + + dynamic_array<UInt32> newTokens; + newTokens.insert(newTokens.end(), inTokens + 2, inTokens + in->length); // don't add version & length words + + int posRegister = FindOutputRegister (newTokens, true); + if (posRegister < 0) + { + #if DEBUG_D3D11_SHADER_PATCHING + printf_console("Fog patch failed: output register not found\n"); + #endif + return NULL; + } + AddFogRegister (newTokens, true); + int tmpRegister = AddTempRegisters (newTokens, 1); + RemapRegisterToTemp (newTokens, kSM4File_OUTPUT, posRegister, tmpRegister); + RemoveRetFromEnd (newTokens); + + DXBCCodeBuilder* codeBuilder = dxb_create_code(newTokens); + DXBCBuilderStream bld(codeBuilder); + bld.op(kSM4Op_MOV).reg('o',posRegister,0xF).swz('r',tmpRegister,kSM4SwzNone); // pos.xyzw = tmp.xyzw + bld.op(kSM4Op_MOV).reg('o',kFogInterpRegister,0x1).swz('r',tmpRegister,kSM4SwzRepZ); // fog.x = tmp.z + bld.op(kSM4Op_RET); + dxb_destroy_code(codeBuilder); + + const unsigned chunkSize = sizeof(DXBCChunkCode) + newTokens.size()*sizeof(newTokens[0]); + UInt8* buf = (UInt8*)malloc(chunkSize); + DXBCChunkCode* chunk = (DXBCChunkCode*)buf; + chunk->fourcc = in->fourcc; + chunk->size = chunkSize - sizeof(DXBCChunkHeader); + chunk->version = inTokens[0]; + chunk->length = newTokens.size() + 2; + memcpy (buf + sizeof(DXBCChunkCode), newTokens.data(), newTokens.size()*sizeof(newTokens[0])); + + return chunk; +} + + +static DXBCChunkCode* AddFogToPixelCodeChunk (const DXBCChunkCode* in, FogMode fogMode) +{ + const UInt32* inTokens = (const UInt32*)&in->version; + + dynamic_array<UInt32> newTokens; + newTokens.insert(newTokens.end(), inTokens + 2, inTokens + in->length); // don't add version & length words + + int colRegister = FindOutputRegister (newTokens, false); + if (colRegister < 0) + { + #if DEBUG_D3D11_SHADER_PATCHING + printf_console("Fog patch failed: output register not found\n"); + #endif + return NULL; + } + AddFogRegister (newTokens, false); + if (!AddConstantBufferRegister (newTokens)) + { + #if DEBUG_D3D11_SHADER_PATCHING + printf_console("Fog patch failed: can't add constant buffer\n"); + #endif + return NULL; + } + + int tmpReg = AddTempRegisters (newTokens, 2); + const int tmp2 = tmpReg+1; + const UInt32 fogParamsReg = (k11FogConstantBufferBind << 16) | k11FogParams; + const UInt32 fogColorReg = (k11FogConstantBufferBind << 16) | k11FogColor; + + RemapRegisterToTemp (newTokens, kSM4File_OUTPUT, colRegister, tmpReg); + RemoveRetFromEnd (newTokens); + + // add fog handling code + DXBCCodeBuilder* codeBuilder = dxb_create_code(newTokens); + DXBCBuilderStream bld(codeBuilder); + + if (fogMode == kFogExp2) + { + // fog = exp(-(density*z)^2) + bld.op(kSM4Op_MUL).reg('r',tmp2,1).swz('c',fogParamsReg,kSM4SwzRepX).swz('v',kFogInterpRegister,kSM4SwzRepX); // tmp = (density/sqrt(ln(2))) * fog + bld.op(kSM4Op_MUL).reg('r',tmp2,1).swz('r',tmp2,kSM4SwzRepX).swz('r',tmp2,kSM4SwzRepX); // tmp = tmp * tmp + bld.op_sat(kSM4Op_EXP,tmp2).reg('r',tmp2,1).swz('r',tmp2,kSM4SwzRepX,true); // tmp = saturate (exp2 (-tmp)) + } + else if (fogMode == kFogExp) + { + // fog = exp(-density*z) + bld.op(kSM4Op_MUL).reg('r',tmp2,1).swz('c',fogParamsReg,kSM4SwzRepX).swz('v',kFogInterpRegister,kSM4SwzRepX); // tmp = (density/sqrt(ln(2))) * fog + bld.op_sat(kSM4Op_EXP,tmp2).reg('r',tmp2,1).swz('r',tmp2,kSM4SwzRepX,true); // tmp = saturate (exp2 (-tmp)) + } + else if (fogMode == kFogLinear) + { + // fog = (end-z)/(end-start) + // -> tmp = (-1/(end-start)) * fog + (end/(end-start)) + bld.op_sat(kSM4Op_MAD,tmp2).reg('r',tmp2,1).swz('v',kFogInterpRegister,kSM4SwzRepX).swz('c',fogParamsReg,kSM4SwzRepZ).swz('c',fogParamsReg,kSM4SwzRepW); + } + else + { + AssertString("unknown fog mode"); + } + + // color.rgb = lerp (fogColor.rgb, color.rgb, fogVar) = + // (color.rgb-fogColor.rgb) * fogVar + fogColor.rgb + bld.op(kSM4Op_ADD).reg('r',tmpReg,7).swz('r',tmpReg,kSM4SwzXYZX).swz('c',fogColorReg,kSM4SwzXYZX, true); + bld.op(kSM4Op_MAD).reg('r',tmpReg,7).swz('r',tmpReg,kSM4SwzXYZX).swz('r',tmp2,kSM4SwzRepX).swz('c',fogColorReg,kSM4SwzXYZX); + + // move into final output + bld.op(kSM4Op_MOV).reg('o',colRegister,0xF).swz('r',tmpReg,kSM4SwzNone); // col.xyzw = tmp.xyzw + bld.op(kSM4Op_RET); + dxb_destroy_code(codeBuilder); + + const unsigned chunkSize = sizeof(DXBCChunkCode) + newTokens.size()*sizeof(newTokens[0]); + UInt8* buf = (UInt8*)malloc(chunkSize); + DXBCChunkCode* chunk = (DXBCChunkCode*)buf; + chunk->fourcc = in->fourcc; + chunk->size = chunkSize - sizeof(DXBCChunkHeader); + chunk->version = inTokens[0]; + chunk->length = newTokens.size() + 2; + memcpy (buf + sizeof(DXBCChunkCode), newTokens.data(), newTokens.size()*sizeof(newTokens[0])); + + return chunk; +} + + +// ------------------------------------------------------------------- + + +static bool FindShaderChunks (const DXBCContainer* dxbc, int* inputIdx, int* outputIdx, int* codeIdx) +{ + *inputIdx = -1; + *outputIdx = -1; + *codeIdx = -1; + for (int i = 0; i < dxbc->chunks.size(); ++i) + { + DXBCChunkHeader* c = dxbc->chunks[i]; + if (c->fourcc == kFOURCC_ISGN) + *inputIdx = i; + else if (c->fourcc == kFOURCC_OSGN) + *outputIdx = i; + else if (c->fourcc == kFOURCC_SHDR || c->fourcc == kFOURCC_SHEX) + *codeIdx = i; + } + if (*inputIdx < 0 || *outputIdx < 0 || *codeIdx < 0) + return false; + return true; +} + + +// ------------------------------------------------------------------- + + + +bool PatchVertexOrDomainShaderFogD3D11 (dynamic_array<UInt8>& byteCode) +{ + std::auto_ptr<DXBCContainer> dxbc (dxbc_parse (byteCode.data(), byteCode.size())); + if (dxbc.get() == NULL) + return false; + + #if DEBUG_D3D11_SHADER_PATCHING + DisassembleShader ("VS before patching", byteCode.data(), byteCode.size()); + #endif + + int inputIdx, outputIdx, codeIdx; + if (!FindShaderChunks (dxbc.get(), &inputIdx, &outputIdx, &codeIdx)) + { + #if DEBUG_D3D11_SHADER_PATCHING + printf_console("Fog patch failed: shader chunks not found?\n"); + #endif + return false; + } + const DXBCChunkSig* inputChunk = (DXBCChunkSig*)dxbc->chunks[inputIdx]; + const DXBCChunkSig* outputChunk = (DXBCChunkSig*)dxbc->chunks[outputIdx]; + const DXBCChunkCode* codeChunk = (DXBCChunkCode*)dxbc->chunks[codeIdx]; + + DXBCChunkSig* newOutputChunk = AddFogToSignatureChunk (outputChunk); + if (!newOutputChunk) + { + #if DEBUG_D3D11_SHADER_PATCHING + printf_console("Fog patch failed: can't add fog output signature\n"); + #endif + return false; + } + + DXBCChunkCode* newCodeChunk = AddFogToVertexCodeChunk (codeChunk); + if (!newCodeChunk) + { + free (newOutputChunk); + return false; + } + + dxbc->chunks[outputIdx] = newOutputChunk; + dxbc->chunks[codeIdx] = newCodeChunk; + dynamic_array<UInt8> newByteCode = byteCode; + dxbc_create(dxbc->chunks.data(), dxbc->chunks.size(), newByteCode); + byteCode = newByteCode; + + #if DEBUG_D3D11_SHADER_PATCHING + DisassembleShader ("VS after patching", byteCode.data(), byteCode.size()); + #endif + + free (newOutputChunk); + free (newCodeChunk); + + return true; +} + + +// ------------------------------------------------------------------- + + +bool PatchPixelShaderFogD3D11 (dynamic_array<UInt8>& byteCode, FogMode fog) +{ + std::auto_ptr<DXBCContainer> dxbc (dxbc_parse (byteCode.data(), byteCode.size())); + if (dxbc.get() == NULL) + return false; + + #if DEBUG_D3D11_SHADER_PATCHING + printf_console("Patching fog mode %d\n", fog); + DisassembleShader ("PS before patching", byteCode.data(), byteCode.size()); + #endif + + int inputIdx, outputIdx, codeIdx; + if (!FindShaderChunks (dxbc.get(), &inputIdx, &outputIdx, &codeIdx)) + { + #if DEBUG_D3D11_SHADER_PATCHING + printf_console("Fog patch failed: shader chunks not found?\n"); + #endif + return false; + } + const DXBCChunkSig* inputChunk = (DXBCChunkSig*)dxbc->chunks[inputIdx]; + const DXBCChunkSig* outputChunk = (DXBCChunkSig*)dxbc->chunks[outputIdx]; + const DXBCChunkCode* codeChunk = (DXBCChunkCode*)dxbc->chunks[codeIdx]; + + DXBCChunkSig* newInputChunk = AddFogToSignatureChunk (inputChunk); + if (!newInputChunk) + { + #if DEBUG_D3D11_SHADER_PATCHING + printf_console("Fog patch failed: can't add fog input signature\n"); + #endif + return false; + } + + DXBCChunkCode* newCodeChunk = AddFogToPixelCodeChunk (codeChunk, fog); + if (!newCodeChunk) + { + free (newInputChunk); + return false; + } + + dxbc->chunks[inputIdx] = newInputChunk; + dxbc->chunks[codeIdx] = newCodeChunk; + + dynamic_array<UInt8> newByteCode = byteCode; + dxbc_create(dxbc->chunks.data(), dxbc->chunks.size(), newByteCode); + byteCode = newByteCode; + + #if DEBUG_D3D11_SHADER_PATCHING + DisassembleShader ("PS after patching", byteCode.data(), byteCode.size()); + #endif + + free (newInputChunk); + free (newCodeChunk); + + return true; +} + + + +bool PatchRemovePartialPrecisionD3D11 (dynamic_array<UInt8>& byteCode) +{ + DXBCChunkSM20* codeChunk = static_cast<DXBCChunkSM20*>(dxbc_find_chunk(byteCode.data(), byteCode.size(), kFOURCC_SM20)); + if (!codeChunk) + return false; + + // Reference for the bytecode format: "Direct3D Shader Codes" on MSDN, + // http://msdn.microsoft.com/en-us/library/windows/hardware/ff552891(v=vs.85).aspx + + #if DEBUG_D3D11_SHADER_PATCHING + dynamic_array<UInt8> origBC = byteCode; + #endif + + const UInt32* codeEnd = (const UInt32*)(((const UInt8*)codeChunk) + sizeof(DXBCChunkHeader) + codeChunk->size); + + // Go past chunk header into chunk content + UInt32* codePtr = (UInt32*)(codeChunk+1); + // Table, ints: version, shader size, code offset + if (codePtr+2 >= codeEnd) + return false; + const UInt32 codeOffset = codePtr[2]; + + // Get to actual byte code start. + // Code offset in the table is from end of DXBCChunkHeader + codePtr = (UInt32*)(((UInt8*)codeChunk) + sizeof(DXBCChunkHeader) + codeOffset); + codePtr++; // skip version token + + // Go over all instructions + bool didChanges = false; + while (codePtr < codeEnd) + { + SM2TokInstruction* insn = (SM2TokInstruction*)codePtr; + const int length = insn->length; + const SM2Opcode op = (SM2Opcode)insn->opcode; + if (op == kSM2Op_DCL) + { + // DCL instructions have special format: destination token is the 2nd token + if (length == 2) + { + SM2TokDst* dst = (SM2TokDst*)(codePtr+2); + if (dst->res_mod & (D3DSPDM_PARTIALPRECISION>>D3DSP_DSTMOD_SHIFT)) + { + dst->res_mod &= ~(D3DSPDM_PARTIALPRECISION>>D3DSP_DSTMOD_SHIFT); + didChanges = true; + } + } + } + else if (op == kSM2Op_DEF || op == kSM2Op_DEFI || op == kSM2Op_DEFB) + { + // DEF* instructions have special format, don't have to do anything + } + else if (op == kSM2Op_CALLNZ || op == D3DSIO_LOOP || op == kSM2Op_IFC || op == kSM2Op_BREAKP || op == kSM2Op_BREAKC) + { + // these instructions don't have destination token + } + else if (length > 1) // must be a more than 2 argument instruction to have a destination token + { + SM2TokDst* dst = (SM2TokDst*)(codePtr+1); + if (dst->res_mod & (D3DSPDM_PARTIALPRECISION>>D3DSP_DSTMOD_SHIFT)) + { + dst->res_mod &= ~(D3DSPDM_PARTIALPRECISION>>D3DSP_DSTMOD_SHIFT); + didChanges = true; + } + } + codePtr += length + 1; + } + + // Update shader checksum if we did changes + if (didChanges && byteCode.size() > 20) + { + void D3DHash (const unsigned char* data, unsigned size, unsigned char res[16]); + UInt8 hsh[16]; + D3DHash (&byteCode[20], byteCode.size()-20, &byteCode[4]); + + #if DEBUG_D3D11_SHADER_PATCHING + DisassembleShader ("Shader before partial precision remove", origBC.data(), origBC.size()); + DisassembleShader ("Shader after partial precision remove", byteCode.data(), byteCode.size()); + #endif + } + + + return true; +} + diff --git a/Runtime/GfxDevice/d3d11/ShaderPatchingD3D11.h b/Runtime/GfxDevice/d3d11/ShaderPatchingD3D11.h new file mode 100644 index 0000000..51b2854 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/ShaderPatchingD3D11.h @@ -0,0 +1,24 @@ +#pragma once + +#include "Runtime/GfxDevice/GfxDeviceTypes.h" +#include "Runtime/Utilities/dynamic_array.h" + +enum { + k11FogColor = 0, + k11FogParams = 1, + k11FogSize = 2 +}; + +enum { + // DX11 has 14 constant buffers, and for safety reasons + // let's use 3rd to last one, 11. If that is already + // in use by shader, there will be no fog. + k11FogConstantBufferBind = 11, +}; + +bool PatchVertexOrDomainShaderFogD3D11 (dynamic_array<UInt8>& byteCode); +bool PatchPixelShaderFogD3D11 (dynamic_array<UInt8>& byteCode, FogMode fog); + +bool PatchRemovePartialPrecisionD3D11 (dynamic_array<UInt8>& byteCode); + +bool PatchRemovePartialPrecisionD3D11 (dynamic_array<UInt8>& byteCode); diff --git a/Runtime/GfxDevice/d3d11/StreamOutSkinnedMesh.cpp b/Runtime/GfxDevice/d3d11/StreamOutSkinnedMesh.cpp new file mode 100644 index 0000000..b1f3bd6 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/StreamOutSkinnedMesh.cpp @@ -0,0 +1,416 @@ +#include "UnityPrefix.h" +#include "Runtime/GfxDevice/d3d11/GfxDeviceD3D11.h" +#include "Runtime/GfxDevice/d3d11/StreamOutSkinnedMesh.h" +#include "Runtime/GfxDevice/d3d11/D3D11Context.h" +#include "Runtime/Math/Matrix4x4.h" +#include "Runtime/GfxDevice/d3d11/InternalShaders/builtin.h" +#include "Runtime/GfxDevice/d3d11/D3D11VBO.h" +#include "Runtime/Threads/ThreadedStreamBuffer.h" +#include "Runtime/GfxDevice/threaded/ThreadedDeviceStates.h" +#include "Runtime/GfxDevice/threaded/ThreadedVBO.h" + +struct ShaderPair +{ + ID3D11GeometryShader* m_GeometryShader; + ID3D11VertexShader* m_VertexShader; + ID3D11InputLayout* m_InputLayout; +}; + +typedef UInt32 InputSpec; // shaderChannelsMap + (bonesPerVertex << 16) + (maxBonesBits << 19) + +typedef std::map< InputSpec, ShaderPair> StreamOutShaderMap; + +struct SkinningGlobalsD3D11 +{ + SkinningGlobalsD3D11() + : m_BoundSP(0) + , m_OldGS(0) + , m_OldPS(0) + , m_OldVS(0) + , m_OldTopo(D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED) + , m_DSState(0) + , m_OldCB(0) + { + } + + StreamOutShaderMap m_ShaderMap; + ShaderPair* m_BoundSP; + ID3D11GeometryShader* m_OldGS; + ID3D11PixelShader* m_OldPS; + ID3D11VertexShader* m_OldVS; + D3D11_PRIMITIVE_TOPOLOGY m_OldTopo; + ID3D11DepthStencilState* m_DSState; + ID3D11Buffer* m_OldCB; +}; +static SkinningGlobalsD3D11 s_SkinningGlobals; + +enum MemExShaderChannel +{ + kMEXC_Position = VERTEX_FORMAT1(Vertex), + kMEXC_Normal = VERTEX_FORMAT1(Normal), + kMEXC_Tangent = VERTEX_FORMAT1(Tangent), +}; + +void StreamOutSkinningInfo::CleanUp() +{ + StreamOutShaderMap::iterator it; + for (it = s_SkinningGlobals.m_ShaderMap.begin(); it != s_SkinningGlobals.m_ShaderMap.end(); ++it) + { + if (it->second.m_GeometryShader) + { + ULONG refCount = it->second.m_GeometryShader->Release(); + AssertIf(refCount != 0); + } + if (it->second.m_VertexShader) + { + ULONG refCount = it->second.m_VertexShader->Release(); + AssertIf(refCount != 0); + } + } + s_SkinningGlobals.m_ShaderMap.clear(); + + s_SkinningGlobals.m_BoundSP = NULL; + SAFE_RELEASE(s_SkinningGlobals.m_OldVS); + SAFE_RELEASE(s_SkinningGlobals.m_OldGS); + SAFE_RELEASE(s_SkinningGlobals.m_OldPS); + SAFE_RELEASE(s_SkinningGlobals.m_OldCB); + s_SkinningGlobals.m_OldTopo = D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED; + + SAFE_RELEASE(s_SkinningGlobals.m_DSState); +} + +static UInt32 roundUpToNextPowerOf2(UInt32 in) +{ + // Round up to nearest power of 2 + // http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2 + in--; + in |= in >> 1; + in |= in >> 2; + in |= in >> 4; + in |= in >> 8; + in |= in >> 16; + in++; + return in; +} +// Get the bones bit index based on bone count. Assumes bonecount is power of 2 +static int getBonesBits(UInt32 boneCount) +{ + // Calculate ln2 + // http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogDeBruijn + + static const int MultiplyDeBruijnBitPosition2[32] = + { + 0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, + 31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9 + }; + UInt32 res = MultiplyDeBruijnBitPosition2[(UInt32)(boneCount * 0x077CB531U) >> 27]; + + if(res < 5) // Minimum size is 32 (= 0) + return 0; + + return res-5; // Adjust so that 32 = 0, 64 = 1 etc. +} + + +// maxBonesBits == Max bone count: 0 = 32, 1 = 64, etc until 5 = 1024 + +static const BYTE* GetMemExShaderCode(UInt32 shaderChannelsMap, int bonesPerVertex, UInt32 maxBonesBits, UInt32& bytecodeSize) +{ + int channelIdx = 0; + switch(shaderChannelsMap) + { + case kMEXC_Position: channelIdx = 0; break; + case kMEXC_Position|kMEXC_Normal: channelIdx = 1; break; + case kMEXC_Position|kMEXC_Normal|kMEXC_Tangent: channelIdx = 2; break; + case kMEXC_Position|kMEXC_Tangent: channelIdx = 3; break; + default: + Assert(0 && "Unsupported vertex format for GPU skinning."); + bytecodeSize = 0; + return 0; + }; + + if(maxBonesBits > 5) + maxBonesBits = 5; // TODO: Alert of too many bones per vertex + + // Adjust bonespervertex to dense array (1, 2, 4 => 0, 1, 2) + if(bonesPerVertex == 4) + bonesPerVertex--; + bonesPerVertex--; + + bytecodeSize = g_StreamOutShaderSizes[channelIdx][maxBonesBits][bonesPerVertex]; + return g_StreamOutShaders[channelIdx][maxBonesBits][bonesPerVertex]; +} + +static ShaderPair* GetMemExShader(UInt32 shaderChannelsMap, UInt32 bonesPerVertex, UInt32 maxBonesBits) +{ + // Already have vertex shader for this format? + InputSpec is = shaderChannelsMap + (bonesPerVertex << 16) + (maxBonesBits << 19); + + StreamOutShaderMap::iterator it = s_SkinningGlobals.m_ShaderMap.find(is); + if (it != s_SkinningGlobals.m_ShaderMap.end()) + return &it->second; + + UInt32 codeSize = 0; + const BYTE* code = GetMemExShaderCode(shaderChannelsMap, bonesPerVertex, maxBonesBits, codeSize); + if (!code) + return NULL; + + D3D11_SO_DECLARATION_ENTRY entries[16] = {0}; + D3D11_SO_DECLARATION_ENTRY* entry = entries; + + + entry->SemanticName = "POSITION"; + entry->SemanticIndex = 0; + entry->StartComponent = 0; + entry->ComponentCount = 3; + entry->OutputSlot = 0; + entry++; + + UINT soStride = sizeof(float) * 3; + UInt32 semanticIndex = 0; + + if(shaderChannelsMap & kMEXC_Normal) + { + entry->SemanticName = "TEXCOORD"; + entry->SemanticIndex = semanticIndex++; + entry->StartComponent = 0; + entry->ComponentCount = 3; + entry->OutputSlot = 0; + entry++; + + soStride += 3 * sizeof(float); + } + + if(shaderChannelsMap & kMEXC_Tangent) + { + entry->SemanticName = "TEXCOORD"; + entry->SemanticIndex = semanticIndex++; + entry->StartComponent = 0; + entry->ComponentCount = 4; + entry->OutputSlot = 0; + entry++; + + soStride += 4 * sizeof(float); + } + + ShaderPair sp; + GetD3D11Device()->CreateVertexShader( + code, + codeSize, + 0, &sp.m_VertexShader); + + const DX11FeatureLevel fl = gGraphicsCaps.d3d11.featureLevel; + + GetD3D11Device()->CreateGeometryShaderWithStreamOutput( + code, + codeSize, + entries, + (entry-entries), + &soStride, + 1, + (fl >= kDX11Level11_0) ? D3D11_SO_NO_RASTERIZED_STREAM : 0, + 0, + &sp.m_GeometryShader); + + sp.m_InputLayout = GetD3D11GfxDevice().GetVertexDecls().GetVertexDecl(shaderChannelsMap, (void*)code, codeSize, true, bonesPerVertex); + + s_SkinningGlobals.m_ShaderMap.insert(std::make_pair(is, sp)); + + return &s_SkinningGlobals.m_ShaderMap.find( is )->second; +} + +// Note: we might not support all formats all the time. +static bool DoesVertexFormatQualifyForMemExport(UInt32 shaderChannelsMap) +{ + // 1. Channel filter + UInt32 unsupported = ~(kMEXC_Position | kMEXC_Normal | kMEXC_Tangent); // TODO: support more channels + //UInt32 unsupported = ~(kMEXC_Position | kMEXC_Normal | kMEXC_Color | kMEXC_UV0 | kMEXC_UV1 | kMEXC_Tangent); + bool qualify = ((shaderChannelsMap & unsupported) == 0); + // 3. Must have position + qualify &= (shaderChannelsMap & kMEXC_Position) != 0; + + return qualify; + +} + +void StreamOutSkinningInfo::SkinMesh(bool last) +{ +// Assert(DoesVertexFormatQualifyForMemExport(info.channelMap)); + if (!DoesVertexFormatQualifyForMemExport(GetChannelMap())) + return; + + // Get the vertex shader + //... + ShaderPair* sp = GetMemExShader(GetChannelMap(), GetBonesPerVertex(), getBonesBits(m_BoneCount)); + + UINT offsets[] = {0}; + D3D11VBO* vbo = (D3D11VBO*)GetDestVBO(); + vbo->BindToStreamOutput(); + + ID3D11DeviceContext* ctx = GetD3D11Context(); + + if (s_SkinningGlobals.m_BoundSP == 0) + { + ctx->VSGetShader( &s_SkinningGlobals.m_OldVS, 0, 0 ); + ctx->GSGetShader( &s_SkinningGlobals.m_OldGS, 0, 0 ); + ctx->PSGetShader( &s_SkinningGlobals.m_OldPS, 0, 0 ); + ctx->IAGetPrimitiveTopology(&s_SkinningGlobals.m_OldTopo); + ctx->VSGetConstantBuffers(0, 1, &s_SkinningGlobals.m_OldCB); + } + + if (s_SkinningGlobals.m_BoundSP != sp) + { + ctx->VSSetShader( sp->m_VertexShader, 0, 0 ); + ctx->GSSetShader( sp->m_GeometryShader, 0, 0 ); + ctx->PSSetShader( 0, 0, 0 ); + s_SkinningGlobals.m_BoundSP = sp; + } + ID3D11Buffer* const cbs[] = { m_SourceBones }; + ctx->VSSetConstantBuffers(0, 1, cbs); + + UInt32 skinStride = 4; // For 1 bone, just the index + if(GetBonesPerVertex() == 2) + skinStride *= 4; // 2 indices, 2 weights + else if(GetBonesPerVertex() == 4) + skinStride *= 8; + + ID3D11Buffer* const vsStreams[] = { m_SourceVBO, m_SourceSkin }; + const UINT streamStrides[]={ GetStride(), skinStride }; + const UINT streamOffsets[] = { 0,0 }; + + ctx->IASetVertexBuffers(0, 2, vsStreams, streamStrides, streamOffsets); + + // Call our own wrapper for DX11 input layout that does redundant layout change + // tracking. + extern void SetInputLayoutD3D11 (ID3D11DeviceContext* ctx, ID3D11InputLayout* layout); + SetInputLayoutD3D11(ctx, sp->m_InputLayout); + + if (s_SkinningGlobals.m_DSState == 0) + { + D3D11_DEPTH_STENCIL_DESC dsstatedesc = CD3D11_DEPTH_STENCIL_DESC(CD3D11_DEFAULT()); + dsstatedesc.DepthEnable = FALSE; + dsstatedesc.StencilEnable = FALSE; + GetD3D11Device()->CreateDepthStencilState(&dsstatedesc, &s_SkinningGlobals.m_DSState); + } + + ID3D11DepthStencilState* bdsstate = 0; + UINT bref; + ctx->OMGetDepthStencilState(&bdsstate, &bref); + ctx->OMSetDepthStencilState(s_SkinningGlobals.m_DSState, 0); + + ctx->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_POINTLIST ); + ctx->Draw(GetVertexCount(), 0); + + ctx->OMSetDepthStencilState(bdsstate, bref); + SAFE_RELEASE(bdsstate); + + if ( last ) + { + ctx->VSSetShader( s_SkinningGlobals.m_OldVS, 0, 0 ); + ctx->GSSetShader( s_SkinningGlobals.m_OldGS, 0, 0 ); + ctx->PSSetShader( s_SkinningGlobals.m_OldPS, 0, 0 ); + ctx->IASetPrimitiveTopology(s_SkinningGlobals.m_OldTopo); + ctx->VSSetConstantBuffers( 0, 1, &s_SkinningGlobals.m_OldCB ); + SAFE_RELEASE(s_SkinningGlobals.m_OldVS); + SAFE_RELEASE(s_SkinningGlobals.m_OldGS); + SAFE_RELEASE(s_SkinningGlobals.m_OldPS); + SAFE_RELEASE(s_SkinningGlobals.m_OldCB); + s_SkinningGlobals.m_BoundSP = 0; + } + vbo->UnbindFromStreamOutput(); + //TODO +} + +// ---------------------------------------------------------------------------- +static ID3D11Buffer* UpdateStaticVBO(ID3D11Buffer* vbo, const size_t size, const void* data, bool dirty) +{ + D3D11_BUFFER_DESC desc = CD3D11_BUFFER_DESC(size, D3D11_BIND_VERTEX_BUFFER, D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE); + + if (!vbo) + { + GetD3D11Device()->CreateBuffer(&desc, 0, &vbo); + dirty = true; + } + else + { + D3D11_BUFFER_DESC curDesc; + vbo->GetDesc(&curDesc); + if (curDesc.ByteWidth != size) + { + vbo->Release(); + GetD3D11Device()->CreateBuffer(&desc, 0, &vbo); + dirty = true; + } + } + + if (dirty) + { + D3D11_MAPPED_SUBRESOURCE map; + GetD3D11Context()->Map(vbo, 0, D3D11_MAP_WRITE_DISCARD, 0, &map); + memcpy(map.pData, data, size); + GetD3D11Context()->Unmap(vbo, 0); + } + + return vbo; +} + +StreamOutSkinningInfo::~StreamOutSkinningInfo() +{ + if(m_SourceSkin) + m_SourceSkin->Release(); + if(m_SourceVBO) + m_SourceVBO->Release(); + if(m_SourceBones) + m_SourceBones->Release(); +} + +void StreamOutSkinningInfo::UpdateSourceData(const void *vertData, const BoneInfluence *skinData, bool dirty) +{ + // If only one bone, it's just one int per vertex + UINT32 skinSize = GetVertexCount() * sizeof(UInt32); + if(GetBonesPerVertex() == 2) + skinSize *= 4; // 2 weights, 2 indices + else if(GetBonesPerVertex() == 4) + skinSize *= 8; // 4 weights, 4 indices + + m_SourceVBO = UpdateStaticVBO(m_SourceVBO, GetVertexCount() * GetStride(), vertData, dirty); + m_SourceSkin = UpdateStaticVBO(m_SourceSkin, skinSize, skinData, dirty); +} + + +void StreamOutSkinningInfo::UpdateSourceBones(const int boneCount, const Matrix4x4f* cachedPose) +{ + Assert(boneCount > 0); + + UInt32 uBoneCount = std::min(1024, boneCount); + uBoneCount = std::max(32, boneCount); // Clamp to 32 - 1024, as that's what our shaders expect. + + if (m_BoneCount < roundUpToNextPowerOf2(uBoneCount) && m_SourceBones) + { + // Bone count changed, resize the bone constant buffer + m_SourceBones->Release(); + m_SourceBones = NULL; + } + m_BoneCount = roundUpToNextPowerOf2(uBoneCount); + + if (!m_SourceBones) + { + const UInt32 bufSize = m_BoneCount * 48; // Must match the max bone count in internalshaders.hlsl + D3D11_BUFFER_DESC desc = CD3D11_BUFFER_DESC(bufSize, D3D11_BIND_CONSTANT_BUFFER, D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE); + GetD3D11Device()->CreateBuffer(&desc, 0, &m_SourceBones); + } + + D3D11_MAPPED_SUBRESOURCE map; + GetD3D11Context()->Map(m_SourceBones, 0, D3D11_MAP_WRITE_DISCARD, 0, &map); + UInt8* dest = (UInt8*)map.pData; + + for (int i = 0; i < uBoneCount; ++i) + { + Matrix4x4f mat = cachedPose[i]; + mat.Transpose(); + memcpy(dest + i * 48, &mat, 48); + } + + GetD3D11Context()->Unmap(m_SourceBones, 0); +} + diff --git a/Runtime/GfxDevice/d3d11/StreamOutSkinnedMesh.h b/Runtime/GfxDevice/d3d11/StreamOutSkinnedMesh.h new file mode 100644 index 0000000..7d95232 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/StreamOutSkinnedMesh.h @@ -0,0 +1,42 @@ +#ifndef __STREAMOUTSKINNEDMESH_H__ +#define __STREAMOUTSKINNEDMESH_H__ + +#include "External/DirectX/builds/dx11include/d3d11.h" +#include "Runtime/GfxDevice/GPUSkinningInfo.h" +class VBO; +class Matrix4x4f; +class ThreadedStreamBuffer; +class GfxDeviceD3D11; + +// MemExport mesh skinning data. +class StreamOutSkinningInfo : public GPUSkinningInfo +{ + friend class GfxDeviceD3D11; +private: + ID3D11Buffer* m_SourceVBO; + ID3D11Buffer* m_SourceSkin; + ID3D11Buffer* m_SourceBones; + + //! Stores the bone count from the previous call to UpdateSourceBones. Used to select the most suitable shader version. + int m_BoneCount; + + // Private constructor and destructor , called from GfxDeviceD3D11 + StreamOutSkinningInfo() : GPUSkinningInfo(), m_SourceVBO(NULL), m_SourceSkin(NULL), m_SourceBones(NULL) {} + virtual ~StreamOutSkinningInfo(); + + + // Actual implementation methods, called from GfxDeviceD3D11 + + void UpdateSourceData(const void *vertData, const BoneInfluence *skinData, bool dirty); + void UpdateSourceBones(const int boneCount, const Matrix4x4f* cachedPose); + void SkinMesh(bool last); + +public: + + //! Clean up created shaders + static void CleanUp(); + +}; + + +#endif diff --git a/Runtime/GfxDevice/d3d11/TexturesD3D11.cpp b/Runtime/GfxDevice/d3d11/TexturesD3D11.cpp new file mode 100644 index 0000000..12f61b0 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/TexturesD3D11.cpp @@ -0,0 +1,1067 @@ +#include "UnityPrefix.h" +#include "TexturesD3D11.h" +#include "D3D11Context.h" +#include "D3D11Utils.h" +#include "Runtime/Allocator/FixedSizeAllocator.h" +#include "Runtime/Graphics/TextureFormat.h" +#include "Runtime/Graphics/Image.h" +#include "Runtime/GfxDevice/TextureUploadUtils.h" +#include "Runtime/GfxDevice/TextureIdMap.h" +#include "Runtime/Utilities/BitUtility.h" +#include "Runtime/Shaders/GraphicsCaps.h" +#include "Runtime/Graphics/Texture2D.h" +#include "External/ProphecySDK/include/prcore/Surface.hpp" +#include "Runtime/Utilities/InitializeAndCleanup.h" + + +//#define ENABLE_OLD_TEXTURE_UPLOAD UNITY_WINRT +#define ENABLE_OLD_TEXTURE_UPLOAD 0 + +typedef FixedSizeAllocator<sizeof(TexturesD3D11::D3D11Texture)> TextureAllocator; +static TextureAllocator* _TextureAlloc = NULL; + +namespace TextureD3D11Alloc +{ + void StaticInitialize() + { + _TextureAlloc = UNITY_NEW_AS_ROOT(TextureAllocator(kMemGfxDevice),kMemGfxDevice, "TextureStructs", ""); + } + + void StaticDestroy() + { + UNITY_DELETE(_TextureAlloc, kMemGfxDevice); + } +} + +static RegisterRuntimeInitializeAndCleanup s_TextureAllocManagerCallbacks(TextureD3D11Alloc::StaticInitialize, TextureD3D11Alloc::StaticDestroy); + +static inline intptr_t AllocD3DTexture(ID3D11Resource* tex, ID3D11ShaderResourceView* srv, ID3D11UnorderedAccessView* uav, bool shadowMap) +{ + return (intptr_t)(new (_TextureAlloc->alloc()) TexturesD3D11::D3D11Texture(tex, srv, uav, shadowMap)); +} + +static inline TexturesD3D11::D3D11Texture* QueryD3DTexture(TextureID textureID) +{ + return (TexturesD3D11::D3D11Texture*)TextureIdMap::QueryNativeTexture(textureID); +} + + +static void SwizzleToRGBA (const UInt8* src, UInt8* dst, int width, int height, int dstPitch, TextureFormat format) +{ + if (format == kTexFormatAlphaLum16) + { + // Handle AlphaLum16 case. ProphecySDK does not support 16 bit/channel formats, + // so we blit manually. + UInt32 rowBytes = GetRowBytesFromWidthAndFormat(width,kTexFormatAlphaLum16); + const UInt8* srcRowData = src; + UInt8* destRowData = dst; + for( int r = 0; r < height; ++r ) + { + for( int c = 0; c < width; ++c ) + { + DWORD val = srcRowData[c*2+1]; + ((DWORD*)destRowData)[c] = 0xFF000000 | (val<<16) | (val<<8) | (val); + } + srcRowData += rowBytes; + destRowData += dstPitch; + } + } + else + { + prcore::Surface srcSurface (width, height, GetRowBytesFromWidthAndFormat(width,format), GetProphecyPixelFormat(format), (void*)src); + prcore::Surface dstSurface (width, height, dstPitch, prcore::PixelFormat(32,0x000000ff,0x0000ff00,0x00ff0000,0xff000000), dst); + dstSurface.BlitImage (srcSurface, prcore::Surface::BLIT_COPY); + } +} + + +struct FormatDesc11 { + TextureFormat unityformat; + DXGI_FORMAT d3dformat; + DXGI_FORMAT sRGBD3dformat; +}; + +const static FormatDesc11 kTextureFormatTable[kTexFormatPCCount+1] = +{ + { kTexFormatPCCount, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, + { kTexFormatAlpha8, DXGI_FORMAT_A8_UNORM, DXGI_FORMAT_A8_UNORM }, // Alpha8 + { kTexFormatARGB4444, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB }, // ARGB4444 + { kTexFormatRGB24, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB }, // RGB24 + { kTexFormatRGBA32, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB }, // RGBA32 + { kTexFormatARGB32, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB }, // ARGB32 + { kTexFormatARGBFloat, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // ARGBFloat + { kTexFormatRGB565, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB }, // RGB565 + { kTexFormatBGR24, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB }, // BGR24 + { kTexFormatAlphaLum16, DXGI_FORMAT_R16_UNORM, DXGI_FORMAT_R16_UNORM }, // AlphaLum16 + { kTexFormatDXT1, DXGI_FORMAT_BC1_UNORM, DXGI_FORMAT_BC1_UNORM_SRGB }, // DXT1 + { kTexFormatDXT3, DXGI_FORMAT_BC2_UNORM, DXGI_FORMAT_BC2_UNORM_SRGB }, // DXT3 + { kTexFormatDXT5, DXGI_FORMAT_BC3_UNORM, DXGI_FORMAT_BC3_UNORM_SRGB }, // DXT5 + { kTexFormatRGBA4444, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB }, // RGBA4444 +}; + + +const static FormatDesc11 kTextureFormatA8Workaround = + { kTexFormatAlpha8, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM }; +const static FormatDesc11 kTextureFormatR16Workaround = + { kTexFormatAlphaLum16, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM }; +const static FormatDesc11 kTextureFormatBGRA32Workaround = + { kTexFormatBGRA32, DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_FORMAT_B8G8R8A8_UNORM }; + + +static const FormatDesc11& GetUploadFormat (TextureFormat inFormat) +{ + // 9.1 doesn't support A8 at all; other 9.x levels only support without mipmaps. + // To simplify things we just always expand to R8G8B8A8 on 9.x. + if (gGraphicsCaps.d3d11.featureLevel < kDX11Level10_0 && inFormat == kTexFormatAlpha8) + return kTextureFormatA8Workaround; + + // 9.1 doesn't support R16 for AlphaLum16, so expand + if (gGraphicsCaps.d3d11.featureLevel <= kDX11Level9_1 && inFormat == kTexFormatAlphaLum16) + return kTextureFormatR16Workaround; + + // kTexFormatBGRA32 is one of those "esoteric" formats that is widely used for webcam textures + if (inFormat == kTexFormatBGRA32) + return kTextureFormatBGRA32Workaround; + + return kTextureFormatTable[inFormat]; +} + +TexturesD3D11::TexturesD3D11() +{ + InvalidateSamplers(); +} + +TexturesD3D11::~TexturesD3D11() +{ + #if !UNITY_EDITOR + Assert(m_ComputeBuffers.empty()); + Assert(m_StagingTextures.empty()); + #endif +} + +void TexturesD3D11::TextureFromShaderResourceView(ID3D11ShaderResourceView* resourceView, ID3D11Texture2D** texture) const +{ + ID3D11Resource* resource = NULL; + resourceView->GetResource(&resource); + Assert(resource && "ID3D11Resource is NULL"); + resource->Release(); // GetResource() calls AddRef() + D3D11_RESOURCE_DIMENSION rType; + resource->GetType(&rType); + Assert(rType == D3D11_RESOURCE_DIMENSION_TEXTURE2D && "ID3D11Resource is not Texture2D"); + resource->QueryInterface(texture); + Assert(texture && "Texture is NULL"); + (*texture)->Release(); // QueryInterface() calls AddRef() +} + +intptr_t TexturesD3D11::RegisterNativeTexture(ID3D11ShaderResourceView* resourceView) const +{ + ID3D11Texture2D* texture = NULL; + TextureFromShaderResourceView(resourceView, &texture); + return AllocD3DTexture(texture, resourceView, 0, false); +} + +void TexturesD3D11::UpdateNativeTexture(TextureID textureID, ID3D11ShaderResourceView* resourceView) +{ + ID3D11Texture2D* texture = NULL; + TextureFromShaderResourceView(resourceView, &texture); + D3D11Texture* target = QueryD3DTexture(textureID); + if(target) + { + target->m_Texture = texture; + target->m_SRV = resourceView; + } + else + AddTexture(textureID, texture, resourceView, 0, false); +} + +void TexturesD3D11::AddTexture (TextureID textureID, ID3D11Resource* texture, ID3D11ShaderResourceView* srv, ID3D11UnorderedAccessView* uav, bool shadowMap) +{ + TextureIdMap::UpdateTexture(textureID, AllocD3DTexture(texture,srv,uav,shadowMap)); +} + +void TexturesD3D11::RemoveTexture( TextureID textureID ) +{ + D3D11Texture* target = QueryD3DTexture(textureID); + if(target) + { + target->~D3D11Texture(); + _TextureAlloc->free(target); + } + TextureIdMap::RemoveTexture(textureID); +} + +TexturesD3D11::D3D11Texture* TexturesD3D11::GetTexture (TextureID textureID) +{ + return QueryD3DTexture(textureID); +} + +void TexturesD3D11::AddComputeBuffer (ComputeBufferID id, const ComputeBuffer11& buf) +{ + m_ComputeBuffers.insert (std::make_pair(id, buf)); +} + +void TexturesD3D11::RemoveComputeBuffer (ComputeBufferID id) +{ + m_ComputeBuffers.erase (id); +} + + +ComputeBuffer11* TexturesD3D11::GetComputeBuffer (ComputeBufferID id) +{ + ComputeBufferMap::iterator it = m_ComputeBuffers.find(id); + return it==m_ComputeBuffers.end() ? NULL : &it->second; +} + + +void TexturesD3D11::Upload2DData (const UInt8* dataPtr, TextureFormat dataFormat, int width, int height, bool decompressData, ID3D11Resource* dst, DXGI_FORMAT dstFormat, bool bgra, int dstSubResource) +{ + DX11_LOG_ENTER_FUNCTION("TexturesD3D11::Upload2DData (0x%08x, %d, %d, %d, %s, 0x%08x, %d, %d)", + dataPtr, dataFormat, width, height, GetDX11BoolString(decompressData), dst, dstFormat, dstSubResource); + + if (bgra) + { + if (dstFormat == DXGI_FORMAT_R8G8B8A8_UNORM) + dstFormat = DXGI_FORMAT_B8G8R8A8_UNORM; + else if (dstFormat == DXGI_FORMAT_R8G8B8A8_UNORM_SRGB) + dstFormat = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB; + } + + HRESULT hr; + + bool isDXT = false; + int texWidth = width; + int texHeight = height; + int texMips = 1; + if (!decompressData && IsCompressedDXTTextureFormat(dataFormat)) + { + isDXT = true; + while (texWidth < 4 || texHeight < 4) + { + texWidth *= 2; + texHeight *= 2; + ++texMips; + } + } + + // find or create a staging texture of needed size & format + UInt64 stagingKey = (UInt64(width) << kStagingWidthShift) | (UInt64(height) << kStagingHeightShift) | (UInt64(dstFormat) << kStagingFormatShift); + StagingTextureMap::iterator it = m_StagingTextures.find (stagingKey); + if (it == m_StagingTextures.end()) + { + D3D11_TEXTURE2D_DESC desc; + desc.Width = texWidth; + desc.Height = texHeight; + desc.MipLevels = texMips; + desc.ArraySize = 1; + desc.Format = dstFormat; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.Usage = D3D11_USAGE_STAGING; + desc.BindFlags = 0; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + + ID3D11Device* dev = GetD3D11Device(); + ID3D11Texture2D* texture = NULL; + hr = dev->CreateTexture2D (&desc, NULL, &texture); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to create staging 2D texture w=%i h=%i d3dfmt=%i [%x]\n", width, height, dstFormat, hr); + return; + } + SetDebugNameD3D11 (texture, Format("Staging-Texture2D-%dx%d-fmt%d", width, height, dstFormat)); + + it = m_StagingTextures.insert (std::make_pair(stagingKey, texture)).first; + } + + // copy/convert source data into the staging texture + const int stagingSubresource = texMips-1; + ID3D11DeviceContext* ctx = GetD3D11Context(); + D3D11_MAPPED_SUBRESOURCE mapped; + hr = ctx->Map(it->second, stagingSubresource, D3D11_MAP_WRITE, 0, &mapped); + if (FAILED(hr)) + { + printf_console ("d3d11: failed to map staging 2D texture w=%i h=%i d3dfmt=%i [%x]\n", width, height, dstFormat, hr); + return; + } + + ///@TODO: more format conversions? + if (decompressData) + { + //int tmpWidth = std::max(width,4); + int tmpHeight = std::max(height,4); + DecompressNativeTextureFormatWithMipLevel (dataFormat, width, height, 0 /*TODO*/, (const UInt32*)dataPtr, mapped.RowPitch/4, tmpHeight, (UInt32*)mapped.pData); + //PerformUploadConversions (width, height, rgba, tempBufferPitch, usageMode, colorSpace, GetProphecyPixelFormat(kTexFormatRGBA32)); //@TODO? + } + else if (dstFormat == DXGI_FORMAT_R8G8B8A8_UNORM || dstFormat == DXGI_FORMAT_B8G8R8A8_UNORM) + { + SwizzleToRGBA (dataPtr, (UInt8*)mapped.pData, width, height, mapped.RowPitch, dataFormat); + } + else + { + size_t dataSize = CalculateImageSize(width,height,dataFormat); + const int minSize = isDXT ? 4 : 1; + int mipWidth = std::max(texWidth >> stagingSubresource, minSize); + int mipHeight = std::max(texHeight >> stagingSubresource, minSize); + size_t mappedSize = mapped.RowPitch * mipHeight; + // pitch for compressed formats is for full row of blocks + if (isDXT) + { + mappedSize /= 4; + mipHeight /= 4; + } + UInt8* mappedData = (UInt8*)mapped.pData; + if (dataSize == mappedSize) + { + memcpy(mappedData, dataPtr, dataSize); + } + else + { + // For compressed formats, height was already divided by block height, so this works out to operate + // on full row blocks + const size_t dataRowPitch = dataSize / mipHeight; + for (int y = 0; y < mipHeight; ++y) + { + memcpy(mappedData, dataPtr, dataRowPitch); + mappedData += mapped.RowPitch; + dataPtr += dataRowPitch; + } + } + } + ctx->Unmap(it->second, stagingSubresource); + + + // copy from staging into destination + ctx->CopySubresourceRegion (dst, dstSubResource, 0, 0, 0, it->second, stagingSubresource, NULL); + // Sometime CopySubresourceRegion hangs, that's why we have a message here + DX11_LOG_OUTPUT("TexturesD3D11::Upload2DData done"); +} + + +void TexturesD3D11::UploadTexture2D( + TextureID tid, TextureDimension dimension, UInt8* srcData, int width, int height, + TextureFormat format, int mipCount, UInt32 uploadFlags, int masterTextureLimit, TextureUsageMode usageMode, TextureColorSpace colorSpace ) +{ + AssertIf( srcData == NULL ); + AssertIf( (!IsPowerOfTwo(width) || !IsPowerOfTwo(height)) && !IsNPOTTextureAllowed(mipCount > 1) ); + + if( dimension != kTexDim2D ) + { + ErrorString( "Incorrect texture dimension!" ); + return; + } + + // Nothing to do here. Early out instead of failing, empty textures are serialized by dynamic fonts. + if( width == 0 || height == 0 ) + return; + + // Figure out whether we'll upload compressed or decompress on the fly + bool uploadIsCompressed, decompressOnTheFly; + HandleFormatDecompression (format, &usageMode, colorSpace, &uploadIsCompressed, &decompressOnTheFly); + if (decompressOnTheFly) + uploadIsCompressed = false; + + // find the texture + D3D11Texture* target = QueryD3DTexture(tid); + + // For compressed textures, stop applying masterTextureLimit if texture size drops below 4 + if( uploadIsCompressed ) + { + while( masterTextureLimit > 0 && ((width >> masterTextureLimit) < 4 || (height >> masterTextureLimit) < 4) ) + { + --masterTextureLimit; + } + } + + // skip several levels in data based on masterTextureLimit + int maxLevel = mipCount - 1; + int baseLevel = std::min( masterTextureLimit, maxLevel ); + int level; + for( level = 0; level < baseLevel; ++level ) + { + srcData += CalculateImageSize (width, height, format); + AssertIf( width == 1 && height == 1 && level != maxLevel ); + width = std::max( width / 2, 1 ); + height = std::max( height / 2, 1 ); + } + + const FormatDesc11& uploadFormat = GetUploadFormat(decompressOnTheFly ? kTexFormatRGBA32 : format); + DXGI_FORMAT d3dFormat = (colorSpace == kTexColorSpaceSRGBXenon || colorSpace == kTexColorSpaceSRGB) ? uploadFormat.sRGBD3dformat : uploadFormat.d3dformat; + const bool needBGRA = (uploadFlags & GfxDevice::kUploadTextureOSDrawingCompatible); + + // While texture is too large for hardware limits, skip mip levels. + int texWidth = width, texHeight = height; + prcore::Surface::BlitMode blitMode = prcore::Surface::BLIT_COPY; + while( texWidth > gGraphicsCaps.maxTextureSize || texHeight > gGraphicsCaps.maxTextureSize ) + { + if( baseLevel < maxLevel ) + { + srcData += CalculateImageSize (texWidth, texHeight, format); + width = std::max( width / 2, 1 ); + height = std::max( height / 2, 1 ); + ++baseLevel; + } + texWidth = std::max( texWidth / 2, 1 ); + texHeight = std::max( texHeight / 2, 1 ); + blitMode = prcore::Surface::BLIT_SCALE; + if( texWidth <= 4 && texHeight <= 4 ) + break; + } + + ID3D11Device* dev = GetD3D11Device(); + + // create texture if it does not exist already + ID3D11Texture2D* texture = NULL; + if(!target) + { + D3D11_TEXTURE2D_DESC desc; + desc.Width = texWidth; + desc.Height = texHeight; + desc.MipLevels = mipCount - baseLevel; + desc.ArraySize = 1; + desc.Format = d3dFormat; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = D3D11_BIND_SHADER_RESOURCE; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + + // GDI-compatible textures require certain restrictions + if (needBGRA) + { + desc.MiscFlags |= D3D11_RESOURCE_MISC_GDI_COMPATIBLE; + desc.BindFlags |= D3D11_BIND_RENDER_TARGET; + // BGRA format + if (desc.Format == DXGI_FORMAT_R8G8B8A8_UNORM) + desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; + else if (desc.Format == DXGI_FORMAT_R8G8B8A8_UNORM_SRGB) + desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB; + else { + AssertString("invalid d3d11 texture format for OS compatible texture"); + } + } + HRESULT hr = dev->CreateTexture2D (&desc, NULL, &texture); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(texture, CalculateImageSize(texWidth, texHeight,format)*(mipCount>1?1.33:1),tid.m_ID); + if( FAILED(hr) ) + printf_console( "d3d11: failed to create 2D texture id=%i w=%i h=%i mips=%i d3dfmt=%i [%x]\n", tid, texWidth, texHeight, mipCount-baseLevel, d3dFormat, hr ); + SetDebugNameD3D11 (texture, Format("Texture2D-%d-%dx%d", tid.m_ID, texWidth, texHeight)); + + // Create the shader resource view + D3D11_SHADER_RESOURCE_VIEW_DESC viewDesc; + viewDesc.Format = desc.Format; + viewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; + viewDesc.Texture2D.MostDetailedMip = 0; + viewDesc.Texture2D.MipLevels = mipCount - baseLevel; + + ID3D11ShaderResourceView* srView = NULL; + hr = dev->CreateShaderResourceView (texture, &viewDesc, &srView); + if (FAILED(hr)) + printf_console ("d3d11: failed to create 2D texture view id=%i [%x]\n", tid, hr); + + SetDebugNameD3D11 (srView, Format("Texture2D-SRV-%d-%dx%d", tid.m_ID, texWidth, texHeight)); + TextureIdMap::UpdateTexture(tid, AllocD3DTexture(texture, srView, NULL, false)); + } + else + { + texture = (ID3D11Texture2D*)target->m_Texture; + } + if( !texture ) + { + AssertString( "failed to create 2D texture" ); + return; + } + + prcore::PixelFormat pf; + + ID3D11DeviceContext* ctx = GetD3D11Context(); + + UInt8* rgba = NULL; + if (uploadFormat.d3dformat == DXGI_FORMAT_R8G8B8A8_UNORM) + { + int tmpWidth = std::max(width,4); + int tmpHeight = std::max(height,4); + rgba = new UInt8[tmpWidth*tmpHeight*4]; + } + + // Upload the mip levels + for( level = baseLevel; level <= maxLevel; ++level ) + { +#if !ENABLE_OLD_TEXTURE_UPLOAD + if(decompressOnTheFly && IsCompressedFlashATFTextureFormat(format)){ + //Workaround for flash decompression, where we do not know the miplevel sizes. + Image tempImage (width, height, kTexFormatRGBA32); + DecompressNativeTextureFormatWithMipLevel(format, width, height, level, (UInt32*)srcData, width, height, (UInt32*)tempImage.GetImageData()); + Upload2DData (tempImage.GetImageData(), kTexFormatRGBA32, width, height, false, texture, uploadFormat.d3dformat, needBGRA, level-baseLevel); + }else{ + Upload2DData (srcData, format, width, height, decompressOnTheFly, texture, uploadFormat.d3dformat, needBGRA, level-baseLevel); + } +#else + if (!uploadIsCompressed) + { + int srcPitch = 0; + const UInt8* finalData = srcData; + + if (decompressOnTheFly) + { + int tmpWidth = std::max(width,4); + int tmpHeight = std::max(height,4); + DecompressNativeTextureFormatWithMipLevel (format, width, height, level, (UInt32*)srcData, tmpWidth,tmpHeight, (UInt32*)rgba); + //PerformUploadConversions (width, height, rgba, tempBufferPitch, usageMode, colorSpace, GetProphecyPixelFormat(kTexFormatRGBA32)); //@TODO? + srcPitch = width * 4; + finalData = rgba; + } + else if (uploadFormat.d3dformat == DXGI_FORMAT_R8G8B8A8_UNORM) + { + srcPitch = width * 4; + SwizzleToRGBA (srcData, rgba, width, height, srcPitch, format); + finalData = rgba; + } + else + { + srcPitch = GetRowBytesFromWidthAndFormat(width,format); + } + + ///@TODO: more format conversions? + ctx->UpdateSubresource (texture, level-baseLevel, NULL, finalData, srcPitch, 0); + } + else + { + int dxtWidth = std::max(width,4); + int srcPitch = (format==kTexFormatDXT1) ? dxtWidth*2 : dxtWidth*4; + if (width == texWidth && height == texHeight) + { + ctx->UpdateSubresource (texture, level-baseLevel, NULL, srcData, srcPitch, 0); + } + else + { + // TODO: fill with garbage? + } + } +#endif + // Go to next level + srcData += CalculateImageSize (width, height, format); + AssertIf( width == 1 && height == 1 && level != maxLevel ); + width = std::max( width / 2, 1 ); + height = std::max( height / 2, 1 ); + texWidth = std::max( texWidth / 2, 1 ); + texHeight = std::max( texHeight / 2, 1 ); + } + + delete[] rgba; +} + + +void TexturesD3D11::UploadTextureSubData2D( + TextureID tid, UInt8* srcData, int mipLevel, + int x, int y, int width, int height, TextureFormat format, TextureColorSpace colorSpace ) +{ + ID3D11DeviceContext* ctx = GetD3D11Context(); + if (!ctx) + return; + + Assert(srcData != NULL); + Assert(!IsAnyCompressedTextureFormat(format)); + + D3D11Texture* target = QueryD3DTexture(tid); + if (!target) + { + AssertString("Texture not found"); + return; + } + + const FormatDesc11& uploadFormat = GetUploadFormat(format); + ID3D11Resource* texture = (ID3D11Resource*)target->m_Texture; + Assert(texture); + + D3D11_BOX destRegion; + destRegion.left = x; + destRegion.right = x + width; + destRegion.top = y; + destRegion.bottom = y + height; + destRegion.front = 0; + destRegion.back = 1; + + ///@TODO: other format conversions? + bool releaseUploadData = false; + UInt8* uploadData = srcData; + int srcPitch = GetRowBytesFromWidthAndFormat(width,format); + if (uploadFormat.d3dformat == DXGI_FORMAT_R8G8B8A8_UNORM) + { + uploadData = new UInt8[width*height*4]; + SwizzleToRGBA (srcData, uploadData, width, height, width*4, format); + releaseUploadData = true; + srcPitch = width*4; + } + ctx->UpdateSubresource (texture, mipLevel, &destRegion, uploadData, srcPitch, 0); + if (releaseUploadData) + delete[] uploadData; +} + + +void TexturesD3D11::UploadTextureCube( + TextureID tid, UInt8* srcData, int faceDataSize, int size, + TextureFormat format, int mipCount, UInt32 uploadFlags, TextureColorSpace colorSpace ) +{ + ID3D11Device* dev = GetD3D11Device(); + if (!dev) + return; + + if (gGraphicsCaps.buggyMipmappedCubemaps) + mipCount = 1; + + // find the texture + D3D11Texture* target = QueryD3DTexture(tid); + + // create texture if it does not exist already + const FormatDesc11& uploadFormat = GetUploadFormat( format ); + bool sRGBUpload = (colorSpace == kTexColorSpaceSRGBXenon || colorSpace == kTexColorSpaceSRGB); + +#if ENABLE_OLD_TEXTURE_UPLOAD + // Due to confirmed Microsoft DirectX Runtime bug we can't supply cubemap subresources via UpdateSubresource() function + // Prepare subresource data for CreateTexture2D() instead + + const int maxLevel = mipCount - 1; + + size_t uploadBufferSize = 0; + TextureFormat formatForSizeCalc = (uploadFormat.d3dformat == DXGI_FORMAT_R8G8B8A8_UNORM) ? kTexFormatARGB32 : format; + int mipSizeForCalc = size; + for (int level = 0; level <= maxLevel; ++level) + { + uploadBufferSize += CalculateImageSize (mipSizeForCalc, mipSizeForCalc, formatForSizeCalc); + mipSizeForCalc = std::max(mipSizeForCalc / 2, 1); + } + uploadBufferSize *= 6; + + UInt8* rawData = new UInt8[uploadBufferSize]; + UInt8* rawDataPtr = rawData; + D3D11_SUBRESOURCE_DATA subresourceData[6*20]; //2^20 should be enough + { + bool uploadIsCompressed = IsCompressedDXTTextureFormat(format); + + ID3D11DeviceContext* ctx = GetD3D11Context(); + + for (int face=0;face<6;face++) + { + int mipSize = size; + UInt8* data = srcData + face * faceDataSize; + + // Upload the mip levels + for (int level = 0; level <= maxLevel; ++level) + { + const UInt32 nLevelSize = CalculateImageSize( mipSize, mipSize, format ); + UInt32 levelRawSize = nLevelSize; + + ///@TODO: handle format conversions + int pitch = GetRowBytesFromWidthAndFormat(mipSize,format); + if (uploadFormat.d3dformat == DXGI_FORMAT_R8G8B8A8_UNORM) + { + pitch = mipSize * 4; + SwizzleToRGBA (data, rawDataPtr, mipSize, mipSize, pitch, format); + levelRawSize = mipSize*mipSize*4; + } + else + { + memcpy (rawDataPtr, data, nLevelSize); + } + + subresourceData[face*mipCount + level].pSysMem = rawDataPtr; + subresourceData[face*mipCount + level].SysMemPitch = pitch; + subresourceData[face*mipCount + level].SysMemSlicePitch = 0; + + // Go to next level + data += nLevelSize; + rawDataPtr += levelRawSize; + AssertIf( mipSize == 1 && level != maxLevel ); + mipSize = std::max( mipSize / 2, 1 ); + } + } + } +#endif + + ID3D11Texture2D* texture = NULL; + if (!target) + { + D3D11_TEXTURE2D_DESC desc; + desc.Width = size; + desc.Height = size; + desc.MipLevels = mipCount; + desc.ArraySize = 6; + desc.Format = sRGBUpload ? uploadFormat.sRGBD3dformat : uploadFormat.d3dformat; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = D3D11_BIND_SHADER_RESOURCE; + desc.CPUAccessFlags = 0; + desc.MiscFlags = D3D11_RESOURCE_MISC_TEXTURECUBE; +#if ENABLE_OLD_TEXTURE_UPLOAD + HRESULT hr = dev->CreateTexture2D (&desc, subresourceData, &texture); +#else + HRESULT hr = dev->CreateTexture2D (&desc, NULL, &texture); +#endif + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(texture, 6 * CalculateImageSize(size, size, format)*(mipCount>1?1.33:1),tid.m_ID); + if (FAILED(hr)) + printf_console ("d3d11: failed to create Cube texture id=%i s=%i mips=%i d3dfmt=%i [%x]\n", tid, size, mipCount, sRGBUpload ? uploadFormat.sRGBD3dformat : uploadFormat.d3dformat, hr); + SetDebugNameD3D11 (texture, Format("TextureCube-%d-%dx%d", tid.m_ID, size)); + + // Create the shader resource view + D3D11_SHADER_RESOURCE_VIEW_DESC viewDesc; + viewDesc.Format = desc.Format; + viewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE; + viewDesc.Texture2D.MostDetailedMip = 0; + viewDesc.Texture2D.MipLevels = mipCount; + + ID3D11ShaderResourceView* srView = NULL; + hr = dev->CreateShaderResourceView (texture, &viewDesc, &srView); + if (FAILED(hr)) + printf_console ("d3d11: failed to create Cube texture view id=%i [%x]\n", tid, hr); + + SetDebugNameD3D11 (srView, Format("TextureCube-SRV-%d-%d", tid.m_ID, size)); + + TextureIdMap::UpdateTexture(tid, AllocD3DTexture(texture, srView, NULL, false)); + } + else + { + texture = (ID3D11Texture2D*)target->m_Texture; + } +#if ENABLE_OLD_TEXTURE_UPLOAD + delete[] rawData; +#endif + + if (!texture) + { + AssertString( "failed to create cubemap" ); + return; + } +#if !ENABLE_OLD_TEXTURE_UPLOAD + // Upload data + // Note: DX11 Runtime on 9.x levels has a bug where setting cubemap data via UpdateSubresource doesn't work (only first + // subresource is ever updated). We use staging resources for upload here, but keep in mind if at some point you want + // to switch away from them. + const int maxLevel = mipCount - 1; + for (int face=0;face<6;face++) + { + int mipSize = size; + UInt8* data = srcData + face * faceDataSize; + + // Upload the mip levels + for (int level = 0; level <= maxLevel; ++level) + { + Upload2DData (data, format, mipSize, mipSize, false, texture, uploadFormat.d3dformat, false, D3D11CalcSubresource(level,face,mipCount)); + + data += CalculateImageSize(mipSize, mipSize, format); + Assert(mipSize != 1 || level == maxLevel); + mipSize = std::max(mipSize/2, 1); + } + } +#endif +} + +void TexturesD3D11::UploadTexture3D( + TextureID tid, UInt8* srcData, int width, int height, int depth, + TextureFormat format, int mipCount, UInt32 uploadFlags ) +{ + ID3D11Device* dev = GetD3D11Device(); + if (!dev) + return; + + if (gGraphicsCaps.buggyMipmapped3DTextures) + mipCount = 1; + + // find the texture + D3D11Texture* target = QueryD3DTexture(tid); + + // create texture if it does not exist already + const FormatDesc11& uploadFormat = GetUploadFormat(format); + + ID3D11Texture3D* texture = NULL; + if (!target) + { + D3D11_TEXTURE3D_DESC desc; + desc.Width = width; + desc.Height = height; + desc.Depth = depth; + desc.MipLevels = mipCount; + desc.Format = uploadFormat.d3dformat; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = D3D11_BIND_SHADER_RESOURCE; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + HRESULT hr = dev->CreateTexture3D (&desc, NULL, &texture); + REGISTER_EXTERNAL_GFX_ALLOCATION_REF(texture, depth * CalculateImageSize(width, height, format)*(mipCount>1?1.33:1),tid.m_ID); + if (FAILED(hr)) + printf_console ("d3d11: failed to create 3D texture id=%i s=%ix%ix%i mips=%i d3dfmt=%i [%x]\n", tid, width, height, depth, mipCount, uploadFormat.d3dformat, hr); + SetDebugNameD3D11 (texture, Format("Texture3D-%d-%dx%dx%d", tid.m_ID, width, height, depth)); + + // Create the shader resource view + D3D11_SHADER_RESOURCE_VIEW_DESC viewDesc; + viewDesc.Format = desc.Format; + viewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D; + viewDesc.Texture3D.MostDetailedMip = 0; + viewDesc.Texture3D.MipLevels = mipCount; + + ID3D11ShaderResourceView* srView = NULL; + hr = dev->CreateShaderResourceView (texture, &viewDesc, &srView); + if (FAILED(hr)) + printf_console ("d3d11: failed to create 3D texture view id=%i [%x]\n", tid, hr); + + SetDebugNameD3D11 (srView, Format("Texture3D-SRV-%d-%dx%dx%d", tid.m_ID, width, height, depth)); + + TextureIdMap::UpdateTexture(tid, AllocD3DTexture(texture, srView, NULL, false)); + } + else + { + texture = (ID3D11Texture3D*)target->m_Texture; + } + if (!texture) + { + AssertString("failed to create 3D texture"); + return; + } + + // Upload data + bool uploadIsCompressed = IsCompressedDXTTextureFormat(format); + + ID3D11DeviceContext* ctx = GetD3D11Context(); + + int maxLevel = mipCount - 1; + + UInt8* rgba = NULL; + if (uploadFormat.d3dformat == DXGI_FORMAT_R8G8B8A8_UNORM) + rgba = new UInt8[width*height*depth*4]; + + for (int level = 0; level <= maxLevel; ++level) + { + ///@TODO: handle format conversions + const UInt8* finalData = srcData; + int pitch = GetRowBytesFromWidthAndFormat(width,format); + if (uploadFormat.d3dformat == DXGI_FORMAT_R8G8B8A8_UNORM) + { + const UInt8* srcSlice = srcData; + UInt8* dstSlice = rgba; + for (int d = 0; d < depth; ++d) + { + SwizzleToRGBA (srcSlice, dstSlice, width, height, width*4, format); + srcSlice += pitch * height; + dstSlice += 4 * width * height; + } + finalData = rgba; + pitch = width * 4; + } + + ctx->UpdateSubresource (texture, level, NULL, finalData, pitch, pitch * height); + + // Go to next level + srcData += CalculateImageSize(width, height, format) * height; + width = std::max(width / 2, 1); + height = std::max(height / 2, 1); + depth = std::max(depth / 2, 1); + } + delete[] rgba; +} + +static D3D11_TEXTURE_ADDRESS_MODE s_D3DWrapModes[kTexWrapCount] = { + D3D11_TEXTURE_ADDRESS_WRAP, + D3D11_TEXTURE_ADDRESS_CLAMP, +}; +static D3D11_FILTER s_D3DFilters[kTexFilterCount] = { + D3D11_FILTER_MIN_MAG_MIP_POINT, + D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT, + D3D11_FILTER_MIN_MAG_MIP_LINEAR, +}; +static D3D11_FILTER s_D3DFiltersShadow[kTexFilterCount] = { + D3D11_FILTER_COMPARISON_MIN_MAG_MIP_POINT, + D3D11_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT, + D3D11_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT, +}; + +ID3D11SamplerState* TexturesD3D11::GetSampler(BuiltinSamplerState sampler) +{ + D3D11Sampler state; + switch (sampler) { + case kSamplerPointClamp: + state.filter = kTexFilterNearest; + state.wrap = kTexWrapClamp; + break; + case kSamplerLinearClamp: + state.filter = kTexFilterBilinear; + state.wrap = kTexWrapClamp; + break; + case kSamplerPointRepeat: + state.filter = kTexFilterNearest; + state.wrap = kTexWrapRepeat; + break; + case kSamplerLinearRepeat: + state.filter = kTexFilterBilinear; + state.wrap = kTexWrapRepeat; + break; + default: AssertString("unknown builtin sampler type"); + } + return GetSampler (state); +} + + +ID3D11SamplerState* TexturesD3D11::GetSampler(const D3D11Sampler& texSampler) +{ + SamplerMap::iterator sit = m_Samplers.find(texSampler); + if (sit != m_Samplers.end()) + return sit->second; + + ID3D11Device* dev = GetD3D11Device(); + ID3D11SamplerState* sampler = NULL; + + D3D11_SAMPLER_DESC desc; + if (texSampler.flags & kSamplerShadowMap) + desc.Filter = s_D3DFiltersShadow[texSampler.filter]; + else if (texSampler.anisoLevel > 1 && gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0) + desc.Filter = D3D11_FILTER_ANISOTROPIC; + else + desc.Filter = s_D3DFilters[texSampler.filter]; + desc.AddressU = desc.AddressV = desc.AddressW = s_D3DWrapModes[texSampler.wrap]; + desc.MipLODBias = texSampler.bias; + desc.MaxAnisotropy = texSampler.anisoLevel; + desc.ComparisonFunc = (gGraphicsCaps.d3d11.featureLevel < kDX11Level10_0) ? D3D11_COMPARISON_LESS_EQUAL : D3D11_COMPARISON_LESS; + desc.BorderColor[0] = desc.BorderColor[1] = desc.BorderColor[2] = desc.BorderColor[3] = 0.0f; + desc.MinLOD = -FLT_MAX; + desc.MaxLOD = FLT_MAX; + HRESULT hr = dev->CreateSamplerState (&desc, &sampler); + SetDebugNameD3D11 (sampler, Format("SamplerState-%d-%d", texSampler.filter, texSampler.wrap)); + + sit = m_Samplers.insert (std::make_pair(texSampler,sampler)).first; + return sit->second; +} + + +bool TexturesD3D11::SetTexture (ShaderType shaderType, int unit, int sampler, TextureID textureID, float bias) +{ + D3D11Texture* target = QueryD3DTexture(textureID); + if (!target) + return false; + + D3D11Texture& tex = *target; + // Do not bind texture if it's currently being used as a render target + if (g_D3D11CurrColorRT && g_D3D11CurrColorRT->m_Texture == tex.m_Texture && !tex.m_UAV) + return false; + + if (bias != std::numeric_limits<float>::infinity()) + tex.m_Sampler.bias = bias; + + // set sampler state + ID3D11SamplerState* smp = GetSampler(tex.m_Sampler); + + ID3D11DeviceContext* ctx = GetD3D11Context(); + switch (shaderType) { + case kShaderVertex: + ctx->VSSetShaderResources (unit, 1, &tex.m_SRV); + if (sampler >= 0 && m_ActiveD3DSamplers[kShaderVertex][sampler] != smp) + { + ctx->VSSetSamplers (sampler, 1, &smp); + m_ActiveD3DSamplers[kShaderVertex][sampler] = smp; + } + break; + case kShaderFragment: + ctx->PSSetShaderResources (unit, 1, &tex.m_SRV); + if (sampler >= 0 && m_ActiveD3DSamplers[kShaderFragment][sampler] != smp) + { + ctx->PSSetSamplers (sampler, 1, &smp); + m_ActiveD3DSamplers[kShaderFragment][sampler] = smp; + } + break; + case kShaderGeometry: + ctx->GSSetShaderResources (unit, 1, &tex.m_SRV); + if (sampler >= 0 && m_ActiveD3DSamplers[kShaderGeometry][sampler] != smp) + { + ctx->GSSetSamplers (sampler, 1, &smp); + m_ActiveD3DSamplers[kShaderGeometry][sampler] = smp; + } + break; + case kShaderHull: + ctx->HSSetShaderResources (unit, 1, &tex.m_SRV); + if (sampler >= 0 && m_ActiveD3DSamplers[kShaderHull][sampler] != smp) + { + ctx->HSSetSamplers (sampler, 1, &smp); + m_ActiveD3DSamplers[kShaderHull][sampler] = smp; + } + break; + case kShaderDomain: + ctx->DSSetShaderResources (unit, 1, &tex.m_SRV); + if (sampler >= 0 && m_ActiveD3DSamplers[kShaderDomain][sampler] != smp) + { + ctx->DSSetSamplers (sampler, 1, &smp); + m_ActiveD3DSamplers[kShaderDomain][sampler] = smp; + } + break; + default: AssertString ("unknown shader type"); + } + + return true; +} + +void TexturesD3D11::InvalidateSamplers() +{ + memset (m_ActiveD3DSamplers, 0, sizeof(m_ActiveD3DSamplers)); +} + + +void TexturesD3D11::SetTextureParams( TextureID textureID, TextureDimension texDim, TextureFilterMode filter, TextureWrapMode wrap, int anisoLevel, bool hasMipMap, TextureColorSpace colorSpace ) +{ + D3D11Texture* target = QueryD3DTexture(textureID); + if (!target) + return; + + D3D11Sampler& s = target->m_Sampler; + s.filter = filter; + s.wrap = wrap; + s.anisoLevel = anisoLevel; + if (hasMipMap) + s.flags |= kSamplerHasMipMap; + else + s.flags &= ~kSamplerHasMipMap; +} + + +void TexturesD3D11::DeleteTexture( TextureID textureID ) +{ + D3D11Texture* target = QueryD3DTexture(textureID); + if( !target ) + return; + + // texture can be null if texture creation failed. At least don't make it crash here + if (target->m_Texture) + { + REGISTER_EXTERNAL_GFX_DEALLOCATION(target->m_Texture); + ULONG refCount = target->m_Texture->Release(); + DebugAssert(!refCount); + } + if (target->m_UAV) + { + ULONG refCount = target->m_UAV->Release(); + DebugAssert(!refCount); + } + if (target->m_SRV) + { + ULONG refCount = target->m_SRV->Release(); + DebugAssert(!refCount); + } + target->~D3D11Texture(); + _TextureAlloc->free(target); + TextureIdMap::RemoveTexture(textureID); +} + +void TexturesD3D11::ClearTextureResources() +{ + for (SamplerMap::iterator it = m_Samplers.begin(); it != m_Samplers.end(); ++it) + { + if (it->second) + it->second->Release(); + } + m_Samplers.clear(); + + for (StagingTextureMap::iterator it = m_StagingTextures.begin(), itEnd = m_StagingTextures.end(); it != itEnd; ++it) + { + if (it->second) + it->second->Release(); + } + m_StagingTextures.clear(); +} + diff --git a/Runtime/GfxDevice/d3d11/TexturesD3D11.h b/Runtime/GfxDevice/d3d11/TexturesD3D11.h new file mode 100644 index 0000000..d5971f9 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/TexturesD3D11.h @@ -0,0 +1,201 @@ +#pragma once + +#include "D3D11Includes.h" +#include "Runtime/GfxDevice/GfxDeviceTypes.h" +#include "Runtime/Graphics/RenderSurface.h" +#include "Runtime/Threads/AtomicOps.h" +#include "Runtime/Utilities/NonCopyable.h" +#include "Runtime/Utilities/dynamic_array.h" +#include <map> + +class ImageReference; + +struct ComputeBuffer11 +{ + ID3D11Buffer* buffer; + ID3D11ShaderResourceView* srv; + ID3D11UnorderedAccessView* uav; +}; + + +class TexturesD3D11 +{ +public: + enum { kSamplerHasMipMap = (1<<0), kSamplerShadowMap = (1<<1) }; + struct D3D11Sampler { + D3D11Sampler() { + memset (this, 0, sizeof(*this)); + } + float bias; + UInt8 filter; // TextureFilterMode + UInt8 wrap; // TextureWrapMode + UInt8 anisoLevel; + UInt8 flags; + }; + struct D3D11Texture { + D3D11Texture() : m_Texture(NULL), m_SRV(NULL), m_UAV(NULL) { } + explicit D3D11Texture (ID3D11Resource* tex, ID3D11ShaderResourceView* srv, ID3D11UnorderedAccessView* uav, bool shadowMap) + : m_Texture(tex), m_SRV(srv), m_UAV(uav) { if (shadowMap) m_Sampler.flags |= kSamplerShadowMap; } + ID3D11Resource* m_Texture; + ID3D11ShaderResourceView* m_SRV; + ID3D11UnorderedAccessView* m_UAV; + D3D11Sampler m_Sampler; + }; + +public: + TexturesD3D11(); + ~TexturesD3D11(); + + void ClearTextureResources(); + + bool SetTexture (ShaderType shaderType, int unit, int sampler, TextureID textureID, float bias); + void SetTextureParams( TextureID texture, TextureDimension texDim, TextureFilterMode filter, TextureWrapMode wrap, int anisoLevel, bool hasMipMap, TextureColorSpace colorSpace ); + + void DeleteTexture( TextureID textureID ); + + void UploadTexture2D( + TextureID tid, TextureDimension dimension, UInt8* srcData, int width, int height, + TextureFormat format, int mipCount, UInt32 uploadFlags, int masterTextureLimit, TextureUsageMode usageMode, TextureColorSpace colorSpace ); + + void UploadTextureSubData2D( + TextureID tid, UInt8* srcData, int mipLevel, + int x, int y, int width, int height, TextureFormat format, TextureColorSpace colorSpace ); + + void UploadTextureCube( + TextureID tid, UInt8* srcData, int faceDataSize, int size, + TextureFormat format, int mipCount, UInt32 uploadFlags, TextureColorSpace colorSpace ); + + void UploadTexture3D( + TextureID tid, UInt8* srcData, int width, int height, int depth, + TextureFormat format, int mipCount, UInt32 uploadFlags ); + + void AddTexture (TextureID textureID, ID3D11Resource* texture, ID3D11ShaderResourceView* srv, ID3D11UnorderedAccessView* uav, bool shadowMap); + void RemoveTexture( TextureID textureID ); + D3D11Texture* GetTexture(TextureID textureID); + ID3D11SamplerState* GetSampler(const D3D11Sampler& texSampler); + ID3D11SamplerState* GetSampler(BuiltinSamplerState sampler); + + void AddComputeBuffer (ComputeBufferID id, const ComputeBuffer11& buf); + void RemoveComputeBuffer (ComputeBufferID id); + ComputeBuffer11* GetComputeBuffer (ComputeBufferID id); + + void InvalidateSamplers(); + void InvalidateSampler (ShaderType shader, int samplerUnit) { m_ActiveD3DSamplers[shader][samplerUnit] = NULL; } + + intptr_t RegisterNativeTexture(ID3D11ShaderResourceView* resourceView) const; + void UpdateNativeTexture(TextureID textureID, ID3D11ShaderResourceView* resourceView); + +private: + void Upload2DData (const UInt8* dataPtr, TextureFormat dataFormat, int width, int height, bool decompressData, ID3D11Resource* dst, DXGI_FORMAT dstFormat, bool bgra, int dstSubResource); + +private: + typedef std::map< D3D11Sampler, ID3D11SamplerState*, memcmp_less<D3D11Sampler> > SamplerMap; + SamplerMap m_Samplers; + + ID3D11SamplerState* m_ActiveD3DSamplers[kShaderTypeCount][kMaxSupportedTextureUnits]; + + // staging texture key: width, height, dxgi format + enum { + kStagingWidthShift = 0ULL, + kStagingHeightShift = 20ULL, + kStagingFormatShift = 40ULL, + }; + typedef std::map<UInt64, ID3D11Resource*> StagingTextureMap; + StagingTextureMap m_StagingTextures; + + typedef std::map<ComputeBufferID, ComputeBuffer11> ComputeBufferMap; + ComputeBufferMap m_ComputeBuffers; + + void TextureFromShaderResourceView(ID3D11ShaderResourceView* resourceView, ID3D11Texture2D** texture) const; +}; + + +struct RenderSurfaceD3D11 : RenderSurfaceBase, NonCopyable +{ + RenderSurfaceD3D11() + : m_Texture(NULL) + , m_SRView(NULL) + , m_SRViewForMips(NULL) + , m_UAView(NULL) + , depth(0) + , dim(kTexDim2D) + { + RenderSurfaceBase_Init(*this); + } + ID3D11Resource* m_Texture; + ID3D11ShaderResourceView* m_SRView; + ID3D11ShaderResourceView* m_SRViewForMips; // always without sRGB + ID3D11UnorderedAccessView* m_UAView; + int depth; + TextureDimension dim; +protected: + void Reset() + { + SAFE_RELEASE(m_Texture); + SAFE_RELEASE(m_SRView); + SAFE_RELEASE(m_SRViewForMips); + SAFE_RELEASE(m_UAView); + RenderSurfaceBase_Init(*this); + depth = 0; + dim = kTexDim2D; + } +}; + +struct RenderColorSurfaceD3D11 : public RenderSurfaceD3D11 +{ + RenderColorSurfaceD3D11() + : format(kRTFormatARGB32) + { + colorSurface = true; + } + + static UInt32 GetRTVKey(int face, int mipLevel, bool secondary) { + return (face) | (secondary ? 8 : 0) | (mipLevel << 4); + } + ID3D11RenderTargetView* GetRTV(int face, int mipLevel, bool secondary) { + UInt32 key = GetRTVKey(face, mipLevel, secondary); + for (int i = 0, n = m_RTVs.size(); i != n; ++i) + if (m_RTVs[i].first == key) + return m_RTVs[i].second; + return NULL; + } + void SetRTV(int face, int mipLevel, bool secondary, ID3D11RenderTargetView* rtv) { + DebugAssert(GetRTV(face, mipLevel, secondary) == NULL); + UInt32 key = GetRTVKey(face, mipLevel, secondary); + m_RTVs.push_back (std::make_pair(key, rtv)); + } + + void Reset() + { + RenderSurfaceD3D11::Reset(); + colorSurface = true; + for (int i = 0, n = m_RTVs.size(); i != n; ++i) + { + SAFE_RELEASE(m_RTVs[i].second); + } + m_RTVs.resize_uninitialized(0); + } + + typedef std::pair<UInt32, ID3D11RenderTargetView*> RTVPair; + dynamic_array<RTVPair> m_RTVs; + RenderTextureFormat format; +}; + +struct RenderDepthSurfaceD3D11 : public RenderSurfaceD3D11 +{ + RenderDepthSurfaceD3D11() + : m_DSView(NULL) + , depthFormat(kDepthFormatNone) + { + colorSurface = false; + } + ID3D11DepthStencilView* m_DSView; + DepthBufferFormat depthFormat; + void Reset() + { + RenderSurfaceD3D11::Reset(); + colorSurface = false; + SAFE_RELEASE(m_DSView); + depthFormat = kDepthFormatNone; + } +}; diff --git a/Runtime/GfxDevice/d3d11/TimerQueryD3D11.cpp b/Runtime/GfxDevice/d3d11/TimerQueryD3D11.cpp new file mode 100644 index 0000000..31afc52 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/TimerQueryD3D11.cpp @@ -0,0 +1,209 @@ +#include "UnityPrefix.h" +#if ENABLE_PROFILER +#include "GfxDeviceD3D11.h" +#include "D3D11Context.h" +#include "TimerQueryD3D11.h" + + +TimerQueryD3D11::TimerQueryD3D11() + : m_Query(NULL), m_Time(0), m_Active(false) +{ + D3D11_QUERY_DESC QueryDesc; + QueryDesc.Query = D3D11_QUERY_TIMESTAMP; + QueryDesc.MiscFlags = 0; + GetD3D11Device()->CreateQuery(&QueryDesc, &m_Query); + m_TimeMultiplier = 0.0f; +} + +TimerQueryD3D11::~TimerQueryD3D11() +{ + SAFE_RELEASE(m_Query); +} + +void TimerQueryD3D11::Measure() +{ + // Flush previous result + GetElapsed(kWaitRenderThread); + + if (m_Query) + { + g_TimerQueriesD3D11.AddActiveTimerQuery(this); + GetD3D11Context()->End(m_Query); + m_Active = true; + m_Time = kInvalidProfileTime; + } + else + m_Time = 0; + m_TimeMultiplier = 0.0f; +} + +ProfileTimeFormat TimerQueryD3D11::GetElapsed(UInt32 flags) +{ + while (m_Active) + { + bool wait = (flags & kWaitRenderThread) != 0; + if (!g_TimerQueriesD3D11.PollNextTimerQuery(wait)) + break; + } + return m_Time; +} + +bool TimerQueryD3D11::PollResult(UInt64& prevTime, bool wait) +{ + for (;;) + { + UINT64 time; + UINT flags = wait ? 0 : D3D11_ASYNC_GETDATA_DONOTFLUSH; + HRESULT hr = GetD3D11Context()->GetData(m_Query, &time, sizeof(time), flags); + if (hr == S_OK) + { + UInt64 elapsed = prevTime ? (time - prevTime) : 0; + m_Time = ProfileTimeFormat(elapsed * m_TimeMultiplier); + prevTime = time; + return true; + } + // Stop polling on unknown result (e.g D3DERR_DEVICELOST) + if (hr != S_FALSE) + { + m_Time = 0; + prevTime = 0; + return true; + } + if (!wait) + break; + } + return false; +} + +TimerQueriesD3D11::TimerQueriesD3D11() +{ + m_LastQueryTime = 0; + m_DisjointQuery = NULL; + memset(m_StartTimeQueries, 0, sizeof(m_StartTimeQueries)); + m_StartTimeQueryIndex = 0; +} + +void TimerQueriesD3D11::ReleaseAllQueries() +{ + SAFE_RELEASE(m_DisjointQuery); + for (int i = 0; i < kStartTimeQueryCount; i++) + { + delete m_StartTimeQueries[i]; + m_StartTimeQueries[i] = NULL; + } + m_InactiveTimerQueries.append(m_ActiveTimerQueries); + m_InactiveTimerQueries.append(m_PolledTimerQueries); + TimerQueryList& queries = m_InactiveTimerQueries; + for (TimerQueryList::iterator it = queries.begin(); it != queries.end(); ++it) + { + TimerQueryD3D11& query = *it; + query.m_Active = false; + query.m_Time = 0; + SAFE_RELEASE(query.m_Query); + } +} + +void TimerQueriesD3D11::RecreateAllQueries() +{ + Assert(m_ActiveTimerQueries.empty()); + Assert(m_PolledTimerQueries.empty()); + TimerQueryList& queries = m_InactiveTimerQueries; + for (TimerQueryList::iterator it = queries.begin(); it != queries.end(); ++it) + { + TimerQueryD3D11& query = *it; + + D3D11_QUERY_DESC QueryDesc; + QueryDesc.Query = D3D11_QUERY_TIMESTAMP; + QueryDesc.MiscFlags = 0; + GetD3D11Device()->CreateQuery(&QueryDesc, &query.m_Query); + } +} + +void TimerQueriesD3D11::BeginTimerQueries() +{ + // Poll queries from previous frames + PollTimerQueries(); + + if (m_DisjointQuery == NULL) + { + D3D11_QUERY_DESC QueryDesc; + QueryDesc.Query = D3D11_QUERY_TIMESTAMP_DISJOINT; + QueryDesc.MiscFlags = 0; + GetD3D11Device()->CreateQuery(&QueryDesc, &m_DisjointQuery); + } + GetD3D11Context()->Begin(m_DisjointQuery); + + int& index = m_StartTimeQueryIndex; + if (m_StartTimeQueries[index] == NULL) + { + m_StartTimeQueries[index] = new TimerQueryD3D11; + } + m_StartTimeQueries[index]->Measure(); + index = (index + 1) % kStartTimeQueryCount; +} + +void TimerQueriesD3D11::EndTimerQueries() +{ + if(m_DisjointQuery == NULL) + return; + + GetD3D11Context()->End(m_DisjointQuery); + + HRESULT hr; + D3D11_QUERY_DATA_TIMESTAMP_DISJOINT disjointQueryResult; + do + { + hr = GetD3D11Context()->GetData(m_DisjointQuery, &disjointQueryResult, sizeof(disjointQueryResult), 0); + } while (hr == S_FALSE); + if (hr == S_OK && !disjointQueryResult.Disjoint) + { + float timeMult = float(1000000000.0 / (double)disjointQueryResult.Frequency); + TimerQueryList::iterator query, queryEnd = m_ActiveTimerQueries.end(); + for (query = m_ActiveTimerQueries.begin(); query != queryEnd; ++query) + query->SetTimeMultiplier(timeMult); + } + // Move queries from active to polled list + m_PolledTimerQueries.append(m_ActiveTimerQueries); +} + +TimerQueryD3D11* TimerQueriesD3D11::CreateTimerQuery() +{ + TimerQueryD3D11* query = new TimerQueryD3D11; + m_InactiveTimerQueries.push_back(*query); + return query; +} + +void TimerQueriesD3D11::AddActiveTimerQuery(TimerQueryD3D11* query) +{ + query->RemoveFromList(); + m_ActiveTimerQueries.push_back(*query); +} + +void TimerQueriesD3D11::PollTimerQueries() +{ + for (;;) + { + if (!PollNextTimerQuery(false)) + break; + } +} + +bool TimerQueriesD3D11::PollNextTimerQuery(bool wait) +{ + if (m_PolledTimerQueries.empty()) + return false; + + TimerQueryD3D11& query = m_PolledTimerQueries.front(); + if (query.PollResult(m_LastQueryTime, wait)) + { + query.m_Active = false; + query.RemoveFromList(); + m_InactiveTimerQueries.push_back(query); + return true; + } + return false; +} + +TimerQueriesD3D11 g_TimerQueriesD3D11; + +#endif diff --git a/Runtime/GfxDevice/d3d11/TimerQueryD3D11.h b/Runtime/GfxDevice/d3d11/TimerQueryD3D11.h new file mode 100644 index 0000000..3f46a5c --- /dev/null +++ b/Runtime/GfxDevice/d3d11/TimerQueryD3D11.h @@ -0,0 +1,67 @@ +#ifndef TIMERQUERYD3D11_H +#define TIMERQUERYD3D11_H + +#if ENABLE_PROFILER + +#include "Runtime/GfxDevice/GfxTimerQuery.h" + +class TimerQueriesD3D11; + +class TimerQueryD3D11 : public GfxTimerQuery +{ +public: + ~TimerQueryD3D11(); + + virtual void Measure(); + virtual ProfileTimeFormat GetElapsed(UInt32 flags); + + bool PollResult(UInt64& prevTime, bool wait); + void SetTimeMultiplier(float tm) { m_TimeMultiplier = tm; } + +private: + friend TimerQueriesD3D11; + TimerQueryD3D11(); + + ID3D11Query* m_Query; + ProfileTimeFormat m_Time; + float m_TimeMultiplier; + bool m_Active; +}; + +class TimerQueriesD3D11 +{ +public: + TimerQueriesD3D11(); + + void ReleaseAllQueries(); + void RecreateAllQueries(); + + void BeginTimerQueries(); + void EndTimerQueries(); + + TimerQueryD3D11* CreateTimerQuery(); + + void AddActiveTimerQuery(TimerQueryD3D11* query); + void PollTimerQueries(); + bool PollNextTimerQuery(bool wait); + +private: + enum + { + kStartTimeQueryCount = 3 + }; + + UInt64 m_LastQueryTime; + ID3D11Query* m_DisjointQuery; + TimerQueryD3D11* m_StartTimeQueries[kStartTimeQueryCount]; + int m_StartTimeQueryIndex; + typedef List<TimerQueryD3D11> TimerQueryList; + TimerQueryList m_InactiveTimerQueries; + TimerQueryList m_ActiveTimerQueries; + TimerQueryList m_PolledTimerQueries; +}; + +extern TimerQueriesD3D11 g_TimerQueriesD3D11; + +#endif +#endif diff --git a/Runtime/GfxDevice/d3d11/VertexDeclarationsD3D11.cpp b/Runtime/GfxDevice/d3d11/VertexDeclarationsD3D11.cpp new file mode 100644 index 0000000..e98779b --- /dev/null +++ b/Runtime/GfxDevice/d3d11/VertexDeclarationsD3D11.cpp @@ -0,0 +1,282 @@ +#include "UnityPrefix.h" +#include "VertexDeclarationsD3D11.h" +#include "D3D11Context.h" +#include "D3D11ByteCode.h" +#include "D3D11Utils.h" +#include "Runtime/GfxDevice/GfxDeviceTypes.h" +#include "Runtime/Utilities/ArrayUtility.h" +#include "Runtime/Shaders/VBO.h" + + +extern ID3D11InputLayout* g_ActiveInputLayoutD3D11; + + +bool VertexDeclarationsD3D11::KeyType::operator < (const KeyType& rhs) const +{ + if (inputSig != rhs.inputSig) + return inputSig < rhs.inputSig; + if (extraBits != rhs.extraBits) + return extraBits < rhs.extraBits; + return memcmp(channels, rhs.channels, sizeof(channels)) < 0; +} + + + +VertexDeclarationsD3D11::VertexDeclarationsD3D11() +{ +} + +VertexDeclarationsD3D11::~VertexDeclarationsD3D11() +{ + Clear(); +} + +static D3D11_INPUT_ELEMENT_DESC kChannelVertexElems[kShaderChannelCount] = { + // semantic name, semantic index, format, input slot, aligned byte offset, input slot class, instance data step rate + { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "COLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 1, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "TANGENT", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, +}; +static const int kDefaultChannelSizes[kShaderChannelCount] = { + 12, // position + 12, // normal + 4, // color + 8, // uv + 8, // uv2 + 16, // tangent +}; + +static const int kChannelSkinningCount = 2; +static D3D11_INPUT_ELEMENT_DESC kChannelSkinning4[kChannelSkinningCount] = { + // Stream 1 + { "BLENDWEIGHT", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "BLENDINDICES", 0, DXGI_FORMAT_R32G32B32A32_SINT, 1, 16, D3D11_INPUT_PER_VERTEX_DATA, 0 }, +}; + +static D3D11_INPUT_ELEMENT_DESC kChannelSkinning2[kChannelSkinningCount] = { + // Stream 1 + { "BLENDWEIGHT", 0, DXGI_FORMAT_R32G32_FLOAT, 1, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "BLENDINDICES", 0, DXGI_FORMAT_R32G32_SINT, 1, 8, D3D11_INPUT_PER_VERTEX_DATA, 0 }, +}; + +static D3D11_INPUT_ELEMENT_DESC kChannelSkinning1[kChannelSkinningCount] = { + // Stream 1 + { "BONEINDEX", 0, DXGI_FORMAT_R32_SINT, 1, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, +}; + +static const D3D11_INPUT_ELEMENT_DESC kImmChannelVertexElems[] = { + // semantic name, semantic index, format, input slot, aligned byte offset, input slot class, instance data step rate + { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "COLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 28, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 1, DXGI_FORMAT_R32G32B32_FLOAT, 0, 40, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 2, DXGI_FORMAT_R32G32B32_FLOAT, 0, 52, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 3, DXGI_FORMAT_R32G32B32_FLOAT, 0, 64, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 4, DXGI_FORMAT_R32G32B32_FLOAT, 0, 76, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 5, DXGI_FORMAT_R32G32B32_FLOAT, 0, 88, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 6, DXGI_FORMAT_R32G32B32_FLOAT, 0,100, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 7, DXGI_FORMAT_R32G32B32_FLOAT, 0,112, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + // feed position as tangent0 data, just in case we use shaders that pretend to want tangents + { "TANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, +}; + +static FORCE_INLINE DXGI_FORMAT GetD3D11VertexDeclType(const ChannelInfo& info) +{ + switch (info.format) + { + case kChannelFormatFloat: + { + switch (info.dimension) + { + case 1: return DXGI_FORMAT_R32_FLOAT; + case 2: return DXGI_FORMAT_R32G32_FLOAT; + case 3: return DXGI_FORMAT_R32G32B32_FLOAT; + case 4: return DXGI_FORMAT_R32G32B32A32_FLOAT; + } + break; + } + case kChannelFormatFloat16: + { + switch (info.dimension) + { + case 2: return DXGI_FORMAT_R16G16_FLOAT; + case 4: return DXGI_FORMAT_R16G16B16A16_FLOAT; + } + break; + } + case kChannelFormatColor: + { + return DXGI_FORMAT_R8G8B8A8_UNORM; + } + } + Assert("No matching D3D11 vertex decl type!"); + return DXGI_FORMAT_UNKNOWN; +} + +ID3D11InputLayout* VertexDeclarationsD3D11::GetVertexDecl( UInt32 shaderChannelsMap, void* vertexShaderCode, unsigned vertexShaderLength, bool memExportSkin, unsigned int bonesPerVertex) +{ + ChannelInfoArray channels; + int offset = 0; + for (int i = 0; i < kShaderChannelCount; i++) + { + ChannelInfo& info = channels[i]; + if (shaderChannelsMap & (1 << i)) + { + info.stream = 0; + info.offset = offset; + info.format = VBO::GetDefaultChannelFormat( i ); + info.dimension = VBO::GetDefaultChannelDimension( i ); + offset += VBO::GetDefaultChannelByteSize( i ); + } + else + info.Reset(); + } + return GetVertexDecl( channels, GetShaderInputSignature(vertexShaderCode, vertexShaderLength), memExportSkin, bonesPerVertex ); +} + + +ID3D11InputLayout* VertexDeclarationsD3D11::GetVertexDecl (const ChannelInfoArray& channels, const InputSignatureD3D11* inputSig, bool streamOutSkin, unsigned int bonesPerVertex) +{ + if (!inputSig) + { + AssertString("DX11 shader input signature is null"); + return NULL; + } + + KeyType key; + memcpy(key.channels, channels, sizeof(key.channels)); + key.extraBits = streamOutSkin ? bonesPerVertex : 0; // Set bones-per-vertex count for memExportSkin + key.inputSig = inputSig; + + // already have vertex declaration for this format/shader? + VertexDeclMap::iterator it = m_VertexDeclMap.find (key); + if( it != m_VertexDeclMap.end() ) + return it->second; + + // don't have this declaration yet - create one + D3D11_INPUT_ELEMENT_DESC elements[kShaderChannelCount + kChannelSkinningCount]; + int elIndex = 0; + for( int chan = 0; chan < kShaderChannelCount; chan++ ) + { + DebugAssert(elIndex < kShaderChannelCount); + if (!channels[chan].IsValid() ) + { + ///@TODO: for now, hack in all shader channels to pretend to be there + elements[elIndex] = kChannelVertexElems[chan]; + elements[elIndex].AlignedByteOffset = 0; + ++elIndex; + continue; + } + elements[elIndex] = kChannelVertexElems[chan]; + elements[elIndex].InputSlot = channels[chan].stream; + elements[elIndex].AlignedByteOffset = channels[chan].offset; + elements[elIndex].Format = GetD3D11VertexDeclType(channels[chan]); + ++elIndex; + } + + if (streamOutSkin) // Append extra elements required for streamout + { + switch(bonesPerVertex) + { + default: + case 1: + elements[elIndex] = kChannelSkinning1[0]; + ++elIndex; + break; + case 2: + for (int i = 0; i < kChannelSkinningCount; ++i) + { + elements[elIndex] = kChannelSkinning2[i]; + ++elIndex; + } + break; + case 4: + for (int i = 0; i < kChannelSkinningCount; ++i) + { + elements[elIndex] = kChannelSkinning4[i]; + ++elIndex; + } + break; + } + } + + ID3D11InputLayout* decl = NULL; + HRESULT hr = GetD3D11Device()->CreateInputLayout (elements, elIndex, inputSig->blob.data(), inputSig->blob.size(), &decl ); + if( FAILED(hr) ) { + AssertString ("Failed to create vertex declaration\n"); + // TODO: error! + } + SetDebugNameD3D11 (decl, Format("InputLayout-%d", elIndex)); + m_VertexDeclMap.insert( std::make_pair( key, decl ) ); + + return decl; +} + +ID3D11InputLayout* VertexDeclarationsD3D11::GetImmVertexDecl (const InputSignatureD3D11* inputSig) +{ + if (!inputSig) + { + AssertString("DX11 shader input signature is null"); + return NULL; + } + + // already have vertex declaration for this shader? + ImmVertexDeclMap::iterator it = m_ImmVertexDeclMap.find (inputSig); + if (it != m_ImmVertexDeclMap.end()) + return it->second; + + // don't have this declaration yet - create one + ID3D11InputLayout* decl = NULL; + HRESULT hr = GetD3D11Device()->CreateInputLayout (kImmChannelVertexElems,ARRAY_SIZE(kImmChannelVertexElems), inputSig->blob.data(), inputSig->blob.size(), &decl); + if (FAILED(hr)) + { + AssertString ("Failed to create vertex declaration for GL.Begin\n"); + // TODO: error! + } + SetDebugNameD3D11 (decl, "InputLayoutImmediate"); + m_ImmVertexDeclMap.insert(std::make_pair(inputSig, decl)); + + return decl; +} + +void VertexDeclarationsD3D11::Clear() +{ + g_ActiveInputLayoutD3D11 = NULL; + + for (VertexDeclMap::iterator it = m_VertexDeclMap.begin(); it != m_VertexDeclMap.end(); ++it) + { + if (it->second) { + ULONG refCount = it->second->Release(); + AssertIf( refCount != 0 ); + } + } + m_VertexDeclMap.clear(); + + for (ImmVertexDeclMap::iterator it = m_ImmVertexDeclMap.begin(); it != m_ImmVertexDeclMap.end(); ++it) + { + if (it->second) { + ULONG refCount = it->second->Release(); + AssertIf( refCount != 0 ); + } + } + m_ImmVertexDeclMap.clear(); +} + + +const InputSignatureD3D11* VertexDeclarationsD3D11::GetShaderInputSignature (void* code, unsigned length) +{ + DXBCChunkHeader* isigChunk = dxbc_find_chunk (code, length, kFOURCC_ISGN); + DebugAssert (isigChunk); + if (!isigChunk) + return NULL; + + InputSignatureD3D11 isig; + dxbc_create (&isigChunk, 1, isig.blob); + + InputSignatures::iterator it = m_InputSignatures.insert(isig).first; + return &(*it); +} diff --git a/Runtime/GfxDevice/d3d11/VertexDeclarationsD3D11.h b/Runtime/GfxDevice/d3d11/VertexDeclarationsD3D11.h new file mode 100644 index 0000000..cd7e981 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/VertexDeclarationsD3D11.h @@ -0,0 +1,51 @@ +#pragma once + +#include "D3D11Includes.h" +#include "Runtime/Filters/Mesh/VertexData.h" +#include "Runtime/Utilities/dynamic_array.h" +#include <map> + +struct InputSignatureD3D11 +{ + dynamic_array<UInt8> blob; + bool operator < (const InputSignatureD3D11& o) const + { + size_t sizeA = blob.size(); + size_t sizeB = o.blob.size(); + if (sizeA != sizeB) + return sizeA < sizeB; + int res = memcmp (blob.data(), o.blob.data(), sizeA); + return res < 0; + } +}; + +class VertexDeclarationsD3D11 +{ +public: + VertexDeclarationsD3D11(); + ~VertexDeclarationsD3D11(); + + ID3D11InputLayout* GetVertexDecl( UInt32 shaderChannelsMap, void* vertexShaderCode, unsigned vertexShaderLength, bool streamOutSkin = false, unsigned int bonesPerVertex = 4 ); + ID3D11InputLayout* GetVertexDecl (const ChannelInfoArray& channels, const InputSignatureD3D11* inputSig, bool streamOutSkin = false, unsigned int bonesPerVertex = 4); + ID3D11InputLayout* GetImmVertexDecl (const InputSignatureD3D11* inputSig); + void Clear(); + + const InputSignatureD3D11* GetShaderInputSignature (void* code, unsigned length); + +private: + typedef std::set<InputSignatureD3D11> InputSignatures; + InputSignatures m_InputSignatures; + + struct KeyType + { + bool operator < (const KeyType& rhs) const; + ChannelInfoArray channels; + const InputSignatureD3D11* inputSig; + UInt32 extraBits; + }; + typedef UNITY_MAP(kMemVertexData, KeyType, ID3D11InputLayout*) VertexDeclMap; + VertexDeclMap m_VertexDeclMap; + + typedef UNITY_MAP(kMemVertexData, const InputSignatureD3D11*, ID3D11InputLayout*) ImmVertexDeclMap; + ImmVertexDeclMap m_ImmVertexDeclMap; +}; |