Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-07-05 09:57:47 +03:00
Code Issues Actions 33 Packages Projects Releases Wiki Activity

chihiro.cpp: store up to 1024 primitive vertices for easier debugging (nw)

Browse Source
This commit is contained in:
yz70s 2015-12-25 19:59:43 +01:00
parent c4451bdc89
commit 6f8d4d4061
2 changed files with 262 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/mame/includes/chihiro.h
View File

@ -394,6 +394,7 @@ public:
colorformat_rendertarget = NV2A_COLOR_FORMAT::A8R8G8B8; colorformat_rendertarget = NV2A_COLOR_FORMAT::A8R8G8B8;
bytespixel_rendertarget = 4; bytespixel_rendertarget = 4;
clear_rendertarget.set(0, 0, 639, 479); clear_rendertarget.set(0, 0, 639, 479);
primitive_type = NV2A_BEGIN_END::STOP;
antialias_control = 0; antialias_control = 0;
rendertarget = nullptr; rendertarget = nullptr;
depthbuffer = nullptr; depthbuffer = nullptr;
@ -514,10 +515,16 @@ public:
int rectangle_pitch; int rectangle_pitch;
void *buffer; void *buffer;
} texture[4]; } texture[4];
NV2A_BEGIN_END primitive_type;
int primitives_count; int primitives_count;
int indexesleft_count; int indexesleft_count;
int indexesleft_first; int indexesleft_first;
UINT32 indexesleft[8]; UINT32 indexesleft[1024]; // vertex indices sent by the software to the 3d accelerator
int vertex_count;
unsigned int vertex_first;
vertex_nv vertex_software[1024+2]; // vertex attributes sent by the software to the 3d accelerator
vertex_t vertex_xy[1024+2]; // vertex attributes computed by the 3d accelerator
struct { struct {
float variable_A[4]; // 0=R 1=G 2=B 3=A float variable_A[4]; // 0=R 1=G 2=B 3=A
float variable_B[4]; float variable_B[4];

445
src/mame/video/chihiro.cpp
View File

@ -2197,9 +2197,9 @@ int nv2a_renderer::read_vertices_0x1800(address_space & space, vertex_nv *destin
for (m = 0; m < limit; m++) { for (m = 0; m < limit; m++) {
if (indexesleft_count == 0) { if (indexesleft_count == 0) {
data = space.read_dword(address); data = space.read_dword(address);
i = (indexesleft_first + indexesleft_count) & 7; i = indexesleft_first + indexesleft_count;
indexesleft[i] = data & 0xffff; indexesleft[i & 1023] = data & 0xffff;
indexesleft[(i + 1) & 7] = (data >> 16) & 0xffff; indexesleft[(i + 1) & 1023] = (data >> 16) & 0xffff;
indexesleft_count = indexesleft_count + 2; indexesleft_count = indexesleft_count + 2;
address += 4; address += 4;
c++; c++;
@ -2211,7 +2211,7 @@ int nv2a_renderer::read_vertices_0x1800(address_space & space, vertex_nv *destin
} }
b = b >> 1; b = b >> 1;
} }
indexesleft_first = (indexesleft_first + 1) & 7; indexesleft_first = (indexesleft_first + 1) & 1023;
indexesleft_count--; indexesleft_count--;
} }
return (int)c; return (int)c;
@ -2231,8 +2231,8 @@ int nv2a_renderer::read_vertices_0x1808(address_space & space, vertex_nv *destin
for (m = 0; m < limit; m++) { for (m = 0; m < limit; m++) {
if (indexesleft_count == 0) { if (indexesleft_count == 0) {
data = space.read_dword(address); data = space.read_dword(address);
i = (indexesleft_first + indexesleft_count) & 7; i = indexesleft_first + indexesleft_count;
indexesleft[i] = data; indexesleft[i & 1023] = data;
indexesleft_count = indexesleft_count + 1; indexesleft_count = indexesleft_count + 1;
address += 4; address += 4;
c++; c++;
@ -2244,7 +2244,7 @@ int nv2a_renderer::read_vertices_0x1808(address_space & space, vertex_nv *destin
} }
b = b >> 1; b = b >> 1;
} }
indexesleft_first = (indexesleft_first + 1) & 7; indexesleft_first = (indexesleft_first + 1) & 1023;
indexesleft_count--; indexesleft_count--;
} }
return (int)c; return (int)c;
@ -2543,21 +2543,22 @@ int nv2a_renderer::geforce_exec_method(address_space & space, UINT32 chanel, UIN
printf("A:%08X MTHD:%08X D:%08X\n\r",address,maddress,data); printf("A:%08X MTHD:%08X D:%08X\n\r",address,maddress,data);
#endif #endif
if (maddress == 0x17fc) { if (maddress == 0x17fc) {
vertex_count = 0;
vertex_first = 0;
indexesleft_count = 0; indexesleft_count = 0;
indexesleft_first = 0; indexesleft_first = 0;
primitives_count = 0; primitives_count = 0;
primitive_type = (NV2A_BEGIN_END)data;
countlen--; countlen--;
} }
if (maddress == 0x1810) { if (maddress == 0x1810) {
// draw vertices // draw vertices
int offset, count; int offset, count;
NV2A_BEGIN_END type;
UINT32 n; UINT32 n;
render_delegate renderspans; render_delegate renderspans;
offset = data & 0xffffff; offset = data & 0xffffff;
count = (data >> 24) & 0xff; count = (data >> 24) & 0xff;
type = (NV2A_BEGIN_END)channel[chanel][subchannel].object.method[0x17fc / 4];
if (((channel[chanel][subchannel].object.method[0x1e60 / 4] & 7) > 0) && (combiner.used != 0)) { if (((channel[chanel][subchannel].object.method[0x1e60 / 4] & 7) > 0) && (combiner.used != 0)) {
renderspans = render_delegate(FUNC(nv2a_renderer::render_register_combiners), this); renderspans = render_delegate(FUNC(nv2a_renderer::render_register_combiners), this);
} }
@ -2569,54 +2570,77 @@ int nv2a_renderer::geforce_exec_method(address_space & space, UINT32 chanel, UIN
#ifdef LOG_NV2A #ifdef LOG_NV2A
printf("vertex %d %d %d\n\r", type, offset, count); printf("vertex %d %d %d\n\r", type, offset, count);
#endif #endif
if (type == NV2A_BEGIN_END::QUADS) { if (primitive_type == NV2A_BEGIN_END::QUADS) {
for (n = 0; n <= count; n += 4) { for (n = 0; n <= count; n += 4) {
vertex_nv vert[4]; read_vertices_0x1810(space, vertex_software + vertex_first, n + offset, 4);
vertex_t xy[4]; convert_vertices_poly(vertex_software + vertex_first, vertex_xy + vertex_first, 4);
render_polygon<4>(limits_rendertarget, renderspans, 4 + 4 * 2, vertex_xy + vertex_first); // 4 rgba, 4 texture units 2 uv
read_vertices_0x1810(space, vert, n + offset, 4); vertex_first = (vertex_first + 4) & 1023;
convert_vertices_poly(vert, xy, 4); vertex_count = vertex_count + 4;
render_polygon<4>(limits_rendertarget, renderspans, 4 + 4 * 2, xy); // 4 rgba, 4 texture units 2 uv
wait(); wait();
} }
} }
else if (type == NV2A_BEGIN_END::TRIANGLE_FAN) { else if (primitive_type == NV2A_BEGIN_END::TRIANGLES) {
vertex_nv vert[3]; for (n = 0; n <= count; n += 3) {
vertex_t xy[3]; read_vertices_0x1810(space, vertex_software + vertex_first, n + offset, 3);
convert_vertices_poly(vertex_software + vertex_first, vertex_xy + vertex_first, 3);
read_vertices_0x1810(space, vert, offset, 2); render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, vertex_xy[vertex_first], vertex_xy[(vertex_first + 1) & 1023], vertex_xy[(vertex_first + 2) & 1023]); // 4 rgba, 4 texture units 2 uv
convert_vertices_poly(vert, xy, 2); vertex_first = (vertex_first + 3) & 1023;
count = count - 2; vertex_count = vertex_count + 3;
offset = offset + 2;
for (n = 0; n <= count; n++) {
read_vertices_0x1810(space, vert + (((n + 1) & 1) + 1), offset + n, 1);
convert_vertices_poly(vert + (((n + 1) & 1) + 1), xy + (((n + 1) & 1) + 1), 1);
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, xy[0], xy[(~(n + 1) & 1) + 1], xy[((n + 1) & 1) + 1]);
wait(); wait();
} }
} }
else if (type == NV2A_BEGIN_END::TRIANGLE_STRIP) { else if (primitive_type == NV2A_BEGIN_END::TRIANGLE_FAN) {
vertex_nv vert[4]; if (vertex_count == 0) {
vertex_t xy[4]; read_vertices_0x1810(space, vertex_software + 1024, offset, 1);
convert_vertices_poly(vertex_software + 1024, vertex_xy + 1024, 1);
read_vertices_0x1810(space, vert, offset, 2); read_vertices_0x1810(space, vertex_software, offset + 1, 1);
convert_vertices_poly(vert, xy, 2); convert_vertices_poly(vertex_software, vertex_xy, 1);
count = count - 2; count = count - 2;
offset = offset + 2; offset = offset + 2;
vertex_first = 1;
vertex_count = 2;
}
// if software sends the vertices 0 1 2 3 4 5 6
// hardware will draw triangles made by (0,1,2) (0,2,3) (0,3,4) (0,4,5) (0,5,6)
for (n = 0; n <= count; n++) { for (n = 0; n <= count; n++) {
read_vertices_0x1810(space, vert + ((n + 2) & 3), offset + n, 1); read_vertices_0x1810(space, vertex_software + vertex_first, offset + n, 1);
convert_vertices_poly(vert + ((n + 2) & 3), xy + ((n + 2) & 3), 1); convert_vertices_poly(vertex_software + vertex_first, vertex_xy + vertex_first, 1);
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, xy[((n & 1) + n) & 3], xy[((~n & 1) + n) & 3], xy[(2 + n) & 3]); render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, vertex_xy[1024], vertex_xy[(vertex_first - 1) & 1023], vertex_xy[vertex_first]);
vertex_first = (vertex_first + 1) & 1023;
vertex_count = vertex_count + 1;
wait();
}
}
else if (primitive_type == NV2A_BEGIN_END::TRIANGLE_STRIP) {
// if software sends the vertices 0 1 2 3 4 5 6
// hardware will draw triangles made by (0,1,2) (1,3,2) (2,3,4) (3,5,4) (4,5,6)
if (vertex_count == 0) {
read_vertices_0x1810(space, vertex_software, offset, 2);
convert_vertices_poly(vertex_software, vertex_xy, 2);
count = count - 2;
offset = offset + 2;
vertex_first = 2;
vertex_count = 2;
}
for (n = 0; n <= count; n++) {
read_vertices_0x1810(space, vertex_software + vertex_first, offset + n, 1);
convert_vertices_poly(vertex_software + vertex_first, vertex_xy + vertex_first, 1);
if ((vertex_count & 1) == 0)
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, vertex_xy[(vertex_first - 2) & 1023], vertex_xy[(vertex_first - 1) & 1023], vertex_xy[vertex_first]);
else
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, vertex_xy[(vertex_first - 2) & 1023], vertex_xy[vertex_first], vertex_xy[(vertex_first - 1) & 1023]);
vertex_first = (vertex_first + 1) & 1023;
vertex_count = vertex_count + 1;
wait(); wait();
} }
} }
else { else {
machine().logerror("Unsupported primitive %d for method 0x1810\n", type); machine().logerror("Unsupported primitive %d for method 0x1810\n", primitive_type);
} }
countlen--; countlen--;
} }
if ((maddress == 0x1800) || (maddress == 0x1808)) { if ((maddress == 0x1800) || (maddress == 0x1808)) {
NV2A_BEGIN_END type;
UINT32 n; UINT32 n;
render_delegate renderspans; render_delegate renderspans;
int mult; int mult;
@ -2636,116 +2660,140 @@ int nv2a_renderer::geforce_exec_method(address_space & space, UINT32 chanel, UIN
// vertices are selected from the vertex buffer using an array of indexes // vertices are selected from the vertex buffer using an array of indexes
// each dword after 1800 contains two 16 bit index values to select the vartices // each dword after 1800 contains two 16 bit index values to select the vartices
// each dword after 1808 contains a 32 bit index value to select the vartices // each dword after 1808 contains a 32 bit index value to select the vartices
type = (NV2A_BEGIN_END)channel[chanel][subchannel].object.method[0x17fc / 4]; if (primitive_type == NV2A_BEGIN_END::QUADS) {
if (type == NV2A_BEGIN_END::QUADS) {
while (1) { while (1) {
vertex_nv vert[4];
vertex_t xy[4];
int c; int c;
if ((countlen * mult + indexesleft_count) < 4) if ((countlen * mult + indexesleft_count) < 4)
break; break;
if (mult == 1) if (mult == 1)
c = read_vertices_0x1808(space, vert, address, 4); c = read_vertices_0x1808(space, vertex_software + vertex_first, address, 4);
else else
c = read_vertices_0x1800(space, vert, address, 4); c = read_vertices_0x1800(space, vertex_software + vertex_first, address, 4);
address = address + c * 4; address = address + c * 4;
countlen = countlen - c; countlen = countlen - c;
convert_vertices_poly(vert, xy, 4); convert_vertices_poly(vertex_software + vertex_first, vertex_xy + vertex_first, 4);
render_polygon<4>(limits_rendertarget, renderspans, 4 + 4 * 2, xy); // 4 rgba, 4 texture units 2 uv render_polygon<4>(limits_rendertarget, renderspans, 4 + 4 * 2, vertex_xy + vertex_first); // 4 rgba, 4 texture units 2 uv
vertex_first = (vertex_first + 4) & 1023;
vertex_count = vertex_count + 4;
wait(); wait();
} }
} }
else if (type == NV2A_BEGIN_END::TRIANGLE_FAN) { else if (primitive_type == NV2A_BEGIN_END::TRIANGLE_FAN) {
if ((countlen * mult + indexesleft_count) >= 3) { int required, c, count;
vertex_nv vert[3];
vertex_t xy[3];
int c, count;
if (mult == 1) required = 1;
c = read_vertices_0x1808(space, vert, address, 2); if (vertex_count == 0)
else required = 3;
c = read_vertices_0x1800(space, vert, address, 2); if ((countlen * mult + indexesleft_count) >= required) {
convert_vertices_poly(vert, xy, 2); if (vertex_count == 0) {
address = address + c * 4;
countlen = countlen - c;
count = countlen * mult + indexesleft_count;
for (n = 1; n <= count; n++) {
if (mult == 1) if (mult == 1)
c = read_vertices_0x1808(space, vert + ((n & 1) + 1), address, 1); c = read_vertices_0x1808(space, vertex_software + 1024, address, 1);
else else
c = read_vertices_0x1800(space, vert + ((n & 1) + 1), address, 1); c = read_vertices_0x1800(space, vertex_software + 1024, address, 1);
convert_vertices_poly(vertex_software + 1024, vertex_xy + 1024, 1);
convert_vertices_poly(vert + ((n & 1) + 1), xy + ((n & 1) + 1), 1);
address = address + c * 4; address = address + c * 4;
countlen = countlen - c; countlen = countlen - c;
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, xy[0], xy[(~n & 1) + 1], xy[(n & 1) + 1]); if (mult == 1)
c = read_vertices_0x1808(space, vertex_software, address, 1);
else
c = read_vertices_0x1800(space, vertex_software, address, 1);
convert_vertices_poly(vertex_software, vertex_xy, 1);
address = address + c * 4;
countlen = countlen - c;
vertex_first = 1;
vertex_count = 2;
}
count = countlen * mult + indexesleft_count;
// if software sends the vertices 0 1 2 3 4 5 6
// hardware will draw triangles made by (0,1,2) (0,2,3) (0,3,4) (0,4,5) (0,5,6)
for (n = 1; n <= count; n++) {
if (mult == 1)
c = read_vertices_0x1808(space, vertex_software + vertex_first, address, 1);
else
c = read_vertices_0x1800(space, vertex_software + vertex_first, address, 1);
convert_vertices_poly(vertex_software + vertex_first, vertex_xy + vertex_first, 1);
address = address + c * 4;
countlen = countlen - c;
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, vertex_xy[1024], vertex_xy[(vertex_first - 1) & 1023], vertex_xy[vertex_first]);
vertex_first = (vertex_first + 1) & 1023;
vertex_count = vertex_count + 1;
wait(); wait();
} }
} }
} }
else if (type == NV2A_BEGIN_END::TRIANGLES) { else if (primitive_type == NV2A_BEGIN_END::TRIANGLES) {
while (1) { while (1) {
vertex_nv vert[3];
vertex_t xy[3];
int c; int c;
if ((countlen * mult + indexesleft_count) < 3) if ((countlen * mult + indexesleft_count) < 3)
break; break;
if (mult == 1) if (mult == 1)
c = read_vertices_0x1808(space, vert, address, 3); c = read_vertices_0x1808(space, vertex_software + vertex_first, address, 3);
else else
c = read_vertices_0x1800(space, vert, address, 3); c = read_vertices_0x1800(space, vertex_software + vertex_first, address, 3);
address = address + c * 4; address = address + c * 4;
countlen = countlen - c; countlen = countlen - c;
convert_vertices_poly(vert, xy, 3); convert_vertices_poly(vertex_software + vertex_first, vertex_xy + vertex_first, 3);
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, xy[0], xy[1], xy[2]); // 4 rgba, 4 texture units 2 uv render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, vertex_xy[vertex_first], vertex_xy[(vertex_first + 1) & 1023], vertex_xy[(vertex_first + 2) & 1023]); // 4 rgba, 4 texture units 2 uv
vertex_first = (vertex_first + 3) & 1023;
vertex_count = vertex_count + 3;
wait(); wait();
} }
} }
else if (type == NV2A_BEGIN_END::TRIANGLE_STRIP) { else if (primitive_type == NV2A_BEGIN_END::TRIANGLE_STRIP) {
if ((countlen * mult + indexesleft_count) >= 3) { int required, c, count;
vertex_nv vert[4];
vertex_t xy[4];
int c, count;
if (mult == 1) required = 1;
c = read_vertices_0x1808(space, vert, address, 2); if (vertex_count == 0)
else required = 3;
c = read_vertices_0x1800(space, vert, address, 2); if ((countlen * mult + indexesleft_count) >= required) {
convert_vertices_poly(vert, xy, 2); // if software sends the vertices 0 1 2 3 4 5 6
address = address + c * 4; // hardware will draw triangles made by (0,1,2) (1,3,2) (2,3,4) (3,5,4) (4,5,6)
countlen = countlen - c; if (vertex_count == 0) {
if (mult == 1)
c = read_vertices_0x1808(space, vertex_software, address, 2);
else
c = read_vertices_0x1800(space, vertex_software, address, 2);
convert_vertices_poly(vertex_software, vertex_xy, 2);
address = address + c * 4;
countlen = countlen - c;
vertex_first = 2;
vertex_count = 2;
}
count = countlen * mult + indexesleft_count; count = countlen * mult + indexesleft_count;
for (n = 0; n < count; n++) { for (n = 0; n < count; n++) {
if (mult == 1) if (mult == 1)
c = read_vertices_0x1808(space, vert + ((n + 2) & 3), address, 1); c = read_vertices_0x1808(space, vertex_software + vertex_first, address, 1);
else else
c = read_vertices_0x1800(space, vert + ((n + 2) & 3), address, 1); c = read_vertices_0x1800(space, vertex_software + vertex_first, address, 1);
address = address + c * 4; address = address + c * 4;
countlen = countlen - c; countlen = countlen - c;
convert_vertices_poly(vert + ((n + 2) & 3), xy + ((n + 2) & 3), 1); convert_vertices_poly(vertex_software + vertex_first, vertex_xy + vertex_first, 1);
if (xy[(n + 2) & 3].y > 293800000.0f) if ((vertex_count & 1) == 0)
xy[(n + 2) & 3].y = xy[(n + 2) & 3].y + 1.0f; render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, vertex_xy[(vertex_first - 2) & 1023], vertex_xy[(vertex_first - 1) & 1023], vertex_xy[vertex_first]);
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, xy[((n & 1) + n) & 3], xy[((~n & 1) + n) & 3], xy[(2 + n) & 3]); else
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, vertex_xy[(vertex_first - 2) & 1023], vertex_xy[vertex_first], vertex_xy[(vertex_first - 1) & 1023]);
vertex_first = (vertex_first + 1) & 1023;
vertex_count = vertex_count + 1;
wait(); wait();
} }
} }
} }
else { else {
machine().logerror("Unsupported primitive %d for method 0x1800/8\n", type); machine().logerror("Unsupported primitive %d for method 0x1800/8\n", primitive_type);
countlen = 0; countlen = 0;
} }
while (countlen > 0) { while (countlen > 0) {
data = space.read_dword(address); data = space.read_dword(address);
n = (indexesleft_first + indexesleft_count) & 7; n = indexesleft_first + indexesleft_count;
if (mult == 2) { if (mult == 2) {
indexesleft[n] = data & 0xffff; indexesleft[n & 1023] = data & 0xffff;
indexesleft[(n + 1) & 7] = (data >> 16) & 0xffff; indexesleft[(n + 1) & 1023] = (data >> 16) & 0xffff;
indexesleft_count = indexesleft_count + 2; indexesleft_count = indexesleft_count + 2;
} }
else { else {
indexesleft[n] = data; indexesleft[n & 1023] = data;
indexesleft_count = indexesleft_count + 1; indexesleft_count = indexesleft_count + 1;
} }
address += 4; address += 4;
@ -2755,7 +2803,6 @@ int nv2a_renderer::geforce_exec_method(address_space & space, UINT32 chanel, UIN
} }
if (maddress == 0x1818) { if (maddress == 0x1818) {
int n; int n;
NV2A_BEGIN_END type;
render_delegate renderspans; render_delegate renderspans;
if (((channel[chanel][subchannel].object.method[0x1e60 / 4] & 7) > 0) && (combiner.used != 0)) { if (((channel[chanel][subchannel].object.method[0x1e60 / 4] & 7) > 0) && (combiner.used != 0)) {
@ -2771,71 +2818,12 @@ int nv2a_renderer::geforce_exec_method(address_space & space, UINT32 chanel, UIN
// then countlen number of dwords with 1818 // then countlen number of dwords with 1818
// end with 17fc primitive type 0 // end with 17fc primitive type 0
// at 1760 16 words specify the vertex format:for each possible vertex attribute the number of components (0=not present) and type of each // at 1760 16 words specify the vertex format:for each possible vertex attribute the number of components (0=not present) and type of each
type = (NV2A_BEGIN_END)channel[chanel][subchannel].object.method[0x17fc / 4]; if (primitive_type == NV2A_BEGIN_END::QUADS) {
if (type == NV2A_BEGIN_END::TRIANGLE_FAN) {
vertex_nv vert[3];
vertex_t xy[3];
int c;
c = read_vertices_0x1818(space, vert, address, 2);
convert_vertices_poly(vert, xy, 2);
countlen = countlen - c;
if (countlen < 0) {
machine().logerror("Method 0x1818 missing %d words to draw a complete primitive\n", -countlen);
countlen = 0;
return 0;
}
address = address + c * 4;
for (n = 1; countlen > 0; n++) {
c = read_vertices_0x1818(space, vert + ((n & 1) + 1), address, 1);
countlen = countlen - c;
if (countlen < 0) {
machine().logerror("Method 0x1818 missing %d words to draw a complete primitive\n", -countlen);
countlen = 0;
break;
}
address = address + c * 4;
convert_vertices_poly(vert + ((n & 1) + 1), xy + ((n & 1) + 1), 1);
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, xy[0], xy[(~n & 1) + 1], xy[(n & 1) + 1]);
wait();
}
}
else if (type == NV2A_BEGIN_END::TRIANGLES) {
while (countlen > 0) { while (countlen > 0) {
vertex_nv vert[3];
vertex_t xy[3];
int c; int c;
c = read_vertices_0x1818(space, vert, address, 3); c = read_vertices_0x1818(space, vertex_software + vertex_first, address, 4);
convert_vertices_poly(vert, xy, 3); convert_vertices_poly(vertex_software + vertex_first, vertex_xy + vertex_first, 4);
countlen = countlen - c;
if (countlen < 0) {
machine().logerror("Method 0x1818 missing %d words to draw a complete primitive\n", -countlen);
countlen = 0;
break;
}
address = address + c * 3;
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, xy[0], xy[1], xy[2]); // 4 rgba, 4 texture units 2 uv
wait();
}
}
else if (type == NV2A_BEGIN_END::TRIANGLE_STRIP) {
vertex_nv vert[4];
vertex_t xy[4];
int c;
c = read_vertices_0x1818(space, vert, address, 2);
convert_vertices_poly(vert, xy, 2);
countlen = countlen - c;
if (countlen < 0) {
machine().logerror("Method 0x1818 missing %d words to draw a complete primitive\n", -countlen);
countlen = 0;
return 0;
}
address = address + c * 4;
for (n = 0; countlen > 0; n++) {
c = read_vertices_0x1818(space, vert + ((n + 2) & 3), address, 1);
convert_vertices_poly(vert + ((n + 2) & 3), xy + ((n + 2) & 3), 1);
countlen = countlen - c; countlen = countlen - c;
if (countlen < 0) { if (countlen < 0) {
machine().logerror("Method 0x1818 missing %d words to draw a complete primitive\n", -countlen); machine().logerror("Method 0x1818 missing %d words to draw a complete primitive\n", -countlen);
@ -2843,36 +2831,17 @@ int nv2a_renderer::geforce_exec_method(address_space & space, UINT32 chanel, UIN
break; break;
} }
address = address + c * 4; address = address + c * 4;
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, xy[((n & 1) + n) & 3], xy[((~n & 1) + n) & 3], xy[(2 + n) & 3]); render_polygon<4>(limits_rendertarget, renderspans, 4 + 4 * 2, vertex_xy); // 4 rgba, 4 texture units 2 uv
vertex_first = (vertex_first + 4) & 1023;
vertex_count = vertex_count + 4;
wait(); wait();
} }
} }
else if (type == NV2A_BEGIN_END::QUADS) { else if (primitive_type == NV2A_BEGIN_END::QUAD_STRIP) {
while (countlen > 0) {
vertex_nv vert[4];
vertex_t xy[4];
int c;
c = read_vertices_0x1818(space, vert, address, 4);
convert_vertices_poly(vert, xy, 4);
countlen = countlen - c;
if (countlen < 0) {
machine().logerror("Method 0x1818 missing %d words to draw a complete primitive\n", -countlen);
countlen = 0;
break;
}
address = address + c * 4;
render_polygon<4>(limits_rendertarget, renderspans, 4 + 4 * 2, xy); // 4 rgba, 4 texture units 2 uv
wait();
}
}
else if (type == NV2A_BEGIN_END::QUAD_STRIP) {
vertex_nv vert[4];
vertex_t xy[4];
int c; int c;
c = read_vertices_0x1818(space, vert, address, 2); c = read_vertices_0x1818(space, vertex_software, address, 2);
convert_vertices_poly(vert, xy, 2); convert_vertices_poly(vertex_software, vertex_xy, 2);
countlen = countlen - c; countlen = countlen - c;
if (countlen < 0) { if (countlen < 0) {
machine().logerror("Method 0x1818 missing %d words to draw a complete primitive\n", -countlen); machine().logerror("Method 0x1818 missing %d words to draw a complete primitive\n", -countlen);
@ -2881,8 +2850,8 @@ int nv2a_renderer::geforce_exec_method(address_space & space, UINT32 chanel, UIN
} }
address = address + c * 4; address = address + c * 4;
for (n = 0; countlen > 0; n += 2) { for (n = 0; countlen > 0; n += 2) {
c = read_vertices_0x1818(space, vert + ((n + 2) & 3), address + ((n + 2) & 3), 2); c = read_vertices_0x1818(space, vertex_software + ((n + 2) & 3), address + ((n + 2) & 3), 2);
convert_vertices_poly(vert + ((n + 2) & 3), xy + ((n + 2) & 3), 2); convert_vertices_poly(vertex_software + ((n + 2) & 3), vertex_xy + ((n + 2) & 3), 2);
countlen = countlen - c; countlen = countlen - c;
if (countlen < 0) { if (countlen < 0) {
machine().logerror("Method 0x1818 missing %d words to draw a complete primitive\n", -countlen); machine().logerror("Method 0x1818 missing %d words to draw a complete primitive\n", -countlen);
@ -2890,13 +2859,107 @@ int nv2a_renderer::geforce_exec_method(address_space & space, UINT32 chanel, UIN
return 0; return 0;
} }
address = address + c * 4; address = address + c * 4;
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, xy[n & 3], xy[(n + 1) & 3], xy[(n + 2) & 3]); render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, vertex_xy[n & 3], vertex_xy[(n + 1) & 3], vertex_xy[(n + 2) & 3]);
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, xy[(n + 2) & 3], xy[(n + 1) & 3], xy[(n + 3) & 3]); render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, vertex_xy[(n + 2) & 3], vertex_xy[(n + 1) & 3], vertex_xy[(n + 3) & 3]);
wait();
}
}
else if (primitive_type == NV2A_BEGIN_END::TRIANGLE_FAN) {
int c;
if (vertex_count == 0) {
c = read_vertices_0x1818(space, vertex_software + 1024, address, 1);
convert_vertices_poly(vertex_software + 1024, vertex_xy + 1024, 1);
countlen = countlen - c;
address = address + c * 4;
c = read_vertices_0x1818(space, vertex_software, address, 1);
convert_vertices_poly(vertex_software, vertex_xy, 1);
countlen = countlen - c;
if (countlen < 0) {
machine().logerror("Method 0x1818 missing %d words to draw a complete primitive\n", -countlen);
countlen = 0;
return 0;
}
address = address + c * 4;
vertex_first = 1;
vertex_count = 2;
}
// if software sends the vertices 0 1 2 3 4 5 6
// hardware will draw triangles made by (0,1,2) (0,2,3) (0,3,4) (0,4,5) (0,5,6)
while (countlen > 0) {
c = read_vertices_0x1818(space, vertex_software + vertex_first, address, 1);
countlen = countlen - c;
if (countlen < 0) {
machine().logerror("Method 0x1818 missing %d words to draw a complete primitive\n", -countlen);
countlen = 0;
break;
}
address = address + c * 4;
convert_vertices_poly(vertex_software + vertex_first, vertex_xy + vertex_first, 1);
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, vertex_xy[1024], vertex_xy[(vertex_first - 1) & 1023], vertex_xy[vertex_first]);
vertex_first = (vertex_first + 1) & 1023;
vertex_count = vertex_count + 1;
wait();
}
}
else if (primitive_type == NV2A_BEGIN_END::TRIANGLES) {
while (countlen > 0) {
int c;
c = read_vertices_0x1818(space, vertex_software + vertex_first, address, 3);
convert_vertices_poly(vertex_software + vertex_first, vertex_xy + vertex_first, 3);
countlen = countlen - c;
if (countlen < 0) {
machine().logerror("Method 0x1818 missing %d words to draw a complete primitive\n", -countlen);
countlen = 0;
break;
}
address = address + c * 4;
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, vertex_xy[vertex_first], vertex_xy[(vertex_first + 1) & 1023], vertex_xy[(vertex_first + 2) & 1023]); // 4 rgba, 4 texture units 2 uv
vertex_first = (vertex_first + 3) & 1023;
vertex_count = vertex_count + 3;
wait();
}
}
else if (primitive_type == NV2A_BEGIN_END::TRIANGLE_STRIP) {
int c;
// if software sends the vertices 0 1 2 3 4 5 6
// hardware will draw triangles made by (0,1,2) (1,3,2) (2,3,4) (3,5,4) (4,5,6)
if (vertex_count == 0) {
c = read_vertices_0x1818(space, vertex_software, address, 2);
convert_vertices_poly(vertex_software, vertex_xy, 2);
countlen = countlen - c;
if (countlen < 0) {
machine().logerror("Method 0x1818 missing %d words to draw a complete primitive\n", -countlen);
countlen = 0;
return 0;
}
address = address + c * 4;
vertex_first = 2;
vertex_count = 2;
}
while (countlen > 0) {
c = read_vertices_0x1818(space, vertex_software + vertex_first, address, 1);
convert_vertices_poly(vertex_software + vertex_first, vertex_xy + vertex_first, 1);
countlen = countlen - c;
if (countlen < 0) {
machine().logerror("Method 0x1818 missing %d words to draw a complete primitive\n", -countlen);
countlen = 0;
break;
}
address = address + c * 4;
if ((vertex_count & 1) == 0)
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, vertex_xy[(vertex_first - 2) & 1023], vertex_xy[(vertex_first - 1) & 1023], vertex_xy[vertex_first]);
else
render_triangle(limits_rendertarget, renderspans, 4 + 4 * 2, vertex_xy[(vertex_first - 2) & 1023], vertex_xy[vertex_first], vertex_xy[(vertex_first - 1) & 1023]);
vertex_first = (vertex_first + 1) & 1023;
vertex_count = vertex_count + 1;
wait(); wait();
} }
} }
else { else {
machine().logerror("Unsupported primitive %d for method 0x1818\n", type); machine().logerror("Unsupported primitive %d for method 0x1818\n", primitive_type);
countlen = 0; countlen = 0;
} }
} }