wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2024-11-21 16:46:41 -08:00
Code Issues Packages Projects Releases Wiki Activity
babbf11d52
vkd3d/libs/vkd3d-shader/glsl.c
Henri Verbeet babbf11d52 vkd3d-shader/glsl: Implement VKD3DSIH_ISHR.
2024-10-02 22:30:58 +02:00

1303 lines
48 KiB
C
Raw Blame History

/*
* Copyright 2021 Atharva Nimbalkar
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "vkd3d_shader_private.h"
struct glsl_src
{
struct vkd3d_string_buffer *str;
};
struct glsl_dst
{
const struct vkd3d_shader_dst_param *vsir;
struct vkd3d_string_buffer *register_name;
struct vkd3d_string_buffer *mask;
};
struct vkd3d_glsl_generator
{
struct vsir_program *program;
struct vkd3d_string_buffer_cache string_buffers;
struct vkd3d_string_buffer *buffer;
struct vkd3d_shader_location location;
struct vkd3d_shader_message_context *message_context;
unsigned int indent;
const char *prefix;
bool failed;
struct shader_limits
{
unsigned int input_count;
unsigned int output_count;
} limits;
bool interstage_input;
bool interstage_output;
const struct vkd3d_shader_interface_info *interface_info;
const struct vkd3d_shader_descriptor_offset_info *offset_info;
const struct vkd3d_shader_scan_descriptor_info1 *descriptor_info;
};
static void VKD3D_PRINTF_FUNC(3, 4) vkd3d_glsl_compiler_error(
struct vkd3d_glsl_generator *generator,
enum vkd3d_shader_error error, const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
vkd3d_shader_verror(generator->message_context, &generator->location, error, fmt, args);
va_end(args);
generator->failed = true;
}
static const char *shader_glsl_get_prefix(enum vkd3d_shader_type type)
{
switch (type)
{
case VKD3D_SHADER_TYPE_VERTEX:
return "vs";
case VKD3D_SHADER_TYPE_HULL:
return "hs";
case VKD3D_SHADER_TYPE_DOMAIN:
return "ds";
case VKD3D_SHADER_TYPE_GEOMETRY:
return "gs";
case VKD3D_SHADER_TYPE_PIXEL:
return "ps";
case VKD3D_SHADER_TYPE_COMPUTE:
return "cs";
default:
return NULL;
}
}
static void shader_glsl_print_indent(struct vkd3d_string_buffer *buffer, unsigned int indent)
{
vkd3d_string_buffer_printf(buffer, "%*s", 4 * indent, "");
}
static void shader_glsl_print_register_name(struct vkd3d_string_buffer *buffer,
struct vkd3d_glsl_generator *gen, const struct vkd3d_shader_register *reg)
{
switch (reg->type)
{
case VKD3DSPR_TEMP:
vkd3d_string_buffer_printf(buffer, "r[%u]", reg->idx[0].offset);
break;
case VKD3DSPR_INPUT:
if (reg->idx_count != 1)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled input register index count %u.", reg->idx_count);
vkd3d_string_buffer_printf(buffer, "<unhandled register %#x>", reg->type);
break;
}
if (reg->idx[0].rel_addr)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled input register indirect addressing.");
vkd3d_string_buffer_printf(buffer, "<unhandled register %#x>", reg->type);
break;
}
vkd3d_string_buffer_printf(buffer, "%s_in[%u]", gen->prefix, reg->idx[0].offset);
break;
case VKD3DSPR_OUTPUT:
if (reg->idx_count != 1)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled output register index count %u.", reg->idx_count);
vkd3d_string_buffer_printf(buffer, "<unhandled register %#x>", reg->type);
break;
}
if (reg->idx[0].rel_addr)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled output register indirect addressing.");
vkd3d_string_buffer_printf(buffer, "<unhandled register %#x>", reg->type);
break;
}
vkd3d_string_buffer_printf(buffer, "%s_out[%u]", gen->prefix, reg->idx[0].offset);
break;
case VKD3DSPR_DEPTHOUT:
if (gen->program->shader_version.type != VKD3D_SHADER_TYPE_PIXEL)
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled depth output in shader type #%x.",
gen->program->shader_version.type);
vkd3d_string_buffer_printf(buffer, "gl_FragDepth");
break;
case VKD3DSPR_IMMCONST:
switch (reg->dimension)
{
case VSIR_DIMENSION_SCALAR:
vkd3d_string_buffer_printf(buffer, "%#xu", reg->u.immconst_u32[0]);
break;
case VSIR_DIMENSION_VEC4:
vkd3d_string_buffer_printf(buffer, "uvec4(%#xu, %#xu, %#xu, %#xu)",
reg->u.immconst_u32[0], reg->u.immconst_u32[1],
reg->u.immconst_u32[2], reg->u.immconst_u32[3]);
break;
default:
vkd3d_string_buffer_printf(buffer, "<unhandled_dimension %#x>", reg->dimension);
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled dimension %#x.", reg->dimension);
break;
}
break;
case VKD3DSPR_CONSTBUFFER:
if (reg->idx_count != 3)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled constant buffer register index count %u.", reg->idx_count);
vkd3d_string_buffer_printf(buffer, "<unhandled register %#x>", reg->type);
break;
}
if (reg->idx[0].rel_addr || reg->idx[2].rel_addr)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled constant buffer register indirect addressing.");
vkd3d_string_buffer_printf(buffer, "<unhandled register %#x>", reg->type);
break;
}
vkd3d_string_buffer_printf(buffer, "%s_cb_%u[%u]",
gen->prefix, reg->idx[0].offset, reg->idx[2].offset);
break;
default:
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled register type %#x.", reg->type);
vkd3d_string_buffer_printf(buffer, "<unrecognised register %#x>", reg->type);
break;
}
}
static void shader_glsl_print_swizzle(struct vkd3d_string_buffer *buffer, uint32_t swizzle, uint32_t mask)
{
const char swizzle_chars[] = "xyzw";
unsigned int i;
vkd3d_string_buffer_printf(buffer, ".");
for (i = 0; i < VKD3D_VEC4_SIZE; ++i)
{
if (mask & (VKD3DSP_WRITEMASK_0 << i))
vkd3d_string_buffer_printf(buffer, "%c", swizzle_chars[vsir_swizzle_get_component(swizzle, i)]);
}
}
static void shader_glsl_print_write_mask(struct vkd3d_string_buffer *buffer, uint32_t write_mask)
{
vkd3d_string_buffer_printf(buffer, ".");
if (write_mask & VKD3DSP_WRITEMASK_0)
vkd3d_string_buffer_printf(buffer, "x");
if (write_mask & VKD3DSP_WRITEMASK_1)
vkd3d_string_buffer_printf(buffer, "y");
if (write_mask & VKD3DSP_WRITEMASK_2)
vkd3d_string_buffer_printf(buffer, "z");
if (write_mask & VKD3DSP_WRITEMASK_3)
vkd3d_string_buffer_printf(buffer, "w");
}
static void glsl_src_cleanup(struct glsl_src *src, struct vkd3d_string_buffer_cache *cache)
{
vkd3d_string_buffer_release(cache, src->str);
}
static void shader_glsl_print_bitcast(struct vkd3d_string_buffer *dst, struct vkd3d_glsl_generator *gen,
const char *src, enum vkd3d_data_type dst_data_type, enum vkd3d_data_type src_data_type, unsigned int size)
{
if (dst_data_type == VKD3D_DATA_UNORM || dst_data_type == VKD3D_DATA_SNORM)
dst_data_type = VKD3D_DATA_FLOAT;
if (src_data_type == VKD3D_DATA_UNORM || src_data_type == VKD3D_DATA_SNORM)
src_data_type = VKD3D_DATA_FLOAT;
if (dst_data_type == src_data_type)
{
vkd3d_string_buffer_printf(dst, "%s", src);
return;
}
if (src_data_type == VKD3D_DATA_FLOAT)
{
switch (dst_data_type)
{
case VKD3D_DATA_INT:
vkd3d_string_buffer_printf(dst, "floatBitsToInt(%s)", src);
return;
case VKD3D_DATA_UINT:
vkd3d_string_buffer_printf(dst, "floatBitsToUint(%s)", src);
return;
default:
break;
}
}
if (src_data_type == VKD3D_DATA_UINT)
{
switch (dst_data_type)
{
case VKD3D_DATA_FLOAT:
vkd3d_string_buffer_printf(dst, "uintBitsToFloat(%s)", src);
return;
case VKD3D_DATA_INT:
if (size == 1)
vkd3d_string_buffer_printf(dst, "int(%s)", src);
else
vkd3d_string_buffer_printf(dst, "ivec%u(%s)", size, src);
return;
default:
break;
}
}
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled bitcast from %#x to %#x.",
src_data_type, dst_data_type);
vkd3d_string_buffer_printf(dst, "%s", src);
}
static void glsl_src_init(struct glsl_src *glsl_src, struct vkd3d_glsl_generator *gen,
const struct vkd3d_shader_src_param *vsir_src, uint32_t mask)
{
const struct vkd3d_shader_register *reg = &vsir_src->reg;
struct vkd3d_string_buffer *register_name, *str;
enum vkd3d_data_type src_data_type;
unsigned int size;
glsl_src->str = vkd3d_string_buffer_get(&gen->string_buffers);
register_name = vkd3d_string_buffer_get(&gen->string_buffers);
if (reg->non_uniform)
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled 'non-uniform' modifier.");
if (reg->type == VKD3DSPR_IMMCONST)
src_data_type = VKD3D_DATA_UINT;
else
src_data_type = VKD3D_DATA_FLOAT;
shader_glsl_print_register_name(register_name, gen, reg);
if (!vsir_src->modifiers)
str = glsl_src->str;
else
str = vkd3d_string_buffer_get(&gen->string_buffers);
size = reg->dimension == VSIR_DIMENSION_VEC4 ? 4 : 1;
shader_glsl_print_bitcast(str, gen, register_name->buffer, reg->data_type, src_data_type, size);
if (reg->dimension == VSIR_DIMENSION_VEC4)
shader_glsl_print_swizzle(str, vsir_src->swizzle, mask);
switch (vsir_src->modifiers)
{
case VKD3DSPSM_NONE:
break;
case VKD3DSPSM_NEG:
vkd3d_string_buffer_printf(glsl_src->str, "-%s", str->buffer);
break;
case VKD3DSPSM_ABS:
vkd3d_string_buffer_printf(glsl_src->str, "abs(%s)", str->buffer);
break;
default:
vkd3d_string_buffer_printf(glsl_src->str, "<unhandled modifier %#x>(%s)",
vsir_src->modifiers, str->buffer);
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled source modifier(s) %#x.", vsir_src->modifiers);
break;
}
if (str != glsl_src->str)
vkd3d_string_buffer_release(&gen->string_buffers, str);
vkd3d_string_buffer_release(&gen->string_buffers, register_name);
}
static void glsl_dst_cleanup(struct glsl_dst *dst, struct vkd3d_string_buffer_cache *cache)
{
vkd3d_string_buffer_release(cache, dst->mask);
vkd3d_string_buffer_release(cache, dst->register_name);
}
static uint32_t glsl_dst_init(struct glsl_dst *glsl_dst, struct vkd3d_glsl_generator *gen,
const struct vkd3d_shader_instruction *ins, const struct vkd3d_shader_dst_param *vsir_dst)
{
uint32_t write_mask = vsir_dst->write_mask;
if (ins->flags & VKD3DSI_PRECISE_XYZW)
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled 'precise' modifier.");
if (vsir_dst->reg.non_uniform)
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled 'non-uniform' modifier.");
glsl_dst->vsir = vsir_dst;
glsl_dst->register_name = vkd3d_string_buffer_get(&gen->string_buffers);
glsl_dst->mask = vkd3d_string_buffer_get(&gen->string_buffers);
shader_glsl_print_register_name(glsl_dst->register_name, gen, &vsir_dst->reg);
shader_glsl_print_write_mask(glsl_dst->mask, write_mask);
return write_mask;
}
static void VKD3D_PRINTF_FUNC(3, 4) shader_glsl_print_assignment(
struct vkd3d_glsl_generator *gen, struct glsl_dst *dst, const char *format, ...)
{
const struct vkd3d_shader_register *dst_reg = &dst->vsir->reg;
struct vkd3d_string_buffer *buffer = gen->buffer;
uint32_t modifiers = dst->vsir->modifiers;
bool close = true;
va_list args;
if (dst->vsir->shift)
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled destination shift %#x.", dst->vsir->shift);
if (modifiers & ~VKD3DSPDM_SATURATE)
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled destination modifier(s) %#x.", modifiers);
shader_glsl_print_indent(buffer, gen->indent);
vkd3d_string_buffer_printf(buffer, "%s%s = ", dst->register_name->buffer, dst->mask->buffer);
if (modifiers & VKD3DSPDM_SATURATE)
vkd3d_string_buffer_printf(buffer, "clamp(");
switch (dst_reg->data_type)
{
default:
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled destination register data type %#x.", dst_reg->data_type);
/* fall through */
case VKD3D_DATA_FLOAT:
close = false;
break;
case VKD3D_DATA_INT:
vkd3d_string_buffer_printf(buffer, "intBitsToFloat(");
break;
case VKD3D_DATA_UINT:
vkd3d_string_buffer_printf(buffer, "uintBitsToFloat(");
break;
}
va_start(args, format);
vkd3d_string_buffer_vprintf(buffer, format, args);
va_end(args);
if (close)
vkd3d_string_buffer_printf(buffer, ")");
if (modifiers & VKD3DSPDM_SATURATE)
vkd3d_string_buffer_printf(buffer, ", 0.0, 1.0)");
vkd3d_string_buffer_printf(buffer, ";\n");
}
static void shader_glsl_unhandled(struct vkd3d_glsl_generator *gen, const struct vkd3d_shader_instruction *ins)
{
shader_glsl_print_indent(gen->buffer, gen->indent);
vkd3d_string_buffer_printf(gen->buffer, "/* <unhandled instruction %#x> */\n", ins->opcode);
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled instruction %#x.", ins->opcode);
}
static void shader_glsl_binop(struct vkd3d_glsl_generator *gen,
const struct vkd3d_shader_instruction *ins, const char *op)
{
struct glsl_src src[2];
struct glsl_dst dst;
uint32_t mask;
mask = glsl_dst_init(&dst, gen, ins, &ins->dst[0]);
glsl_src_init(&src[0], gen, &ins->src[0], mask);
glsl_src_init(&src[1], gen, &ins->src[1], mask);
shader_glsl_print_assignment(gen, &dst, "%s %s %s", src[0].str->buffer, op, src[1].str->buffer);
glsl_src_cleanup(&src[1], &gen->string_buffers);
glsl_src_cleanup(&src[0], &gen->string_buffers);
glsl_dst_cleanup(&dst, &gen->string_buffers);
}
static void shader_glsl_dot(struct vkd3d_glsl_generator *gen,
const struct vkd3d_shader_instruction *ins, uint32_t src_mask)
{
unsigned int component_count;
struct glsl_src src[2];
struct glsl_dst dst;
uint32_t dst_mask;
dst_mask = glsl_dst_init(&dst, gen, ins, &ins->dst[0]);
glsl_src_init(&src[0], gen, &ins->src[0], src_mask);
glsl_src_init(&src[1], gen, &ins->src[1], src_mask);
if ((component_count = vsir_write_mask_component_count(dst_mask)) > 1)
shader_glsl_print_assignment(gen, &dst, "vec%d(dot(%s, %s))",
component_count, src[0].str->buffer, src[1].str->buffer);
else
shader_glsl_print_assignment(gen, &dst, "dot(%s, %s)",
src[0].str->buffer, src[1].str->buffer);
glsl_src_cleanup(&src[1], &gen->string_buffers);
glsl_src_cleanup(&src[0], &gen->string_buffers);
glsl_dst_cleanup(&dst, &gen->string_buffers);
}
static void shader_glsl_intrinsic(struct vkd3d_glsl_generator *gen,
const struct vkd3d_shader_instruction *ins, const char *op)
{
struct vkd3d_string_buffer *args;
struct glsl_src src;
struct glsl_dst dst;
unsigned int i;
uint32_t mask;
mask = glsl_dst_init(&dst, gen, ins, &ins->dst[0]);
args = vkd3d_string_buffer_get(&gen->string_buffers);
for (i = 0; i < ins->src_count; ++i)
{
glsl_src_init(&src, gen, &ins->src[i], mask);
vkd3d_string_buffer_printf(args, "%s%s", i ? ", " : "", src.str->buffer);
glsl_src_cleanup(&src, &gen->string_buffers);
}
shader_glsl_print_assignment(gen, &dst, "%s(%s)", op, args->buffer);
vkd3d_string_buffer_release(&gen->string_buffers, args);
glsl_dst_cleanup(&dst, &gen->string_buffers);
}
static void shader_glsl_relop(struct vkd3d_glsl_generator *gen,
const struct vkd3d_shader_instruction *ins, const char *scalar_op, const char *vector_op)
{
unsigned int mask_size;
struct glsl_src src[2];
struct glsl_dst dst;
uint32_t mask;
mask = glsl_dst_init(&dst, gen, ins, &ins->dst[0]);
glsl_src_init(&src[0], gen, &ins->src[0], mask);
glsl_src_init(&src[1], gen, &ins->src[1], mask);
if ((mask_size = vsir_write_mask_component_count(mask)) > 1)
shader_glsl_print_assignment(gen, &dst, "uvec%u(%s(%s, %s)) * 0xffffffffu",
mask_size, vector_op, src[0].str->buffer, src[1].str->buffer);
else
shader_glsl_print_assignment(gen, &dst, "%s %s %s ? 0xffffffffu : 0u",
src[0].str->buffer, scalar_op, src[1].str->buffer);
glsl_src_cleanup(&src[1], &gen->string_buffers);
glsl_src_cleanup(&src[0], &gen->string_buffers);
glsl_dst_cleanup(&dst, &gen->string_buffers);
}
static void shader_glsl_cast(struct vkd3d_glsl_generator *gen, const struct vkd3d_shader_instruction *ins,
const char *scalar_constructor, const char *vector_constructor)
{
unsigned int component_count;
struct glsl_src src;
struct glsl_dst dst;
uint32_t mask;
mask = glsl_dst_init(&dst, gen, ins, &ins->dst[0]);
glsl_src_init(&src, gen, &ins->src[0], mask);
if ((component_count = vsir_write_mask_component_count(mask)) > 1)
shader_glsl_print_assignment(gen, &dst, "%s%u(%s)",
vector_constructor, component_count, src.str->buffer);
else
shader_glsl_print_assignment(gen, &dst, "%s(%s)",
scalar_constructor, src.str->buffer);
glsl_src_cleanup(&src, &gen->string_buffers);
glsl_dst_cleanup(&dst, &gen->string_buffers);
}
static void shader_glsl_if(struct vkd3d_glsl_generator *gen, const struct vkd3d_shader_instruction *ins)
{
const char *condition;
struct glsl_src src;
glsl_src_init(&src, gen, &ins->src[0], VKD3DSP_WRITEMASK_0);
shader_glsl_print_indent(gen->buffer, gen->indent);
condition = ins->flags == VKD3D_SHADER_CONDITIONAL_OP_NZ ? "bool" : "!bool";
vkd3d_string_buffer_printf(gen->buffer, "if (%s(%s))\n", condition, src.str->buffer);
glsl_src_cleanup(&src, &gen->string_buffers);
shader_glsl_print_indent(gen->buffer, gen->indent);
vkd3d_string_buffer_printf(gen->buffer, "{\n");
++gen->indent;
}
static void shader_glsl_else(struct vkd3d_glsl_generator *gen, const struct vkd3d_shader_instruction *ins)
{
unsigned int i = 4 * (gen->indent - 1);
vkd3d_string_buffer_printf(gen->buffer, "%*s}\n%*selse\n%*s{\n", i, "", i, "", i, "");
}
static void shader_glsl_endif(struct vkd3d_glsl_generator *gen)
{
--gen->indent;
shader_glsl_print_indent(gen->buffer, gen->indent);
vkd3d_string_buffer_printf(gen->buffer, "}\n");
}
static void shader_glsl_unary_op(struct vkd3d_glsl_generator *gen,
const struct vkd3d_shader_instruction *ins, const char *op)
{
struct glsl_src src;
struct glsl_dst dst;
uint32_t mask;
mask = glsl_dst_init(&dst, gen, ins, &ins->dst[0]);
glsl_src_init(&src, gen, &ins->src[0], mask);
shader_glsl_print_assignment(gen, &dst, "%s%s", op, src.str->buffer);
glsl_src_cleanup(&src, &gen->string_buffers);
glsl_dst_cleanup(&dst, &gen->string_buffers);
}
static void shader_glsl_mov(struct vkd3d_glsl_generator *gen, const struct vkd3d_shader_instruction *ins)
{
struct glsl_src src;
struct glsl_dst dst;
uint32_t mask;
mask = glsl_dst_init(&dst, gen, ins, &ins->dst[0]);
glsl_src_init(&src, gen, &ins->src[0], mask);
shader_glsl_print_assignment(gen, &dst, "%s", src.str->buffer);
glsl_src_cleanup(&src, &gen->string_buffers);
glsl_dst_cleanup(&dst, &gen->string_buffers);
}
static void shader_glsl_movc(struct vkd3d_glsl_generator *gen, const struct vkd3d_shader_instruction *ins)
{
unsigned int component_count;
struct glsl_src src[3];
struct glsl_dst dst;
uint32_t mask;
mask = glsl_dst_init(&dst, gen, ins, &ins->dst[0]);
glsl_src_init(&src[0], gen, &ins->src[0], mask);
glsl_src_init(&src[1], gen, &ins->src[1], mask);
glsl_src_init(&src[2], gen, &ins->src[2], mask);
if ((component_count = vsir_write_mask_component_count(mask)) > 1)
shader_glsl_print_assignment(gen, &dst, "mix(%s, %s, bvec%u(%s))",
src[2].str->buffer, src[1].str->buffer, component_count, src[0].str->buffer);
else
shader_glsl_print_assignment(gen, &dst, "mix(%s, %s, bool(%s))",
src[2].str->buffer, src[1].str->buffer, src[0].str->buffer);
glsl_src_cleanup(&src[2], &gen->string_buffers);
glsl_src_cleanup(&src[1], &gen->string_buffers);
glsl_src_cleanup(&src[0], &gen->string_buffers);
glsl_dst_cleanup(&dst, &gen->string_buffers);
}
static void shader_glsl_print_sysval_name(struct vkd3d_string_buffer *buffer, struct vkd3d_glsl_generator *gen,
enum vkd3d_shader_sysval_semantic sysval, unsigned int idx)
{
const struct vkd3d_shader_version *version = &gen->program->shader_version;
switch (sysval)
{
case VKD3D_SHADER_SV_POSITION:
if (version->type == VKD3D_SHADER_TYPE_PIXEL || version->type == VKD3D_SHADER_TYPE_COMPUTE)
{
vkd3d_string_buffer_printf(buffer, "<unhandled sysval %#x>", sysval);
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled system value %#x.", sysval);
}
else
{
vkd3d_string_buffer_printf(buffer, "gl_Position");
if (idx)
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled SV_POSITION index %u.", idx);
}
break;
case VKD3D_SHADER_SV_IS_FRONT_FACE:
if (version->type != VKD3D_SHADER_TYPE_PIXEL)
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled SV_IS_FRONT_FACE in shader type #%x.", version->type);
vkd3d_string_buffer_printf(buffer,
"uintBitsToFloat(uvec4(gl_FrontFacing ? 0xffffffffu : 0u, 0u, 0u, 0u))");
break;
case VKD3D_SHADER_SV_TARGET:
if (version->type != VKD3D_SHADER_TYPE_PIXEL)
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled SV_TARGET in shader type #%x.", version->type);
vkd3d_string_buffer_printf(buffer, "shader_out_%u", idx);
break;
default:
vkd3d_string_buffer_printf(buffer, "<unhandled sysval %#x>", sysval);
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled system value %#x.", sysval);
break;
}
}
static void shader_glsl_shader_prologue(struct vkd3d_glsl_generator *gen)
{
const struct shader_signature *signature = &gen->program->input_signature;
struct vkd3d_string_buffer *buffer = gen->buffer;
const struct signature_element *e;
unsigned int i;
for (i = 0; i < signature->element_count; ++i)
{
e = &signature->elements[i];
if (e->target_location == SIGNATURE_TARGET_LOCATION_UNUSED)
continue;
shader_glsl_print_indent(buffer, gen->indent);
vkd3d_string_buffer_printf(buffer, "%s_in[%u]", gen->prefix, e->register_index);
shader_glsl_print_write_mask(buffer, e->mask);
if (e->sysval_semantic == VKD3D_SHADER_SV_NONE)
{
if (gen->interstage_input)
{
vkd3d_string_buffer_printf(buffer, " = shader_in.reg_%u", e->target_location);
if (e->target_location >= gen->limits.input_count)
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Input element %u specifies target location %u, "
"but only %u inputs are supported.",
i, e->target_location, gen->limits.input_count);
}
else
{
vkd3d_string_buffer_printf(buffer, " = shader_in_%u", i);
}
}
else
{
vkd3d_string_buffer_printf(buffer, " = ");
shader_glsl_print_sysval_name(buffer, gen, e->sysval_semantic, e->semantic_index);
}
shader_glsl_print_write_mask(buffer, e->mask);
vkd3d_string_buffer_printf(buffer, ";\n");
}
}
static void shader_glsl_shader_epilogue(struct vkd3d_glsl_generator *gen)
{
const struct shader_signature *signature = &gen->program->output_signature;
struct vkd3d_string_buffer *buffer = gen->buffer;
const struct signature_element *e;
unsigned int i;
for (i = 0; i < signature->element_count; ++i)
{
e = &signature->elements[i];
if (e->target_location == SIGNATURE_TARGET_LOCATION_UNUSED)
continue;
shader_glsl_print_indent(buffer, gen->indent);
if (e->sysval_semantic == VKD3D_SHADER_SV_NONE)
{
if (gen->interstage_output)
{
vkd3d_string_buffer_printf(buffer, "shader_out.reg_%u", e->target_location);
if (e->target_location >= gen->limits.output_count)
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Output element %u specifies target location %u, "
"but only %u outputs are supported.",
i, e->target_location, gen->limits.output_count);
}
else
{
vkd3d_string_buffer_printf(buffer, "<unhandled output %u>", e->target_location);
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled output.");
}
}
else
{
shader_glsl_print_sysval_name(buffer, gen, e->sysval_semantic, e->semantic_index);
}
shader_glsl_print_write_mask(buffer, e->mask);
vkd3d_string_buffer_printf(buffer, " = %s_out[%u]", gen->prefix, e->register_index);
shader_glsl_print_write_mask(buffer, e->mask);
vkd3d_string_buffer_printf(buffer, ";\n");
}
}
static void shader_glsl_ret(struct vkd3d_glsl_generator *gen, const struct vkd3d_shader_instruction *ins)
{
const struct vkd3d_shader_version *version = &gen->program->shader_version;
if (version->major >= 4)
{
shader_glsl_shader_epilogue(gen);
shader_glsl_print_indent(gen->buffer, gen->indent);
vkd3d_string_buffer_printf(gen->buffer, "return;\n");
}
}
static void vkd3d_glsl_handle_instruction(struct vkd3d_glsl_generator *gen,
const struct vkd3d_shader_instruction *ins)
{
gen->location = ins->location;
switch (ins->opcode)
{
case VKD3DSIH_ADD:
shader_glsl_binop(gen, ins, "+");
break;
case VKD3DSIH_AND:
shader_glsl_binop(gen, ins, "&");
break;
case VKD3DSIH_DCL_INPUT:
case VKD3DSIH_DCL_INPUT_PS:
case VKD3DSIH_DCL_INPUT_PS_SIV:
case VKD3DSIH_DCL_OUTPUT:
case VKD3DSIH_DCL_OUTPUT_SIV:
case VKD3DSIH_NOP:
break;
case VKD3DSIH_DIV:
shader_glsl_binop(gen, ins, "/");
break;
case VKD3DSIH_DP2:
shader_glsl_dot(gen, ins, vkd3d_write_mask_from_component_count(2));
break;
case VKD3DSIH_DP3:
shader_glsl_dot(gen, ins, vkd3d_write_mask_from_component_count(3));
break;
case VKD3DSIH_DP4:
shader_glsl_dot(gen, ins, VKD3DSP_WRITEMASK_ALL);
break;
case VKD3DSIH_ELSE:
shader_glsl_else(gen, ins);
break;
case VKD3DSIH_ENDIF:
shader_glsl_endif(gen);
break;
case VKD3DSIH_IEQ:
shader_glsl_relop(gen, ins, "==", "equal");
break;
case VKD3DSIH_EXP:
shader_glsl_intrinsic(gen, ins, "exp2");
break;
case VKD3DSIH_FRC:
shader_glsl_intrinsic(gen, ins, "fract");
break;
case VKD3DSIH_FTOI:
shader_glsl_cast(gen, ins, "int", "ivec");
break;
case VKD3DSIH_FTOU:
shader_glsl_cast(gen, ins, "uint", "uvec");
break;
case VKD3DSIH_GEO:
shader_glsl_relop(gen, ins, ">=", "greaterThanEqual");
break;
case VKD3DSIH_IF:
shader_glsl_if(gen, ins);
break;
case VKD3DSIH_MAD:
shader_glsl_intrinsic(gen, ins, "fma");
break;
case VKD3DSIH_ISHL:
shader_glsl_binop(gen, ins, "<<");
break;
case VKD3DSIH_ISHR:
shader_glsl_binop(gen, ins, ">>");
break;
case VKD3DSIH_LTO:
shader_glsl_relop(gen, ins, "<", "lessThan");
break;
case VKD3DSIH_MAX:
shader_glsl_intrinsic(gen, ins, "max");
break;
case VKD3DSIH_MIN:
shader_glsl_intrinsic(gen, ins, "min");
break;
case VKD3DSIH_INE:
case VKD3DSIH_NEU:
shader_glsl_relop(gen, ins, "!=", "notEqual");
break;
case VKD3DSIH_ITOF:
case VKD3DSIH_UTOF:
shader_glsl_cast(gen, ins, "float", "vec");
break;
case VKD3DSIH_LOG:
shader_glsl_intrinsic(gen, ins, "log2");
break;
case VKD3DSIH_MOV:
shader_glsl_mov(gen, ins);
break;
case VKD3DSIH_MOVC:
shader_glsl_movc(gen, ins);
break;
case VKD3DSIH_MUL:
shader_glsl_binop(gen, ins, "*");
break;
case VKD3DSIH_NOT:
shader_glsl_unary_op(gen, ins, "~");
break;
case VKD3DSIH_OR:
shader_glsl_binop(gen, ins, "|");
break;
case VKD3DSIH_RET:
shader_glsl_ret(gen, ins);
break;
case VKD3DSIH_ROUND_NE:
shader_glsl_intrinsic(gen, ins, "roundEven");
break;
case VKD3DSIH_ROUND_NI:
shader_glsl_intrinsic(gen, ins, "floor");
break;
case VKD3DSIH_ROUND_PI:
shader_glsl_intrinsic(gen, ins, "ceil");
break;
case VKD3DSIH_ROUND_Z:
shader_glsl_intrinsic(gen, ins, "trunc");
break;
case VKD3DSIH_RSQ:
shader_glsl_intrinsic(gen, ins, "inversesqrt");
break;
case VKD3DSIH_SQRT:
shader_glsl_intrinsic(gen, ins, "sqrt");
break;
default:
shader_glsl_unhandled(gen, ins);
break;
}
}
static bool shader_glsl_check_shader_visibility(const struct vkd3d_glsl_generator *gen,
enum vkd3d_shader_visibility visibility)
{
enum vkd3d_shader_type t = gen->program->shader_version.type;
switch (visibility)
{
case VKD3D_SHADER_VISIBILITY_ALL:
return true;
case VKD3D_SHADER_VISIBILITY_VERTEX:
return t == VKD3D_SHADER_TYPE_VERTEX;
case VKD3D_SHADER_VISIBILITY_HULL:
return t == VKD3D_SHADER_TYPE_HULL;
case VKD3D_SHADER_VISIBILITY_DOMAIN:
return t == VKD3D_SHADER_TYPE_DOMAIN;
case VKD3D_SHADER_VISIBILITY_GEOMETRY:
return t == VKD3D_SHADER_TYPE_GEOMETRY;
case VKD3D_SHADER_VISIBILITY_PIXEL:
return t == VKD3D_SHADER_TYPE_PIXEL;
case VKD3D_SHADER_VISIBILITY_COMPUTE:
return t == VKD3D_SHADER_TYPE_COMPUTE;
default:
WARN("Invalid shader visibility %#x.\n", visibility);
return false;
}
}
static bool shader_glsl_get_cbv_binding(const struct vkd3d_glsl_generator *gen,
unsigned int register_space, unsigned int register_idx, unsigned int *binding_idx)
{
const struct vkd3d_shader_interface_info *interface_info = gen->interface_info;
const struct vkd3d_shader_resource_binding *binding;
unsigned int i;
if (!interface_info)
return false;
for (i = 0; i < interface_info->binding_count; ++i)
{
binding = &interface_info->bindings[i];
if (binding->type != VKD3D_SHADER_DESCRIPTOR_TYPE_CBV)
continue;
if (binding->register_space != register_space)
continue;
if (binding->register_index != register_idx)
continue;
if (!shader_glsl_check_shader_visibility(gen, binding->shader_visibility))
continue;
if (!(binding->flags & VKD3D_SHADER_BINDING_FLAG_BUFFER))
continue;
*binding_idx = i;
return true;
}
return false;
}
static void shader_glsl_generate_cbv_declaration(struct vkd3d_glsl_generator *gen,
const struct vkd3d_shader_descriptor_info1 *cbv)
{
const struct vkd3d_shader_descriptor_binding *binding;
const struct vkd3d_shader_descriptor_offset *offset;
struct vkd3d_string_buffer *buffer = gen->buffer;
const char *prefix = gen->prefix;
unsigned int binding_idx;
size_t size;
if (cbv->count != 1)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_BINDING_NOT_FOUND,
"Constant buffer %u has unsupported descriptor array size %u.", cbv->register_id, cbv->count);
return;
}
if (!shader_glsl_get_cbv_binding(gen, cbv->register_space, cbv->register_index, &binding_idx))
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_BINDING_NOT_FOUND,
"No descriptor binding specified for constant buffer %u.", cbv->register_id);
return;
}
binding = &gen->interface_info->bindings[binding_idx].binding;
if (binding->set != 0)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_BINDING_NOT_FOUND,
"Unsupported binding set %u specified for constant buffer %u.", binding->set, cbv->register_id);
return;
}
if (binding->count != 1)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_BINDING_NOT_FOUND,
"Unsupported binding count %u specified for constant buffer %u.", binding->count, cbv->register_id);
return;
}
if (gen->offset_info && gen->offset_info->binding_offsets)
{
offset = &gen->offset_info->binding_offsets[binding_idx];
if (offset->static_offset || offset->dynamic_offset_index != ~0u)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled descriptor offset specified for constant buffer %u.",
cbv->register_id);
return;
}
}
size = align(cbv->buffer_size, VKD3D_VEC4_SIZE * sizeof(uint32_t));
size /= VKD3D_VEC4_SIZE * sizeof(uint32_t);
vkd3d_string_buffer_printf(buffer,
"layout(std140, binding = %u) uniform block_%s_cb_%u { vec4 %s_cb_%u[%zu]; };\n",
binding->binding, prefix, cbv->register_id, prefix, cbv->register_id, size);
}
static void shader_glsl_generate_descriptor_declarations(struct vkd3d_glsl_generator *gen)
{
const struct vkd3d_shader_scan_descriptor_info1 *info = gen->descriptor_info;
const struct vkd3d_shader_descriptor_info1 *descriptor;
unsigned int i;
for (i = 0; i < info->descriptor_count; ++i)
{
descriptor = &info->descriptors[i];
switch (descriptor->type)
{
case VKD3D_SHADER_DESCRIPTOR_TYPE_CBV:
shader_glsl_generate_cbv_declaration(gen, descriptor);
break;
default:
vkd3d_string_buffer_printf(gen->buffer, "/* <unhandled descriptor type %#x> */\n", descriptor->type);
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled descriptor type %#x.", descriptor->type);
break;
}
}
if (info->descriptor_count)
vkd3d_string_buffer_printf(gen->buffer, "\n");
}
static void shader_glsl_generate_interface_block(struct vkd3d_string_buffer *buffer,
const char *type, unsigned int count)
{
unsigned int i;
vkd3d_string_buffer_printf(buffer, "%s shader_in_out\n{\n", type);
for (i = 0; i < count; ++i)
{
vkd3d_string_buffer_printf(buffer, " vec4 reg_%u;\n", i);
}
vkd3d_string_buffer_printf(buffer, "} shader_%s;\n", type);
}
static void shader_glsl_generate_input_declarations(struct vkd3d_glsl_generator *gen)
{
const struct shader_signature *signature = &gen->program->input_signature;
struct vkd3d_string_buffer *buffer = gen->buffer;
const struct signature_element *e;
unsigned int i;
if (!gen->interstage_input)
{
for (i = 0; i < signature->element_count; ++i)
{
e = &signature->elements[i];
if (e->target_location == SIGNATURE_TARGET_LOCATION_UNUSED)
continue;
if (e->sysval_semantic)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled system value %#x.", e->sysval_semantic);
continue;
}
if (e->component_type != VKD3D_SHADER_COMPONENT_FLOAT)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled component type %#x.", e->component_type);
continue;
}
if (e->min_precision != VKD3D_SHADER_MINIMUM_PRECISION_NONE)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled minimum precision %#x.", e->min_precision);
continue;
}
if (e->interpolation_mode != VKD3DSIM_NONE)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled interpolation mode %#x.", e->interpolation_mode);
continue;
}
vkd3d_string_buffer_printf(buffer,
"layout(location = %u) in vec4 shader_in_%u;\n", e->target_location, i);
}
}
else if (gen->limits.input_count)
{
shader_glsl_generate_interface_block(buffer, "in", gen->limits.input_count);
}
vkd3d_string_buffer_printf(buffer, "\n");
}
static void shader_glsl_generate_output_declarations(struct vkd3d_glsl_generator *gen)
{
const struct shader_signature *signature = &gen->program->output_signature;
struct vkd3d_string_buffer *buffer = gen->buffer;
const struct signature_element *e;
unsigned int i;
if (!gen->interstage_output)
{
for (i = 0; i < signature->element_count; ++i)
{
e = &signature->elements[i];
if (e->target_location == SIGNATURE_TARGET_LOCATION_UNUSED)
continue;
if (e->sysval_semantic != VKD3D_SHADER_SV_TARGET)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled system value %#x.", e->sysval_semantic);
continue;
}
if (e->component_type != VKD3D_SHADER_COMPONENT_FLOAT)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled component type %#x.", e->component_type);
continue;
}
if (e->min_precision != VKD3D_SHADER_MINIMUM_PRECISION_NONE)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled minimum precision %#x.", e->min_precision);
continue;
}
if (e->interpolation_mode != VKD3DSIM_NONE)
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled interpolation mode %#x.", e->interpolation_mode);
continue;
}
vkd3d_string_buffer_printf(buffer,
"layout(location = %u) out vec4 shader_out_%u;\n", e->target_location, i);
}
}
else if (gen->limits.output_count)
{
shader_glsl_generate_interface_block(buffer, "out", gen->limits.output_count);
}
vkd3d_string_buffer_printf(buffer, "\n");
}
static void shader_glsl_generate_declarations(struct vkd3d_glsl_generator *gen)
{
const struct vsir_program *program = gen->program;
struct vkd3d_string_buffer *buffer = gen->buffer;
shader_glsl_generate_descriptor_declarations(gen);
shader_glsl_generate_input_declarations(gen);
shader_glsl_generate_output_declarations(gen);
if (gen->limits.input_count)
vkd3d_string_buffer_printf(buffer, "vec4 %s_in[%u];\n", gen->prefix, gen->limits.input_count);
if (gen->limits.output_count)
vkd3d_string_buffer_printf(buffer, "vec4 %s_out[%u];\n", gen->prefix, gen->limits.output_count);
if (program->temp_count)
vkd3d_string_buffer_printf(buffer, "vec4 r[%u];\n", program->temp_count);
vkd3d_string_buffer_printf(buffer, "\n");
}
static int vkd3d_glsl_generator_generate(struct vkd3d_glsl_generator *gen, struct vkd3d_shader_code *out)
{
const struct vkd3d_shader_instruction_array *instructions = &gen->program->instructions;
struct vkd3d_string_buffer *buffer = gen->buffer;
unsigned int i;
void *code;
MESSAGE("Generating a GLSL shader. This is unsupported; you get to keep all the pieces if it breaks.\n");
vkd3d_string_buffer_printf(buffer, "#version 440\n\n");
vkd3d_string_buffer_printf(buffer, "/* Generated by %s. */\n\n", vkd3d_shader_get_version(NULL, NULL));
shader_glsl_generate_declarations(gen);
vkd3d_string_buffer_printf(buffer, "void main()\n{\n");
++gen->indent;
shader_glsl_shader_prologue(gen);
for (i = 0; i < instructions->count; ++i)
{
vkd3d_glsl_handle_instruction(gen, &instructions->elements[i]);
}
vkd3d_string_buffer_printf(buffer, "}\n");
if (TRACE_ON())
vkd3d_string_buffer_trace(buffer);
if (gen->failed)
return VKD3D_ERROR_INVALID_SHADER;
if ((code = vkd3d_malloc(buffer->buffer_size)))
{
memcpy(code, buffer->buffer, buffer->content_size);
out->size = buffer->content_size;
out->code = code;
}
else return VKD3D_ERROR_OUT_OF_MEMORY;
return VKD3D_OK;
}
static void vkd3d_glsl_generator_cleanup(struct vkd3d_glsl_generator *gen)
{
vkd3d_string_buffer_release(&gen->string_buffers, gen->buffer);
vkd3d_string_buffer_cache_cleanup(&gen->string_buffers);
}
static void shader_glsl_init_limits(struct vkd3d_glsl_generator *gen, const struct vkd3d_shader_version *version)
{
struct shader_limits *limits = &gen->limits;
if (version->major < 4 || version->major >= 6)
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled shader version %u.%u.", version->major, version->minor);
switch (version->type)
{
case VKD3D_SHADER_TYPE_VERTEX:
limits->input_count = 32;
limits->output_count = 32;
break;
case VKD3D_SHADER_TYPE_PIXEL:
limits->input_count = 32;
limits->output_count = 8;
break;
default:
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled shader type %#x.", version->type);
limits->input_count = 0;
limits->output_count = 0;
break;
}
}
static void vkd3d_glsl_generator_init(struct vkd3d_glsl_generator *gen,
struct vsir_program *program, const struct vkd3d_shader_compile_info *compile_info,
const struct vkd3d_shader_scan_descriptor_info1 *descriptor_info,
struct vkd3d_shader_message_context *message_context)
{
enum vkd3d_shader_type type = program->shader_version.type;
memset(gen, 0, sizeof(*gen));
gen->program = program;
vkd3d_string_buffer_cache_init(&gen->string_buffers);
gen->buffer = vkd3d_string_buffer_get(&gen->string_buffers);
gen->location.source_name = compile_info->source_name;
gen->message_context = message_context;
if (!(gen->prefix = shader_glsl_get_prefix(type)))
{
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled shader type %#x.", type);
gen->prefix = "unknown";
}
shader_glsl_init_limits(gen, &program->shader_version);
gen->interstage_input = type != VKD3D_SHADER_TYPE_VERTEX;
gen->interstage_output = type != VKD3D_SHADER_TYPE_PIXEL;
gen->interface_info = vkd3d_find_struct(compile_info->next, INTERFACE_INFO);
gen->offset_info = vkd3d_find_struct(compile_info->next, DESCRIPTOR_OFFSET_INFO);
gen->descriptor_info = descriptor_info;
}
int glsl_compile(struct vsir_program *program, uint64_t config_flags,
const struct vkd3d_shader_scan_descriptor_info1 *descriptor_info,
const struct vkd3d_shader_compile_info *compile_info,
struct vkd3d_shader_code *out, struct vkd3d_shader_message_context *message_context)
{
struct vkd3d_glsl_generator generator;
int ret;
if ((ret = vsir_program_transform(program, config_flags, compile_info, message_context)) < 0)
return ret;
vkd3d_glsl_generator_init(&generator, program, compile_info, descriptor_info, message_context);
ret = vkd3d_glsl_generator_generate(&generator, out);
vkd3d_glsl_generator_cleanup(&generator);
return ret;
}
Reference in New Issue View Git Blame Copy Permalink