1 // 2 // Copyright (c) 2002-2013 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 "GLSLANG/ShaderLang.h" 8 9 #include <assert.h> 10 #include <math.h> 11 #include <stdio.h> 12 #include <stdlib.h> 13 #include <string.h> 14 #include <vector> 15 16 // 17 // Return codes from main. 18 // 19 enum TFailCode { 20 ESuccess = 0, 21 EFailUsage, 22 EFailCompile, 23 EFailCompilerCreate, 24 }; 25 26 static void usage(); 27 static ShShaderType FindShaderType(const char* fileName); 28 static bool CompileFile(char* fileName, ShHandle compiler, int compileOptions); 29 static void LogMsg(const char* msg, const char* name, const int num, const char* logName); 30 static void PrintActiveVariables(ShHandle compiler, ShShaderInfo varType); 31 32 // If NUM_SOURCE_STRINGS is set to a value > 1, the input file data is 33 // broken into that many chunks. 34 const unsigned int NUM_SOURCE_STRINGS = 2; 35 typedef std::vector<char*> ShaderSource; 36 static bool ReadShaderSource(const char* fileName, ShaderSource& source); 37 static void FreeShaderSource(ShaderSource& source); 38 39 // 40 // Set up the per compile resources 41 // 42 void GenerateResources(ShBuiltInResources* resources) 43 { 44 ShInitBuiltInResources(resources); 45 46 resources->MaxVertexAttribs = 8; 47 resources->MaxVertexUniformVectors = 128; 48 resources->MaxVaryingVectors = 8; 49 resources->MaxVertexTextureImageUnits = 0; 50 resources->MaxCombinedTextureImageUnits = 8; 51 resources->MaxTextureImageUnits = 8; 52 resources->MaxFragmentUniformVectors = 16; 53 resources->MaxDrawBuffers = 1; 54 55 resources->OES_standard_derivatives = 0; 56 resources->OES_EGL_image_external = 0; 57 } 58 59 int main(int argc, char* argv[]) 60 { 61 TFailCode failCode = ESuccess; 62 63 int compileOptions = 0; 64 int numCompiles = 0; 65 ShHandle vertexCompiler = 0; 66 ShHandle fragmentCompiler = 0; 67 char* buffer = 0; 68 size_t bufferLen = 0; 69 ShShaderSpec spec = SH_GLES2_SPEC; 70 ShShaderOutput output = SH_ESSL_OUTPUT; 71 72 ShInitialize(); 73 74 ShBuiltInResources resources; 75 GenerateResources(&resources); 76 77 argc--; 78 argv++; 79 for (; (argc >= 1) && (failCode == ESuccess); argc--, argv++) { 80 if (argv[0][0] == '-') { 81 switch (argv[0][1]) { 82 case 'i': compileOptions |= SH_INTERMEDIATE_TREE; break; 83 case 'o': compileOptions |= SH_OBJECT_CODE; break; 84 case 'u': compileOptions |= SH_VARIABLES; break; 85 case 'l': compileOptions |= SH_UNROLL_FOR_LOOP_WITH_INTEGER_INDEX; break; 86 case 'e': compileOptions |= SH_EMULATE_BUILT_IN_FUNCTIONS; break; 87 case 'd': compileOptions |= SH_DEPENDENCY_GRAPH; break; 88 case 't': compileOptions |= SH_TIMING_RESTRICTIONS; break; 89 case 's': 90 if (argv[0][2] == '=') { 91 switch (argv[0][3]) { 92 case 'e': spec = SH_GLES2_SPEC; break; 93 case 'w': spec = SH_WEBGL_SPEC; break; 94 case 'c': spec = SH_CSS_SHADERS_SPEC; break; 95 default: failCode = EFailUsage; 96 } 97 } else { 98 failCode = EFailUsage; 99 } 100 break; 101 case 'b': 102 if (argv[0][2] == '=') { 103 switch (argv[0][3]) { 104 case 'e': output = SH_ESSL_OUTPUT; break; 105 case 'g': output = SH_GLSL_OUTPUT; break; 106 case 'h': 107 if (argv[0][4] == '1' && argv[0][5] == '1') 108 { 109 output = SH_HLSL11_OUTPUT; 110 } 111 else 112 { 113 output = SH_HLSL9_OUTPUT; 114 } 115 break; 116 default: failCode = EFailUsage; 117 } 118 } else { 119 failCode = EFailUsage; 120 } 121 break; 122 case 'x': 123 if (argv[0][2] == '=') { 124 switch (argv[0][3]) { 125 case 'i': resources.OES_EGL_image_external = 1; break; 126 case 'd': resources.OES_standard_derivatives = 1; break; 127 case 'r': resources.ARB_texture_rectangle = 1; break; 128 case 'l': resources.EXT_shader_texture_lod = 1; break; 129 default: failCode = EFailUsage; 130 } 131 } else { 132 failCode = EFailUsage; 133 } 134 break; 135 default: failCode = EFailUsage; 136 } 137 } else { 138 ShHandle compiler = 0; 139 switch (FindShaderType(argv[0])) { 140 case SH_VERTEX_SHADER: 141 if (vertexCompiler == 0) 142 vertexCompiler = ShConstructCompiler( 143 SH_VERTEX_SHADER, spec, output, &resources); 144 compiler = vertexCompiler; 145 break; 146 case SH_FRAGMENT_SHADER: 147 if (fragmentCompiler == 0) 148 fragmentCompiler = ShConstructCompiler( 149 SH_FRAGMENT_SHADER, spec, output, &resources); 150 compiler = fragmentCompiler; 151 break; 152 default: break; 153 } 154 if (compiler) { 155 bool compiled = CompileFile(argv[0], compiler, compileOptions); 156 157 LogMsg("BEGIN", "COMPILER", numCompiles, "INFO LOG"); 158 ShGetInfo(compiler, SH_INFO_LOG_LENGTH, &bufferLen); 159 buffer = (char*) realloc(buffer, bufferLen * sizeof(char)); 160 ShGetInfoLog(compiler, buffer); 161 puts(buffer); 162 LogMsg("END", "COMPILER", numCompiles, "INFO LOG"); 163 printf("\n\n"); 164 165 if (compiled && (compileOptions & SH_OBJECT_CODE)) { 166 LogMsg("BEGIN", "COMPILER", numCompiles, "OBJ CODE"); 167 ShGetInfo(compiler, SH_OBJECT_CODE_LENGTH, &bufferLen); 168 buffer = (char*) realloc(buffer, bufferLen * sizeof(char)); 169 ShGetObjectCode(compiler, buffer); 170 puts(buffer); 171 LogMsg("END", "COMPILER", numCompiles, "OBJ CODE"); 172 printf("\n\n"); 173 } 174 if (compiled && (compileOptions & SH_VARIABLES)) { 175 LogMsg("BEGIN", "COMPILER", numCompiles, "ACTIVE ATTRIBS"); 176 PrintActiveVariables(compiler, SH_ACTIVE_ATTRIBUTES); 177 LogMsg("END", "COMPILER", numCompiles, "ACTIVE ATTRIBS"); 178 printf("\n\n"); 179 180 LogMsg("BEGIN", "COMPILER", numCompiles, "ACTIVE UNIFORMS"); 181 PrintActiveVariables(compiler, SH_ACTIVE_UNIFORMS); 182 LogMsg("END", "COMPILER", numCompiles, "ACTIVE UNIFORMS"); 183 printf("\n\n"); 184 } 185 if (!compiled) 186 failCode = EFailCompile; 187 ++numCompiles; 188 } else { 189 failCode = EFailCompilerCreate; 190 } 191 } 192 } 193 194 if ((vertexCompiler == 0) && (fragmentCompiler == 0)) 195 failCode = EFailUsage; 196 if (failCode == EFailUsage) 197 usage(); 198 199 if (vertexCompiler) 200 ShDestruct(vertexCompiler); 201 if (fragmentCompiler) 202 ShDestruct(fragmentCompiler); 203 if (buffer) 204 free(buffer); 205 ShFinalize(); 206 207 return failCode; 208 } 209 210 // 211 // print usage to stdout 212 // 213 void usage() 214 { 215 printf("Usage: translate [-i -m -o -u -l -e -b=e -b=g -b=h -x=i -x=d] file1 file2 ...\n" 216 "Where: filename : filename ending in .frag or .vert\n" 217 " -i : print intermediate tree\n" 218 " -m : map long variable names\n" 219 " -o : print translated code\n" 220 " -u : print active attribs and uniforms\n" 221 " -l : unroll for-loops with integer indices\n" 222 " -e : emulate certain built-in functions (workaround for driver bugs)\n" 223 " -t : enforce experimental timing restrictions\n" 224 " -d : print dependency graph used to enforce timing restrictions\n" 225 " -s=e : use GLES2 spec (this is by default)\n" 226 " -s=w : use WebGL spec\n" 227 " -s=c : use CSS Shaders spec\n" 228 " -b=e : output GLSL ES code (this is by default)\n" 229 " -b=g : output GLSL code\n" 230 " -b=h9 : output HLSL9 code\n" 231 " -b=h11 : output HLSL11 code\n" 232 " -x=i : enable GL_OES_EGL_image_external\n" 233 " -x=d : enable GL_OES_EGL_standard_derivatives\n" 234 " -x=r : enable ARB_texture_rectangle\n" 235 " -x=l : enable EXT_shader_texture_lod\n"); 236 } 237 238 // 239 // Deduce the shader type from the filename. Files must end in one of the 240 // following extensions: 241 // 242 // .frag* = fragment shader 243 // .vert* = vertex shader 244 // 245 ShShaderType FindShaderType(const char* fileName) 246 { 247 assert(fileName); 248 249 const char* ext = strrchr(fileName, '.'); 250 251 if (ext && strcmp(ext, ".sl") == 0) 252 for (; ext > fileName && ext[0] != '.'; ext--); 253 254 ext = strrchr(fileName, '.'); 255 if (ext) { 256 if (strncmp(ext, ".frag", 4) == 0) return SH_FRAGMENT_SHADER; 257 if (strncmp(ext, ".vert", 4) == 0) return SH_VERTEX_SHADER; 258 } 259 260 return SH_FRAGMENT_SHADER; 261 } 262 263 // 264 // Read a file's data into a string, and compile it using ShCompile 265 // 266 bool CompileFile(char* fileName, ShHandle compiler, int compileOptions) 267 { 268 ShaderSource source; 269 if (!ReadShaderSource(fileName, source)) 270 return false; 271 272 int ret = ShCompile(compiler, &source[0], source.size(), compileOptions); 273 274 FreeShaderSource(source); 275 return ret ? true : false; 276 } 277 278 void LogMsg(const char* msg, const char* name, const int num, const char* logName) 279 { 280 printf("#### %s %s %d %s ####\n", msg, name, num, logName); 281 } 282 283 void PrintActiveVariables(ShHandle compiler, ShShaderInfo varType) 284 { 285 size_t nameSize = 0; 286 switch (varType) { 287 case SH_ACTIVE_ATTRIBUTES: 288 ShGetInfo(compiler, SH_ACTIVE_ATTRIBUTE_MAX_LENGTH, &nameSize); 289 break; 290 case SH_ACTIVE_UNIFORMS: 291 ShGetInfo(compiler, SH_ACTIVE_UNIFORM_MAX_LENGTH, &nameSize); 292 break; 293 default: assert(0); 294 } 295 if (nameSize <= 1) return; 296 char* name = new char[nameSize]; 297 298 size_t activeVars = 0; 299 int size = 0; 300 ShDataType type = SH_NONE; 301 ShPrecisionType precision = SH_PRECISION_UNDEFINED; 302 int staticUse = 0; 303 const char* typeName = NULL; 304 ShGetInfo(compiler, varType, &activeVars); 305 for (size_t i = 0; i < activeVars; ++i) { 306 switch (varType) { 307 case SH_ACTIVE_ATTRIBUTES: 308 ShGetVariableInfo(compiler, SH_ACTIVE_ATTRIBUTES, static_cast<int>(i), NULL, &size, &type, &precision, &staticUse, name, NULL); 309 break; 310 case SH_ACTIVE_UNIFORMS: 311 ShGetVariableInfo(compiler, SH_ACTIVE_UNIFORMS, static_cast<int>(i), NULL, &size, &type, &precision, &staticUse, name, NULL); 312 break; 313 default: assert(0); 314 } 315 switch (type) { 316 case SH_FLOAT: typeName = "GL_FLOAT"; break; 317 case SH_FLOAT_VEC2: typeName = "GL_FLOAT_VEC2"; break; 318 case SH_FLOAT_VEC3: typeName = "GL_FLOAT_VEC3"; break; 319 case SH_FLOAT_VEC4: typeName = "GL_FLOAT_VEC4"; break; 320 case SH_INT: typeName = "GL_INT"; break; 321 case SH_INT_VEC2: typeName = "GL_INT_VEC2"; break; 322 case SH_INT_VEC3: typeName = "GL_INT_VEC3"; break; 323 case SH_INT_VEC4: typeName = "GL_INT_VEC4"; break; 324 case SH_UNSIGNED_INT: typeName = "GL_UNSIGNED_INT"; break; 325 case SH_UNSIGNED_INT_VEC2: typeName = "GL_UNSIGNED_INT_VEC2"; break; 326 case SH_UNSIGNED_INT_VEC3: typeName = "GL_UNSIGNED_INT_VEC3"; break; 327 case SH_UNSIGNED_INT_VEC4: typeName = "GL_UNSIGNED_INT_VEC4"; break; 328 case SH_BOOL: typeName = "GL_BOOL"; break; 329 case SH_BOOL_VEC2: typeName = "GL_BOOL_VEC2"; break; 330 case SH_BOOL_VEC3: typeName = "GL_BOOL_VEC3"; break; 331 case SH_BOOL_VEC4: typeName = "GL_BOOL_VEC4"; break; 332 case SH_FLOAT_MAT2: typeName = "GL_FLOAT_MAT2"; break; 333 case SH_FLOAT_MAT3: typeName = "GL_FLOAT_MAT3"; break; 334 case SH_FLOAT_MAT4: typeName = "GL_FLOAT_MAT4"; break; 335 case SH_FLOAT_MAT2x3: typeName = "GL_FLOAT_MAT2x3"; break; 336 case SH_FLOAT_MAT3x2: typeName = "GL_FLOAT_MAT3x2"; break; 337 case SH_FLOAT_MAT4x2: typeName = "GL_FLOAT_MAT4x2"; break; 338 case SH_FLOAT_MAT2x4: typeName = "GL_FLOAT_MAT2x4"; break; 339 case SH_FLOAT_MAT3x4: typeName = "GL_FLOAT_MAT3x4"; break; 340 case SH_FLOAT_MAT4x3: typeName = "GL_FLOAT_MAT4x3"; break; 341 case SH_SAMPLER_2D: typeName = "GL_SAMPLER_2D"; break; 342 case SH_SAMPLER_CUBE: typeName = "GL_SAMPLER_CUBE"; break; 343 case SH_SAMPLER_EXTERNAL_OES: typeName = "GL_SAMPLER_EXTERNAL_OES"; break; 344 default: assert(0); 345 } 346 printf("%lu: name:%s type:%s size:%d\n", i, name, typeName, size); 347 } 348 delete [] name; 349 } 350 351 static bool ReadShaderSource(const char* fileName, ShaderSource& source) { 352 FILE* in = fopen(fileName, "rb"); 353 if (!in) { 354 printf("Error: unable to open input file: %s\n", fileName); 355 return false; 356 } 357 358 // Obtain file size. 359 fseek(in, 0, SEEK_END); 360 size_t count = ftell(in); 361 rewind(in); 362 363 int len = (int)ceil((float)count / (float)NUM_SOURCE_STRINGS); 364 source.reserve(NUM_SOURCE_STRINGS); 365 // Notice the usage of do-while instead of a while loop here. 366 // It is there to handle empty files in which case a single empty 367 // string is added to vector. 368 do { 369 char* data = new char[len + 1]; 370 size_t nread = fread(data, 1, len, in); 371 data[nread] = '\0'; 372 source.push_back(data); 373 374 count -= nread; 375 } while (count > 0); 376 377 fclose(in); 378 return true; 379 } 380 381 static void FreeShaderSource(ShaderSource& source) { 382 for (ShaderSource::size_type i = 0; i < source.size(); ++i) { 383 delete [] source[i]; 384 } 385 source.clear(); 386 } 387 388
