mirror of
https://github.com/scratchfoundation/bgfx.git
synced 2024-11-25 00:58:30 -05:00
2768 lines
64 KiB
C++
2768 lines
64 KiB
C++
/*
|
|
* Copyright 2011-2014 Branimir Karadzic. All rights reserved.
|
|
* License: http://www.opensource.org/licenses/BSD-2-Clause
|
|
*/
|
|
|
|
#define _BX_TRACE(_format, ...) \
|
|
BX_MACRO_BLOCK_BEGIN \
|
|
if (g_verbose) \
|
|
{ \
|
|
fprintf(stderr, BX_FILE_LINE_LITERAL "" _format "\n", ##__VA_ARGS__); \
|
|
} \
|
|
BX_MACRO_BLOCK_END
|
|
|
|
#define _BX_WARN(_condition, _format, ...) \
|
|
BX_MACRO_BLOCK_BEGIN \
|
|
if (!(_condition) ) \
|
|
{ \
|
|
BX_TRACE("WARN " _format, ##__VA_ARGS__); \
|
|
} \
|
|
BX_MACRO_BLOCK_END
|
|
|
|
#define _BX_CHECK(_condition, _format, ...) \
|
|
BX_MACRO_BLOCK_BEGIN \
|
|
if (!(_condition) ) \
|
|
{ \
|
|
BX_TRACE("CHECK " _format, ##__VA_ARGS__); \
|
|
bx::debugBreak(); \
|
|
} \
|
|
BX_MACRO_BLOCK_END
|
|
|
|
#define BX_TRACE _BX_TRACE
|
|
#define BX_WARN _BX_WARN
|
|
#define BX_CHECK _BX_CHECK
|
|
|
|
bool g_verbose = false;
|
|
|
|
#include <bx/bx.h>
|
|
#include <bx/debug.h>
|
|
|
|
#define NOMINMAX
|
|
#include <alloca.h>
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <algorithm>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <unordered_map>
|
|
|
|
#define MAX_TAGS 256
|
|
extern "C"
|
|
{
|
|
#include <fpp.h>
|
|
} // extern "C"
|
|
|
|
#define BGFX_CHUNK_MAGIC_CSH BX_MAKEFOURCC('C', 'S', 'H', 0x1)
|
|
#define BGFX_CHUNK_MAGIC_FSH BX_MAKEFOURCC('F', 'S', 'H', 0x3)
|
|
#define BGFX_CHUNK_MAGIC_VSH BX_MAKEFOURCC('V', 'S', 'H', 0x3)
|
|
|
|
#include <bx/commandline.h>
|
|
#include <bx/endian.h>
|
|
#include <bx/uint32_t.h>
|
|
#include <bx/readerwriter.h>
|
|
#include <bx/string.h>
|
|
#include <bx/hash.h>
|
|
|
|
#include "glsl_optimizer.h"
|
|
|
|
#include "../../src/vertexdecl.h"
|
|
|
|
#if BX_PLATFORM_WINDOWS
|
|
# include <sal.h>
|
|
# define __D3DX9MATH_INL__ // not used and MinGW complains about type-punning
|
|
BX_PRAGMA_DIAGNOSTIC_PUSH();
|
|
BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG_GCC("-Wundef");
|
|
# include <d3dx9.h>
|
|
# include <d3dcompiler.h>
|
|
BX_PRAGMA_DIAGNOSTIC_POP();
|
|
#endif // BX_PLATFORM_WINDOWS
|
|
|
|
long int fsize(FILE* _file)
|
|
{
|
|
long int pos = ftell(_file);
|
|
fseek(_file, 0L, SEEK_END);
|
|
long int size = ftell(_file);
|
|
fseek(_file, pos, SEEK_SET);
|
|
return size;
|
|
}
|
|
|
|
static const char* s_ARB_shader_texture_lod[] =
|
|
{
|
|
"texture2DLod",
|
|
"texture2DProjLod",
|
|
"texture3DLod",
|
|
"texture3DProjLod",
|
|
"textureCubeLod",
|
|
"shadow2DLod",
|
|
"shadow2DProjLod",
|
|
NULL
|
|
// "texture1DLod",
|
|
// "texture1DProjLod",
|
|
// "shadow1DLod",
|
|
// "shadow1DProjLod",
|
|
};
|
|
|
|
static const char* s_EXT_shadow_samplers[] =
|
|
{
|
|
"shadow2D",
|
|
"shadow2DProj",
|
|
"sampler2DShadow",
|
|
NULL
|
|
};
|
|
|
|
static const char* s_OES_standard_derivatives[] =
|
|
{
|
|
"dFdx",
|
|
"dFdy",
|
|
"fwidth",
|
|
NULL
|
|
};
|
|
|
|
static const char* s_OES_texture_3D[] =
|
|
{
|
|
"texture3D",
|
|
"texture3DProj",
|
|
"texture3DLod",
|
|
"texture3DProjLod",
|
|
NULL
|
|
};
|
|
|
|
struct RemapInputSemantic
|
|
{
|
|
bgfx::Attrib::Enum m_attr;
|
|
const char* m_name;
|
|
uint8_t m_index;
|
|
};
|
|
|
|
static const RemapInputSemantic s_remapInputSemantic[bgfx::Attrib::Count+1] =
|
|
{
|
|
{ bgfx::Attrib::Position, "POSITION", 0 },
|
|
{ bgfx::Attrib::Normal, "NORMAL", 0 },
|
|
{ bgfx::Attrib::Tangent, "TANGENT", 0 },
|
|
{ bgfx::Attrib::Bitangent, "BITANGENT", 0 },
|
|
{ bgfx::Attrib::Color0, "COLOR", 0 },
|
|
{ bgfx::Attrib::Color1, "COLOR", 1 },
|
|
{ bgfx::Attrib::Indices, "BLENDINDICES", 0 },
|
|
{ bgfx::Attrib::Weight, "BLENDWEIGHT", 0 },
|
|
{ bgfx::Attrib::TexCoord0, "TEXCOORD", 0 },
|
|
{ bgfx::Attrib::TexCoord1, "TEXCOORD", 1 },
|
|
{ bgfx::Attrib::TexCoord2, "TEXCOORD", 2 },
|
|
{ bgfx::Attrib::TexCoord3, "TEXCOORD", 3 },
|
|
{ bgfx::Attrib::TexCoord4, "TEXCOORD", 4 },
|
|
{ bgfx::Attrib::TexCoord5, "TEXCOORD", 5 },
|
|
{ bgfx::Attrib::TexCoord6, "TEXCOORD", 6 },
|
|
{ bgfx::Attrib::TexCoord7, "TEXCOORD", 7 },
|
|
{ bgfx::Attrib::Count, "", 0 },
|
|
};
|
|
|
|
const RemapInputSemantic& findInputSemantic(const char* _name, uint8_t _index)
|
|
{
|
|
for (uint32_t ii = 0; ii < bgfx::Attrib::Count; ++ii)
|
|
{
|
|
const RemapInputSemantic& ris = s_remapInputSemantic[ii];
|
|
if (0 == strcmp(ris.m_name, _name)
|
|
&& ris.m_index == _index)
|
|
{
|
|
return ris;
|
|
}
|
|
}
|
|
|
|
return s_remapInputSemantic[bgfx::Attrib::Count];
|
|
}
|
|
|
|
struct UniformType
|
|
{
|
|
enum Enum
|
|
{
|
|
Uniform1i,
|
|
Uniform1f,
|
|
End,
|
|
|
|
Uniform1iv,
|
|
Uniform1fv,
|
|
Uniform2fv,
|
|
Uniform3fv,
|
|
Uniform4fv,
|
|
Uniform3x3fv,
|
|
Uniform4x4fv,
|
|
|
|
Count
|
|
};
|
|
};
|
|
|
|
#define BGFX_UNIFORM_FRAGMENTBIT UINT8_C(0x10)
|
|
|
|
const char* s_uniformTypeName[UniformType::Count] =
|
|
{
|
|
"int",
|
|
"float",
|
|
NULL,
|
|
"int",
|
|
"float",
|
|
"vec2",
|
|
"vec3",
|
|
"vec4",
|
|
"mat3",
|
|
"mat4",
|
|
};
|
|
|
|
UniformType::Enum nameToUniformTypeEnum(const char* _name)
|
|
{
|
|
for (uint32_t ii = 0; ii < UniformType::Count; ++ii)
|
|
{
|
|
if (NULL != s_uniformTypeName[ii]
|
|
&& 0 == strcmp(_name, s_uniformTypeName[ii]) )
|
|
{
|
|
return UniformType::Enum(ii);
|
|
}
|
|
}
|
|
|
|
return UniformType::Count;
|
|
}
|
|
|
|
struct Uniform
|
|
{
|
|
std::string name;
|
|
UniformType::Enum type;
|
|
uint8_t num;
|
|
uint16_t regIndex;
|
|
uint16_t regCount;
|
|
};
|
|
typedef std::vector<Uniform> UniformArray;
|
|
|
|
const char* interpolationDx11(const char* _glsl)
|
|
{
|
|
if (0 == strcmp(_glsl, "smooth") )
|
|
{
|
|
return "linear";
|
|
}
|
|
else if (0 == strcmp(_glsl, "flat") )
|
|
{
|
|
return "nointerpolation";
|
|
}
|
|
|
|
return _glsl; // noperspective
|
|
}
|
|
|
|
#if BX_PLATFORM_WINDOWS
|
|
struct UniformRemapDx9
|
|
{
|
|
UniformType::Enum id;
|
|
D3DXPARAMETER_CLASS paramClass;
|
|
D3DXPARAMETER_TYPE paramType;
|
|
uint8_t columns;
|
|
uint8_t rows;
|
|
};
|
|
|
|
static const UniformRemapDx9 s_constRemapDx9[7] =
|
|
{
|
|
{ UniformType::Uniform1iv, D3DXPC_SCALAR, D3DXPT_INT, 0, 0 },
|
|
{ UniformType::Uniform1fv, D3DXPC_SCALAR, D3DXPT_FLOAT, 0, 0 },
|
|
{ UniformType::Uniform2fv, D3DXPC_VECTOR, D3DXPT_FLOAT, 0, 0 },
|
|
{ UniformType::Uniform3fv, D3DXPC_VECTOR, D3DXPT_FLOAT, 0, 0 },
|
|
{ UniformType::Uniform4fv, D3DXPC_VECTOR, D3DXPT_FLOAT, 0, 0 },
|
|
{ UniformType::Uniform3x3fv, D3DXPC_MATRIX_COLUMNS, D3DXPT_FLOAT, 3, 3 },
|
|
{ UniformType::Uniform4x4fv, D3DXPC_MATRIX_COLUMNS, D3DXPT_FLOAT, 4, 4 },
|
|
};
|
|
|
|
UniformType::Enum findUniformTypeDx9(const D3DXCONSTANT_DESC& constDesc)
|
|
{
|
|
for (uint32_t ii = 0; ii < BX_COUNTOF(s_constRemapDx9); ++ii)
|
|
{
|
|
const UniformRemapDx9& remap = s_constRemapDx9[ii];
|
|
|
|
if (remap.paramClass == constDesc.Class
|
|
&& remap.paramType == constDesc.Type)
|
|
{
|
|
if (D3DXPC_MATRIX_COLUMNS != constDesc.Class)
|
|
{
|
|
return remap.id;
|
|
}
|
|
|
|
if (remap.columns == constDesc.Columns
|
|
&& remap.rows == constDesc.Rows)
|
|
{
|
|
return remap.id;
|
|
}
|
|
}
|
|
}
|
|
|
|
return UniformType::Count;
|
|
}
|
|
|
|
static uint32_t s_optimizationLevelDx9[4] =
|
|
{
|
|
D3DXSHADER_OPTIMIZATION_LEVEL0,
|
|
D3DXSHADER_OPTIMIZATION_LEVEL1,
|
|
D3DXSHADER_OPTIMIZATION_LEVEL2,
|
|
D3DXSHADER_OPTIMIZATION_LEVEL3,
|
|
};
|
|
|
|
struct UniformRemapDx11
|
|
{
|
|
UniformType::Enum id;
|
|
D3D_SHADER_VARIABLE_CLASS paramClass;
|
|
D3D_SHADER_VARIABLE_TYPE paramType;
|
|
uint8_t columns;
|
|
uint8_t rows;
|
|
};
|
|
|
|
static const UniformRemapDx11 s_constRemapDx11[7] =
|
|
{
|
|
{ UniformType::Uniform1iv, D3D_SVC_SCALAR, D3D_SVT_INT, 0, 0 },
|
|
{ UniformType::Uniform1fv, D3D_SVC_SCALAR, D3D_SVT_FLOAT, 0, 0 },
|
|
{ UniformType::Uniform2fv, D3D_SVC_VECTOR, D3D_SVT_FLOAT, 0, 0 },
|
|
{ UniformType::Uniform3fv, D3D_SVC_VECTOR, D3D_SVT_FLOAT, 0, 0 },
|
|
{ UniformType::Uniform4fv, D3D_SVC_VECTOR, D3D_SVT_FLOAT, 0, 0 },
|
|
{ UniformType::Uniform3x3fv, D3D_SVC_MATRIX_COLUMNS, D3D_SVT_FLOAT, 3, 3 },
|
|
{ UniformType::Uniform4x4fv, D3D_SVC_MATRIX_COLUMNS, D3D_SVT_FLOAT, 4, 4 },
|
|
};
|
|
|
|
UniformType::Enum findUniformTypeDx11(const D3D11_SHADER_TYPE_DESC& constDesc)
|
|
{
|
|
for (uint32_t ii = 0; ii < BX_COUNTOF(s_constRemapDx11); ++ii)
|
|
{
|
|
const UniformRemapDx11& remap = s_constRemapDx11[ii];
|
|
|
|
if (remap.paramClass == constDesc.Class
|
|
&& remap.paramType == constDesc.Type)
|
|
{
|
|
if (D3D_SVC_MATRIX_COLUMNS != constDesc.Class)
|
|
{
|
|
return remap.id;
|
|
}
|
|
|
|
if (remap.columns == constDesc.Columns
|
|
&& remap.rows == constDesc.Rows)
|
|
{
|
|
return remap.id;
|
|
}
|
|
}
|
|
}
|
|
|
|
return UniformType::Count;
|
|
}
|
|
|
|
static uint32_t s_optimizationLevelDx11[4] =
|
|
{
|
|
D3DCOMPILE_OPTIMIZATION_LEVEL0,
|
|
D3DCOMPILE_OPTIMIZATION_LEVEL1,
|
|
D3DCOMPILE_OPTIMIZATION_LEVEL2,
|
|
D3DCOMPILE_OPTIMIZATION_LEVEL3,
|
|
};
|
|
#endif // BX_PLATFORM_WINDOWS
|
|
|
|
int32_t writef(bx::WriterI* _writer, const char* _format, ...)
|
|
{
|
|
va_list argList;
|
|
va_start(argList, _format);
|
|
|
|
char temp[2048];
|
|
|
|
char* out = temp;
|
|
int32_t max = sizeof(temp);
|
|
int32_t len = bx::vsnprintf(out, max, _format, argList);
|
|
if (len > max)
|
|
{
|
|
out = (char*)alloca(len);
|
|
len = bx::vsnprintf(out, len, _format, argList);
|
|
}
|
|
|
|
len = bx::write(_writer, out, len);
|
|
|
|
va_end(argList);
|
|
|
|
return len;
|
|
}
|
|
|
|
class Bin2cWriter : public bx::CrtFileWriter
|
|
{
|
|
public:
|
|
Bin2cWriter(const char* _name)
|
|
: m_name(_name)
|
|
{
|
|
}
|
|
|
|
virtual ~Bin2cWriter()
|
|
{
|
|
}
|
|
|
|
virtual int32_t close() BX_OVERRIDE
|
|
{
|
|
generate();
|
|
return bx::CrtFileWriter::close();
|
|
}
|
|
|
|
virtual int32_t write(const void* _data, int32_t _size) BX_OVERRIDE
|
|
{
|
|
const char* data = (const char*)_data;
|
|
m_buffer.insert(m_buffer.end(), data, data+_size);
|
|
return _size;
|
|
}
|
|
|
|
private:
|
|
void generate()
|
|
{
|
|
#define HEX_DUMP_WIDTH 16
|
|
#define HEX_DUMP_SPACE_WIDTH 96
|
|
#define HEX_DUMP_FORMAT "%-" BX_STRINGIZE(HEX_DUMP_SPACE_WIDTH) "." BX_STRINGIZE(HEX_DUMP_SPACE_WIDTH) "s"
|
|
const uint8_t* data = &m_buffer[0];
|
|
uint32_t size = (uint32_t)m_buffer.size();
|
|
|
|
outf("static const uint8_t %s[%d] =\n{\n", m_name.c_str(), size);
|
|
|
|
if (NULL != data)
|
|
{
|
|
char hex[HEX_DUMP_SPACE_WIDTH+1];
|
|
char ascii[HEX_DUMP_WIDTH+1];
|
|
uint32_t hexPos = 0;
|
|
uint32_t asciiPos = 0;
|
|
for (uint32_t ii = 0; ii < size; ++ii)
|
|
{
|
|
bx::snprintf(&hex[hexPos], sizeof(hex)-hexPos, "0x%02x, ", data[asciiPos]);
|
|
hexPos += 6;
|
|
|
|
ascii[asciiPos] = isprint(data[asciiPos]) && data[asciiPos] != '\\' ? data[asciiPos] : '.';
|
|
asciiPos++;
|
|
|
|
if (HEX_DUMP_WIDTH == asciiPos)
|
|
{
|
|
ascii[asciiPos] = '\0';
|
|
outf("\t" HEX_DUMP_FORMAT "// %s\n", hex, ascii);
|
|
data += asciiPos;
|
|
hexPos = 0;
|
|
asciiPos = 0;
|
|
}
|
|
}
|
|
|
|
if (0 != asciiPos)
|
|
{
|
|
ascii[asciiPos] = '\0';
|
|
outf("\t" HEX_DUMP_FORMAT "// %s\n", hex, ascii);
|
|
}
|
|
}
|
|
|
|
outf("};\n");
|
|
#undef HEX_DUMP_WIDTH
|
|
#undef HEX_DUMP_SPACE_WIDTH
|
|
#undef HEX_DUMP_FORMAT
|
|
}
|
|
|
|
int32_t outf(const char* _format, ...)
|
|
{
|
|
va_list argList;
|
|
va_start(argList, _format);
|
|
|
|
char temp[2048];
|
|
char* out = temp;
|
|
int32_t max = sizeof(temp);
|
|
int32_t len = bx::vsnprintf(out, max, _format, argList);
|
|
if (len > max)
|
|
{
|
|
out = (char*)alloca(len);
|
|
len = bx::vsnprintf(out, len, _format, argList);
|
|
}
|
|
|
|
int32_t size = bx::CrtFileWriter::write(out, len);
|
|
|
|
va_end(argList);
|
|
|
|
return size;
|
|
}
|
|
|
|
std::string m_filePath;
|
|
std::string m_name;
|
|
typedef std::vector<uint8_t> Buffer;
|
|
Buffer m_buffer;
|
|
};
|
|
|
|
struct Varying
|
|
{
|
|
std::string m_precision;
|
|
std::string m_interpolation;
|
|
std::string m_name;
|
|
std::string m_type;
|
|
std::string m_init;
|
|
std::string m_semantics;
|
|
};
|
|
|
|
typedef std::unordered_map<std::string, Varying> VaryingMap;
|
|
|
|
class File
|
|
{
|
|
public:
|
|
File(const char* _filePath)
|
|
: m_data(NULL)
|
|
{
|
|
FILE* file = fopen(_filePath, "r");
|
|
if (NULL != file)
|
|
{
|
|
m_size = fsize(file);
|
|
m_data = new char[m_size+1];
|
|
m_size = (uint32_t)fread(m_data, 1, m_size, file);
|
|
m_data[m_size] = '\0';
|
|
fclose(file);
|
|
}
|
|
}
|
|
|
|
~File()
|
|
{
|
|
delete [] m_data;
|
|
}
|
|
|
|
const char* getData() const
|
|
{
|
|
return m_data;
|
|
}
|
|
|
|
uint32_t getSize() const
|
|
{
|
|
return m_size;
|
|
}
|
|
|
|
private:
|
|
char* m_data;
|
|
uint32_t m_size;
|
|
};
|
|
|
|
void strins(char* _str, const char* _insert)
|
|
{
|
|
size_t len = strlen(_insert);
|
|
memmove(&_str[len], _str, strlen(_str) );
|
|
memcpy(_str, _insert, len);
|
|
}
|
|
|
|
void strreplace(char* _str, const char* _find, const char* _replace)
|
|
{
|
|
const size_t len = strlen(_find);
|
|
|
|
char* replace = (char*)alloca(len+1);
|
|
bx::strlcpy(replace, _replace, len+1);
|
|
for (size_t ii = strlen(replace); ii < len; ++ii)
|
|
{
|
|
replace[ii] = ' ';
|
|
}
|
|
replace[len] = '\0';
|
|
|
|
BX_CHECK(len >= strlen(_replace), "");
|
|
for (char* ptr = strstr(_str, _find); NULL != ptr; ptr = strstr(ptr + len, _find) )
|
|
{
|
|
memcpy(ptr, replace, len);
|
|
}
|
|
}
|
|
|
|
class LineReader
|
|
{
|
|
public:
|
|
LineReader(const char* _str)
|
|
: m_str(_str)
|
|
, m_pos(0)
|
|
, m_size( (uint32_t)strlen(_str) )
|
|
{
|
|
}
|
|
|
|
std::string getLine()
|
|
{
|
|
const char* str = &m_str[m_pos];
|
|
skipLine();
|
|
|
|
const char* eol = &m_str[m_pos];
|
|
|
|
std::string tmp;
|
|
tmp.assign(str, eol-str);
|
|
return tmp;
|
|
}
|
|
|
|
bool isEof() const
|
|
{
|
|
return m_str[m_pos] == '\0';
|
|
}
|
|
|
|
void skipLine()
|
|
{
|
|
const char* str = &m_str[m_pos];
|
|
const char* nl = bx::strnl(str);
|
|
m_pos += (uint32_t)(nl - str);
|
|
}
|
|
|
|
const char* m_str;
|
|
uint32_t m_pos;
|
|
uint32_t m_size;
|
|
};
|
|
|
|
void printCode(const char* _code, int32_t _line = 0, int32_t _start = 0, int32_t _end = INT32_MAX)
|
|
{
|
|
fprintf(stderr, "Code:\n---\n");
|
|
|
|
LineReader lr(_code);
|
|
for (int32_t line = 1; !lr.isEof() && line < _end; ++line)
|
|
{
|
|
if (line >= _start)
|
|
{
|
|
fprintf(stderr, "%s%3d: %s", _line == line ? ">>> " : " ", line, lr.getLine().c_str() );
|
|
}
|
|
else
|
|
{
|
|
lr.skipLine();
|
|
}
|
|
}
|
|
|
|
fprintf(stderr, "---\n");
|
|
}
|
|
|
|
void writeFile(const char* _filePath, const void* _data, int32_t _size)
|
|
{
|
|
bx::CrtFileWriter out;
|
|
if (0 == out.open(_filePath) )
|
|
{
|
|
out.write(_data, _size);
|
|
out.close();
|
|
}
|
|
}
|
|
|
|
bool compileGLSLShader(bx::CommandLine& _cmdLine, uint32_t _gles, const std::string& _code, bx::WriterI* _writer)
|
|
{
|
|
char ch = tolower(_cmdLine.findOption('\0', "type")[0]);
|
|
const glslopt_shader_type type = ch == 'f'
|
|
? kGlslOptShaderFragment
|
|
: (ch == 'c' ? kGlslOptShaderCompute : kGlslOptShaderVertex);
|
|
|
|
glslopt_target target = kGlslTargetOpenGL;
|
|
switch (_gles)
|
|
{
|
|
case 2:
|
|
target = kGlslTargetOpenGLES20;
|
|
break;
|
|
|
|
case 3:
|
|
target = kGlslTargetOpenGLES30;
|
|
break;
|
|
|
|
default:
|
|
target = kGlslTargetOpenGL;
|
|
break;
|
|
}
|
|
|
|
glslopt_ctx* ctx = glslopt_initialize(target);
|
|
|
|
glslopt_shader* shader = glslopt_optimize(ctx, type, _code.c_str(), 0);
|
|
|
|
if (!glslopt_get_status(shader) )
|
|
{
|
|
const char* log = glslopt_get_log(shader);
|
|
int32_t source = 0;
|
|
int32_t line = 0;
|
|
int32_t column = 0;
|
|
int32_t start = 0;
|
|
int32_t end = INT32_MAX;
|
|
|
|
if (3 == sscanf(log, "%u:%u(%u):", &source, &line, &column)
|
|
&& 0 != line)
|
|
{
|
|
start = bx::uint32_imax(1, line-10);
|
|
end = start + 20;
|
|
}
|
|
|
|
printCode(_code.c_str(), line, start, end);
|
|
fprintf(stderr, "Error: %s\n", log);
|
|
glslopt_cleanup(ctx);
|
|
return false;
|
|
}
|
|
|
|
const char* optimizedShader = glslopt_get_output(shader);
|
|
|
|
// Trim all directives.
|
|
while ('#' == *optimizedShader)
|
|
{
|
|
optimizedShader = bx::strnl(optimizedShader);
|
|
}
|
|
|
|
if (0 != _gles)
|
|
{
|
|
char* shader = const_cast<char*>(optimizedShader);
|
|
strreplace(shader, "gl_FragDepthEXT", "gl_FragDepth");
|
|
|
|
strreplace(shader, "texture2DLodEXT", "texture2DLod");
|
|
strreplace(shader, "texture2DProjLodEXT", "texture2DProjLod");
|
|
strreplace(shader, "textureCubeLodEXT", "textureCubeLod");
|
|
strreplace(shader, "texture2DGradEXT", "texture2DGrad");
|
|
strreplace(shader, "texture2DProjGradEXT", "texture2DProjGrad");
|
|
strreplace(shader, "textureCubeGradEXT", "textureCubeGrad");
|
|
|
|
strreplace(shader, "shadow2DEXT", "shadow2D");
|
|
strreplace(shader, "shadow2DProjEXT", "shadow2DProj");
|
|
}
|
|
|
|
UniformArray uniforms;
|
|
|
|
{
|
|
const char* parse = optimizedShader;
|
|
|
|
while (NULL != parse
|
|
&& *parse != '\0')
|
|
{
|
|
parse = bx::strws(parse);
|
|
const char* eol = strchr(parse, ';');
|
|
if (NULL != eol)
|
|
{
|
|
const char* qualifier = parse;
|
|
parse = bx::strws(bx::strword(parse) );
|
|
|
|
if (0 == strncmp(qualifier, "attribute", 9)
|
|
|| 0 == strncmp(qualifier, "varying", 7) )
|
|
{
|
|
// skip attributes and varyings.
|
|
parse = eol + 1;
|
|
continue;
|
|
}
|
|
|
|
if (0 != strncmp(qualifier, "uniform", 7) )
|
|
{
|
|
// end if there is no uniform keyword.
|
|
parse = NULL;
|
|
continue;
|
|
}
|
|
|
|
const char* precision = NULL;
|
|
const char* type = parse;
|
|
|
|
if (0 == strncmp(type, "lowp", 4)
|
|
|| 0 == strncmp(type, "mediump", 7)
|
|
|| 0 == strncmp(type, "highp", 5) )
|
|
{
|
|
precision = type;
|
|
type = parse = bx::strws(bx::strword(parse) );
|
|
}
|
|
|
|
BX_UNUSED(precision);
|
|
|
|
char uniformType[256];
|
|
parse = bx::strword(parse);
|
|
|
|
if (0 == strncmp(type, "sampler", 7) )
|
|
{
|
|
strcpy(uniformType, "int");
|
|
}
|
|
else
|
|
{
|
|
bx::strlcpy(uniformType, type, parse-type+1);
|
|
}
|
|
|
|
const char* name = parse = bx::strws(parse);
|
|
|
|
char uniformName[256];
|
|
uint8_t num = 1;
|
|
const char* array = bx::strnstr(name, "[", eol-parse);
|
|
if (NULL != array)
|
|
{
|
|
bx::strlcpy(uniformName, name, array-name+1);
|
|
|
|
char arraySize[32];
|
|
const char* end = bx::strnstr(array, "]", eol-array);
|
|
bx::strlcpy(arraySize, array+1, end-array);
|
|
num = atoi(arraySize);
|
|
}
|
|
else
|
|
{
|
|
bx::strlcpy(uniformName, name, eol-name+1);
|
|
}
|
|
|
|
Uniform un;
|
|
un.type = nameToUniformTypeEnum(uniformType);
|
|
|
|
if (UniformType::Count != un.type)
|
|
{
|
|
BX_TRACE("name: %s (type %d, num %d)", uniformName, un.type, num);
|
|
|
|
un.name = uniformName;
|
|
un.num = num;
|
|
un.regIndex = 0;
|
|
un.regCount = num;
|
|
uniforms.push_back(un);
|
|
}
|
|
|
|
parse = eol + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
uint16_t count = (uint16_t)uniforms.size();
|
|
bx::write(_writer, count);
|
|
|
|
for (UniformArray::const_iterator it = uniforms.begin(); it != uniforms.end(); ++it)
|
|
{
|
|
const Uniform& un = *it;
|
|
uint8_t nameSize = (uint8_t)un.name.size();
|
|
bx::write(_writer, nameSize);
|
|
bx::write(_writer, un.name.c_str(), nameSize);
|
|
uint8_t type = un.type;
|
|
bx::write(_writer, type);
|
|
bx::write(_writer, un.num);
|
|
bx::write(_writer, un.regIndex);
|
|
bx::write(_writer, un.regCount);
|
|
|
|
BX_TRACE("%s, %s, %d, %d, %d"
|
|
, un.name.c_str()
|
|
, s_uniformTypeName[un.type]
|
|
, un.num
|
|
, un.regIndex
|
|
, un.regCount
|
|
);
|
|
}
|
|
|
|
uint32_t shaderSize = (uint32_t)strlen(optimizedShader);
|
|
bx::write(_writer, shaderSize);
|
|
bx::write(_writer, optimizedShader, shaderSize);
|
|
uint8_t nul = 0;
|
|
bx::write(_writer, nul);
|
|
|
|
glslopt_cleanup(ctx);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool compileHLSLShaderDx9(bx::CommandLine& _cmdLine, const std::string& _code, bx::WriterI* _writer)
|
|
{
|
|
#if BX_PLATFORM_WINDOWS
|
|
BX_TRACE("DX9");
|
|
|
|
const char* profile = _cmdLine.findOption('p', "profile");
|
|
if (NULL == profile)
|
|
{
|
|
fprintf(stderr, "Shader profile must be specified.\n");
|
|
return false;
|
|
}
|
|
|
|
bool debug = _cmdLine.hasArg('\0', "debug");
|
|
|
|
uint32_t flags = 0;
|
|
flags |= debug ? D3DXSHADER_DEBUG : 0;
|
|
flags |= _cmdLine.hasArg('\0', "avoid-flow-control") ? D3DXSHADER_AVOID_FLOW_CONTROL : 0;
|
|
flags |= _cmdLine.hasArg('\0', "no-preshader") ? D3DXSHADER_NO_PRESHADER : 0;
|
|
flags |= _cmdLine.hasArg('\0', "partial-precision") ? D3DXSHADER_PARTIALPRECISION : 0;
|
|
flags |= _cmdLine.hasArg('\0', "prefer-flow-control") ? D3DXSHADER_PREFER_FLOW_CONTROL : 0;
|
|
flags |= _cmdLine.hasArg('\0', "backwards-compatibility") ? D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY : 0;
|
|
|
|
bool werror = _cmdLine.hasArg('\0', "Werror");
|
|
|
|
uint32_t optimization = 3;
|
|
if (_cmdLine.hasArg(optimization, 'O') )
|
|
{
|
|
optimization = bx::uint32_min(optimization, BX_COUNTOF(s_optimizationLevelDx9)-1);
|
|
flags |= s_optimizationLevelDx9[optimization];
|
|
}
|
|
else
|
|
{
|
|
flags |= D3DXSHADER_SKIPOPTIMIZATION;
|
|
}
|
|
|
|
BX_TRACE("Profile: %s", profile);
|
|
BX_TRACE("Flags: 0x%08x", flags);
|
|
|
|
LPD3DXBUFFER code;
|
|
LPD3DXBUFFER errorMsg;
|
|
LPD3DXCONSTANTTABLE constantTable;
|
|
|
|
HRESULT hr;
|
|
|
|
// Output preprocessed shader so that HLSL can be debugged via GPA
|
|
// or PIX. Compiling through memory won't embed preprocessed shader
|
|
// file path.
|
|
if (debug)
|
|
{
|
|
std::string hlslfp = _cmdLine.findOption('o');
|
|
hlslfp += ".hlsl";
|
|
writeFile(hlslfp.c_str(), _code.c_str(), (int32_t)_code.size() );
|
|
|
|
hr = D3DXCompileShaderFromFileA(hlslfp.c_str()
|
|
, NULL
|
|
, NULL
|
|
, "main"
|
|
, profile
|
|
, flags
|
|
, &code
|
|
, &errorMsg
|
|
, &constantTable
|
|
);
|
|
}
|
|
else
|
|
{
|
|
hr = D3DXCompileShader(_code.c_str()
|
|
, (uint32_t)_code.size()
|
|
, NULL
|
|
, NULL
|
|
, "main"
|
|
, profile
|
|
, flags
|
|
, &code
|
|
, &errorMsg
|
|
, &constantTable
|
|
);
|
|
}
|
|
|
|
if (FAILED(hr)
|
|
|| (werror && NULL != errorMsg) )
|
|
{
|
|
const char* log = (const char*)errorMsg->GetBufferPointer();
|
|
|
|
char source[1024];
|
|
int32_t line = 0;
|
|
int32_t column = 0;
|
|
int32_t start = 0;
|
|
int32_t end = INT32_MAX;
|
|
|
|
if (3 == sscanf(log, "%[^(](%u,%u):", source, &line, &column)
|
|
&& 0 != line)
|
|
{
|
|
start = bx::uint32_imax(1, line-10);
|
|
end = start + 20;
|
|
}
|
|
|
|
printCode(_code.c_str(), line, start, end);
|
|
fprintf(stderr, "Error: 0x%08x %s\n", (uint32_t)hr, log);
|
|
errorMsg->Release();
|
|
return false;
|
|
}
|
|
|
|
UniformArray uniforms;
|
|
|
|
if (NULL != constantTable)
|
|
{
|
|
D3DXCONSTANTTABLE_DESC desc;
|
|
hr = constantTable->GetDesc(&desc);
|
|
if (FAILED(hr) )
|
|
{
|
|
fprintf(stderr, "Error 0x%08x\n", (uint32_t)hr);
|
|
return false;
|
|
}
|
|
|
|
BX_TRACE("Creator: %s 0x%08x", desc.Creator, (uint32_t /*mingw warning*/)desc.Version);
|
|
BX_TRACE("Num constants: %d", desc.Constants);
|
|
BX_TRACE("# cl ty RxC S By Name");
|
|
|
|
for (uint32_t ii = 0; ii < desc.Constants; ++ii)
|
|
{
|
|
D3DXHANDLE handle = constantTable->GetConstant(NULL, ii);
|
|
D3DXCONSTANT_DESC constDesc;
|
|
uint32_t count;
|
|
constantTable->GetConstantDesc(handle, &constDesc, &count);
|
|
BX_TRACE("%3d %2d %2d [%dx%d] %d %3d %s[%d] c%d (%d)"
|
|
, ii
|
|
, constDesc.Class
|
|
, constDesc.Type
|
|
, constDesc.Rows
|
|
, constDesc.Columns
|
|
, constDesc.StructMembers
|
|
, constDesc.Bytes
|
|
, constDesc.Name
|
|
, constDesc.Elements
|
|
, constDesc.RegisterIndex
|
|
, constDesc.RegisterCount
|
|
);
|
|
|
|
UniformType::Enum type = findUniformTypeDx9(constDesc);
|
|
if (UniformType::Count != type)
|
|
{
|
|
Uniform un;
|
|
un.name = '$' == constDesc.Name[0] ? constDesc.Name+1 : constDesc.Name;
|
|
un.type = type;
|
|
un.num = constDesc.Elements;
|
|
un.regIndex = constDesc.RegisterIndex;
|
|
un.regCount = constDesc.RegisterCount;
|
|
uniforms.push_back(un);
|
|
}
|
|
}
|
|
}
|
|
|
|
uint16_t count = (uint16_t)uniforms.size();
|
|
bx::write(_writer, count);
|
|
|
|
uint32_t fragmentBit = profile[0] == 'p' ? BGFX_UNIFORM_FRAGMENTBIT : 0;
|
|
for (UniformArray::const_iterator it = uniforms.begin(); it != uniforms.end(); ++it)
|
|
{
|
|
const Uniform& un = *it;
|
|
uint8_t nameSize = (uint8_t)un.name.size();
|
|
bx::write(_writer, nameSize);
|
|
bx::write(_writer, un.name.c_str(), nameSize);
|
|
uint8_t type = un.type|fragmentBit;
|
|
bx::write(_writer, type);
|
|
bx::write(_writer, un.num);
|
|
bx::write(_writer, un.regIndex);
|
|
bx::write(_writer, un.regCount);
|
|
|
|
BX_TRACE("%s, %s, %d, %d, %d"
|
|
, un.name.c_str()
|
|
, s_uniformTypeName[un.type]
|
|
, un.num
|
|
, un.regIndex
|
|
, un.regCount
|
|
);
|
|
}
|
|
|
|
uint16_t shaderSize = (uint16_t)code->GetBufferSize();
|
|
bx::write(_writer, shaderSize);
|
|
bx::write(_writer, code->GetBufferPointer(), shaderSize);
|
|
uint8_t nul = 0;
|
|
bx::write(_writer, nul);
|
|
|
|
if (_cmdLine.hasArg('\0', "disasm") )
|
|
{
|
|
LPD3DXBUFFER disasm;
|
|
D3DXDisassembleShader( (const DWORD*)code->GetBufferPointer()
|
|
, false
|
|
, NULL
|
|
, &disasm
|
|
);
|
|
|
|
if (NULL != disasm)
|
|
{
|
|
std::string disasmfp = _cmdLine.findOption('o');
|
|
disasmfp += ".disasm";
|
|
|
|
writeFile(disasmfp.c_str(), disasm->GetBufferPointer(), disasm->GetBufferSize() );
|
|
disasm->Release();
|
|
}
|
|
}
|
|
|
|
if (NULL != code)
|
|
{
|
|
code->Release();
|
|
}
|
|
|
|
if (NULL != errorMsg)
|
|
{
|
|
errorMsg->Release();
|
|
}
|
|
|
|
if (NULL != constantTable)
|
|
{
|
|
constantTable->Release();
|
|
}
|
|
|
|
return true;
|
|
#else
|
|
BX_UNUSED(_cmdLine, _code, _writer);
|
|
fprintf(stderr, "HLSL compiler is not supported on this platform.\n");
|
|
return false;
|
|
#endif // BX_PLATFORM_WINDOWS
|
|
}
|
|
|
|
bool compileHLSLShaderDx11(bx::CommandLine& _cmdLine, const std::string& _code, bx::WriterI* _writer)
|
|
{
|
|
#if BX_PLATFORM_WINDOWS
|
|
BX_TRACE("DX11");
|
|
|
|
const char* profile = _cmdLine.findOption('p', "profile");
|
|
if (NULL == profile)
|
|
{
|
|
fprintf(stderr, "Shader profile must be specified.\n");
|
|
return false;
|
|
}
|
|
|
|
bool debug = _cmdLine.hasArg('\0', "debug");
|
|
|
|
uint32_t flags = D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY;
|
|
flags |= debug ? D3DCOMPILE_DEBUG : 0;
|
|
flags |= _cmdLine.hasArg('\0', "avoid-flow-control") ? D3DCOMPILE_AVOID_FLOW_CONTROL : 0;
|
|
flags |= _cmdLine.hasArg('\0', "no-preshader") ? D3DCOMPILE_NO_PRESHADER : 0;
|
|
flags |= _cmdLine.hasArg('\0', "partial-precision") ? D3DCOMPILE_PARTIAL_PRECISION : 0;
|
|
flags |= _cmdLine.hasArg('\0', "prefer-flow-control") ? D3DCOMPILE_PREFER_FLOW_CONTROL : 0;
|
|
flags |= _cmdLine.hasArg('\0', "backwards-compatibility") ? D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY : 0;
|
|
|
|
bool werror = _cmdLine.hasArg('\0', "Werror");
|
|
|
|
if (werror)
|
|
{
|
|
flags |= D3DCOMPILE_WARNINGS_ARE_ERRORS;
|
|
}
|
|
|
|
uint32_t optimization = 3;
|
|
if (_cmdLine.hasArg(optimization, 'O') )
|
|
{
|
|
optimization = bx::uint32_min(optimization, BX_COUNTOF(s_optimizationLevelDx11)-1);
|
|
flags |= s_optimizationLevelDx11[optimization];
|
|
}
|
|
else
|
|
{
|
|
flags |= D3DCOMPILE_SKIP_OPTIMIZATION;
|
|
}
|
|
|
|
BX_TRACE("Profile: %s", profile);
|
|
BX_TRACE("Flags: 0x%08x", flags);
|
|
|
|
ID3DBlob* code;
|
|
ID3DBlob* errorMsg;
|
|
|
|
// Output preprocessed shader so that HLSL can be debugged via GPA
|
|
// or PIX. Compiling through memory won't embed preprocessed shader
|
|
// file path.
|
|
std::string hlslfp;
|
|
|
|
if (debug)
|
|
{
|
|
hlslfp = _cmdLine.findOption('o');
|
|
hlslfp += ".hlsl";
|
|
writeFile(hlslfp.c_str(), _code.c_str(), (int32_t)_code.size() );
|
|
}
|
|
|
|
HRESULT hr = D3DCompile(_code.c_str()
|
|
, _code.size()
|
|
, hlslfp.c_str()
|
|
, NULL
|
|
, NULL
|
|
, "main"
|
|
, profile
|
|
, flags
|
|
, 0
|
|
, &code
|
|
, &errorMsg
|
|
);
|
|
if (FAILED(hr)
|
|
|| (werror && NULL != errorMsg) )
|
|
{
|
|
const char* log = (char*)errorMsg->GetBufferPointer();
|
|
|
|
int32_t line = 0;
|
|
int32_t column = 0;
|
|
int32_t start = 0;
|
|
int32_t end = INT32_MAX;
|
|
|
|
if (2 == sscanf(log, "(%u,%u):", &line, &column)
|
|
&& 0 != line)
|
|
{
|
|
start = bx::uint32_imax(1, line-10);
|
|
end = start + 20;
|
|
}
|
|
|
|
printCode(_code.c_str(), line, start, end);
|
|
fprintf(stderr, "Error: 0x%08x %s\n", (uint32_t)hr, log);
|
|
errorMsg->Release();
|
|
return false;
|
|
}
|
|
|
|
UniformArray uniforms;
|
|
|
|
ID3D11ShaderReflection* reflect = NULL;
|
|
hr = D3DReflect(code->GetBufferPointer()
|
|
, code->GetBufferSize()
|
|
, IID_ID3D11ShaderReflection
|
|
, (void**)&reflect
|
|
);
|
|
if (FAILED(hr) )
|
|
{
|
|
fprintf(stderr, "Error: 0x%08x\n", (uint32_t)hr);
|
|
return false;
|
|
}
|
|
|
|
D3D11_SHADER_DESC desc;
|
|
hr = reflect->GetDesc(&desc);
|
|
if (FAILED(hr) )
|
|
{
|
|
fprintf(stderr, BX_FILE_LINE_LITERAL "Error: 0x%08x\n", (uint32_t)hr);
|
|
return false;
|
|
}
|
|
|
|
BX_TRACE("Creator: %s 0x%08x", desc.Creator, desc.Version);
|
|
BX_TRACE("Num constant buffers: %d", desc.ConstantBuffers);
|
|
|
|
BX_TRACE("Input:");
|
|
uint8_t numAttrs = 0;
|
|
uint16_t attrs[bgfx::Attrib::Count];
|
|
|
|
if (profile[0] == 'v') // Only care about input semantic on vertex shaders
|
|
{
|
|
for (uint32_t ii = 0; ii < desc.InputParameters; ++ii)
|
|
{
|
|
D3D11_SIGNATURE_PARAMETER_DESC spd;
|
|
reflect->GetInputParameterDesc(ii, &spd);
|
|
BX_TRACE("\t%2d: %s%d, vt %d, ct %d, mask %x, reg %d"
|
|
, ii
|
|
, spd.SemanticName
|
|
, spd.SemanticIndex
|
|
, spd.SystemValueType
|
|
, spd.ComponentType
|
|
, spd.Mask
|
|
, spd.Register
|
|
);
|
|
|
|
const RemapInputSemantic& ris = findInputSemantic(spd.SemanticName, spd.SemanticIndex);
|
|
if (ris.m_attr != bgfx::Attrib::Count)
|
|
{
|
|
attrs[numAttrs] = bgfx::attribToId(ris.m_attr);
|
|
++numAttrs;
|
|
}
|
|
}
|
|
}
|
|
|
|
BX_TRACE("Output:");
|
|
for (uint32_t ii = 0; ii < desc.OutputParameters; ++ii)
|
|
{
|
|
D3D11_SIGNATURE_PARAMETER_DESC spd;
|
|
reflect->GetOutputParameterDesc(ii, &spd);
|
|
BX_TRACE("\t%2d: %s%d, %d, %d", ii, spd.SemanticName, spd.SemanticIndex, spd.SystemValueType, spd.ComponentType);
|
|
}
|
|
|
|
uint16_t size = 0;
|
|
|
|
for (uint32_t ii = 0; ii < bx::uint32_min(1, desc.ConstantBuffers); ++ii)
|
|
{
|
|
ID3D11ShaderReflectionConstantBuffer* cbuffer = reflect->GetConstantBufferByIndex(ii);
|
|
D3D11_SHADER_BUFFER_DESC bufferDesc;
|
|
hr = cbuffer->GetDesc(&bufferDesc);
|
|
|
|
size = (uint16_t)bufferDesc.Size;
|
|
|
|
if (SUCCEEDED(hr) )
|
|
{
|
|
BX_TRACE("%s, %d, vars %d, size %d"
|
|
, bufferDesc.Name
|
|
, bufferDesc.Type
|
|
, bufferDesc.Variables
|
|
, bufferDesc.Size
|
|
);
|
|
|
|
for (uint32_t jj = 0; jj < bufferDesc.Variables; ++jj)
|
|
{
|
|
ID3D11ShaderReflectionVariable* var = cbuffer->GetVariableByIndex(jj);
|
|
ID3D11ShaderReflectionType* type = var->GetType();
|
|
D3D11_SHADER_VARIABLE_DESC varDesc;
|
|
hr = var->GetDesc(&varDesc);
|
|
if (SUCCEEDED(hr) )
|
|
{
|
|
D3D11_SHADER_TYPE_DESC constDesc;
|
|
hr = type->GetDesc(&constDesc);
|
|
if (SUCCEEDED(hr) )
|
|
{
|
|
UniformType::Enum type = findUniformTypeDx11(constDesc);
|
|
|
|
if (UniformType::Count != type
|
|
&& 0 != (varDesc.uFlags & D3D_SVF_USED) )
|
|
{
|
|
Uniform un;
|
|
un.name = varDesc.Name;
|
|
un.type = type;
|
|
un.num = constDesc.Elements;
|
|
un.regIndex = varDesc.StartOffset;
|
|
un.regCount = BX_ALIGN_16(varDesc.Size)/16;
|
|
uniforms.push_back(un);
|
|
|
|
BX_TRACE("\t%s, %d, size %d, flags 0x%08x, %d"
|
|
, varDesc.Name
|
|
, varDesc.StartOffset
|
|
, varDesc.Size
|
|
, varDesc.uFlags
|
|
, type
|
|
);
|
|
}
|
|
else
|
|
{
|
|
BX_TRACE("\t%s, unknown type", varDesc.Name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BX_TRACE("Bound:");
|
|
for (uint32_t ii = 0; ii < desc.BoundResources; ++ii)
|
|
{
|
|
D3D11_SHADER_INPUT_BIND_DESC bindDesc;
|
|
|
|
hr = reflect->GetResourceBindingDesc(ii, &bindDesc);
|
|
if (SUCCEEDED(hr) )
|
|
{
|
|
// if (bindDesc.Type == D3D_SIT_SAMPLER)
|
|
{
|
|
BX_TRACE("\t%s, %d, %d, %d"
|
|
, bindDesc.Name
|
|
, bindDesc.Type
|
|
, bindDesc.BindPoint
|
|
, bindDesc.BindCount
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
uint16_t count = (uint16_t)uniforms.size();
|
|
bx::write(_writer, count);
|
|
|
|
uint32_t fragmentBit = profile[0] == 'p' ? BGFX_UNIFORM_FRAGMENTBIT : 0;
|
|
for (UniformArray::const_iterator it = uniforms.begin(); it != uniforms.end(); ++it)
|
|
{
|
|
const Uniform& un = *it;
|
|
uint8_t nameSize = (uint8_t)un.name.size();
|
|
bx::write(_writer, nameSize);
|
|
bx::write(_writer, un.name.c_str(), nameSize);
|
|
uint8_t type = un.type|fragmentBit;
|
|
bx::write(_writer, type);
|
|
bx::write(_writer, un.num);
|
|
bx::write(_writer, un.regIndex);
|
|
bx::write(_writer, un.regCount);
|
|
|
|
BX_TRACE("%s, %s, %d, %d, %d"
|
|
, un.name.c_str()
|
|
, s_uniformTypeName[un.type]
|
|
, un.num
|
|
, un.regIndex
|
|
, un.regCount
|
|
);
|
|
}
|
|
|
|
uint16_t shaderSize = (uint16_t)code->GetBufferSize();
|
|
bx::write(_writer, shaderSize);
|
|
bx::write(_writer, code->GetBufferPointer(), shaderSize);
|
|
uint8_t nul = 0;
|
|
bx::write(_writer, nul);
|
|
|
|
bx::write(_writer, numAttrs);
|
|
bx::write(_writer, attrs, numAttrs*sizeof(uint16_t) );
|
|
|
|
bx::write(_writer, size);
|
|
|
|
if (_cmdLine.hasArg('\0', "disasm") )
|
|
{
|
|
ID3DBlob* disasm;
|
|
D3DDisassemble(code->GetBufferPointer()
|
|
, code->GetBufferSize()
|
|
, 0
|
|
, NULL
|
|
, &disasm
|
|
);
|
|
|
|
if (NULL != disasm)
|
|
{
|
|
std::string disasmfp = _cmdLine.findOption('o');
|
|
disasmfp += ".disasm";
|
|
|
|
writeFile(disasmfp.c_str(), disasm->GetBufferPointer(), (uint32_t)disasm->GetBufferSize() );
|
|
disasm->Release();
|
|
}
|
|
}
|
|
|
|
if (NULL != reflect)
|
|
{
|
|
reflect->Release();
|
|
}
|
|
|
|
if (NULL != errorMsg)
|
|
{
|
|
errorMsg->Release();
|
|
}
|
|
|
|
code->Release();
|
|
|
|
return true;
|
|
#else
|
|
BX_UNUSED(_cmdLine, _code, _writer);
|
|
fprintf(stderr, "HLSL compiler is not supported on this platform.\n");
|
|
return false;
|
|
#endif // BX_PLATFORM_WINDOWS
|
|
}
|
|
|
|
struct Preprocessor
|
|
{
|
|
Preprocessor(const char* _filePath, bool _gles, const char* _includeDir = NULL)
|
|
: m_tagptr(m_tags)
|
|
, m_scratchPos(0)
|
|
, m_fgetsPos(0)
|
|
{
|
|
m_tagptr->tag = FPPTAG_USERDATA;
|
|
m_tagptr->data = this;
|
|
m_tagptr++;
|
|
|
|
m_tagptr->tag = FPPTAG_DEPENDS;
|
|
m_tagptr->data = (void*)fppDepends;
|
|
m_tagptr++;
|
|
|
|
m_tagptr->tag = FPPTAG_INPUT;
|
|
m_tagptr->data = (void*)fppInput;
|
|
m_tagptr++;
|
|
|
|
m_tagptr->tag = FPPTAG_OUTPUT;
|
|
m_tagptr->data = (void*)fppOutput;
|
|
m_tagptr++;
|
|
|
|
m_tagptr->tag = FPPTAG_ERROR;
|
|
m_tagptr->data = (void*)fppError;
|
|
m_tagptr++;
|
|
|
|
m_tagptr->tag = FPPTAG_IGNOREVERSION;
|
|
m_tagptr->data = (void*)0;
|
|
m_tagptr++;
|
|
|
|
m_tagptr->tag = FPPTAG_LINE;
|
|
m_tagptr->data = (void*)0;
|
|
m_tagptr++;
|
|
|
|
m_tagptr->tag = FPPTAG_INPUT_NAME;
|
|
m_tagptr->data = scratch(_filePath);
|
|
m_tagptr++;
|
|
|
|
if (NULL != _includeDir)
|
|
{
|
|
addInclude(_includeDir);
|
|
}
|
|
|
|
if (!_gles)
|
|
{
|
|
m_default = "#define lowp\n#define mediump\n#define highp\n";
|
|
}
|
|
}
|
|
|
|
void setDefine(const char* _define)
|
|
{
|
|
m_tagptr->tag = FPPTAG_DEFINE;
|
|
m_tagptr->data = scratch(_define);
|
|
m_tagptr++;
|
|
}
|
|
|
|
void setDefaultDefine(const char* _name)
|
|
{
|
|
char temp[1024];
|
|
bx::snprintf(temp, BX_COUNTOF(temp)
|
|
, "#ifndef %s\n"
|
|
"# define %s 0\n"
|
|
"#endif // %s\n"
|
|
"\n"
|
|
, _name
|
|
, _name
|
|
, _name
|
|
);
|
|
|
|
m_default += temp;
|
|
}
|
|
|
|
void writef(const char* _format, ...)
|
|
{
|
|
va_list argList;
|
|
va_start(argList, _format);
|
|
bx::stringPrintfVargs(m_default, _format, argList);
|
|
va_end(argList);
|
|
}
|
|
|
|
void addInclude(const char* _includeDir)
|
|
{
|
|
char* start = scratch(_includeDir);
|
|
|
|
for (char* split = strchr(start, ';'); NULL != split; split = strchr(start, ';'))
|
|
{
|
|
*split = '\0';
|
|
m_tagptr->tag = FPPTAG_INCLUDE_DIR;
|
|
m_tagptr->data = start;
|
|
m_tagptr++;
|
|
start = split + 1;
|
|
}
|
|
|
|
m_tagptr->tag = FPPTAG_INCLUDE_DIR;
|
|
m_tagptr->data = start;
|
|
m_tagptr++;
|
|
}
|
|
|
|
void addDependency(const char* _fileName)
|
|
{
|
|
m_depends += " \\\n ";
|
|
m_depends += _fileName;
|
|
}
|
|
|
|
bool run(const char* _input)
|
|
{
|
|
m_fgetsPos = 0;
|
|
|
|
m_preprocessed.clear();
|
|
m_input = m_default;
|
|
m_input += "\n\n";
|
|
|
|
size_t len = strlen(_input)+1;
|
|
char* temp = new char[len];
|
|
bx::eolLF(temp, len, _input);
|
|
m_input += temp;
|
|
delete [] temp;
|
|
|
|
fppTag* tagptr = m_tagptr;
|
|
|
|
tagptr->tag = FPPTAG_END;
|
|
tagptr->data = 0;
|
|
tagptr++;
|
|
|
|
int result = fppPreProcess(m_tags);
|
|
|
|
return 0 == result;
|
|
}
|
|
|
|
char* fgets(char* _buffer, int _size)
|
|
{
|
|
int ii = 0;
|
|
for (char ch = m_input[m_fgetsPos]; m_fgetsPos < m_input.size() && ii < _size-1; ch = m_input[++m_fgetsPos])
|
|
{
|
|
_buffer[ii++] = ch;
|
|
|
|
if (ch == '\n' || ii == _size)
|
|
{
|
|
_buffer[ii] = '\0';
|
|
m_fgetsPos++;
|
|
return _buffer;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void fppDepends(char* _fileName, void* _userData)
|
|
{
|
|
Preprocessor* thisClass = (Preprocessor*)_userData;
|
|
thisClass->addDependency(_fileName);
|
|
}
|
|
|
|
static char* fppInput(char* _buffer, int _size, void* _userData)
|
|
{
|
|
Preprocessor* thisClass = (Preprocessor*)_userData;
|
|
return thisClass->fgets(_buffer, _size);
|
|
}
|
|
|
|
static void fppOutput(int _ch, void* _userData)
|
|
{
|
|
Preprocessor* thisClass = (Preprocessor*)_userData;
|
|
thisClass->m_preprocessed += _ch;
|
|
}
|
|
|
|
static void fppError(void* /*_userData*/, char* _format, va_list _vargs)
|
|
{
|
|
vfprintf(stderr, _format, _vargs);
|
|
}
|
|
|
|
char* scratch(const char* _str)
|
|
{
|
|
char* result = &m_scratch[m_scratchPos];
|
|
strcpy(result, _str);
|
|
m_scratchPos += (uint32_t)strlen(_str)+1;
|
|
|
|
return result;
|
|
}
|
|
|
|
fppTag m_tags[MAX_TAGS];
|
|
fppTag* m_tagptr;
|
|
|
|
std::string m_depends;
|
|
std::string m_default;
|
|
std::string m_input;
|
|
std::string m_preprocessed;
|
|
char m_scratch[16<<10];
|
|
uint32_t m_scratchPos;
|
|
uint32_t m_fgetsPos;
|
|
};
|
|
|
|
typedef std::vector<std::string> InOut;
|
|
|
|
uint32_t parseInOut(InOut& _inout, const char* _str, const char* _eol)
|
|
{
|
|
uint32_t hash = 0;
|
|
_str = bx::strws(_str);
|
|
|
|
if (_str < _eol)
|
|
{
|
|
const char* delim;
|
|
do
|
|
{
|
|
delim = strpbrk(_str, " ,");
|
|
if (NULL != delim)
|
|
{
|
|
delim = delim > _eol ? _eol : delim;
|
|
std::string token;
|
|
token.assign(_str, delim-_str);
|
|
_inout.push_back(token);
|
|
_str = bx::strws(delim + 1);
|
|
}
|
|
}
|
|
while (delim < _eol && _str < _eol && NULL != delim);
|
|
|
|
std::sort(_inout.begin(), _inout.end() );
|
|
|
|
bx::HashMurmur2A murmur;
|
|
murmur.begin();
|
|
for (InOut::const_iterator it = _inout.begin(), itEnd = _inout.end(); it != itEnd; ++it)
|
|
{
|
|
murmur.add(it->c_str(), (uint32_t)it->size() );
|
|
}
|
|
hash = murmur.end();
|
|
}
|
|
|
|
return hash;
|
|
}
|
|
|
|
void addFragData(Preprocessor& _preprocessor, char* _data, uint32_t _idx, bool _comma)
|
|
{
|
|
char find[32];
|
|
bx::snprintf(find, sizeof(find), "gl_FragData[%d]", _idx);
|
|
|
|
char replace[32];
|
|
bx::snprintf(replace, sizeof(replace), "gl_FragData_%d_", _idx);
|
|
|
|
strreplace(_data, find, replace);
|
|
|
|
_preprocessor.writef(
|
|
" \\\n\t%sout vec4 gl_FragData_%d_ : SV_TARGET%d"
|
|
, _comma ? ", " : " "
|
|
, _idx
|
|
, _idx
|
|
);
|
|
}
|
|
|
|
void voidFragData(char* _data, uint32_t _idx)
|
|
{
|
|
char find[32];
|
|
bx::snprintf(find, sizeof(find), "gl_FragData[%d]", _idx);
|
|
|
|
strreplace(_data, find, "bgfx_VoidFrag");
|
|
}
|
|
|
|
// c - compute
|
|
// d - domain
|
|
// f - fragment
|
|
// g - geometry
|
|
// h - hull
|
|
// v - vertex
|
|
//
|
|
// OpenGL #version Features Direct3D Features Shader Model
|
|
// 2.1 120 vf 9.0 vf 2.0
|
|
// 3.0 130
|
|
// 3.1 140
|
|
// 3.2 150 vgf
|
|
// 3.3 330 10.0 vgf 4.0
|
|
// 4.0 400 vhdgf
|
|
// 4.1 410
|
|
// 4.2 420 11.0 vhdgf+c 5.0
|
|
// 4.3 430 vhdgf+c
|
|
// 4.4 440
|
|
|
|
void help(const char* _error = NULL)
|
|
{
|
|
if (NULL != _error)
|
|
{
|
|
fprintf(stderr, "Error:\n%s\n\n", _error);
|
|
}
|
|
|
|
fprintf(stderr
|
|
, "shaderc, bgfx shader compiler tool\n"
|
|
"Copyright 2011-2014 Branimir Karadzic. All rights reserved.\n"
|
|
"License: http://www.opensource.org/licenses/BSD-2-Clause\n\n"
|
|
);
|
|
|
|
fprintf(stderr
|
|
, "Usage: shaderc -f <in> -o <out> --type <v/f> --platform <platform>\n"
|
|
|
|
"\n"
|
|
"Options:\n"
|
|
" -f <file path> Input file path.\n"
|
|
" -i <include path> Include path (for multiple paths use semicolon).\n"
|
|
" -o <file path> Output file path.\n"
|
|
" --bin2c <file path> Generate C header file.\n"
|
|
" --depends <file path> Generate makefile style depends file.\n"
|
|
" --platform <platform> Target platform.\n"
|
|
" android\n"
|
|
" asm.js\n"
|
|
" ios\n"
|
|
" linux\n"
|
|
" nacl\n"
|
|
" osx\n"
|
|
" windows\n"
|
|
" --preprocess Preprocess only.\n"
|
|
" --raw Do not process shader. No preprocessor, and no glsl-optimizer (GLSL only).\n"
|
|
" --type <type> Shader type (vertex, fragment)\n"
|
|
" --varyingdef <file path> Path to varying.def.sc file.\n"
|
|
" --verbose Verbose.\n"
|
|
|
|
"\n"
|
|
"Options (DX9 and DX11 only):\n"
|
|
|
|
"\n"
|
|
" --debug Debug information.\n"
|
|
" --disasm Disassemble compiled shader.\n"
|
|
" -p, --profile <profile> Shader model (f.e. ps_3_0).\n"
|
|
" -O <level> Optimization level (0, 1, 2, 3).\n"
|
|
" --Werror Treat warnings as errors.\n"
|
|
|
|
"\n"
|
|
"For additional information, see https://github.com/bkaradzic/bgfx\n"
|
|
);
|
|
}
|
|
|
|
int main(int _argc, const char* _argv[])
|
|
{
|
|
bx::CommandLine cmdLine(_argc, _argv);
|
|
|
|
if (cmdLine.hasArg('h', "help") )
|
|
{
|
|
help();
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
g_verbose = cmdLine.hasArg("verbose");
|
|
|
|
const char* filePath = cmdLine.findOption('f');
|
|
if (NULL == filePath)
|
|
{
|
|
help("Shader file name must be specified.");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
const char* outFilePath = cmdLine.findOption('o');
|
|
if (NULL == outFilePath)
|
|
{
|
|
help("Output file name must be specified.");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
const char* type = cmdLine.findOption('\0', "type");
|
|
if (NULL == type)
|
|
{
|
|
help("Must specify shader type.");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
const char* platform = cmdLine.findOption('\0', "platform");
|
|
if (NULL == platform)
|
|
{
|
|
help("Must specify platform.");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
bool raw = cmdLine.hasArg('\0', "raw");
|
|
|
|
uint32_t gles = 0;
|
|
uint32_t hlsl = 2;
|
|
uint32_t d3d = 11;
|
|
const char* profile = cmdLine.findOption('p', "profile");
|
|
if (NULL != profile)
|
|
{
|
|
if (0 == strncmp(&profile[1], "s_4_0_level", 11) )
|
|
{
|
|
hlsl = 2;
|
|
}
|
|
else if (0 == strncmp(&profile[1], "s_3", 3) )
|
|
{
|
|
hlsl = 3;
|
|
d3d = 9;
|
|
}
|
|
else if (0 == strncmp(&profile[1], "s_4", 3) )
|
|
{
|
|
hlsl = 4;
|
|
}
|
|
else if (0 == strncmp(&profile[1], "s_5", 3) )
|
|
{
|
|
hlsl = 5;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
gles = 2;
|
|
}
|
|
|
|
const char* bin2c = NULL;
|
|
if (cmdLine.hasArg("bin2c") )
|
|
{
|
|
bin2c = cmdLine.findOption("bin2c");
|
|
if (NULL == bin2c)
|
|
{
|
|
bin2c = bx::baseName(outFilePath);
|
|
uint32_t len = (uint32_t)strlen(bin2c);
|
|
char* temp = (char*)alloca(len+1);
|
|
for (char *out = temp; *bin2c != '\0';)
|
|
{
|
|
char ch = *bin2c++;
|
|
if (isalnum(ch) )
|
|
{
|
|
*out++ = ch;
|
|
}
|
|
else
|
|
{
|
|
*out++ = '_';
|
|
}
|
|
}
|
|
temp[len] = '\0';
|
|
|
|
bin2c = temp;
|
|
}
|
|
}
|
|
|
|
bool depends = cmdLine.hasArg("depends");
|
|
bool preprocessOnly = cmdLine.hasArg("preprocess");
|
|
const char* includeDir = cmdLine.findOption('i');
|
|
|
|
Preprocessor preprocessor(filePath, 0 != gles, includeDir);
|
|
|
|
std::string dir;
|
|
{
|
|
const char* base = bx::baseName(filePath);
|
|
|
|
if (base != filePath)
|
|
{
|
|
dir.assign(filePath, base-filePath);
|
|
preprocessor.addInclude(dir.c_str() );
|
|
}
|
|
}
|
|
|
|
preprocessor.setDefaultDefine("BX_PLATFORM_ANDROID");
|
|
preprocessor.setDefaultDefine("BX_PLATFORM_EMSCRIPTEN");
|
|
preprocessor.setDefaultDefine("BX_PLATFORM_IOS");
|
|
preprocessor.setDefaultDefine("BX_PLATFORM_LINUX");
|
|
preprocessor.setDefaultDefine("BX_PLATFORM_NACL");
|
|
preprocessor.setDefaultDefine("BX_PLATFORM_OSX");
|
|
preprocessor.setDefaultDefine("BX_PLATFORM_WINDOWS");
|
|
preprocessor.setDefaultDefine("BX_PLATFORM_XBOX360");
|
|
// preprocessor.setDefaultDefine("BGFX_SHADER_LANGUAGE_ESSL");
|
|
preprocessor.setDefaultDefine("BGFX_SHADER_LANGUAGE_GLSL");
|
|
preprocessor.setDefaultDefine("BGFX_SHADER_LANGUAGE_HLSL");
|
|
preprocessor.setDefaultDefine("BGFX_SHADER_TYPE_COMPUTE");
|
|
preprocessor.setDefaultDefine("BGFX_SHADER_TYPE_FRAGMENT");
|
|
preprocessor.setDefaultDefine("BGFX_SHADER_TYPE_VERTEX");
|
|
|
|
bool glsl = false;
|
|
|
|
if (0 == bx::stricmp(platform, "android") )
|
|
{
|
|
preprocessor.setDefine("BX_PLATFORM_ANDROID=1");
|
|
preprocessor.setDefine("BGFX_SHADER_LANGUAGE_GLSL=1");
|
|
glsl = true;
|
|
}
|
|
else if (0 == bx::stricmp(platform, "asm.js") )
|
|
{
|
|
preprocessor.setDefine("BX_PLATFORM_EMSCRIPTEN=1");
|
|
preprocessor.setDefine("BGFX_SHADER_LANGUAGE_GLSL=1");
|
|
glsl = true;
|
|
}
|
|
else if (0 == bx::stricmp(platform, "ios") )
|
|
{
|
|
preprocessor.setDefine("BX_PLATFORM_IOS=1");
|
|
preprocessor.setDefine("BGFX_SHADER_LANGUAGE_GLSL=1");
|
|
glsl = true;
|
|
}
|
|
else if (0 == bx::stricmp(platform, "linux") )
|
|
{
|
|
preprocessor.setDefine("BX_PLATFORM_LINUX=1");
|
|
preprocessor.setDefine("BGFX_SHADER_LANGUAGE_GLSL=1");
|
|
glsl = true;
|
|
}
|
|
else if (0 == bx::stricmp(platform, "nacl") )
|
|
{
|
|
preprocessor.setDefine("BX_PLATFORM_NACL=1");
|
|
preprocessor.setDefine("BGFX_SHADER_LANGUAGE_GLSL=1");
|
|
glsl = true;
|
|
}
|
|
else if (0 == bx::stricmp(platform, "osx") )
|
|
{
|
|
preprocessor.setDefine("BX_PLATFORM_OSX=1");
|
|
preprocessor.setDefine("BGFX_SHADER_LANGUAGE_GLSL=1");
|
|
glsl = true;
|
|
}
|
|
else if (0 == bx::stricmp(platform, "windows") )
|
|
{
|
|
preprocessor.setDefine("BX_PLATFORM_WINDOWS=1");
|
|
char temp[256];
|
|
bx::snprintf(temp, sizeof(temp), "BGFX_SHADER_LANGUAGE_HLSL=%d", hlsl);
|
|
preprocessor.setDefine(temp);
|
|
}
|
|
else if (0 == bx::stricmp(platform, "xbox360") )
|
|
{
|
|
preprocessor.setDefine("BX_PLATFORM_XBOX360=1");
|
|
preprocessor.setDefine("BGFX_SHADER_LANGUAGE_HLSL=3");
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "Unknown platform %s?!", platform);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
preprocessor.setDefine("M_PI=3.1415926535897932384626433832795");
|
|
|
|
char shaderType = tolower(type[0]);
|
|
switch (shaderType)
|
|
{
|
|
case 'c':
|
|
preprocessor.setDefine("BGFX_SHADER_TYPE_COMPUTE=1");
|
|
break;
|
|
|
|
case 'f':
|
|
preprocessor.setDefine("BGFX_SHADER_TYPE_FRAGMENT=1");
|
|
break;
|
|
|
|
case 'v':
|
|
preprocessor.setDefine("BGFX_SHADER_TYPE_VERTEX=1");
|
|
break;
|
|
|
|
default:
|
|
fprintf(stderr, "Unknown type: %s?!", type);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
bool compiled = false;
|
|
|
|
FILE* file = fopen(filePath, "r");
|
|
if (NULL != file)
|
|
{
|
|
VaryingMap varyingMap;
|
|
|
|
std::string defaultVarying = dir + "varying.def.sc";
|
|
const char* varyingdef = cmdLine.findOption("varyingdef", defaultVarying.c_str() );
|
|
File attribdef(varyingdef);
|
|
const char* parse = attribdef.getData();
|
|
if (NULL != parse
|
|
&& *parse != '\0')
|
|
{
|
|
preprocessor.addDependency(varyingdef);
|
|
}
|
|
|
|
while (NULL != parse
|
|
&& *parse != '\0')
|
|
{
|
|
parse = bx::strws(parse);
|
|
const char* eol = strchr(parse, ';');
|
|
if (NULL == eol)
|
|
{
|
|
eol = bx::streol(parse);
|
|
}
|
|
|
|
if (NULL != eol)
|
|
{
|
|
const char* precision = NULL;
|
|
const char* interpolation = NULL;
|
|
const char* type = parse;
|
|
|
|
if (0 == strncmp(type, "lowp", 4)
|
|
|| 0 == strncmp(type, "mediump", 7)
|
|
|| 0 == strncmp(type, "highp", 5) )
|
|
{
|
|
precision = type;
|
|
type = parse = bx::strws(bx::strword(parse) );
|
|
}
|
|
|
|
if (0 == strncmp(type, "flat", 4)
|
|
|| 0 == strncmp(type, "smooth", 6)
|
|
|| 0 == strncmp(type, "noperspective", 13) )
|
|
{
|
|
interpolation = type;
|
|
type = parse = bx::strws(bx::strword(parse) );
|
|
}
|
|
|
|
const char* name = parse = bx::strws(bx::strword(parse) );
|
|
const char* column = parse = bx::strws(bx::strword(parse) );
|
|
const char* semantics = parse = bx::strws(bx::strnws (parse) );
|
|
const char* assign = parse = bx::strws(bx::strword(parse) );
|
|
const char* init = parse = bx::strws(bx::strnws (parse) );
|
|
|
|
if (type < eol
|
|
&& name < eol
|
|
&& column < eol
|
|
&& ':' == *column
|
|
&& semantics < eol)
|
|
{
|
|
Varying var;
|
|
if (NULL != precision)
|
|
{
|
|
var.m_precision.assign(precision, bx::strword(precision)-precision);
|
|
}
|
|
|
|
if (NULL != interpolation)
|
|
{
|
|
var.m_interpolation.assign(interpolation, bx::strword(interpolation)-interpolation);
|
|
}
|
|
|
|
var.m_type.assign(type, bx::strword(type)-type);
|
|
var.m_name.assign(name, bx::strword(name)-name);
|
|
var.m_semantics.assign(semantics, bx::strword(semantics)-semantics);
|
|
|
|
if (assign < eol
|
|
&& '=' == *assign
|
|
&& init < eol)
|
|
{
|
|
var.m_init.assign(init, eol-init);
|
|
}
|
|
|
|
varyingMap.insert(std::make_pair(var.m_name, var) );
|
|
}
|
|
|
|
parse = bx::strnl(eol);
|
|
}
|
|
}
|
|
|
|
InOut shaderInputs;
|
|
InOut shaderOutputs;
|
|
uint32_t inputHash = 0;
|
|
uint32_t outputHash = 0;
|
|
|
|
char* data;
|
|
char* input;
|
|
{
|
|
const size_t padding = 1024;
|
|
uint32_t size = (uint32_t)fsize(file);
|
|
data = new char[size+padding+1];
|
|
size = (uint32_t)fread(data, 1, size, file);
|
|
// Compiler generates "error X3000: syntax error: unexpected end of file"
|
|
// if input doesn't have empty line at EOF.
|
|
data[size] = '\n';
|
|
memset(&data[size+1], 0, padding);
|
|
fclose(file);
|
|
|
|
input = const_cast<char*>(bx::strws(data) );
|
|
while (input[0] == '$')
|
|
{
|
|
const char* str = bx::strws(input+1);
|
|
const char* eol = bx::streol(str);
|
|
const char* nl = bx::strnl(eol);
|
|
input = const_cast<char*>(nl);
|
|
|
|
if (0 == strncmp(str, "input", 5) )
|
|
{
|
|
str += 5;
|
|
const char* comment = strstr(str, "//");
|
|
eol = NULL != comment && comment < eol ? comment : eol;
|
|
inputHash = parseInOut(shaderInputs, str, eol);
|
|
}
|
|
else if (0 == strncmp(str, "output", 6) )
|
|
{
|
|
str += 6;
|
|
const char* comment = strstr(str, "//");
|
|
eol = NULL != comment && comment < eol ? comment : eol;
|
|
outputHash = parseInOut(shaderOutputs, str, eol);
|
|
}
|
|
else if (0 == strncmp(str, "raw", 3) )
|
|
{
|
|
raw = true;
|
|
str += 3;
|
|
}
|
|
}
|
|
|
|
if (!raw)
|
|
{
|
|
// To avoid commented code being recognized as used feature,
|
|
// first preprocess pass is used to strip all comments before
|
|
// substituting code.
|
|
preprocessor.run(input);
|
|
delete [] data;
|
|
|
|
size = (uint32_t)preprocessor.m_preprocessed.size();
|
|
data = new char[size+padding+1];
|
|
memcpy(data, preprocessor.m_preprocessed.c_str(), size);
|
|
memset(&data[size], 0, padding+1);
|
|
input = data;
|
|
}
|
|
}
|
|
|
|
if (raw)
|
|
{
|
|
bx::CrtFileWriter* writer = NULL;
|
|
|
|
if (NULL != bin2c)
|
|
{
|
|
writer = new Bin2cWriter(bin2c);
|
|
}
|
|
else
|
|
{
|
|
writer = new bx::CrtFileWriter;
|
|
}
|
|
|
|
if (0 != writer->open(outFilePath) )
|
|
{
|
|
fprintf(stderr, "Unable to open output file '%s'.", outFilePath);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
uint32_t inputHash = 0;
|
|
uint32_t outputHash = 0;
|
|
|
|
if ('f' == shaderType)
|
|
{
|
|
bx::write(writer, BGFX_CHUNK_MAGIC_FSH);
|
|
bx::write(writer, inputHash);
|
|
}
|
|
else if ('v' == shaderType)
|
|
{
|
|
bx::write(writer, BGFX_CHUNK_MAGIC_VSH);
|
|
bx::write(writer, outputHash);
|
|
}
|
|
else
|
|
{
|
|
bx::write(writer, BGFX_CHUNK_MAGIC_CSH);
|
|
bx::write(writer, outputHash);
|
|
}
|
|
|
|
if (glsl)
|
|
{
|
|
bx::write(writer, uint16_t(0) );
|
|
|
|
uint32_t shaderSize = (uint32_t)strlen(input);
|
|
bx::write(writer, shaderSize);
|
|
bx::write(writer, input, shaderSize);
|
|
bx::write(writer, uint8_t(0) );
|
|
|
|
compiled = true;
|
|
}
|
|
else
|
|
{
|
|
if (d3d > 9)
|
|
{
|
|
compiled = compileHLSLShaderDx11(cmdLine, input, writer);
|
|
}
|
|
else
|
|
{
|
|
compiled = compileHLSLShaderDx9(cmdLine, input, writer);
|
|
}
|
|
}
|
|
|
|
writer->close();
|
|
delete writer;
|
|
}
|
|
else if ('c' == shaderType) // Compute
|
|
{
|
|
char* entry = strstr(input, "void main()");
|
|
if (NULL == entry)
|
|
{
|
|
fprintf(stderr, "Shader entry point 'void main()' is not found.\n");
|
|
}
|
|
else
|
|
{
|
|
if (glsl)
|
|
{
|
|
}
|
|
else
|
|
{
|
|
preprocessor.writef(
|
|
"#define lowp\n"
|
|
"#define mediump\n"
|
|
"#define highp\n"
|
|
"#define ivec2 int2\n"
|
|
"#define ivec3 int3\n"
|
|
"#define ivec4 int4\n"
|
|
"#define uvec2 uint2\n"
|
|
"#define uvec3 uint3\n"
|
|
"#define uvec4 uint4\n"
|
|
"#define vec2 float2\n"
|
|
"#define vec3 float3\n"
|
|
"#define vec4 float4\n"
|
|
"#define mat2 float2x2\n"
|
|
"#define mat3 float3x3\n"
|
|
"#define mat4 float4x4\n"
|
|
);
|
|
|
|
entry[4] = '_';
|
|
|
|
preprocessor.writef("#define void_main()");
|
|
preprocessor.writef(" \\\n\tvoid main(");
|
|
|
|
uint32_t arg = 0;
|
|
|
|
const bool hasLocalInvocationID = NULL != strstr(input, "gl_LocalInvocationID");
|
|
const bool hasLocalInvocationIndex = NULL != strstr(input, "gl_LocalInvocationIndex");
|
|
const bool hasGlobalInvocationID = NULL != strstr(input, "gl_GlobalInvocationID");
|
|
const bool hasWorkGroupID = NULL != strstr(input, "gl_WorkGroupID");
|
|
|
|
if (hasLocalInvocationID)
|
|
{
|
|
preprocessor.writef(
|
|
" \\\n\t%sint3 gl_LocalInvocationID : SV_GroupThreadID"
|
|
, arg++ > 0 ? ", " : " "
|
|
);
|
|
}
|
|
|
|
if (hasLocalInvocationIndex)
|
|
{
|
|
preprocessor.writef(
|
|
" \\\n\t%sint gl_LocalInvocationIndex : SV_GroupIndex"
|
|
, arg++ > 0 ? ", " : " "
|
|
);
|
|
}
|
|
|
|
if (hasGlobalInvocationID)
|
|
{
|
|
preprocessor.writef(
|
|
" \\\n\t%sint3 gl_GlobalInvocationID : SV_DispatchThreadID"
|
|
, arg++ > 0 ? ", " : " "
|
|
);
|
|
}
|
|
|
|
if (hasWorkGroupID)
|
|
{
|
|
preprocessor.writef(
|
|
" \\\n\t%sint3 gl_WorkGroupID : SV_GroupID"
|
|
, arg++ > 0 ? ", " : " "
|
|
);
|
|
}
|
|
|
|
preprocessor.writef(
|
|
" \\\n\t)\n"
|
|
);
|
|
}
|
|
|
|
if (preprocessor.run(input) )
|
|
{
|
|
BX_TRACE("Input file: %s", filePath);
|
|
BX_TRACE("Output file: %s", outFilePath);
|
|
|
|
if (preprocessOnly)
|
|
{
|
|
bx::CrtFileWriter writer;
|
|
|
|
if (0 != writer.open(outFilePath) )
|
|
{
|
|
fprintf(stderr, "Unable to open output file '%s'.", outFilePath);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
writer.write(preprocessor.m_preprocessed.c_str(), (int32_t)preprocessor.m_preprocessed.size() );
|
|
writer.close();
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
{
|
|
bx::CrtFileWriter* writer = NULL;
|
|
|
|
if (NULL != bin2c)
|
|
{
|
|
writer = new Bin2cWriter(bin2c);
|
|
}
|
|
else
|
|
{
|
|
writer = new bx::CrtFileWriter;
|
|
}
|
|
|
|
if (0 != writer->open(outFilePath) )
|
|
{
|
|
fprintf(stderr, "Unable to open output file '%s'.", outFilePath);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
bx::write(writer, BGFX_CHUNK_MAGIC_CSH);
|
|
bx::write(writer, outputHash);
|
|
|
|
if (glsl)
|
|
{
|
|
std::string code;
|
|
|
|
if (gles)
|
|
{
|
|
bx::stringPrintf(code, "#version 310 es\n");
|
|
}
|
|
else
|
|
{
|
|
int32_t version = atoi(profile);
|
|
bx::stringPrintf(code, "#version %d\n", version == 0 ? 430 : version);
|
|
}
|
|
|
|
code += preprocessor.m_preprocessed;
|
|
#if 1
|
|
bx::write(writer, uint16_t(0) );
|
|
|
|
uint32_t shaderSize = (uint32_t)code.size();
|
|
bx::write(writer, shaderSize);
|
|
bx::write(writer, code.c_str(), shaderSize);
|
|
bx::write(writer, uint8_t(0) );
|
|
|
|
compiled = true;
|
|
#else
|
|
compiled = compileGLSLShader(cmdLine, gles, code, writer);
|
|
#endif // 0
|
|
}
|
|
else
|
|
{
|
|
if (d3d > 9)
|
|
{
|
|
compiled = compileHLSLShaderDx11(cmdLine, preprocessor.m_preprocessed, writer);
|
|
}
|
|
else
|
|
{
|
|
compiled = compileHLSLShaderDx9(cmdLine, preprocessor.m_preprocessed, writer);
|
|
}
|
|
}
|
|
|
|
writer->close();
|
|
delete writer;
|
|
}
|
|
|
|
if (compiled)
|
|
{
|
|
if (depends)
|
|
{
|
|
std::string ofp = outFilePath;
|
|
ofp += ".d";
|
|
bx::CrtFileWriter writer;
|
|
if (0 == writer.open(ofp.c_str() ) )
|
|
{
|
|
writef(&writer, "%s : %s\n", outFilePath, preprocessor.m_depends.c_str() );
|
|
writer.close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else // Vertex/Fragment
|
|
{
|
|
char* entry = strstr(input, "void main()");
|
|
if (NULL == entry)
|
|
{
|
|
fprintf(stderr, "Shader entry point 'void main()' is not found.\n");
|
|
}
|
|
else
|
|
{
|
|
if (glsl)
|
|
{
|
|
preprocessor.writef(
|
|
"#define ivec2 vec2\n"
|
|
"#define ivec3 vec3\n"
|
|
"#define ivec4 vec4\n"
|
|
);
|
|
|
|
if (0 == gles)
|
|
{
|
|
// bgfx shadow2D/Proj behave like EXT_shadow_samplers
|
|
// not as GLSL language 1.2 specs shadow2D/Proj.
|
|
preprocessor.writef(
|
|
"#define shadow2D(_sampler, _coord) bgfxShadow2D(_sampler, _coord).x\n"
|
|
"#define shadow2DProj(_sampler, _coord) bgfxShadow2DProj(_sampler, _coord).x\n"
|
|
);
|
|
}
|
|
|
|
for (InOut::const_iterator it = shaderInputs.begin(), itEnd = shaderInputs.end(); it != itEnd; ++it)
|
|
{
|
|
VaryingMap::const_iterator varyingIt = varyingMap.find(*it);
|
|
if (varyingIt != varyingMap.end() )
|
|
{
|
|
const Varying& var = varyingIt->second;
|
|
const char* name = var.m_name.c_str();
|
|
|
|
if (0 == strncmp(name, "a_", 2)
|
|
|| 0 == strncmp(name, "i_", 2) )
|
|
{
|
|
preprocessor.writef("attribute %s %s %s %s;\n"
|
|
, var.m_precision.c_str()
|
|
, var.m_interpolation.c_str()
|
|
, var.m_type.c_str()
|
|
, name
|
|
);
|
|
}
|
|
else
|
|
{
|
|
preprocessor.writef("%s varying %s %s %s;\n"
|
|
, var.m_interpolation.c_str()
|
|
, var.m_precision.c_str()
|
|
, var.m_type.c_str()
|
|
, name
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (InOut::const_iterator it = shaderOutputs.begin(), itEnd = shaderOutputs.end(); it != itEnd; ++it)
|
|
{
|
|
VaryingMap::const_iterator varyingIt = varyingMap.find(*it);
|
|
if (varyingIt != varyingMap.end() )
|
|
{
|
|
const Varying& var = varyingIt->second;
|
|
preprocessor.writef("%s varying %s %s;\n"
|
|
, var.m_interpolation.c_str()
|
|
, var.m_type.c_str()
|
|
, var.m_name.c_str()
|
|
);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
preprocessor.writef(
|
|
"#define lowp\n"
|
|
"#define mediump\n"
|
|
"#define highp\n"
|
|
"#define ivec2 int2\n"
|
|
"#define ivec3 int3\n"
|
|
"#define ivec4 int4\n"
|
|
"#define uvec2 uint2\n"
|
|
"#define uvec3 uint3\n"
|
|
"#define uvec4 uint4\n"
|
|
"#define vec2 float2\n"
|
|
"#define vec3 float3\n"
|
|
"#define vec4 float4\n"
|
|
"#define mat2 float2x2\n"
|
|
"#define mat3 float3x3\n"
|
|
"#define mat4 float4x4\n"
|
|
);
|
|
|
|
if (hlsl < 4)
|
|
{
|
|
preprocessor.writef(
|
|
"#define flat\n"
|
|
"#define smooth\n"
|
|
"#define noperspective\n"
|
|
);
|
|
}
|
|
|
|
entry[4] = '_';
|
|
|
|
if ('f' == shaderType)
|
|
{
|
|
const char* brace = strstr(entry, "{");
|
|
if (NULL != brace)
|
|
{
|
|
strins(const_cast<char*>(brace+1), "\nvec4 bgfx_VoidFrag;\n");
|
|
}
|
|
|
|
const bool hasFragCoord = NULL != strstr(input, "gl_FragCoord") || hlsl > 3;
|
|
const bool hasFragDepth = NULL != strstr(input, "gl_FragDepth");
|
|
const bool hasFrontFacing = NULL != strstr(input, "gl_FrontFacing");
|
|
bool hasFragData[8] = {};
|
|
uint32_t numFragData = 0;
|
|
for (uint32_t ii = 0; ii < BX_COUNTOF(hasFragData); ++ii)
|
|
{
|
|
char temp[32];
|
|
bx::snprintf(temp, BX_COUNTOF(temp), "gl_FragData[%d]", ii);
|
|
hasFragData[ii] = NULL != strstr(input, temp);
|
|
numFragData += hasFragData[ii];
|
|
}
|
|
|
|
if (0 == numFragData)
|
|
{
|
|
// GL errors when both gl_FragColor and gl_FragData is used.
|
|
// This will trigger the same error with HLSL compiler too.
|
|
preprocessor.writef("#define gl_FragColor gl_FragData_0_\n");
|
|
}
|
|
|
|
preprocessor.writef("#define void_main()");
|
|
preprocessor.writef(" \\\n\tvoid main(");
|
|
|
|
uint32_t arg = 0;
|
|
|
|
if (hasFragCoord)
|
|
{
|
|
preprocessor.writef(" \\\n\tvec4 gl_FragCoord : SV_POSITION");
|
|
++arg;
|
|
}
|
|
|
|
for (InOut::const_iterator it = shaderInputs.begin(), itEnd = shaderInputs.end(); it != itEnd; ++it)
|
|
{
|
|
VaryingMap::const_iterator varyingIt = varyingMap.find(*it);
|
|
if (varyingIt != varyingMap.end() )
|
|
{
|
|
const Varying& var = varyingIt->second;
|
|
preprocessor.writef(" \\\n\t%s%s %s %s : %s"
|
|
, arg++ > 0 ? ", " : " "
|
|
, interpolationDx11(var.m_interpolation.c_str() )
|
|
, var.m_type.c_str()
|
|
, var.m_name.c_str()
|
|
, var.m_semantics.c_str()
|
|
);
|
|
}
|
|
}
|
|
|
|
addFragData(preprocessor, input, 0, arg++ > 0);
|
|
|
|
const uint32_t maxRT = d3d > 9 ? BX_COUNTOF(hasFragData) : 4;
|
|
|
|
for (uint32_t ii = 1; ii < BX_COUNTOF(hasFragData); ++ii)
|
|
{
|
|
if (ii < maxRT)
|
|
{
|
|
if (hasFragData[ii])
|
|
{
|
|
addFragData(preprocessor, input, ii, arg++ > 0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
voidFragData(input, ii);
|
|
}
|
|
}
|
|
|
|
if (hasFragDepth)
|
|
{
|
|
preprocessor.writef(
|
|
" \\\n\t%sout float gl_FragDepth : SV_DEPTH"
|
|
, arg++ > 0 ? ", " : " "
|
|
);
|
|
}
|
|
|
|
if (hasFrontFacing
|
|
&& hlsl >= 3)
|
|
{
|
|
preprocessor.writef(
|
|
" \\\n\t%sfloat __vface : VFACE"
|
|
, arg++ > 0 ? ", " : " "
|
|
);
|
|
}
|
|
|
|
preprocessor.writef(
|
|
" \\\n\t)\n"
|
|
);
|
|
|
|
if (hasFrontFacing)
|
|
{
|
|
if (hlsl >= 3)
|
|
{
|
|
preprocessor.writef(
|
|
"#define gl_FrontFacing (__vface <= 0.0)\n"
|
|
);
|
|
}
|
|
else
|
|
{
|
|
preprocessor.writef(
|
|
"#define gl_FrontFacing false\n"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
else if ('v' == shaderType)
|
|
{
|
|
const char* brace = strstr(entry, "{");
|
|
if (NULL != brace)
|
|
{
|
|
const char* end = bx::strmb(brace, '{', '}');
|
|
if (NULL != end)
|
|
{
|
|
strins(const_cast<char*>(end), "__RETURN__;\n");
|
|
}
|
|
}
|
|
|
|
preprocessor.writef(
|
|
"struct Output\n"
|
|
"{\n"
|
|
"\tvec4 gl_Position : SV_POSITION;\n"
|
|
"#define gl_Position _varying_.gl_Position\n"
|
|
);
|
|
for (InOut::const_iterator it = shaderOutputs.begin(), itEnd = shaderOutputs.end(); it != itEnd; ++it)
|
|
{
|
|
VaryingMap::const_iterator varyingIt = varyingMap.find(*it);
|
|
if (varyingIt != varyingMap.end() )
|
|
{
|
|
const Varying& var = varyingIt->second;
|
|
preprocessor.writef("\t%s %s : %s;\n", var.m_type.c_str(), var.m_name.c_str(), var.m_semantics.c_str() );
|
|
preprocessor.writef("#define %s _varying_.%s\n", var.m_name.c_str(), var.m_name.c_str() );
|
|
}
|
|
}
|
|
preprocessor.writef(
|
|
"};\n"
|
|
);
|
|
|
|
preprocessor.writef("#define void_main() \\\n");
|
|
preprocessor.writef("Output main(");
|
|
bool first = true;
|
|
for (InOut::const_iterator it = shaderInputs.begin(), itEnd = shaderInputs.end(); it != itEnd; ++it)
|
|
{
|
|
VaryingMap::const_iterator varyingIt = varyingMap.find(*it);
|
|
if (varyingIt != varyingMap.end() )
|
|
{
|
|
const Varying& var = varyingIt->second;
|
|
preprocessor.writef("%s%s %s : %s\\\n", first ? "" : "\t, ", var.m_type.c_str(), var.m_name.c_str(), var.m_semantics.c_str() );
|
|
first = false;
|
|
}
|
|
}
|
|
preprocessor.writef(
|
|
") \\\n"
|
|
"{ \\\n"
|
|
"\tOutput _varying_;"
|
|
);
|
|
|
|
for (InOut::const_iterator it = shaderOutputs.begin(), itEnd = shaderOutputs.end(); it != itEnd; ++it)
|
|
{
|
|
VaryingMap::const_iterator varyingIt = varyingMap.find(*it);
|
|
if (varyingIt != varyingMap.end() )
|
|
{
|
|
const Varying& var = varyingIt->second;
|
|
preprocessor.writef(" \\\n\t%s = %s;", var.m_name.c_str(), var.m_init.c_str() );
|
|
}
|
|
}
|
|
|
|
preprocessor.writef(
|
|
"\n#define __RETURN__ \\\n"
|
|
"\t} \\\n"
|
|
"\treturn _varying_"
|
|
);
|
|
}
|
|
}
|
|
|
|
if (preprocessor.run(input) )
|
|
{
|
|
BX_TRACE("Input file: %s", filePath);
|
|
BX_TRACE("Output file: %s", outFilePath);
|
|
|
|
if (preprocessOnly)
|
|
{
|
|
bx::CrtFileWriter writer;
|
|
|
|
if (0 != writer.open(outFilePath) )
|
|
{
|
|
fprintf(stderr, "Unable to open output file '%s'.", outFilePath);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
if (glsl)
|
|
{
|
|
const char* profile = cmdLine.findOption('p', "profile");
|
|
if (NULL == profile)
|
|
{
|
|
writef(&writer
|
|
, "#ifdef GL_ES\n"
|
|
"precision highp float;\n"
|
|
"#endif // GL_ES\n\n"
|
|
);
|
|
}
|
|
}
|
|
writer.write(preprocessor.m_preprocessed.c_str(), (int32_t)preprocessor.m_preprocessed.size() );
|
|
writer.close();
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
{
|
|
bx::CrtFileWriter* writer = NULL;
|
|
|
|
if (NULL != bin2c)
|
|
{
|
|
writer = new Bin2cWriter(bin2c);
|
|
}
|
|
else
|
|
{
|
|
writer = new bx::CrtFileWriter;
|
|
}
|
|
|
|
if (0 != writer->open(outFilePath) )
|
|
{
|
|
fprintf(stderr, "Unable to open output file '%s'.", outFilePath);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
if ('f' == shaderType)
|
|
{
|
|
bx::write(writer, BGFX_CHUNK_MAGIC_FSH);
|
|
bx::write(writer, inputHash);
|
|
}
|
|
else if ('v' == shaderType)
|
|
{
|
|
bx::write(writer, BGFX_CHUNK_MAGIC_VSH);
|
|
bx::write(writer, outputHash);
|
|
}
|
|
else
|
|
{
|
|
bx::write(writer, BGFX_CHUNK_MAGIC_CSH);
|
|
bx::write(writer, outputHash);
|
|
}
|
|
|
|
if (glsl)
|
|
{
|
|
std::string code;
|
|
|
|
bool hasTextureLod = NULL != bx::findIdentifierMatch(input, s_ARB_shader_texture_lod /*EXT_shader_texture_lod*/);
|
|
|
|
if (0 == gles)
|
|
{
|
|
bx::stringPrintf(code, "#version %s\n", profile);
|
|
int32_t version = atoi(profile);
|
|
|
|
bx::stringPrintf(code
|
|
, "#define bgfxShadow2D shadow2D\n"
|
|
"#define bgfxShadow2DProj shadow2DProj\n"
|
|
);
|
|
|
|
if (hasTextureLod
|
|
&& 130 > version)
|
|
{
|
|
bx::stringPrintf(code
|
|
, "#extension GL_ARB_shader_texture_lod : enable\n"
|
|
);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Pretend that all extensions are available.
|
|
// This will be stripped later.
|
|
if (hasTextureLod)
|
|
{
|
|
bx::stringPrintf(code
|
|
, "#extension GL_EXT_shader_texture_lod : enable\n"
|
|
"#define texture2DLod texture2DLodEXT\n"
|
|
"#define texture2DProjLod texture2DProjLodEXT\n"
|
|
"#define textureCubeLod textureCubeLodEXT\n"
|
|
// "#define texture2DGrad texture2DGradEXT\n"
|
|
// "#define texture2DProjGrad texture2DProjGradEXT\n"
|
|
// "#define textureCubeGrad textureCubeGradEXT\n"
|
|
);
|
|
}
|
|
|
|
if (NULL != bx::findIdentifierMatch(input, s_OES_standard_derivatives) )
|
|
{
|
|
bx::stringPrintf(code, "#extension GL_OES_standard_derivatives : enable\n");
|
|
}
|
|
|
|
if (NULL != bx::findIdentifierMatch(input, s_OES_texture_3D) )
|
|
{
|
|
bx::stringPrintf(code, "#extension GL_OES_texture_3D : enable\n");
|
|
}
|
|
|
|
if (NULL != bx::findIdentifierMatch(input, s_EXT_shadow_samplers) )
|
|
{
|
|
bx::stringPrintf(code
|
|
, "#extension GL_EXT_shadow_samplers : enable\n"
|
|
"#define shadow2D shadow2DEXT\n"
|
|
"#define shadow2DProj shadow2DProjEXT\n"
|
|
);
|
|
}
|
|
|
|
if (NULL != bx::findIdentifierMatch(input, "gl_FragDepth") )
|
|
{
|
|
bx::stringPrintf(code
|
|
, "#extension GL_EXT_frag_depth : enable\n"
|
|
"#define gl_FragDepth gl_FragDepthEXT\n"
|
|
);
|
|
}
|
|
}
|
|
|
|
code += preprocessor.m_preprocessed;
|
|
compiled = compileGLSLShader(cmdLine, gles, code, writer);
|
|
}
|
|
else
|
|
{
|
|
if (d3d > 9)
|
|
{
|
|
compiled = compileHLSLShaderDx11(cmdLine, preprocessor.m_preprocessed, writer);
|
|
}
|
|
else
|
|
{
|
|
compiled = compileHLSLShaderDx9(cmdLine, preprocessor.m_preprocessed, writer);
|
|
}
|
|
}
|
|
|
|
writer->close();
|
|
delete writer;
|
|
}
|
|
|
|
if (compiled)
|
|
{
|
|
if (depends)
|
|
{
|
|
std::string ofp = outFilePath;
|
|
ofp += ".d";
|
|
bx::CrtFileWriter writer;
|
|
if (0 == writer.open(ofp.c_str() ) )
|
|
{
|
|
writef(&writer, "%s : %s\n", outFilePath, preprocessor.m_depends.c_str() );
|
|
writer.close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
delete [] data;
|
|
}
|
|
|
|
if (compiled)
|
|
{
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
remove(outFilePath);
|
|
|
|
fprintf(stderr, "Failed to build shader.\n");
|
|
return EXIT_FAILURE;
|
|
}
|