src/third_party/angle/samples/translator/translator.cpp

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