From: Brian Paul Date: Tue, 25 Apr 2017 00:51:05 +0000 (-0600) Subject: draw: whitespace fixes in draw_pipe_vbuf.c X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=75be43ed33e7ce01d74bb294c41feec821ecf685;p=mesa.git draw: whitespace fixes in draw_pipe_vbuf.c Remove trailing whitespace, fix formatting, etc. Trivial. --- diff --git a/src/gallium/auxiliary/draw/draw_pipe_vbuf.c b/src/gallium/auxiliary/draw/draw_pipe_vbuf.c index f26063d1fea..8592f51db12 100644 --- a/src/gallium/auxiliary/draw/draw_pipe_vbuf.c +++ b/src/gallium/auxiliary/draw/draw_pipe_vbuf.c @@ -28,7 +28,7 @@ /** * \file * Vertex buffer drawing stage. - * + * * \author Jose Fonseca * \author Keith Whitwell */ @@ -37,7 +37,6 @@ #include "util/u_debug.h" #include "util/u_math.h" #include "util/u_memory.h" - #include "draw_vbuf.h" #include "draw_private.h" #include "draw_vertex.h" @@ -53,14 +52,14 @@ struct vbuf_stage { struct draw_stage stage; /**< This must be first (base class) */ struct vbuf_render *render; - + const struct vertex_info *vinfo; - + /** Vertex size in bytes */ unsigned vertex_size; struct translate *translate; - + /* FIXME: we have no guarantee that 'unsigned' is 32bit */ /** Vertices in hardware format */ @@ -68,7 +67,7 @@ struct vbuf_stage { unsigned *vertex_ptr; unsigned max_vertices; unsigned nr_vertices; - + /** Indices */ ushort *indices; unsigned max_indices; @@ -87,31 +86,28 @@ struct vbuf_stage { * Basically a cast wrapper. */ static inline struct vbuf_stage * -vbuf_stage( struct draw_stage *stage ) +vbuf_stage(struct draw_stage *stage) { assert(stage); return (struct vbuf_stage *)stage; } -static void vbuf_flush_vertices( struct vbuf_stage *vbuf ); -static void vbuf_alloc_vertices( struct vbuf_stage *vbuf ); +static void vbuf_flush_vertices(struct vbuf_stage *vbuf); +static void vbuf_alloc_vertices(struct vbuf_stage *vbuf); -static inline void -check_space( struct vbuf_stage *vbuf, unsigned nr ) +static inline void +check_space(struct vbuf_stage *vbuf, unsigned nr) { if (vbuf->nr_vertices + nr > vbuf->max_vertices || - vbuf->nr_indices + nr > vbuf->max_indices) - { - vbuf_flush_vertices( vbuf ); - vbuf_alloc_vertices( vbuf ); + vbuf->nr_indices + nr > vbuf->max_indices) { + vbuf_flush_vertices(vbuf); + vbuf_alloc_vertices(vbuf); } } - - /** * Extract the needed fields from post-transformed vertex and emit * a hardware(driver) vertex. @@ -119,22 +115,21 @@ check_space( struct vbuf_stage *vbuf, unsigned nr ) * have a couple of slots at the beginning (1-dword header, 4-dword * clip pos) that we ignore here. We only use the vertex->data[] fields. */ -static inline ushort -emit_vertex( struct vbuf_stage *vbuf, - struct vertex_header *vertex ) +static inline ushort +emit_vertex(struct vbuf_stage *vbuf, struct vertex_header *vertex) { if (vertex->vertex_id == UNDEFINED_VERTEX_ID && vbuf->vertex_ptr) { /* Hmm - vertices are emitted one at a time - better make sure * set_buffer is efficient. Consider a special one-shot mode for * translate. */ - /* Note: we really do want data[0] here, not data[pos]: + /* Note: we really do want data[0] here, not data[pos]: */ vbuf->translate->set_buffer(vbuf->translate, 0, vertex->data[0], 0, ~0); vbuf->translate->run(vbuf->translate, 0, 1, 0, 0, vbuf->vertex_ptr); if (0) draw_dump_emitted_vertex(vbuf->vinfo, (uint8_t *)vbuf->vertex_ptr); - + vbuf->vertex_ptr += vbuf->vertex_size/4; vertex->vertex_id = vbuf->nr_vertices++; } @@ -143,57 +138,52 @@ emit_vertex( struct vbuf_stage *vbuf, } -static void -vbuf_tri( struct draw_stage *stage, - struct prim_header *prim ) +static void +vbuf_tri(struct draw_stage *stage, struct prim_header *prim) { - struct vbuf_stage *vbuf = vbuf_stage( stage ); + struct vbuf_stage *vbuf = vbuf_stage(stage); unsigned i; - check_space( vbuf, 3 ); + check_space(vbuf, 3); for (i = 0; i < 3; i++) { - vbuf->indices[vbuf->nr_indices++] = emit_vertex( vbuf, prim->v[i] ); + vbuf->indices[vbuf->nr_indices++] = emit_vertex(vbuf, prim->v[i]); } } -static void -vbuf_line( struct draw_stage *stage, - struct prim_header *prim ) +static void +vbuf_line(struct draw_stage *stage, struct prim_header *prim) { - struct vbuf_stage *vbuf = vbuf_stage( stage ); + struct vbuf_stage *vbuf = vbuf_stage(stage); unsigned i; - check_space( vbuf, 2 ); + check_space(vbuf, 2); for (i = 0; i < 2; i++) { - vbuf->indices[vbuf->nr_indices++] = emit_vertex( vbuf, prim->v[i] ); - } + vbuf->indices[vbuf->nr_indices++] = emit_vertex(vbuf, prim->v[i]); + } } -static void -vbuf_point( struct draw_stage *stage, - struct prim_header *prim ) +static void +vbuf_point(struct draw_stage *stage, struct prim_header *prim) { - struct vbuf_stage *vbuf = vbuf_stage( stage ); + struct vbuf_stage *vbuf = vbuf_stage(stage); - check_space( vbuf, 1 ); + check_space(vbuf, 1); - vbuf->indices[vbuf->nr_indices++] = emit_vertex( vbuf, prim->v[0] ); + vbuf->indices[vbuf->nr_indices++] = emit_vertex(vbuf, prim->v[0]); } - - /** * Set the prim type for subsequent vertices. * This may result in a new vertex size. The existing vbuffer (if any) * will be flushed if needed and a new one allocated. */ static void -vbuf_start_prim( struct vbuf_stage *vbuf, uint prim ) +vbuf_start_prim(struct vbuf_stage *vbuf, uint prim) { struct translate_key hw_key; unsigned dst_offset; @@ -203,7 +193,7 @@ vbuf_start_prim( struct vbuf_stage *vbuf, uint prim ) vbuf->render->set_primitive(vbuf->render, prim); /* Must do this after set_primitive() above: - * + * * XXX: need some state managment to track when this needs to be * recalculated. The driver should tell us whether there was a * state change. @@ -220,7 +210,7 @@ vbuf_start_prim( struct vbuf_stage *vbuf, uint prim ) unsigned emit_sz = 0; unsigned src_buffer = 0; enum pipe_format output_format; - unsigned src_offset = (vinfo->attrib[i].src_index * 4 * sizeof(float) ); + unsigned src_offset = (vinfo->attrib[i].src_index * 4 * sizeof(float)); output_format = draw_translate_vinfo_format(vinfo->attrib[i].emit); emit_sz = draw_translate_vinfo_size(vinfo->attrib[i].emit); @@ -255,8 +245,7 @@ vbuf_start_prim( struct vbuf_stage *vbuf, uint prim ) /* Don't bother with caching at this stage: */ if (!vbuf->translate || - translate_key_compare(&vbuf->translate->key, &hw_key) != 0) - { + translate_key_compare(&vbuf->translate->key, &hw_key) != 0) { translate_key_sanitize(&hw_key); vbuf->translate = translate_cache_find(vbuf->cache, &hw_key); @@ -273,42 +262,39 @@ vbuf_start_prim( struct vbuf_stage *vbuf, uint prim ) } -static void -vbuf_first_tri( struct draw_stage *stage, - struct prim_header *prim ) +static void +vbuf_first_tri(struct draw_stage *stage, struct prim_header *prim) { - struct vbuf_stage *vbuf = vbuf_stage( stage ); + struct vbuf_stage *vbuf = vbuf_stage(stage); - vbuf_flush_vertices( vbuf ); + vbuf_flush_vertices(vbuf); vbuf_start_prim(vbuf, PIPE_PRIM_TRIANGLES); stage->tri = vbuf_tri; - stage->tri( stage, prim ); + stage->tri(stage, prim); } -static void -vbuf_first_line( struct draw_stage *stage, - struct prim_header *prim ) +static void +vbuf_first_line(struct draw_stage *stage, struct prim_header *prim) { - struct vbuf_stage *vbuf = vbuf_stage( stage ); + struct vbuf_stage *vbuf = vbuf_stage(stage); - vbuf_flush_vertices( vbuf ); + vbuf_flush_vertices(vbuf); vbuf_start_prim(vbuf, PIPE_PRIM_LINES); stage->line = vbuf_line; - stage->line( stage, prim ); + stage->line(stage, prim); } -static void -vbuf_first_point( struct draw_stage *stage, - struct prim_header *prim ) +static void +vbuf_first_point(struct draw_stage *stage, struct prim_header *prim) { - struct vbuf_stage *vbuf = vbuf_stage( stage ); + struct vbuf_stage *vbuf = vbuf_stage(stage); vbuf_flush_vertices(vbuf); vbuf_start_prim(vbuf, PIPE_PRIM_POINTS); stage->point = vbuf_point; - stage->point( stage, prim ); + stage->point(stage, prim); } @@ -316,28 +302,26 @@ vbuf_first_point( struct draw_stage *stage, /** * Flush existing vertex buffer and allocate a new one. */ -static void -vbuf_flush_vertices( struct vbuf_stage *vbuf ) +static void +vbuf_flush_vertices(struct vbuf_stage *vbuf) { - if(vbuf->vertices) { + if (vbuf->vertices) { + vbuf->render->unmap_vertices(vbuf->render, 0, vbuf->nr_vertices - 1); - vbuf->render->unmap_vertices( vbuf->render, 0, vbuf->nr_vertices - 1 ); + if (vbuf->nr_indices) { + vbuf->render->draw_elements(vbuf->render, + vbuf->indices, + vbuf->nr_indices); - if (vbuf->nr_indices) - { - vbuf->render->draw_elements(vbuf->render, - vbuf->indices, - vbuf->nr_indices ); - vbuf->nr_indices = 0; } - + /* Reset temporary vertices ids */ - if(vbuf->nr_vertices) - draw_reset_vertex_ids( vbuf->stage.draw ); - + if (vbuf->nr_vertices) + draw_reset_vertex_ids(vbuf->stage.draw); + /* Free the vertex buffer */ - vbuf->render->release_vertices( vbuf->render ); + vbuf->render->release_vertices(vbuf->render); vbuf->max_vertices = vbuf->nr_vertices = 0; vbuf->vertex_ptr = vbuf->vertices = NULL; @@ -353,20 +337,21 @@ vbuf_flush_vertices( struct vbuf_stage *vbuf ) vbuf->stage.line = vbuf_first_line; vbuf->stage.tri = vbuf_first_tri; } - -static void -vbuf_alloc_vertices( struct vbuf_stage *vbuf ) + +static void +vbuf_alloc_vertices(struct vbuf_stage *vbuf) { if (vbuf->vertex_ptr) { assert(!vbuf->nr_indices); assert(!vbuf->vertices); } - + /* Allocate a new vertex buffer */ - vbuf->max_vertices = vbuf->render->max_vertex_buffer_bytes / vbuf->vertex_size; + vbuf->max_vertices = + vbuf->render->max_vertex_buffer_bytes / vbuf->vertex_size; - if(vbuf->max_vertices >= UNDEFINED_VERTEX_ID) + if (vbuf->max_vertices >= UNDEFINED_VERTEX_ID) vbuf->max_vertices = UNDEFINED_VERTEX_ID - 1; /* Must always succeed -- driver gives us a @@ -378,24 +363,23 @@ vbuf_alloc_vertices( struct vbuf_stage *vbuf ) (ushort) vbuf->vertex_size, (ushort) vbuf->max_vertices); - vbuf->vertices = (uint *) vbuf->render->map_vertices( vbuf->render ); - + vbuf->vertices = (uint *) vbuf->render->map_vertices(vbuf->render); + vbuf->vertex_ptr = vbuf->vertices; } - -static void -vbuf_flush( struct draw_stage *stage, unsigned flags ) +static void +vbuf_flush(struct draw_stage *stage, unsigned flags) { - struct vbuf_stage *vbuf = vbuf_stage( stage ); + struct vbuf_stage *vbuf = vbuf_stage(stage); - vbuf_flush_vertices( vbuf ); + vbuf_flush_vertices(vbuf); } -static void -vbuf_reset_stipple_counter( struct draw_stage *stage ) +static void +vbuf_reset_stipple_counter(struct draw_stage *stage) { /* XXX: Need to do something here for hardware with linestipple. */ @@ -403,28 +387,29 @@ vbuf_reset_stipple_counter( struct draw_stage *stage ) } -static void vbuf_destroy( struct draw_stage *stage ) +static void +vbuf_destroy(struct draw_stage *stage) { - struct vbuf_stage *vbuf = vbuf_stage( stage ); + struct vbuf_stage *vbuf = vbuf_stage(stage); + + if (vbuf->indices) + align_free(vbuf->indices); - if(vbuf->indices) - align_free( vbuf->indices ); - if (vbuf->render) - vbuf->render->destroy( vbuf->render ); + vbuf->render->destroy(vbuf->render); if (vbuf->cache) translate_cache_destroy(vbuf->cache); - FREE( stage ); + FREE(stage); } /** * Create a new primitive vbuf/render stage. */ -struct draw_stage *draw_vbuf_stage( struct draw_context *draw, - struct vbuf_render *render ) +struct draw_stage * +draw_vbuf_stage(struct draw_context *draw, struct vbuf_render *render) { struct vbuf_stage *vbuf = CALLOC_STRUCT(vbuf_stage); if (!vbuf)