// Just to get something on the screen, we'll just not subdivide correctly. void TransformDrawEngine::DrawBezier(int ucount, int vcount) { u16 indices[3 * 3 * 6]; static bool reported = false; if (!reported) { Reporting::ReportMessage("Unsupported bezier curve"); reported = true; } // if (gstate.patchprimitive) // Generate indices for a rectangular mesh. int c = 0; for (int y = 0; y < 3; y++) { for (int x = 0; x < 3; x++) { indices[c++] = y * 4 + x; indices[c++] = y * 4 + x + 1; indices[c++] = (y + 1) * 4 + x + 1; indices[c++] = (y + 1) * 4 + x + 1; indices[c++] = (y + 1) * 4 + x; indices[c++] = y * 4 + x; } } // We are free to use the "decoded" buffer here. // Let's split it into two to get a second buffer, there's enough space. u8 *decoded2 = decoded + 65536 * 24; // Alright, now for the vertex data. // For now, we will simply inject UVs. float customUV[4 * 4 * 2]; for (int y = 0; y < 4; y++) { for (int x = 0; x < 4; x++) { customUV[(y * 4 + x) * 2 + 0] = (float)x/3.0f; customUV[(y * 4 + x) * 2 + 1] = (float)y/3.0f; } } if (!(gstate.vertType & GE_VTYPE_TC_MASK)) { VertexDecoder *dec = GetVertexDecoder(gstate.vertType); dec->SetVertexType(gstate.vertType); u32 newVertType = dec->InjectUVs(decoded2, Memory::GetPointer(gstate_c.vertexAddr), customUV, 16); SubmitPrim(decoded2, &indices[0], GE_PRIM_TRIANGLES, c, newVertType, GE_VTYPE_IDX_16BIT, 0); } else { SubmitPrim(Memory::GetPointer(gstate_c.vertexAddr), &indices[0], GE_PRIM_TRIANGLES, c, gstate.vertType, GE_VTYPE_IDX_16BIT, 0); } Flush(); // as our vertex storage here is temporary, it will only survive one draw. }
void TransformDrawEngine::SubmitBezier(void* control_points, void* indices, int count_u, int count_v, GEPatchPrimType prim_type, u32 vertType) { Flush(); if (prim_type != GE_PATCHPRIM_TRIANGLES) { // Only triangles supported! return; } u16 index_lower_bound = 0; u16 index_upper_bound = count_u * count_v - 1; bool indices_16bit = (vertType & GE_VTYPE_IDX_MASK) == GE_VTYPE_IDX_16BIT; const u8* indices8 = (const u8*)indices; const u16* indices16 = (const u16*)indices; if (indices) GetIndexBounds(indices, count_u*count_v, vertType, &index_lower_bound, &index_upper_bound); // Simplify away bones and morph before proceeding SimpleVertex *simplified_control_points = (SimpleVertex *)(decoded + 65536 * 12); u8 *temp_buffer = decoded + 65536 * 24; u32 origVertType = vertType; vertType = NormalizeVertices((u8 *)simplified_control_points, temp_buffer, (u8 *)control_points, index_lower_bound, index_upper_bound, vertType); VertexDecoder *vdecoder = GetVertexDecoder(vertType); int vertexSize = vdecoder->VertexSize(); if (vertexSize != sizeof(SimpleVertex)) { ERROR_LOG(G3D, "Something went really wrong, vertex size: %i vs %i", vertexSize, (int)sizeof(SimpleVertex)); } const DecVtxFormat& vtxfmt = vdecoder->GetDecVtxFmt(); // Bezier patches share less control points than spline patches. Otherwise they are pretty much the same (except bezier don't support the open/close thing) int num_patches_u = (count_u - 1) / 3; int num_patches_v = (count_v - 1) / 3; BezierPatch* patches = new BezierPatch[num_patches_u * num_patches_v]; for (int patch_u = 0; patch_u < num_patches_u; patch_u++) { for (int patch_v = 0; patch_v < num_patches_v; patch_v++) { BezierPatch& patch = patches[patch_u + patch_v * num_patches_u]; for (int point = 0; point < 16; ++point) { int idx = (patch_u * 3 + point%4) + (patch_v * 3 + point/4) * count_u; if (indices) patch.points[point] = simplified_control_points + (indices_16bit ? indices16[idx] : indices8[idx]); else patch.points[point] = simplified_control_points + idx; } patch.u_index = patch_u * 3; patch.v_index = patch_v * 3; } } u8 *decoded2 = decoded + 65536 * 36; int count = 0; u8 *dest = decoded2; // Simple approximation of the real tesselation factor. // We shouldn't really split up into separate 4x4 patches, instead we should do something that works // like the splines, so we subdivide across the whole "mega-patch". if (num_patches_u == 0) num_patches_u = 1; if (num_patches_v == 0) num_patches_v = 1; int tess_u = gstate.getPatchDivisionU() / num_patches_u; int tess_v = gstate.getPatchDivisionV() / num_patches_v; if (tess_u < 4) tess_u = 4; if (tess_v < 4) tess_v = 4; for (int patch_idx = 0; patch_idx < num_patches_u*num_patches_v; ++patch_idx) { BezierPatch& patch = patches[patch_idx]; TesselateBezierPatch(dest, count, tess_u, tess_v, patch, origVertType); } delete[] patches; u32 vertTypeWithIndex16 = (vertType & ~GE_VTYPE_IDX_MASK) | GE_VTYPE_IDX_16BIT; UVScale prevUVScale; if (g_Config.bPrescaleUV) { // We scaled during Normalize already so let's turn it off when drawing. prevUVScale = gstate_c.uv; gstate_c.uv.uScale = 1.0f; gstate_c.uv.vScale = 1.0f; gstate_c.uv.uOff = 0; gstate_c.uv.vOff = 0; } SubmitPrim(decoded2, quadIndices_, GE_PRIM_TRIANGLES, count, vertTypeWithIndex16, 0); Flush(); if (g_Config.bPrescaleUV) { gstate_c.uv = prevUVScale; } }
void TransformDrawEngine::SubmitSpline(void* control_points, void* indices, int count_u, int count_v, int type_u, int type_v, GEPatchPrimType prim_type, u32 vertType) { Flush(); if (prim_type != GE_PATCHPRIM_TRIANGLES) { // Only triangles supported! return; } u16 index_lower_bound = 0; u16 index_upper_bound = count_u * count_v - 1; bool indices_16bit = (vertType & GE_VTYPE_IDX_MASK) == GE_VTYPE_IDX_16BIT; const u8* indices8 = (const u8*)indices; const u16* indices16 = (const u16*)indices; if (indices) GetIndexBounds(indices, count_u*count_v, vertType, &index_lower_bound, &index_upper_bound); // Simplify away bones and morph before proceeding SimpleVertex *simplified_control_points = (SimpleVertex *)(decoded + 65536 * 12); u8 *temp_buffer = decoded + 65536 * 24; u32 origVertType = vertType; vertType = NormalizeVertices((u8 *)simplified_control_points, temp_buffer, (u8 *)control_points, index_lower_bound, index_upper_bound, vertType); VertexDecoder *vdecoder = GetVertexDecoder(vertType); int vertexSize = vdecoder->VertexSize(); if (vertexSize != sizeof(SimpleVertex)) { ERROR_LOG(G3D, "Something went really wrong, vertex size: %i vs %i", vertexSize, (int)sizeof(SimpleVertex)); } const DecVtxFormat& vtxfmt = vdecoder->GetDecVtxFmt(); // TODO: Do something less idiotic to manage this buffer SimpleVertex **points = new SimpleVertex *[count_u * count_v]; // Make an array of pointers to the control points, to get rid of indices. for (int idx = 0; idx < count_u * count_v; idx++) { if (indices) points[idx] = simplified_control_points + (indices_16bit ? indices16[idx] : indices8[idx]); else points[idx] = simplified_control_points + idx; } u8 *decoded2 = decoded + 65536 * 36; int count = 0; u8 *dest = decoded2; SplinePatchLocal patch; patch.type_u = type_u; patch.type_v = type_v; patch.count_u = count_u; patch.count_v = count_v; patch.points = points; TesselateSplinePatch(dest, count, patch, origVertType); delete[] points; u32 vertTypeWithIndex16 = (vertType & ~GE_VTYPE_IDX_MASK) | GE_VTYPE_IDX_16BIT; UVScale prevUVScale; if (g_Config.bPrescaleUV) { // We scaled during Normalize already so let's turn it off when drawing. prevUVScale = gstate_c.uv; gstate_c.uv.uScale = 1.0f; gstate_c.uv.vScale = 1.0f; gstate_c.uv.uOff = 0; gstate_c.uv.vOff = 0; } SubmitPrim(decoded2, quadIndices_, GE_PRIM_TRIANGLES, count, vertTypeWithIndex16, 0); Flush(); if (g_Config.bPrescaleUV) { gstate_c.uv = prevUVScale; } }
void TransformDrawEngine::SubmitBezier(const void *control_points, const void *indices, int count_u, int count_v, GEPatchPrimType prim_type, u32 vertType) { Flush(); // TODO: Verify correct functionality with < 4. if (count_u < 4 || count_v < 4) return; u16 index_lower_bound = 0; u16 index_upper_bound = count_u * count_v - 1; bool indices_16bit = (vertType & GE_VTYPE_IDX_MASK) == GE_VTYPE_IDX_16BIT; const u8* indices8 = (const u8*)indices; const u16* indices16 = (const u16*)indices; if (indices) GetIndexBounds(indices, count_u*count_v, vertType, &index_lower_bound, &index_upper_bound); // Simplify away bones and morph before proceeding // There are normally not a lot of control points so just splitting decoded should be reasonably safe, although not great. SimpleVertex *simplified_control_points = (SimpleVertex *)(decoded + 65536 * 12); u8 *temp_buffer = decoded + 65536 * 18; u32 origVertType = vertType; vertType = NormalizeVertices((u8 *)simplified_control_points, temp_buffer, (u8 *)control_points, index_lower_bound, index_upper_bound, vertType); VertexDecoder *vdecoder = GetVertexDecoder(vertType); int vertexSize = vdecoder->VertexSize(); if (vertexSize != sizeof(SimpleVertex)) { ERROR_LOG(G3D, "Something went really wrong, vertex size: %i vs %i", vertexSize, (int)sizeof(SimpleVertex)); } // Bezier patches share less control points than spline patches. Otherwise they are pretty much the same (except bezier don't support the open/close thing) int num_patches_u = (count_u - 1) / 3; int num_patches_v = (count_v - 1) / 3; BezierPatch* patches = new BezierPatch[num_patches_u * num_patches_v]; for (int patch_u = 0; patch_u < num_patches_u; patch_u++) { for (int patch_v = 0; patch_v < num_patches_v; patch_v++) { BezierPatch& patch = patches[patch_u + patch_v * num_patches_u]; for (int point = 0; point < 16; ++point) { int idx = (patch_u * 3 + point%4) + (patch_v * 3 + point/4) * count_u; if (indices) patch.points[point] = simplified_control_points + (indices_16bit ? indices16[idx] : indices8[idx]); else patch.points[point] = simplified_control_points + idx; } patch.u_index = patch_u * 3; patch.v_index = patch_v * 3; patch.index = patch_v * num_patches_u + patch_u; } } int count = 0; u8 *dest = splineBuffer; // Simple approximation of the real tesselation factor. // We shouldn't really split up into separate 4x4 patches, instead we should do something that works // like the splines, so we subdivide across the whole "mega-patch". if (num_patches_u == 0) num_patches_u = 1; if (num_patches_v == 0) num_patches_v = 1; int tess_u = gstate.getPatchDivisionU(); int tess_v = gstate.getPatchDivisionV(); if (tess_u < 4) tess_u = 4; if (tess_v < 4) tess_v = 4; u16 *inds = quadIndices_; int maxVertices = SPLINE_BUFFER_SIZE / vertexSize; for (int patch_idx = 0; patch_idx < num_patches_u*num_patches_v; ++patch_idx) { BezierPatch& patch = patches[patch_idx]; TesselateBezierPatch(dest, inds, count, tess_u, tess_v, patch, origVertType, maxVertices); } delete[] patches; u32 vertTypeWithIndex16 = (vertType & ~GE_VTYPE_IDX_MASK) | GE_VTYPE_IDX_16BIT; UVScale prevUVScale; if (g_Config.bPrescaleUV) { // We scaled during Normalize already so let's turn it off when drawing. prevUVScale = gstate_c.uv; gstate_c.uv.uScale = 1.0f; gstate_c.uv.vScale = 1.0f; gstate_c.uv.uOff = 0; gstate_c.uv.vOff = 0; } int bytesRead; SubmitPrim(splineBuffer, quadIndices_, primType[prim_type], count, vertTypeWithIndex16, &bytesRead); Flush(); if (g_Config.bPrescaleUV) { gstate_c.uv = prevUVScale; } }
void TransformDrawEngine::SubmitBezier(void* control_points, void* indices, int count_u, int count_v, GEPatchPrimType prim_type, u32 vertType) { Flush(); if (prim_type != GE_PATCHPRIM_TRIANGLES) { // Only triangles supported! return; } u16 index_lower_bound = 0; u16 index_upper_bound = count_u * count_v - 1; bool indices_16bit = (vertType & GE_VTYPE_IDX_MASK) == GE_VTYPE_IDX_16BIT; const u8* indices8 = (const u8*)indices; const u16* indices16 = (const u16*)indices; if (indices) GetIndexBounds(indices, count_u*count_v, vertType, &index_lower_bound, &index_upper_bound); // Simplify away bones and morph before proceeding SimpleVertex *simplified_control_points = (SimpleVertex *)(decoded + 65536 * 12); u8 *temp_buffer = decoded + 65536 * 24; u32 origVertType = vertType; vertType = NormalizeVertices((u8 *)simplified_control_points, temp_buffer, (u8 *)control_points, index_lower_bound, index_upper_bound, vertType); VertexDecoder *vdecoder = GetVertexDecoder(vertType); int vertexSize = vdecoder->VertexSize(); if (vertexSize != sizeof(SimpleVertex)) { ERROR_LOG(G3D, "Something went really wrong, vertex size: %i vs %i", vertexSize, (int)sizeof(SimpleVertex)); } const DecVtxFormat& vtxfmt = vdecoder->GetDecVtxFmt(); // Bezier patches share less control points than spline patches. Otherwise they are pretty much the same (except bezier don't support the open/close thing) int num_patches_u = (count_u - 1) / 3; int num_patches_v = (count_v - 1) / 3; BezierPatch* patches = new BezierPatch[num_patches_u * num_patches_v]; for (int patch_u = 0; patch_u < num_patches_u; patch_u++) { for (int patch_v = 0; patch_v < num_patches_v; patch_v++) { BezierPatch& patch = patches[patch_u + patch_v * num_patches_u]; for (int point = 0; point < 16; ++point) { int idx = (patch_u * 3 + point%4) + (patch_v * 3 + point/4) * count_u; if (indices) patch.points[point] = simplified_control_points + (indices_16bit ? indices16[idx] : indices8[idx]); else patch.points[point] = simplified_control_points + idx; } patch.u_index = patch_u * 3; patch.v_index = patch_v * 3; } } u8 *decoded2 = decoded + 65536 * 36; int count = 0; u8 *dest = decoded2; for (int patch_idx = 0; patch_idx < num_patches_u*num_patches_v; ++patch_idx) { BezierPatch& patch = patches[patch_idx]; TesselateBezierPatch(dest, count, patch, origVertType); } delete[] patches; u32 vertTypeWithIndex16 = (vertType & ~GE_VTYPE_IDX_MASK) | GE_VTYPE_IDX_16BIT; SubmitPrim(decoded2, quadIndices_, GE_PRIM_TRIANGLES, count, vertTypeWithIndex16, -1, 0); Flush(); }
void TransformDrawEngine::SubmitSpline(void* control_points, void* indices, int count_u, int count_v, int type_u, int type_v, u32 prim_type, u32 vertex_type) { Flush(); if (prim_type != GE_PATCHPRIM_TRIANGLES) { // Only triangles supported! return; } // We're not actually going to decode, only reshuffle. VertexDecoder vdecoder; vdecoder.SetVertexType(vertex_type); int undecodedVertexSize = vdecoder.VertexSize(); const DecVtxFormat& vtxfmt = vdecoder.GetDecVtxFmt(); u16 index_lower_bound = 0; u16 index_upper_bound = count_u * count_v - 1; bool indices_16bit = (vertex_type & GE_VTYPE_IDX_MASK) == GE_VTYPE_IDX_16BIT; u8* indices8 = (u8*)indices; u16* indices16 = (u16*)indices; if (indices) GetIndexBounds(indices, count_u*count_v, vertex_type, &index_lower_bound, &index_upper_bound); int num_patches_u = count_u - 3; int num_patches_v = count_v - 3; // TODO: Do something less idiotic to manage this buffer HWSplinePatch* patches = new HWSplinePatch[num_patches_u * num_patches_v]; for (int patch_u = 0; patch_u < num_patches_u; ++patch_u) { for (int patch_v = 0; patch_v < num_patches_v; ++patch_v) { HWSplinePatch& patch = patches[patch_u + patch_v * num_patches_u]; for (int point = 0; point < 16; ++point) { int idx = (patch_u + point%4) + (patch_v + point/4) * count_u; if (indices) patch.points[point] = (u8 *)control_points + undecodedVertexSize * (indices_16bit ? indices16[idx] : indices8[idx]); else patch.points[point] = (u8 *)control_points + undecodedVertexSize * idx; } patch.type = (type_u | (type_v<<2)); if (patch_u != 0) patch.type &= ~START_OPEN_U; if (patch_v != 0) patch.type &= ~START_OPEN_V; if (patch_u != num_patches_u-1) patch.type &= ~END_OPEN_U; if (patch_v != num_patches_v-1) patch.type &= ~END_OPEN_V; } } u8 *decoded2 = decoded + 65536 * 24; int count = 0; u8 *dest = decoded2; for (int patch_idx = 0; patch_idx < num_patches_u*num_patches_v; ++patch_idx) { HWSplinePatch& patch = patches[patch_idx]; // TODO: Should do actual patch subdivision instead of just drawing the control points! const int tile_min_u = (patch.type & START_OPEN_U) ? 0 : 1; const int tile_min_v = (patch.type & START_OPEN_V) ? 0 : 1; const int tile_max_u = (patch.type & END_OPEN_U) ? 3 : 2; const int tile_max_v = (patch.type & END_OPEN_V) ? 3 : 2; for (int tile_u = tile_min_u; tile_u < tile_max_u; ++tile_u) { for (int tile_v = tile_min_v; tile_v < tile_max_v; ++tile_v) { int point_index = tile_u + tile_v*4; u8 *v0 = patch.points[point_index]; u8 *v1 = patch.points[point_index+1]; u8 *v2 = patch.points[point_index+4]; u8 *v3 = patch.points[point_index+5]; // TODO: Insert UVs where applicable. Actually subdivide. CopyTriangle(dest, v0, v1, v2, undecodedVertexSize); CopyTriangle(dest, v2, v1, v0, undecodedVertexSize); CopyTriangle(dest, v2, v1, v3, undecodedVertexSize); CopyTriangle(dest, v3, v1, v2, undecodedVertexSize); count += 12; } } } delete[] patches; u32 vertTypeWithoutIndex = vertex_type & ~GE_VTYPE_IDX_MASK; SubmitPrim(decoded2, 0, GE_PRIM_TRIANGLES, count, vertTypeWithoutIndex, GE_VTYPE_IDX_NONE, 0); Flush(); }