mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-02-03 08:54:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

(slang) slang_process: simplify data mappings.

Browse Source
This commit is contained in:
aliaspider 2018-02-03 17:22:47 +01:00
parent 1464995fdc
commit 76d07cd6a7
4 changed files with 75 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
gfx/drivers/d3d11.c
View File

@ -176,61 +176,47 @@ static bool d3d11_gfx_set_shader(void* data, enum rarch_shader_type type, const
for (i = 0; i < d3d11->shader_preset->passes; source = &d3d11->pass[i++].rt)
{
unsigned j;
texture_map_t texture_map
[3 + GFX_MAX_FRAME_HISTORY + 1 + GFX_MAX_SHADERS * 2 + GFX_MAX_TEXTURES + 1] = {
SL_TEXTURE_MAP(
SLANG_TEXTURE_SEMANTIC_ORIGINAL, d3d11->frame.texture[0].view,
d3d11->pass[i].sampler, d3d11->frame.texture[0].size_data),
SL_TEXTURE_MAP(
SLANG_TEXTURE_SEMANTIC_SOURCE, source->view, d3d11->pass[i].sampler,
source->size_data),
};
texture_map_t* ptr = texture_map;
/* clang-format off */
semantics_map_t semantics_map = {
{
/* Original */
{ &d3d11->frame.texture[0].view, 0,
&d3d11->frame.texture[0].size_data, 0,
&d3d11->pass[i].sampler, 0 },
while (ptr->texture_data)
ptr++;
/* Source */
{ &source->view, 0,
&source->size_data, 0,
&d3d11->pass[i].sampler, 0 },
for (j = 0; j < GFX_MAX_FRAME_HISTORY + 1; j++)
{
*ptr = (texture_map_t)SL_TEXTURE_MAP_ARRAY(
SLANG_TEXTURE_SEMANTIC_ORIGINAL_HISTORY, j, d3d11->frame.texture[j].view,
d3d11->pass[i].sampler, d3d11->frame.texture[j].size_data);
ptr++;
}
/* OriginalHistory */
{ &d3d11->frame.texture[0].view, sizeof(*d3d11->frame.texture),
&d3d11->frame.texture[0].size_data, sizeof(*d3d11->frame.texture),
&d3d11->pass[i].sampler, 0 },
for (j = 0; j < i; j++)
{
*ptr = (texture_map_t)SL_TEXTURE_MAP_ARRAY(
SLANG_TEXTURE_SEMANTIC_PASS_OUTPUT, j, d3d11->pass[j].rt.view,
d3d11->pass[i].sampler, d3d11->pass[j].rt.size_data);
ptr++;
}
/* PassOutput */
{ &d3d11->pass[0].rt.view, sizeof(*d3d11->pass),
&d3d11->pass[0].rt.size_data, sizeof(*d3d11->pass),
&d3d11->pass[i].sampler, 0 },
for (j = 0; j < GFX_MAX_SHADERS; j++)
{
*ptr = (texture_map_t)SL_TEXTURE_MAP_ARRAY(
SLANG_TEXTURE_SEMANTIC_PASS_FEEDBACK, j, d3d11->pass[j].feedback.view,
d3d11->pass[i].sampler, d3d11->pass[j].rt.size_data);
ptr++;
}
/* PassFeedback */
{ &d3d11->pass[0].feedback.view, sizeof(*d3d11->pass),
&d3d11->pass[0].feedback.size_data, sizeof(*d3d11->pass),
&d3d11->pass[i].sampler, 0 },
for (j = 0; j < d3d11->shader_preset->luts; j++)
{
*ptr = (texture_map_t)SL_TEXTURE_MAP_ARRAY(
SLANG_TEXTURE_SEMANTIC_USER, j, d3d11->luts[j].view, d3d11->luts[j].sampler,
d3d11->luts[j].size_data);
ptr++;
}
uniform_map_t uniform_map[] = {
SL_UNIFORM_MAP(SLANG_SEMANTIC_MVP, d3d11->mvp),
SL_UNIFORM_MAP(SLANG_SEMANTIC_OUTPUT, d3d11->pass[i].rt.size_data),
SL_UNIFORM_MAP(SLANG_SEMANTIC_FRAME_COUNT, d3d11->pass[i].frame_count),
SL_UNIFORM_MAP(SLANG_SEMANTIC_FINAL_VIEWPORT, d3d11->frame.output_size),
{ 0 }
/* User */
{ &d3d11->luts[0].view, sizeof(*d3d11->luts),
&d3d11->luts[0].size_data, sizeof(*d3d11->luts),
&d3d11->luts[0].sampler, sizeof(*d3d11->luts) },
},
{
&d3d11->mvp, /* MVP */
&d3d11->pass[i].rt.size_data, /* OutputSize */
&d3d11->frame.output_size, /* FinalViewportSize */
&d3d11->pass[i].frame_count, /* FrameCount */
}
};
semantics_map_t semantics_map = { texture_map, uniform_map };
/* clang-format on */
if (!slang_process(
d3d11->shader_preset, i, RARCH_SHADER_HLSL, 50, &semantics_map,

58
gfx/drivers_shader/slang_process.cpp
View File

@ -88,7 +88,7 @@ static bool slang_process_reflection(
const ShaderResources& ps_resources,
video_shader* shader_info,
unsigned pass_number,
const semantics_map_t* semantics_map,
const semantics_map_t* map,
pass_semantics_t* out)
{
unordered_map<string, slang_texture_semantic_map> texture_semantic_map;
@ -168,17 +168,15 @@ static bool slang_process_reflection(
vector<uniform_sem_t> uniforms[SLANG_CBUFFER_MAX];
vector<texture_sem_t> textures;
uniform_map_t* uniform_map = semantics_map->uniform_map;
while (uniform_map->data)
for (int semantic = 0; semantic < SLANG_NUM_BASE_SEMANTICS; semantic++)
{
slang_semantic_meta& src = sl_reflection.semantics[uniform_map->semantic];
slang_semantic_meta& src = sl_reflection.semantics[semantic];
if (src.push_constant || src.uniform)
{
uniform_sem_t uniform = { uniform_map->data, uniform_map->id,
uniform_sem_t uniform = { map->uniforms[semantic],
src.num_components * (unsigned)sizeof(float) };
string uniform_id = get_semantic_name(sl_reflection, uniform_map->semantic, 0);
string uniform_id = get_semantic_name(sl_reflection, (slang_semantic)semantic, 0);
strncpy(uniform.id, uniform_id.c_str(), sizeof(uniform.id));
if (src.push_constant)
@ -192,8 +190,6 @@ static bool slang_process_reflection(
uniforms[SLANG_CBUFFER_UBO].push_back(uniform);
}
}
uniform_map++;
}
for (int i = 0; i < sl_reflection.semantic_float_parameters.size(); i++)
@ -202,8 +198,7 @@ static bool slang_process_reflection(
if (src.push_constant || src.uniform)
{
uniform_sem_t uniform = { &shader_info->parameters[i].current,
"shader_info->parameter[i].current", sizeof(float) };
uniform_sem_t uniform = { &shader_info->parameters[i].current, sizeof(float) };
string uniform_id = get_semantic_name(sl_reflection, SLANG_SEMANTIC_FLOAT_PARAMETER, i);
strncpy(uniform.id, uniform_id.c_str(), sizeof(uniform.id));
@ -221,42 +216,43 @@ static bool slang_process_reflection(
}
}
texture_map_t* texture_map = semantics_map->texture_map;
while (texture_map->texture_data)
for (int semantic = 0; semantic < SLANG_NUM_TEXTURE_SEMANTICS; semantic++)
{
if (texture_map->index < sl_reflection.semantic_textures[texture_map->semantic].size())
for (int index = 0; index < sl_reflection.semantic_textures[semantic].size(); index++)
{
slang_texture_semantic_meta& src =
sl_reflection.semantic_textures[texture_map->semantic][texture_map->index];
slang_texture_semantic_meta& src = sl_reflection.semantic_textures[semantic][index];
if (src.stage_mask)
{
texture_sem_t texture = { texture_map->texture_data, texture_map->texture_id,
texture_map->sampler_data, texture_map->sampler_id };
texture.stage_mask = src.stage_mask;
texture.binding = src.binding;
string id = get_semantic_name(sl_reflection, texture_map->semantic, texture_map->index);
texture_sem_t texture = {
(void*)((uintptr_t)map->textures[semantic].image + index * map->textures[semantic].image_stride),
(void*)((uintptr_t)map->textures[semantic].sampler + index * map->textures[semantic].sampler_stride),
};
texture.stage_mask = src.stage_mask;
texture.binding = src.binding;
string id = get_semantic_name(sl_reflection, (slang_texture_semantic)semantic, index);
strncpy(texture.id, id.c_str(), sizeof(texture.id));
textures.push_back(texture);
if (texture_map->semantic == SLANG_TEXTURE_SEMANTIC_PASS_FEEDBACK)
shader_info->pass[texture_map->index].feedback = true;
if (semantic == SLANG_TEXTURE_SEMANTIC_PASS_FEEDBACK)
shader_info->pass[index].feedback = true;
if (texture_map->semantic == SLANG_TEXTURE_SEMANTIC_ORIGINAL_HISTORY &&
shader_info->history_size < texture_map->index)
shader_info->history_size = texture_map->index;
if (semantic == SLANG_TEXTURE_SEMANTIC_ORIGINAL_HISTORY &&
shader_info->history_size < index)
shader_info->history_size = index;
}
if (src.push_constant || src.uniform)
{
uniform_sem_t uniform = { texture_map->size_data, texture_map->size_id,
4 * sizeof(float) };
uniform_sem_t uniform = {
(void*)((uintptr_t)map->textures[semantic].size + index * map->textures[semantic].size_stride),
4 * sizeof(float)
};
string uniform_id =
get_size_semantic_name(sl_reflection, texture_map->semantic, texture_map->index);
get_size_semantic_name(sl_reflection, (slang_texture_semantic)semantic, index);
strncpy(uniform.id, uniform_id.c_str(), sizeof(uniform.id));
@ -272,8 +268,6 @@ static bool slang_process_reflection(
}
}
}
texture_map++;
}
out->texture_count = textures.size();

40
gfx/drivers_shader/slang_process.h
View File

@ -26,45 +26,29 @@
typedef struct
{
enum slang_semantic semantic;
void* data;
const char* id;
} uniform_map_t;
void* ptr;
size_t stride;
} data_map_t;
typedef struct
{
enum slang_texture_semantic semantic;
int index;
void* texture_data;
const char* texture_id;
void* sampler_data;
const char* sampler_id;
void* size_data;
const char* size_id;
void* image;
size_t image_stride;
void* size;
size_t size_stride;
void* sampler;
size_t sampler_stride;
} texture_map_t;
#define SL_UNIFORM_MAP(sem, data) \
{ \
sem, &data, #data \
}
#define SL_TEXTURE_MAP_ARRAY(sem, index, tex, sampl, size) \
{ \
sem, index, &tex, #tex, &sampl, #sampl, &size, #size \
}
#define SL_TEXTURE_MAP(sem, tex, sampl, size) SL_TEXTURE_MAP_ARRAY(sem, 0, tex, sampl, size)
typedef struct
{
texture_map_t* texture_map;
uniform_map_t* uniform_map;
texture_map_t textures[SLANG_NUM_TEXTURE_SEMANTICS];
void* uniforms[SLANG_NUM_BASE_SEMANTICS];
} semantics_map_t;
typedef struct
{
void* data;
const char* data_id;
unsigned size;
unsigned offset;
char id[64];
@ -73,9 +57,7 @@ typedef struct
typedef struct
{
void* texture_data;
const char* texture_id;
void* sampler_data;
const char* sampler_id;
unsigned stage_mask;
unsigned binding;
char id[64];

2
gfx/drivers_shader/slang_reflection.h
View File

@ -63,6 +63,8 @@ enum slang_semantic
SLANG_SEMANTIC_FINAL_VIEWPORT = 2,
// uint, frame count with modulo
SLANG_SEMANTIC_FRAME_COUNT = 3,
SLANG_NUM_BASE_SEMANTICS,
// float, user defined parameter, arrayed
SLANG_SEMANTIC_FLOAT_PARAMETER = 4,