third_party
/
virglrenderer
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

renderer: CLEANUP: boolean/GLboolean -> bool

Browse Source 
use stdbool.h as much as possible
some of the gallium code imported uses boolean
so leave it alone for now
macos/master
Dave Airlie 11 years ago
parent a20ce55f73
commit ca23e98b22
7 changed files with 247 additions and 253 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 4
      src/vrend_blitter.c
  2. 12
      src/vrend_decode.c
  3. 4
      src/vrend_formats.c
  4. 248
      src/vrend_renderer.c
  5. 7
      src/vrend_renderer.h
  6. 205
      src/vrend_shader.c
  7. 20
      src/vrend_shader.h

4
src/vrend_blitter.c
Unescape View File

@ -351,7 +351,7 @@ static void get_texcoords(struct vrend_resource *src_res,
int x1, int y1, int x2, int y2, int x1, int y1, int x2, int y2,
float out[4]) float out[4])
{ {
boolean normalized = src_res->base.target != PIPE_TEXTURE_RECT && bool normalized = src_res->base.target != PIPE_TEXTURE_RECT &&
src_res->base.nr_samples <= 1; src_res->base.nr_samples <= 1;
if (normalized) { if (normalized) {
@ -468,7 +468,7 @@ void vrend_renderer_blit_gl(struct vrend_context *ctx,
GLenum filter; GLenum filter;
GLuint pos_loc, tc_loc; GLuint pos_loc, tc_loc;
GLuint samp_loc; GLuint samp_loc;
boolean has_depth, has_stencil; bool has_depth, has_stencil;
bool blit_stencil, blit_depth; bool blit_stencil, blit_depth;
int dst_z; int dst_z;
const struct util_format_description *src_desc = const struct util_format_description *src_desc =

12
src/vrend_decode.c
Unescape View File

@ -954,7 +954,7 @@ static int vrend_decode_get_query_result(struct vrend_decode_ctx *ctx, int lengt
static int vrend_decode_set_render_condition(struct vrend_decode_ctx *ctx, int length) static int vrend_decode_set_render_condition(struct vrend_decode_ctx *ctx, int length)
{ {
uint32_t handle = get_buf_entry(ctx, VIRGL_RENDER_CONDITION_HANDLE); uint32_t handle = get_buf_entry(ctx, VIRGL_RENDER_CONDITION_HANDLE);
boolean condition = get_buf_entry(ctx, VIRGL_RENDER_CONDITION_CONDITION) & 1; bool condition = get_buf_entry(ctx, VIRGL_RENDER_CONDITION_CONDITION) & 1;
uint mode = get_buf_entry(ctx, VIRGL_RENDER_CONDITION_MODE); uint mode = get_buf_entry(ctx, VIRGL_RENDER_CONDITION_MODE);
if (length != VIRGL_RENDER_CONDITION_SIZE) if (length != VIRGL_RENDER_CONDITION_SIZE)
@ -1061,7 +1061,7 @@ void vrend_renderer_context_destroy(uint32_t handle)
free(ctx); free(ctx);
/* switch to ctx 0 */ /* switch to ctx 0 */
if (ret && handle != 0) if (ret && handle != 0)
vrend_hw_switch_context(dec_ctx[0]->grctx, TRUE); vrend_hw_switch_context(dec_ctx[0]->grctx, true);
} }
struct vrend_context *vrend_lookup_renderer_ctx(uint32_t ctx_id) struct vrend_context *vrend_lookup_renderer_ctx(uint32_t ctx_id)
@ -1078,7 +1078,7 @@ struct vrend_context *vrend_lookup_renderer_ctx(uint32_t ctx_id)
int vrend_decode_block(uint32_t ctx_id, uint32_t *block, int ndw) int vrend_decode_block(uint32_t ctx_id, uint32_t *block, int ndw)
{ {
struct vrend_decode_ctx *gdctx; struct vrend_decode_ctx *gdctx;
boolean bret; bool bret;
int ret; int ret;
if (ctx_id > VREND_MAX_CTX) if (ctx_id > VREND_MAX_CTX)
return EINVAL; return EINVAL;
@ -1088,8 +1088,8 @@ int vrend_decode_block(uint32_t ctx_id, uint32_t *block, int ndw)
gdctx = dec_ctx[ctx_id]; gdctx = dec_ctx[ctx_id];
bret = vrend_hw_switch_context(gdctx->grctx, TRUE); bret = vrend_hw_switch_context(gdctx->grctx, true);
if (bret == FALSE) if (bret == false)
return EINVAL; return EINVAL;
gdctx->ds->buf = block; gdctx->ds->buf = block;
@ -1218,7 +1218,7 @@ void vrend_decode_reset(bool ctx_0_only)
{ {
int i; int i;
vrend_hw_switch_context(dec_ctx[0]->grctx, TRUE); vrend_hw_switch_context(dec_ctx[0]->grctx, true);
if (ctx_0_only == false) { if (ctx_0_only == false) {
for (i = 1; i < VREND_MAX_CTX; i++) { for (i = 1; i < VREND_MAX_CTX; i++) {

4
src/vrend_formats.c
Unescape View File

@ -248,7 +248,7 @@ static void vrend_add_formats(struct vrend_format_table *table, int num_entries)
GLuint tex_id, fb_id; GLuint tex_id, fb_id;
for (i = 0; i < num_entries; i++) { for (i = 0; i < num_entries; i++) {
GLenum status; GLenum status;
boolean is_depth = FALSE; bool is_depth = false;
/**/ /**/
glGenTextures(1, &tex_id); glGenTextures(1, &tex_id);
glGenFramebuffers(1, &fb_id); glGenFramebuffers(1, &fb_id);
@ -295,7 +295,7 @@ static void vrend_add_formats(struct vrend_format_table *table, int num_entries)
attachment = GL_DEPTH_STENCIL_ATTACHMENT; attachment = GL_DEPTH_STENCIL_ATTACHMENT;
glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, attachment, GL_TEXTURE_2D, tex_id, 0); glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, attachment, GL_TEXTURE_2D, tex_id, 0);
is_depth = TRUE; is_depth = true;
glDrawBuffer(GL_NONE); glDrawBuffer(GL_NONE);
} else { } else {
glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex_id, 0); glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex_id, 0);

248
src/vrend_renderer.c
Unescape View File

@ -101,14 +101,16 @@ struct global_renderer_state {
struct vrend_context *current_hw_ctx; struct vrend_context *current_hw_ctx;
struct list_head waiting_query_list; struct list_head waiting_query_list;
boolean have_mesa_invert; bool have_mesa_invert;
boolean have_samplers; bool have_samplers;
boolean have_robustness; bool have_robustness;
boolean have_multisample; bool have_multisample;
boolean have_ms_scaled_blit; bool have_ms_scaled_blit;
boolean have_nv_prim_restart, have_gl_prim_restart, have_bit_encoding; bool have_nv_prim_restart;
bool have_gl_prim_restart;
boolean have_vertex_attrib_binding; bool have_bit_encoding;
bool have_vertex_attrib_binding;
uint32_t max_uniform_blocks; uint32_t max_uniform_blocks;
struct list_head active_ctx_list; struct list_head active_ctx_list;
}; };
@ -120,7 +122,7 @@ struct vrend_linked_shader_program {
struct list_head sl[PIPE_SHADER_TYPES]; struct list_head sl[PIPE_SHADER_TYPES];
GLuint id; GLuint id;
boolean dual_src_linked; bool dual_src_linked;
struct vrend_shader *ss[PIPE_SHADER_TYPES]; struct vrend_shader *ss[PIPE_SHADER_TYPES];
uint32_t samplers_used_mask[PIPE_SHADER_TYPES]; uint32_t samplers_used_mask[PIPE_SHADER_TYPES];
@ -307,7 +309,7 @@ struct vrend_sub_context {
uint32_t const_bufs_used_mask[PIPE_SHADER_TYPES]; uint32_t const_bufs_used_mask[PIPE_SHADER_TYPES];
int num_sampler_states[PIPE_SHADER_TYPES]; int num_sampler_states[PIPE_SHADER_TYPES];
boolean sampler_state_dirty; bool sampler_state_dirty;
uint32_t fb_id; uint32_t fb_id;
int nr_cbufs, old_nr_cbufs; int nr_cbufs, old_nr_cbufs;
@ -317,13 +319,13 @@ struct vrend_sub_context {
struct vrend_viewport vps[PIPE_MAX_VIEWPORTS]; struct vrend_viewport vps[PIPE_MAX_VIEWPORTS];
float depth_transform, depth_scale; float depth_transform, depth_scale;
/* viewport is negative */ /* viewport is negative */
GLboolean viewport_is_negative; bool viewport_is_negative;
/* this is set if the contents of the FBO look upside down when viewed /* this is set if the contents of the FBO look upside down when viewed
with 0,0 as the bottom corner */ with 0,0 as the bottom corner */
GLboolean inverted_fbo_content; bool inverted_fbo_content;
uint32_t scissor_state_dirty; uint32_t scissor_state_dirty;
uint32_t viewport_state_dirty; uint32_t viewport_state_dirty;
boolean stencil_state_dirty; bool stencil_state_dirty;
uint32_t fb_height; uint32_t fb_height;
struct pipe_scissor_state ss[PIPE_MAX_VIEWPORTS]; struct pipe_scissor_state ss[PIPE_MAX_VIEWPORTS];
@ -340,10 +342,11 @@ struct vrend_sub_context {
struct pipe_clip_state ucp_state; struct pipe_clip_state ucp_state;
GLboolean blend_enabled; bool blend_enabled;
GLboolean depth_test_enabled; bool depth_test_enabled;
GLboolean alpha_test_enabled; bool alpha_test_enabled;
GLboolean stencil_test_enabled; bool stencil_test_enabled;
GLuint program_id; GLuint program_id;
struct pipe_rasterizer_state hw_rs_state; struct pipe_rasterizer_state hw_rs_state;
@ -367,15 +370,14 @@ struct vrend_context {
struct util_hash_table *res_hash; struct util_hash_table *res_hash;
struct list_head active_nontimer_query_list; struct list_head active_nontimer_query_list;
boolean query_on_hw;
/* has this ctx gotten an error? */ /* has this ctx gotten an error? */
boolean in_error; bool in_error;
enum virgl_ctx_errors last_error; enum virgl_ctx_errors last_error;
boolean ctx_switch_pending; bool ctx_switch_pending;
boolean pstip_inited; bool pstip_inited;
GLuint pstipple_tex_id; GLuint pstipple_tex_id;
struct vrend_shader_cfg shader_cfg; struct vrend_shader_cfg shader_cfg;
@ -393,16 +395,16 @@ void vrend_update_stencil_state(struct vrend_context *ctx);
static struct vrend_format_table tex_conv_table[VIRGL_FORMAT_MAX]; static struct vrend_format_table tex_conv_table[VIRGL_FORMAT_MAX];
static inline boolean vrend_format_can_sample(enum virgl_formats format) static inline bool vrend_format_can_sample(enum virgl_formats format)
{ {
return tex_conv_table[format].bindings & VREND_BIND_SAMPLER; return tex_conv_table[format].bindings & VREND_BIND_SAMPLER;
} }
static inline boolean vrend_format_can_render(enum virgl_formats format) static inline bool vrend_format_can_render(enum virgl_formats format)
{ {
return tex_conv_table[format].bindings & VREND_BIND_RENDER; return tex_conv_table[format].bindings & VREND_BIND_RENDER;
} }
static inline boolean vrend_format_is_ds(enum virgl_formats format) static inline bool vrend_format_is_ds(enum virgl_formats format)
{ {
return tex_conv_table[format].bindings & VREND_BIND_DEPTHSTENCIL; return tex_conv_table[format].bindings & VREND_BIND_DEPTHSTENCIL;
} }
@ -426,7 +428,7 @@ static const char *vrend_ctx_error_strings[] = { "None", "Unknown", "Illegal sha
static void __report_context_error(const char *fname, struct vrend_context *ctx, enum virgl_ctx_errors error, uint32_t value) static void __report_context_error(const char *fname, struct vrend_context *ctx, enum virgl_ctx_errors error, uint32_t value)
{ {
ctx->in_error = TRUE; ctx->in_error = true;
ctx->last_error = error; ctx->last_error = error;
fprintf(stderr,"%s: context error reported %d \"%s\" %s %d\n", fname, ctx->ctx_id, ctx->debug_name, vrend_ctx_error_strings[error], value); fprintf(stderr,"%s: context error reported %d \"%s\" %s %d\n", fname, ctx->ctx_id, ctx->debug_name, vrend_ctx_error_strings[error], value);
} }
@ -451,7 +453,7 @@ static void __report_core_warn(const char *fname, struct vrend_context *ctx, enu
fprintf(stderr,"%s: core profile violation reported %d \"%s\" %s %d\n", fname, ctx->ctx_id, ctx->debug_name, vrend_core_profile_warn_strings[error], value); fprintf(stderr,"%s: core profile violation reported %d \"%s\" %s %d\n", fname, ctx->ctx_id, ctx->debug_name, vrend_core_profile_warn_strings[error], value);
} }
#define report_core_warn(ctx, error, value) __report_core_warn(__func__, ctx, error, value) #define report_core_warn(ctx, error, value) __report_core_warn(__func__, ctx, error, value)
static inline boolean should_invert_viewport(struct vrend_context *ctx) static inline bool should_invert_viewport(struct vrend_context *ctx)
{ {
/* if we have a negative viewport then gallium wanted to invert it, /* if we have a negative viewport then gallium wanted to invert it,
however since we are rendering to GL FBOs we need to invert it however since we are rendering to GL FBOs we need to invert it
@ -539,7 +541,7 @@ static void vrend_destroy_shader_selector(struct vrend_shader_selector *sel)
free(sel); free(sel);
} }
static boolean vrend_compile_shader(struct vrend_context *ctx, static bool vrend_compile_shader(struct vrend_context *ctx,
struct vrend_shader *shader) struct vrend_shader *shader)
{ {
GLint param; GLint param;
@ -553,9 +555,9 @@ static boolean vrend_compile_shader(struct vrend_context *ctx,
report_context_error(ctx, VIRGL_ERROR_CTX_ILLEGAL_SHADER, 0); report_context_error(ctx, VIRGL_ERROR_CTX_ILLEGAL_SHADER, 0);
fprintf(stderr,"shader failed to compile\n%s\n", infolog); fprintf(stderr,"shader failed to compile\n%s\n", infolog);
fprintf(stderr,"GLSL:\n%s\n", shader->glsl_prog); fprintf(stderr,"GLSL:\n%s\n", shader->glsl_prog);
return FALSE; return false;
} }
return TRUE; return true;
} }
static inline void static inline void
@ -586,7 +588,7 @@ vrend_insert_format_swizzle(int override_format, struct vrend_format_table *entr
tex_conv_table[override_format].swizzle[i] = swizzle[i]; tex_conv_table[override_format].swizzle[i] = swizzle[i];
} }
static boolean vrend_is_timer_query(GLenum gltype) static bool vrend_is_timer_query(GLenum gltype)
{ {
return gltype == GL_TIMESTAMP || return gltype == GL_TIMESTAMP ||
gltype == GL_TIME_ELAPSED; gltype == GL_TIME_ELAPSED;
@ -613,7 +615,7 @@ static void vrend_init_pstipple_texture(struct vrend_context *ctx)
ctx->pstip_inited = true; ctx->pstip_inited = true;
} }
static void vrend_blend_enable(struct vrend_context *ctx, GLboolean blend_enable) static void vrend_blend_enable(struct vrend_context *ctx, bool blend_enable)
{ {
if (ctx->sub->blend_enabled != blend_enable) { if (ctx->sub->blend_enabled != blend_enable) {
ctx->sub->blend_enabled = blend_enable; ctx->sub->blend_enabled = blend_enable;
@ -624,7 +626,7 @@ static void vrend_blend_enable(struct vrend_context *ctx, GLboolean blend_enable
} }
} }
static void vrend_depth_test_enable(struct vrend_context *ctx, GLboolean depth_test_enable) static void vrend_depth_test_enable(struct vrend_context *ctx, bool depth_test_enable)
{ {
if (ctx->sub->depth_test_enabled != depth_test_enable) { if (ctx->sub->depth_test_enabled != depth_test_enable) {
ctx->sub->depth_test_enabled = depth_test_enable; ctx->sub->depth_test_enabled = depth_test_enable;
@ -635,8 +637,7 @@ static void vrend_depth_test_enable(struct vrend_context *ctx, GLboolean depth_t
} }
} }
static void vrend_alpha_test_enable(struct vrend_context *ctx, static void vrend_alpha_test_enable(struct vrend_context *ctx, bool alpha_test_enable)
GLboolean alpha_test_enable)
{ {
if (vrend_state.use_core_profile) { if (vrend_state.use_core_profile) {
/* handled in shaders */ /* handled in shaders */
@ -650,8 +651,7 @@ static void vrend_alpha_test_enable(struct vrend_context *ctx,
glDisable(GL_ALPHA_TEST); glDisable(GL_ALPHA_TEST);
} }
} }
static void vrend_stencil_test_enable(struct vrend_context *ctx, static void vrend_stencil_test_enable(struct vrend_context *ctx, bool stencil_test_enable)
GLboolean stencil_test_enable)
{ {
if (ctx->sub->stencil_test_enabled != stencil_test_enable) { if (ctx->sub->stencil_test_enabled != stencil_test_enable) {
ctx->sub->stencil_test_enabled = stencil_test_enable; ctx->sub->stencil_test_enabled = stencil_test_enable;
@ -785,7 +785,7 @@ static struct vrend_linked_shader_program *add_shader_program(struct vrend_conte
/* need to rewrite VS code to add interpolation params */ /* need to rewrite VS code to add interpolation params */
if ((gs && gs->compiled_fs_id != fs->id) || if ((gs && gs->compiled_fs_id != fs->id) ||
(!gs && vs->compiled_fs_id != fs->id)) { (!gs && vs->compiled_fs_id != fs->id)) {
boolean ret; bool ret;
if (gs) if (gs)
vrend_patch_vertex_shader_interpolants(gs->glsl_prog, vrend_patch_vertex_shader_interpolants(gs->glsl_prog,
@ -796,7 +796,7 @@ static struct vrend_linked_shader_program *add_shader_program(struct vrend_conte
&vs->sel->sinfo, &vs->sel->sinfo,
&fs->sel->sinfo, false, fs->key.flatshade); &fs->sel->sinfo, false, fs->key.flatshade);
ret = vrend_compile_shader(ctx, gs ? gs : vs); ret = vrend_compile_shader(ctx, gs ? gs : vs);
if (ret == FALSE) { if (ret == false) {
glDeleteShader(gs ? gs->id : vs->id); glDeleteShader(gs ? gs->id : vs->id);
free(sprog); free(sprog);
return NULL; return NULL;
@ -962,7 +962,7 @@ static struct vrend_linked_shader_program *add_shader_program(struct vrend_conte
} }
static struct vrend_linked_shader_program *lookup_shader_program(struct vrend_context *ctx, static struct vrend_linked_shader_program *lookup_shader_program(struct vrend_context *ctx,
GLuint vs_id, GLuint fs_id, GLuint gs_id, GLboolean dual_src) GLuint vs_id, GLuint fs_id, GLuint gs_id, bool dual_src)
{ {
struct vrend_linked_shader_program *ent; struct vrend_linked_shader_program *ent;
LIST_FOR_EACH_ENTRY(ent, &ctx->sub->programs, head) { LIST_FOR_EACH_ENTRY(ent, &ctx->sub->programs, head) {
@ -1425,7 +1425,7 @@ void vrend_set_framebuffer_state(struct vrend_context *ctx,
int old_num; int old_num;
GLenum status; GLenum status;
GLint new_height = -1; GLint new_height = -1;
boolean new_ibf = GL_FALSE; bool new_ibf = false;
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, ctx->sub->fb_id); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, ctx->sub->fb_id);
@ -1473,10 +1473,10 @@ void vrend_set_framebuffer_state(struct vrend_context *ctx,
/* find a buffer to set fb_height from */ /* find a buffer to set fb_height from */
if (ctx->sub->nr_cbufs == 0 && !ctx->sub->zsurf) { if (ctx->sub->nr_cbufs == 0 && !ctx->sub->zsurf) {
new_height = 0; new_height = 0;
new_ibf = FALSE; new_ibf = false;
} else if (ctx->sub->nr_cbufs == 0) { } else if (ctx->sub->nr_cbufs == 0) {
new_height = u_minify(ctx->sub->zsurf->texture->base.height0, ctx->sub->zsurf->val0); new_height = u_minify(ctx->sub->zsurf->texture->base.height0, ctx->sub->zsurf->val0);
new_ibf = ctx->sub->zsurf->texture->y_0_top ? TRUE : FALSE; new_ibf = ctx->sub->zsurf->texture->y_0_top ? true : false;
} }
else { else {
surf = NULL; surf = NULL;
@ -1488,7 +1488,7 @@ void vrend_set_framebuffer_state(struct vrend_context *ctx,
} }
assert(surf); assert(surf);
new_height = u_minify(surf->texture->base.height0, surf->val0); new_height = u_minify(surf->texture->base.height0, surf->val0);
new_ibf = surf->texture->y_0_top ? TRUE : FALSE; new_ibf = surf->texture->y_0_top ? true : false;
} }
if (new_height != -1) { if (new_height != -1) {
@ -1522,7 +1522,7 @@ void vrend_set_viewport_states(struct vrend_context *ctx,
GLint x, y; GLint x, y;
GLsizei width, height; GLsizei width, height;
GLclampd near_val, far_val; GLclampd near_val, far_val;
GLboolean viewport_is_negative = (state[0].scale[1] < 0) ? GL_TRUE : GL_FALSE; bool viewport_is_negative = (state[0].scale[1] < 0) ? true : false;
GLfloat abs_s1 = fabsf(state->scale[1]); GLfloat abs_s1 = fabsf(state->scale[1]);
int i, idx; int i, idx;
@ -1697,7 +1697,7 @@ void vrend_set_constants(struct vrend_context *ctx,
int i; int i;
consts = &ctx->sub->consts[shader]; consts = &ctx->sub->consts[shader];
ctx->sub->const_dirty[shader] = TRUE; ctx->sub->const_dirty[shader] = true;
consts->consts = realloc(consts->consts, num_constant * sizeof(float)); consts->consts = realloc(consts->consts, num_constant * sizeof(float));
if (!consts->consts) if (!consts->consts)
@ -1873,7 +1873,7 @@ void vrend_set_single_sampler_view(struct vrend_context *ctx,
} }
if (tex->srgb_decode != view->srgb_decode && util_format_is_srgb(tex->base.base.format)) { if (tex->srgb_decode != view->srgb_decode && util_format_is_srgb(tex->base.base.format)) {
if (vrend_state.have_samplers) if (vrend_state.have_samplers)
ctx->sub->sampler_state_dirty = TRUE; ctx->sub->sampler_state_dirty = true;
else { else {
glTexParameteri(view->texture->target, GL_TEXTURE_SRGB_DECODE_EXT, glTexParameteri(view->texture->target, GL_TEXTURE_SRGB_DECODE_EXT,
view->srgb_decode); view->srgb_decode);
@ -1921,7 +1921,7 @@ static inline void vrend_fill_shader_key(struct vrend_context *ctx,
{ {
if (vrend_state.use_core_profile == true) { if (vrend_state.use_core_profile == true) {
int i; int i;
boolean add_alpha_test = true; bool add_alpha_test = true;
for (i = 0; i < ctx->sub->nr_cbufs; i++) { for (i = 0; i < ctx->sub->nr_cbufs; i++) {
if (!ctx->sub->surf[i]) if (!ctx->sub->surf[i])
continue; continue;
@ -1938,7 +1938,7 @@ static inline void vrend_fill_shader_key(struct vrend_context *ctx,
key->color_two_side = ctx->sub->rs_state.light_twoside; key->color_two_side = ctx->sub->rs_state.light_twoside;
key->clip_plane_enable = ctx->sub->rs_state.clip_plane_enable; key->clip_plane_enable = ctx->sub->rs_state.clip_plane_enable;
key->flatshade = ctx->sub->rs_state.flatshade ? TRUE : FALSE; key->flatshade = ctx->sub->rs_state.flatshade ? true : false;
} else { } else {
key->add_alpha_test = 0; key->add_alpha_test = 0;
key->pstipple_tex = 0; key->pstipple_tex = 0;
@ -1975,10 +1975,10 @@ static int vrend_shader_create(struct vrend_context *ctx,
} }
shader->key = key; shader->key = key;
if (1) {//shader->sel->type == PIPE_SHADER_FRAGMENT || shader->sel->type == PIPE_SHADER_GEOMETRY) { if (1) {//shader->sel->type == PIPE_SHADER_FRAGMENT || shader->sel->type == PIPE_SHADER_GEOMETRY) {
boolean ret; bool ret;
ret = vrend_compile_shader(ctx, shader); ret = vrend_compile_shader(ctx, shader);
if (ret == FALSE) { if (ret == false) {
glDeleteShader(shader->id); glDeleteShader(shader->id);
free(shader->glsl_prog); free(shader->glsl_prog);
return -1; return -1;
@ -1989,7 +1989,7 @@ static int vrend_shader_create(struct vrend_context *ctx,
static int vrend_shader_select(struct vrend_context *ctx, static int vrend_shader_select(struct vrend_context *ctx,
struct vrend_shader_selector *sel, struct vrend_shader_selector *sel,
boolean *dirty) bool *dirty)
{ {
struct vrend_shader_key key; struct vrend_shader_key key;
struct vrend_shader *shader = NULL; struct vrend_shader *shader = NULL;
@ -2462,7 +2462,7 @@ static void vrend_draw_bind_samplers(struct vrend_context *ctx)
glBindTexture(GL_TEXTURE_2D, ctx->pstipple_tex_id); glBindTexture(GL_TEXTURE_2D, ctx->pstipple_tex_id);
glUniform1i(ctx->sub->prog->fs_stipple_loc, sampler_id); glUniform1i(ctx->sub->prog->fs_stipple_loc, sampler_id);
} }
ctx->sub->sampler_state_dirty = FALSE; ctx->sub->sampler_state_dirty = false;
} }
static void vrend_draw_bind_ubo(struct vrend_context *ctx) static void vrend_draw_bind_ubo(struct vrend_context *ctx)
@ -2503,7 +2503,7 @@ void vrend_draw_vbo(struct vrend_context *ctx,
uint32_t cso) uint32_t cso)
{ {
int i; int i;
bool new_program = FALSE; bool new_program = false;
uint32_t shader_type; uint32_t shader_type;
if (ctx->in_error) if (ctx->in_error)
@ -2525,8 +2525,8 @@ void vrend_draw_vbo(struct vrend_context *ctx,
if (ctx->sub->shader_dirty) { if (ctx->sub->shader_dirty) {
struct vrend_linked_shader_program *prog; struct vrend_linked_shader_program *prog;
boolean fs_dirty, vs_dirty, gs_dirty; bool fs_dirty, vs_dirty, gs_dirty;
boolean dual_src = util_blend_state_is_dual(&ctx->sub->blend_state, 0); bool dual_src = util_blend_state_is_dual(&ctx->sub->blend_state, 0);
if (!ctx->sub->vs || !ctx->sub->fs) { if (!ctx->sub->vs || !ctx->sub->fs) {
fprintf(stderr,"dropping rendering due to missing shaders: %s\n", ctx->debug_name); fprintf(stderr,"dropping rendering due to missing shaders: %s\n", ctx->debug_name);
return; return;
@ -2548,7 +2548,7 @@ void vrend_draw_vbo(struct vrend_context *ctx,
return; return;
} }
if (ctx->sub->prog != prog) { if (ctx->sub->prog != prog) {
new_program = TRUE; new_program = true;
ctx->sub->prog = prog; ctx->sub->prog = prog;
} }
} }
@ -2571,7 +2571,7 @@ void vrend_draw_vbo(struct vrend_context *ctx,
if (ctx->sub->prog->const_locs[shader_type][i] != -1 && ctx->sub->consts[shader_type].consts) if (ctx->sub->prog->const_locs[shader_type][i] != -1 && ctx->sub->consts[shader_type].consts)
glUniform4uiv(ctx->sub->prog->const_locs[shader_type][i], 1, &ctx->sub->consts[shader_type].consts[i * 4]); glUniform4uiv(ctx->sub->prog->const_locs[shader_type][i], 1, &ctx->sub->consts[shader_type].consts[i * 4]);
} }
ctx->sub->const_dirty[shader_type] = FALSE; ctx->sub->const_dirty[shader_type] = false;
} }
} }
@ -2585,7 +2585,6 @@ void vrend_draw_vbo(struct vrend_context *ctx,
} }
glUniform4f(ctx->sub->prog->vs_ws_adjust_loc, 0.0, ctx->sub->viewport_is_negative ? -1.0 : 1.0, ctx->sub->depth_scale, ctx->sub->depth_transform); glUniform4f(ctx->sub->prog->vs_ws_adjust_loc, 0.0, ctx->sub->viewport_is_negative ? -1.0 : 1.0, ctx->sub->depth_scale, ctx->sub->depth_transform);
if (ctx->sub->rs_state.clip_plane_enable) { if (ctx->sub->rs_state.clip_plane_enable) {
for (i = 0 ; i < 8; i++) { for (i = 0 ; i < 8; i++) {
glUniform4fv(ctx->sub->prog->clip_locs[i], 1, (const GLfloat *)&ctx->sub->ucp_state.ucp[i]); glUniform4fv(ctx->sub->prog->clip_locs[i], 1, (const GLfloat *)&ctx->sub->ucp_state.ucp[i]);
@ -2781,7 +2780,7 @@ translate_stencil_op(GLuint op)
#undef CASE #undef CASE
} }
static inline boolean is_dst_blend(int blend_factor) static inline bool is_dst_blend(int blend_factor)
{ {
return (blend_factor == PIPE_BLENDFACTOR_DST_ALPHA || return (blend_factor == PIPE_BLENDFACTOR_DST_ALPHA ||
blend_factor == PIPE_BLENDFACTOR_INV_DST_ALPHA); blend_factor == PIPE_BLENDFACTOR_INV_DST_ALPHA);
@ -2895,10 +2894,10 @@ static void vrend_hw_emit_blend(struct vrend_context *ctx)
translate_blend_factor(state->rt[0].alpha_dst_factor)); translate_blend_factor(state->rt[0].alpha_dst_factor));
glBlendEquationSeparate(translate_blend_func(state->rt[0].rgb_func), glBlendEquationSeparate(translate_blend_func(state->rt[0].rgb_func),
translate_blend_func(state->rt[0].alpha_func)); translate_blend_func(state->rt[0].alpha_func));
vrend_blend_enable(ctx, GL_TRUE); vrend_blend_enable(ctx, true);
} }
else else
vrend_blend_enable(ctx, GL_FALSE); vrend_blend_enable(ctx, false);
if (state->rt[0].colormask != ctx->sub->hw_blend_state.rt[0].colormask) { if (state->rt[0].colormask != ctx->sub->hw_blend_state.rt[0].colormask) {
int i; int i;
@ -2931,7 +2930,7 @@ void vrend_object_bind_blend(struct vrend_context *ctx,
if (handle == 0) { if (handle == 0) {
memset(&ctx->sub->blend_state, 0, sizeof(ctx->sub->blend_state)); memset(&ctx->sub->blend_state, 0, sizeof(ctx->sub->blend_state));
vrend_blend_enable(ctx, GL_FALSE); vrend_blend_enable(ctx, false);
return; return;
} }
state = vrend_object_lookup(ctx->sub->object_hash, handle, VIRGL_OBJECT_BLEND); state = vrend_object_lookup(ctx->sub->object_hash, handle, VIRGL_OBJECT_BLEND);
@ -2950,21 +2949,21 @@ static void vrend_hw_emit_dsa(struct vrend_context *ctx)
struct pipe_depth_stencil_alpha_state *state = &ctx->sub->dsa_state; struct pipe_depth_stencil_alpha_state *state = &ctx->sub->dsa_state;
if (state->depth.enabled) { if (state->depth.enabled) {
vrend_depth_test_enable(ctx, GL_TRUE); vrend_depth_test_enable(ctx, true);
glDepthFunc(GL_NEVER + state->depth.func); glDepthFunc(GL_NEVER + state->depth.func);
if (state->depth.writemask) if (state->depth.writemask)
glDepthMask(GL_TRUE); glDepthMask(GL_TRUE);
else else
glDepthMask(GL_FALSE); glDepthMask(GL_FALSE);
} else } else
vrend_depth_test_enable(ctx, GL_FALSE); vrend_depth_test_enable(ctx, false);
if (state->alpha.enabled) { if (state->alpha.enabled) {
vrend_alpha_test_enable(ctx, GL_TRUE); vrend_alpha_test_enable(ctx, true);
if (!vrend_state.use_core_profile) if (!vrend_state.use_core_profile)
glAlphaFunc(GL_NEVER + state->alpha.func, state->alpha.ref_value); glAlphaFunc(GL_NEVER + state->alpha.func, state->alpha.ref_value);
} else } else
vrend_alpha_test_enable(ctx, GL_FALSE); vrend_alpha_test_enable(ctx, false);
} }
@ -2976,8 +2975,8 @@ void vrend_object_bind_dsa(struct vrend_context *ctx,
if (handle == 0) { if (handle == 0) {
memset(&ctx->sub->dsa_state, 0, sizeof(ctx->sub->dsa_state)); memset(&ctx->sub->dsa_state, 0, sizeof(ctx->sub->dsa_state));
ctx->sub->dsa = NULL; ctx->sub->dsa = NULL;
ctx->sub->stencil_state_dirty = TRUE; ctx->sub->stencil_state_dirty = true;
ctx->sub->shader_dirty = TRUE; ctx->sub->shader_dirty = true;
vrend_hw_emit_dsa(ctx); vrend_hw_emit_dsa(ctx);
return; return;
} }
@ -2989,8 +2988,8 @@ void vrend_object_bind_dsa(struct vrend_context *ctx,
} }
if (ctx->sub->dsa != state) { if (ctx->sub->dsa != state) {
ctx->sub->stencil_state_dirty = TRUE; ctx->sub->stencil_state_dirty = true;
ctx->sub->shader_dirty = TRUE; ctx->sub->shader_dirty = true;
} }
ctx->sub->dsa_state = *state; ctx->sub->dsa_state = *state;
ctx->sub->dsa = state; ctx->sub->dsa = state;
@ -3019,7 +3018,7 @@ void vrend_update_stencil_state(struct vrend_context *ctx)
if (!state->stencil[1].enabled) { if (!state->stencil[1].enabled) {
if (state->stencil[0].enabled) { if (state->stencil[0].enabled) {
vrend_stencil_test_enable(ctx, GL_TRUE); vrend_stencil_test_enable(ctx, true);
glStencilOp(translate_stencil_op(state->stencil[0].fail_op), glStencilOp(translate_stencil_op(state->stencil[0].fail_op),
translate_stencil_op(state->stencil[0].zfail_op), translate_stencil_op(state->stencil[0].zfail_op),
@ -3030,9 +3029,9 @@ void vrend_update_stencil_state(struct vrend_context *ctx)
state->stencil[0].valuemask); state->stencil[0].valuemask);
glStencilMask(state->stencil[0].writemask); glStencilMask(state->stencil[0].writemask);
} else } else
vrend_stencil_test_enable(ctx, GL_FALSE); vrend_stencil_test_enable(ctx, false);
} else { } else {
vrend_stencil_test_enable(ctx, GL_TRUE); vrend_stencil_test_enable(ctx, true);
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
GLenum face = (i == 1) ? GL_BACK : GL_FRONT; GLenum face = (i == 1) ? GL_BACK : GL_FRONT;
@ -3047,7 +3046,7 @@ void vrend_update_stencil_state(struct vrend_context *ctx)
glStencilMaskSeparate(face, state->stencil[i].writemask); glStencilMaskSeparate(face, state->stencil[i].writemask);
} }
} }
ctx->sub->stencil_state_dirty = FALSE; ctx->sub->stencil_state_dirty = false;
} }
static inline GLenum translate_fill(uint32_t mode) static inline GLenum translate_fill(uint32_t mode)
@ -3251,7 +3250,7 @@ void vrend_object_bind_rasterizer(struct vrend_context *ctx,
ctx->sub->rs_state = *state; ctx->sub->rs_state = *state;
ctx->sub->scissor_state_dirty = (1 << 0); ctx->sub->scissor_state_dirty = (1 << 0);
ctx->sub->shader_dirty = TRUE; ctx->sub->shader_dirty = true;
vrend_hw_emit_rs(ctx); vrend_hw_emit_rs(ctx);
} }
@ -3274,7 +3273,7 @@ void vrend_bind_sampler_states(struct vrend_context *ctx,
ctx->sub->sampler_state[shader_type][i + start_slot] = state; ctx->sub->sampler_state[shader_type][i + start_slot] = state;
} }
ctx->sub->sampler_state_dirty = TRUE; ctx->sub->sampler_state_dirty = true;
} }
@ -3289,7 +3288,7 @@ static void vrend_apply_sampler_state(struct vrend_context *ctx,
struct vrend_texture *tex = (struct vrend_texture *)res; struct vrend_texture *tex = (struct vrend_texture *)res;
struct vrend_sampler_state *vstate = ctx->sub->sampler_state[shader_type][id]; struct vrend_sampler_state *vstate = ctx->sub->sampler_state[shader_type][id];
struct pipe_sampler_state *state = &vstate->base; struct pipe_sampler_state *state = &vstate->base;
bool set_all = FALSE; bool set_all = false;
GLenum target = tex->base.target; GLenum target = tex->base.target;
if (!state) { if (!state) {
@ -3314,7 +3313,7 @@ static void vrend_apply_sampler_state(struct vrend_context *ctx,
} }
if (tex->state.max_lod == -1) if (tex->state.max_lod == -1)
set_all = TRUE; set_all = true;
if (tex->state.wrap_s != state->wrap_s || set_all) if (tex->state.wrap_s != state->wrap_s || set_all)
glTexParameteri(target, GL_TEXTURE_WRAP_S, convert_wrap(state->wrap_s)); glTexParameteri(target, GL_TEXTURE_WRAP_S, convert_wrap(state->wrap_s));
@ -3412,27 +3411,27 @@ void vrend_renderer_init(struct vrend_if_cbs *cbs)
} }
if (epoxy_has_gl_extension("GL_ARB_robustness")) if (epoxy_has_gl_extension("GL_ARB_robustness"))
vrend_state.have_robustness = TRUE; vrend_state.have_robustness = true;
else else
fprintf(stderr,"WARNING: running without ARB robustness in place may crash\n"); fprintf(stderr,"WARNING: running without ARB robustness in place may crash\n");
if (epoxy_has_gl_extension("GL_MESA_pack_invert")) if (epoxy_has_gl_extension("GL_MESA_pack_invert"))
vrend_state.have_mesa_invert = TRUE; vrend_state.have_mesa_invert = true;
if (gl_ver >= 43 || epoxy_has_gl_extension("GL_ARB_vertex_attrib_binding")) if (gl_ver >= 43 || epoxy_has_gl_extension("GL_ARB_vertex_attrib_binding"))
vrend_state.have_vertex_attrib_binding = TRUE; vrend_state.have_vertex_attrib_binding = true;
if (gl_ver >= 33 || epoxy_has_gl_extension("GL_ARB_sampler_objects")) if (gl_ver >= 33 || epoxy_has_gl_extension("GL_ARB_sampler_objects"))
vrend_state.have_samplers = TRUE; vrend_state.have_samplers = true;
if (gl_ver >= 33 || epoxy_has_gl_extension("GL_ARB_shader_bit_encoding")) if (gl_ver >= 33 || epoxy_has_gl_extension("GL_ARB_shader_bit_encoding"))
vrend_state.have_bit_encoding = TRUE; vrend_state.have_bit_encoding = true;
if (gl_ver >= 31) if (gl_ver >= 31)
vrend_state.have_gl_prim_restart = TRUE; vrend_state.have_gl_prim_restart = true;
else if (epoxy_has_gl_extension("GL_NV_primitive_restart")) else if (epoxy_has_gl_extension("GL_NV_primitive_restart"))
vrend_state.have_nv_prim_restart = TRUE; vrend_state.have_nv_prim_restart = true;
if (epoxy_has_gl_extension("GL_EXT_framebuffer_multisample") && epoxy_has_gl_extension("GL_ARB_texture_multisample")) { if (epoxy_has_gl_extension("GL_EXT_framebuffer_multisample") && epoxy_has_gl_extension("GL_ARB_texture_multisample")) {
vrend_state.have_multisample = true; vrend_state.have_multisample = true;
if (epoxy_has_gl_extension("GL_EXT_framebuffer_multisample_blit_scaled")) if (epoxy_has_gl_extension("GL_EXT_framebuffer_multisample_blit_scaled"))
vrend_state.have_ms_scaled_blit = TRUE; vrend_state.have_ms_scaled_blit = true;
} }
/* callbacks for when we are cleaning up the object table */ /* callbacks for when we are cleaning up the object table */
@ -3717,7 +3716,7 @@ int vrend_renderer_resource_create(struct vrend_renderer_resource_create_args *a
gr->base.array_size = args->array_size; gr->base.array_size = args->array_size;
if (args->flags & VIRGL_RESOURCE_Y_0_TOP) if (args->flags & VIRGL_RESOURCE_Y_0_TOP)
gr->y_0_top = TRUE; gr->y_0_top = true;
pipe_reference_init(&gr->base.reference, 1); pipe_reference_init(&gr->base.reference, 1);
@ -3785,11 +3784,11 @@ int vrend_renderer_resource_create(struct vrend_renderer_resource_create_args *a
if (gr->target == GL_TEXTURE_2D_MULTISAMPLE) { if (gr->target == GL_TEXTURE_2D_MULTISAMPLE) {
glTexImage2DMultisample(gr->target, args->nr_samples, glTexImage2DMultisample(gr->target, args->nr_samples,
internalformat, args->width, args->height, internalformat, args->width, args->height,
TRUE); GL_TRUE);
} else { } else {
glTexImage3DMultisample(gr->target, args->nr_samples, glTexImage3DMultisample(gr->target, args->nr_samples,
internalformat, args->width, args->height, args->array_size, internalformat, args->width, args->height, args->array_size,
TRUE); GL_TRUE);
} }
} else if (gr->target == GL_TEXTURE_CUBE_MAP) { } else if (gr->target == GL_TEXTURE_CUBE_MAP) {
@ -3844,9 +3843,6 @@ int vrend_renderer_resource_create(struct vrend_renderer_resource_create_args *a
void vrend_renderer_resource_destroy(struct vrend_resource *res, bool remove) void vrend_renderer_resource_destroy(struct vrend_resource *res, bool remove)
{ {
// if (res->scannedout) TODO
// (*vrend_clicbs->scanout_resource_info)(0, res->id, 0, 0, 0, 0, 0);
if (res->readback_fb_id) if (res->readback_fb_id)
glDeleteFramebuffers(1, &res->readback_fb_id); glDeleteFramebuffers(1, &res->readback_fb_id);
@ -4094,7 +4090,7 @@ static int vrend_renderer_transfer_write_iov(struct vrend_context *ctx,
int need_temp = 0; int need_temp = 0;
int elsize = util_format_get_blocksize(res->base.format); int elsize = util_format_get_blocksize(res->base.format);
int x = 0, y = 0; int x = 0, y = 0;
boolean compressed; bool compressed;
bool invert = false; bool invert = false;
float depth_scale; float depth_scale;
GLuint send_size = 0; GLuint send_size = 0;
@ -4168,10 +4164,10 @@ static int vrend_renderer_transfer_write_iov(struct vrend_context *ctx,
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, res->readback_fb_id); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, res->readback_fb_id);
} }
glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT); glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
vrend_blend_enable(ctx, GL_FALSE); vrend_blend_enable(ctx, false);
vrend_depth_test_enable(ctx, GL_FALSE); vrend_depth_test_enable(ctx, false);
vrend_alpha_test_enable(ctx, GL_FALSE); vrend_alpha_test_enable(ctx, false);
vrend_stencil_test_enable(ctx, GL_FALSE); vrend_stencil_test_enable(ctx, false);
glPixelZoom(1.0f, res->y_0_top ? -1.0f : 1.0f); glPixelZoom(1.0f, res->y_0_top ? -1.0f : 1.0f);
glWindowPos2i(info->box->x, res->y_0_top ? res->base.height0 - info->box->y : info->box->y); glWindowPos2i(info->box->x, res->y_0_top ? res->base.height0 - info->box->y : info->box->y);
glDrawPixels(info->box->width, info->box->height, glformat, gltype, glDrawPixels(info->box->width, info->box->height, glformat, gltype,
@ -4347,7 +4343,7 @@ static int vrend_transfer_send_readpixels(struct vrend_context *ctx,
int need_temp = 0; int need_temp = 0;
GLuint fb_id; GLuint fb_id;
void *data; void *data;
boolean actually_invert, separate_invert = FALSE; bool actually_invert, separate_invert = false;
GLenum format, type; GLenum format, type;
GLint y1; GLint y1;
uint32_t send_size = 0; uint32_t send_size = 0;
@ -4364,7 +4360,7 @@ static int vrend_transfer_send_readpixels(struct vrend_context *ctx,
actually_invert = res->y_0_top; actually_invert = res->y_0_top;
if (actually_invert && !vrend_state.have_mesa_invert) if (actually_invert && !vrend_state.have_mesa_invert)
separate_invert = TRUE; separate_invert = true;
if (num_iovs > 1 || separate_invert) if (num_iovs > 1 || separate_invert)
need_temp = 1; need_temp = 1;
@ -4485,7 +4481,7 @@ static int vrend_renderer_transfer_send_iov(struct vrend_context *ctx,
vrend_transfer_write_return(data, send_size, info->offset, iov, num_iovs); vrend_transfer_write_return(data, send_size, info->offset, iov, num_iovs);
glUnmapBuffer(res->target); glUnmapBuffer(res->target);
} else { } else {
boolean can_readpixels = TRUE; bool can_readpixels = true;
can_readpixels = vrend_format_can_render(res->base.format) || vrend_format_is_ds(res->base.format); can_readpixels = vrend_format_can_render(res->base.format) || vrend_format_is_ds(res->base.format);
@ -4547,7 +4543,7 @@ int vrend_renderer_transfer_iov(const struct vrend_transfer_info *info,
if (!check_iov_bounds(res, info, iov, num_iovs)) if (!check_iov_bounds(res, info, iov, num_iovs))
return EINVAL; return EINVAL;
vrend_hw_switch_context(vrend_lookup_renderer_ctx(0), TRUE); vrend_hw_switch_context(vrend_lookup_renderer_ctx(0), true);
if (transfer_mode == VREND_TRANSFER_WRITE) if (transfer_mode == VREND_TRANSFER_WRITE)
return vrend_renderer_transfer_write_iov(ctx, res, iov, num_iovs, return vrend_renderer_transfer_write_iov(ctx, res, iov, num_iovs,
@ -4590,7 +4586,7 @@ void vrend_set_stencil_ref(struct vrend_context *ctx,
ctx->sub->stencil_refs[1] != ref->ref_value[1]) { ctx->sub->stencil_refs[1] != ref->ref_value[1]) {
ctx->sub->stencil_refs[0] = ref->ref_value[0]; ctx->sub->stencil_refs[0] = ref->ref_value[0];
ctx->sub->stencil_refs[1] = ref->ref_value[1]; ctx->sub->stencil_refs[1] = ref->ref_value[1];
ctx->sub->stencil_state_dirty = TRUE; ctx->sub->stencil_state_dirty = true;
} }
} }
@ -5145,7 +5141,7 @@ void vrend_renderer_check_fences(void)
vrend_clicbs->write_fence(latest_id); vrend_clicbs->write_fence(latest_id);
} }
static boolean vrend_get_one_query_result(GLuint query_id, bool use_64, uint64_t *result) static bool vrend_get_one_query_result(GLuint query_id, bool use_64, uint64_t *result)
{ {
GLint ready; GLint ready;
GLuint passed; GLuint passed;
@ -5154,7 +5150,7 @@ static boolean vrend_get_one_query_result(GLuint query_id, bool use_64, uint64_t
glGetQueryObjectiv(query_id, GL_QUERY_RESULT_AVAILABLE_ARB, &ready); glGetQueryObjectiv(query_id, GL_QUERY_RESULT_AVAILABLE_ARB, &ready);
if (!ready) if (!ready)
return FALSE; return false;
if (use_64) { if (use_64) {
glGetQueryObjectui64v(query_id, GL_QUERY_RESULT_ARB, &pass64); glGetQueryObjectui64v(query_id, GL_QUERY_RESULT_ARB, &pass64);
@ -5163,23 +5159,23 @@ static boolean vrend_get_one_query_result(GLuint query_id, bool use_64, uint64_t
glGetQueryObjectuiv(query_id, GL_QUERY_RESULT_ARB, &passed); glGetQueryObjectuiv(query_id, GL_QUERY_RESULT_ARB, &passed);
*result = passed; *result = passed;
} }
return TRUE; return true;
} }
static boolean vrend_check_query(struct vrend_query *query) static bool vrend_check_query(struct vrend_query *query)
{ {
uint64_t result; uint64_t result;
struct virgl_host_query_state *state; struct virgl_host_query_state *state;
boolean ret; bool ret;
ret = vrend_get_one_query_result(query->id, FALSE, &result); ret = vrend_get_one_query_result(query->id, false, &result);
if (ret == FALSE) if (ret == false)
return FALSE; return false;
state = query->res->ptr; state = query->res->ptr;
state->result = result; state->result = result;
state->query_state = VIRGL_QUERY_STATE_DONE; state->query_state = VIRGL_QUERY_STATE_DONE;
return TRUE; return true;
} }
void vrend_renderer_check_queries(void) void vrend_renderer_check_queries(void)
@ -5190,34 +5186,34 @@ void vrend_renderer_check_queries(void)
return; return;
LIST_FOR_EACH_ENTRY_SAFE(query, stor, &vrend_state.waiting_query_list, waiting_queries) { LIST_FOR_EACH_ENTRY_SAFE(query, stor, &vrend_state.waiting_query_list, waiting_queries) {
vrend_hw_switch_context(vrend_lookup_renderer_ctx(query->ctx_id), TRUE); vrend_hw_switch_context(vrend_lookup_renderer_ctx(query->ctx_id), true);
if (vrend_check_query(query) == TRUE) if (vrend_check_query(query))
list_delinit(&query->waiting_queries); list_delinit(&query->waiting_queries);
} }
} }
boolean vrend_hw_switch_context(struct vrend_context *ctx, boolean now) bool vrend_hw_switch_context(struct vrend_context *ctx, bool now)
{ {
if (ctx == vrend_state.current_ctx && ctx->ctx_switch_pending == FALSE) if (ctx == vrend_state.current_ctx && ctx->ctx_switch_pending == false)
return TRUE; return true;
if (ctx->ctx_id != 0 && ctx->in_error) { if (ctx->ctx_id != 0 && ctx->in_error) {
return FALSE; return false;
} }
ctx->ctx_switch_pending = TRUE; ctx->ctx_switch_pending = true;
if (now == TRUE) { if (now == true) {
vrend_finish_context_switch(ctx); vrend_finish_context_switch(ctx);
} }
vrend_state.current_ctx = ctx; vrend_state.current_ctx = ctx;
return TRUE; return true;
} }
static void vrend_finish_context_switch(struct vrend_context *ctx) static void vrend_finish_context_switch(struct vrend_context *ctx)
{ {
if (ctx->ctx_switch_pending == FALSE) if (ctx->ctx_switch_pending == false)
return; return;
ctx->ctx_switch_pending = FALSE; ctx->ctx_switch_pending = false;
if (vrend_state.current_hw_ctx == ctx) if (vrend_state.current_hw_ctx == ctx)
return; return;
@ -5349,20 +5345,20 @@ void vrend_get_query_result(struct vrend_context *ctx, uint32_t handle,
uint32_t wait) uint32_t wait)
{ {
struct vrend_query *q; struct vrend_query *q;
boolean ret; bool ret;
q = vrend_object_lookup(ctx->sub->object_hash, handle, VIRGL_OBJECT_QUERY); q = vrend_object_lookup(ctx->sub->object_hash, handle, VIRGL_OBJECT_QUERY);
if (!q) if (!q)
return; return;
ret = vrend_check_query(q); ret = vrend_check_query(q);
if (ret == FALSE) if (ret == false)
list_addtail(&q->waiting_queries, &vrend_state.waiting_query_list); list_addtail(&q->waiting_queries, &vrend_state.waiting_query_list);
} }
void vrend_render_condition(struct vrend_context *ctx, void vrend_render_condition(struct vrend_context *ctx,
uint32_t handle, uint32_t handle,
boolean condtion, bool condition,
uint mode) uint mode)
{ {
struct vrend_query *q; struct vrend_query *q;
@ -5684,7 +5680,7 @@ void vrend_renderer_force_ctx_0(void)
struct vrend_context *ctx0 = vrend_lookup_renderer_ctx(0); struct vrend_context *ctx0 = vrend_lookup_renderer_ctx(0);
vrend_state.current_ctx = NULL; vrend_state.current_ctx = NULL;
vrend_state.current_hw_ctx = NULL; vrend_state.current_hw_ctx = NULL;
vrend_hw_switch_context(ctx0, TRUE); vrend_hw_switch_context(ctx0, true);
vrend_clicbs->make_current(0, ctx0->sub->gl_context); vrend_clicbs->make_current(0, ctx0->sub->gl_context);
} }

7
src/vrend_renderer.h
Unescape View File

@ -56,9 +56,8 @@ struct vrend_resource {
struct iovec *iov; struct iovec *iov;
uint32_t num_iovs; uint32_t num_iovs;
boolean y_0_top; bool y_0_top;
boolean scannedout;
GLuint tbo_tex_id;/* tbos have two ids to track */ GLuint tbo_tex_id;/* tbos have two ids to track */
}; };
@ -302,7 +301,7 @@ int vrend_renderer_create_fence(int client_fence_id, uint32_t ctx_id);
void vrend_renderer_check_fences(void); void vrend_renderer_check_fences(void);
void vrend_renderer_check_queries(void); void vrend_renderer_check_queries(void);
boolean vrend_hw_switch_context(struct vrend_context *ctx, boolean now); bool vrend_hw_switch_context(struct vrend_context *ctx, bool now);
uint32_t vrend_renderer_object_insert(struct vrend_context *ctx, void *data, uint32_t vrend_renderer_object_insert(struct vrend_context *ctx, void *data,
uint32_t size, uint32_t handle, enum virgl_object_type type); uint32_t size, uint32_t handle, enum virgl_object_type type);
void vrend_renderer_object_destroy(struct vrend_context *ctx, uint32_t handle); void vrend_renderer_object_destroy(struct vrend_context *ctx, uint32_t handle);
@ -317,7 +316,7 @@ void vrend_get_query_result(struct vrend_context *ctx, uint32_t handle,
uint32_t wait); uint32_t wait);
void vrend_render_condition(struct vrend_context *ctx, void vrend_render_condition(struct vrend_context *ctx,
uint32_t handle, uint32_t handle,
boolean condtion, bool condtion,
uint mode); uint mode);
void *vrend_renderer_get_cursor_contents(uint32_t res_handle, uint32_t *width, uint32_t *height); void *vrend_renderer_get_cursor_contents(uint32_t res_handle, uint32_t *width, uint32_t *height);
void vrend_bind_va(GLuint vaoid); void vrend_bind_va(GLuint vaoid);

205
src/vrend_shader.c
Unescape View File

@ -50,13 +50,13 @@ struct vrend_shader_io {
unsigned done; unsigned done;
int sid; int sid;
unsigned interpolate; unsigned interpolate;
boolean centroid; bool centroid;
unsigned first; unsigned first;
boolean glsl_predefined_no_emit; bool glsl_predefined_no_emit;
boolean glsl_no_index; bool glsl_no_index;
boolean glsl_gl_in; bool glsl_gl_in;
boolean override_no_wm; bool override_no_wm;
boolean is_int; bool is_int;
char glsl_name[64]; char glsl_name[64];
}; };
@ -117,14 +117,14 @@ struct dump_ctx {
/* create a shader with lower left if upper left is primary variant /* create a shader with lower left if upper left is primary variant
or vice versa */ or vice versa */
uint32_t shadow_samp_mask; uint32_t shadow_samp_mask;
boolean write_all_cbufs; bool write_all_cbufs;
int fs_coord_origin, fs_pixel_center; int fs_coord_origin, fs_pixel_center;
int gs_in_prim, gs_out_prim, gs_max_out_verts; int gs_in_prim, gs_out_prim, gs_max_out_verts;
struct vrend_shader_key *key; struct vrend_shader_key *key;
boolean has_ints; bool has_ints;
boolean has_instanceid; bool has_instanceid;
int indent_level; int indent_level;
int num_in_clip_dist; int num_in_clip_dist;
int num_clip_dist; int num_clip_dist;
@ -173,17 +173,17 @@ static inline int gs_input_prim_to_size(int prim)
}; };
} }
static inline boolean fs_emit_layout(struct dump_ctx *ctx) static inline bool fs_emit_layout(struct dump_ctx *ctx)
{ {
if (ctx->fs_pixel_center) if (ctx->fs_pixel_center)
return TRUE; return true;
/* if coord origin is 0 and invert is 0 - emit origin_upper_left, /* if coord origin is 0 and invert is 0 - emit origin_upper_left,
if coord_origin is 0 and invert is 1 - emit nothing (lower) if coord_origin is 0 and invert is 1 - emit nothing (lower)
if coord origin is 1 and invert is 0 - emit nothing (lower) if coord origin is 1 and invert is 0 - emit nothing (lower)
if coord_origin is 1 and invert is 1 - emit origin upper left */ if coord_origin is 1 and invert is 1 - emit origin upper left */
if (!(ctx->fs_coord_origin ^ ctx->key->invert_fs_origin)) if (!(ctx->fs_coord_origin ^ ctx->key->invert_fs_origin))
return TRUE; return true;
return FALSE; return false;
} }
static char *strcat_realloc(char *str, const char *catstr) static char *strcat_realloc(char *str, const char *catstr)
@ -218,10 +218,10 @@ iter_declaration(struct tgsi_iterate_context *iter,
ctx->inputs[i].sid = decl->Semantic.Index; ctx->inputs[i].sid = decl->Semantic.Index;
ctx->inputs[i].interpolate = decl->Interp.Interpolate; ctx->inputs[i].interpolate = decl->Interp.Interpolate;
ctx->inputs[i].first = decl->Range.First; ctx->inputs[i].first = decl->Range.First;
ctx->inputs[i].glsl_predefined_no_emit = FALSE; ctx->inputs[i].glsl_predefined_no_emit = false;
ctx->inputs[i].glsl_no_index = FALSE; ctx->inputs[i].glsl_no_index = false;
ctx->inputs[i].override_no_wm = FALSE; ctx->inputs[i].override_no_wm = false;
ctx->inputs[i].glsl_gl_in = FALSE; ctx->inputs[i].glsl_gl_in = false;
switch (ctx->inputs[i].name) { switch (ctx->inputs[i].name) {
case TGSI_SEMANTIC_COLOR: case TGSI_SEMANTIC_COLOR:
@ -233,7 +233,7 @@ iter_declaration(struct tgsi_iterate_context *iter,
name_prefix = "gl_SecondaryColor"; name_prefix = "gl_SecondaryColor";
else else
fprintf(stderr, "got illegal color semantic index %d\n", decl->Semantic.Index); fprintf(stderr, "got illegal color semantic index %d\n", decl->Semantic.Index);
ctx->inputs[i].glsl_no_index = TRUE; ctx->inputs[i].glsl_no_index = true;
} else { } else {
if (ctx->key->color_two_side) { if (ctx->key->color_two_side) {
int j = ctx->num_inputs++; int j = ctx->num_inputs++;
@ -241,9 +241,9 @@ iter_declaration(struct tgsi_iterate_context *iter,
ctx->inputs[j].sid = decl->Semantic.Index; ctx->inputs[j].sid = decl->Semantic.Index;
ctx->inputs[j].interpolate = decl->Interp.Interpolate; ctx->inputs[j].interpolate = decl->Interp.Interpolate;
ctx->inputs[j].first = decl->Range.First; ctx->inputs[j].first = decl->Range.First;
ctx->inputs[j].glsl_predefined_no_emit = FALSE; ctx->inputs[j].glsl_predefined_no_emit = false;
ctx->inputs[j].glsl_no_index = FALSE; ctx->inputs[j].glsl_no_index = false;
ctx->inputs[j].override_no_wm = FALSE; ctx->inputs[j].override_no_wm = false;
ctx->color_in_mask |= (1 << decl->Semantic.Index); ctx->color_in_mask |= (1 << decl->Semantic.Index);
@ -254,9 +254,9 @@ iter_declaration(struct tgsi_iterate_context *iter,
ctx->inputs[k].interpolate = 0; ctx->inputs[k].interpolate = 0;
ctx->inputs[k].centroid = 0; ctx->inputs[k].centroid = 0;
ctx->inputs[k].first = 0; ctx->inputs[k].first = 0;
ctx->inputs[k].override_no_wm = FALSE; ctx->inputs[k].override_no_wm = false;
ctx->inputs[k].glsl_predefined_no_emit = TRUE; ctx->inputs[k].glsl_predefined_no_emit = true;
ctx->inputs[k].glsl_no_index = TRUE; ctx->inputs[k].glsl_no_index = true;
} }
add_two_side = true; add_two_side = true;
} }
@ -268,53 +268,53 @@ iter_declaration(struct tgsi_iterate_context *iter,
case TGSI_SEMANTIC_PRIMID: case TGSI_SEMANTIC_PRIMID:
if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) { if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) {
name_prefix = "gl_PrimitiveIDIn"; name_prefix = "gl_PrimitiveIDIn";
ctx->inputs[i].glsl_predefined_no_emit = TRUE; ctx->inputs[i].glsl_predefined_no_emit = true;
ctx->inputs[i].glsl_no_index = TRUE; ctx->inputs[i].glsl_no_index = true;
ctx->inputs[i].override_no_wm = TRUE; ctx->inputs[i].override_no_wm = true;
ctx->has_ints = TRUE; ctx->has_ints = true;
break; break;
} else if (iter->processor.Processor == TGSI_PROCESSOR_FRAGMENT) { } else if (iter->processor.Processor == TGSI_PROCESSOR_FRAGMENT) {
name_prefix = "gl_PrimitiveID"; name_prefix = "gl_PrimitiveID";
ctx->inputs[i].glsl_predefined_no_emit = TRUE; ctx->inputs[i].glsl_predefined_no_emit = true;
ctx->inputs[i].glsl_no_index = TRUE; ctx->inputs[i].glsl_no_index = true;
ctx->glsl_ver_required = 150; ctx->glsl_ver_required = 150;
break; break;
} }
case TGSI_SEMANTIC_PSIZE: case TGSI_SEMANTIC_PSIZE:
if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) { if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) {
name_prefix = "gl_PointSize"; name_prefix = "gl_PointSize";
ctx->inputs[i].glsl_predefined_no_emit = TRUE; ctx->inputs[i].glsl_predefined_no_emit = true;
ctx->inputs[i].glsl_no_index = TRUE; ctx->inputs[i].glsl_no_index = true;
ctx->inputs[i].override_no_wm = TRUE; ctx->inputs[i].override_no_wm = true;
ctx->inputs[i].glsl_gl_in = TRUE; ctx->inputs[i].glsl_gl_in = true;
break; break;
} }
case TGSI_SEMANTIC_CLIPDIST: case TGSI_SEMANTIC_CLIPDIST:
if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) { if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) {
name_prefix = "gl_ClipDistance"; name_prefix = "gl_ClipDistance";
ctx->inputs[i].glsl_predefined_no_emit = TRUE; ctx->inputs[i].glsl_predefined_no_emit = true;
ctx->inputs[i].glsl_no_index = TRUE; ctx->inputs[i].glsl_no_index = true;
ctx->inputs[i].glsl_gl_in = TRUE; ctx->inputs[i].glsl_gl_in = true;
ctx->num_in_clip_dist += 4; ctx->num_in_clip_dist += 4;
break; break;
} else if (iter->processor.Processor == TGSI_PROCESSOR_FRAGMENT) { } else if (iter->processor.Processor == TGSI_PROCESSOR_FRAGMENT) {
name_prefix = "gl_ClipDistance"; name_prefix = "gl_ClipDistance";
ctx->inputs[i].glsl_predefined_no_emit = TRUE; ctx->inputs[i].glsl_predefined_no_emit = true;
ctx->inputs[i].glsl_no_index = TRUE; ctx->inputs[i].glsl_no_index = true;
ctx->num_in_clip_dist += 4; ctx->num_in_clip_dist += 4;
break; break;
} }
case TGSI_SEMANTIC_POSITION: case TGSI_SEMANTIC_POSITION:
if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) { if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) {
name_prefix = "gl_Position"; name_prefix = "gl_Position";
ctx->inputs[i].glsl_predefined_no_emit = TRUE; ctx->inputs[i].glsl_predefined_no_emit = true;
ctx->inputs[i].glsl_no_index = TRUE; ctx->inputs[i].glsl_no_index = true;
ctx->inputs[i].glsl_gl_in = TRUE; ctx->inputs[i].glsl_gl_in = true;
break; break;
} else if (iter->processor.Processor == TGSI_PROCESSOR_FRAGMENT) { } else if (iter->processor.Processor == TGSI_PROCESSOR_FRAGMENT) {
name_prefix = "gl_FragCoord"; name_prefix = "gl_FragCoord";
ctx->inputs[i].glsl_predefined_no_emit = TRUE; ctx->inputs[i].glsl_predefined_no_emit = true;
ctx->inputs[i].glsl_no_index = TRUE; ctx->inputs[i].glsl_no_index = true;
break; break;
} }
/* fallthrough for vertex shader */ /* fallthrough for vertex shader */
@ -325,17 +325,17 @@ iter_declaration(struct tgsi_iterate_context *iter,
return TRUE; return TRUE;
} }
name_prefix = "gl_FrontFacing"; name_prefix = "gl_FrontFacing";
ctx->inputs[i].glsl_predefined_no_emit = TRUE; ctx->inputs[i].glsl_predefined_no_emit = true;
ctx->inputs[i].glsl_no_index = TRUE; ctx->inputs[i].glsl_no_index = true;
ctx->front_face_emitted = TRUE; ctx->front_face_emitted = true;
break; break;
} }
case TGSI_SEMANTIC_GENERIC: case TGSI_SEMANTIC_GENERIC:
if (iter->processor.Processor == TGSI_PROCESSOR_FRAGMENT) { if (iter->processor.Processor == TGSI_PROCESSOR_FRAGMENT) {
if (ctx->key->coord_replace & (1 << ctx->inputs[i].sid)) { if (ctx->key->coord_replace & (1 << ctx->inputs[i].sid)) {
name_prefix = "vec4(gl_PointCoord, 0.0, 1.0)"; name_prefix = "vec4(gl_PointCoord, 0.0, 1.0)";
ctx->inputs[i].glsl_predefined_no_emit = TRUE; ctx->inputs[i].glsl_predefined_no_emit = true;
ctx->inputs[i].glsl_no_index = TRUE; ctx->inputs[i].glsl_no_index = true;
break; break;
} }
} }
@ -378,10 +378,10 @@ iter_declaration(struct tgsi_iterate_context *iter,
ctx->outputs[i].sid = decl->Semantic.Index; ctx->outputs[i].sid = decl->Semantic.Index;
ctx->outputs[i].interpolate = decl->Interp.Interpolate; ctx->outputs[i].interpolate = decl->Interp.Interpolate;
ctx->outputs[i].first = decl->Range.First; ctx->outputs[i].first = decl->Range.First;
ctx->outputs[i].glsl_predefined_no_emit = FALSE; ctx->outputs[i].glsl_predefined_no_emit = false;
ctx->outputs[i].glsl_no_index = FALSE; ctx->outputs[i].glsl_no_index = false;
ctx->outputs[i].override_no_wm = FALSE; ctx->outputs[i].override_no_wm = false;
ctx->outputs[i].is_int = FALSE; ctx->outputs[i].is_int = false;
switch (ctx->outputs[i].name) { switch (ctx->outputs[i].name) {
case TGSI_SEMANTIC_POSITION: case TGSI_SEMANTIC_POSITION:
@ -390,21 +390,21 @@ iter_declaration(struct tgsi_iterate_context *iter,
if (ctx->outputs[i].first > 0) if (ctx->outputs[i].first > 0)
fprintf(stderr,"Illegal position input\n"); fprintf(stderr,"Illegal position input\n");
name_prefix = "gl_Position"; name_prefix = "gl_Position";
ctx->outputs[i].glsl_predefined_no_emit = TRUE; ctx->outputs[i].glsl_predefined_no_emit = true;
ctx->outputs[i].glsl_no_index = TRUE; ctx->outputs[i].glsl_no_index = true;
} else if (iter->processor.Processor == TGSI_PROCESSOR_FRAGMENT) { } else if (iter->processor.Processor == TGSI_PROCESSOR_FRAGMENT) {
if (ctx->outputs[i].first > 0) if (ctx->outputs[i].first > 0)
fprintf(stderr,"Illegal position input\n"); fprintf(stderr,"Illegal position input\n");
name_prefix = "gl_FragDepth"; name_prefix = "gl_FragDepth";
ctx->outputs[i].glsl_predefined_no_emit = TRUE; ctx->outputs[i].glsl_predefined_no_emit = true;
ctx->outputs[i].glsl_no_index = TRUE; ctx->outputs[i].glsl_no_index = true;
ctx->outputs[i].override_no_wm = TRUE; ctx->outputs[i].override_no_wm = true;
} }
break; break;
case TGSI_SEMANTIC_CLIPDIST: case TGSI_SEMANTIC_CLIPDIST:
name_prefix = "gl_ClipDistance"; name_prefix = "gl_ClipDistance";
ctx->outputs[i].glsl_predefined_no_emit = TRUE; ctx->outputs[i].glsl_predefined_no_emit = true;
ctx->outputs[i].glsl_no_index = TRUE; ctx->outputs[i].glsl_no_index = true;
ctx->num_clip_dist += 4; ctx->num_clip_dist += 4;
if (iter->processor.Processor == TGSI_PROCESSOR_VERTEX && if (iter->processor.Processor == TGSI_PROCESSOR_VERTEX &&
ctx->key->gs_present) ctx->key->gs_present)
@ -412,9 +412,9 @@ iter_declaration(struct tgsi_iterate_context *iter,
break; break;
case TGSI_SEMANTIC_CLIPVERTEX: case TGSI_SEMANTIC_CLIPVERTEX:
name_prefix = "gl_ClipVertex"; name_prefix = "gl_ClipVertex";
ctx->outputs[i].glsl_predefined_no_emit = TRUE; ctx->outputs[i].glsl_predefined_no_emit = true;
ctx->outputs[i].glsl_no_index = TRUE; ctx->outputs[i].glsl_no_index = true;
ctx->outputs[i].override_no_wm = TRUE; ctx->outputs[i].override_no_wm = true;
if (ctx->glsl_ver_required >= 140) if (ctx->glsl_ver_required >= 140)
ctx->has_clipvertex = true; ctx->has_clipvertex = true;
break; break;
@ -422,7 +422,7 @@ iter_declaration(struct tgsi_iterate_context *iter,
case TGSI_SEMANTIC_COLOR: case TGSI_SEMANTIC_COLOR:
if (iter->processor.Processor == TGSI_PROCESSOR_VERTEX) { if (iter->processor.Processor == TGSI_PROCESSOR_VERTEX) {
if (ctx->glsl_ver_required < 140) { if (ctx->glsl_ver_required < 140) {
ctx->outputs[i].glsl_no_index = TRUE; ctx->outputs[i].glsl_no_index = true;
if (ctx->outputs[i].sid == 0) if (ctx->outputs[i].sid == 0)
name_prefix = "gl_FrontColor"; name_prefix = "gl_FrontColor";
else if (ctx->outputs[i].sid == 1) else if (ctx->outputs[i].sid == 1)
@ -435,7 +435,7 @@ iter_declaration(struct tgsi_iterate_context *iter,
case TGSI_SEMANTIC_BCOLOR: case TGSI_SEMANTIC_BCOLOR:
if (iter->processor.Processor == TGSI_PROCESSOR_VERTEX) { if (iter->processor.Processor == TGSI_PROCESSOR_VERTEX) {
if (ctx->glsl_ver_required < 140) { if (ctx->glsl_ver_required < 140) {
ctx->outputs[i].glsl_no_index = TRUE; ctx->outputs[i].glsl_no_index = true;
if (ctx->outputs[i].sid == 0) if (ctx->outputs[i].sid == 0)
name_prefix = "gl_BackColor"; name_prefix = "gl_BackColor";
else if (ctx->outputs[i].sid == 1) else if (ctx->outputs[i].sid == 1)
@ -447,42 +447,42 @@ iter_declaration(struct tgsi_iterate_context *iter,
} }
case TGSI_SEMANTIC_PSIZE: case TGSI_SEMANTIC_PSIZE:
if (iter->processor.Processor == TGSI_PROCESSOR_VERTEX) { if (iter->processor.Processor == TGSI_PROCESSOR_VERTEX) {
ctx->outputs[i].glsl_predefined_no_emit = TRUE; ctx->outputs[i].glsl_predefined_no_emit = true;
ctx->outputs[i].glsl_no_index = TRUE; ctx->outputs[i].glsl_no_index = true;
ctx->outputs[i].override_no_wm = TRUE; ctx->outputs[i].override_no_wm = true;
name_prefix = "gl_PointSize"; name_prefix = "gl_PointSize";
break; break;
} else if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) { } else if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) {
ctx->outputs[i].glsl_predefined_no_emit = TRUE; ctx->outputs[i].glsl_predefined_no_emit = true;
ctx->outputs[i].glsl_no_index = TRUE; ctx->outputs[i].glsl_no_index = true;
ctx->outputs[i].override_no_wm = TRUE; ctx->outputs[i].override_no_wm = true;
name_prefix = "gl_PointSize"; name_prefix = "gl_PointSize";
break; break;
} }
case TGSI_SEMANTIC_LAYER: case TGSI_SEMANTIC_LAYER:
if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) { if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) {
ctx->outputs[i].glsl_predefined_no_emit = TRUE; ctx->outputs[i].glsl_predefined_no_emit = true;
ctx->outputs[i].glsl_no_index = TRUE; ctx->outputs[i].glsl_no_index = true;
ctx->outputs[i].override_no_wm = TRUE; ctx->outputs[i].override_no_wm = true;
ctx->outputs[i].is_int = TRUE; ctx->outputs[i].is_int = true;
name_prefix = "gl_Layer"; name_prefix = "gl_Layer";
break; break;
} }
case TGSI_SEMANTIC_PRIMID: case TGSI_SEMANTIC_PRIMID:
if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) { if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) {
ctx->outputs[i].glsl_predefined_no_emit = TRUE; ctx->outputs[i].glsl_predefined_no_emit = true;
ctx->outputs[i].glsl_no_index = TRUE; ctx->outputs[i].glsl_no_index = true;
ctx->outputs[i].override_no_wm = TRUE; ctx->outputs[i].override_no_wm = true;
ctx->outputs[i].is_int = TRUE; ctx->outputs[i].is_int = true;
name_prefix = "gl_PrimitiveID"; name_prefix = "gl_PrimitiveID";
break; break;
} }
case TGSI_SEMANTIC_VIEWPORT_INDEX: case TGSI_SEMANTIC_VIEWPORT_INDEX:
if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) { if (iter->processor.Processor == TGSI_PROCESSOR_GEOMETRY) {
ctx->outputs[i].glsl_predefined_no_emit = TRUE; ctx->outputs[i].glsl_predefined_no_emit = true;
ctx->outputs[i].glsl_no_index = TRUE; ctx->outputs[i].glsl_no_index = true;
ctx->outputs[i].override_no_wm = TRUE; ctx->outputs[i].override_no_wm = true;
ctx->outputs[i].is_int = TRUE; ctx->outputs[i].is_int = true;
name_prefix = "gl_ViewportIndex"; name_prefix = "gl_ViewportIndex";
if (ctx->glsl_ver_required >= 140) if (ctx->glsl_ver_required >= 140)
ctx->has_viewport_idx = true; ctx->has_viewport_idx = true;
@ -553,16 +553,16 @@ iter_declaration(struct tgsi_iterate_context *iter,
i = ctx->num_system_values++; i = ctx->num_system_values++;
ctx->system_values[i].name = decl->Semantic.Name; ctx->system_values[i].name = decl->Semantic.Name;
ctx->system_values[i].sid = decl->Semantic.Index; ctx->system_values[i].sid = decl->Semantic.Index;
ctx->system_values[i].glsl_predefined_no_emit = TRUE; ctx->system_values[i].glsl_predefined_no_emit = true;
ctx->system_values[i].glsl_no_index = TRUE; ctx->system_values[i].glsl_no_index = true;
ctx->system_values[i].override_no_wm = TRUE; ctx->system_values[i].override_no_wm = true;
ctx->system_values[i].first = decl->Range.First; ctx->system_values[i].first = decl->Range.First;
if (decl->Semantic.Name == TGSI_SEMANTIC_INSTANCEID) { if (decl->Semantic.Name == TGSI_SEMANTIC_INSTANCEID) {
name_prefix = "gl_InstanceID"; name_prefix = "gl_InstanceID";
ctx->has_instanceid = TRUE; ctx->has_instanceid = true;
} else if (decl->Semantic.Name == TGSI_SEMANTIC_VERTEXID) { } else if (decl->Semantic.Name == TGSI_SEMANTIC_VERTEXID) {
name_prefix = "gl_VertexID"; name_prefix = "gl_VertexID";
ctx->has_ints = TRUE; ctx->has_ints = true;
} else { } else {
fprintf(stderr, "unsupported system value %d\n", decl->Semantic.Name); fprintf(stderr, "unsupported system value %d\n", decl->Semantic.Name);
name_prefix = "unknown"; name_prefix = "unknown";
@ -574,7 +574,6 @@ iter_declaration(struct tgsi_iterate_context *iter,
break; break;
} }
return TRUE; return TRUE;
} }
@ -586,7 +585,7 @@ iter_property(struct tgsi_iterate_context *iter,
if (prop->Property.PropertyName == TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS) { if (prop->Property.PropertyName == TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS) {
if (prop->u[0].Data == 1) if (prop->u[0].Data == 1)
ctx->write_all_cbufs = TRUE; ctx->write_all_cbufs = true;
} }
if (prop->Property.PropertyName == TGSI_PROPERTY_FS_COORD_ORIGIN) { if (prop->Property.PropertyName == TGSI_PROPERTY_FS_COORD_ORIGIN) {
@ -630,10 +629,10 @@ iter_immediate(
if (imm->Immediate.DataType == TGSI_IMM_FLOAT32) { if (imm->Immediate.DataType == TGSI_IMM_FLOAT32) {
ctx->imm[first].val[i].f = imm->u[i].Float; ctx->imm[first].val[i].f = imm->u[i].Float;
} else if (imm->Immediate.DataType == TGSI_IMM_UINT32) { } else if (imm->Immediate.DataType == TGSI_IMM_UINT32) {
ctx->has_ints = TRUE; ctx->has_ints = true;
ctx->imm[first].val[i].ui = imm->u[i].Uint; ctx->imm[first].val[i].ui = imm->u[i].Uint;
} else if (imm->Immediate.DataType == TGSI_IMM_INT32) { } else if (imm->Immediate.DataType == TGSI_IMM_INT32) {
ctx->has_ints = TRUE; ctx->has_ints = true;
ctx->imm[first].val[i].i = imm->u[i].Int; ctx->imm[first].val[i].i = imm->u[i].Int;
} }
} }
@ -1156,7 +1155,7 @@ iter_instruction(struct tgsi_iterate_context *iter,
ctx->prog_type = iter->processor.Processor; ctx->prog_type = iter->processor.Processor;
if (dtype == TGSI_TYPE_SIGNED || dtype == TGSI_TYPE_UNSIGNED || if (dtype == TGSI_TYPE_SIGNED || dtype == TGSI_TYPE_UNSIGNED ||
stype == TGSI_TYPE_SIGNED || stype == TGSI_TYPE_UNSIGNED) stype == TGSI_TYPE_SIGNED || stype == TGSI_TYPE_UNSIGNED)
ctx->has_ints = TRUE; ctx->has_ints = true;
if (inst->Instruction.Opcode == TGSI_OPCODE_TXQ) { if (inst->Instruction.Opcode == TGSI_OPCODE_TXQ) {
dtypeprefix = "intBitsToFloat"; dtypeprefix = "intBitsToFloat";
@ -1329,7 +1328,7 @@ iter_instruction(struct tgsi_iterate_context *iter,
snprintf(srcs[i], 255, "%s(%s%subo%dcontents[%d]%s)", stypeprefix, prefix, cname, dim, src->Register.Index, swizzle); snprintf(srcs[i], 255, "%s(%s%subo%dcontents[%d]%s)", stypeprefix, prefix, cname, dim, src->Register.Index, swizzle);
} else { } else {
const char *csp; const char *csp;
ctx->has_ints = TRUE; ctx->has_ints = true;
if (stype == TGSI_TYPE_FLOAT || stype == TGSI_TYPE_UNTYPED) if (stype == TGSI_TYPE_FLOAT || stype == TGSI_TYPE_UNTYPED)
csp = "uintBitsToFloat"; csp = "uintBitsToFloat";
else if (stype == TGSI_TYPE_SIGNED) else if (stype == TGSI_TYPE_SIGNED)
@ -1387,7 +1386,7 @@ iter_instruction(struct tgsi_iterate_context *iter,
switch (imd->type) { switch (imd->type) {
case TGSI_IMM_FLOAT32: case TGSI_IMM_FLOAT32:
if (isinf(imd->val[idx].f) || isnan(imd->val[idx].f)) { if (isinf(imd->val[idx].f) || isnan(imd->val[idx].f)) {
ctx->has_ints = TRUE; ctx->has_ints = true;
snprintf(temp, 48, "uintBitsToFloat(%uU)", imd->val[idx].ui); snprintf(temp, 48, "uintBitsToFloat(%uU)", imd->val[idx].ui);
} else } else
snprintf(temp, 25, "%.8g", imd->val[idx].f); snprintf(temp, 25, "%.8g", imd->val[idx].f);
@ -1910,7 +1909,7 @@ const char *vrend_shader_samplertypeconv(int sampler_type, int *is_shad)
} }
} }
static const char *get_interp_string(int interpolate, boolean flatshade) static const char *get_interp_string(int interpolate, bool flatshade)
{ {
switch (interpolate) { switch (interpolate) {
case TGSI_INTERPOLATE_LINEAR: case TGSI_INTERPOLATE_LINEAR:
@ -1937,7 +1936,7 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
if (ctx->prog_type == TGSI_PROCESSOR_FRAGMENT) { if (ctx->prog_type == TGSI_PROCESSOR_FRAGMENT) {
if (fs_emit_layout(ctx)) { if (fs_emit_layout(ctx)) {
boolean upper_left = !(ctx->fs_coord_origin ^ ctx->key->invert_fs_origin); bool upper_left = !(ctx->fs_coord_origin ^ ctx->key->invert_fs_origin);
char comma = (upper_left && ctx->fs_pixel_center) ? ',' : ' '; char comma = (upper_left && ctx->fs_pixel_center) ? ',' : ' ';
snprintf(buf, 255, "layout(%s%c%s) in vec4 gl_FragCoord;\n", snprintf(buf, 255, "layout(%s%c%s) in vec4 gl_FragCoord;\n",
@ -2268,18 +2267,18 @@ static void replace_interp(char *program,
memcpy(ptr, pstring, strlen(pstring)); memcpy(ptr, pstring, strlen(pstring));
} }
boolean vrend_patch_vertex_shader_interpolants(char *program, bool vrend_patch_vertex_shader_interpolants(char *program,
struct vrend_shader_info *vs_info, struct vrend_shader_info *vs_info,
struct vrend_shader_info *fs_info, bool is_gs, bool flatshade) struct vrend_shader_info *fs_info, bool is_gs, bool flatshade)
{ {
int i; int i;
const char *pstring; const char *pstring;
char glsl_name[64]; char glsl_name[64];
if (!vs_info || !fs_info) if (!vs_info || !fs_info)
return TRUE; return true;
if (!fs_info->interpinfo) if (!fs_info->interpinfo)
return TRUE; return true;
for (i = 0; i < fs_info->num_interps; i++) { for (i = 0; i < fs_info->num_interps; i++) {
pstring = get_interp_string(fs_info->interpinfo[i].interpolate, flatshade); pstring = get_interp_string(fs_info->interpinfo[i].interpolate, flatshade);
@ -2313,5 +2312,5 @@ boolean vrend_patch_vertex_shader_interpolants(char *program,
if (vrend_dump_shaders) if (vrend_dump_shaders)
fprintf(stderr,"GLSL: post interp: %s\n", program); fprintf(stderr,"GLSL: post interp: %s\n", program);
return TRUE; return true;
} }

20
src/vrend_shader.h
Unescape View File

@ -53,15 +53,15 @@ struct vrend_shader_info {
struct vrend_shader_key { struct vrend_shader_key {
uint32_t coord_replace; uint32_t coord_replace;
boolean invert_fs_origin; bool invert_fs_origin;
boolean pstipple_tex; bool pstipple_tex;
boolean add_alpha_test; bool add_alpha_test;
boolean color_two_side; bool color_two_side;
uint8_t alpha_test; uint8_t alpha_test;
uint8_t clip_plane_enable; uint8_t clip_plane_enable;
float alpha_ref_val; float alpha_ref_val;
boolean gs_present; bool gs_present;
boolean flatshade; bool flatshade;
}; };
struct vrend_shader_cfg { struct vrend_shader_cfg {
@ -69,10 +69,10 @@ struct vrend_shader_cfg {
bool use_core_profile; bool use_core_profile;
}; };
boolean vrend_patch_vertex_shader_interpolants(char *program, bool vrend_patch_vertex_shader_interpolants(char *program,
struct vrend_shader_info *vs_info, struct vrend_shader_info *vs_info,
struct vrend_shader_info *fs_info, struct vrend_shader_info *fs_info,
bool is_gs, bool flatshade); bool is_gs, bool flatshade);
char *vrend_convert_shader(struct vrend_shader_cfg *cfg, char *vrend_convert_shader(struct vrend_shader_cfg *cfg,
const struct tgsi_token *tokens, const struct tgsi_token *tokens,

Write Preview
Loading…
Cancel
Save