e95ecc54fa
Also fix issue where the keyword "shared" conflicts with the layout qualifier identifier "shared" by allowing the keyword in the layout qualifier identifier list. git-svn-id: https://cvs.khronos.org/svn/repos/ogl/trunk/ecosystem/public/sdk/tools/glslang@19948 e7fa87d3-cd2b-0410-9028-fcbf551c1848
363 lines
9.8 KiB
C++
363 lines
9.8 KiB
C++
//
|
|
//Copyright (C) 2002-2005 3Dlabs Inc. Ltd.
|
|
//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 "./../glslang/Include/ShHandle.h"
|
|
#include "./../glslang/Public/ShaderLang.h"
|
|
#include <string.h>
|
|
#include <math.h>
|
|
|
|
#ifdef _WIN32
|
|
#include <windows.h>
|
|
#include <psapi.h>
|
|
#endif
|
|
|
|
extern "C" {
|
|
SH_IMPORT_EXPORT void ShOutputHtml();
|
|
}
|
|
|
|
//#define MEASURE_MEMORY
|
|
|
|
//
|
|
// Return codes from main.
|
|
//
|
|
enum TFailCode {
|
|
ESuccess = 0,
|
|
EFailUsage,
|
|
EFailCompile,
|
|
EFailLink,
|
|
EFailCompilerCreate,
|
|
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 };
|
|
|
|
static EShLanguage FindLanguage(char *lang);
|
|
bool CompileFile(char *fileName, ShHandle, int, const TBuiltInResource*);
|
|
void usage();
|
|
void FreeFileData(char **data);
|
|
char** ReadFileData(char *fileName);
|
|
void InfoLogMsg(char* msg, const char* name, const int num);
|
|
int ShOutputMultipleStrings(char ** );
|
|
//Added to accomodate the multiple strings.
|
|
int OutputMultipleStrings = 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;
|
|
}
|
|
|
|
int C_DECL main(int argc, char* argv[])
|
|
{
|
|
bool delay = false;
|
|
int numCompilers = 0;
|
|
bool compileFailed = false;
|
|
bool linkFailed = false;
|
|
int debugOptions = 0;
|
|
int i;
|
|
|
|
ShHandle linker = 0;
|
|
ShHandle uniformMap = 0;
|
|
ShHandle compilers[EShLangCount];
|
|
|
|
ShInitialize();
|
|
|
|
#ifdef _WIN32
|
|
__try {
|
|
#endif
|
|
argc--;
|
|
argv++;
|
|
for (; argc >= 1; argc--, argv++) {
|
|
if (argv[0][0] == '-' || argv[0][0] == '/') {
|
|
switch (argv[0][1]) {
|
|
case 'd': delay = true; break;
|
|
|
|
#ifdef MEASURE_MEMORY
|
|
case 'i': break;
|
|
case 'a': break;
|
|
case 'h': break;
|
|
#else
|
|
case 'i': debugOptions |= EDebugOpIntermediate; break;
|
|
case 'a': debugOptions |= EDebugOpAssembly; break;
|
|
#endif
|
|
case 'c': if(!ShOutputMultipleStrings(++argv))
|
|
return EFailUsage;
|
|
--argc; break;
|
|
case 'm': debugOptions |= EDebugOpLinkMaps; break;
|
|
default: usage(); return EFailUsage;
|
|
}
|
|
} else {
|
|
compilers[numCompilers] = ShConstructCompiler(FindLanguage(argv[0]), debugOptions);
|
|
if (compilers[numCompilers] == 0)
|
|
return EFailCompilerCreate;
|
|
++numCompilers;
|
|
|
|
TBuiltInResource resources;
|
|
GenerateResources(resources);
|
|
if (! CompileFile(argv[0], compilers[numCompilers-1], debugOptions, &resources))
|
|
compileFailed = true;
|
|
}
|
|
}
|
|
|
|
if (!numCompilers) {
|
|
usage();
|
|
return EFailUsage;
|
|
}
|
|
|
|
linker = ShConstructLinker(EShExVertexFragment, debugOptions);
|
|
if (linker == 0)
|
|
return EFailLinkerCreate;
|
|
|
|
uniformMap = ShConstructUniformMap();
|
|
if (uniformMap == 0)
|
|
return EFailLinkerCreate;
|
|
|
|
if (numCompilers > 0) {
|
|
ShSetFixedAttributeBindings(linker, &FixedAttributeTable);
|
|
if (! ShLink(linker, compilers, numCompilers, uniformMap, 0, 0))
|
|
linkFailed = true;
|
|
}
|
|
|
|
for (i = 0; i < numCompilers; ++i) {
|
|
InfoLogMsg("BEGIN", "COMPILER", i);
|
|
puts(ShGetInfoLog(compilers[i]));
|
|
InfoLogMsg("END", "COMPILER", i);
|
|
}
|
|
|
|
InfoLogMsg("BEGIN", "LINKER", -1);
|
|
puts(ShGetInfoLog(linker));
|
|
InfoLogMsg("END", "LINKER", -1);
|
|
|
|
#ifdef _WIN32
|
|
} __finally {
|
|
#endif
|
|
for (i = 0; i < numCompilers; ++i)
|
|
ShDestruct(compilers[i]);
|
|
|
|
ShDestruct(linker);
|
|
ShDestruct(uniformMap);
|
|
|
|
#ifdef _WIN32
|
|
if (delay)
|
|
Sleep(1000000);
|
|
|
|
}
|
|
#endif
|
|
|
|
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:
|
|
//
|
|
// .frag* = fragment programs
|
|
// .vert* = vertex programs
|
|
//
|
|
static EShLanguage FindLanguage(char *name)
|
|
{
|
|
if (!name)
|
|
return EShLangVertex;
|
|
|
|
char *ext = strrchr(name, '.');
|
|
|
|
if (ext && strcmp(ext, ".sl") == 0)
|
|
for (; ext > name && ext[0] != '.'; ext--);
|
|
|
|
if (ext = strrchr(name, '.')) {
|
|
if (strncmp(ext, ".frag", 4) == 0) return EShLangFragment;
|
|
}
|
|
|
|
return EShLangVertex;
|
|
}
|
|
|
|
|
|
//
|
|
// Read a file's data into a string, and compile it using ShCompile
|
|
//
|
|
bool CompileFile(char *fileName, ShHandle compiler, int debugOptions, const TBuiltInResource *resources)
|
|
{
|
|
int ret;
|
|
char **data = ReadFileData(fileName);
|
|
|
|
#ifdef MEASURE_MEMORY
|
|
PROCESS_MEMORY_COUNTERS counters;
|
|
#endif
|
|
|
|
if (!data)
|
|
return false;
|
|
|
|
#ifdef MEASURE_MEMORY
|
|
for (int i = 0; i < 1000; ++i) {
|
|
for (int j = 0; j < 100; ++j)
|
|
#endif
|
|
ret = ShCompile(compiler, data, OutputMultipleStrings, EShOptNone, resources, debugOptions);
|
|
#ifdef MEASURE_MEMORY
|
|
|
|
GetProcessMemoryInfo(GetCurrentProcess(), &counters, sizeof(counters));
|
|
}
|
|
#endif
|
|
|
|
FreeFileData(data);
|
|
|
|
return ret ? true : false;
|
|
}
|
|
|
|
|
|
//
|
|
// print usage to stdout
|
|
//
|
|
void usage()
|
|
{
|
|
printf("Usage: standalone [-i -a -c -m -d -h] file1 file2 ...\n"
|
|
"Where: filename = filename ending in .frag* or .vert*\n");
|
|
}
|
|
|
|
|
|
//
|
|
// Malloc a string of sufficient size and read a string into it.
|
|
//
|
|
# define MAX_SOURCE_STRINGS 5
|
|
char** ReadFileData(char *fileName)
|
|
{
|
|
FILE *in;
|
|
int errorCode = fopen_s(&in, fileName, "r");
|
|
char *fdata;
|
|
int count = 0;
|
|
char**return_data=(char**)malloc(MAX_SOURCE_STRINGS+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';
|
|
OutputMultipleStrings=0;
|
|
return return_data;
|
|
}
|
|
|
|
int len = (int)(ceil)((float)count/(float)OutputMultipleStrings);
|
|
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){
|
|
OutputMultipleStrings=(i+1);
|
|
break;
|
|
}
|
|
len = count;
|
|
}
|
|
++i;
|
|
}
|
|
return return_data;
|
|
}
|
|
|
|
|
|
|
|
void FreeFileData(char **data)
|
|
{
|
|
for(int i=0;i<OutputMultipleStrings;i++)
|
|
free(data[i]);
|
|
}
|
|
|
|
|
|
|
|
void InfoLogMsg(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);
|
|
}
|
|
|
|
int ShOutputMultipleStrings(char **argv)
|
|
{
|
|
if(!(abs(OutputMultipleStrings = atoi(*argv)))||((OutputMultipleStrings >5 || OutputMultipleStrings < 1)? 1:0)){
|
|
printf("Invalid Command Line Argument after -c option.\n"
|
|
"Usage: -c <integer> where integer =[1,5]\n"
|
|
"This option must be specified before the input file path\n");
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|