1//
2// Copyright (c) 2014 The ANGLE Project Authors. All rights reserved.
3// Use of this source code is governed by a BSD-style license that can be
4// found in the LICENSE file.
5//
6
7// ShaderD3D.cpp: Defines the rx::ShaderD3D class which implements rx::ShaderImpl.
8
9#include "libGLESv2/renderer/d3d/ShaderD3D.h"
10#include "libGLESv2/renderer/Renderer.h"
11#include "libGLESv2/Shader.h"
12#include "libGLESv2/main.h"
13
14#include "common/utilities.h"
15
16namespace rx
17{
18
19template <typename VarT>
20void FilterInactiveVariables(std::vector<VarT> *variableList)
21{
22    ASSERT(variableList);
23
24    for (size_t varIndex = 0; varIndex < variableList->size();)
25    {
26        if (!(*variableList)[varIndex].staticUse)
27        {
28            variableList->erase(variableList->begin() + varIndex);
29        }
30        else
31        {
32            varIndex++;
33        }
34    }
35}
36
37void *ShaderD3D::mFragmentCompiler = NULL;
38void *ShaderD3D::mVertexCompiler = NULL;
39
40template <typename VarT>
41const std::vector<VarT> *GetShaderVariables(const std::vector<VarT> *variableList)
42{
43    ASSERT(variableList);
44    return variableList;
45}
46
47ShaderD3D::ShaderD3D(GLenum type, rx::Renderer *renderer)
48    : mType(type),
49      mRenderer(renderer),
50      mShaderVersion(100)
51{
52    uncompile();
53    initializeCompiler();
54}
55
56ShaderD3D::~ShaderD3D()
57{
58}
59
60ShaderD3D *ShaderD3D::makeShaderD3D(ShaderImpl *impl)
61{
62    ASSERT(HAS_DYNAMIC_TYPE(ShaderD3D*, impl));
63    return static_cast<ShaderD3D*>(impl);
64}
65
66const ShaderD3D *ShaderD3D::makeShaderD3D(const ShaderImpl *impl)
67{
68    ASSERT(HAS_DYNAMIC_TYPE(const ShaderD3D*, impl));
69    return static_cast<const ShaderD3D*>(impl);
70}
71
72// Perform a one-time initialization of the shader compiler (or after being destructed by releaseCompiler)
73void ShaderD3D::initializeCompiler()
74{
75    if (!mFragmentCompiler)
76    {
77        int result = ShInitialize();
78
79        if (result)
80        {
81            ShShaderOutput hlslVersion = (mRenderer->getMajorShaderModel() >= 4) ? SH_HLSL11_OUTPUT : SH_HLSL9_OUTPUT;
82
83            ShBuiltInResources resources;
84            ShInitBuiltInResources(&resources);
85
86            // TODO(geofflang): use context's caps
87            const gl::Caps &caps = mRenderer->getRendererCaps();
88            const gl::Extensions &extensions = mRenderer->getRendererExtensions();
89
90            resources.MaxVertexAttribs = caps.maxVertexAttributes;
91            resources.MaxVertexUniformVectors = caps.maxVertexUniformVectors;
92            resources.MaxVaryingVectors = caps.maxVaryingVectors;
93            resources.MaxVertexTextureImageUnits = caps.maxVertexTextureImageUnits;
94            resources.MaxCombinedTextureImageUnits = caps.maxCombinedTextureImageUnits;
95            resources.MaxTextureImageUnits = caps.maxTextureImageUnits;
96            resources.MaxFragmentUniformVectors = caps.maxFragmentUniformVectors;
97            resources.MaxDrawBuffers = caps.maxDrawBuffers;
98            resources.OES_standard_derivatives = extensions.standardDerivatives;
99            resources.EXT_draw_buffers = extensions.drawBuffers;
100            resources.EXT_shader_texture_lod = 1;
101            // resources.OES_EGL_image_external = mRenderer->getShareHandleSupport() ? 1 : 0; // TODO: commented out until the extension is actually supported.
102            resources.FragmentPrecisionHigh = 1;   // Shader Model 2+ always supports FP24 (s16e7) which corresponds to highp
103            resources.EXT_frag_depth = 1; // Shader Model 2+ always supports explicit depth output
104            // GLSL ES 3.0 constants
105            resources.MaxVertexOutputVectors = caps.maxVertexOutputComponents / 4;
106            resources.MaxFragmentInputVectors = caps.maxFragmentInputComponents / 4;
107            resources.MinProgramTexelOffset = caps.minProgramTexelOffset;
108            resources.MaxProgramTexelOffset = caps.maxProgramTexelOffset;
109
110            mFragmentCompiler = ShConstructCompiler(GL_FRAGMENT_SHADER, SH_GLES2_SPEC, hlslVersion, &resources);
111            mVertexCompiler = ShConstructCompiler(GL_VERTEX_SHADER, SH_GLES2_SPEC, hlslVersion, &resources);
112        }
113    }
114}
115
116void ShaderD3D::releaseCompiler()
117{
118    ShDestruct(mFragmentCompiler);
119    ShDestruct(mVertexCompiler);
120
121    mFragmentCompiler = NULL;
122    mVertexCompiler = NULL;
123
124    ShFinalize();
125}
126
127void ShaderD3D::parseVaryings(void *compiler)
128{
129     if (!mHlsl.empty())
130    {
131        const std::vector<sh::Varying> *varyings = ShGetVaryings(compiler);
132        ASSERT(varyings);
133
134        for (size_t varyingIndex = 0; varyingIndex < varyings->size(); varyingIndex++)
135        {
136            mVaryings.push_back(gl::PackedVarying((*varyings)[varyingIndex]));
137        }
138
139        mUsesMultipleRenderTargets = mHlsl.find("GL_USES_MRT")          != std::string::npos;
140        mUsesFragColor             = mHlsl.find("GL_USES_FRAG_COLOR")   != std::string::npos;
141        mUsesFragData              = mHlsl.find("GL_USES_FRAG_DATA")    != std::string::npos;
142        mUsesFragCoord             = mHlsl.find("GL_USES_FRAG_COORD")   != std::string::npos;
143        mUsesFrontFacing           = mHlsl.find("GL_USES_FRONT_FACING") != std::string::npos;
144        mUsesPointSize             = mHlsl.find("GL_USES_POINT_SIZE")   != std::string::npos;
145        mUsesPointCoord            = mHlsl.find("GL_USES_POINT_COORD")  != std::string::npos;
146        mUsesDepthRange            = mHlsl.find("GL_USES_DEPTH_RANGE")  != std::string::npos;
147        mUsesFragDepth             = mHlsl.find("GL_USES_FRAG_DEPTH")   != std::string::npos;
148        mUsesDiscardRewriting      = mHlsl.find("ANGLE_USES_DISCARD_REWRITING") != std::string::npos;
149        mUsesNestedBreak           = mHlsl.find("ANGLE_USES_NESTED_BREAK") != std::string::npos;
150    }
151}
152
153void ShaderD3D::resetVaryingsRegisterAssignment()
154{
155    for (size_t varyingIndex = 0; varyingIndex < mVaryings.size(); varyingIndex++)
156    {
157        mVaryings[varyingIndex].resetRegisterAssignment();
158    }
159}
160
161// initialize/clean up previous state
162void ShaderD3D::uncompile()
163{
164    // set by compileToHLSL
165    mHlsl.clear();
166    mInfoLog.clear();
167
168    mUsesMultipleRenderTargets = false;
169    mUsesFragColor = false;
170    mUsesFragData = false;
171    mUsesFragCoord = false;
172    mUsesFrontFacing = false;
173    mUsesPointSize = false;
174    mUsesPointCoord = false;
175    mUsesDepthRange = false;
176    mUsesFragDepth = false;
177    mShaderVersion = 100;
178    mUsesDiscardRewriting = false;
179    mUsesNestedBreak = false;
180
181    mVaryings.clear();
182    mUniforms.clear();
183    mInterfaceBlocks.clear();
184    mActiveAttributes.clear();
185    mActiveOutputVariables.clear();
186}
187
188void ShaderD3D::compileToHLSL(void *compiler, const std::string &source)
189{
190    // ensure the compiler is loaded
191    initializeCompiler();
192
193    int compileOptions = (SH_OBJECT_CODE | SH_VARIABLES);
194    std::string sourcePath;
195    if (gl::perfActive())
196    {
197        sourcePath = getTempPath();
198        writeFile(sourcePath.c_str(), source.c_str(), source.length());
199        compileOptions |= SH_LINE_DIRECTIVES;
200    }
201
202    int result;
203    if (sourcePath.empty())
204    {
205        const char* sourceStrings[] =
206        {
207            source.c_str(),
208        };
209
210        result = ShCompile(compiler, sourceStrings, ArraySize(sourceStrings), compileOptions);
211    }
212    else
213    {
214        const char* sourceStrings[] =
215        {
216            sourcePath.c_str(),
217            source.c_str(),
218        };
219
220        result = ShCompile(compiler, sourceStrings, ArraySize(sourceStrings), compileOptions | SH_SOURCE_PATH);
221    }
222
223    size_t shaderVersion = 100;
224    ShGetInfo(compiler, SH_SHADER_VERSION, &shaderVersion);
225
226    mShaderVersion = static_cast<int>(shaderVersion);
227
228    if (shaderVersion == 300 && mRenderer->getCurrentClientVersion() < 3)
229    {
230        mInfoLog = "GLSL ES 3.00 is not supported by OpenGL ES 2.0 contexts";
231        TRACE("\n%s", mInfoLog.c_str());
232    }
233    else if (result)
234    {
235        size_t objCodeLen = 0;
236        ShGetInfo(compiler, SH_OBJECT_CODE_LENGTH, &objCodeLen);
237
238        char* outputHLSL = new char[objCodeLen];
239        ShGetObjectCode(compiler, outputHLSL);
240
241#ifdef _DEBUG
242        std::ostringstream hlslStream;
243        hlslStream << "// GLSL\n";
244        hlslStream << "//\n";
245
246        size_t curPos = 0;
247        while (curPos != std::string::npos)
248        {
249            size_t nextLine = source.find("\n", curPos);
250            size_t len = (nextLine == std::string::npos) ? std::string::npos : (nextLine - curPos + 1);
251
252            hlslStream << "// " << source.substr(curPos, len);
253
254            curPos = (nextLine == std::string::npos) ? std::string::npos : (nextLine + 1);
255        }
256        hlslStream << "\n\n";
257        hlslStream << outputHLSL;
258        mHlsl = hlslStream.str();
259#else
260        mHlsl = outputHLSL;
261#endif
262
263        SafeDeleteArray(outputHLSL);
264
265        mUniforms = *GetShaderVariables(ShGetUniforms(compiler));
266
267        for (size_t uniformIndex = 0; uniformIndex < mUniforms.size(); uniformIndex++)
268        {
269            const sh::Uniform &uniform = mUniforms[uniformIndex];
270
271            if (uniform.staticUse)
272            {
273                unsigned int index = -1;
274                bool result = ShGetUniformRegister(compiler, uniform.name.c_str(), &index);
275                UNUSED_ASSERTION_VARIABLE(result);
276                ASSERT(result);
277
278                mUniformRegisterMap[uniform.name] = index;
279            }
280        }
281
282        mInterfaceBlocks = *GetShaderVariables(ShGetInterfaceBlocks(compiler));
283
284        for (size_t blockIndex = 0; blockIndex < mInterfaceBlocks.size(); blockIndex++)
285        {
286            const sh::InterfaceBlock &interfaceBlock = mInterfaceBlocks[blockIndex];
287
288            if (interfaceBlock.staticUse)
289            {
290                unsigned int index = -1;
291                bool result = ShGetInterfaceBlockRegister(compiler, interfaceBlock.name.c_str(), &index);
292                UNUSED_ASSERTION_VARIABLE(result);
293                ASSERT(result);
294
295                mInterfaceBlockRegisterMap[interfaceBlock.name] = index;
296            }
297        }
298    }
299    else
300    {
301        size_t infoLogLen = 0;
302        ShGetInfo(compiler, SH_INFO_LOG_LENGTH, &infoLogLen);
303
304        char* infoLog = new char[infoLogLen];
305        ShGetInfoLog(compiler, infoLog);
306        mInfoLog = infoLog;
307
308        TRACE("\n%s", mInfoLog.c_str());
309    }
310}
311
312rx::D3DWorkaroundType ShaderD3D::getD3DWorkarounds() const
313{
314    if (mUsesDiscardRewriting)
315    {
316        // ANGLE issue 486:
317        // Work-around a D3D9 compiler bug that presents itself when using conditional discard, by disabling optimization
318        return rx::ANGLE_D3D_WORKAROUND_SKIP_OPTIMIZATION;
319    }
320
321    if (mUsesNestedBreak)
322    {
323        // ANGLE issue 603:
324        // Work-around a D3D9 compiler bug that presents itself when using break in a nested loop, by maximizing optimization
325        // We want to keep the use of ANGLE_D3D_WORKAROUND_MAX_OPTIMIZATION minimal to prevent hangs, so usesDiscard takes precedence
326        return rx::ANGLE_D3D_WORKAROUND_MAX_OPTIMIZATION;
327    }
328
329    return rx::ANGLE_D3D_WORKAROUND_NONE;
330}
331
332// true if varying x has a higher priority in packing than y
333bool ShaderD3D::compareVarying(const gl::PackedVarying &x, const gl::PackedVarying &y)
334{
335    if (x.type == y.type)
336    {
337        return x.arraySize > y.arraySize;
338    }
339
340    // Special case for handling structs: we sort these to the end of the list
341    if (x.type == GL_STRUCT_ANGLEX)
342    {
343        return false;
344    }
345
346    if (y.type == GL_STRUCT_ANGLEX)
347    {
348        return true;
349    }
350
351    return gl::VariableSortOrder(x.type) < gl::VariableSortOrder(y.type);
352}
353
354unsigned int ShaderD3D::getUniformRegister(const std::string &uniformName) const
355{
356    ASSERT(mUniformRegisterMap.count(uniformName) > 0);
357    return mUniformRegisterMap.find(uniformName)->second;
358}
359
360unsigned int ShaderD3D::getInterfaceBlockRegister(const std::string &blockName) const
361{
362    ASSERT(mInterfaceBlockRegisterMap.count(blockName) > 0);
363    return mInterfaceBlockRegisterMap.find(blockName)->second;
364}
365
366void *ShaderD3D::getCompiler()
367{
368    if (mType == GL_VERTEX_SHADER)
369    {
370        return mVertexCompiler;
371    }
372    else
373    {
374        ASSERT(mType == GL_FRAGMENT_SHADER);
375        return mFragmentCompiler;
376    }
377}
378
379ShShaderOutput ShaderD3D::getCompilerOutputType(GLenum shader)
380{
381    void *compiler = NULL;
382
383    switch (shader)
384    {
385      case GL_VERTEX_SHADER:   compiler = mVertexCompiler;   break;
386      case GL_FRAGMENT_SHADER: compiler = mFragmentCompiler; break;
387      default: UNREACHABLE();  return SH_HLSL9_OUTPUT;
388    }
389
390    size_t outputType = 0;
391    ShGetInfo(compiler, SH_OUTPUT_TYPE, &outputType);
392
393    return static_cast<ShShaderOutput>(outputType);
394}
395
396bool ShaderD3D::compile(const std::string &source)
397{
398    uncompile();
399
400    void *compiler = getCompiler();
401
402    compileToHLSL(compiler, source);
403
404    if (mType == GL_VERTEX_SHADER)
405    {
406        parseAttributes(compiler);
407    }
408
409    parseVaryings(compiler);
410
411    if (mType == GL_FRAGMENT_SHADER)
412    {
413        std::sort(mVaryings.begin(), mVaryings.end(), compareVarying);
414
415        const std::string &hlsl = getTranslatedSource();
416        if (!hlsl.empty())
417        {
418            mActiveOutputVariables = *GetShaderVariables(ShGetOutputVariables(compiler));
419            FilterInactiveVariables(&mActiveOutputVariables);
420        }
421    }
422
423    return !getTranslatedSource().empty();
424}
425
426void ShaderD3D::parseAttributes(void *compiler)
427{
428    const std::string &hlsl = getTranslatedSource();
429    if (!hlsl.empty())
430    {
431        mActiveAttributes = *GetShaderVariables(ShGetAttributes(compiler));
432        FilterInactiveVariables(&mActiveAttributes);
433    }
434}
435
436int ShaderD3D::getSemanticIndex(const std::string &attributeName) const
437{
438    if (!attributeName.empty())
439    {
440        int semanticIndex = 0;
441        for (size_t attributeIndex = 0; attributeIndex < mActiveAttributes.size(); attributeIndex++)
442        {
443            const sh::ShaderVariable &attribute = mActiveAttributes[attributeIndex];
444
445            if (attribute.name == attributeName)
446            {
447                return semanticIndex;
448            }
449
450            semanticIndex += gl::VariableRegisterCount(attribute.type);
451        }
452    }
453
454    return -1;
455}
456
457}
458