1
/***************************************************************************
5
Helper routines for polygon rendering.
7
***************************************************************************/
13
/***************************************************************************
15
***************************************************************************/
18
#define KEEP_STATISTICS 0
20
/* turn this on to log the reasons for any long waits */
23
/* number of profiling ticks before we consider a wait "long" */
24
#define LOG_WAIT_THRESHOLD 1000
28
/***************************************************************************
30
***************************************************************************/
32
#define SCANLINES_PER_BUCKET 8
33
#define CACHE_LINE_SIZE 64 /* this is a general guess */
34
#define TOTAL_BUCKETS (512 / SCANLINES_PER_BUCKET)
35
#define UNITS_PER_POLY (100 / SCANLINES_PER_BUCKET)
39
/***************************************************************************
41
***************************************************************************/
43
/* forward definitions */
44
typedef struct _polygon_info polygon_info;
47
/* tri_extent describes start/end points for a scanline */
48
typedef struct _tri_extent tri_extent;
51
INT16 startx; /* starting X coordinate (inclusive) */
52
INT16 stopx; /* ending X coordinate (exclusive) */
56
/* single set of polygon per-parameter data */
57
typedef struct _poly_param poly_param;
60
float start; /* parameter value at starting X,Y */
61
float dpdx; /* dp/dx relative to starting X */
62
float dpdy; /* dp/dy relative to starting Y */
66
/* poly edge is used internally for quad rendering */
67
typedef struct _poly_edge poly_edge;
70
poly_edge * next; /* next edge in sequence */
71
int index; /* index of this edge */
72
const poly_vertex * v1; /* pointer to first vertex */
73
const poly_vertex * v2; /* pointer to second vertex */
74
float dxdy; /* dx/dy along the edge */
75
float dpdy[MAX_VERTEX_PARAMS];/* per-parameter dp/dy values */
79
/* poly section is used internally for quad rendering */
80
typedef struct _poly_section poly_section;
83
const poly_edge * ledge; /* pointer to left edge */
84
const poly_edge * redge; /* pointer to right edge */
85
float ybottom; /* bottom of this section */
89
/* work_unit_shared is a common set of data shared between tris and quads */
90
typedef struct _work_unit_shared work_unit_shared;
91
struct _work_unit_shared
93
polygon_info * polygon; /* pointer to polygon */
94
volatile UINT32 count_next; /* number of scanlines and index of next item to process */
95
INT16 scanline; /* starting scanline and count */
96
UINT16 previtem; /* index of previous item in the same bucket */
98
UINT32 dummy; /* pad to 16 bytes */
103
/* tri_work_unit is a triangle-specific work-unit */
104
typedef struct _tri_work_unit tri_work_unit;
105
struct _tri_work_unit
107
work_unit_shared shared; /* shared data */
108
tri_extent extent[SCANLINES_PER_BUCKET]; /* array of scanline extents */
112
/* quad_work_unit is a quad-specific work-unit */
113
typedef struct _quad_work_unit quad_work_unit;
114
struct _quad_work_unit
116
work_unit_shared shared; /* shared data */
117
poly_extent extent[SCANLINES_PER_BUCKET]; /* array of scanline extents */
121
/* work_unit is a union of the two types */
122
typedef union _work_unit work_unit;
125
work_unit_shared shared; /* shared data */
126
tri_work_unit tri; /* triangle work unit */
127
quad_work_unit quad; /* quad work unit */
131
/* polygon_info describes a single polygon, which includes the poly_params */
134
poly_manager * poly; /* pointer back to the poly manager */
135
void * dest; /* pointer to the destination we are rendering to */
136
void * extra; /* extra data pointer */
137
UINT8 numparams; /* number of parameters for this polygon */
138
UINT8 numverts; /* number of vertices in this polygon */
139
poly_draw_scanline_func callback; /* callback to handle a scanline's worth of work */
140
INT32 xorigin; /* X origin for all parameters */
141
INT32 yorigin; /* Y origin for all parameters */
142
poly_param param[MAX_VERTEX_PARAMS];/* array of parameter data */
146
/* full poly manager description */
149
/* queue management */
150
osd_work_queue * queue; /* work queue */
152
/* triangle work units */
153
work_unit ** unit; /* array of work unit pointers */
154
UINT32 unit_next; /* index of next unit to allocate */
155
UINT32 unit_count; /* number of work units available */
156
size_t unit_size; /* size of each work unit, in bytes */
158
/* quad work units */
159
UINT32 quadunit_next; /* index of next unit to allocate */
160
UINT32 quadunit_count; /* number of work units available */
161
size_t quadunit_size; /* size of each work unit, in bytes */
164
polygon_info ** polygon; /* array of polygon pointers */
165
UINT32 polygon_next; /* index of next polygon to allocate */
166
UINT32 polygon_count; /* number of polygon items available */
167
size_t polygon_size; /* size of each polygon, in bytes */
170
void ** extra; /* array of extra data pointers */
171
UINT32 extra_next; /* index of next extra data to allocate */
172
UINT32 extra_count; /* number of extra data items available */
173
size_t extra_size; /* size of each extra data, in bytes */
176
UINT8 flags; /* flags */
179
UINT16 unit_bucket[TOTAL_BUCKETS]; /* buckets for tracking unit usage */
182
UINT32 triangles; /* number of triangles queued */
183
UINT32 quads; /* number of quads queued */
184
UINT64 pixels; /* number of pixels rendered */
186
UINT32 unit_waits; /* number of times we waited for a unit */
187
UINT32 unit_max; /* maximum units used */
188
UINT32 polygon_waits; /* number of times we waited for a polygon */
189
UINT32 polygon_max; /* maximum polygons used */
190
UINT32 extra_waits; /* number of times we waited for an extra data */
191
UINT32 extra_max; /* maximum extra data used */
192
UINT32 conflicts[WORK_MAX_THREADS]; /* number of conflicts found, per thread */
193
UINT32 resolved[WORK_MAX_THREADS]; /* number of conflicts resolved, per thread */
199
/***************************************************************************
201
***************************************************************************/
203
static void **allocate_array(running_machine &machine, size_t *itemsize, UINT32 itemcount);
204
static void *poly_item_callback(void *param, int threadid);
205
static void poly_state_presave(poly_manager *poly);
209
/***************************************************************************
211
***************************************************************************/
213
/*-------------------------------------------------
214
round_coordinate - round a coordinate to
215
an integer, following rules that 0.5 rounds
217
-------------------------------------------------*/
219
INLINE INT32 round_coordinate(float value)
221
INT32 result = floor(value);
222
return result + (value - (float)result > 0.5f);
226
/*-------------------------------------------------
227
convert_tri_extent_to_poly_extent - convert
228
a simple tri_extent to a full poly_extent
229
-------------------------------------------------*/
231
INLINE void convert_tri_extent_to_poly_extent(poly_extent *dstextent, const tri_extent *srcextent, const polygon_info *polygon, INT32 y)
233
/* copy start/stop always */
234
dstextent->startx = srcextent->startx;
235
dstextent->stopx = srcextent->stopx;
237
/* if we have parameters, process them as well */
238
for (int paramnum = 0; paramnum < polygon->numparams; paramnum++)
240
dstextent->param[paramnum].start = polygon->param[paramnum].start + srcextent->startx * polygon->param[paramnum].dpdx + y * polygon->param[paramnum].dpdy;
241
dstextent->param[paramnum].dpdx = polygon->param[paramnum].dpdx;
246
/*-------------------------------------------------
247
interpolate_vertex - interpolate values in
248
a vertex based on p[0] crossing the clipval
249
-------------------------------------------------*/
251
INLINE void interpolate_vertex(poly_vertex *outv, const poly_vertex *v1, const poly_vertex *v2, int paramcount, float clipval)
253
float frac = (clipval - v1->p[0]) / (v2->p[0] - v1->p[0]);
256
/* create a new one at the intersection point */
257
outv->x = v1->x + frac * (v2->x - v1->x);
258
outv->y = v1->y + frac * (v2->y - v1->y);
259
for (paramnum = 0; paramnum < paramcount; paramnum++)
260
outv->p[paramnum] = v1->p[paramnum] + frac * (v2->p[paramnum] - v1->p[paramnum]);
264
/*-------------------------------------------------
265
copy_vertex - copy vertex data from one to
267
-------------------------------------------------*/
269
INLINE void copy_vertex(poly_vertex *outv, const poly_vertex *v, int paramcount)
275
for (paramnum = 0; paramnum < paramcount; paramnum++)
276
outv->p[paramnum] = v->p[paramnum];
280
/*-------------------------------------------------
281
allocate_polygon - allocate a new polygon
282
object, blocking if we run out
283
-------------------------------------------------*/
285
INLINE polygon_info *allocate_polygon(poly_manager *poly, int miny, int maxy)
287
/* wait for a work item if we have to */
288
if (poly->polygon_next + 1 > poly->polygon_count)
290
poly_wait(poly, "Out of polygons");
292
poly->polygon_waits++;
295
else if (poly->unit_next + (maxy - miny) / SCANLINES_PER_BUCKET + 2 > poly->unit_count)
297
poly_wait(poly, "Out of work units");
303
poly->polygon_max = MAX(poly->polygon_max, poly->polygon_next + 1);
305
return poly->polygon[poly->polygon_next++];
310
/***************************************************************************
311
INITIALIZATION/TEARDOWN
312
***************************************************************************/
314
/*-------------------------------------------------
315
poly_alloc - initialize a new polygon
317
-------------------------------------------------*/
319
poly_manager *poly_alloc(running_machine &machine, int max_polys, size_t extra_data_size, UINT8 flags)
323
/* allocate the manager itself */
324
poly = auto_alloc_clear(machine, poly_manager);
327
/* allocate polygons */
328
poly->polygon_size = sizeof(polygon_info);
329
poly->polygon_count = MAX(max_polys, 1);
330
poly->polygon_next = 0;
331
poly->polygon = (polygon_info **)allocate_array(machine, &poly->polygon_size, poly->polygon_count);
333
/* allocate extra data */
334
poly->extra_size = extra_data_size;
335
poly->extra_count = poly->polygon_count;
336
poly->extra_next = 1;
337
poly->extra = allocate_array(machine, &poly->extra_size, poly->extra_count);
339
/* allocate triangle work units */
340
poly->unit_size = (flags & POLYFLAG_ALLOW_QUADS) ? sizeof(quad_work_unit) : sizeof(tri_work_unit);
341
poly->unit_count = MIN(poly->polygon_count * UNITS_PER_POLY, 65535);
343
poly->unit = (work_unit **)allocate_array(machine, &poly->unit_size, poly->unit_count);
345
/* create the work queue */
346
if (!(flags & POLYFLAG_NO_WORK_QUEUE))
347
poly->queue = osd_work_queue_alloc(WORK_QUEUE_FLAG_MULTI | WORK_QUEUE_FLAG_HIGH_FREQ);
349
/* request a pre-save callback for synchronization */
350
machine.save().register_presave(save_prepost_delegate(FUNC(poly_state_presave), poly));
355
/*-------------------------------------------------
356
poly_free - free a polygon manager
357
-------------------------------------------------*/
359
void poly_free(poly_manager *poly)
363
int i, conflicts = 0, resolved = 0;
364
for (i = 0; i < ARRAY_LENGTH(poly->conflicts); i++)
366
conflicts += poly->conflicts[i];
367
resolved += poly->resolved[i];
369
printf("Total triangles = %d\n", poly->triangles);
370
printf("Total quads = %d\n", poly->quads);
371
if (poly->pixels > 1000000000)
372
printf("Total pixels = %d%09d\n", (UINT32)(poly->pixels / 1000000000), (UINT32)(poly->pixels % 1000000000));
374
printf("Total pixels = %d\n", (UINT32)poly->pixels);
375
printf("Conflicts: %d resolved, %d total\n", resolved, conflicts);
376
printf("Units: %5d used, %5d allocated, %5d waits, %4d bytes each, %7d total\n", poly->unit_max, poly->unit_count, poly->unit_waits, poly->unit_size, poly->unit_count * poly->unit_size);
377
printf("Polygons: %5d used, %5d allocated, %5d waits, %4d bytes each, %7d total\n", poly->polygon_max, poly->polygon_count, poly->polygon_waits, poly->polygon_size, poly->polygon_count * poly->polygon_size);
378
printf("Extra data: %5d used, %5d allocated, %5d waits, %4d bytes each, %7d total\n", poly->extra_max, poly->extra_count, poly->extra_waits, poly->extra_size, poly->extra_count * poly->extra_size);
382
/* free the work queue */
383
if (poly->queue != NULL)
384
osd_work_queue_free(poly->queue);
389
/***************************************************************************
391
***************************************************************************/
393
/*-------------------------------------------------
394
poly_wait - wait for all pending rendering
396
-------------------------------------------------*/
398
void poly_wait(poly_manager *poly, const char *debug_reason)
402
/* remember the start time if we're logging */
404
time = get_profile_ticks();
406
/* wait for all pending work items to complete */
407
if (poly->queue != NULL)
408
osd_work_queue_wait(poly->queue, osd_ticks_per_second() * 100);
410
/* if we don't have a queue, just run the whole list now */
414
for (unitnum = 0; unitnum < poly->unit_next; unitnum++)
415
poly_item_callback(poly->unit[unitnum], 0);
418
/* log any long waits */
421
time = get_profile_ticks() - time;
422
if (time > LOG_WAIT_THRESHOLD)
423
logerror("Poly:Waited %d cycles for %s\n", (int)time, debug_reason);
426
/* reset the state */
427
poly->polygon_next = poly->unit_next = 0;
428
memset(poly->unit_bucket, 0xff, sizeof(poly->unit_bucket));
430
/* we need to preserve the last extra data that was supplied */
431
if (poly->extra_next > 1)
432
memcpy(poly->extra[0], poly->extra[poly->extra_next - 1], poly->extra_size);
433
poly->extra_next = 1;
437
/*-------------------------------------------------
438
poly_get_extra_data - get a pointer to the
439
extra data for the next polygon
440
-------------------------------------------------*/
442
void *poly_get_extra_data(poly_manager *poly)
444
/* wait for a work item if we have to */
445
if (poly->extra_next + 1 > poly->extra_count)
447
poly_wait(poly, "Out of extra data");
453
/* return a pointer to the extra data for the next item */
455
poly->extra_max = MAX(poly->extra_max, poly->extra_next + 1);
457
return poly->extra[poly->extra_next++];
462
/***************************************************************************
463
CORE TRIANGLE RENDERING
464
***************************************************************************/
466
/*-------------------------------------------------
467
poly_render_triangle - render a single
468
triangle given 3 vertexes
469
-------------------------------------------------*/
471
UINT32 poly_render_triangle(poly_manager *poly, void *dest, const rectangle *cliprect, poly_draw_scanline_func callback, int paramcount, const poly_vertex *v1, const poly_vertex *v2, const poly_vertex *v3)
473
float dxdy_v1v2, dxdy_v1v3, dxdy_v2v3;
474
const poly_vertex *tv;
475
INT32 curscan, scaninc;
476
polygon_info *polygon;
477
INT32 v1yclip, v3yclip;
482
/* first sort by Y */
502
/* compute some integral X/Y vertex values */
503
v1x = round_coordinate(v1->x);
504
v1y = round_coordinate(v1->y);
505
v3y = round_coordinate(v3->y);
507
/* clip coordinates */
509
v3yclip = v3y + ((poly->flags & POLYFLAG_INCLUDE_BOTTOM_EDGE) ? 1 : 0);
510
if (cliprect != NULL)
512
v1yclip = MAX(v1yclip, cliprect->min_y);
513
v3yclip = MIN(v3yclip, cliprect->max_y + 1);
515
if (v3yclip - v1yclip <= 0)
518
/* allocate a new polygon */
519
polygon = allocate_polygon(poly, v1yclip, v3yclip);
521
/* fill in the polygon information */
522
polygon->poly = poly;
523
polygon->dest = dest;
524
polygon->callback = callback;
525
polygon->extra = poly->extra[poly->extra_next - 1];
526
polygon->numparams = paramcount;
527
polygon->numverts = 3;
529
/* set the start X/Y coordinates */
530
polygon->xorigin = v1x;
531
polygon->yorigin = v1y;
533
/* compute the slopes for each portion of the triangle */
534
dxdy_v1v2 = (v2->y == v1->y) ? 0.0f : (v2->x - v1->x) / (v2->y - v1->y);
535
dxdy_v1v3 = (v3->y == v1->y) ? 0.0f : (v3->x - v1->x) / (v3->y - v1->y);
536
dxdy_v2v3 = (v3->y == v2->y) ? 0.0f : (v3->x - v2->x) / (v3->y - v2->y);
538
/* compute the X extents for each scanline */
539
startunit = poly->unit_next;
540
for (curscan = v1yclip; curscan < v3yclip; curscan += scaninc)
542
UINT32 bucketnum = ((UINT32)curscan / SCANLINES_PER_BUCKET) % TOTAL_BUCKETS;
543
UINT32 unit_index = poly->unit_next++;
544
tri_work_unit *unit = &poly->unit[unit_index]->tri;
547
/* determine how much to advance to hit the next bucket */
548
scaninc = SCANLINES_PER_BUCKET - (UINT32)curscan % SCANLINES_PER_BUCKET;
550
/* fill in the work unit basics */
551
unit->shared.polygon = polygon;
552
unit->shared.count_next = MIN(v3yclip - curscan, scaninc);
553
unit->shared.scanline = curscan;
554
unit->shared.previtem = poly->unit_bucket[bucketnum];
555
poly->unit_bucket[bucketnum] = unit_index;
557
/* iterate over extents */
558
for (extnum = 0; extnum < unit->shared.count_next; extnum++)
560
float fully = (float)(curscan + extnum) + 0.5f;
561
float startx = v1->x + (fully - v1->y) * dxdy_v1v3;
563
INT32 istartx, istopx;
565
/* compute the ending X based on which part of the triangle we're in */
567
stopx = v1->x + (fully - v1->y) * dxdy_v1v2;
569
stopx = v2->x + (fully - v2->y) * dxdy_v2v3;
571
/* clamp to full pixels */
572
istartx = round_coordinate(startx);
573
istopx = round_coordinate(stopx);
575
/* force start < stop */
576
if (istartx > istopx)
578
INT32 temp = istartx;
583
/* include the right edge if requested */
584
if (poly->flags & POLYFLAG_INCLUDE_RIGHT_EDGE)
587
/* apply left/right clipping */
588
if (cliprect != NULL)
590
if (istartx < cliprect->min_x)
591
istartx = cliprect->min_x;
592
if (istopx > cliprect->max_x)
593
istopx = cliprect->max_x + 1;
596
/* set the extent and update the total pixel count */
597
if (istartx >= istopx)
598
istartx = istopx = 0;
599
unit->extent[extnum].startx = istartx;
600
unit->extent[extnum].stopx = istopx;
601
pixels += istopx - istartx;
605
poly->unit_max = MAX(poly->unit_max, poly->unit_next);
608
/* compute parameter starting points and deltas */
611
float a00 = v2->y - v3->y;
612
float a01 = v3->x - v2->x;
613
float a02 = v2->x*v3->y - v3->x*v2->y;
614
float a10 = v3->y - v1->y;
615
float a11 = v1->x - v3->x;
616
float a12 = v3->x*v1->y - v1->x*v3->y;
617
float a20 = v1->y - v2->y;
618
float a21 = v2->x - v1->x;
619
float a22 = v1->x*v2->y - v2->x*v1->y;
620
float det = a02 + a12 + a22;
622
if(fabsf(det) < 0.001) {
623
for (int paramnum = 0; paramnum < paramcount; paramnum++)
625
poly_param *params = &polygon->param[paramnum];
628
params->start = v1->p[paramnum];
634
for (int paramnum = 0; paramnum < paramcount; paramnum++)
636
poly_param *params = &polygon->param[paramnum];
637
params->dpdx = idet*(v1->p[paramnum]*a00 + v2->p[paramnum]*a10 + v3->p[paramnum]*a20);
638
params->dpdy = idet*(v1->p[paramnum]*a01 + v2->p[paramnum]*a11 + v3->p[paramnum]*a21);
639
params->start = idet*(v1->p[paramnum]*a02 + v2->p[paramnum]*a12 + v3->p[paramnum]*a22);
644
/* enqueue the work items */
645
if (poly->queue != NULL)
646
osd_work_item_queue_multiple(poly->queue, poly_item_callback, poly->unit_next - startunit, poly->unit[startunit], poly->unit_size, WORK_ITEM_FLAG_AUTO_RELEASE);
648
/* return the total number of pixels in the triangle */
650
poly->pixels += pixels;
655
/*-------------------------------------------------
656
poly_render_triangle_fan - render a set of
658
-------------------------------------------------*/
660
UINT32 poly_render_triangle_fan(poly_manager *poly, void *dest, const rectangle *cliprect, poly_draw_scanline_func callback, int paramcount, int numverts, const poly_vertex *v)
665
/* iterate over vertices */
666
for (vertnum = 2; vertnum < numverts; vertnum++)
667
pixels += poly_render_triangle(poly, dest, cliprect, callback, paramcount, &v[0], &v[vertnum - 1], &v[vertnum]);
672
/*-------------------------------------------------
673
poly_render_triangle_custom - perform a custom
674
render of an object, given specific extents
675
-------------------------------------------------*/
677
UINT32 poly_render_triangle_custom(poly_manager *poly, void *dest, const rectangle *cliprect, poly_draw_scanline_func callback, int startscanline, int numscanlines, const poly_extent *extents)
679
INT32 curscan, scaninc;
680
polygon_info *polygon;
681
INT32 v1yclip, v3yclip;
685
/* clip coordinates */
686
if (cliprect != NULL)
688
v1yclip = MAX(startscanline, cliprect->min_y);
689
v3yclip = MIN(startscanline + numscanlines, cliprect->max_y + 1);
693
v1yclip = startscanline;
694
v3yclip = startscanline + numscanlines;
696
if (v3yclip - v1yclip <= 0)
699
/* allocate a new polygon */
700
polygon = allocate_polygon(poly, v1yclip, v3yclip);
702
/* fill in the polygon information */
703
polygon->poly = poly;
704
polygon->dest = dest;
705
polygon->callback = callback;
706
polygon->extra = poly->extra[poly->extra_next - 1];
707
polygon->numparams = 0;
708
polygon->numverts = 3;
710
/* compute the X extents for each scanline */
711
startunit = poly->unit_next;
712
for (curscan = v1yclip; curscan < v3yclip; curscan += scaninc)
714
UINT32 bucketnum = ((UINT32)curscan / SCANLINES_PER_BUCKET) % TOTAL_BUCKETS;
715
UINT32 unit_index = poly->unit_next++;
716
tri_work_unit *unit = &poly->unit[unit_index]->tri;
719
/* determine how much to advance to hit the next bucket */
720
scaninc = SCANLINES_PER_BUCKET - (UINT32)curscan % SCANLINES_PER_BUCKET;
722
/* fill in the work unit basics */
723
unit->shared.polygon = polygon;
724
unit->shared.count_next = MIN(v3yclip - curscan, scaninc);
725
unit->shared.scanline = curscan;
726
unit->shared.previtem = poly->unit_bucket[bucketnum];
727
poly->unit_bucket[bucketnum] = unit_index;
729
/* iterate over extents */
730
for (extnum = 0; extnum < unit->shared.count_next; extnum++)
732
const poly_extent *extent = &extents[(curscan + extnum) - startscanline];
733
INT32 istartx = extent->startx, istopx = extent->stopx;
735
/* force start < stop */
736
if (istartx > istopx)
738
INT32 temp = istartx;
743
/* apply left/right clipping */
744
if (cliprect != NULL)
746
if (istartx < cliprect->min_x)
747
istartx = cliprect->min_x;
748
if (istopx > cliprect->max_x)
749
istopx = cliprect->max_x + 1;
752
/* set the extent and update the total pixel count */
753
unit->extent[extnum].startx = istartx;
754
unit->extent[extnum].stopx = istopx;
755
if (istartx < istopx)
756
pixels += istopx - istartx;
760
poly->unit_max = MAX(poly->unit_max, poly->unit_next);
763
/* enqueue the work items */
764
if (poly->queue != NULL)
765
osd_work_item_queue_multiple(poly->queue, poly_item_callback, poly->unit_next - startunit, poly->unit[startunit], poly->unit_size, WORK_ITEM_FLAG_AUTO_RELEASE);
767
/* return the total number of pixels in the object */
769
poly->pixels += pixels;
775
/***************************************************************************
777
***************************************************************************/
779
/*-------------------------------------------------
780
poly_render_quad - render a single quad
782
-------------------------------------------------*/
784
UINT32 poly_render_quad(poly_manager *poly, void *dest, const rectangle *cliprect, poly_draw_scanline_func callback, int paramcount, const poly_vertex *v1, const poly_vertex *v2, const poly_vertex *v3, const poly_vertex *v4)
786
poly_edge fedgelist[3], bedgelist[3];
787
const poly_edge *ledge, *redge;
788
const poly_vertex *v[4];
790
int minv, maxv, curv;
791
INT32 minyclip, maxyclip;
793
INT32 curscan, scaninc;
794
polygon_info *polygon;
798
assert(poly->flags & POLYFLAG_ALLOW_QUADS);
800
/* arrays make things easier */
806
/* determine min/max Y vertices */
807
if (v[1]->y < v[0]->y)
811
if (v[2]->y < v[minv]->y)
813
else if (v[2]->y > v[maxv]->y)
815
if (v[3]->y < v[minv]->y)
817
else if (v[3]->y > v[maxv]->y)
820
/* determine start/end scanlines */
821
miny = round_coordinate(v[minv]->y);
822
maxy = round_coordinate(v[maxv]->y);
824
/* clip coordinates */
826
maxyclip = maxy + ((poly->flags & POLYFLAG_INCLUDE_BOTTOM_EDGE) ? 1 : 0);
827
if (cliprect != NULL)
829
minyclip = MAX(minyclip, cliprect->min_y);
830
maxyclip = MIN(maxyclip, cliprect->max_y + 1);
832
if (maxyclip - minyclip <= 0)
835
/* allocate a new polygon */
836
polygon = allocate_polygon(poly, minyclip, maxyclip);
838
/* fill in the polygon information */
839
polygon->poly = poly;
840
polygon->dest = dest;
841
polygon->callback = callback;
842
polygon->extra = poly->extra[poly->extra_next - 1];
843
polygon->numparams = paramcount;
844
polygon->numverts = 4;
846
/* walk forward to build up the forward edge list */
847
edgeptr = &fedgelist[0];
848
for (curv = minv; curv != maxv; curv = (curv + 1) & 3)
853
/* set the two vertices */
854
edgeptr->v1 = v[curv];
855
edgeptr->v2 = v[(curv + 1) & 3];
857
/* if horizontal, skip altogether */
858
if (edgeptr->v1->y == edgeptr->v2->y)
861
/* need dx/dy always, and parameter deltas as necessary */
862
ooy = 1.0f / (edgeptr->v2->y - edgeptr->v1->y);
863
edgeptr->dxdy = (edgeptr->v2->x - edgeptr->v1->x) * ooy;
864
for (paramnum = 0; paramnum < paramcount; paramnum++)
865
edgeptr->dpdy[paramnum] = (edgeptr->v2->p[paramnum] - edgeptr->v1->p[paramnum]) * ooy;
869
/* walk backward to build up the backward edge list */
870
edgeptr = &bedgelist[0];
871
for (curv = minv; curv != maxv; curv = (curv - 1) & 3)
876
/* set the two vertices */
877
edgeptr->v1 = v[curv];
878
edgeptr->v2 = v[(curv - 1) & 3];
880
/* if horizontal, skip altogether */
881
if (edgeptr->v1->y == edgeptr->v2->y)
884
/* need dx/dy always, and parameter deltas as necessary */
885
ooy = 1.0f / (edgeptr->v2->y - edgeptr->v1->y);
886
edgeptr->dxdy = (edgeptr->v2->x - edgeptr->v1->x) * ooy;
887
for (paramnum = 0; paramnum < paramcount; paramnum++)
888
edgeptr->dpdy[paramnum] = (edgeptr->v2->p[paramnum] - edgeptr->v1->p[paramnum]) * ooy;
892
/* determine which list is left/right: */
893
/* if the first vertex is shared, compare the slopes */
894
/* if the first vertex is not shared, compare the X coordinates */
895
if ((fedgelist[0].v1 == bedgelist[0].v1 && fedgelist[0].dxdy < bedgelist[0].dxdy) ||
896
(fedgelist[0].v1 != bedgelist[0].v1 && fedgelist[0].v1->x < bedgelist[0].v1->x))
907
/* compute the X extents for each scanline */
908
startunit = poly->unit_next;
909
for (curscan = minyclip; curscan < maxyclip; curscan += scaninc)
911
UINT32 bucketnum = ((UINT32)curscan / SCANLINES_PER_BUCKET) % TOTAL_BUCKETS;
912
UINT32 unit_index = poly->unit_next++;
913
quad_work_unit *unit = &poly->unit[unit_index]->quad;
916
/* determine how much to advance to hit the next bucket */
917
scaninc = SCANLINES_PER_BUCKET - (UINT32)curscan % SCANLINES_PER_BUCKET;
919
/* fill in the work unit basics */
920
unit->shared.polygon = polygon;
921
unit->shared.count_next = MIN(maxyclip - curscan, scaninc);
922
unit->shared.scanline = curscan;
923
unit->shared.previtem = poly->unit_bucket[bucketnum];
924
poly->unit_bucket[bucketnum] = unit_index;
926
/* iterate over extents */
927
for (extnum = 0; extnum < unit->shared.count_next; extnum++)
929
float fully = (float)(curscan + extnum) + 0.5f;
931
INT32 istartx, istopx;
934
/* compute the ending X based on which part of the triangle we're in */
935
while (fully > ledge->v2->y && fully < v[maxv]->y)
937
while (fully > redge->v2->y && fully < v[maxv]->y)
939
startx = ledge->v1->x + (fully - ledge->v1->y) * ledge->dxdy;
940
stopx = redge->v1->x + (fully - redge->v1->y) * redge->dxdy;
942
/* clamp to full pixels */
943
istartx = round_coordinate(startx);
944
istopx = round_coordinate(stopx);
946
/* compute parameter starting points and deltas */
949
float ldy = fully - ledge->v1->y;
950
float rdy = fully - redge->v1->y;
951
float oox = 1.0f / (stopx - startx);
953
/* iterate over parameters */
954
for (paramnum = 0; paramnum < paramcount; paramnum++)
956
float lparam = ledge->v1->p[paramnum] + ldy * ledge->dpdy[paramnum];
957
float rparam = redge->v1->p[paramnum] + rdy * redge->dpdy[paramnum];
958
float dpdx = (rparam - lparam) * oox;
960
unit->extent[extnum].param[paramnum].start = lparam;// - ((float)istartx + 0.5f) * dpdx;
961
unit->extent[extnum].param[paramnum].dpdx = dpdx;
965
/* include the right edge if requested */
966
if (poly->flags & POLYFLAG_INCLUDE_RIGHT_EDGE)
969
/* apply left/right clipping */
970
if (cliprect != NULL)
972
if (istartx < cliprect->min_x)
974
for (paramnum = 0; paramnum < paramcount; paramnum++)
975
unit->extent[extnum].param[paramnum].start += (cliprect->min_x - istartx) * unit->extent[extnum].param[paramnum].dpdx;
976
istartx = cliprect->min_x;
978
if (istopx > cliprect->max_x)
979
istopx = cliprect->max_x + 1;
982
/* set the extent and update the total pixel count */
983
if (istartx >= istopx)
984
istartx = istopx = 0;
985
unit->extent[extnum].startx = istartx;
986
unit->extent[extnum].stopx = istopx;
987
pixels += istopx - istartx;
991
poly->unit_max = MAX(poly->unit_max, poly->unit_next);
994
/* enqueue the work items */
995
if (poly->queue != NULL)
996
osd_work_item_queue_multiple(poly->queue, poly_item_callback, poly->unit_next - startunit, poly->unit[startunit], poly->unit_size, WORK_ITEM_FLAG_AUTO_RELEASE);
998
/* return the total number of pixels in the triangle */
1000
poly->pixels += pixels;
1005
/*-------------------------------------------------
1006
poly_render_quad_fan - render a set of
1008
-------------------------------------------------*/
1010
UINT32 poly_render_quad_fan(poly_manager *poly, void *dest, const rectangle *cliprect, poly_draw_scanline_func callback, int paramcount, int numverts, const poly_vertex *v)
1015
/* iterate over vertices */
1016
for (vertnum = 2; vertnum < numverts; vertnum += 2)
1017
pixels += poly_render_quad(poly, dest, cliprect, callback, paramcount, &v[0], &v[vertnum - 1], &v[vertnum], &v[MIN(vertnum + 1, numverts - 1)]);
1023
/***************************************************************************
1024
CORE POLYGON RENDERING
1025
***************************************************************************/
1027
/*-------------------------------------------------
1028
poly_render_polygon - render a single polygon up
1030
-------------------------------------------------*/
1032
UINT32 poly_render_polygon(poly_manager *poly, void *dest, const rectangle *cliprect, poly_draw_scanline_func callback, int paramcount, int numverts, const poly_vertex *v)
1034
poly_edge fedgelist[MAX_POLYGON_VERTS - 1], bedgelist[MAX_POLYGON_VERTS - 1];
1035
const poly_edge *ledge, *redge;
1037
int minv, maxv, curv;
1038
INT32 minyclip, maxyclip;
1040
INT32 curscan, scaninc;
1041
polygon_info *polygon;
1046
assert(poly->flags & POLYFLAG_ALLOW_QUADS);
1048
/* determine min/max Y vertices */
1050
for (vertnum = 1; vertnum < numverts; vertnum++)
1052
if (v[vertnum].y < v[minv].y)
1054
else if (v[vertnum].y > v[maxv].y)
1058
/* determine start/end scanlines */
1059
miny = round_coordinate(v[minv].y);
1060
maxy = round_coordinate(v[maxv].y);
1062
/* clip coordinates */
1064
maxyclip = maxy + ((poly->flags & POLYFLAG_INCLUDE_BOTTOM_EDGE) ? 1 : 0);
1065
if (cliprect != NULL)
1067
minyclip = MAX(minyclip, cliprect->min_y);
1068
maxyclip = MIN(maxyclip, cliprect->max_y + 1);
1070
if (maxyclip - minyclip <= 0)
1073
/* allocate a new polygon */
1074
polygon = allocate_polygon(poly, minyclip, maxyclip);
1076
/* fill in the polygon information */
1077
polygon->poly = poly;
1078
polygon->dest = dest;
1079
polygon->callback = callback;
1080
polygon->extra = poly->extra[poly->extra_next - 1];
1081
polygon->numparams = paramcount;
1082
polygon->numverts = numverts;
1084
/* walk forward to build up the forward edge list */
1085
edgeptr = &fedgelist[0];
1086
for (curv = minv; curv != maxv; curv = (curv == numverts - 1) ? 0 : (curv + 1))
1091
/* set the two vertices */
1092
edgeptr->v1 = &v[curv];
1093
edgeptr->v2 = &v[(curv == numverts - 1) ? 0 : (curv + 1)];
1095
/* if horizontal, skip altogether */
1096
if (edgeptr->v1->y == edgeptr->v2->y)
1099
/* need dx/dy always, and parameter deltas as necessary */
1100
ooy = 1.0f / (edgeptr->v2->y - edgeptr->v1->y);
1101
edgeptr->dxdy = (edgeptr->v2->x - edgeptr->v1->x) * ooy;
1102
for (paramnum = 0; paramnum < paramcount; paramnum++)
1103
edgeptr->dpdy[paramnum] = (edgeptr->v2->p[paramnum] - edgeptr->v1->p[paramnum]) * ooy;
1107
/* walk backward to build up the backward edge list */
1108
edgeptr = &bedgelist[0];
1109
for (curv = minv; curv != maxv; curv = (curv == 0) ? (numverts - 1) : (curv - 1))
1114
/* set the two vertices */
1115
edgeptr->v1 = &v[curv];
1116
edgeptr->v2 = &v[(curv == 0) ? (numverts - 1) : (curv - 1)];
1118
/* if horizontal, skip altogether */
1119
if (edgeptr->v1->y == edgeptr->v2->y)
1122
/* need dx/dy always, and parameter deltas as necessary */
1123
ooy = 1.0f / (edgeptr->v2->y - edgeptr->v1->y);
1124
edgeptr->dxdy = (edgeptr->v2->x - edgeptr->v1->x) * ooy;
1125
for (paramnum = 0; paramnum < paramcount; paramnum++)
1126
edgeptr->dpdy[paramnum] = (edgeptr->v2->p[paramnum] - edgeptr->v1->p[paramnum]) * ooy;
1130
/* determine which list is left/right: */
1131
/* if the first vertex is shared, compare the slopes */
1132
/* if the first vertex is not shared, compare the X coordinates */
1133
if ((fedgelist[0].v1 == bedgelist[0].v1 && fedgelist[0].dxdy < bedgelist[0].dxdy) ||
1134
(fedgelist[0].v1 != bedgelist[0].v1 && fedgelist[0].v1->x < bedgelist[0].v1->x))
1145
/* compute the X extents for each scanline */
1146
startunit = poly->unit_next;
1147
for (curscan = minyclip; curscan < maxyclip; curscan += scaninc)
1149
UINT32 bucketnum = ((UINT32)curscan / SCANLINES_PER_BUCKET) % TOTAL_BUCKETS;
1150
UINT32 unit_index = poly->unit_next++;
1151
quad_work_unit *unit = &poly->unit[unit_index]->quad;
1154
/* determine how much to advance to hit the next bucket */
1155
scaninc = SCANLINES_PER_BUCKET - (UINT32)curscan % SCANLINES_PER_BUCKET;
1157
/* fill in the work unit basics */
1158
unit->shared.polygon = polygon;
1159
unit->shared.count_next = MIN(maxyclip - curscan, scaninc);
1160
unit->shared.scanline = curscan;
1161
unit->shared.previtem = poly->unit_bucket[bucketnum];
1162
poly->unit_bucket[bucketnum] = unit_index;
1164
/* iterate over extents */
1165
for (extnum = 0; extnum < unit->shared.count_next; extnum++)
1167
float fully = (float)(curscan + extnum) + 0.5f;
1168
float startx, stopx;
1169
INT32 istartx, istopx;
1172
/* compute the ending X based on which part of the triangle we're in */
1173
while (fully > ledge->v2->y && fully < v[maxv].y)
1175
while (fully > redge->v2->y && fully < v[maxv].y)
1177
startx = ledge->v1->x + (fully - ledge->v1->y) * ledge->dxdy;
1178
stopx = redge->v1->x + (fully - redge->v1->y) * redge->dxdy;
1180
/* clamp to full pixels */
1181
istartx = round_coordinate(startx);
1182
istopx = round_coordinate(stopx);
1184
/* compute parameter starting points and deltas */
1187
float ldy = fully - ledge->v1->y;
1188
float rdy = fully - redge->v1->y;
1189
float oox = 1.0f / (stopx - startx);
1191
/* iterate over parameters */
1192
for (paramnum = 0; paramnum < paramcount; paramnum++)
1194
float lparam = ledge->v1->p[paramnum] + ldy * ledge->dpdy[paramnum];
1195
float rparam = redge->v1->p[paramnum] + rdy * redge->dpdy[paramnum];
1196
float dpdx = (rparam - lparam) * oox;
1198
unit->extent[extnum].param[paramnum].start = lparam;// - ((float)istartx + 0.5f) * dpdx;
1199
unit->extent[extnum].param[paramnum].dpdx = dpdx;
1203
/* include the right edge if requested */
1204
if (poly->flags & POLYFLAG_INCLUDE_RIGHT_EDGE)
1207
/* apply left/right clipping */
1208
if (cliprect != NULL)
1210
if (istartx < cliprect->min_x)
1212
for (paramnum = 0; paramnum < paramcount; paramnum++)
1213
unit->extent[extnum].param[paramnum].start += (cliprect->min_x - istartx) * unit->extent[extnum].param[paramnum].dpdx;
1214
istartx = cliprect->min_x;
1216
if (istopx > cliprect->max_x)
1217
istopx = cliprect->max_x + 1;
1220
/* set the extent and update the total pixel count */
1221
if (istartx >= istopx)
1222
istartx = istopx = 0;
1223
unit->extent[extnum].startx = istartx;
1224
unit->extent[extnum].stopx = istopx;
1225
pixels += istopx - istartx;
1229
poly->unit_max = MAX(poly->unit_max, poly->unit_next);
1232
/* enqueue the work items */
1233
if (poly->queue != NULL)
1234
osd_work_item_queue_multiple(poly->queue, poly_item_callback, poly->unit_next - startunit, poly->unit[startunit], poly->unit_size, WORK_ITEM_FLAG_AUTO_RELEASE);
1236
/* return the total number of pixels in the triangle */
1238
poly->pixels += pixels;
1244
/***************************************************************************
1246
***************************************************************************/
1248
/*-------------------------------------------------
1249
poly_zclip_if_less - z clip a polygon against
1250
the given value, returning a set of clipped
1252
-------------------------------------------------*/
1254
int poly_zclip_if_less(int numverts, const poly_vertex *v, poly_vertex *outv, int paramcount, float clipval)
1256
int prevclipped = (v[numverts - 1].p[0] < clipval);
1257
poly_vertex *nextout = outv;
1260
/* iterate over vertices */
1261
for (vertnum = 0; vertnum < numverts; vertnum++)
1263
int thisclipped = (v[vertnum].p[0] < clipval);
1265
/* if we switched from clipped to non-clipped, interpolate a vertex */
1266
if (thisclipped != prevclipped)
1267
interpolate_vertex(nextout++, &v[(vertnum == 0) ? (numverts - 1) : (vertnum - 1)], &v[vertnum], paramcount, clipval);
1269
/* if this vertex is not clipped, copy it in */
1271
copy_vertex(nextout++, &v[vertnum], paramcount);
1273
/* remember the last state */
1274
prevclipped = thisclipped;
1276
return nextout - outv;
1281
/***************************************************************************
1283
***************************************************************************/
1285
/*-------------------------------------------------
1286
allocate_array - allocate an array of pointers
1287
-------------------------------------------------*/
1289
static void **allocate_array(running_machine &machine, size_t *itemsize, UINT32 itemcount)
1298
/* round to a cache line boundary */
1299
*itemsize = ((*itemsize + CACHE_LINE_SIZE - 1) / CACHE_LINE_SIZE) * CACHE_LINE_SIZE;
1301
/* allocate the array */
1302
ptrarray = auto_alloc_array_clear(machine, void *, itemcount);
1304
/* allocate the actual items */
1305
ptrarray[0] = auto_alloc_array_clear(machine, UINT8, *itemsize * itemcount);
1307
/* initialize the pointer array */
1308
for (itemnum = 1; itemnum < itemcount; itemnum++)
1309
ptrarray[itemnum] = (UINT8 *)ptrarray[0] + *itemsize * itemnum;
1314
/*-------------------------------------------------
1315
poly_item_callback - callback for each poly
1317
-------------------------------------------------*/
1319
static void *poly_item_callback(void *param, int threadid)
1323
work_unit *unit = (work_unit *)param;
1324
polygon_info *polygon = unit->shared.polygon;
1325
int count = unit->shared.count_next & 0xffff;
1326
UINT32 orig_count_next;
1329
/* if our previous item isn't done yet, enqueue this item to the end and proceed */
1330
if (unit->shared.previtem != 0xffff)
1332
work_unit *prevunit = polygon->poly->unit[unit->shared.previtem];
1333
if (prevunit->shared.count_next != 0)
1335
UINT32 unitnum = ((UINT8 *)unit - (UINT8 *)polygon->poly->unit[0]) / polygon->poly->unit_size;
1336
UINT32 new_count_next;
1338
/* attempt to atomically swap in this new value */
1341
orig_count_next = prevunit->shared.count_next;
1342
new_count_next = orig_count_next | (unitnum << 16);
1343
} while (compare_exchange32((volatile INT32 *)&prevunit->shared.count_next, orig_count_next, new_count_next) != orig_count_next);
1346
/* track resolved conflicts */
1347
polygon->poly->conflicts[threadid]++;
1348
if (orig_count_next != 0)
1349
polygon->poly->resolved[threadid]++;
1351
/* if we succeeded, skip out early so we can do other work */
1352
if (orig_count_next != 0)
1357
/* iterate over extents */
1358
for (curscan = 0; curscan < count; curscan++)
1360
if (polygon->numverts == 3)
1362
poly_extent tmpextent;
1363
convert_tri_extent_to_poly_extent(&tmpextent, &unit->tri.extent[curscan], polygon, unit->shared.scanline + curscan);
1364
(*polygon->callback)(polygon->dest, unit->shared.scanline + curscan, &tmpextent, polygon->extra, threadid);
1367
(*polygon->callback)(polygon->dest, unit->shared.scanline + curscan, &unit->quad.extent[curscan], polygon->extra, threadid);
1370
/* set our count to 0 and re-fetch the original count value */
1373
orig_count_next = unit->shared.count_next;
1374
} while (compare_exchange32((volatile INT32 *)&unit->shared.count_next, orig_count_next, 0) != orig_count_next);
1376
/* if we have no more work to do, do nothing */
1377
orig_count_next >>= 16;
1378
if (orig_count_next == 0)
1380
param = polygon->poly->unit[orig_count_next];
1386
/*-------------------------------------------------
1387
poly_state_presave - pre-save callback to
1388
ensure everything is synced before saving
1389
-------------------------------------------------*/
1391
static void poly_state_presave(poly_manager *poly)
1393
poly_wait(poly, "pre-save");
added
removed
mess/src/emu/video/poly.c
