mirror of
https://github.com/RetroDECK/Duckstation.git
synced 2025-02-01 12:15:37 +00:00
2191 lines
64 KiB
C++
2191 lines
64 KiB
C++
/*
|
|
* Copyright (C) 2014 Patrick Mours
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
*/
|
|
|
|
#include "effect_parser.hpp"
|
|
#include "effect_codegen.hpp"
|
|
#include <cmath> // signbit, isinf, isnan
|
|
#include <cstdio> // snprintf
|
|
#include <cassert>
|
|
#include <algorithm> // std::find_if, std::max
|
|
#include <unordered_set>
|
|
|
|
using namespace reshadefx;
|
|
|
|
namespace {
|
|
class codegen_glsl final : public codegen
|
|
{
|
|
public:
|
|
codegen_glsl(bool gles, bool vulkan_semantics, bool debug_info, bool uniforms_to_spec_constants, bool enable_16bit_types, bool flip_vert_y)
|
|
: _gles(gles), _debug_info(debug_info), _vulkan_semantics(vulkan_semantics), _uniforms_to_spec_constants(uniforms_to_spec_constants), _enable_16bit_types(enable_16bit_types), _flip_vert_y(flip_vert_y)
|
|
{
|
|
// Create default block and reserve a memory block to avoid frequent reallocations
|
|
std::string &block = _blocks.emplace(0, std::string()).first->second;
|
|
block.reserve(8192);
|
|
}
|
|
|
|
private:
|
|
enum class naming
|
|
{
|
|
// After escaping, name should already be unique, so no additional steps are taken
|
|
unique,
|
|
// After escaping, will be numbered when clashing with another name
|
|
general,
|
|
// This is a special name that is not modified and should be unique
|
|
reserved,
|
|
// Replace name with a code snippet
|
|
expression,
|
|
};
|
|
|
|
std::string _ubo_block;
|
|
std::string _compute_block;
|
|
std::unordered_map<id, std::string> _names;
|
|
std::unordered_map<id, std::string> _blocks;
|
|
bool _gles = false;
|
|
bool _debug_info = false;
|
|
bool _vulkan_semantics = false;
|
|
bool _uniforms_to_spec_constants = false;
|
|
bool _enable_16bit_types = false;
|
|
bool _flip_vert_y = false;
|
|
bool _enable_control_flow_attributes = false;
|
|
std::unordered_map<id, id> _remapped_sampler_variables;
|
|
std::unordered_map<std::string, uint32_t> _semantic_to_location;
|
|
|
|
// Only write compatibility intrinsics to result if they are actually in use
|
|
bool _uses_fmod = false;
|
|
bool _uses_componentwise_or = false;
|
|
bool _uses_componentwise_and = false;
|
|
bool _uses_componentwise_cond = false;
|
|
|
|
void write_result(module &module) override
|
|
{
|
|
module = std::move(_module);
|
|
|
|
std::string preamble;
|
|
|
|
if (_enable_16bit_types)
|
|
// GL_NV_gpu_shader5, GL_AMD_gpu_shader_half_float or GL_EXT_shader_16bit_storage
|
|
preamble += "#extension GL_NV_gpu_shader5 : require\n";
|
|
if (_enable_control_flow_attributes)
|
|
preamble += "#extension GL_EXT_control_flow_attributes : enable\n";
|
|
|
|
if (_uses_fmod)
|
|
preamble += "float fmodHLSL(float x, float y) { return x - y * trunc(x / y); }\n"
|
|
"vec2 fmodHLSL(vec2 x, vec2 y) { return x - y * trunc(x / y); }\n"
|
|
"vec3 fmodHLSL(vec3 x, vec3 y) { return x - y * trunc(x / y); }\n"
|
|
"vec4 fmodHLSL(vec4 x, vec4 y) { return x - y * trunc(x / y); }\n"
|
|
"mat2 fmodHLSL(mat2 x, mat2 y) { return x - matrixCompMult(y, mat2(trunc(x[0] / y[0]), trunc(x[1] / y[1]))); }\n"
|
|
"mat3 fmodHLSL(mat3 x, mat3 y) { return x - matrixCompMult(y, mat3(trunc(x[0] / y[0]), trunc(x[1] / y[1]), trunc(x[2] / y[2]))); }\n"
|
|
"mat4 fmodHLSL(mat4 x, mat4 y) { return x - matrixCompMult(y, mat4(trunc(x[0] / y[0]), trunc(x[1] / y[1]), trunc(x[2] / y[2]), trunc(x[3] / y[3]))); }\n";
|
|
if (_uses_componentwise_or)
|
|
preamble +=
|
|
"bvec2 compOr(bvec2 a, bvec2 b) { return bvec2(a.x || b.x, a.y || b.y); }\n"
|
|
"bvec3 compOr(bvec3 a, bvec3 b) { return bvec3(a.x || b.x, a.y || b.y, a.z || b.z); }\n"
|
|
"bvec4 compOr(bvec4 a, bvec4 b) { return bvec4(a.x || b.x, a.y || b.y, a.z || b.z, a.w || b.w); }\n";
|
|
if (_uses_componentwise_and)
|
|
preamble +=
|
|
"bvec2 compAnd(bvec2 a, bvec2 b) { return bvec2(a.x && b.x, a.y && b.y); }\n"
|
|
"bvec3 compAnd(bvec3 a, bvec3 b) { return bvec3(a.x && b.x, a.y && b.y, a.z && b.z); }\n"
|
|
"bvec4 compAnd(bvec4 a, bvec4 b) { return bvec4(a.x && b.x, a.y && b.y, a.z && b.z, a.w && b.w); }\n";
|
|
if (_uses_componentwise_cond)
|
|
preamble +=
|
|
"vec2 compCond(bvec2 cond, vec2 a, vec2 b) { return vec2(cond.x ? a.x : b.x, cond.y ? a.y : b.y); }\n"
|
|
"vec3 compCond(bvec3 cond, vec3 a, vec3 b) { return vec3(cond.x ? a.x : b.x, cond.y ? a.y : b.y, cond.z ? a.z : b.z); }\n"
|
|
"vec4 compCond(bvec4 cond, vec4 a, vec4 b) { return vec4(cond.x ? a.x : b.x, cond.y ? a.y : b.y, cond.z ? a.z : b.z, cond.w ? a.w : b.w); }\n"
|
|
"ivec2 compCond(bvec2 cond, ivec2 a, ivec2 b) { return ivec2(cond.x ? a.x : b.x, cond.y ? a.y : b.y); }\n"
|
|
"ivec3 compCond(bvec3 cond, ivec3 a, ivec3 b) { return ivec3(cond.x ? a.x : b.x, cond.y ? a.y : b.y, cond.z ? a.z : b.z); }\n"
|
|
"ivec4 compCond(bvec4 cond, ivec4 a, ivec4 b) { return ivec4(cond.x ? a.x : b.x, cond.y ? a.y : b.y, cond.z ? a.z : b.z, cond.w ? a.w : b.w); }\n"
|
|
"uvec2 compCond(bvec2 cond, uvec2 a, uvec2 b) { return uvec2(cond.x ? a.x : b.x, cond.y ? a.y : b.y); }\n"
|
|
"uvec3 compCond(bvec3 cond, uvec3 a, uvec3 b) { return uvec3(cond.x ? a.x : b.x, cond.y ? a.y : b.y, cond.z ? a.z : b.z); }\n"
|
|
"uvec4 compCond(bvec4 cond, uvec4 a, uvec4 b) { return uvec4(cond.x ? a.x : b.x, cond.y ? a.y : b.y, cond.z ? a.z : b.z, cond.w ? a.w : b.w); }\n";
|
|
|
|
if (!_ubo_block.empty())
|
|
{
|
|
if (_vulkan_semantics)
|
|
{
|
|
preamble += "layout(std140, set = 0, binding = 0) uniform _Globals {\n" + _ubo_block + "};\n";
|
|
}
|
|
else
|
|
{
|
|
preamble += "layout(std140, binding = 1) uniform _Globals {\n" + _ubo_block + "};\n";
|
|
}
|
|
}
|
|
|
|
module.code.assign(preamble.begin(), preamble.end());
|
|
|
|
const std::string &main_block = _blocks.at(0);
|
|
module.code.insert(module.code.end(), main_block.begin(), main_block.end());
|
|
}
|
|
|
|
template <bool is_param = false, bool is_decl = true, bool is_interface = false>
|
|
void write_type(std::string &s, const type &type) const
|
|
{
|
|
if constexpr (is_decl)
|
|
{
|
|
// Global variables are implicitly 'static' in GLSL, so the keyword does not exist
|
|
if (type.has(type::q_precise))
|
|
s += "precise ";
|
|
if (type.has(type::q_groupshared))
|
|
s += "shared ";
|
|
}
|
|
|
|
if constexpr (is_interface)
|
|
{
|
|
if (type.has(type::q_linear))
|
|
s += "smooth ";
|
|
if (type.has(type::q_noperspective))
|
|
s += "noperspective ";
|
|
if (type.has(type::q_centroid))
|
|
s += "centroid ";
|
|
if (type.has(type::q_nointerpolation))
|
|
s += "flat ";
|
|
}
|
|
|
|
if constexpr (is_interface || is_param)
|
|
{
|
|
if (type.has(type::q_inout))
|
|
s += "inout ";
|
|
else if (type.has(type::q_in))
|
|
s += "in ";
|
|
else if (type.has(type::q_out))
|
|
s += "out ";
|
|
}
|
|
|
|
switch (type.base)
|
|
{
|
|
case type::t_void:
|
|
s += "void";
|
|
break;
|
|
case type::t_bool:
|
|
if (type.cols > 1)
|
|
s += "mat" + std::to_string(type.rows) + 'x' + std::to_string(type.cols);
|
|
else if (type.rows > 1)
|
|
s += "bvec" + std::to_string(type.rows);
|
|
else
|
|
s += "bool";
|
|
break;
|
|
case type::t_min16int:
|
|
if (_enable_16bit_types)
|
|
{
|
|
assert(type.cols == 1);
|
|
if (type.rows > 1)
|
|
s += "i16vec" + std::to_string(type.rows);
|
|
else
|
|
s += "int16_t";
|
|
break;
|
|
}
|
|
else if constexpr (is_decl)
|
|
s += "mediump ";
|
|
[[fallthrough]];
|
|
case type::t_int:
|
|
if (type.cols > 1)
|
|
s += "mat" + std::to_string(type.rows) + 'x' + std::to_string(type.cols);
|
|
else if (type.rows > 1)
|
|
s += "ivec" + std::to_string(type.rows);
|
|
else
|
|
s += "int";
|
|
break;
|
|
case type::t_min16uint:
|
|
if (_enable_16bit_types)
|
|
{
|
|
assert(type.cols == 1);
|
|
if (type.rows > 1)
|
|
s += "u16vec" + std::to_string(type.rows);
|
|
else
|
|
s += "uint16_t";
|
|
break;
|
|
}
|
|
else if constexpr (is_decl)
|
|
s += "mediump ";
|
|
[[fallthrough]];
|
|
case type::t_uint:
|
|
if (type.cols > 1)
|
|
s += "mat" + std::to_string(type.rows) + 'x' + std::to_string(type.cols);
|
|
else if (type.rows > 1)
|
|
s += "uvec" + std::to_string(type.rows);
|
|
else
|
|
s += "uint";
|
|
break;
|
|
case type::t_min16float:
|
|
if (_enable_16bit_types)
|
|
{
|
|
assert(type.cols == 1);
|
|
if (type.rows > 1)
|
|
s += "f16vec" + std::to_string(type.rows);
|
|
else
|
|
s += "float16_t";
|
|
break;
|
|
}
|
|
else if constexpr (is_decl)
|
|
s += "mediump ";
|
|
[[fallthrough]];
|
|
case type::t_float:
|
|
if (type.cols > 1)
|
|
s += "mat" + std::to_string(type.rows) + 'x' + std::to_string(type.cols);
|
|
else if (type.rows > 1)
|
|
s += "vec" + std::to_string(type.rows);
|
|
else
|
|
s += "float";
|
|
break;
|
|
case type::t_struct:
|
|
s += id_to_name(type.definition);
|
|
break;
|
|
case type::t_sampler1d_int:
|
|
s += "isampler1D";
|
|
break;
|
|
case type::t_sampler2d_int:
|
|
s += "isampler2D";
|
|
break;
|
|
case type::t_sampler3d_int:
|
|
s += "isampler3D";
|
|
break;
|
|
case type::t_sampler1d_uint:
|
|
s += "usampler1D";
|
|
break;
|
|
case type::t_sampler3d_uint:
|
|
s += "usampler3D";
|
|
break;
|
|
case type::t_sampler2d_uint:
|
|
s += "usampler2D";
|
|
break;
|
|
case type::t_sampler1d_float:
|
|
s += "sampler1D";
|
|
break;
|
|
case type::t_sampler2d_float:
|
|
s += "sampler2D";
|
|
break;
|
|
case type::t_sampler3d_float:
|
|
s += "sampler3D";
|
|
break;
|
|
case type::t_storage1d_int:
|
|
if constexpr (is_param)
|
|
s += "writeonly ";
|
|
s += "iimage1D";
|
|
break;
|
|
case type::t_storage2d_int:
|
|
if constexpr (is_param)
|
|
s += "writeonly ";
|
|
s += "iimage2D";
|
|
break;
|
|
case type::t_storage3d_int:
|
|
if constexpr (is_param)
|
|
s += "writeonly ";
|
|
s += "iimage3D";
|
|
break;
|
|
case type::t_storage1d_uint:
|
|
if constexpr (is_param)
|
|
s += "writeonly ";
|
|
s += "uimage1D";
|
|
break;
|
|
case type::t_storage2d_uint:
|
|
if constexpr (is_param)
|
|
s += "writeonly ";
|
|
s += "uimage2D";
|
|
break;
|
|
case type::t_storage3d_uint:
|
|
if constexpr (is_param)
|
|
s += "writeonly ";
|
|
s += "uimage3D";
|
|
break;
|
|
case type::t_storage1d_float:
|
|
if constexpr (is_param)
|
|
s += "writeonly ";
|
|
s += "image1D";
|
|
break;
|
|
case type::t_storage2d_float:
|
|
if constexpr (is_param) // Images need a format to be readable, but declaring that on function parameters is not well supported, so can only support write-only images there
|
|
s += "writeonly ";
|
|
s += "image2D";
|
|
break;
|
|
case type::t_storage3d_float:
|
|
if constexpr (is_param)
|
|
s += "writeonly ";
|
|
s += "image3D";
|
|
break;
|
|
default:
|
|
assert(false);
|
|
}
|
|
}
|
|
void write_constant(std::string &s, const type &type, const constant &data) const
|
|
{
|
|
if (type.is_array())
|
|
{
|
|
auto elem_type = type;
|
|
elem_type.array_length = 0;
|
|
|
|
write_type<false, false>(s, elem_type);
|
|
s += '[' + std::to_string(type.array_length) + "](";
|
|
|
|
for (int i = 0; i < type.array_length; ++i)
|
|
{
|
|
write_constant(s, elem_type, i < static_cast<int>(data.array_data.size()) ? data.array_data[i] : constant());
|
|
|
|
if (i < type.array_length - 1)
|
|
s += ", ";
|
|
}
|
|
|
|
s += ')';
|
|
return;
|
|
}
|
|
|
|
// There can only be numeric constants
|
|
assert(type.is_numeric());
|
|
|
|
if (!type.is_scalar())
|
|
write_type<false, false>(s, type), s += '(';
|
|
|
|
for (unsigned int i = 0, components = type.components(); i < components; ++i)
|
|
{
|
|
switch (type.base)
|
|
{
|
|
case type::t_bool:
|
|
s += data.as_uint[i] ? "true" : "false";
|
|
break;
|
|
case type::t_min16int:
|
|
case type::t_int:
|
|
s += std::to_string(data.as_int[i]);
|
|
break;
|
|
case type::t_min16uint:
|
|
case type::t_uint:
|
|
s += std::to_string(data.as_uint[i]) + 'u';
|
|
break;
|
|
case type::t_min16float:
|
|
case type::t_float:
|
|
if (std::isnan(data.as_float[i])) {
|
|
s += "0.0/0.0/*nan*/";
|
|
break;
|
|
}
|
|
if (std::isinf(data.as_float[i])) {
|
|
s += std::signbit(data.as_float[i]) ? "1.0/0.0/*inf*/" : "-1.0/0.0/*-inf*/";
|
|
break;
|
|
}
|
|
char temp[64]; // Will be null-terminated by snprintf
|
|
std::snprintf(temp, sizeof(temp), "%1.8e", data.as_float[i]);
|
|
s += temp;
|
|
break;
|
|
default:
|
|
assert(false);
|
|
}
|
|
|
|
if (i < components - 1)
|
|
s += ", ";
|
|
}
|
|
|
|
if (!type.is_scalar())
|
|
s += ')';
|
|
}
|
|
void write_location(std::string &s, const location &loc) const
|
|
{
|
|
if (loc.source.empty() || !_debug_info)
|
|
return;
|
|
|
|
s += "#line " + std::to_string(loc.line) + '\n';
|
|
}
|
|
void write_texture_format(std::string &s, texture_format format)
|
|
{
|
|
switch (format)
|
|
{
|
|
case texture_format::r8:
|
|
s += "r8";
|
|
break;
|
|
case texture_format::r16:
|
|
s += "r16";
|
|
break;
|
|
case texture_format::r16f:
|
|
s += "r16f";
|
|
break;
|
|
case texture_format::r32i:
|
|
s += "r32i";
|
|
break;
|
|
case texture_format::r32u:
|
|
s += "r32u";
|
|
break;
|
|
case texture_format::r32f:
|
|
s += "r32f";
|
|
break;
|
|
case texture_format::rg8:
|
|
s += "rg8";
|
|
break;
|
|
case texture_format::rg16:
|
|
s += "rg16";
|
|
break;
|
|
case texture_format::rg16f:
|
|
s += "rg16f";
|
|
break;
|
|
case texture_format::rg32f:
|
|
s += "rg32f";
|
|
break;
|
|
case texture_format::rgba8:
|
|
s += "rgba8";
|
|
break;
|
|
case texture_format::rgba16:
|
|
s += "rgba16";
|
|
break;
|
|
case texture_format::rgba16f:
|
|
s += "rgba16f";
|
|
break;
|
|
case texture_format::rgba32f:
|
|
s += "rgba32f";
|
|
break;
|
|
case texture_format::rgb10a2:
|
|
s += "rgb10_a2";
|
|
break;
|
|
default:
|
|
assert(false);
|
|
}
|
|
}
|
|
|
|
std::string id_to_name(id id) const
|
|
{
|
|
if (const auto it = _remapped_sampler_variables.find(id);
|
|
it != _remapped_sampler_variables.end())
|
|
id = it->second;
|
|
|
|
assert(id != 0);
|
|
if (const auto names_it = _names.find(id);
|
|
names_it != _names.end())
|
|
return names_it->second;
|
|
return '_' + std::to_string(id);
|
|
}
|
|
|
|
template <naming naming_type = naming::general>
|
|
void define_name(const id id, std::string name)
|
|
{
|
|
assert(!name.empty());
|
|
if constexpr (naming_type != naming::expression)
|
|
if (name[0] == '_')
|
|
return; // Filter out names that may clash with automatic ones
|
|
if constexpr (naming_type != naming::reserved)
|
|
name = escape_name(std::move(name));
|
|
if constexpr (naming_type == naming::general)
|
|
if (std::find_if(_names.begin(), _names.end(), [&name](const auto &it) { return it.second == name; }) != _names.end())
|
|
name += '_' + std::to_string(id); // Append a numbered suffix if the name already exists
|
|
_names[id] = std::move(name);
|
|
}
|
|
|
|
uint32_t semantic_to_location(const std::string &semantic, uint32_t max_array_length = 1)
|
|
{
|
|
if (semantic.compare(0, 5, "COLOR") == 0)
|
|
return std::strtoul(semantic.c_str() + 5, nullptr, 10);
|
|
if (semantic.compare(0, 9, "SV_TARGET") == 0)
|
|
return std::strtoul(semantic.c_str() + 9, nullptr, 10);
|
|
|
|
if (const auto it = _semantic_to_location.find(semantic);
|
|
it != _semantic_to_location.end())
|
|
return it->second;
|
|
|
|
// Extract the semantic index from the semantic name (e.g. 2 for "TEXCOORD2")
|
|
size_t digit_index = semantic.size() - 1;
|
|
while (digit_index != 0 && semantic[digit_index] >= '0' && semantic[digit_index] <= '9')
|
|
digit_index--;
|
|
digit_index++;
|
|
|
|
const uint32_t semantic_digit = std::strtoul(semantic.c_str() + digit_index, nullptr, 10);
|
|
const std::string semantic_base = semantic.substr(0, digit_index);
|
|
|
|
uint32_t location = static_cast<uint32_t>(_semantic_to_location.size());
|
|
|
|
// Now create adjoining location indices for all possible semantic indices belonging to this semantic name
|
|
for (uint32_t a = 0; a < semantic_digit + max_array_length; ++a)
|
|
{
|
|
const auto insert = _semantic_to_location.emplace(semantic_base + std::to_string(a), location + a);
|
|
if (!insert.second)
|
|
{
|
|
assert(a == 0 || (insert.first->second - a) == location);
|
|
|
|
// Semantic was already created with a different location index, so need to remap to that
|
|
location = insert.first->second - a;
|
|
}
|
|
}
|
|
|
|
return location + semantic_digit;
|
|
}
|
|
|
|
std::string escape_name(std::string name) const
|
|
{
|
|
static const std::unordered_set<std::string> s_reserverd_names = {
|
|
"common", "partition", "input", "output", "active", "filter", "superp", "invariant",
|
|
"attribute", "varying", "buffer", "resource", "coherent", "readonly", "writeonly",
|
|
"layout", "flat", "smooth", "lowp", "mediump", "highp", "precision", "patch", "subroutine",
|
|
"atomic_uint", "fixed",
|
|
"vec2", "vec3", "vec4", "ivec2", "dvec2", "dvec3", "dvec4", "ivec3", "ivec4", "uvec2", "uvec3", "uvec4", "bvec2", "bvec3", "bvec4", "fvec2", "fvec3", "fvec4", "hvec2", "hvec3", "hvec4",
|
|
"mat2", "mat3", "mat4", "dmat2", "dmat3", "dmat4", "mat2x2", "mat2x3", "mat2x4", "dmat2x2", "dmat2x3", "dmat2x4", "mat3x2", "mat3x3", "mat3x4", "dmat3x2", "dmat3x3", "dmat3x4", "mat4x2", "mat4x3", "mat4x4", "dmat4x2", "dmat4x3", "dmat4x4",
|
|
"sampler1DShadow", "sampler1DArrayShadow", "isampler1D", "isampler1DArray", "usampler1D", "usampler1DArray",
|
|
"sampler2DShadow", "sampler2DArrayShadow", "isampler2D", "isampler2DArray", "usampler2D", "usampler2DArray", "sampler2DRect", "sampler2DRectShadow", "isampler2DRect", "usampler2DRect", "isampler2DMS", "usampler2DMS", "isampler2DMSArray", "usampler2DMSArray",
|
|
"isampler3D", "usampler3D", "sampler3DRect",
|
|
"samplerCubeShadow", "samplerCubeArrayShadow", "isamplerCube", "isamplerCubeArray", "usamplerCube", "usamplerCubeArray",
|
|
"samplerBuffer", "isamplerBuffer", "usamplerBuffer",
|
|
"image1D", "iimage1D", "uimage1D", "image1DArray", "iimage1DArray", "uimage1DArray",
|
|
"image2D", "iimage2D", "uimage2D", "image2DArray", "iimage2DArray", "uimage2DArray", "image2DRect", "iimage2DRect", "uimage2DRect", "image2DMS", "iimage2DMS", "uimage2DMS", "image2DMSArray", "iimage2DMSArray", "uimage2DMSArray",
|
|
"image3D", "iimage3D", "uimage3D",
|
|
"imageCube", "iimageCube", "uimageCube", "imageCubeArray", "iimageCubeArray", "uimageCubeArray",
|
|
"imageBuffer", "iimageBuffer", "uimageBuffer",
|
|
"abs", "sign", "all", "any", "sin", "sinh", "cos", "cosh", "tan", "tanh", "asin", "acos", "atan",
|
|
"exp", "exp2", "log", "log2", "sqrt", "inversesqrt", "ceil", "floor", "fract", "trunc", "round",
|
|
"radians", "degrees", "length", "normalize", "transpose", "determinant", "intBitsToFloat", "uintBitsToFloat",
|
|
"floatBitsToInt", "floatBitsToUint", "matrixCompMult", "not", "lessThan", "greaterThan", "lessThanEqual",
|
|
"greaterThanEqual", "equal", "notEqual", "dot", "cross", "distance", "pow", "modf", "frexp", "ldexp",
|
|
"min", "max", "step", "reflect", "texture", "textureOffset", "fma", "mix", "clamp", "smoothstep", "refract",
|
|
"faceforward", "textureLod", "textureLodOffset", "texelFetch", "main"
|
|
};
|
|
|
|
// Escape reserved names so that they do not fail to compile
|
|
if (name.compare(0, 3, "gl_") == 0 || s_reserverd_names.count(name))
|
|
// Append an underscore at start instead of the end, since another one may get added in 'define_name' when there is a suffix
|
|
// This is guaranteed to not clash with user defined names, since those starting with an underscore are filtered out in 'define_name'
|
|
name = '_' + name;
|
|
|
|
// Remove duplicated underscore symbols from name which can occur due to namespaces but are not allowed in GLSL
|
|
for (size_t pos = 0; (pos = name.find("__", pos)) != std::string::npos;)
|
|
name.replace(pos, 2, "_");
|
|
|
|
return name;
|
|
}
|
|
std::string semantic_to_builtin(std::string name, const std::string &semantic, shader_type stype) const
|
|
{
|
|
if (semantic == "SV_POSITION")
|
|
return stype == shader_type::ps ? "gl_FragCoord" : "gl_Position";
|
|
if (semantic == "SV_POINTSIZE")
|
|
return "gl_PointSize";
|
|
if (semantic == "SV_DEPTH")
|
|
return "gl_FragDepth";
|
|
if (semantic == "SV_VERTEXID")
|
|
return _vulkan_semantics ? "gl_VertexIndex" : "gl_VertexID";
|
|
if (semantic == "SV_ISFRONTFACE")
|
|
return "gl_FrontFacing";
|
|
if (semantic == "SV_GROUPID")
|
|
return "gl_WorkGroupID";
|
|
if (semantic == "SV_GROUPINDEX")
|
|
return "gl_LocalInvocationIndex";
|
|
if (semantic == "SV_GROUPTHREADID")
|
|
return "gl_LocalInvocationID";
|
|
if (semantic == "SV_DISPATCHTHREADID")
|
|
return "gl_GlobalInvocationID";
|
|
|
|
return escape_name(std::move(name));
|
|
}
|
|
|
|
static void increase_indentation_level(std::string &block)
|
|
{
|
|
if (block.empty())
|
|
return;
|
|
|
|
for (size_t pos = 0; (pos = block.find("\n\t", pos)) != std::string::npos; pos += 3)
|
|
block.replace(pos, 2, "\n\t\t");
|
|
|
|
block.insert(block.begin(), '\t');
|
|
}
|
|
|
|
id define_struct(const location &loc, struct_info &info) override
|
|
{
|
|
info.definition = make_id();
|
|
define_name<naming::unique>(info.definition, info.unique_name);
|
|
|
|
_structs.push_back(info);
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
write_location(code, loc);
|
|
|
|
code += "struct " + id_to_name(info.definition) + "\n{\n";
|
|
|
|
for (const struct_member_info &member : info.member_list)
|
|
{
|
|
code += '\t';
|
|
write_type(code, member.type); // GLSL does not allow interpolation attributes on struct members
|
|
code += ' ';
|
|
code += escape_name(member.name);
|
|
if (member.type.is_array())
|
|
code += '[' + std::to_string(member.type.array_length) + ']';
|
|
code += ";\n";
|
|
}
|
|
|
|
if (info.member_list.empty())
|
|
code += "float _dummy;\n";
|
|
|
|
code += "};\n";
|
|
|
|
return info.definition;
|
|
}
|
|
id define_texture(const location &, texture_info &info) override
|
|
{
|
|
info.id = make_id();
|
|
info.binding = ~0u;
|
|
|
|
_module.textures.push_back(info);
|
|
|
|
return info.id;
|
|
}
|
|
id define_sampler(const location &loc, const texture_info &, sampler_info &info) override
|
|
{
|
|
info.id = make_id();
|
|
info.binding = _module.num_sampler_bindings++;
|
|
info.texture_binding = ~0u; // Unset texture bindings
|
|
|
|
define_name<naming::unique>(info.id, info.unique_name);
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
write_location(code, loc);
|
|
|
|
code += "layout(";
|
|
if (_vulkan_semantics)
|
|
code += "set = 1, ";
|
|
#if 0
|
|
code += "binding = " + std::to_string(info.binding);
|
|
#else
|
|
code += "binding = /*SAMPLER:" + info.unique_name + "*/0";
|
|
#endif
|
|
code += ") uniform ";
|
|
write_type(code, info.type);
|
|
code += ' ' + id_to_name(info.id) + ";\n";
|
|
|
|
_module.samplers.push_back(info);
|
|
|
|
return info.id;
|
|
}
|
|
id define_storage(const location &loc, const texture_info &tex_info, storage_info &info) override
|
|
{
|
|
info.id = make_id();
|
|
info.binding = _module.num_storage_bindings++;
|
|
|
|
define_name<naming::unique>(info.id, info.unique_name);
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
write_location(code, loc);
|
|
|
|
code += "layout(binding = " + std::to_string(info.binding) + ", ";
|
|
write_texture_format(code, tex_info.format);
|
|
code += ") uniform ";
|
|
write_type(code, info.type);
|
|
code += ' ' + id_to_name(info.id) + ";\n";
|
|
|
|
_module.storages.push_back(info);
|
|
|
|
return info.id;
|
|
}
|
|
id define_uniform(const location &loc, uniform_info &info) override
|
|
{
|
|
const id res = make_id();
|
|
|
|
define_name<naming::unique>(res, info.name);
|
|
|
|
if (_uniforms_to_spec_constants && info.has_initializer_value)
|
|
{
|
|
info.size = info.type.components() * 4;
|
|
if (info.type.is_array())
|
|
info.size *= info.type.array_length;
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
write_location(code, loc);
|
|
|
|
assert(!info.type.has(type::q_static) && !info.type.has(type::q_const));
|
|
|
|
code += "const ";
|
|
write_type(code, info.type);
|
|
code += ' ' + id_to_name(res) + " = ";
|
|
if (!info.type.is_scalar())
|
|
write_type<false, false>(code, info.type);
|
|
code += "(SPEC_CONSTANT_" + info.name + ");\n";
|
|
|
|
_module.spec_constants.push_back(info);
|
|
}
|
|
else
|
|
{
|
|
// GLSL specification on std140 layout:
|
|
// 1. If the member is a scalar consuming N basic machine units, the base alignment is N.
|
|
// 2. If the member is a two- or four-component vector with components consuming N basic machine units, the base alignment is 2N or 4N, respectively.
|
|
// 3. If the member is a three-component vector with components consuming N basic machine units, the base alignment is 4N.
|
|
// 4. If the member is an array of scalars or vectors, the base alignment and array stride are set to match the base alignment of a single array element,
|
|
// according to rules (1), (2), and (3), and rounded up to the base alignment of a four-component vector.
|
|
// 7. If the member is a row-major matrix with C columns and R rows, the matrix is stored identically to an array of R row vectors with C components each, according to rule (4).
|
|
// 8. If the member is an array of S row-major matrices with C columns and R rows, the matrix is stored identically to a row of S*R row vectors with C components each, according to rule (4).
|
|
uint32_t alignment = (info.type.rows == 3 ? 4 /* (3) */ : info.type.rows /* (2)*/) * 4 /* (1)*/;
|
|
info.size = info.type.rows * 4;
|
|
|
|
if (info.type.is_matrix())
|
|
{
|
|
alignment = 16 /* (4) */;
|
|
info.size = info.type.rows * alignment /* (7), (8) */;
|
|
}
|
|
if (info.type.is_array())
|
|
{
|
|
alignment = 16 /* (4) */;
|
|
info.size = align_up(info.size, alignment) * info.type.array_length;
|
|
}
|
|
|
|
// Adjust offset according to alignment rules from above
|
|
info.offset = _module.total_uniform_size;
|
|
info.offset = align_up(info.offset, alignment);
|
|
_module.total_uniform_size = info.offset + info.size;
|
|
|
|
write_location(_ubo_block, loc);
|
|
|
|
_ubo_block += '\t';
|
|
// Note: All matrices are floating-point, even if the uniform type says different!!
|
|
write_type(_ubo_block, info.type);
|
|
_ubo_block += ' ' + id_to_name(res);
|
|
|
|
if (info.type.is_array())
|
|
_ubo_block += '[' + std::to_string(info.type.array_length) + ']';
|
|
|
|
_ubo_block += ";\n";
|
|
|
|
_module.uniforms.push_back(info);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
id define_variable(const location &loc, const type &type, std::string name, bool global, id initializer_value) override
|
|
{
|
|
const id res = make_id();
|
|
|
|
// GLSL does not allow local sampler variables, so try to remap those
|
|
if (!global && type.is_sampler())
|
|
return (_remapped_sampler_variables[res] = 0), res;
|
|
|
|
if (!name.empty())
|
|
define_name<naming::general>(res, name);
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
write_location(code, loc);
|
|
|
|
if (!global)
|
|
code += '\t';
|
|
|
|
if (initializer_value != 0 && (type.has(type::q_const) && !_gles))
|
|
code += "const ";
|
|
|
|
write_type(code, type);
|
|
code += ' ' + id_to_name(res);
|
|
|
|
if (type.is_array())
|
|
code += '[' + std::to_string(type.array_length) + ']';
|
|
|
|
if (initializer_value != 0)
|
|
code += " = " + id_to_name(initializer_value);
|
|
|
|
code += ";\n";
|
|
|
|
return res;
|
|
}
|
|
id define_function(const location &loc, function_info &info) override
|
|
{
|
|
return define_function(loc, info, false);
|
|
}
|
|
|
|
id define_function(const location &loc, function_info &info, bool is_entry_point)
|
|
{
|
|
info.definition = make_id();
|
|
|
|
// Name is used in other places like the "ENTRY_POINT" defines, so escape it here
|
|
info.unique_name = escape_name(info.unique_name);
|
|
|
|
if (!is_entry_point)
|
|
define_name<naming::unique>(info.definition, info.unique_name);
|
|
else
|
|
define_name<naming::reserved>(info.definition, "main");
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
write_location(code, loc);
|
|
|
|
write_type(code, info.return_type);
|
|
code += ' ' + id_to_name(info.definition) + '(';
|
|
|
|
assert(info.parameter_list.empty() || !is_entry_point);
|
|
|
|
for (size_t i = 0, num_params = info.parameter_list.size(); i < num_params; ++i)
|
|
{
|
|
auto ¶m = info.parameter_list[i];
|
|
|
|
param.definition = make_id();
|
|
define_name<naming::unique>(param.definition, param.name);
|
|
|
|
code += '\n';
|
|
write_location(code, param.location);
|
|
code += '\t';
|
|
write_type<true>(code, param.type); // GLSL does not allow interpolation attributes on function parameters
|
|
code += ' ' + id_to_name(param.definition);
|
|
|
|
if (param.type.is_array())
|
|
code += '[' + std::to_string(param.type.array_length) + ']';
|
|
|
|
if (i < num_params - 1)
|
|
code += ',';
|
|
}
|
|
|
|
code += ")\n";
|
|
|
|
_functions.push_back(std::make_unique<function_info>(info));
|
|
|
|
return info.definition;
|
|
}
|
|
|
|
void define_entry_point(function_info &func, shader_type stype, int num_threads[3]) override
|
|
{
|
|
// Modify entry point name so each thread configuration is made separate
|
|
if (stype == shader_type::cs)
|
|
func.unique_name = 'E' + func.unique_name +
|
|
'_' + std::to_string(num_threads[0]) +
|
|
'_' + std::to_string(num_threads[1]) +
|
|
'_' + std::to_string(num_threads[2]);
|
|
|
|
if (const auto it = std::find_if(_module.entry_points.begin(), _module.entry_points.end(),
|
|
[&func](const auto &ep) { return ep.name == func.unique_name; });
|
|
it != _module.entry_points.end())
|
|
return;
|
|
|
|
_module.entry_points.push_back({ func.unique_name, stype });
|
|
|
|
_blocks.at(0) += "#ifdef ENTRY_POINT_" + func.unique_name + '\n';
|
|
if (stype == shader_type::cs)
|
|
_blocks.at(0) += "layout(local_size_x = " + std::to_string(num_threads[0]) +
|
|
", local_size_y = " + std::to_string(num_threads[1]) +
|
|
", local_size_z = " + std::to_string(num_threads[2]) + ") in;\n";
|
|
|
|
function_info entry_point;
|
|
entry_point.return_type = { type::t_void };
|
|
|
|
std::unordered_map<std::string, std::string> semantic_to_varying_variable;
|
|
|
|
const auto create_varying_variable = [this, stype, &semantic_to_varying_variable](type type, unsigned int extra_qualifiers, const std::string &name, const std::string &semantic) {
|
|
// Skip built in variables
|
|
if (!semantic_to_builtin(std::string(), semantic, stype).empty())
|
|
return;
|
|
|
|
// Do not create multiple input/output variables for duplicate semantic usage (since every input/output location may only be defined once in GLSL)
|
|
if ((extra_qualifiers & type::q_in) != 0 &&
|
|
!semantic_to_varying_variable.emplace(semantic, name).second)
|
|
return;
|
|
|
|
type.qualifiers |= extra_qualifiers;
|
|
assert((type.has(type::q_in) || type.has(type::q_out)) && !type.has(type::q_inout));
|
|
|
|
// OpenGL does not allow varying of type boolean
|
|
if (type.is_boolean())
|
|
type.base = type::t_float;
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
const int array_length = std::max(1, type.array_length);
|
|
const uint32_t location = semantic_to_location(semantic, array_length);
|
|
|
|
for (int a = 0; a < array_length; ++a)
|
|
{
|
|
code += "layout(location = " + std::to_string(location + a) + ") ";
|
|
write_type<false, false, true>(code, type);
|
|
code += ' ';
|
|
code += escape_name(type.is_array() ?
|
|
name + '_' + std::to_string(a) :
|
|
name);
|
|
code += ";\n";
|
|
}
|
|
};
|
|
|
|
// Translate function parameters to input/output variables
|
|
if (func.return_type.is_struct())
|
|
{
|
|
const struct_info &definition = get_struct(func.return_type.definition);
|
|
|
|
for (const struct_member_info &member : definition.member_list)
|
|
create_varying_variable(member.type, type::q_out, "_return_" + member.name, member.semantic);
|
|
}
|
|
else if (!func.return_type.is_void())
|
|
{
|
|
create_varying_variable(func.return_type, type::q_out, "_return", func.return_semantic);
|
|
}
|
|
|
|
const auto num_params = func.parameter_list.size();
|
|
for (size_t i = 0; i < num_params; ++i)
|
|
{
|
|
type param_type = func.parameter_list[i].type;
|
|
param_type.qualifiers &= ~type::q_inout;
|
|
|
|
// Create separate input/output variables for "inout" parameters (since "inout" is not valid on those in GLSL)
|
|
if (func.parameter_list[i].type.has(type::q_in))
|
|
{
|
|
// Flatten structure parameters
|
|
if (param_type.is_struct())
|
|
{
|
|
const struct_info &definition = get_struct(param_type.definition);
|
|
|
|
for (int a = 0, array_length = std::max(1, param_type.array_length); a < array_length; a++)
|
|
for (const struct_member_info &member : definition.member_list)
|
|
create_varying_variable(member.type, param_type.qualifiers | type::q_in, "_in_param" + std::to_string(i) + '_' + std::to_string(a) + '_' + member.name, member.semantic);
|
|
}
|
|
else
|
|
{
|
|
create_varying_variable(param_type, type::q_in, "_in_param" + std::to_string(i), func.parameter_list[i].semantic);
|
|
}
|
|
}
|
|
|
|
if (func.parameter_list[i].type.has(type::q_out))
|
|
{
|
|
if (param_type.is_struct())
|
|
{
|
|
const struct_info &definition = get_struct(param_type.definition);
|
|
|
|
for (int a = 0, array_length = std::max(1, param_type.array_length); a < array_length; a++)
|
|
for (const struct_member_info &member : definition.member_list)
|
|
create_varying_variable(member.type, param_type.qualifiers | type::q_out, "_out_param" + std::to_string(i) + '_' + std::to_string(a) + '_' + member.name, member.semantic);
|
|
}
|
|
else
|
|
{
|
|
create_varying_variable(param_type, type::q_out, "_out_param" + std::to_string(i), func.parameter_list[i].semantic);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Translate return value to output variable
|
|
define_function({}, entry_point, true);
|
|
enter_block(create_block());
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
// Handle input parameters
|
|
for (size_t i = 0; i < num_params; ++i)
|
|
{
|
|
const type ¶m_type = func.parameter_list[i].type;
|
|
|
|
if (param_type.has(type::q_in))
|
|
{
|
|
// Create local array element variables
|
|
for (int a = 0, array_length = std::max(1, param_type.array_length); a < array_length; a++)
|
|
{
|
|
if (param_type.is_struct())
|
|
{
|
|
// Build struct from separate member input variables
|
|
code += '\t';
|
|
write_type<false, true>(code, param_type);
|
|
code += ' ';
|
|
code += escape_name(param_type.is_array() ?
|
|
"_in_param" + std::to_string(i) + '_' + std::to_string(a) :
|
|
"_in_param" + std::to_string(i));
|
|
code += " = ";
|
|
write_type<false, false>(code, param_type);
|
|
code += '(';
|
|
|
|
const struct_info &definition = get_struct(param_type.definition);
|
|
|
|
for (const struct_member_info &member : definition.member_list)
|
|
{
|
|
std::string in_param_name = "_in_param" + std::to_string(i) + '_' + std::to_string(a) + '_' + member.name;
|
|
if (const auto it = semantic_to_varying_variable.find(member.semantic);
|
|
it != semantic_to_varying_variable.end() && it->second != in_param_name)
|
|
in_param_name = it->second;
|
|
|
|
if (member.type.is_array())
|
|
{
|
|
write_type<false, false>(code, member.type);
|
|
code += "[](";
|
|
|
|
for (int b = 0; b < member.type.array_length; b++)
|
|
{
|
|
// OpenGL does not allow varying of type boolean, so need to cast here
|
|
if (member.type.is_boolean())
|
|
{
|
|
write_type<false, false>(code, member.type);
|
|
code += '(';
|
|
}
|
|
|
|
code += escape_name(in_param_name + '_' + std::to_string(b));
|
|
|
|
if (member.type.is_boolean())
|
|
code += ')';
|
|
|
|
if (b < member.type.array_length - 1)
|
|
code += ", ";
|
|
}
|
|
|
|
code += ')';
|
|
}
|
|
else
|
|
{
|
|
if (member.type.is_boolean() || (_gles && member.type.is_integral()))
|
|
{
|
|
write_type<false, false>(code, member.type);
|
|
code += '(';
|
|
}
|
|
|
|
code += semantic_to_builtin(std::move(in_param_name), member.semantic, stype);
|
|
|
|
if (member.type.is_boolean() || (_gles && member.type.is_integral()))
|
|
code += ')';
|
|
}
|
|
|
|
code += ", ";
|
|
}
|
|
|
|
// There can be no empty structs, so can assume that the last two characters are always ", "
|
|
code.pop_back();
|
|
code.pop_back();
|
|
|
|
code += ");\n";
|
|
}
|
|
else if (const auto it = semantic_to_varying_variable.find(func.parameter_list[i].semantic);
|
|
it != semantic_to_varying_variable.end() && it->second != "_in_param" + std::to_string(i))
|
|
{
|
|
// Create local variables for duplicated semantics (since no input/output variable is created for those, see 'create_varying_variable')
|
|
code += '\t';
|
|
write_type<false, true>(code, param_type);
|
|
code += ' ';
|
|
code += escape_name(param_type.is_array() ?
|
|
"_in_param" + std::to_string(i) + '_' + std::to_string(a) :
|
|
"_in_param" + std::to_string(i));
|
|
code += " = ";
|
|
|
|
if (param_type.is_boolean())
|
|
{
|
|
write_type<false, false>(code, param_type);
|
|
code += '(';
|
|
}
|
|
|
|
code += escape_name(param_type.is_array() ?
|
|
it->second + '_' + std::to_string(a) :
|
|
it->second);
|
|
|
|
if (param_type.is_boolean())
|
|
code += ')';
|
|
|
|
code += ";\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
// Create local parameter variables which are used as arguments in the entry point function call below
|
|
code += '\t';
|
|
write_type<false, true>(code, param_type);
|
|
code += ' ';
|
|
code += escape_name("_param" + std::to_string(i));
|
|
if (param_type.is_array())
|
|
code += '[' + std::to_string(param_type.array_length) + ']';
|
|
|
|
// Initialize those local variables with the input value if existing
|
|
// Parameters with only an "out" qualifier are written to by the entry point function, so do not need to be initialized
|
|
if (param_type.has(type::q_in))
|
|
{
|
|
code += " = ";
|
|
|
|
// Build array from separate array element variables
|
|
if (param_type.is_array())
|
|
{
|
|
write_type<false, false>(code, param_type);
|
|
code += "[](";
|
|
|
|
for (int a = 0; a < param_type.array_length; ++a)
|
|
{
|
|
// OpenGL does not allow varying of type boolean, so need to cast here
|
|
if (param_type.is_boolean())
|
|
{
|
|
write_type<false, false>(code, param_type);
|
|
code += '(';
|
|
}
|
|
|
|
code += escape_name("_in_param" + std::to_string(i) + '_' + std::to_string(a));
|
|
|
|
if (param_type.is_boolean())
|
|
code += ')';
|
|
|
|
if (a < param_type.array_length - 1)
|
|
code += ", ";
|
|
}
|
|
|
|
code += ')';
|
|
}
|
|
else
|
|
{
|
|
if (param_type.is_boolean() || (_gles && param_type.is_integral()))
|
|
{
|
|
write_type<false, false>(code, param_type);
|
|
code += '(';
|
|
}
|
|
|
|
code += semantic_to_builtin("_in_param" + std::to_string(i), func.parameter_list[i].semantic, stype);
|
|
|
|
if (param_type.is_boolean() || (_gles && param_type.is_integral()))
|
|
code += ')';
|
|
}
|
|
}
|
|
|
|
code += ";\n";
|
|
}
|
|
|
|
code += '\t';
|
|
// Structs cannot be output variables, so have to write to a temporary first and then output each member separately
|
|
if (func.return_type.is_struct())
|
|
{
|
|
write_type(code, func.return_type);
|
|
code += " _return = ";
|
|
}
|
|
// All other output types can write to the output variable directly
|
|
else if (!func.return_type.is_void())
|
|
{
|
|
code += semantic_to_builtin("_return", func.return_semantic, stype);
|
|
code += " = ";
|
|
}
|
|
|
|
// Call the function this entry point refers to
|
|
code += id_to_name(func.definition) + '(';
|
|
|
|
for (size_t i = 0; i < num_params; ++i)
|
|
{
|
|
code += "_param" + std::to_string(i);
|
|
|
|
if (i < num_params - 1)
|
|
code += ", ";
|
|
}
|
|
|
|
code += ");\n";
|
|
|
|
// Handle output parameters
|
|
for (size_t i = 0; i < num_params; ++i)
|
|
{
|
|
const type ¶m_type = func.parameter_list[i].type;
|
|
if (!param_type.has(type::q_out))
|
|
continue;
|
|
|
|
if (param_type.is_struct())
|
|
{
|
|
const struct_info &definition = get_struct(param_type.definition);
|
|
|
|
// Split out struct fields into separate output variables again
|
|
for (int a = 0, array_length = std::max(1, param_type.array_length); a < array_length; a++)
|
|
{
|
|
for (const struct_member_info &member : definition.member_list)
|
|
{
|
|
if (member.type.is_array())
|
|
{
|
|
for (int b = 0; b < member.type.array_length; b++)
|
|
{
|
|
code += '\t';
|
|
code += escape_name("_out_param" + std::to_string(i) + '_' + std::to_string(a) + '_' + member.name + '_' + std::to_string(b));
|
|
code += " = ";
|
|
|
|
// OpenGL does not allow varying of type boolean, so need to cast here
|
|
if (member.type.is_boolean())
|
|
{
|
|
type varying_type = member.type;
|
|
varying_type.base = type::t_float;
|
|
write_type<false, false>(code, varying_type);
|
|
code += '(';
|
|
}
|
|
|
|
code += escape_name("_param" + std::to_string(i));
|
|
if (param_type.is_array())
|
|
code += '[' + std::to_string(a) + ']';
|
|
code += '.';
|
|
code += member.name;
|
|
code += '[' + std::to_string(b) + ']';
|
|
|
|
if (member.type.is_boolean())
|
|
code += ')';
|
|
|
|
code += ";\n";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
code += '\t';
|
|
code += semantic_to_builtin("_out_param" + std::to_string(i) + '_' + std::to_string(a) + '_' + member.name, member.semantic, stype);
|
|
code += " = ";
|
|
|
|
if (member.type.is_boolean())
|
|
{
|
|
type varying_type = member.type;
|
|
varying_type.base = type::t_float;
|
|
write_type<false, false>(code, varying_type);
|
|
code += '(';
|
|
}
|
|
|
|
code += escape_name("_param" + std::to_string(i));
|
|
if (param_type.is_array())
|
|
code += '[' + std::to_string(a) + ']';
|
|
code += '.';
|
|
code += member.name;
|
|
|
|
if (member.type.is_boolean())
|
|
code += ')';
|
|
|
|
code += ";\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (param_type.is_array())
|
|
{
|
|
// Split up array output into individual array elements again
|
|
for (int a = 0; a < param_type.array_length; a++)
|
|
{
|
|
code += '\t';
|
|
code += escape_name("_out_param" + std::to_string(i) + '_' + std::to_string(a));
|
|
code += " = ";
|
|
|
|
// OpenGL does not allow varying of type boolean, so need to cast here
|
|
if (param_type.is_boolean())
|
|
{
|
|
type varying_type = param_type;
|
|
varying_type.base = type::t_float;
|
|
write_type<false, false>(code, varying_type);
|
|
code += '(';
|
|
}
|
|
|
|
code += escape_name("_param" + std::to_string(i));
|
|
code += '[' + std::to_string(a) + ']';
|
|
|
|
if (param_type.is_boolean())
|
|
code += ')';
|
|
|
|
code += ";\n";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
code += '\t';
|
|
code += semantic_to_builtin("_out_param" + std::to_string(i), func.parameter_list[i].semantic, stype);
|
|
code += " = ";
|
|
|
|
if (param_type.is_boolean())
|
|
{
|
|
type varying_type = param_type;
|
|
varying_type.base = type::t_float;
|
|
write_type<false, false>(code, varying_type);
|
|
code += '(';
|
|
}
|
|
|
|
code += escape_name("_param" + std::to_string(i));
|
|
|
|
if (param_type.is_boolean())
|
|
code += ')';
|
|
|
|
code += ";\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
// Handle return struct output variables
|
|
if (func.return_type.is_struct())
|
|
{
|
|
const struct_info &definition = get_struct(func.return_type.definition);
|
|
|
|
for (const struct_member_info &member : definition.member_list)
|
|
{
|
|
code += '\t';
|
|
code += semantic_to_builtin("_return_" + member.name, member.semantic, stype);
|
|
code += " = _return." + escape_name(member.name) + ";\n";
|
|
}
|
|
}
|
|
|
|
// Add code to flip the output vertically
|
|
if (_flip_vert_y && stype == shader_type::vs)
|
|
code += "\tgl_Position.y = -gl_Position.y;\n";
|
|
|
|
leave_block_and_return(0);
|
|
leave_function();
|
|
|
|
_blocks.at(0) += "#endif\n";
|
|
}
|
|
|
|
id emit_load(const expression &exp, bool force_new_id) override
|
|
{
|
|
if (exp.is_constant)
|
|
return emit_constant(exp.type, exp.constant);
|
|
else if (exp.chain.empty() && !force_new_id) // Can refer to values without access chain directly
|
|
return exp.base;
|
|
|
|
const id res = make_id();
|
|
|
|
std::string type, expr_code = id_to_name(exp.base);
|
|
|
|
for (const auto &op : exp.chain)
|
|
{
|
|
switch (op.op)
|
|
{
|
|
case expression::operation::op_cast:
|
|
type.clear();
|
|
write_type<false, false>(type, op.to);
|
|
expr_code = type + '(' + expr_code + ')';
|
|
break;
|
|
case expression::operation::op_member:
|
|
expr_code += '.';
|
|
expr_code += escape_name(get_struct(op.from.definition).member_list[op.index].name);
|
|
break;
|
|
case expression::operation::op_dynamic_index:
|
|
// For matrices this will extract a column, but that is fine, since they are initialized column-wise too
|
|
// Also cast to an integer, since it could be a boolean too, but GLSL does not allow those in index expressions
|
|
expr_code += "[int(" + id_to_name(op.index) + ")]";
|
|
break;
|
|
case expression::operation::op_constant_index:
|
|
if (op.from.is_vector() && !op.from.is_array())
|
|
expr_code += '.',
|
|
expr_code += "xyzw"[op.index];
|
|
else
|
|
expr_code += '[' + std::to_string(op.index) + ']';
|
|
break;
|
|
case expression::operation::op_swizzle:
|
|
if (op.from.is_matrix())
|
|
{
|
|
if (op.swizzle[1] < 0)
|
|
{
|
|
const int row = (op.swizzle[0] % 4);
|
|
const int col = (op.swizzle[0] - row) / 4;
|
|
|
|
expr_code += '[' + std::to_string(row) + "][" + std::to_string(col) + ']';
|
|
}
|
|
else
|
|
{
|
|
// TODO: Implement matrix to vector swizzles
|
|
assert(false);
|
|
expr_code += "_NOT_IMPLEMENTED_"; // Make sure compilation fails
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// can't swizzle scalars
|
|
if (_gles && op.from.is_scalar())
|
|
{
|
|
// => e.g. vec3(expr, expr, expr).xyz
|
|
type.clear();
|
|
write_type<false, false>(type, op.to);
|
|
std::string new_code = type;
|
|
new_code += '(';
|
|
|
|
const unsigned int components = op.to.components();
|
|
for (unsigned int i = 0; i < components; ++i)
|
|
{
|
|
if (i > 0)
|
|
new_code += ',';
|
|
new_code += '(' + expr_code + ')';
|
|
}
|
|
new_code += ')';
|
|
expr_code = std::move(new_code);
|
|
}
|
|
else
|
|
{
|
|
expr_code += '.';
|
|
for (unsigned int i = 0; i < 4 && op.swizzle[i] >= 0; ++i)
|
|
expr_code += "xyzw"[op.swizzle[i]];
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// GLSL matrices are always floating point, so need to cast result to the target type
|
|
if (!exp.chain.empty() && exp.chain[0].from.is_matrix() && !exp.chain[0].from.is_floating_point())
|
|
{
|
|
type.clear();
|
|
write_type<false, false>(type, exp.type);
|
|
expr_code = type + '(' + expr_code + ')';
|
|
}
|
|
|
|
if (force_new_id)
|
|
{
|
|
// Need to store value in a new variable to comply with request for a new ID
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
code += '\t';
|
|
write_type(code, exp.type);
|
|
code += ' ' + id_to_name(res) + " = " + expr_code + ";\n";
|
|
}
|
|
else
|
|
{
|
|
// Avoid excessive variable definitions by instancing simple load operations in code every time
|
|
define_name<naming::expression>(res, std::move(expr_code));
|
|
}
|
|
|
|
return res;
|
|
}
|
|
void emit_store(const expression &exp, id value) override
|
|
{
|
|
if (const auto it = _remapped_sampler_variables.find(exp.base);
|
|
it != _remapped_sampler_variables.end())
|
|
{
|
|
assert(it->second == 0);
|
|
it->second = value;
|
|
return;
|
|
}
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
write_location(code, exp.location);
|
|
|
|
code += '\t' + id_to_name(exp.base);
|
|
|
|
for (const auto &op : exp.chain)
|
|
{
|
|
switch (op.op)
|
|
{
|
|
case expression::operation::op_member:
|
|
code += '.';
|
|
code += escape_name(get_struct(op.from.definition).member_list[op.index].name);
|
|
break;
|
|
case expression::operation::op_dynamic_index:
|
|
code += "[int(" + id_to_name(op.index) + ")]";
|
|
break;
|
|
case expression::operation::op_constant_index:
|
|
code += '[' + std::to_string(op.index) + ']';
|
|
break;
|
|
case expression::operation::op_swizzle:
|
|
if (op.from.is_matrix())
|
|
{
|
|
if (op.swizzle[1] < 0)
|
|
{
|
|
const int row = (op.swizzle[0] % 4);
|
|
const int col = (op.swizzle[0] - row) / 4;
|
|
|
|
code += '[' + std::to_string(row) + "][" + std::to_string(col) + ']';
|
|
}
|
|
else
|
|
{
|
|
// TODO: Implement matrix to vector swizzles
|
|
assert(false);
|
|
code += "_NOT_IMPLEMENTED_"; // Make sure compilation fails
|
|
}
|
|
}
|
|
else
|
|
{
|
|
code += '.';
|
|
for (unsigned int i = 0; i < 4 && op.swizzle[i] >= 0; ++i)
|
|
code += "xyzw"[op.swizzle[i]];
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
code += " = ";
|
|
|
|
// GLSL matrices are always floating point, so need to cast type
|
|
if (!exp.chain.empty() && exp.chain[0].from.is_matrix() && !exp.chain[0].from.is_floating_point())
|
|
// Only supporting scalar assignments to matrices currently, so can assume to always cast to float
|
|
code += "float(" + id_to_name(value) + ");\n";
|
|
else
|
|
code += id_to_name(value) + ";\n";
|
|
}
|
|
|
|
id emit_constant(const type &type, const constant &data) override
|
|
{
|
|
const id res = make_id();
|
|
|
|
if (type.is_array() || type.is_struct())
|
|
{
|
|
assert(type.has(type::q_const));
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
code += '\t';
|
|
|
|
// GLSL requires constants to be initialized, but struct initialization is not supported right now
|
|
if (!type.is_struct())
|
|
code += "const ";
|
|
|
|
write_type(code, type);
|
|
code += ' ' + id_to_name(res);
|
|
|
|
// Array constants need to be stored in a constant variable as they cannot be used in-place
|
|
if (type.is_array())
|
|
code += '[' + std::to_string(type.array_length) + ']';
|
|
|
|
// Struct initialization is not supported right now
|
|
if (!type.is_struct()) {
|
|
code += " = ";
|
|
write_constant(code, type, data);
|
|
}
|
|
|
|
code += ";\n";
|
|
return res;
|
|
}
|
|
|
|
std::string code;
|
|
write_constant(code, type, data);
|
|
define_name<naming::expression>(res, std::move(code));
|
|
|
|
return res;
|
|
}
|
|
|
|
id emit_unary_op(const location &loc, tokenid op, const type &res_type, id val) override
|
|
{
|
|
const id res = make_id();
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
write_location(code, loc);
|
|
|
|
code += '\t';
|
|
write_type(code, res_type);
|
|
code += ' ' + id_to_name(res) + " = ";
|
|
|
|
switch (op)
|
|
{
|
|
case tokenid::minus:
|
|
code += '-';
|
|
break;
|
|
case tokenid::tilde:
|
|
code += '~';
|
|
break;
|
|
case tokenid::exclaim:
|
|
if (res_type.is_vector())
|
|
code += "not";
|
|
else
|
|
code += "!bool";
|
|
break;
|
|
default:
|
|
assert(false);
|
|
}
|
|
|
|
code += '(' + id_to_name(val) + ");\n";
|
|
|
|
return res;
|
|
}
|
|
id emit_binary_op(const location &loc, tokenid op, const type &res_type, const type &type, id lhs, id rhs) override
|
|
{
|
|
const id res = make_id();
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
write_location(code, loc);
|
|
|
|
code += '\t';
|
|
write_type(code, res_type);
|
|
code += ' ' + id_to_name(res) + " = ";
|
|
|
|
std::string intrinsic, operator_code;
|
|
|
|
switch (op)
|
|
{
|
|
case tokenid::plus:
|
|
case tokenid::plus_plus:
|
|
case tokenid::plus_equal:
|
|
operator_code = '+';
|
|
break;
|
|
case tokenid::minus:
|
|
case tokenid::minus_minus:
|
|
case tokenid::minus_equal:
|
|
operator_code = '-';
|
|
break;
|
|
case tokenid::star:
|
|
case tokenid::star_equal:
|
|
if (type.is_matrix())
|
|
intrinsic = "matrixCompMult";
|
|
else
|
|
operator_code = '*';
|
|
break;
|
|
case tokenid::slash:
|
|
case tokenid::slash_equal:
|
|
operator_code = '/';
|
|
break;
|
|
case tokenid::percent:
|
|
case tokenid::percent_equal:
|
|
if (type.is_floating_point())
|
|
intrinsic = "fmodHLSL",
|
|
_uses_fmod = true;
|
|
else
|
|
operator_code = '%';
|
|
break;
|
|
case tokenid::caret:
|
|
case tokenid::caret_equal:
|
|
operator_code = '^';
|
|
break;
|
|
case tokenid::pipe:
|
|
case tokenid::pipe_equal:
|
|
operator_code = '|';
|
|
break;
|
|
case tokenid::ampersand:
|
|
case tokenid::ampersand_equal:
|
|
operator_code = '&';
|
|
break;
|
|
case tokenid::less_less:
|
|
case tokenid::less_less_equal:
|
|
operator_code = "<<";
|
|
break;
|
|
case tokenid::greater_greater:
|
|
case tokenid::greater_greater_equal:
|
|
operator_code = ">>";
|
|
break;
|
|
case tokenid::pipe_pipe:
|
|
if (type.is_vector())
|
|
intrinsic = "compOr",
|
|
_uses_componentwise_or = true;
|
|
else
|
|
operator_code = "||";
|
|
break;
|
|
case tokenid::ampersand_ampersand:
|
|
if (type.is_vector())
|
|
intrinsic = "compAnd",
|
|
_uses_componentwise_and = true;
|
|
else
|
|
operator_code = "&&";
|
|
break;
|
|
case tokenid::less:
|
|
if (type.is_vector())
|
|
intrinsic = "lessThan";
|
|
else
|
|
operator_code = '<';
|
|
break;
|
|
case tokenid::less_equal:
|
|
if (type.is_vector())
|
|
intrinsic = "lessThanEqual";
|
|
else
|
|
operator_code = "<=";
|
|
break;
|
|
case tokenid::greater:
|
|
if (type.is_vector())
|
|
intrinsic = "greaterThan";
|
|
else
|
|
operator_code = '>';
|
|
break;
|
|
case tokenid::greater_equal:
|
|
if (type.is_vector())
|
|
intrinsic = "greaterThanEqual";
|
|
else
|
|
operator_code = ">=";
|
|
break;
|
|
case tokenid::equal_equal:
|
|
if (type.is_vector())
|
|
intrinsic = "equal";
|
|
else
|
|
operator_code = "==";
|
|
break;
|
|
case tokenid::exclaim_equal:
|
|
if (type.is_vector())
|
|
intrinsic = "notEqual";
|
|
else
|
|
operator_code = "!=";
|
|
break;
|
|
default:
|
|
assert(false);
|
|
}
|
|
|
|
if (!intrinsic.empty())
|
|
code += intrinsic + '(' + id_to_name(lhs) + ", " + id_to_name(rhs) + ')';
|
|
else
|
|
code += id_to_name(lhs) + ' ' + operator_code + ' ' + id_to_name(rhs);
|
|
|
|
code += ";\n";
|
|
|
|
return res;
|
|
}
|
|
id emit_ternary_op(const location &loc, tokenid op, const type &res_type, id condition, id true_value, id false_value) override
|
|
{
|
|
if (op != tokenid::question)
|
|
return assert(false), 0; // Should never happen, since this is the only ternary operator currently supported
|
|
|
|
const id res = make_id();
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
write_location(code, loc);
|
|
|
|
code += '\t';
|
|
write_type(code, res_type);
|
|
code += ' ' + id_to_name(res);
|
|
|
|
if (res_type.is_array())
|
|
code += '[' + std::to_string(res_type.array_length) + ']';
|
|
|
|
code += " = ";
|
|
|
|
if (res_type.is_vector())
|
|
code += "compCond(" + id_to_name(condition) + ", " + id_to_name(true_value) + ", " + id_to_name(false_value) + ");\n",
|
|
_uses_componentwise_cond = true;
|
|
else // GLSL requires the conditional expression to be a scalar boolean
|
|
code += id_to_name(condition) + " ? " + id_to_name(true_value) + " : " + id_to_name(false_value) + ";\n";
|
|
|
|
return res;
|
|
}
|
|
id emit_call(const location &loc, id function, const type &res_type, const std::vector<expression> &args) override
|
|
{
|
|
#ifndef NDEBUG
|
|
for (const expression &arg : args)
|
|
assert(arg.chain.empty() && arg.base != 0);
|
|
#endif
|
|
|
|
const id res = make_id();
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
write_location(code, loc);
|
|
|
|
code += '\t';
|
|
|
|
if (!res_type.is_void())
|
|
{
|
|
write_type(code, res_type);
|
|
code += ' ' + id_to_name(res);
|
|
|
|
if (res_type.is_array())
|
|
code += '[' + std::to_string(res_type.array_length) + ']';
|
|
|
|
code += " = ";
|
|
}
|
|
|
|
code += id_to_name(function) + '(';
|
|
|
|
for (size_t i = 0, num_args = args.size(); i < num_args; ++i)
|
|
{
|
|
code += id_to_name(args[i].base);
|
|
|
|
if (i < num_args - 1)
|
|
code += ", ";
|
|
}
|
|
|
|
code += ");\n";
|
|
|
|
return res;
|
|
}
|
|
id emit_call_intrinsic(const location &loc, id intrinsic, const type &res_type, const std::vector<expression> &args) override
|
|
{
|
|
#ifndef NDEBUG
|
|
for (const expression &arg : args)
|
|
assert(arg.chain.empty() && arg.base != 0);
|
|
#endif
|
|
|
|
const id res = make_id();
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
write_location(code, loc);
|
|
|
|
code += '\t';
|
|
|
|
if (!res_type.is_void())
|
|
{
|
|
write_type(code, res_type);
|
|
code += ' ' + id_to_name(res) + " = ";
|
|
}
|
|
|
|
enum
|
|
{
|
|
#define IMPLEMENT_INTRINSIC_GLSL(name, i, code) name##i,
|
|
#include "effect_symbol_table_intrinsics.inl"
|
|
};
|
|
|
|
switch (intrinsic)
|
|
{
|
|
#define IMPLEMENT_INTRINSIC_GLSL(name, i, code) case name##i: code break;
|
|
#include "effect_symbol_table_intrinsics.inl"
|
|
default:
|
|
assert(false);
|
|
}
|
|
|
|
code += ";\n";
|
|
|
|
return res;
|
|
}
|
|
id emit_construct(const location &loc, const type &type, const std::vector<expression> &args) override
|
|
{
|
|
#ifndef NDEBUG
|
|
for (const auto &arg : args)
|
|
assert((arg.type.is_scalar() || type.is_array()) && arg.chain.empty() && arg.base != 0);
|
|
#endif
|
|
|
|
const id res = make_id();
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
write_location(code, loc);
|
|
|
|
code += '\t';
|
|
write_type(code, type);
|
|
code += ' ' + id_to_name(res);
|
|
|
|
if (type.is_array())
|
|
code += '[' + std::to_string(type.array_length) + ']';
|
|
|
|
code += " = ";
|
|
|
|
write_type<false, false>(code, type);
|
|
|
|
if (type.is_array())
|
|
code += '[' + std::to_string(type.array_length) + ']';
|
|
|
|
code += '(';
|
|
|
|
for (size_t i = 0, num_args = args.size(); i < num_args; ++i)
|
|
{
|
|
code += id_to_name(args[i].base);
|
|
|
|
if (i < num_args - 1)
|
|
code += ", ";
|
|
}
|
|
|
|
code += ");\n";
|
|
|
|
return res;
|
|
}
|
|
|
|
void emit_if(const location &loc, id condition_value, id condition_block, id true_statement_block, id false_statement_block, unsigned int flags) override
|
|
{
|
|
assert(condition_value != 0 && condition_block != 0 && true_statement_block != 0 && false_statement_block != 0);
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
std::string &true_statement_data = _blocks.at(true_statement_block);
|
|
std::string &false_statement_data = _blocks.at(false_statement_block);
|
|
|
|
increase_indentation_level(true_statement_data);
|
|
increase_indentation_level(false_statement_data);
|
|
|
|
code += _blocks.at(condition_block);
|
|
|
|
write_location(code, loc);
|
|
|
|
if (flags != 0 && !_gles)
|
|
{
|
|
_enable_control_flow_attributes = true;
|
|
|
|
code += "#if GL_EXT_control_flow_attributes\n\t[[";
|
|
if ((flags & 0x1) == 0x1)
|
|
code += "flatten";
|
|
if ((flags & 0x3) == 0x3)
|
|
code += ", ";
|
|
if ((flags & 0x2) == 0x2)
|
|
code += "dont_flatten";
|
|
code += "]]\n#endif\n";
|
|
}
|
|
|
|
code += '\t';
|
|
code += "if (" + id_to_name(condition_value) + ")\n\t{\n";
|
|
code += true_statement_data;
|
|
code += "\t}\n";
|
|
|
|
if (!false_statement_data.empty())
|
|
{
|
|
code += "\telse\n\t{\n";
|
|
code += false_statement_data;
|
|
code += "\t}\n";
|
|
}
|
|
|
|
// Remove consumed blocks to save memory
|
|
_blocks.erase(condition_block);
|
|
_blocks.erase(true_statement_block);
|
|
_blocks.erase(false_statement_block);
|
|
}
|
|
id emit_phi(const location &loc, id condition_value, id condition_block, id true_value, id true_statement_block, id false_value, id false_statement_block, const type &type) override
|
|
{
|
|
assert(condition_value != 0 && condition_block != 0 && true_value != 0 && true_statement_block != 0 && false_value != 0 && false_statement_block != 0);
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
std::string &true_statement_data = _blocks.at(true_statement_block);
|
|
std::string &false_statement_data = _blocks.at(false_statement_block);
|
|
|
|
increase_indentation_level(true_statement_data);
|
|
increase_indentation_level(false_statement_data);
|
|
|
|
const id res = make_id();
|
|
|
|
code += _blocks.at(condition_block);
|
|
|
|
code += '\t';
|
|
write_type(code, type);
|
|
code += ' ' + id_to_name(res) + ";\n";
|
|
|
|
write_location(code, loc);
|
|
|
|
code += "\tif (" + id_to_name(condition_value) + ")\n\t{\n";
|
|
code += (true_statement_block != condition_block ? true_statement_data : std::string());
|
|
code += "\t\t" + id_to_name(res) + " = " + id_to_name(true_value) + ";\n";
|
|
code += "\t}\n\telse\n\t{\n";
|
|
code += (false_statement_block != condition_block ? false_statement_data : std::string());
|
|
code += "\t\t" + id_to_name(res) + " = " + id_to_name(false_value) + ";\n";
|
|
code += "\t}\n";
|
|
|
|
// Remove consumed blocks to save memory
|
|
_blocks.erase(condition_block);
|
|
_blocks.erase(true_statement_block);
|
|
_blocks.erase(false_statement_block);
|
|
|
|
return res;
|
|
}
|
|
void emit_loop(const location &loc, id condition_value, id prev_block, id header_block, id condition_block, id loop_block, id continue_block, unsigned int flags) override
|
|
{
|
|
assert(prev_block != 0 && header_block != 0 && loop_block != 0 && continue_block != 0);
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
std::string &loop_data = _blocks.at(loop_block);
|
|
std::string &continue_data = _blocks.at(continue_block);
|
|
|
|
increase_indentation_level(loop_data);
|
|
increase_indentation_level(loop_data);
|
|
increase_indentation_level(continue_data);
|
|
|
|
code += _blocks.at(prev_block);
|
|
|
|
std::string attributes;
|
|
if (flags != 0 && !_gles)
|
|
{
|
|
_enable_control_flow_attributes = true;
|
|
|
|
attributes += "#if GL_EXT_control_flow_attributes\n\t[[";
|
|
if ((flags & 0x1) == 0x1)
|
|
attributes += "unroll";
|
|
if ((flags & 0x3) == 0x3)
|
|
attributes += ", ";
|
|
if ((flags & 0x2) == 0x2)
|
|
attributes += "dont_unroll";
|
|
attributes += "]]\n#endif\n";
|
|
}
|
|
|
|
// Condition value can be missing in infinite loop constructs like "for (;;)"
|
|
std::string condition_name = condition_value != 0 ? id_to_name(condition_value) : "true";
|
|
|
|
if (condition_block == 0)
|
|
{
|
|
// Convert the last SSA variable initializer to an assignment statement
|
|
auto pos_assign = continue_data.rfind(condition_name);
|
|
auto pos_prev_assign = continue_data.rfind('\t', pos_assign);
|
|
continue_data.erase(pos_prev_assign + 1, pos_assign - pos_prev_assign - 1);
|
|
|
|
// We need to add the continue block to all "continue" statements as well
|
|
const std::string continue_id = "__CONTINUE__" + std::to_string(continue_block);
|
|
for (size_t offset = 0; (offset = loop_data.find(continue_id, offset)) != std::string::npos; offset += continue_data.size())
|
|
loop_data.replace(offset, continue_id.size(), continue_data);
|
|
|
|
code += "\tbool " + condition_name + ";\n";
|
|
|
|
write_location(code, loc);
|
|
|
|
code += attributes;
|
|
code += '\t';
|
|
code += "do\n\t{\n\t\t{\n";
|
|
code += loop_data; // Encapsulate loop body into another scope, so not to confuse any local variables with the current iteration variable accessed in the continue block below
|
|
code += "\t\t}\n";
|
|
code += continue_data;
|
|
code += "\t}\n\twhile (" + condition_name + ");\n";
|
|
}
|
|
else
|
|
{
|
|
std::string &condition_data = _blocks.at(condition_block);
|
|
|
|
// If the condition data is just a single line, then it is a simple expression, which we can just put into the loop condition as-is
|
|
if (std::count(condition_data.begin(), condition_data.end(), '\n') == 1)
|
|
{
|
|
// Convert SSA variable initializer back to a condition expression
|
|
auto pos_assign = condition_data.find('=');
|
|
condition_data.erase(0, pos_assign + 2);
|
|
auto pos_semicolon = condition_data.rfind(';');
|
|
condition_data.erase(pos_semicolon);
|
|
|
|
condition_name = std::move(condition_data);
|
|
assert(condition_data.empty());
|
|
}
|
|
else
|
|
{
|
|
code += condition_data;
|
|
|
|
increase_indentation_level(condition_data);
|
|
|
|
// Convert the last SSA variable initializer to an assignment statement
|
|
auto pos_assign = condition_data.rfind(condition_name);
|
|
auto pos_prev_assign = condition_data.rfind('\t', pos_assign);
|
|
condition_data.erase(pos_prev_assign + 1, pos_assign - pos_prev_assign - 1);
|
|
}
|
|
|
|
const std::string continue_id = "__CONTINUE__" + std::to_string(continue_block);
|
|
for (size_t offset = 0; (offset = loop_data.find(continue_id, offset)) != std::string::npos; offset += continue_data.size())
|
|
loop_data.replace(offset, continue_id.size(), continue_data + condition_data);
|
|
|
|
code += attributes;
|
|
code += '\t';
|
|
code += "while (" + condition_name + ")\n\t{\n\t\t{\n";
|
|
code += loop_data;
|
|
code += "\t\t}\n";
|
|
code += continue_data;
|
|
code += condition_data;
|
|
code += "\t}\n";
|
|
|
|
_blocks.erase(condition_block);
|
|
}
|
|
|
|
// Remove consumed blocks to save memory
|
|
_blocks.erase(prev_block);
|
|
_blocks.erase(header_block);
|
|
_blocks.erase(loop_block);
|
|
_blocks.erase(continue_block);
|
|
}
|
|
void emit_switch(const location &loc, id selector_value, id selector_block, id default_label, id default_block, const std::vector<id> &case_literal_and_labels, const std::vector<id> &case_blocks, unsigned int) override
|
|
{
|
|
assert(selector_value != 0 && selector_block != 0 && default_label != 0 && default_block != 0);
|
|
assert(case_blocks.size() == case_literal_and_labels.size() / 2);
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
code += _blocks.at(selector_block);
|
|
|
|
write_location(code, loc);
|
|
|
|
code += "\tswitch (" + id_to_name(selector_value) + ")\n\t{\n";
|
|
|
|
std::vector<id> labels = case_literal_and_labels;
|
|
for (size_t i = 0; i < labels.size(); i += 2)
|
|
{
|
|
if (labels[i + 1] == 0)
|
|
continue; // Happens if a case was already handled, see below
|
|
|
|
code += "\tcase " + std::to_string(labels[i]) + ": ";
|
|
|
|
if (labels[i + 1] == default_label)
|
|
{
|
|
code += "default: ";
|
|
default_label = 0;
|
|
}
|
|
else
|
|
{
|
|
for (size_t k = i + 2; k < labels.size(); k += 2)
|
|
{
|
|
if (labels[k + 1] == 0 || labels[k + 1] != labels[i + 1])
|
|
continue;
|
|
|
|
code += "case " + std::to_string(labels[k]) + ": ";
|
|
labels[k + 1] = 0;
|
|
}
|
|
}
|
|
|
|
assert(case_blocks[i / 2] != 0);
|
|
std::string &case_data = _blocks.at(case_blocks[i / 2]);
|
|
|
|
increase_indentation_level(case_data);
|
|
|
|
code += "{\n";
|
|
code += case_data;
|
|
code += "\t}\n";
|
|
}
|
|
|
|
|
|
if (default_label != 0 && default_block != _current_block)
|
|
{
|
|
std::string &default_data = _blocks.at(default_block);
|
|
|
|
increase_indentation_level(default_data);
|
|
|
|
code += "\tdefault: {\n";
|
|
code += default_data;
|
|
code += "\t}\n";
|
|
|
|
_blocks.erase(default_block);
|
|
}
|
|
|
|
code += "\t}\n";
|
|
|
|
// Remove consumed blocks to save memory
|
|
_blocks.erase(selector_block);
|
|
for (const id case_block : case_blocks)
|
|
_blocks.erase(case_block);
|
|
}
|
|
|
|
id create_block() override
|
|
{
|
|
const id res = make_id();
|
|
|
|
std::string &block = _blocks.emplace(res, std::string()).first->second;
|
|
// Reserve a decently big enough memory block to avoid frequent reallocations
|
|
block.reserve(4096);
|
|
|
|
return res;
|
|
}
|
|
id set_block(id id) override
|
|
{
|
|
_last_block = _current_block;
|
|
_current_block = id;
|
|
|
|
return _last_block;
|
|
}
|
|
void enter_block(id id) override
|
|
{
|
|
_current_block = id;
|
|
}
|
|
id leave_block_and_kill() override
|
|
{
|
|
if (!is_in_block())
|
|
return 0;
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
code += "\tdiscard;\n";
|
|
|
|
const auto &return_type = _functions.back()->return_type;
|
|
if (!return_type.is_void())
|
|
{
|
|
// Add a return statement to exit functions in case discard is the last control flow statement
|
|
code += "\treturn ";
|
|
write_constant(code, return_type, constant());
|
|
code += ";\n";
|
|
}
|
|
|
|
return set_block(0);
|
|
}
|
|
id leave_block_and_return(id value) override
|
|
{
|
|
if (!is_in_block())
|
|
return 0;
|
|
|
|
// Skip implicit return statement
|
|
if (!_functions.back()->return_type.is_void() && value == 0)
|
|
return set_block(0);
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
code += "\treturn";
|
|
|
|
if (value != 0)
|
|
code += ' ' + id_to_name(value);
|
|
|
|
code += ";\n";
|
|
|
|
return set_block(0);
|
|
}
|
|
id leave_block_and_switch(id, id) override
|
|
{
|
|
if (!is_in_block())
|
|
return _last_block;
|
|
|
|
return set_block(0);
|
|
}
|
|
id leave_block_and_branch(id target, unsigned int loop_flow) override
|
|
{
|
|
if (!is_in_block())
|
|
return _last_block;
|
|
|
|
std::string &code = _blocks.at(_current_block);
|
|
|
|
switch (loop_flow)
|
|
{
|
|
case 1:
|
|
code += "\tbreak;\n";
|
|
break;
|
|
case 2: // Keep track of continue target block, so we can insert its code here later
|
|
code += "__CONTINUE__" + std::to_string(target) + "\tcontinue;\n";
|
|
break;
|
|
}
|
|
|
|
return set_block(0);
|
|
}
|
|
id leave_block_and_branch_conditional(id, id, id) override
|
|
{
|
|
if (!is_in_block())
|
|
return _last_block;
|
|
|
|
return set_block(0);
|
|
}
|
|
void leave_function() override
|
|
{
|
|
assert(_last_block != 0);
|
|
|
|
_blocks.at(0) += "{\n" + _blocks.at(_last_block) + "}\n";
|
|
}
|
|
};
|
|
} // namespace
|
|
|
|
codegen *reshadefx::create_codegen_glsl(bool gles, bool vulkan_semantics, bool debug_info, bool uniforms_to_spec_constants, bool enable_16bit_types, bool flip_vert_y)
|
|
{
|
|
return new codegen_glsl(gles, vulkan_semantics, debug_info, uniforms_to_spec_constants, enable_16bit_types, flip_vert_y);
|
|
}
|