luboslenco
1082 lines
24 KiB
C
1082 lines
24 KiB
C
|
|
// Simple text processing tool for converting shaders at runtime.
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdbool.h>
|
|
#include <string.h>
|
|
#include "iron_string.h"
|
|
#ifdef __linux__
|
|
int krafix_compile(const char *source, char *output, int *length, const char *targetlang, const char *system, const char *shadertype, int version);
|
|
#endif
|
|
|
|
#ifdef _WIN32
|
|
#include <d3d11.h>
|
|
#include <D3Dcompiler.h>
|
|
|
|
static void write_attrib(char *file, int *output_len, const char *attrib, int index) {
|
|
if (index > -1) {
|
|
strcpy(file + (*output_len), attrib);
|
|
(*output_len) += strlen(attrib);
|
|
file[(*output_len)] = 0;
|
|
(*output_len) += 1;
|
|
file[(*output_len)] = index;
|
|
(*output_len) += 1;
|
|
}
|
|
}
|
|
|
|
char *hlsl_to_bin(char *source, char *shader_type, char *to) {
|
|
char *type;
|
|
if (string_equals(shader_type, "vert")) {
|
|
type = "vs_5_0";
|
|
}
|
|
else if (string_equals(shader_type, "frag")) {
|
|
type = "ps_5_0";
|
|
}
|
|
else {
|
|
type = "gs_5_0";
|
|
}
|
|
|
|
ID3DBlob *error_message;
|
|
ID3DBlob *shader_buffer;
|
|
// UINT flags = D3DCOMPILE_SKIP_OPTIMIZATION | D3DCOMPILE_SKIP_VALIDATION;
|
|
UINT flags = D3DCOMPILE_OPTIMIZATION_LEVEL3;
|
|
HRESULT hr = D3DCompile(source, strlen(source) + 1, NULL, NULL, NULL, "main", type, flags, 0, &shader_buffer, &error_message);
|
|
if (hr != S_OK) {
|
|
printf("%s\n", (char *)error_message->lpVtbl->GetBufferPointer(error_message));
|
|
return NULL;
|
|
}
|
|
|
|
ID3D11ShaderReflection *reflector = NULL;
|
|
D3DReflect(shader_buffer->lpVtbl->GetBufferPointer(shader_buffer), shader_buffer->lpVtbl->GetBufferSize(shader_buffer), &IID_ID3D11ShaderReflection, (void **)&reflector);
|
|
|
|
int len = shader_buffer->lpVtbl->GetBufferSize(shader_buffer);
|
|
char *file = malloc(len * 2);
|
|
int output_len = 0;
|
|
|
|
bool has_bone = strstr(source, " bone:") != NULL;
|
|
bool has_col = strstr(source, " col:") != NULL;
|
|
bool has_nor = strstr(source, " nor:") != NULL;
|
|
bool has_pos = strstr(source, " pos:") != NULL;
|
|
bool has_tex = strstr(source, " tex:") != NULL;
|
|
|
|
int ibone = -1;
|
|
int icol = -1;
|
|
int inor = -1;
|
|
int ipos = -1;
|
|
int itex = -1;
|
|
int iweight = -1;
|
|
|
|
int index = 0;
|
|
if (has_bone) ibone = index++;
|
|
if (has_col) icol = index++;
|
|
if (has_nor) inor = index++;
|
|
if (has_pos) ipos = index++;
|
|
if (has_tex) itex = index++;
|
|
if (has_bone) iweight = index++;
|
|
|
|
file[output_len] = (char)index;
|
|
output_len += 1;
|
|
|
|
write_attrib(file, &output_len, "bone", ibone);
|
|
write_attrib(file, &output_len, "col", icol);
|
|
write_attrib(file, &output_len, "nor", inor);
|
|
write_attrib(file, &output_len, "pos", ipos);
|
|
write_attrib(file, &output_len, "tex", itex);
|
|
write_attrib(file, &output_len, "weight", iweight);
|
|
|
|
D3D11_SHADER_DESC desc;
|
|
reflector->lpVtbl->GetDesc(reflector, &desc);
|
|
|
|
file[output_len] = desc.BoundResources;
|
|
output_len += 1;
|
|
for (int i = 0; i < desc.BoundResources; ++i) {
|
|
D3D11_SHADER_INPUT_BIND_DESC bindDesc;
|
|
reflector->lpVtbl->GetResourceBindingDesc(reflector, i, &bindDesc);
|
|
strcpy(file + output_len, bindDesc.Name);
|
|
output_len += strlen(bindDesc.Name);
|
|
file[output_len] = 0;
|
|
output_len += 1;
|
|
file[output_len] = bindDesc.BindPoint;
|
|
output_len += 1;
|
|
}
|
|
|
|
ID3D11ShaderReflectionConstantBuffer *constants = reflector->lpVtbl->GetConstantBufferByName(reflector, "$Globals");
|
|
D3D11_SHADER_BUFFER_DESC buffer_desc;
|
|
hr = constants->lpVtbl->GetDesc(constants, &buffer_desc);
|
|
if (hr == S_OK) {
|
|
file[output_len] = buffer_desc.Variables;
|
|
output_len += 1;
|
|
for (int i = 0; i < buffer_desc.Variables; ++i) {
|
|
ID3D11ShaderReflectionVariable *variable = constants->lpVtbl->GetVariableByIndex(constants, i);
|
|
D3D11_SHADER_VARIABLE_DESC variable_desc;
|
|
hr = variable->lpVtbl->GetDesc(variable, &variable_desc);
|
|
if (hr == S_OK) {
|
|
strcpy(file + output_len, variable_desc.Name);
|
|
output_len += strlen(variable_desc.Name);
|
|
file[output_len] = 0;
|
|
output_len += 1;
|
|
|
|
*(uint32_t *)(file + output_len) = variable_desc.StartOffset;
|
|
output_len += 4;
|
|
|
|
*(uint32_t *)(file + output_len) = variable_desc.Size;
|
|
output_len += 4;
|
|
|
|
D3D11_SHADER_TYPE_DESC type_desc;
|
|
ID3D11ShaderReflectionType *type = variable->lpVtbl->GetType(variable);
|
|
hr = type->lpVtbl->GetDesc(type, &type_desc);
|
|
if (hr == S_OK) {
|
|
file[output_len] = type_desc.Columns;
|
|
output_len += 1;
|
|
file[output_len] = type_desc.Rows;
|
|
output_len += 1;
|
|
}
|
|
else {
|
|
file[output_len] = 0;
|
|
output_len += 1;
|
|
file[output_len] = 0;
|
|
output_len += 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
file[output_len] = 0;
|
|
output_len += 1;
|
|
}
|
|
|
|
memcpy(file + output_len, (char *)shader_buffer->lpVtbl->GetBufferPointer(shader_buffer), shader_buffer->lpVtbl->GetBufferSize(shader_buffer));
|
|
output_len += shader_buffer->lpVtbl->GetBufferSize(shader_buffer);
|
|
|
|
shader_buffer->lpVtbl->Release(shader_buffer);
|
|
reflector->lpVtbl->Release(reflector);
|
|
|
|
FILE *fp = fopen(to, "wb");
|
|
fwrite(file, 1, output_len, fp);
|
|
fclose(fp);
|
|
free(file);
|
|
}
|
|
|
|
void hlslbin(const char *from, const char *to) {
|
|
FILE *fp = fopen(from, "rb");
|
|
fseek(fp , 0, SEEK_END);
|
|
int size = ftell(fp);
|
|
rewind(fp);
|
|
char *source = malloc(size + 1);
|
|
source[size] = 0;
|
|
fread(source, size, 1, fp);
|
|
fclose(fp);
|
|
|
|
char *type;
|
|
if (strstr(from, ".vert.")) {
|
|
type = "vert";
|
|
}
|
|
else if (strstr(from, ".frag.")) {
|
|
type = "frag";
|
|
}
|
|
else {
|
|
type = "geom";
|
|
}
|
|
|
|
hlsl_to_bin(source, type, to);
|
|
}
|
|
#endif
|
|
|
|
static char out[128 * 1024];
|
|
static int out_pos = 0;
|
|
static char line[1024];
|
|
static char tmp[1024];
|
|
|
|
static char *buffer;
|
|
static int buffer_size;
|
|
static int buffer_pos = 0;
|
|
|
|
typedef struct var {
|
|
char name[64];
|
|
char type[16];
|
|
} var_t;
|
|
|
|
static char defines[32][64];
|
|
static int defines_count;
|
|
static bool is_defined[8];
|
|
static int is_defined_index;
|
|
|
|
static char *numbers[] = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
|
|
|
|
static var_t inputs[8];
|
|
static var_t outputs[8];
|
|
static var_t uniforms[32];
|
|
static var_t samplers[32];
|
|
static int inputs_count;
|
|
static int outputs_count;
|
|
static int uniforms_count;
|
|
static int samplers_count;
|
|
|
|
static char *shader_type;
|
|
|
|
const char *version_glsl = "#version 450\n";
|
|
const char *version_essl = "#version 300 es\n";
|
|
const char *precision_essl = "precision highp float;\nprecision mediump int;\n";
|
|
|
|
const char *header_glsl = "#define GLSL\n\
|
|
#define mul(a, b) b * a\n\
|
|
#define atan2(x, y) atan(y, x)\n\
|
|
#define OUT(t, v) out t v\n\
|
|
";
|
|
|
|
const char *header_hlsl = "#define HLSL\n\
|
|
#define sampler2D Texture2D\n\
|
|
#define sampler3D Texture3D\n\
|
|
#define texture(tex, coord) tex.Sample(tex ## _sampler, coord)\n\
|
|
#define textureLod(tex, coord, lod) tex.SampleLevel(tex ## _sampler, coord, lod)\n\
|
|
#define texelFetch(tex, coord, lod) tex.Load(float3(coord.xy, lod))\n\
|
|
uint2 _GetDimensions(Texture2D tex, uint lod) { uint x, y; tex.GetDimensions(x, y); return uint2(x, y); }\n\
|
|
#define textureSize _GetDimensions\n\
|
|
#define mod(a, b) (a % b)\n\
|
|
#define vec2 float2\n\
|
|
#define vec3 float3\n\
|
|
#define vec4 float4\n\
|
|
#define ivec2 int2\n\
|
|
#define ivec3 int3\n\
|
|
#define ivec4 int4\n\
|
|
#define mat2 float2x2\n\
|
|
#define mat3 float3x3\n\
|
|
#define mat4 float4x4\n\
|
|
#define dFdx ddx\n\
|
|
#define dFdy ddy\n\
|
|
#define inversesqrt rsqrt\n\
|
|
#define fract frac\n\
|
|
#define mix lerp\n\
|
|
#define OUT(t, v) out t v\n\
|
|
";
|
|
|
|
const char *header_msl = "// my_main\n\
|
|
#define METAL\n\
|
|
#include <metal_stdlib>\n\
|
|
#include <simd/simd.h>\n\
|
|
using namespace metal;\n\
|
|
#define sampler2D texture2d<float>\n\
|
|
#define sampler3D texture3d<float>\n\
|
|
#define texture(tex, coord) tex.sample(tex ## _sampler, coord)\n\
|
|
#define textureLod(tex, coord, lod) tex.sample(tex ## _sampler, coord, level(lod))\n\
|
|
#define texelFetch(tex, coord, lod) tex.read(uint2(coord), uint(lod))\n\
|
|
float2 _getDimensions(texture2d<float> tex, uint lod) { return float2(tex.get_width(lod), tex.get_height(lod)); }\n\
|
|
#define textureSize _getDimensions\n\
|
|
#define mod(a, b) fmod(a, b)\n\
|
|
#define vec2 float2\n\
|
|
#define vec3 float3\n\
|
|
#define vec4 float4\n\
|
|
#define ivec2 int2\n\
|
|
#define ivec3 int3\n\
|
|
#define ivec4 int4\n\
|
|
#define mat2 float2x2\n\
|
|
#define mat3 float3x3\n\
|
|
#define mat4 float4x4\n\
|
|
#define dFdx dfdx\n\
|
|
#define dFdy dfdy\n\
|
|
#define inversesqrt rsqrt\n\
|
|
#define mul(a, b) b * a\n\
|
|
#define discard discard_fragment()\n\
|
|
#define OUT(t, v) thread t &v\n\
|
|
class my_class {\n\
|
|
public:\n\
|
|
";
|
|
|
|
static char *read_line() {
|
|
int i = 0;
|
|
while (true) {
|
|
if (buffer[buffer_pos] == '\0') {
|
|
return NULL;
|
|
}
|
|
|
|
line[i] = buffer[buffer_pos];
|
|
i++;
|
|
buffer_pos++;
|
|
|
|
#ifdef _WIN32
|
|
if (line[i - 1] == '\r') {
|
|
line[i - 1] = '\n';
|
|
buffer_pos++; // Skip \n
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
if (line[i - 1] == '\n') {
|
|
break;
|
|
}
|
|
}
|
|
|
|
line[i] = '\0';
|
|
return &line[0];
|
|
}
|
|
|
|
static void w(char *str) {
|
|
strcpy(out + out_pos, str);
|
|
out_pos += strlen(str);
|
|
}
|
|
|
|
static bool is_undefined() {
|
|
for (int i = 0; i <= is_defined_index; ++i) {
|
|
if (!is_defined[i]) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void write_includes(char *file, int off) {
|
|
char *_buffer = buffer;
|
|
int _pos = buffer_pos;
|
|
buffer_pos = off;
|
|
|
|
FILE *fp = fopen(file, "rb");
|
|
fseek(fp, 0, SEEK_END);
|
|
int size = ftell(fp);
|
|
rewind(fp);
|
|
buffer = malloc(size + 1);
|
|
buffer[size] = '\0';
|
|
fread(buffer, size, 1, fp);
|
|
fclose(fp);
|
|
|
|
while (true) {
|
|
char *line = read_line();
|
|
if (line == NULL) {
|
|
break;
|
|
}
|
|
|
|
if (starts_with(line, "#include ")) {
|
|
char *rel = line + 10; // #include "
|
|
rel[strlen(rel) - 1 - 1] = '\0'; // trailing "
|
|
|
|
char tmp[512];
|
|
int last = string_last_index_of(file, "/") + 1;
|
|
strncpy(tmp, file, last);
|
|
tmp[last] = '\0';
|
|
strcat(tmp, rel);
|
|
|
|
write_includes(tmp, 0);
|
|
line[0] = '\0';
|
|
}
|
|
|
|
if (starts_with(line, "#define ")) {
|
|
strcpy(defines[defines_count++], line + 8);
|
|
}
|
|
|
|
if (starts_with(line, "#ifdef ")) {
|
|
line += 7;
|
|
is_defined_index++;
|
|
is_defined[is_defined_index] = false;
|
|
for (int i = 0; i < defines_count; ++i) {
|
|
if (string_equals(line, defines[i])) {
|
|
is_defined[is_defined_index] = true;
|
|
break;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (starts_with(line, "#else")) {
|
|
is_defined[is_defined_index] = !is_defined[is_defined_index];
|
|
continue;
|
|
}
|
|
|
|
if (starts_with(line, "#endif")) {
|
|
is_defined_index--;
|
|
continue;
|
|
}
|
|
|
|
if (starts_with(line, "//") || is_undefined()) {
|
|
continue;
|
|
}
|
|
|
|
w(line);
|
|
}
|
|
|
|
free(buffer);
|
|
buffer = _buffer;
|
|
buffer_pos = _pos;
|
|
}
|
|
|
|
static void write_header(char *shader_lang) {
|
|
if (string_equals(shader_lang, "glsl") ||
|
|
string_equals(shader_lang, "essl") ||
|
|
string_equals(shader_lang, "spirv")
|
|
) {
|
|
if (string_equals(shader_lang, "essl")) {
|
|
w(version_essl);
|
|
w(precision_essl);
|
|
}
|
|
else {
|
|
w(version_glsl);
|
|
}
|
|
w(header_glsl);
|
|
|
|
if (string_equals(shader_lang, "spirv")) {
|
|
strcpy(defines[defines_count++], "SPIRV\n");
|
|
}
|
|
else {
|
|
strcpy(defines[defines_count++], "GLSL\n");
|
|
if (string_equals(shader_lang, "essl")) {
|
|
strcpy(defines[defines_count++], "ESSL\n");
|
|
}
|
|
}
|
|
}
|
|
else if (string_equals(shader_lang, "hlsl")) {
|
|
w(header_hlsl);
|
|
strcpy(defines[defines_count++], "HLSL\n");
|
|
}
|
|
else if (string_equals(shader_lang, "msl")) {
|
|
w(header_msl);
|
|
strcpy(defines[defines_count++], "METAL\n");
|
|
}
|
|
}
|
|
|
|
static int sort_vars(const void *_a, const void *_b) {
|
|
var_t *a = _a;
|
|
var_t *b = _b;
|
|
return strcmp(a->name, b->name);
|
|
}
|
|
|
|
static void read_vars(char *line, var_t *vars, int *vars_count, char *start) {
|
|
*vars_count = 0;
|
|
|
|
while (starts_with(line, start)) {
|
|
memset(&vars[*vars_count], 0, sizeof(var_t));
|
|
line = line + strlen(start);
|
|
|
|
int pos = string_index_of(line, " ");
|
|
strncat(vars[*vars_count].type, line, pos);
|
|
line += pos + 1;
|
|
|
|
pos = string_index_of(line, ";");
|
|
strncat(vars[*vars_count].name, line, pos);
|
|
|
|
(*vars_count)++;
|
|
line = read_line();
|
|
|
|
while (starts_with(line, "#")) {
|
|
w(line);
|
|
line = read_line();
|
|
}
|
|
}
|
|
|
|
qsort(vars, *vars_count, sizeof(var_t), sort_vars);
|
|
}
|
|
|
|
static void init_buffer() {
|
|
buffer = malloc(128 * 1024);
|
|
strcpy(buffer, out);
|
|
buffer_size = strlen(buffer);
|
|
buffer_pos = 0;
|
|
out[0] = '\0';
|
|
out_pos = 0;
|
|
|
|
inputs_count = 0;
|
|
outputs_count = 0;
|
|
uniforms_count = 0;
|
|
samplers_count = 0;
|
|
}
|
|
|
|
static void write_hlsl_return() {
|
|
w("\tshader_output stage_output;\n");
|
|
if (string_equals(shader_type, "vert")) {
|
|
w("\tgl_Position.z = (gl_Position.z + gl_Position.w) * 0.5;\n");
|
|
w("\tstage_output.gl_Position = gl_Position;\n");
|
|
}
|
|
for (int i = 0; i < outputs_count; ++i) {
|
|
w("\tstage_output.");
|
|
w(outputs[i].name);
|
|
if (out[out_pos - 1] == ']') {
|
|
out_pos -= 3; // Erase [i]
|
|
}
|
|
w(" = ");
|
|
w(outputs[i].name);
|
|
if (out[out_pos - 1] == ']') {
|
|
out_pos -= 3;
|
|
}
|
|
w(";\n");
|
|
}
|
|
w("\treturn stage_output;\n");
|
|
}
|
|
|
|
static char *write_hlsl_inputs(char *line) {
|
|
read_vars(line, inputs, &inputs_count, "in ");
|
|
|
|
w("struct shader_input {\n");
|
|
for (int i = 0; i < inputs_count; ++i) {
|
|
w("\t");
|
|
w(inputs[i].type);
|
|
w(" ");
|
|
w(inputs[i].name);
|
|
w(": TEXCOORD");
|
|
w(numbers[i]);
|
|
w(";\n");
|
|
}
|
|
|
|
if (string_index_of(buffer, "gl_VertexID") > -1) {
|
|
w("\tuint gl_VertexID: SV_VertexID;\n");
|
|
}
|
|
if (string_index_of(buffer, "gl_InstanceID") > -1) {
|
|
w("\tuint gl_InstanceID: SV_InstanceID;\n");
|
|
}
|
|
|
|
w("};\n");
|
|
|
|
return line;
|
|
}
|
|
|
|
static char *write_hlsl_outputs(char *line) {
|
|
read_vars(line, outputs, &outputs_count, "out ");
|
|
|
|
w("struct shader_output {\n");
|
|
for (int i = 0; i < outputs_count; ++i) {
|
|
w("\t");
|
|
w(outputs[i].type);
|
|
w(" ");
|
|
w(outputs[i].name);
|
|
|
|
if (string_equals(shader_type, "vert")) {
|
|
w(": TEXCOORD");
|
|
}
|
|
else {
|
|
w(": SV_TARGET");
|
|
}
|
|
|
|
w(numbers[i]);
|
|
w(";\n");
|
|
}
|
|
|
|
if (string_equals(shader_type, "vert")) {
|
|
w("\tvec4 gl_Position: SV_POSITION;\n");
|
|
}
|
|
|
|
w("};\n");
|
|
|
|
return line;
|
|
}
|
|
|
|
static void to_hlsl() {
|
|
init_buffer();
|
|
|
|
while (true) {
|
|
char *line = read_line();
|
|
if (line == NULL) {
|
|
break;
|
|
}
|
|
|
|
if (starts_with(line, "in ")) {
|
|
line = write_hlsl_inputs(line);
|
|
|
|
for (int i = 0; i < inputs_count; ++i) {
|
|
w("static ");
|
|
w(inputs[i].type);
|
|
w(" ");
|
|
w(inputs[i].name);
|
|
w(";\n");
|
|
}
|
|
|
|
if (string_index_of(buffer, "gl_VertexID") > -1) {
|
|
w("static uint gl_VertexID;\n");
|
|
}
|
|
if (string_index_of(buffer, "gl_InstanceID") > -1) {
|
|
w("static uint gl_InstanceID;\n");
|
|
}
|
|
}
|
|
|
|
if (starts_with(line, "out ")) {
|
|
line = write_hlsl_outputs(line);
|
|
|
|
if (string_equals(shader_type, "vert")) {
|
|
w("static vec4 gl_Position;\n");
|
|
}
|
|
|
|
for (int i = 0; i < outputs_count; ++i) {
|
|
w("static ");
|
|
w(outputs[i].type);
|
|
w(" ");
|
|
w(outputs[i].name);
|
|
w(";\n");
|
|
}
|
|
}
|
|
|
|
if (starts_with(line, "uniform sampler")) {
|
|
int len = strlen(line);
|
|
int last = string_last_index_of(line, " ");
|
|
strcpy(tmp, "SamplerState ");
|
|
strncat(tmp, line + last + 1, len - last - 3); // - ";\n"
|
|
strcat(tmp, "_sampler;\n");
|
|
w(tmp);
|
|
}
|
|
|
|
if (starts_with(line, "const ")) {
|
|
w("static ");
|
|
}
|
|
|
|
if (starts_with(line, "vec") ||
|
|
starts_with(line, "float ") ||
|
|
starts_with(line, "int ")
|
|
) {
|
|
if (ends_with(line, ";\n")) {
|
|
w("static ");
|
|
}
|
|
}
|
|
|
|
if (ends_with(line, "return;\n")) {
|
|
write_hlsl_return();
|
|
line = "";
|
|
}
|
|
|
|
if (starts_with(line, "void main")) {
|
|
w("shader_output main(shader_input stage_input) {\n");
|
|
line = "";
|
|
|
|
for (int i = 0; i < inputs_count; ++i) {
|
|
w("\t");
|
|
w(inputs[i].name);
|
|
w(" = stage_input.");
|
|
w(inputs[i].name);
|
|
w(";\n");
|
|
}
|
|
|
|
if (string_index_of(buffer, "gl_VertexID") > -1) {
|
|
w("\tgl_VertexID = stage_input.gl_VertexID;\n");
|
|
}
|
|
|
|
if (string_index_of(buffer, "gl_InstanceID") > -1) {
|
|
w("\tgl_InstanceID = stage_input.gl_InstanceID;\n");
|
|
}
|
|
}
|
|
|
|
if (starts_with(line, "}") && buffer_pos == buffer_size) {
|
|
write_hlsl_return();
|
|
}
|
|
|
|
w(line);
|
|
}
|
|
|
|
free(buffer);
|
|
}
|
|
|
|
static char *write_msl_inputs(char *line) {
|
|
read_vars(line, inputs, &inputs_count, "in ");
|
|
|
|
w("struct shader_input {\n");
|
|
|
|
for (int i = 0; i < inputs_count; ++i) {
|
|
w("\t");
|
|
w(inputs[i].type);
|
|
w(" ");
|
|
w(inputs[i].name);
|
|
if (string_equals(shader_type, "vert")) {
|
|
w(" [[attribute(");
|
|
}
|
|
else {
|
|
w(" [[user(locn");
|
|
}
|
|
w(numbers[i]);
|
|
w(")]];\n");
|
|
}
|
|
|
|
w("};\n");
|
|
|
|
return line;
|
|
}
|
|
|
|
static char *write_msl_outputs(char *line) {
|
|
read_vars(line, outputs, &outputs_count, "out ");
|
|
|
|
w("struct shader_output {\n");
|
|
for (int i = 0; i < outputs_count; ++i) {
|
|
int pos = string_index_of(outputs[i].name, "[");
|
|
if (pos > -1) {
|
|
int n = outputs[i].name[pos + 1] - '0';
|
|
for (int j = 0; j < n; ++j) {
|
|
w("\t");
|
|
w(outputs[i].type);
|
|
w(" ");
|
|
// w(outputs[i].name);
|
|
w("frag_color");
|
|
w(numbers[j]);
|
|
w(" [[color(");
|
|
w(numbers[j]);
|
|
w(")]];\n");
|
|
}
|
|
}
|
|
else {
|
|
w("\t");
|
|
w(outputs[i].type);
|
|
w(" ");
|
|
w(outputs[i].name);
|
|
if (string_equals(shader_type, "vert")) {
|
|
w(" [[user(locn");
|
|
w(numbers[i]);
|
|
w(")]];\n");
|
|
}
|
|
else {
|
|
w(" [[color(0)]];\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (string_equals(shader_type, "vert")) {
|
|
w("\tvec4 gl_Position [[position]];\n");
|
|
}
|
|
|
|
w("};\n");
|
|
|
|
return line;
|
|
}
|
|
|
|
static char *write_msl_uniforms(char *line) {
|
|
read_vars(line, uniforms, &uniforms_count, "uniform ");
|
|
|
|
w("struct shader_uniforms {\n");
|
|
|
|
for (int i = 0; i < uniforms_count; ++i) {
|
|
|
|
if (starts_with(uniforms[i].type, "sampler")) {
|
|
strcpy(samplers[samplers_count].type, uniforms[i].type);
|
|
strcpy(samplers[samplers_count].name, uniforms[i].name);
|
|
samplers_count++;
|
|
continue;
|
|
}
|
|
|
|
w("\t");
|
|
w(uniforms[i].type);
|
|
w(" ");
|
|
w(uniforms[i].name);
|
|
w(";\n");
|
|
}
|
|
|
|
w("};\n");
|
|
|
|
return line;
|
|
}
|
|
|
|
static void write_msl_return() {
|
|
w("\tshader_output stage_output;\n");
|
|
if (string_equals(shader_type, "vert")) {
|
|
w("\tgl_Position.z = (gl_Position.z + gl_Position.w) * 0.5;\n");
|
|
w("\tstage_output.gl_Position = gl_Position;\n");
|
|
}
|
|
for (int i = 0; i < outputs_count; ++i) {
|
|
int pos = string_index_of(outputs[i].name, "[");
|
|
if (pos > -1) {
|
|
int n = outputs[i].name[pos + 1] - '0';
|
|
char tmp[64];
|
|
strcpy(tmp, outputs[i].name);
|
|
tmp[pos] = '\0';
|
|
for (int j = 0; j < n; ++j) {
|
|
w("\tstage_output.");
|
|
w(tmp);
|
|
w(numbers[j]);
|
|
w(" = ");
|
|
w(tmp);
|
|
w("[");
|
|
w(numbers[j]);
|
|
w("];\n");
|
|
}
|
|
}
|
|
else {
|
|
w("\tstage_output.");
|
|
w(outputs[i].name);
|
|
w(" = ");
|
|
w(outputs[i].name);
|
|
w(";\n");
|
|
}
|
|
}
|
|
w("\treturn stage_output;\n");
|
|
}
|
|
|
|
static void to_msl() {
|
|
init_buffer();
|
|
char main_header[1024];
|
|
char main_body[1024];
|
|
strcpy(main_header, "#undef texture\n");
|
|
strcpy(main_body, "\tmy_class c;\n\treturn c.my_main(stage_input");
|
|
|
|
while (true) {
|
|
|
|
char *line = read_line();
|
|
if (line == NULL) {
|
|
break;
|
|
}
|
|
|
|
if (starts_with(line, "in ")) {
|
|
line = write_msl_inputs(line);
|
|
|
|
for (int i = 0; i < inputs_count; ++i) {
|
|
w(inputs[i].type);
|
|
w(" ");
|
|
w(inputs[i].name);
|
|
w(";\n");
|
|
}
|
|
|
|
if (string_index_of(buffer, "gl_VertexID") > -1) {
|
|
w("uint gl_VertexID;\n");
|
|
}
|
|
if (string_index_of(buffer, "gl_InstanceID") > -1) {
|
|
w("uint gl_InstanceID;\n");
|
|
}
|
|
}
|
|
|
|
if (starts_with(line, "out ")) {
|
|
line = write_msl_outputs(line);
|
|
|
|
if (string_equals(shader_type, "vert")) {
|
|
w("vec4 gl_Position;\n");
|
|
}
|
|
|
|
for (int i = 0; i < outputs_count; ++i) {
|
|
w(outputs[i].type);
|
|
w(" ");
|
|
w(outputs[i].name);
|
|
w(";\n");
|
|
}
|
|
}
|
|
|
|
if (starts_with(line, "uniform ")) {
|
|
line = write_msl_uniforms(line);
|
|
|
|
for (int i = 0; i < uniforms_count; ++i) {
|
|
w(uniforms[i].type);
|
|
w(" ");
|
|
w(uniforms[i].name);
|
|
w(";\n");
|
|
|
|
if (starts_with(uniforms[i].type, "sampler")) {
|
|
w("sampler ");
|
|
w(uniforms[i].name);
|
|
w("_sampler;\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (starts_with(line, "void main")) {
|
|
|
|
if (string_equals(shader_type, "vert")) {
|
|
strcat(main_header, "vertex ");
|
|
}
|
|
else {
|
|
strcat(main_header, "fragment ");
|
|
}
|
|
|
|
w("shader_output my_main(shader_input stage_input");
|
|
strcat(main_header, "my_class::shader_output my_main(my_class::shader_input stage_input [[stage_in]]");
|
|
|
|
if (uniforms_count > 0) {
|
|
w(", constant shader_uniforms& uniforms");
|
|
strcat(main_header, ", constant my_class::shader_uniforms& uniforms [[buffer(");
|
|
if (string_equals(shader_type, "vert")) {
|
|
strcat(main_header, "1");
|
|
}
|
|
else {
|
|
strcat(main_header, "0");
|
|
}
|
|
strcat(main_header, ")]]");
|
|
strcat(main_body, ", uniforms");
|
|
}
|
|
|
|
if (samplers_count > 0) {
|
|
for (int i = 0; i < samplers_count; ++i) {
|
|
w(", ");
|
|
w(samplers[i].type);
|
|
w(" ");
|
|
w(samplers[i].name);
|
|
|
|
w(", sampler ");
|
|
w(samplers[i].name);
|
|
w("_sampler");
|
|
|
|
strcat(main_header, ", ");
|
|
strcat(main_header, samplers[i].type);
|
|
strcat(main_header, " ");
|
|
strcat(main_header, samplers[i].name);
|
|
strcat(main_header, " [[texture(");
|
|
strcat(main_header, numbers[i]);
|
|
strcat(main_header, ")]]");
|
|
|
|
strcat(main_header, ", sampler ");
|
|
strcat(main_header, samplers[i].name);
|
|
strcat(main_header, "_sampler [[sampler(");
|
|
strcat(main_header, numbers[i]);
|
|
strcat(main_header, ")]]");
|
|
|
|
strcat(main_body, ", ");
|
|
strcat(main_body, samplers[i].name);
|
|
strcat(main_body, ", ");
|
|
strcat(main_body, samplers[i].name);
|
|
strcat(main_body, "_sampler");
|
|
}
|
|
}
|
|
|
|
if (string_equals(shader_type, "vert")) {
|
|
if (string_index_of(buffer, "gl_VertexID") > -1) {
|
|
w(", uint gl_VertexID");
|
|
strcat(main_header, ", uint gl_VertexID [[vertex_id]]");
|
|
strcat(main_body, ", gl_VertexID");
|
|
}
|
|
if (string_index_of(buffer, "gl_InstanceID") > -1) {
|
|
w(", uint gl_InstanceID");
|
|
strcat(main_header, ", uint gl_InstanceID [[instance_id]]");
|
|
strcat(main_body, ", gl_InstanceID");
|
|
}
|
|
}
|
|
|
|
w(") {\n");
|
|
strcat(main_header, ") {\n");
|
|
strcat(main_body, ");\n}\n");
|
|
|
|
line = "";
|
|
|
|
for (int i = 0; i < inputs_count; ++i) {
|
|
w("\t");
|
|
w(inputs[i].name);
|
|
w(" = stage_input.");
|
|
w(inputs[i].name);
|
|
w(";\n");
|
|
}
|
|
|
|
if (string_index_of(buffer, "gl_VertexID") > -1) {
|
|
w("\tthis->gl_VertexID = gl_VertexID;\n");
|
|
}
|
|
|
|
if (string_index_of(buffer, "gl_InstanceID") > -1) {
|
|
w("\tthis->gl_InstanceID = gl_InstanceID;\n");
|
|
}
|
|
|
|
for (int i = 0; i < uniforms_count; ++i) {
|
|
int pos = string_index_of(uniforms[i].name, "[");
|
|
if (pos > -1) {
|
|
char tmp[64];
|
|
strcpy(tmp, uniforms[i].name);
|
|
tmp[pos] = '\0';
|
|
|
|
int n = uniforms[i].name[pos + 1] - '0';
|
|
for (int j = 0; j < n; ++j) {
|
|
w("\tthis->");
|
|
w(tmp);
|
|
w("[");
|
|
w(numbers[j]);
|
|
w("] = uniforms.");
|
|
w(tmp);
|
|
w("[");
|
|
w(numbers[j]);
|
|
w("];\n");
|
|
}
|
|
}
|
|
else if (starts_with(uniforms[i].type, "sampler")) {
|
|
w("\tthis->");
|
|
w(uniforms[i].name);
|
|
w(" = ");
|
|
w(uniforms[i].name);
|
|
w(";\n");
|
|
|
|
w("\tthis->");
|
|
w(uniforms[i].name);
|
|
w("_sampler = ");
|
|
w(uniforms[i].name);
|
|
w("_sampler;\n");
|
|
}
|
|
else {
|
|
w("\tthis->");
|
|
w(uniforms[i].name);
|
|
w(" = uniforms.");
|
|
w(uniforms[i].name);
|
|
w(";\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (starts_with(line, "}") && buffer_pos == buffer_size) {
|
|
write_msl_return();
|
|
}
|
|
|
|
w(line);
|
|
}
|
|
|
|
w("};\n"); // class my_class
|
|
w(main_header);
|
|
w(main_body);
|
|
|
|
free(buffer);
|
|
}
|
|
|
|
int ashader(char *shader_lang, char *from, char *to) {
|
|
// shader_lang == glsl || essl || hlsl || msl || spirv
|
|
shader_type = string_index_of(from, ".vert") != -1 ? "vert" : "frag";
|
|
|
|
#ifdef _WIN32
|
|
char from_[512];
|
|
strcpy(from_, from);
|
|
int len = strlen(from_);
|
|
for (int i = 0; i < len; ++i) {
|
|
if (from_[i] == '\\') {
|
|
from_[i] = '/';
|
|
}
|
|
}
|
|
from = from_;
|
|
#endif
|
|
|
|
out[0] = '\0';
|
|
out_pos = 0;
|
|
defines_count = 0;
|
|
is_defined[0] = true;
|
|
is_defined_index = 0;
|
|
write_header(shader_lang);
|
|
|
|
write_includes(from, 13); // Skip #version 450\n
|
|
|
|
if (string_equals(shader_lang, "glsl") ||
|
|
string_equals(shader_lang, "essl")
|
|
) {
|
|
FILE *fp = fopen(to, "wb");
|
|
fwrite(out, 1, strlen(out), fp);
|
|
fclose(fp);
|
|
}
|
|
|
|
#ifdef __linux__
|
|
else if (string_equals(shader_lang, "spirv")) {
|
|
char *buf = malloc(1024 * 1024);
|
|
int buf_len;
|
|
krafix_compile(out, buf, &buf_len, "spirv", "linux", shader_type, -1);
|
|
|
|
FILE *fp = fopen(to, "wb");
|
|
fwrite(buf, 1, buf_len, fp);
|
|
fclose(fp);
|
|
}
|
|
#endif
|
|
|
|
else if (string_equals(shader_lang, "hlsl")) {
|
|
to_hlsl();
|
|
|
|
// FILE *fp = fopen(to, "wb");
|
|
// fwrite(out, 1, strlen(out), fp); // Write .hlsl
|
|
// fclose(fp);
|
|
|
|
#ifdef _WIN32
|
|
char to_[512];
|
|
strcpy(to_, to);
|
|
to_[strlen(to_) - 4] = '\0';
|
|
strcat(to_, "d3d11");
|
|
hlsl_to_bin(out, shader_type, to_);
|
|
#endif
|
|
}
|
|
|
|
else if (string_equals(shader_lang, "msl")) {
|
|
to_msl();
|
|
|
|
char to_[512];
|
|
strcpy(to_, to);
|
|
to_[strlen(to_) - 3] = '\0';
|
|
strcat(to_, "metal");
|
|
|
|
FILE *fp = fopen(to_, "wb");
|
|
fwrite(out, 1, strlen(out), fp);
|
|
fclose(fp);
|
|
}
|
|
|
|
return 0;
|
|
}
|