KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

draw: rename vertex header members 

clip -> clip_vertex and pre_clip_pos -> clip_pos.
Looks more obvious to me what these values actually represent (so use
something resembling the vs output names).

Reviewed-by: Brian Paul <brianp@vmware.com
Reviewed-by: Jose Fonseca <jfonseca@vmware.com>
This commit is contained in:
Roland Scheidegger 2015-12-11 23:29:59 +01:00
parent 1b22815af6
commit 8575ddb644
6 changed files with 46 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/gallium/auxiliary/draw/draw_cliptest_tmp.h
View File

@ -91,8 +91,8 @@ static boolean TAG(do_cliptest)( struct pt_post_vs *pvs,
}
for (i = 0; i < 4; i++) {
out->clip[i] = clipvertex[i];
out->pre_clip_pos[i] = position[i];
out->clip_vertex[i] = clipvertex[i];
out->clip_pos[i] = position[i];
}
/* Do the hardwired planes first:

28
src/gallium/auxiliary/draw/draw_llvm.c
View File

@ -188,6 +188,7 @@ create_jit_sampler_type(struct gallivm_state *gallivm, const char *struct_name)
sampler_type = LLVMStructTypeInContext(gallivm->context, elem_types,
Elements(elem_types), 0);
(void) target; /* silence unused var warning for non-debug build */
LP_CHECK_MEMBER_OFFSET(struct draw_jit_sampler, min_lod,
target, sampler_type,
DRAW_JIT_SAMPLER_MIN_LOD);
@ -234,6 +235,8 @@ create_jit_context_type(struct gallivm_state *gallivm,
PIPE_MAX_SAMPLERS); /* samplers */
context_type = LLVMStructTypeInContext(gallivm->context, elem_types,
Elements(elem_types), 0);
(void) target; /* silence unused var warning for non-debug build */
LP_CHECK_MEMBER_OFFSET(struct draw_jit_context, vs_constants,
target, context_type, DRAW_JIT_CTX_CONSTANTS);
LP_CHECK_MEMBER_OFFSET(struct draw_jit_context, num_vs_constants,
@ -382,8 +385,8 @@ create_jit_vertex_header(struct gallivm_state *gallivm, int data_elems)
util_snprintf(struct_name, 23, "vertex_header%d", data_elems);
elem_types[DRAW_JIT_VERTEX_VERTEX_ID] = LLVMIntTypeInContext(gallivm->context, 32);
elem_types[DRAW_JIT_VERTEX_CLIP] = LLVMArrayType(LLVMFloatTypeInContext(gallivm->context), 4);
elem_types[DRAW_JIT_VERTEX_PRE_CLIP_POS] = LLVMArrayType(LLVMFloatTypeInContext(gallivm->context), 4);
elem_types[DRAW_JIT_VERTEX_CLIP_VERTEX] = LLVMArrayType(LLVMFloatTypeInContext(gallivm->context), 4);
elem_types[DRAW_JIT_VERTEX_CLIP_POS] = LLVMArrayType(LLVMFloatTypeInContext(gallivm->context), 4);
elem_types[DRAW_JIT_VERTEX_DATA] = LLVMArrayType(elem_types[1], data_elems);
vertex_header = LLVMStructTypeInContext(gallivm->context, elem_types,
@ -403,12 +406,13 @@ create_jit_vertex_header(struct gallivm_state *gallivm, int data_elems)
target, vertex_header,
DRAW_JIT_VERTEX_VERTEX_ID);
*/
LP_CHECK_MEMBER_OFFSET(struct vertex_header, clip,
(void) target; /* silence unused var warning for non-debug build */
LP_CHECK_MEMBER_OFFSET(struct vertex_header, clip_vertex,
target, vertex_header,
DRAW_JIT_VERTEX_CLIP);
LP_CHECK_MEMBER_OFFSET(struct vertex_header, pre_clip_pos,
DRAW_JIT_VERTEX_CLIP_VERTEX);
LP_CHECK_MEMBER_OFFSET(struct vertex_header, clip_pos,
target, vertex_header,
DRAW_JIT_VERTEX_PRE_CLIP_POS);
DRAW_JIT_VERTEX_CLIP_POS);
LP_CHECK_MEMBER_OFFSET(struct vertex_header, data,
target, vertex_header,
DRAW_JIT_VERTEX_DATA);
@ -1015,7 +1019,7 @@ store_clip(struct gallivm_state *gallivm,
const struct lp_type vs_type,
LLVMValueRef io_ptr,
LLVMValueRef (*outputs)[TGSI_NUM_CHANNELS],
boolean pre_clip_pos, int idx)
boolean clip_vertex, int idx)
{
LLVMBuilderRef builder = gallivm->builder;
LLVMValueRef soa[4];
@ -1042,13 +1046,13 @@ store_clip(struct gallivm_state *gallivm,
soa[2] = LLVMBuildLoad(builder, outputs[idx][2], ""); /*z0 z1 .. zn*/
soa[3] = LLVMBuildLoad(builder, outputs[idx][3], ""); /*w0 w1 .. wn*/
if (!pre_clip_pos) {
if (clip_vertex) {
for (i = 0; i < vs_type.length; i++) {
clip_ptrs[i] = draw_jit_header_clip(gallivm, io_ptrs[i]);
clip_ptrs[i] = draw_jit_header_clip_vertex(gallivm, io_ptrs[i]);
}
} else {
for (i = 0; i < vs_type.length; i++) {
clip_ptrs[i] = draw_jit_header_pre_clip_pos(gallivm, io_ptrs[i]);
clip_ptrs[i] = draw_jit_header_clip_pos(gallivm, io_ptrs[i]);
}
}
@ -1767,8 +1771,8 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant,
if (pos != -1 && cv != -1) {
/* store original positions in clip before further manipulation */
store_clip(gallivm, vs_type, io, outputs, FALSE, key->clip_user ? cv : pos);
store_clip(gallivm, vs_type, io, outputs, TRUE, pos);
store_clip(gallivm, vs_type, io, outputs, TRUE, key->clip_user ? cv : pos);
store_clip(gallivm, vs_type, io, outputs, FALSE, pos);
/* do cliptest */
if (enable_cliptest) {

12
src/gallium/auxiliary/draw/draw_llvm.h
View File

@ -104,8 +104,8 @@ enum {
enum {
DRAW_JIT_VERTEX_VERTEX_ID = 0,
DRAW_JIT_VERTEX_CLIP,
DRAW_JIT_VERTEX_PRE_CLIP_POS,
DRAW_JIT_VERTEX_CLIP_VERTEX,
DRAW_JIT_VERTEX_CLIP_POS,
DRAW_JIT_VERTEX_DATA
};
@ -162,11 +162,11 @@ enum {
#define draw_jit_header_id(_gallivm, _ptr) \
lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_VERTEX_VERTEX_ID, "id")
#define draw_jit_header_clip(_gallivm, _ptr) \
lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_VERTEX_CLIP, "clip")
#define draw_jit_header_clip_vertex(_gallivm, _ptr) \
lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_VERTEX_CLIP_VERTEX, "clip_vertex")
#define draw_jit_header_pre_clip_pos(_gallivm, _ptr) \
lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_VERTEX_PRE_CLIP_POS, "pre_clip_pos")
#define draw_jit_header_clip_pos(_gallivm, _ptr) \
lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_VERTEX_CLIP_POS, "clip_pos")
#define draw_jit_header_data(_gallivm, _ptr) \
lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_VERTEX_DATA, "data")

38
src/gallium/auxiliary/draw/draw_pipe_clip.c
View File

@ -151,15 +151,15 @@ static void interp(const struct clip_stage *clip,
/* Interpolate the clip-space coords.
*/
interp_attr(dst->clip, t, in->clip, out->clip);
interp_attr(dst->clip_vertex, t, in->clip_vertex, out->clip_vertex);
/* interpolate the clip-space position */
interp_attr(dst->pre_clip_pos, t, in->pre_clip_pos, out->pre_clip_pos);
interp_attr(dst->clip_pos, t, in->clip_pos, out->clip_pos);
/* Do the projective divide and viewport transformation to get
* new window coordinates:
*/
{
const float *pos = dst->pre_clip_pos;
const float *pos = dst->clip_pos;
const float *scale =
clip->stage.draw->viewports[viewport_index].scale;
const float *trans =
@ -193,11 +193,11 @@ static void interp(const struct clip_stage *clip,
t_nopersp = t;
/* find either in.x != out.x or in.y != out.y */
for (k = 0; k < 2; k++) {
if (in->pre_clip_pos[k] != out->pre_clip_pos[k]) {
if (in->clip_pos[k] != out->clip_pos[k]) {
/* do divide by W, then compute linear interpolation factor */
float in_coord = in->pre_clip_pos[k] / in->pre_clip_pos[3];
float out_coord = out->pre_clip_pos[k] / out->pre_clip_pos[3];
float dst_coord = dst->pre_clip_pos[k] / dst->pre_clip_pos[3];
float in_coord = in->clip_pos[k] / in->clip_pos[3];
float out_coord = out->clip_pos[k] / out->clip_pos[3];
float dst_coord = dst->clip_pos[k] / dst->clip_pos[3];
t_nopersp = (dst_coord - out_coord) / (in_coord - out_coord);
break;
}
@ -308,10 +308,10 @@ static void emit_poly(struct draw_stage *stage,
stage->draw->rasterizer->flatshade_first);
for (j = 0; j < 3; j++) {
debug_printf(" Vert %d: clip: %f %f %f %f\n", j,
header.v[j]->clip[0],
header.v[j]->clip[1],
header.v[j]->clip[2],
header.v[j]->clip[3]);
header.v[j]->clip_vertex[0],
header.v[j]->clip_vertex[1],
header.v[j]->clip_vertex[2],
header.v[j]->clip_vertex[3]);
for (k = 0; k < draw_num_shader_outputs(stage->draw); k++) {
debug_printf(" Vert %d: Attr %d: %f %f %f %f\n", j, k,
header.v[j]->data[k][0],
@ -349,7 +349,7 @@ static inline float getclipdist(const struct clip_stage *clipper,
if (plane_idx < 6) {
/* ordinary xyz view volume clipping uses pos output */
plane = clipper->plane[plane_idx];
dp = dot4(vert->pre_clip_pos, plane);
dp = dot4(vert->clip_pos, plane);
}
else if (clipper->have_clipdist) {
/* pick the correct clipdistance element from the output vectors */
@ -363,7 +363,7 @@ static inline float getclipdist(const struct clip_stage *clipper,
* (clip will contain clipVertex output if available, pos otherwise).
*/
plane = clipper->plane[plane_idx];
dp = dot4(vert->clip, plane);
dp = dot4(vert->clip_vertex, plane);
}
return dp;
}
@ -410,9 +410,9 @@ do_clip_tri(struct draw_stage *stage,
viewport_index = draw_viewport_index(clipper->stage.draw, prov_vertex);
if (DEBUG_CLIP) {
const float *v0 = header->v[0]->clip;
const float *v1 = header->v[1]->clip;
const float *v2 = header->v[2]->clip;
const float *v0 = header->v[0]->clip_vertex;
const float *v1 = header->v[1]->clip_vertex;
const float *v2 = header->v[2]->clip_vertex;
debug_printf("Clip triangle:\n");
debug_printf(" %f, %f, %f, %f\n", v0[0], v0[1], v0[2], v0[3]);
debug_printf(" %f, %f, %f, %f\n", v1[0], v1[1], v1[2], v1[3]);
@ -681,9 +681,9 @@ clip_point_guard_xy(struct draw_stage *stage, struct prim_header *header)
* automatically). These would usually be captured by depth clip
* too but this can be disabled.
*/
if (header->v[0]->clip[3] <= 0.0f ||
util_is_inf_or_nan(header->v[0]->clip[0]) ||
util_is_inf_or_nan(header->v[0]->clip[1]))
if (header->v[0]->clip_vertex[3] <= 0.0f ||
util_is_inf_or_nan(header->v[0]->clip_vertex[0]) ||
util_is_inf_or_nan(header->v[0]->clip_vertex[1]))
return;
}
stage->next->point(stage->next, header);

4
src/gallium/auxiliary/draw/draw_private.h
View File

@ -89,8 +89,8 @@ struct vertex_header {
unsigned pad:1;
unsigned vertex_id:16;
float clip[4];
float pre_clip_pos[4];
float clip_vertex[4];
float clip_pos[4];
/* This will probably become float (*data)[4] soon:
*/

2
src/gallium/auxiliary/draw/draw_pt_so_emit.c
View File

@ -275,7 +275,7 @@ void draw_pt_so_emit( struct pt_so_emit *emit,
emit->generated_primitives = 0;
emit->input_vertex_stride = input_verts->stride;
if (emit->use_pre_clip_pos)
emit->pre_clip_pos = input_verts->verts->pre_clip_pos;
emit->pre_clip_pos = input_verts->verts->clip_pos;
emit->inputs = (const float (*)[4])input_verts->verts->data;