StandAlone/StandAlone.cpp

//
//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 "./../glslang/Include/ShHandle.h"
#include "./../glslang/Public/ShaderLang.h"
#include <string.h>
#include <stdlib.h>
#include <math.h>

#ifdef _WIN32
    #include <windows.h>
    #include <psapi.h>
#endif

extern "C" {
    SH_IMPORT_EXPORT void ShOutputHtml();
}

//
// 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(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;
}

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] == '-') {
                switch (argv[0][1]) {
                case 'd':
                    delay = true;                        
                    break;
                case 'i': 
                    debugOptions |= EDebugOpIntermediate;       
                    break;
                case 'l':
                    debugOptions |= EDebugOpMemoryLeakMode;
                    break;
                case 'r':
                    debugOptions |= EDebugOpRelaxedErrors;
                    break;
                case 's':
                    debugOptions |= EDebugOpSuppressInfolog;
                    break;
                case 't':
                    debugOptions |= EDebugOpTexturePrototypes;
                    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;
        }

        if (! (debugOptions & EDebugOpSuppressInfolog)) {
            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(const char *fileName, ShHandle compiler, int debugOptions, 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]);

#ifdef _WIN32
    PROCESS_MEMORY_COUNTERS counters;  // just for memory leak testing
#endif

    if (! shaderStrings)
        return false;

    EShMessages messages = EShMsgDefault;
    if (debugOptions & EDebugOpRelaxedErrors)
        messages = (EShMessages)(messages | EShMsgRelaxedErrors);
    for (int i = 0; i < ((debugOptions & EDebugOpMemoryLeakMode) ? 100 : 1); ++i) {
        for (int j = 0; j < ((debugOptions & EDebugOpMemoryLeakMode) ? 100 : 1); ++j) {
            //ret = ShCompile(compiler, shaderStrings, NumShaderStrings, lengths, EShOptNone, resources, debugOptions, 100, false, messages);
            ret = ShCompile(compiler, shaderStrings, NumShaderStrings, 0, EShOptNone, resources, debugOptions, 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, debugOptions, 100, false, messages);
        }

#ifdef _WIN32
        if (debugOptions & EDebugOpMemoryLeakMode) {
            GetProcessMemoryInfo(GetCurrentProcess(), &counters, sizeof(counters));
            printf("Working set size: %d\n", counters.WorkingSetSize);
        }
#endif
    }

    delete [] lengths;
    FreeFileData(shaderStrings);

    return ret ? true : false;
}


//
//   print usage to stdout
//
void usage()
{
    printf("Usage: standalone [ options ] filename\n"
           "Where: filename = filename ending in .frag* or .vert*\n"
           "-i: intermediate (glslang AST)\n"
           "-d: delay end (keeps output up in debugger, WIN32)\n"
           "-l: memory leak mode\n"
           "-s: silent mode (no info log)\n"
           "-r: relaxed semantic error checking 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);
}