mirror of
https://github.com/hrydgard/ppsspp.git
synced 2025-04-02 11:01:50 -04:00
d3d: Copy over the vertex preview stuff.
Really need to just centralize, I know. But want a debugger that works first.
This commit is contained in:
Unknown W. Brackets
parent
4a615dc46c
commit
d2018f4aea
5 changed files with 249 additions and 1 deletions
|
|
@ -1633,4 +1633,8 @@ bool DIRECTX9_GPU::GetCurrentTexture(GPUDebugBuffer &buffer, int level) {
|
|||
return success;
|
||||
}
|
||||
|
||||
bool DIRECTX9_GPU::GetCurrentSimpleVertices(int count, std::vector<GPUDebugVertex> &vertices, std::vector<u16> &indices) {
|
||||
return transformDraw_.GetCurrentSimpleVertices(count, vertices, indices);
|
||||
}
|
||||
|
||||
};
|
||||
|
|
|
|||
|
|
@ -77,6 +77,8 @@ public:
|
|||
bool GetCurrentDepthbuffer(GPUDebugBuffer &buffer);
|
||||
bool GetCurrentStencilbuffer(GPUDebugBuffer &buffer);
|
||||
bool GetCurrentTexture(GPUDebugBuffer &buffer, int level);
|
||||
bool GetCurrentSimpleVertices(int count, std::vector<GPUDebugVertex> &vertices, std::vector<u16> &indices);
|
||||
|
||||
protected:
|
||||
virtual void FastRunLoop(DisplayList &list);
|
||||
virtual void ProcessEvent(GPUEvent ev);
|
||||
|
|
|
|||
|
|
@ -15,12 +15,122 @@
|
|||
// Official git repository and contact information can be found at
|
||||
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
|
||||
|
||||
#include "Core/Config.h"
|
||||
#include "Core/MemMap.h"
|
||||
#include "GPU/Directx9/TransformPipelineDX9.h"
|
||||
#include "Gpu/Common/VertexDecoderCommon.h"
|
||||
#include "GPU/Common/SplineCommon.h"
|
||||
#include "GPU/Common/VertexDecoderCommon.h"
|
||||
|
||||
namespace DX9 {
|
||||
|
||||
// This normalizes a set of vertices in any format to SimpleVertex format, by processing away morphing AND skinning.
|
||||
// The rest of the transform pipeline like lighting will go as normal, either hardware or software.
|
||||
// The implementation is initially a bit inefficient but shouldn't be a big deal.
|
||||
// An intermediate buffer of not-easy-to-predict size is stored at bufPtr.
|
||||
u32 TransformDrawEngineDX9::NormalizeVertices(u8 *outPtr, u8 *bufPtr, const u8 *inPtr, VertexDecoderDX9 *dec, int lowerBound, int upperBound, u32 vertType) {
|
||||
// First, decode the vertices into a GPU compatible format. This step can be eliminated but will need a separate
|
||||
// implementation of the vertex decoder.
|
||||
dec->DecodeVerts(bufPtr, inPtr, lowerBound, upperBound);
|
||||
|
||||
// OK, morphing eliminated but bones still remain to be taken care of.
|
||||
// Let's do a partial software transform where we only do skinning.
|
||||
|
||||
VertexReader reader(bufPtr, dec->GetDecVtxFmt(), vertType);
|
||||
|
||||
SimpleVertex *sverts = (SimpleVertex *)outPtr;
|
||||
|
||||
const u8 defaultColor[4] = {
|
||||
(u8)gstate.getMaterialAmbientR(),
|
||||
(u8)gstate.getMaterialAmbientG(),
|
||||
(u8)gstate.getMaterialAmbientB(),
|
||||
(u8)gstate.getMaterialAmbientA(),
|
||||
};
|
||||
|
||||
// Let's have two separate loops, one for non skinning and one for skinning.
|
||||
if (!g_Config.bSoftwareSkinning && (vertType & GE_VTYPE_WEIGHT_MASK) != GE_VTYPE_WEIGHT_NONE) {
|
||||
int numBoneWeights = vertTypeGetNumBoneWeights(vertType);
|
||||
for (int i = lowerBound; i <= upperBound; i++) {
|
||||
reader.Goto(i);
|
||||
SimpleVertex &sv = sverts[i];
|
||||
if (vertType & GE_VTYPE_TC_MASK) {
|
||||
reader.ReadUV(sv.uv);
|
||||
}
|
||||
|
||||
if (vertType & GE_VTYPE_COL_MASK) {
|
||||
reader.ReadColor0_8888(sv.color);
|
||||
} else {
|
||||
memcpy(sv.color, defaultColor, 4);
|
||||
}
|
||||
|
||||
float nrm[3], pos[3];
|
||||
float bnrm[3], bpos[3];
|
||||
|
||||
if (vertType & GE_VTYPE_NRM_MASK) {
|
||||
// Normals are generated during tesselation anyway, not sure if any need to supply
|
||||
reader.ReadNrm(nrm);
|
||||
} else {
|
||||
nrm[0] = 0;
|
||||
nrm[1] = 0;
|
||||
nrm[2] = 1.0f;
|
||||
}
|
||||
reader.ReadPos(pos);
|
||||
|
||||
// Apply skinning transform directly
|
||||
float weights[8];
|
||||
reader.ReadWeights(weights);
|
||||
// Skinning
|
||||
Vec3Packedf psum(0,0,0);
|
||||
Vec3Packedf nsum(0,0,0);
|
||||
for (int w = 0; w < numBoneWeights; w++) {
|
||||
if (weights[w] != 0.0f) {
|
||||
Vec3ByMatrix43(bpos, pos, gstate.boneMatrix+w*12);
|
||||
Vec3Packedf tpos(bpos);
|
||||
psum += tpos * weights[w];
|
||||
|
||||
Norm3ByMatrix43(bnrm, nrm, gstate.boneMatrix+w*12);
|
||||
Vec3Packedf tnorm(bnrm);
|
||||
nsum += tnorm * weights[w];
|
||||
}
|
||||
}
|
||||
sv.pos = psum;
|
||||
sv.nrm = nsum;
|
||||
}
|
||||
} else {
|
||||
for (int i = lowerBound; i <= upperBound; i++) {
|
||||
reader.Goto(i);
|
||||
SimpleVertex &sv = sverts[i];
|
||||
if (vertType & GE_VTYPE_TC_MASK) {
|
||||
reader.ReadUV(sv.uv);
|
||||
} else {
|
||||
sv.uv[0] = 0; // This will get filled in during tesselation
|
||||
sv.uv[1] = 0;
|
||||
}
|
||||
if (vertType & GE_VTYPE_COL_MASK) {
|
||||
reader.ReadColor0_8888(sv.color);
|
||||
} else {
|
||||
memcpy(sv.color, defaultColor, 4);
|
||||
}
|
||||
if (vertType & GE_VTYPE_NRM_MASK) {
|
||||
// Normals are generated during tesselation anyway, not sure if any need to supply
|
||||
reader.ReadNrm((float *)&sv.nrm);
|
||||
} else {
|
||||
sv.nrm.x = 0;
|
||||
sv.nrm.y = 0;
|
||||
sv.nrm.z = 1.0f;
|
||||
}
|
||||
reader.ReadPos((float *)&sv.pos);
|
||||
}
|
||||
}
|
||||
|
||||
// Okay, there we are! Return the new type (but keep the index bits)
|
||||
return GE_VTYPE_TC_FLOAT | GE_VTYPE_COL_8888 | GE_VTYPE_NRM_FLOAT | GE_VTYPE_POS_FLOAT | (vertType & (GE_VTYPE_IDX_MASK | GE_VTYPE_THROUGH));
|
||||
}
|
||||
|
||||
u32 TransformDrawEngineDX9::NormalizeVertices(u8 *outPtr, u8 *bufPtr, const u8 *inPtr, int lowerBound, int upperBound, u32 vertType) {
|
||||
const u32 vertTypeID = (vertType & 0xFFFFFF) | (gstate.getUVGenMode() << 24);
|
||||
VertexDecoderDX9 *dec = GetVertexDecoder(vertTypeID);
|
||||
return NormalizeVertices(outPtr, bufPtr, inPtr, dec, lowerBound, upperBound, vertType);
|
||||
}
|
||||
|
||||
// Spline implementation copied and modified from neobrain's softgpu (orphis code?)
|
||||
|
||||
|
|
|
|||
|
|
@ -81,6 +81,7 @@
|
|||
#include "GPU/ge_constants.h"
|
||||
|
||||
#include "GPU/Common/TextureDecoder.h"
|
||||
#include "GPU/Common/SplineCommon.h"
|
||||
#include "GPU/Common/TransformCommon.h"
|
||||
#include "GPU/Directx9/StateMappingDX9.h"
|
||||
#include "GPU/Directx9/TextureCacheDX9.h"
|
||||
|
|
@ -1307,4 +1308,131 @@ bool TransformDrawEngineDX9::TestBoundingBox(void* control_points, int vertexCou
|
|||
return true;
|
||||
}
|
||||
|
||||
// TODO: Probably move this to common code (with normalization?)
|
||||
|
||||
static Vec3f ClipToScreen(const Vec4f& coords) {
|
||||
// TODO: Check for invalid parameters (x2 < x1, etc)
|
||||
float vpx1 = getFloat24(gstate.viewportx1);
|
||||
float vpx2 = getFloat24(gstate.viewportx2);
|
||||
float vpy1 = getFloat24(gstate.viewporty1);
|
||||
float vpy2 = getFloat24(gstate.viewporty2);
|
||||
float vpz1 = getFloat24(gstate.viewportz1);
|
||||
float vpz2 = getFloat24(gstate.viewportz2);
|
||||
|
||||
float retx = coords.x * vpx1 / coords.w + vpx2;
|
||||
float rety = coords.y * vpy1 / coords.w + vpy2;
|
||||
float retz = coords.z * vpz1 / coords.w + vpz2;
|
||||
|
||||
// 16 = 0xFFFF / 4095.9375
|
||||
return Vec3f(retx * 16, rety * 16, retz);
|
||||
}
|
||||
|
||||
static Vec3f ScreenToDrawing(const Vec3f& coords) {
|
||||
Vec3f ret;
|
||||
ret.x = (coords.x - gstate.getOffsetX16()) * (1.0f / 16.0f);
|
||||
ret.y = (coords.y - gstate.getOffsetY16()) * (1.0f / 16.0f);
|
||||
ret.z = coords.z;
|
||||
return ret;
|
||||
}
|
||||
|
||||
// TODO: This probably is not the best interface.
|
||||
bool TransformDrawEngineDX9::GetCurrentSimpleVertices(int count, std::vector<GPUDebugVertex> &vertices, std::vector<u16> &indices) {
|
||||
// This is always for the current vertices.
|
||||
u16 indexLowerBound = 0;
|
||||
u16 indexUpperBound = count - 1;
|
||||
|
||||
bool savedVertexFullAlpha = gstate_c.vertexFullAlpha;
|
||||
|
||||
if ((gstate.vertType & GE_VTYPE_IDX_MASK) != GE_VTYPE_IDX_NONE) {
|
||||
const u8 *inds = Memory::GetPointer(gstate_c.indexAddr);
|
||||
const u16 *inds16 = (const u16 *)inds;
|
||||
|
||||
if (inds) {
|
||||
GetIndexBounds(inds, count, gstate.vertType, &indexLowerBound, &indexUpperBound);
|
||||
indices.resize(count);
|
||||
switch (gstate.vertType & GE_VTYPE_IDX_MASK) {
|
||||
case GE_VTYPE_IDX_16BIT:
|
||||
for (int i = 0; i < count; ++i) {
|
||||
indices[i] = inds16[i];
|
||||
}
|
||||
break;
|
||||
case GE_VTYPE_IDX_8BIT:
|
||||
for (int i = 0; i < count; ++i) {
|
||||
indices[i] = inds[i];
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
indices.clear();
|
||||
}
|
||||
} else {
|
||||
indices.clear();
|
||||
}
|
||||
|
||||
static std::vector<u32> temp_buffer;
|
||||
static std::vector<SimpleVertex> simpleVertices;
|
||||
temp_buffer.resize(std::max((int)indexUpperBound, 8192) * 128 / sizeof(u32));
|
||||
simpleVertices.resize(indexUpperBound + 1);
|
||||
NormalizeVertices((u8 *)(&simpleVertices[0]), (u8 *)(&temp_buffer[0]), Memory::GetPointer(gstate_c.vertexAddr), indexLowerBound, indexUpperBound, gstate.vertType);
|
||||
|
||||
float world[16];
|
||||
float view[16];
|
||||
float worldview[16];
|
||||
float worldviewproj[16];
|
||||
ConvertMatrix4x3To4x4(world, gstate.worldMatrix);
|
||||
ConvertMatrix4x3To4x4(view, gstate.viewMatrix);
|
||||
Matrix4ByMatrix4(worldview, world, view);
|
||||
Matrix4ByMatrix4(worldviewproj, worldview, gstate.projMatrix);
|
||||
|
||||
vertices.resize(indexUpperBound + 1);
|
||||
for (int i = indexLowerBound; i <= indexUpperBound; ++i) {
|
||||
const SimpleVertex &vert = simpleVertices[i];
|
||||
|
||||
if (gstate.isModeThrough()) {
|
||||
if (gstate.vertType & GE_VTYPE_TC_MASK) {
|
||||
vertices[i].u = vert.uv[0];
|
||||
vertices[i].v = vert.uv[1];
|
||||
} else {
|
||||
vertices[i].u = 0.0f;
|
||||
vertices[i].v = 0.0f;
|
||||
}
|
||||
vertices[i].x = vert.pos.x;
|
||||
vertices[i].y = vert.pos.y;
|
||||
vertices[i].z = vert.pos.z;
|
||||
if (gstate.vertType & GE_VTYPE_COL_MASK) {
|
||||
memcpy(vertices[i].c, vert.color, sizeof(vertices[i].c));
|
||||
} else {
|
||||
memset(vertices[i].c, 0, sizeof(vertices[i].c));
|
||||
}
|
||||
} else {
|
||||
float clipPos[4];
|
||||
Vec3ByMatrix44(clipPos, vert.pos.AsArray(), worldviewproj);
|
||||
Vec3f screenPos = ClipToScreen(clipPos);
|
||||
Vec3f drawPos = ScreenToDrawing(screenPos);
|
||||
|
||||
if (gstate.vertType & GE_VTYPE_TC_MASK) {
|
||||
vertices[i].u = vert.uv[0];
|
||||
vertices[i].v = vert.uv[1];
|
||||
} else {
|
||||
vertices[i].u = 0.0f;
|
||||
vertices[i].v = 0.0f;
|
||||
}
|
||||
vertices[i].x = drawPos.x;
|
||||
vertices[i].y = drawPos.y;
|
||||
vertices[i].z = drawPos.z;
|
||||
if (gstate.vertType & GE_VTYPE_COL_MASK) {
|
||||
memcpy(vertices[i].c, vert.color, sizeof(vertices[i].c));
|
||||
} else {
|
||||
memset(vertices[i].c, 0, sizeof(vertices[i].c));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
gstate_c.vertexFullAlpha = savedVertexFullAlpha;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@
|
|||
#include <map>
|
||||
|
||||
#include <d3d9.h>
|
||||
#include "GPU/Common/GPUDebugInterface.h"
|
||||
#include "GPU/Common/IndexGenerator.h"
|
||||
#include "GPU/Directx9/VertexDecoderDX9.h"
|
||||
|
||||
|
|
@ -105,6 +106,8 @@ public:
|
|||
void SubmitBezier(void* control_points, void* indices, int count_u, int count_v, GEPatchPrimType prim_type, u32 vertType);
|
||||
bool TestBoundingBox(void* control_points, int vertexCount, u32 vertType);
|
||||
|
||||
bool GetCurrentSimpleVertices(int count, std::vector<GPUDebugVertex> &vertices, std::vector<u16> &indices);
|
||||
|
||||
void DecodeVerts();
|
||||
void SetShaderManager(ShaderManagerDX9 *shaderManager) {
|
||||
shaderManager_ = shaderManager;
|
||||
|
|
@ -141,6 +144,7 @@ private:
|
|||
bool IsReallyAClear(int numVerts) const;
|
||||
|
||||
// Preprocessing for spline/bezier
|
||||
u32 NormalizeVertices(u8 *outPtr, u8 *bufPtr, const u8 *inPtr, VertexDecoderDX9 *dec, int lowerBound, int upperBound, u32 vertType);
|
||||
u32 NormalizeVertices(u8 *outPtr, u8 *bufPtr, const u8 *inPtr, int lowerBound, int upperBound, u32 vertType);
|
||||
|
||||
// drawcall ID
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue