
git-svn-id: https://cvs.khronos.org/svn/repos/ogl/trunk/ecosystem/public/sdk/tools/glslang@22939 e7fa87d3-cd2b-0410-9028-fcbf551c1848
555 lines
16 KiB
C++
555 lines
16 KiB
C++
//
|
|
//Copyright (C) 2002-2005 3Dlabs Inc. Ltd.
|
|
//Copyright (C) 2013 LunarG, Inc.
|
|
//
|
|
//All rights reserved.
|
|
//
|
|
//Redistribution and use in source and binary forms, with or without
|
|
//modification, are permitted provided that the following conditions
|
|
//are met:
|
|
//
|
|
// Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
//
|
|
// Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following
|
|
// disclaimer in the documentation and/or other materials provided
|
|
// with the distribution.
|
|
//
|
|
// Neither the name of 3Dlabs Inc. Ltd. nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
//"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
//LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
//FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
//COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
//INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
//BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
//CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
//ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
//POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
#include "Worklist.h"
|
|
#include "./../glslang/Include/ShHandle.h"
|
|
#include "./../glslang/Public/ShaderLang.h"
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <math.h>
|
|
|
|
#include "osinclude.h"
|
|
|
|
extern "C" {
|
|
SH_IMPORT_EXPORT void ShOutputHtml();
|
|
}
|
|
|
|
// Command-line options
|
|
enum TOptions {
|
|
EOptionNone = 0x000,
|
|
EOptionIntermediate = 0x001,
|
|
EOptionSuppressInfolog = 0x002,
|
|
EOptionMemoryLeakMode = 0x004,
|
|
EOptionRelaxedErrors = 0x008,
|
|
EOptionGiveWarnings = 0x010,
|
|
EOptionsLinkProgram = 0x020,
|
|
EOptionMultiThreaded = 0x040,
|
|
};
|
|
|
|
//
|
|
// Return codes from main.
|
|
//
|
|
enum TFailCode {
|
|
ESuccess = 0,
|
|
EFailUsage,
|
|
EFailCompile,
|
|
EFailLink,
|
|
EFailCompilerCreate,
|
|
EFailThreadCreate,
|
|
EFailLinkerCreate
|
|
};
|
|
|
|
//
|
|
// Just placeholders for testing purposes. The stand-alone environment
|
|
// can't actually do a full link without something specifying real
|
|
// attribute bindings.
|
|
//
|
|
ShBinding FixedAttributeBindings[] = {
|
|
{ "gl_Vertex", 15 },
|
|
{ "gl_Color", 10 },
|
|
{ "gl_Normal", 7 },
|
|
};
|
|
|
|
ShBindingTable FixedAttributeTable = { 3, FixedAttributeBindings };
|
|
|
|
EShLanguage FindLanguage(const std::string& name);
|
|
bool CompileFile(const char *fileName, ShHandle, int options, const TBuiltInResource*);
|
|
void usage();
|
|
void FreeFileData(char **data);
|
|
char** ReadFileData(const char *fileName);
|
|
void InfoLogMsg(const char* msg, const char* name, const int num);
|
|
|
|
// Use to test breaking a single shader file into multiple strings.
|
|
int NumShaderStrings = 1;
|
|
|
|
//
|
|
// Set up the per compile resources
|
|
//
|
|
void GenerateResources(TBuiltInResource& resources)
|
|
{
|
|
resources.maxLights = 32;
|
|
resources.maxClipPlanes = 6;
|
|
resources.maxTextureUnits = 32;
|
|
resources.maxTextureCoords = 32;
|
|
resources.maxVertexAttribs = 64;
|
|
resources.maxVertexUniformComponents = 4096;
|
|
resources.maxVaryingFloats = 64;
|
|
resources.maxVertexTextureImageUnits = 32;
|
|
resources.maxCombinedTextureImageUnits = 32;
|
|
resources.maxTextureImageUnits = 32;
|
|
resources.maxFragmentUniformComponents = 4096;
|
|
resources.maxDrawBuffers = 32;
|
|
resources.maxVertexUniformVectors = 128;
|
|
resources.maxVaryingVectors = 8;
|
|
resources.maxFragmentUniformVectors = 16;
|
|
resources.maxVertexOutputVectors = 16;
|
|
resources.maxFragmentInputVectors = 15;
|
|
resources.minProgramTexelOffset = -8;
|
|
resources.maxProgramTexelOffset = 7;
|
|
}
|
|
|
|
// thread-safe list of shaders to asynchronously grab and compile
|
|
glslang::TWorklist Worklist;
|
|
|
|
// array of unique places to leave the shader names and infologs for the asynchronous compiles
|
|
glslang::TWorkItem **Work = 0;
|
|
int NumWorkItems = 0;
|
|
|
|
int Options = 0;
|
|
bool Delay = false;
|
|
const char* ExecutableName;
|
|
|
|
bool ProcessArguments(int argc, char* argv[])
|
|
{
|
|
ExecutableName = argv[0];
|
|
NumWorkItems = argc; // will include some empties where the '-' options were, but it doesn't matter, they'll be 0
|
|
Work = new glslang::TWorkItem*[NumWorkItems];
|
|
Work[0] = 0;
|
|
|
|
argc--;
|
|
argv++;
|
|
for (; argc >= 1; argc--, argv++) {
|
|
if (argv[0][0] == '-') {
|
|
Work[argc] = 0;
|
|
switch (argv[0][1]) {
|
|
case 'd':
|
|
Delay = true;
|
|
break;
|
|
case 'i':
|
|
Options |= EOptionIntermediate;
|
|
break;
|
|
case 'l':
|
|
Options |= EOptionsLinkProgram;
|
|
break;
|
|
case 'm':
|
|
Options |= EOptionMemoryLeakMode;
|
|
break;
|
|
case 'r':
|
|
Options |= EOptionRelaxedErrors;
|
|
break;
|
|
case 's':
|
|
Options |= EOptionSuppressInfolog;
|
|
break;
|
|
case 't':
|
|
#ifdef _WIN32
|
|
Options |= EOptionMultiThreaded;
|
|
#endif
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
} else {
|
|
Work[argc] = new glslang::TWorkItem(std::string(argv[0]));
|
|
Worklist.add(Work[argc]);
|
|
}
|
|
}
|
|
|
|
if (Worklist.empty())
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
// Thread entry point, for non-linking asynchronous mode.
|
|
unsigned int
|
|
#ifdef _WIN32
|
|
__stdcall
|
|
#endif
|
|
CompileShaders(void*)
|
|
{
|
|
glslang::TWorkItem* workItem;
|
|
while (Worklist.remove(workItem)) {
|
|
ShHandle compiler = ShConstructCompiler(FindLanguage(workItem->name), Options);
|
|
if (compiler == 0)
|
|
return false;
|
|
|
|
TBuiltInResource resources;
|
|
GenerateResources(resources);
|
|
CompileFile(workItem->name.c_str(), compiler, Options, &resources);
|
|
|
|
if (! (Options & EOptionSuppressInfolog))
|
|
workItem->results = ShGetInfoLog(compiler);
|
|
|
|
ShDestruct(compiler);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// For linking mode: Will independently parse each item in the worklist, but then put them
|
|
// in the same program and link them together.
|
|
//
|
|
// Uses the new C++ interface instead of the old handle-based interface.
|
|
//
|
|
void CompileAndLinkShaders()
|
|
{
|
|
// keep track of what to free
|
|
std::list<glslang::TShader*> shaders;
|
|
|
|
EShMessages messages = EShMsgDefault;
|
|
if (Options & EOptionRelaxedErrors)
|
|
messages = (EShMessages)(messages | EShMsgRelaxedErrors);
|
|
if (Options & EOptionIntermediate)
|
|
messages = (EShMessages)(messages | EShMsgAST);
|
|
|
|
TBuiltInResource resources;
|
|
GenerateResources(resources);
|
|
|
|
//
|
|
// Per-shader processing...
|
|
//
|
|
|
|
glslang::TProgram program;
|
|
glslang::TWorkItem* workItem;
|
|
while (Worklist.remove(workItem)) {
|
|
EShLanguage stage = FindLanguage(workItem->name);
|
|
glslang::TShader* shader = new glslang::TShader(stage);
|
|
shaders.push_back(shader);
|
|
|
|
char** shaderStrings = ReadFileData(workItem->name.c_str());
|
|
if (! shaderStrings) {
|
|
usage();
|
|
return;
|
|
}
|
|
|
|
shader->setStrings(shaderStrings, 1);
|
|
|
|
shader->parse(&resources, 100, false, messages);
|
|
|
|
program.addShader(shader);
|
|
|
|
if (! (Options & EOptionSuppressInfolog)) {
|
|
puts(workItem->name.c_str());
|
|
puts(shader->getInfoLog());
|
|
puts(shader->getInfoDebugLog());
|
|
}
|
|
|
|
FreeFileData(shaderStrings);
|
|
}
|
|
|
|
//
|
|
// Program-level processing...
|
|
//
|
|
|
|
program.link(messages);
|
|
if (! (Options & EOptionSuppressInfolog)) {
|
|
puts(program.getInfoLog());
|
|
puts(program.getInfoDebugLog());
|
|
}
|
|
|
|
// free everything up
|
|
while (shaders.size() > 0) {
|
|
delete shaders.back();
|
|
shaders.pop_back();
|
|
}
|
|
|
|
// TODO: memory: for each compile, need a GetThreadPoolAllocator().pop();
|
|
}
|
|
|
|
int C_DECL main(int argc, char* argv[])
|
|
{
|
|
bool compileFailed = false;
|
|
bool linkFailed = false;
|
|
|
|
// Init for front-end proper
|
|
ShInitialize();
|
|
|
|
// Init for standalone
|
|
glslang::InitGlobalLock();
|
|
|
|
if (! ProcessArguments(argc, argv)) {
|
|
usage();
|
|
return EFailUsage;
|
|
}
|
|
|
|
//
|
|
// Two modes:
|
|
// 1) linking all arguments together, single-threaded, new C++ interface
|
|
// 2) independent arguments, can be tackled by multiple asynchronous threads, for testing thread safety, using the old handle interface
|
|
//
|
|
if (Options & EOptionsLinkProgram)
|
|
CompileAndLinkShaders();
|
|
else {
|
|
bool printShaderNames = Worklist.size() > 1;
|
|
|
|
if (Options & EOptionMultiThreaded) {
|
|
const int NumThreads = 16;
|
|
void* threads[NumThreads];
|
|
for (int t = 0; t < NumThreads; ++t) {
|
|
threads[t] = glslang::OS_CreateThread(&CompileShaders);
|
|
if (! threads[t]) {
|
|
printf("Failed to create thread\n");
|
|
return EFailThreadCreate;
|
|
}
|
|
}
|
|
glslang::OS_WaitForAllThreads(threads, NumThreads);
|
|
} else {
|
|
if (! CompileShaders(0))
|
|
compileFailed = true;
|
|
}
|
|
|
|
// Print out all the resulting infologs
|
|
for (int w = 0; w < NumWorkItems; ++w) {
|
|
if (Work[w]) {
|
|
if (printShaderNames)
|
|
puts(Work[w]->name.c_str());
|
|
puts(Work[w]->results.c_str());
|
|
delete Work[w];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Delay)
|
|
glslang::OS_Sleep(1000000);
|
|
|
|
if (compileFailed)
|
|
return EFailCompile;
|
|
if (linkFailed)
|
|
return EFailLink;
|
|
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Deduce the language from the filename. Files must end in one of the
|
|
// following extensions:
|
|
//
|
|
// .vert = vertex
|
|
// .tesc = tessellation control
|
|
// .tese = tessellation evaluation
|
|
// .geom = geometry
|
|
// .frag = fragment
|
|
// .comp = compute
|
|
//
|
|
EShLanguage FindLanguage(const std::string& name)
|
|
{
|
|
size_t ext = name.rfind('.');
|
|
if (ext == std::string::npos) {
|
|
usage();
|
|
return EShLangVertex;
|
|
}
|
|
|
|
std::string suffix = name.substr(ext + 1, std::string::npos);
|
|
if (suffix == "vert")
|
|
return EShLangVertex;
|
|
else if (suffix == "tesc")
|
|
return EShLangTessControl;
|
|
else if (suffix == "tese")
|
|
return EShLangTessEvaluation;
|
|
else if (suffix == "geom")
|
|
return EShLangGeometry;
|
|
else if (suffix == "frag")
|
|
return EShLangFragment;
|
|
else if (suffix == "comp")
|
|
return EShLangCompute;
|
|
|
|
usage();
|
|
return EShLangVertex;
|
|
}
|
|
|
|
//
|
|
// Read a file's data into a string, and compile it using the old interface ShCompile,
|
|
// for non-linkable results.
|
|
//
|
|
bool CompileFile(const char *fileName, ShHandle compiler, int Options, const TBuiltInResource* resources)
|
|
{
|
|
int ret;
|
|
char** shaderStrings = ReadFileData(fileName);
|
|
if (! shaderStrings) {
|
|
usage();
|
|
return false;
|
|
}
|
|
|
|
int* lengths = new int[NumShaderStrings];
|
|
|
|
// move to length-based strings, rather than null-terminated strings
|
|
for (int s = 0; s < NumShaderStrings; ++s)
|
|
lengths[s] = strlen(shaderStrings[s]);
|
|
|
|
if (! shaderStrings)
|
|
return false;
|
|
|
|
EShMessages messages = EShMsgDefault;
|
|
if (Options & EOptionRelaxedErrors)
|
|
messages = (EShMessages)(messages | EShMsgRelaxedErrors);
|
|
if (Options & EOptionIntermediate)
|
|
messages = (EShMessages)(messages | EShMsgAST);
|
|
|
|
for (int i = 0; i < ((Options & EOptionMemoryLeakMode) ? 100 : 1); ++i) {
|
|
for (int j = 0; j < ((Options & EOptionMemoryLeakMode) ? 100 : 1); ++j) {
|
|
//ret = ShCompile(compiler, shaderStrings, NumShaderStrings, lengths, EShOptNone, resources, Options, 100, false, messages);
|
|
ret = ShCompile(compiler, shaderStrings, NumShaderStrings, 0, EShOptNone, resources, Options, 100, false, messages);
|
|
//const char* multi[4] = { "# ve", "rsion", " 300 e", "s" };
|
|
//const char* multi[7] = { "/", "/", "\\", "\n", "\n", "#", "version 300 es" };
|
|
//ret = ShCompile(compiler, multi, 4, 0, EShOptNone, resources, Options, 100, false, messages);
|
|
}
|
|
|
|
if (Options & EOptionMemoryLeakMode)
|
|
glslang::OS_DumpMemoryCounters();
|
|
}
|
|
|
|
delete [] lengths;
|
|
FreeFileData(shaderStrings);
|
|
|
|
return ret ? true : false;
|
|
}
|
|
|
|
//
|
|
// print usage to stdout
|
|
//
|
|
void usage()
|
|
{
|
|
printf("Usage: glslangValidator [ options ] filename\n"
|
|
"Where: filename is a name ending in\n"
|
|
" .vert for a vertex shader\n"
|
|
" .tesc for a tessellation control shader\n"
|
|
" .tese for a tessellation evaluation shader\n"
|
|
" .geom for a geometry shader\n"
|
|
" .frag for a fragment shader\n"
|
|
" .comp for a compute shader\n\n"
|
|
"Compilation warnings and errors will be printed to stdout.\n"
|
|
"To get other information, use one of the following options:\n"
|
|
"-i: intermediate tree (glslang AST) is printed out\n"
|
|
"-d: delay exit\n"
|
|
"-l: link validation of all input files\n"
|
|
"-m: memory leak mode\n"
|
|
"-r: relaxed semantic error-checking mode\n"
|
|
"-s: silent mode\n"
|
|
"-t: multi-threaded mode\n");
|
|
}
|
|
|
|
#ifndef _WIN32
|
|
|
|
#include <errno.h>
|
|
|
|
int fopen_s(
|
|
FILE** pFile,
|
|
const char *filename,
|
|
const char *mode
|
|
)
|
|
{
|
|
if (!pFile || !filename || !mode) {
|
|
return EINVAL;
|
|
}
|
|
|
|
FILE* f = fopen(filename, mode);
|
|
if (! f) {
|
|
if (errno != 0) {
|
|
return errno;
|
|
} else {
|
|
return ENOENT;
|
|
}
|
|
}
|
|
*pFile = f;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
//
|
|
// Malloc a string of sufficient size and read a string into it.
|
|
//
|
|
char** ReadFileData(const char *fileName)
|
|
{
|
|
FILE *in;
|
|
int errorCode = fopen_s(&in, fileName, "r");
|
|
char *fdata;
|
|
int count = 0;
|
|
const int maxSourceStrings = 5;
|
|
char** return_data = (char**)malloc(maxSourceStrings+1);
|
|
|
|
//return_data[MAX_SOURCE_STRINGS]=NULL;
|
|
if (errorCode) {
|
|
printf("Error: unable to open input file: %s\n", fileName);
|
|
return 0;
|
|
}
|
|
|
|
while (fgetc(in) != EOF)
|
|
count++;
|
|
|
|
fseek(in, 0, SEEK_SET);
|
|
|
|
|
|
if (!(fdata = (char *)malloc(count+2))) {
|
|
printf("Error allocating memory\n");
|
|
return 0;
|
|
}
|
|
if (fread(fdata,1,count, in)!=count) {
|
|
printf("Error reading input file: %s\n", fileName);
|
|
return 0;
|
|
}
|
|
fdata[count] = '\0';
|
|
fclose(in);
|
|
if(count==0){
|
|
return_data[0]=(char*)malloc(count+2);
|
|
return_data[0][0]='\0';
|
|
NumShaderStrings=0;
|
|
return return_data;
|
|
}
|
|
|
|
int len = (int)(ceil)((float)count/(float)NumShaderStrings);
|
|
int ptr_len=0,i=0;
|
|
while(count>0){
|
|
return_data[i]=(char*)malloc(len+2);
|
|
memcpy(return_data[i],fdata+ptr_len,len);
|
|
return_data[i][len]='\0';
|
|
count-=(len);
|
|
ptr_len+=(len);
|
|
if(count<len){
|
|
if(count==0){
|
|
NumShaderStrings=(i+1);
|
|
break;
|
|
}
|
|
len = count;
|
|
}
|
|
++i;
|
|
}
|
|
return return_data;
|
|
}
|
|
|
|
void FreeFileData(char **data)
|
|
{
|
|
for(int i=0;i<NumShaderStrings;i++)
|
|
free(data[i]);
|
|
}
|
|
|
|
void InfoLogMsg(const char* msg, const char* name, const int num)
|
|
{
|
|
printf(num >= 0 ? "#### %s %s %d INFO LOG ####\n" :
|
|
"#### %s %s INFO LOG ####\n", msg, name, num);
|
|
}
|