[Bf-blender-cvs] SVN commit: /data/svn/bf-blender [47216] branches/soc-2011-tomato/intern/ raskter/raskter.c: make rasterizer thread safe.
Campbell Barton
ideasman42 at gmail.com
Wed May 30 12:24:35 CEST 2012
Revision: 47216
http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-blender&revision=47216
Author: campbellbarton
Date: 2012-05-30 10:24:34 +0000 (Wed, 30 May 2012)
Log Message:
-----------
make rasterizer thread safe.
Modified Paths:
--------------
branches/soc-2011-tomato/intern/raskter/raskter.c
Modified: branches/soc-2011-tomato/intern/raskter/raskter.c
===================================================================
--- branches/soc-2011-tomato/intern/raskter/raskter.c 2012-05-30 09:28:37 UTC (rev 47215)
+++ branches/soc-2011-tomato/intern/raskter/raskter.c 2012-05-30 10:24:34 UTC (rev 47216)
@@ -55,8 +55,11 @@
int sizey;
};
-static struct e_status *all_edges, *possible_edges;
-static struct r_buffer_stats rb;
+struct r_fill_context {
+ struct e_status *all_edges, *possible_edges;
+ struct r_buffer_stats rb;
+};
+
/*
* Sort all the edges of the input polygon by Y, then by X, of the "first" vertex encountered.
* This will ensure we can scan convert the entire poly in one pass.
@@ -65,7 +68,7 @@
* just the poly. Since the DEM code could end up being coupled with this, we'll keep it separate
* for now.
*/
-static void preprocess_all_edges(struct poly_vert *verts, int num_verts, struct e_status *open_edge)
+static void preprocess_all_edges(struct r_fill_context *ctx, struct poly_vert *verts, int num_verts, struct e_status *open_edge)
{
int i;
int xbeg;
@@ -82,7 +85,7 @@
struct poly_vert *v;
/* set up pointers */
v = verts;
- all_edges = NULL;
+ ctx->all_edges = NULL;
/* loop all verts */
for (i = 0; i < num_verts; i++) {
/* determine beginnings and endings of edges, linking last vertex to first vertex */
@@ -148,7 +151,7 @@
e_new->drift_inc = xdist % dy;
e_new->xshift = (xdist / dy) * e_new->xdir;
}
- next_edge_ref = &all_edges;
+ next_edge_ref = &ctx->all_edges;
/* link in all the edges, in sorted order */
for (;; ) {
next_edge = *next_edge_ref;
@@ -168,7 +171,7 @@
* for speed, but waiting on final design choices for curve-data before eliminating data the DEM code will need
* if it ends up being coupled with this function.
*/
-int rast_scan_fill(struct poly_vert *verts, int num_verts)
+int rast_scan_fill(struct r_fill_context *ctx, struct poly_vert *verts, int num_verts)
{
int x_curr; /* current pixel position in X */
int y_curr; /* current scan line being drawn */
@@ -208,13 +211,13 @@
* Do some preprocessing on all edges. This constructs a table structure in memory of all
* the edge properties and can "flip" some edges so sorting works correctly.
*/
- preprocess_all_edges(verts, num_verts, edgbuf);
+ preprocess_all_edges(ctx, verts, num_verts, edgbuf);
/*
* Set the pointer for tracking the edges currently in processing to NULL to make sure
* we don't get some crazy value after initialization.
*/
- possible_edges = NULL;
+ ctx->possible_edges = NULL;
/*
* Loop through all scan lines to be drawn. Since we sorted by Y values during
@@ -229,7 +232,7 @@
* TODO: This clips Y to the frame buffer, which should be done in the preprocessor, but for now is done here.
* Will get changed once DEM code gets in.
*/
- for (y_curr = MAX2(all_edges->ybeg, 0); (all_edges || possible_edges) && (y_curr < rb.sizey); y_curr++) {
+ for (y_curr = MAX2(ctx->all_edges->ybeg, 0); (ctx->all_edges || ctx->possible_edges) && (y_curr < ctx->rb.sizey); y_curr++) {
/*
* Link any edges that start on the current scan line into the list of
@@ -246,16 +249,16 @@
*
* At each iteration, make sure we still have a non-NULL edge.
*/
- for (edgec = &possible_edges; all_edges && (all_edges->ybeg == y_curr); ) {
- x_curr = all_edges->x; /* Set current X position. */
+ for (edgec = &ctx->possible_edges; ctx->all_edges && (ctx->all_edges->ybeg == y_curr); ) {
+ x_curr = ctx->all_edges->x; /* Set current X position. */
for (;; ) { /* Start looping edges. Will break when edges run out. */
e_curr = *edgec; /* Set up a current edge pointer. */
if (!e_curr || (e_curr->x >= x_curr)) { /* If we have an no edge, or we need to skip some X-span, */
- e_temp = all_edges->e_next; /* set a temp "next" edge to test. */
- *edgec = all_edges; /* Add this edge to the list to be scanned. */
- all_edges->e_next = e_curr; /* Set up the next edge. */
- edgec = &all_edges->e_next; /* Set our list to the next edge's location in memory. */
- all_edges = e_temp; /* Skip the NULL or bad X edge, set pointer to next edge. */
+ e_temp = ctx->all_edges->e_next; /* set a temp "next" edge to test. */
+ *edgec = ctx->all_edges; /* Add this edge to the list to be scanned. */
+ ctx->all_edges->e_next = e_curr; /* Set up the next edge. */
+ edgec = &ctx->all_edges->e_next; /* Set our list to the next edge's location in memory. */
+ ctx->all_edges = e_temp; /* Skip the NULL or bad X edge, set pointer to next edge. */
break; /* Stop looping edges (since we ran out or hit empty X span. */
}
else {
@@ -268,11 +271,11 @@
* Determine the current scan line's offset in the pixel buffer based on its Y position.
* Basically we just multiply the current scan line's Y value by the number of pixels in each line.
*/
- yp = y_curr * rb.sizex;
+ yp = y_curr * ctx->rb.sizex;
/*
* Set a "scan line pointer" in memory. The location of the buffer plus the row offset.
*/
- spxl = rb.buf + (yp);
+ spxl = ctx->rb.buf + (yp);
/*
* Set up the current edge to the first (in X) edge. The edges which could possibly be in this
* list were determined in the preceeding edge loop above. They were already sorted in X by the
@@ -281,7 +284,7 @@
* At each iteration, test for a NULL edge. Since we'll keep cycling edge's to their own "next" edge
* we will eventually hit a NULL when the list runs out.
*/
- for (e_curr = possible_edges; e_curr; e_curr = e_curr->e_next) {
+ for (e_curr = ctx->possible_edges; e_curr; e_curr = e_curr->e_next) {
/*
* Calculate a span of pixels to fill on the current scan line.
*
@@ -300,7 +303,7 @@
/* set up xmin and xmax bounds on this scan line */
cpxl = spxl + MAX2(e_curr->x, 0);
e_curr = e_curr->e_next;
- mpxl = spxl + MIN2(e_curr->x, rb.sizex) - 1;
+ mpxl = spxl + MIN2(e_curr->x, ctx->rb.sizex) - 1;
/* draw the pixels. */
for (; cpxl <= mpxl; cpxl++){
@@ -321,7 +324,7 @@
* polygons, we dont have fractional positions, so we only move in x-direction
* when needed to get all the way to the next pixel over...
*/
- for (edgec = &possible_edges; (e_curr = *edgec); ) {
+ for (edgec = &ctx->possible_edges; (e_curr = *edgec); ) {
if (!(--(e_curr->num))) {
*edgec = e_curr->e_next;
}
@@ -342,8 +345,8 @@
* pass, then we know we need to sort by x, so then cycle through edges again and perform
* the sort.-
*/
- if (possible_edges) {
- for (edgec = &possible_edges; (e_curr = *edgec)->e_next; edgec = &(*edgec)->e_next) {
+ if (ctx->possible_edges) {
+ for (edgec = &ctx->possible_edges; (e_curr = *edgec)->e_next; edgec = &(*edgec)->e_next) {
/* if the current edge hits scan line at greater X than the next edge, we need to exchange the edges */
if (e_curr->x > e_curr->e_next->x) {
*edgec = e_curr->e_next;
@@ -359,7 +362,7 @@
for (;; ) {
/* reset exchange flag so it's only set if we encounter another one */
swixd = 0;
- for (edgec = &possible_edges; (e_curr = *edgec)->e_next; edgec = &(*edgec)->e_next) {
+ for (edgec = &ctx->possible_edges; (e_curr = *edgec)->e_next; edgec = &(*edgec)->e_next) {
/* again, if current edge hits scan line at higher X than next edge, exchange the edges and set flag */
if (e_curr->x > e_curr->e_next->x) {
*edgec = e_curr->e_next;
@@ -386,6 +389,7 @@
int PLX_raskterize(float *verts, int num, float *buf, int buf_x, int buf_y) {
int i; /* i: Loop counter. */
struct poly_vert *ply; /* ply: Pointer to a list of integer buffer-space vertex coordinates. */
+ struct r_fill_context ctx = {0};
/*
* Allocate enough memory for our poly_vert list. It'll be the size of the poly_vert
@@ -411,11 +415,11 @@
ply[i].y = (verts[(i << 1) + 1] * buf_y) + 0.5f; /* Range expand normalized Y to integer buffer-space Y. */
}
- rb.buf = buf; /* Set the output buffer pointer. */
- rb.sizex = buf_x; /* Set the output buffer size in X. (width) */
- rb.sizey = buf_y; /* Set the output buffer size in Y. (height) */
+ ctx.rb.buf = buf; /* Set the output buffer pointer. */
+ ctx.rb.sizex = buf_x; /* Set the output buffer size in X. (width) */
+ ctx.rb.sizey = buf_y; /* Set the output buffer size in Y. (height) */
- i = rast_scan_fill(ply, num); /* Call our rasterizer, passing in the integer coords for each vert. */
+ i = rast_scan_fill(&ctx, ply, num); /* Call our rasterizer, passing in the integer coords for each vert. */
free(ply); /* Free the memory allocated for the integer coordinate table. */
return(i); /* Return the value returned by the rasterizer. */
}
More information about the Bf-blender-cvs
mailing list