1 //
2 // Copyright 2002 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 #include "compiler/translator/TranslatorGLSL.h"
8
9 #include "angle_gl.h"
10 #include "compiler/translator/BuiltInFunctionEmulatorGLSL.h"
11 #include "compiler/translator/ExtensionGLSL.h"
12 #include "compiler/translator/OutputGLSL.h"
13 #include "compiler/translator/VersionGLSL.h"
14 #include "compiler/translator/tree_ops/RewriteTexelFetchOffset.h"
15 #include "compiler/translator/tree_ops/apple/RewriteRowMajorMatrices.h"
16 #include "compiler/translator/tree_ops/apple/RewriteUnaryMinusOperatorFloat.h"
17
18 namespace sh
19 {
20
TranslatorGLSL(sh::GLenum type,ShShaderSpec spec,ShShaderOutput output)21 TranslatorGLSL::TranslatorGLSL(sh::GLenum type, ShShaderSpec spec, ShShaderOutput output)
22 : TCompiler(type, spec, output)
23 {}
24
initBuiltInFunctionEmulator(BuiltInFunctionEmulator * emu,ShCompileOptions compileOptions)25 void TranslatorGLSL::initBuiltInFunctionEmulator(BuiltInFunctionEmulator *emu,
26 ShCompileOptions compileOptions)
27 {
28 if ((compileOptions & SH_EMULATE_ABS_INT_FUNCTION) != 0)
29 {
30 InitBuiltInAbsFunctionEmulatorForGLSLWorkarounds(emu, getShaderType());
31 }
32
33 if ((compileOptions & SH_EMULATE_ISNAN_FLOAT_FUNCTION) != 0)
34 {
35 InitBuiltInIsnanFunctionEmulatorForGLSLWorkarounds(emu, getShaderVersion());
36 }
37
38 if ((compileOptions & SH_EMULATE_ATAN2_FLOAT_FUNCTION) != 0)
39 {
40 InitBuiltInAtanFunctionEmulatorForGLSLWorkarounds(emu);
41 }
42
43 int targetGLSLVersion = ShaderOutputTypeToGLSLVersion(getOutputType());
44 InitBuiltInFunctionEmulatorForGLSLMissingFunctions(emu, getShaderType(), targetGLSLVersion);
45 }
46
translate(TIntermBlock * root,ShCompileOptions compileOptions,PerformanceDiagnostics *)47 bool TranslatorGLSL::translate(TIntermBlock *root,
48 ShCompileOptions compileOptions,
49 PerformanceDiagnostics * /*perfDiagnostics*/)
50 {
51 TInfoSinkBase &sink = getInfoSink().obj;
52
53 // Write GLSL version.
54 writeVersion(root);
55
56 // Write extension behaviour as needed
57 writeExtensionBehavior(root, compileOptions);
58
59 // Write pragmas after extensions because some drivers consider pragmas
60 // like non-preprocessor tokens.
61 WritePragma(sink, compileOptions, getPragma());
62
63 // If flattening the global invariant pragma, write invariant declarations for built-in
64 // variables. It should be harmless to do this twice in the case that the shader also explicitly
65 // did this. However, it's important to emit invariant qualifiers only for those built-in
66 // variables that are actually used, to avoid affecting the behavior of the shader.
67 if ((compileOptions & SH_FLATTEN_PRAGMA_STDGL_INVARIANT_ALL) != 0 &&
68 getPragma().stdgl.invariantAll &&
69 !sh::RemoveInvariant(getShaderType(), getShaderVersion(), getOutputType(), compileOptions))
70 {
71 ASSERT(wereVariablesCollected());
72
73 switch (getShaderType())
74 {
75 case GL_VERTEX_SHADER:
76 sink << "invariant gl_Position;\n";
77
78 // gl_PointSize should be declared invariant in both ESSL 1.00 and 3.00 fragment
79 // shaders if it's statically referenced.
80 conditionallyOutputInvariantDeclaration("gl_PointSize");
81 break;
82 case GL_FRAGMENT_SHADER:
83 // The preprocessor will reject this pragma if it's used in ESSL 3.00 fragment
84 // shaders, so we can use simple logic to determine whether to declare these
85 // variables invariant.
86 conditionallyOutputInvariantDeclaration("gl_FragCoord");
87 conditionallyOutputInvariantDeclaration("gl_PointCoord");
88 break;
89 default:
90 // Currently not reached, but leave this in for future expansion.
91 ASSERT(false);
92 break;
93 }
94 }
95
96 if ((compileOptions & SH_REWRITE_TEXELFETCHOFFSET_TO_TEXELFETCH) != 0)
97 {
98 if (!sh::RewriteTexelFetchOffset(this, root, getSymbolTable(), getShaderVersion()))
99 {
100 return false;
101 }
102 }
103
104 if ((compileOptions & SH_REWRITE_FLOAT_UNARY_MINUS_OPERATOR) != 0)
105 {
106 if (!sh::RewriteUnaryMinusOperatorFloat(this, root))
107 {
108 return false;
109 }
110 }
111
112 if ((compileOptions & SH_REWRITE_ROW_MAJOR_MATRICES) != 0 && getShaderVersion() >= 300)
113 {
114 if (!RewriteRowMajorMatrices(this, root, &getSymbolTable()))
115 {
116 return false;
117 }
118 }
119
120 // Write emulated built-in functions if needed.
121 if (!getBuiltInFunctionEmulator().isOutputEmpty())
122 {
123 sink << "// BEGIN: Generated code for built-in function emulation\n\n";
124 sink << "#define emu_precision\n\n";
125 getBuiltInFunctionEmulator().outputEmulatedFunctions(sink);
126 sink << "// END: Generated code for built-in function emulation\n\n";
127 }
128
129 // Declare gl_FragColor and glFragData as webgl_FragColor and webgl_FragData
130 // if it's core profile shaders and they are used.
131 if (getShaderType() == GL_FRAGMENT_SHADER)
132 {
133 const bool mayHaveESSL1SecondaryOutputs =
134 IsExtensionEnabled(getExtensionBehavior(), TExtension::EXT_blend_func_extended) &&
135 getShaderVersion() == 100;
136 const bool declareGLFragmentOutputs = IsGLSL130OrNewer(getOutputType());
137
138 bool hasGLFragColor = false;
139 bool hasGLFragData = false;
140 bool hasGLSecondaryFragColor = false;
141 bool hasGLSecondaryFragData = false;
142
143 for (const auto &outputVar : mOutputVariables)
144 {
145 if (declareGLFragmentOutputs)
146 {
147 if (outputVar.name == "gl_FragColor")
148 {
149 ASSERT(!hasGLFragColor);
150 hasGLFragColor = true;
151 continue;
152 }
153 else if (outputVar.name == "gl_FragData")
154 {
155 ASSERT(!hasGLFragData);
156 hasGLFragData = true;
157 continue;
158 }
159 }
160 if (mayHaveESSL1SecondaryOutputs)
161 {
162 if (outputVar.name == "gl_SecondaryFragColorEXT")
163 {
164 ASSERT(!hasGLSecondaryFragColor);
165 hasGLSecondaryFragColor = true;
166 continue;
167 }
168 else if (outputVar.name == "gl_SecondaryFragDataEXT")
169 {
170 ASSERT(!hasGLSecondaryFragData);
171 hasGLSecondaryFragData = true;
172 continue;
173 }
174 }
175 }
176 ASSERT(!((hasGLFragColor || hasGLSecondaryFragColor) &&
177 (hasGLFragData || hasGLSecondaryFragData)));
178 if (hasGLFragColor)
179 {
180 sink << "out vec4 webgl_FragColor;\n";
181 }
182 if (hasGLFragData)
183 {
184 sink << "out vec4 webgl_FragData[gl_MaxDrawBuffers];\n";
185 }
186 if (hasGLSecondaryFragColor)
187 {
188 sink << "out vec4 webgl_SecondaryFragColor;\n";
189 }
190 if (hasGLSecondaryFragData)
191 {
192 sink << "out vec4 webgl_SecondaryFragData[" << getResources().MaxDualSourceDrawBuffers
193 << "];\n";
194 }
195
196 EmitEarlyFragmentTestsGLSL(*this, sink);
197 }
198
199 if (getShaderType() == GL_COMPUTE_SHADER)
200 {
201 EmitWorkGroupSizeGLSL(*this, sink);
202 }
203
204 if (getShaderType() == GL_GEOMETRY_SHADER_EXT)
205 {
206 WriteGeometryShaderLayoutQualifiers(
207 sink, getGeometryShaderInputPrimitiveType(), getGeometryShaderInvocations(),
208 getGeometryShaderOutputPrimitiveType(), getGeometryShaderMaxVertices());
209 }
210
211 // Write translated shader.
212 TOutputGLSL outputGLSL(this, sink, compileOptions);
213
214 root->traverse(&outputGLSL);
215
216 return true;
217 }
218
shouldFlattenPragmaStdglInvariantAll()219 bool TranslatorGLSL::shouldFlattenPragmaStdglInvariantAll()
220 {
221 // Required when outputting to any GLSL version greater than 1.20, but since ANGLE doesn't
222 // translate to that version, return true for the next higher version.
223 return IsGLSL130OrNewer(getOutputType());
224 }
225
shouldCollectVariables(ShCompileOptions compileOptions)226 bool TranslatorGLSL::shouldCollectVariables(ShCompileOptions compileOptions)
227 {
228 return (compileOptions & SH_FLATTEN_PRAGMA_STDGL_INVARIANT_ALL) != 0 ||
229 TCompiler::shouldCollectVariables(compileOptions);
230 }
231
writeVersion(TIntermNode * root)232 void TranslatorGLSL::writeVersion(TIntermNode *root)
233 {
234 TVersionGLSL versionGLSL(getShaderType(), getPragma(), getOutputType());
235 root->traverse(&versionGLSL);
236 int version = versionGLSL.getVersion();
237 // We need to write version directive only if it is greater than 110.
238 // If there is no version directive in the shader, 110 is implied.
239 if (version > 110)
240 {
241 TInfoSinkBase &sink = getInfoSink().obj;
242 sink << "#version " << version << "\n";
243 }
244 }
245
writeExtensionBehavior(TIntermNode * root,ShCompileOptions compileOptions)246 void TranslatorGLSL::writeExtensionBehavior(TIntermNode *root, ShCompileOptions compileOptions)
247 {
248 bool usesTextureCubeMapArray = false;
249 bool usesTextureBuffer = false;
250
251 TInfoSinkBase &sink = getInfoSink().obj;
252 const TExtensionBehavior &extBehavior = getExtensionBehavior();
253 for (const auto &iter : extBehavior)
254 {
255 if (iter.second == EBhUndefined)
256 {
257 continue;
258 }
259
260 if (getOutputType() == SH_GLSL_COMPATIBILITY_OUTPUT)
261 {
262 // For GLSL output, we don't need to emit most extensions explicitly,
263 // but some we need to translate in GL compatibility profile.
264 if (iter.first == TExtension::EXT_shader_texture_lod)
265 {
266 sink << "#extension GL_ARB_shader_texture_lod : " << GetBehaviorString(iter.second)
267 << "\n";
268 }
269
270 if (iter.first == TExtension::EXT_draw_buffers)
271 {
272 sink << "#extension GL_ARB_draw_buffers : " << GetBehaviorString(iter.second)
273 << "\n";
274 }
275
276 if (iter.first == TExtension::EXT_geometry_shader ||
277 iter.first == TExtension::OES_geometry_shader)
278 {
279 sink << "#extension GL_ARB_geometry_shader4 : " << GetBehaviorString(iter.second)
280 << "\n";
281 }
282 }
283
284 const bool isMultiview =
285 (iter.first == TExtension::OVR_multiview) || (iter.first == TExtension::OVR_multiview2);
286 if (isMultiview)
287 {
288 // Only either OVR_multiview or OVR_multiview2 should be emitted.
289 if ((iter.first != TExtension::OVR_multiview) ||
290 !IsExtensionEnabled(extBehavior, TExtension::OVR_multiview2))
291 {
292 EmitMultiviewGLSL(*this, compileOptions, iter.first, iter.second, sink);
293 }
294 }
295
296 // Support ANGLE_texture_multisample extension on GLSL300
297 if (getShaderVersion() >= 300 && iter.first == TExtension::ANGLE_texture_multisample &&
298 getOutputType() < SH_GLSL_330_CORE_OUTPUT)
299 {
300 sink << "#extension GL_ARB_texture_multisample : " << GetBehaviorString(iter.second)
301 << "\n";
302 }
303
304 if ((iter.first == TExtension::OES_texture_cube_map_array ||
305 iter.first == TExtension::EXT_texture_cube_map_array) &&
306 (iter.second == EBhRequire || iter.second == EBhEnable))
307 {
308 usesTextureCubeMapArray = true;
309 }
310
311 if ((iter.first == TExtension::OES_texture_buffer ||
312 iter.first == TExtension::EXT_texture_buffer) &&
313 (iter.second == EBhRequire || iter.second == EBhEnable))
314 {
315 usesTextureBuffer = true;
316 }
317 }
318
319 // GLSL ES 3 explicit location qualifiers need to use an extension before GLSL 330
320 if (getShaderVersion() >= 300 && getOutputType() < SH_GLSL_330_CORE_OUTPUT &&
321 getShaderType() != GL_COMPUTE_SHADER)
322 {
323 sink << "#extension GL_ARB_explicit_attrib_location : require\n";
324 }
325
326 // Need to enable gpu_shader5 to have index constant sampler array indexing
327 if (getOutputType() != SH_ESSL_OUTPUT && getOutputType() < SH_GLSL_400_CORE_OUTPUT &&
328 getShaderVersion() == 100)
329 {
330 // Don't use "require" on to avoid breaking WebGL 1 on drivers that silently
331 // support index constant sampler array indexing, but don't have the extension or
332 // on drivers that don't have the extension at all as it would break WebGL 1 for
333 // some users.
334 sink << "#extension GL_ARB_gpu_shader5 : enable\n";
335 sink << "#extension GL_EXT_gpu_shader5 : enable\n";
336 }
337
338 if (usesTextureCubeMapArray)
339 {
340 if (getOutputType() >= SH_GLSL_COMPATIBILITY_OUTPUT &&
341 getOutputType() < SH_GLSL_400_CORE_OUTPUT)
342 {
343 sink << "#extension GL_ARB_texture_cube_map_array : enable\n";
344 }
345 else if (getOutputType() == SH_ESSL_OUTPUT && getShaderVersion() < 320)
346 {
347 sink << "#extension GL_OES_texture_cube_map_array : enable\n";
348 sink << "#extension GL_EXT_texture_cube_map_array : enable\n";
349 }
350 }
351
352 if (usesTextureBuffer)
353 {
354 if (getOutputType() >= SH_GLSL_COMPATIBILITY_OUTPUT &&
355 getOutputType() < SH_GLSL_400_CORE_OUTPUT)
356 {
357 sink << "#extension GL_ARB_texture_buffer_objects : enable\n";
358 }
359 else if (getOutputType() == SH_ESSL_OUTPUT && getShaderVersion() < 320)
360 {
361 sink << "#extension GL_OES_texture_buffer : enable\n";
362 sink << "#extension GL_EXT_texture_buffer : enable\n";
363 }
364 }
365
366 TExtensionGLSL extensionGLSL(getOutputType());
367 root->traverse(&extensionGLSL);
368
369 for (const auto &ext : extensionGLSL.getEnabledExtensions())
370 {
371 sink << "#extension " << ext << " : enable\n";
372 }
373 for (const auto &ext : extensionGLSL.getRequiredExtensions())
374 {
375 sink << "#extension " << ext << " : require\n";
376 }
377 }
378
conditionallyOutputInvariantDeclaration(const char * builtinVaryingName)379 void TranslatorGLSL::conditionallyOutputInvariantDeclaration(const char *builtinVaryingName)
380 {
381 if (isVaryingDefined(builtinVaryingName))
382 {
383 TInfoSinkBase &sink = getInfoSink().obj;
384 sink << "invariant " << builtinVaryingName << ";\n";
385 }
386 }
387
388 } // namespace sh
389