ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Better and complete buffering for the inline-buffers

This commit is contained in:
Jannik Vogel 2015-07-17 03:57:42 +02:00
parent 7802178db7
commit 34ba061b60
1 changed files with 85 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

176
hw/xbox/nv2a.c
View File

@ -1309,11 +1309,14 @@ typedef struct VertexAttribute {
unsigned int converted_size;
unsigned int converted_count;
float *inline_buffer_buffer;
GLint gl_count;
GLenum gl_type;
GLboolean gl_normalize;
GLuint gl_converted_buffer;
GLuint gl_inline_buffer_buffer;
} VertexAttribute;
typedef struct VertexShaderConstant {
@ -1403,13 +1406,6 @@ typedef struct TextureBinding {
unsigned int refcnt;
} TextureBinding;
typedef struct InlineVertexBufferEntry {
float position[4];
float weight[4];
float diffuse[4];
float tex_coord[NV2A_MAX_TEXTURES][4];
} InlineVertexBufferEntry;
typedef struct KelvinState {
hwaddr dma_notifies;
hwaddr dma_state;
@ -1537,8 +1533,6 @@ typedef struct PGRAPHState {
uint32_t inline_elements[NV2A_MAX_BATCH_LENGTH];
unsigned int inline_buffer_length;
InlineVertexBufferEntry inline_buffer[NV2A_MAX_BATCH_LENGTH];
GLuint gl_inline_buffer_buffer;
GLuint gl_element_buffer;
GLuint gl_memory_buffer;
@ -3759,9 +3753,9 @@ static void pgraph_init(NV2AState *d)
for (i=0; i<NV2A_VERTEXSHADER_ATTRIBUTES; i++) {
glGenBuffers(1, &pg->vertex_attributes[i].gl_converted_buffer);
glGenBuffers(1, &pg->vertex_attributes[i].gl_inline_buffer_buffer);
}
glGenBuffers(1, &pg->gl_inline_array_buffer);
glGenBuffers(1, &pg->gl_inline_buffer_buffer);
glGenBuffers(1, &pg->gl_element_buffer);
glGenBuffers(1, &pg->gl_memory_buffer);
@ -3858,31 +3852,39 @@ static unsigned int kelvin_map_texgen(uint32_t parameter, unsigned int channel)
return texgen;
}
static void finish_inline_vertex(PGRAPHState *pg)
static void allocate_inline_buffer_vertices(PGRAPHState *pg, unsigned int attr)
{
int i;
VertexAttribute *attribute = &pg->vertex_attributes[attr];
if (attribute->inline_buffer_buffer || pg->inline_buffer_length == 0) {
return;
}
/* Now upload the previous attribute value */
attribute->inline_buffer_buffer = g_malloc(NV2A_MAX_BATCH_LENGTH
* sizeof(float) * 4);
for (i = 0; i < pg->inline_buffer_length; i++) {
memcpy(&attribute->inline_buffer_buffer[i * 4],
attribute->inline_value,
sizeof(float) * 4);
}
}
static void finish_inline_buffer_vertex(PGRAPHState *pg)
{
int i;
assert(pg->inline_buffer_length < NV2A_MAX_BATCH_LENGTH);
InlineVertexBufferEntry *entry =
&pg->inline_buffer[pg->inline_buffer_length];
memcpy(entry->position,
pg->vertex_attributes[NV2A_VERTEX_ATTR_POSITION].inline_value,
sizeof(float) * 4);
memcpy(entry->weight,
pg->vertex_attributes[NV2A_VERTEX_ATTR_WEIGHT].inline_value,
sizeof(float) * 4);
memcpy(entry->diffuse,
pg->vertex_attributes[NV2A_VERTEX_ATTR_DIFFUSE].inline_value,
sizeof(float) * 4);
for (i = 0; i < NV2A_MAX_TEXTURES; i++) {
memcpy(entry->tex_coord[i],
pg->vertex_attributes[NV2A_VERTEX_ATTR_TEXTURE0+i].inline_value,
sizeof(float)*4);
for (i = 0; i < NV2A_VERTEXSHADER_ATTRIBUTES; i++) {
VertexAttribute *attribute = &pg->vertex_attributes[i];
if (attribute->inline_buffer_buffer) {
memcpy(&attribute->inline_buffer_buffer[
pg->inline_buffer_length * 4],
attribute->inline_value,
sizeof(float) * 4);
}
}
pg->inline_buffer_length++;
@ -4597,9 +4599,12 @@ static void pgraph_method(NV2AState *d,
case NV097_SET_VERTEX4F ...
NV097_SET_VERTEX4F + 12: {
slot = (class_method - NV097_SET_VERTEX4F) / 4;
pg->vertex_attributes[NV2A_VERTEX_ATTR_POSITION].inline_value[slot] = *(float*)&parameter;
VertexAttribute *attribute =
&pg->vertex_attributes[NV2A_VERTEX_ATTR_POSITION];
allocate_inline_buffer_vertices(pg, NV2A_VERTEX_ATTR_POSITION);
attribute->inline_value[slot] = *(float*)&parameter;
if (slot == 3) {
finish_inline_vertex(pg);
finish_inline_buffer_vertex(pg);
}
break;
}
@ -4717,48 +4722,31 @@ static void pgraph_method(NV2AState *d,
if (parameter == NV097_SET_BEGIN_END_OP_END) {
if (pg->inline_buffer_length) {
// pgraph_bind_vertex_attributes(...)
for (i = 0; i < NV2A_VERTEXSHADER_ATTRIBUTES; i++) {
VertexAttribute *attribute = &pg->vertex_attributes[i];
glBindBuffer(GL_ARRAY_BUFFER, pg->gl_inline_buffer_buffer);
glBufferData(GL_ARRAY_BUFFER,
pg->inline_buffer_length
* sizeof(InlineVertexBufferEntry),
pg->inline_buffer,
GL_DYNAMIC_DRAW);
if (attribute->inline_buffer_buffer) {
glVertexAttribPointer(NV2A_VERTEX_ATTR_POSITION,
4,
GL_FLOAT,
GL_FALSE,
sizeof(InlineVertexBufferEntry),
(void*)offsetof(InlineVertexBufferEntry, position));
glEnableVertexAttribArray(NV2A_VERTEX_ATTR_POSITION);
glBindBuffer(GL_ARRAY_BUFFER,
attribute->gl_inline_buffer_buffer);
glBufferData(GL_ARRAY_BUFFER,
pg->inline_buffer_length
* sizeof(float) * 4,
attribute->inline_buffer_buffer,
GL_DYNAMIC_DRAW);
glVertexAttribPointer(NV2A_VERTEX_ATTR_WEIGHT,
4,
GL_FLOAT,
GL_FALSE,
sizeof(InlineVertexBufferEntry),
(void*)offsetof(InlineVertexBufferEntry, weight));
glEnableVertexAttribArray(NV2A_VERTEX_ATTR_WEIGHT);
/* Clear buffer for next batch */
g_free(attribute->inline_buffer_buffer);
attribute->inline_buffer_buffer = NULL;
glVertexAttribPointer(NV2A_VERTEX_ATTR_DIFFUSE,
4,
GL_FLOAT,
GL_FALSE,
sizeof(InlineVertexBufferEntry),
(void*)offsetof(InlineVertexBufferEntry, diffuse));
glEnableVertexAttribArray(NV2A_VERTEX_ATTR_DIFFUSE);
glVertexAttribPointer(i, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(i);
} else {
glDisableVertexAttribArray(i);
glVertexAttrib4fv(i, attribute->inline_value);
}
for (i=0; i<NV2A_MAX_TEXTURES; i++) {
glVertexAttribPointer(NV2A_VERTEX_ATTR_TEXTURE0+i,
4,
GL_FLOAT,
GL_FALSE,
sizeof(InlineVertexBufferEntry),
(void*)(offsetof(InlineVertexBufferEntry, tex_coord)
+ i*sizeof(float)*4));
glEnableVertexAttribArray(NV2A_VERTEX_ATTR_TEXTURE0+i);
}
glDrawArrays(pg->gl_primitive_mode,
@ -4899,6 +4887,7 @@ static void pgraph_method(NV2AState *d,
pg->inline_elements_length = 0;
pg->inline_array_length = 0;
pg->inline_buffer_length = 0;
}
pgraph_set_surface_dirty(pg, true, depth_test || stencil_test);
@ -5024,45 +5013,50 @@ static void pgraph_method(NV2AState *d,
case NV097_SET_VERTEX_DATA2F_M ...
NV097_SET_VERTEX_DATA2F_M + 0x7c: {
slot = (class_method - NV097_SET_VERTEX_DATA2F_M) / 8;
unsigned int part =
((class_method - NV097_SET_VERTEX_DATA2F_M) % 8) / 4;
pg->vertex_attributes[slot].inline_value[part] = *(float*)&parameter;
pg->vertex_attributes[slot].inline_value[2] = 0.0;
pg->vertex_attributes[slot].inline_value[3] = 1.0;
slot = (class_method - NV097_SET_VERTEX_DATA2F_M) / 4;
unsigned int part = slot % 2;
slot /= 2;
VertexAttribute *attribute = &pg->vertex_attributes[slot];
allocate_inline_buffer_vertices(pg, slot);
attribute->inline_value[part] = *(float*)&parameter;
/* FIXME: Should these really be set to 0.0 and 1.0 ? Conditions? */
attribute->inline_value[2] = 0.0;
attribute->inline_value[3] = 1.0;
if ((slot == 0) && (part == 1)) {
finish_inline_vertex(pg);
finish_inline_buffer_vertex(pg);
}
break;
}
case NV097_SET_VERTEX_DATA4F_M ...
NV097_SET_VERTEX_DATA4F_M + 0xfc: {
slot = (class_method - NV097_SET_VERTEX_DATA4F_M) / 16;
unsigned int part =
((class_method - NV097_SET_VERTEX_DATA4F_M) % 16) / 4;
pg->vertex_attributes[slot].inline_value[part] = *(float*)&parameter;
slot = (class_method - NV097_SET_VERTEX_DATA4F_M) / 4;
unsigned int part = slot % 4;
slot /= 4;
VertexAttribute *attribute = &pg->vertex_attributes[slot];
allocate_inline_buffer_vertices(pg, slot);
attribute->inline_value[part] = *(float*)&parameter;
if ((slot == 0) && (part == 3)) {
finish_inline_vertex(pg);
finish_inline_buffer_vertex(pg);
}
break;
}
case NV097_SET_VERTEX_DATA4UB ...
NV097_SET_VERTEX_DATA4UB + 0x3c:
NV097_SET_VERTEX_DATA4UB + 0x3c: {
slot = (class_method - NV097_SET_VERTEX_DATA4UB) / 4;
pg->vertex_attributes[slot].inline_value[0] =
(parameter & 0xFF) / 255.0;
pg->vertex_attributes[slot].inline_value[1] =
((parameter >> 8) & 0xFF) / 255.0;
pg->vertex_attributes[slot].inline_value[2] =
((parameter >> 16) & 0xFF) / 255.0;
pg->vertex_attributes[slot].inline_value[3] =
((parameter >> 24) & 0xFF) / 255.0;
VertexAttribute *attribute = &pg->vertex_attributes[slot];
allocate_inline_buffer_vertices(pg, slot);
attribute->inline_value[0] = (parameter & 0xFF) / 255.0;
attribute->inline_value[1] = ((parameter >> 8) & 0xFF) / 255.0;
attribute->inline_value[2] = ((parameter >> 16) & 0xFF) / 255.0;
attribute->inline_value[3] = ((parameter >> 24) & 0xFF) / 255.0;
if (slot == 0) {
finish_inline_vertex(pg);
finish_inline_buffer_vertex(pg);
assert(false); /* FIXME: Untested */
}
break;
}
case NV097_SET_SEMAPHORE_OFFSET:
kelvin->semaphore_offset = parameter;