~ppsspp/ppsspp/ppsspp-1.1.1

transformDraw_.SubmitBezier(control_points, indices, gstate.getPatchDivisionU(), gstate.getPatchDivisionV(), bz_ucount, bz_vcount, patchPrim, computeNormals, patchFacing, gstate.vertType);

1040

}

1041

1042

void GLES_GPU::Execute_Spline(u32 op, u32 diff) {

1043

// This also make skipping drawing very effective.

1044

framebufferManager_.SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason);

1045

if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) {

1046

// TODO: Should this eat some cycles? Probably yes. Not sure if important.

1047

return;

1048

}

1049

1050

if (!Memory::IsValidAddress(gstate_c.vertexAddr)) {

1051

ERROR_LOG_REPORT(G3D, "Bad vertex address %08x!", gstate_c.vertexAddr);

1052

return;

1053

}

1054

1055

void *control_points = Memory::GetPointerUnchecked(gstate_c.vertexAddr);

1056

void *indices = NULL;

1057

if ((gstate.vertType & GE_VTYPE_IDX_MASK) != GE_VTYPE_IDX_NONE) {

1058

if (!Memory::IsValidAddress(gstate_c.indexAddr)) {

1059

ERROR_LOG_REPORT(G3D, "Bad index address %08x!", gstate_c.indexAddr);

1060

return;

1061

}

1062

indices = Memory::GetPointerUnchecked(gstate_c.indexAddr);

1063

}

1064

1065

if (gstate.getPatchPrimitiveType() == GE_PATCHPRIM_UNKNOWN) {

1066

ERROR_LOG_REPORT(G3D, "Unsupported patch primitive %x", gstate.getPatchPrimitiveType());

1067

return;

1068

}

1069

1070

if (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) {

1071

DEBUG_LOG_REPORT(G3D, "Spline + morph: %i", (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) >> GE_VTYPE_MORPHCOUNT_SHIFT);

1072

}

1073

if (vertTypeIsSkinningEnabled(gstate.vertType)) {

1074

DEBUG_LOG_REPORT(G3D, "Spline + skinning: %i", vertTypeGetNumBoneWeights(gstate.vertType));

1075

}

1076

1077

int sp_ucount = op & 0xFF;

1078

int sp_vcount = (op >> 8) & 0xFF;

1079

int sp_utype = (op >> 16) & 0x3;

1080

int sp_vtype = (op >> 18) & 0x3;

1081

GEPatchPrimType patchPrim = gstate.getPatchPrimitiveType();

1082

bool computeNormals = gstate.isLightingEnabled();

1083

bool patchFacing = gstate.patchfacing & 1;

1084

u32 vertType = gstate.vertType;

1085

transformDraw_.SubmitSpline(control_points, indices, gstate.getPatchDivisionU(), gstate.getPatchDivisionV(), sp_ucount, sp_vcount, sp_utype, sp_vtype, patchPrim, computeNormals, patchFacing, vertType);

1086

}

1087

1088

void GLES_GPU::Execute_BoundingBox(u32 op, u32 diff) {

1089

// Just resetting, nothing to bound.

1090

const u32 data = op & 0x00FFFFFF;

1091

if (data == 0) {

1092

// TODO: Should this set the bboxResult? Let's set it true for now.

1093

currentList->bboxResult = true;

1094

return;

1095

}

1096

if (((data & 7) == 0) && data <= 64) { // Sanity check

1097

void *control_points = Memory::GetPointer(gstate_c.vertexAddr);

1098

if (gstate.vertType & GE_VTYPE_IDX_MASK) {

1099

ERROR_LOG_REPORT_ONCE(boundingbox, G3D, "Indexed bounding box data not supported.");

1100

// Data seems invalid. Let's assume the box test passed.

1101

currentList->bboxResult = true;

1102

return;

1103

}

1104

1105

// Test if the bounding box is within the drawing region.

1106

currentList->bboxResult = transformDraw_.TestBoundingBox(control_points, data, gstate.vertType);

1107

} else {

1108

ERROR_LOG_REPORT_ONCE(boundingbox, G3D, "Bad bounding box data: %06x", data);

1109

// Data seems invalid. Let's assume the box test passed.

1110

currentList->bboxResult = true;

1111

}

1112

}

1113

1114

void GLES_GPU::Execute_Region(u32 op, u32 diff) {

1115

gstate_c.framebufChanged = true;

1116

gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;

1117

}

1118

1119

void GLES_GPU::Execute_Scissor(u32 op, u32 diff) {

1120

gstate_c.framebufChanged = true;

1121

gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;

1122

}

1123

1124

void GLES_GPU::Execute_FramebufType(u32 op, u32 diff) {

1125

gstate_c.framebufChanged = true;

1126

gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;

1127

}

1128

1129

void GLES_GPU::Execute_ViewportType(u32 op, u32 diff) {

1130

gstate_c.framebufChanged = true;

1131

gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;

1132

}

1133

1134

void GLES_GPU::Execute_ViewportZType(u32 op, u32 diff) {

1135

gstate_c.framebufChanged = true;

1136

gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;

1137

shaderManager_->DirtyUniform(DIRTY_DEPTHRANGE);

1138

}

1139

1140

void GLES_GPU::Execute_TexScaleU(u32 op, u32 diff) {

1141

gstate_c.uv.uScale = getFloat24(op);

1142

shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);

1143

}

1144

1145

void GLES_GPU::Execute_TexScaleV(u32 op, u32 diff) {

1146

gstate_c.uv.vScale = getFloat24(op);

1147

shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);

1148

}

1149

1150

void GLES_GPU::Execute_TexOffsetU(u32 op, u32 diff) {

1151

gstate_c.uv.uOff = getFloat24(op);

1152

shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);

1153

}

1154

1155

void GLES_GPU::Execute_TexOffsetV(u32 op, u32 diff) {

1156

gstate_c.uv.vOff = getFloat24(op);

1157

shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);

1158

}

1159

1160

void GLES_GPU::Execute_TexAddr0(u32 op, u32 diff) {

1161

gstate_c.textureChanged = TEXCHANGE_UPDATED;

1162

shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);

1163

}

1164

1165

void GLES_GPU::Execute_TexAddrN(u32 op, u32 diff) {

1166

gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;

1167

}

1168

1169

void GLES_GPU::Execute_TexBufw0(u32 op, u32 diff) {

1170

gstate_c.textureChanged = TEXCHANGE_UPDATED;

1171

}

1172

1173

void GLES_GPU::Execute_TexBufwN(u32 op, u32 diff) {

1174

gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;

1175

}

1176

1177

void GLES_GPU::Execute_TexSize0(u32 op, u32 diff) {

1178

// Render to texture may have overridden the width/height.

1179

// Don't reset it unless the size is different / the texture has changed.

1180

if (diff || gstate_c.textureChanged != TEXCHANGE_UNCHANGED) {

1181

gstate_c.curTextureWidth = gstate.getTextureWidth(0);

1182

gstate_c.curTextureHeight = gstate.getTextureHeight(0);

1183

shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);

1184

// We will need to reset the texture now.

1185

gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;

1186

}

1187

}

1188

1189

void GLES_GPU::Execute_TexSizeN(u32 op, u32 diff) {

1190

gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;

1191

}

1192

1193

void GLES_GPU::Execute_TexFormat(u32 op, u32 diff) {

1194

gstate_c.textureChanged = TEXCHANGE_UPDATED;

1195

}

1196

1197

void GLES_GPU::Execute_TexMapMode(u32 op, u32 diff) {

1198

shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);

1199

}

1200

1201

void GLES_GPU::Execute_TexParamType(u32 op, u32 diff) {

1202

gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;

1203

}

1204

1205

void GLES_GPU::Execute_TexEnvColor(u32 op, u32 diff) {

1206

shaderManager_->DirtyUniform(DIRTY_TEXENV);

1207

}

1208

1209

void GLES_GPU::Execute_TexLevel(u32 op, u32 diff) {

1210

// I had hoped that this would let us avoid excessively flushing in Gran Turismo, but not so,

1211

// as the game switches rapidly between modes 0 and 1.

1212

1213

if (gstate.getTexLevelMode() == GE_TEXLEVEL_MODE_CONST) {

1214

gstate.texlevel ^= diff;

1215

Flush();

1216

gstate.texlevel ^= diff;

1217

}

1218

1219

gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;

1220

}

1221

1222

void GLES_GPU::Execute_LoadClut(u32 op, u32 diff) {

1223

gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;

1224

textureCache_.LoadClut(gstate.getClutAddress(), gstate.getClutLoadBytes());

1225

// This could be used to "dirty" textures with clut.

1226

}

1227

1228

void GLES_GPU::Execute_ClutFormat(u32 op, u32 diff) {

1229

gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;

1230

// This could be used to "dirty" textures with clut.

1231

}

1232

1233

void GLES_GPU::Execute_Ambient(u32 op, u32 diff) {

1234

shaderManager_->DirtyUniform(DIRTY_AMBIENT);

1235

}

1236

1237

void GLES_GPU::Execute_MaterialDiffuse(u32 op, u32 diff) {

1238

shaderManager_->DirtyUniform(DIRTY_MATDIFFUSE);

1239

}

1240

1241

void GLES_GPU::Execute_MaterialEmissive(u32 op, u32 diff) {

1242

shaderManager_->DirtyUniform(DIRTY_MATEMISSIVE);

1243

}

1244

1245

void GLES_GPU::Execute_MaterialAmbient(u32 op, u32 diff) {

1246

shaderManager_->DirtyUniform(DIRTY_MATAMBIENTALPHA);

1247

}

1248

1249

void GLES_GPU::Execute_MaterialSpecular(u32 op, u32 diff) {

1250

shaderManager_->DirtyUniform(DIRTY_MATSPECULAR);

1251

}

1252

1253

void GLES_GPU::Execute_Light0Param(u32 op, u32 diff) {

1254

shaderManager_->DirtyUniform(DIRTY_LIGHT0);

1255

}

1256

1257

void GLES_GPU::Execute_Light1Param(u32 op, u32 diff) {

1258

shaderManager_->DirtyUniform(DIRTY_LIGHT1);

1259

}

1260

1261

void GLES_GPU::Execute_Light2Param(u32 op, u32 diff) {

1262

shaderManager_->DirtyUniform(DIRTY_LIGHT2);

1263

}

1264

1265

void GLES_GPU::Execute_Light3Param(u32 op, u32 diff) {

1266

shaderManager_->DirtyUniform(DIRTY_LIGHT3);

1267

}

1268

1269

void GLES_GPU::Execute_FogColor(u32 op, u32 diff) {

1270

shaderManager_->DirtyUniform(DIRTY_FOGCOLOR);

1271

}

1272

1273

void GLES_GPU::Execute_FogCoef(u32 op, u32 diff) {

1274

shaderManager_->DirtyUniform(DIRTY_FOGCOEF);

1275

}

1276

1277

void GLES_GPU::Execute_ColorTestMask(u32 op, u32 diff) {

1278

shaderManager_->DirtyUniform(DIRTY_ALPHACOLORMASK);

1279

}

1280

1281

void GLES_GPU::Execute_AlphaTest(u32 op, u32 diff) {

1282

shaderManager_->DirtyUniform(DIRTY_ALPHACOLORREF);

1283

shaderManager_->DirtyUniform(DIRTY_ALPHACOLORMASK);

1284

}

1285

1286

void GLES_GPU::Execute_StencilTest(u32 op, u32 diff) {

1287

shaderManager_->DirtyUniform(DIRTY_STENCILREPLACEVALUE);

1288

}

1289

1290

void GLES_GPU::Execute_ColorRef(u32 op, u32 diff) {

1291

shaderManager_->DirtyUniform(DIRTY_ALPHACOLORREF);

1292

}

1293

1294

void GLES_GPU::Execute_WorldMtxNum(u32 op, u32 diff) {

1295

// This is almost always followed by GE_CMD_WORLDMATRIXDATA.

1296

const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);

1297

u32 *dst = (u32 *)(gstate.worldMatrix + (op & 0xF));

1298

const int end = 12 - (op & 0xF);

1299

int i = 0;

1300

1301

while ((src[i] >> 24) == GE_CMD_WORLDMATRIXDATA) {

1302

const u32 newVal = src[i] << 8;

1303

if (dst[i] != newVal) {

1304

Flush();

1305

dst[i] = newVal;

1306

shaderManager_->DirtyUniform(DIRTY_WORLDMATRIX);

1307

}

1308

if (++i >= end) {

1309

break;

1310

}

1311

}

1312

1313

const int count = i;

1314

gstate.worldmtxnum = (GE_CMD_WORLDMATRIXNUMBER << 24) | ((op + count) & 0xF);

1315

1316

// Skip over the loaded data, it's done now.

1317

UpdatePC(currentList->pc, currentList->pc + count * 4);

1318

currentList->pc += count * 4;

1319

}

1320

1321

void GLES_GPU::Execute_WorldMtxData(u32 op, u32 diff) {

1322

// Note: it's uncommon to get here now, see above.

1323

int num = gstate.worldmtxnum & 0xF;

1324

u32 newVal = op << 8;

1325

if (num < 12 && newVal != ((const u32 *)gstate.worldMatrix)[num]) {

1326

Flush();

1327

((u32 *)gstate.worldMatrix)[num] = newVal;

1328

shaderManager_->DirtyUniform(DIRTY_WORLDMATRIX);

1329

}

1330

num++;

1331

gstate.worldmtxnum = (GE_CMD_WORLDMATRIXNUMBER << 24) | (num & 0xF);

1332

}

1333

1334

void GLES_GPU::Execute_ViewMtxNum(u32 op, u32 diff) {

1335

// This is almost always followed by GE_CMD_VIEWMATRIXDATA.

1336

const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);

1337

u32 *dst = (u32 *)(gstate.viewMatrix + (op & 0xF));

1338

const int end = 12 - (op & 0xF);

1339

int i = 0;

1340

1341

while ((src[i] >> 24) == GE_CMD_VIEWMATRIXDATA) {

1342

const u32 newVal = src[i] << 8;

1343

if (dst[i] != newVal) {

1344

Flush();

1345

dst[i] = newVal;

1346

shaderManager_->DirtyUniform(DIRTY_VIEWMATRIX);

1347

}

1348

if (++i >= end) {

1349

break;

1350

}

1351

}

1352

1353

const int count = i;

1354

gstate.viewmtxnum = (GE_CMD_VIEWMATRIXNUMBER << 24) | ((op + count) & 0xF);

1355

1356

// Skip over the loaded data, it's done now.

1357

UpdatePC(currentList->pc, currentList->pc + count * 4);

1358

currentList->pc += count * 4;

1359

}

1360

1361

void GLES_GPU::Execute_ViewMtxData(u32 op, u32 diff) {

1362

// Note: it's uncommon to get here now, see above.

1363

int num = gstate.viewmtxnum & 0xF;

1364

u32 newVal = op << 8;

1365

if (num < 12 && newVal != ((const u32 *)gstate.viewMatrix)[num]) {

1366

Flush();

1367

((u32 *)gstate.viewMatrix)[num] = newVal;

1368

shaderManager_->DirtyUniform(DIRTY_VIEWMATRIX);

1369

}

1370

num++;

1371

gstate.viewmtxnum = (GE_CMD_VIEWMATRIXNUMBER << 24) | (num & 0xF);

1372

}

1373

1374

void GLES_GPU::Execute_ProjMtxNum(u32 op, u32 diff) {

1375

// This is almost always followed by GE_CMD_PROJMATRIXDATA.

1376

const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);

1377

u32 *dst = (u32 *)(gstate.projMatrix + (op & 0xF));

1378

const int end = 16 - (op & 0xF);

1379

int i = 0;

1380

1381

while ((src[i] >> 24) == GE_CMD_PROJMATRIXDATA) {

1382

const u32 newVal = src[i] << 8;

1383

if (dst[i] != newVal) {

1384

Flush();

1385

dst[i] = newVal;

1386

shaderManager_->DirtyUniform(DIRTY_PROJMATRIX);

1387

}

1388

if (++i >= end) {

1389

break;

1390

}

1391

}

1392

1393

const int count = i;

1394

gstate.projmtxnum = (GE_CMD_PROJMATRIXNUMBER << 24) | ((op + count) & 0xF);

1395

1396

// Skip over the loaded data, it's done now.

1397

UpdatePC(currentList->pc, currentList->pc + count * 4);

1398

currentList->pc += count * 4;

1399

}

1400

1401

void GLES_GPU::Execute_ProjMtxData(u32 op, u32 diff) {

1402

// Note: it's uncommon to get here now, see above.

1403

int num = gstate.projmtxnum & 0xF;

1404

u32 newVal = op << 8;

1405

if (newVal != ((const u32 *)gstate.projMatrix)[num]) {

1406

Flush();

1407

((u32 *)gstate.projMatrix)[num] = newVal;

1408

shaderManager_->DirtyUniform(DIRTY_PROJMATRIX);

1409

}

1410

num++;

1411

gstate.projmtxnum = (GE_CMD_PROJMATRIXNUMBER << 24) | (num & 0xF);

1412

}

1413

1414

void GLES_GPU::Execute_TgenMtxNum(u32 op, u32 diff) {

1415

// This is almost always followed by GE_CMD_TGENMATRIXDATA.

1416

const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);

1417

u32 *dst = (u32 *)(gstate.tgenMatrix + (op & 0xF));

1418

const int end = 12 - (op & 0xF);

1419

int i = 0;

1420

1421

while ((src[i] >> 24) == GE_CMD_TGENMATRIXDATA) {

1422

const u32 newVal = src[i] << 8;

1423

if (dst[i] != newVal) {

1424

Flush();

1425

dst[i] = newVal;

1426

shaderManager_->DirtyUniform(DIRTY_TEXMATRIX);

1427

}

1428

if (++i >= end) {

1429

break;

1430

}

1431

}

1432

1433

const int count = i;

1434

gstate.texmtxnum = (GE_CMD_TGENMATRIXNUMBER << 24) | ((op + count) & 0xF);

1435

1436

// Skip over the loaded data, it's done now.

1437

UpdatePC(currentList->pc, currentList->pc + count * 4);

1438

currentList->pc += count * 4;

1439

}

1440

1441

void GLES_GPU::Execute_TgenMtxData(u32 op, u32 diff) {

1442

// Note: it's uncommon to get here now, see above.

1443

int num = gstate.texmtxnum & 0xF;

1444

u32 newVal = op << 8;

1445

if (num < 12 && newVal != ((const u32 *)gstate.tgenMatrix)[num]) {

1446

Flush();

1447

((u32 *)gstate.tgenMatrix)[num] = newVal;

1448

shaderManager_->DirtyUniform(DIRTY_TEXMATRIX);

1449

}

1450

num++;

1451

gstate.texmtxnum = (GE_CMD_TGENMATRIXNUMBER << 24) | (num & 0xF);

1452

}

1453

1454

void GLES_GPU::Execute_BoneMtxNum(u32 op, u32 diff) {

1455

// This is almost always followed by GE_CMD_BONEMATRIXDATA.

1456

const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);

1457

u32 *dst = (u32 *)(gstate.boneMatrix + (op & 0x7F));

1458

const int end = 12 * 8 - (op & 0x7F);

1459

int i = 0;

1460

1461

// If we can't use software skinning, we have to flush and dirty.

1462

if (!g_Config.bSoftwareSkinning || (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) != 0) {

1463

while ((src[i] >> 24) == GE_CMD_BONEMATRIXDATA) {

1464

const u32 newVal = src[i] << 8;

1465

if (dst[i] != newVal) {

1466

Flush();

1467

dst[i] = newVal;

1468

}

1469

if (++i >= end) {

1470

break;

1471

}

1472

}

1473

1474

const int numPlusCount = (op & 0x7F) + i;

1475

for (int num = op & 0x7F; num < numPlusCount; num += 12) {

1476

shaderManager_->DirtyUniform(DIRTY_BONEMATRIX0 << (num / 12));

1477

}

1478

} else {

1479

while ((src[i] >> 24) == GE_CMD_BONEMATRIXDATA) {

1480

dst[i] = src[i] << 8;

1481

if (++i >= end) {

1482

break;

1483

}

1484

}

1485

1486

const int numPlusCount = (op & 0x7F) + i;

1487

for (int num = op & 0x7F; num < numPlusCount; num += 12) {

1488

gstate_c.deferredVertTypeDirty |= DIRTY_BONEMATRIX0 << (num / 12);

1489

}

1490

}

1491

1492

const int count = i;

1493

gstate.boneMatrixNumber = (GE_CMD_BONEMATRIXNUMBER << 24) | ((op + count) & 0x7F);

1494

1495

// Skip over the loaded data, it's done now.

1496

UpdatePC(currentList->pc, currentList->pc + count * 4);

1497

currentList->pc += count * 4;

1498

}

1499

1500

void GLES_GPU::Execute_BoneMtxData(u32 op, u32 diff) {

1501

// Note: it's uncommon to get here now, see above.

1502

int num = gstate.boneMatrixNumber & 0x7F;

1503

u32 newVal = op << 8;

1504

if (num < 96 && newVal != ((const u32 *)gstate.boneMatrix)[num]) {

1505

// Bone matrices should NOT flush when software skinning is enabled!

1506

if (!g_Config.bSoftwareSkinning || (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) != 0) {

1507

Flush();

1508

shaderManager_->DirtyUniform(DIRTY_BONEMATRIX0 << (num / 12));

1509

} else {

1510

gstate_c.deferredVertTypeDirty |= DIRTY_BONEMATRIX0 << (num / 12);

1511

}

1512

((u32 *)gstate.boneMatrix)[num] = newVal;

1513

}

1514

num++;

1515

gstate.boneMatrixNumber = (GE_CMD_BONEMATRIXNUMBER << 24) | (num & 0x7F);

1516

}

1517

1518

void GLES_GPU::Execute_BlockTransferStart(u32 op, u32 diff) {

1519

// TODO: Here we should check if the transfer overlaps a framebuffer or any textures,

1520

// and take appropriate action. This is a block transfer between RAM and VRAM, or vice versa.

1521

// Can we skip this on SkipDraw?

1522

DoBlockTransfer(gstate_c.skipDrawReason);

1523

1524

// Fixes Gran Turismo's funky text issue, since it overwrites the current texture.

1525

gstate_c.textureChanged = TEXCHANGE_UPDATED;

1526

}

1527

1528

void GLES_GPU::Execute_Generic(u32 op, u32 diff) {

1529

u32 cmd = op >> 24;

1530

u32 data = op & 0xFFFFFF;

1531

1532

// Handle control and drawing commands here directly. The others we delegate.

1533

switch (cmd) {

1534

case GE_CMD_BASE:

1535

break;

1536

1537

case GE_CMD_VADDR:

1538

Execute_Vaddr(op, diff);

1539

break;

1540

1541

case GE_CMD_IADDR:

1542

Execute_Iaddr(op, diff);

1543

break;

1544

1545

case GE_CMD_PRIM:

1546

Execute_Prim(op, diff);

1547

break;

1548

1549

// The arrow and other rotary items in Puzbob are bezier patches, strangely enough.

1550

case GE_CMD_BEZIER:

1551

Execute_Bezier(op, diff);

1552

break;

1553

1554

case GE_CMD_SPLINE:

1555

Execute_Spline(op, diff);

1556

break;

1557

1558

case GE_CMD_BOUNDINGBOX:

1559

Execute_BoundingBox(op, diff);

1560

break;

1561

1562

case GE_CMD_VERTEXTYPE:

1563

Execute_VertexType(op, diff);

1564

break;

1565

1566

case GE_CMD_REGION1:

1567

case GE_CMD_REGION2:

1568

Execute_Region(op, diff);

1569

break;

1570

1571

case GE_CMD_CLIPENABLE:

1572

//we always clip, this is opengl

1573

break;

1574

1575

case GE_CMD_CULLFACEENABLE:

1576

case GE_CMD_CULL:

1577

break;

1578

1579

case GE_CMD_TEXTUREMAPENABLE:

1580

// Don't need to dirty the texture here, already dirtied at list start/etc.

1581

break;

1582

1583

case GE_CMD_LIGHTINGENABLE:

1584

break;

1585

1586

case GE_CMD_FOGCOLOR:

1587

Execute_FogColor(op, diff);

1588

break;

1589

1590

case GE_CMD_FOG1:

1591

case GE_CMD_FOG2:

1592

Execute_FogCoef(op, diff);

1593

break;

1594

1595

case GE_CMD_FOGENABLE:

1596

break;

1597

1598

case GE_CMD_DITHERENABLE:

1599

break;

1600

1601

case GE_CMD_OFFSETX:

1602

break;

1603

1604

case GE_CMD_OFFSETY:

1605

break;

1606

1607

case GE_CMD_TEXSCALEU:

1608

Execute_TexScaleU(op, diff);

1609

break;

1610

1611

case GE_CMD_TEXSCALEV:

1612

Execute_TexScaleV(op, diff);

1613

break;

1614

1615

case GE_CMD_TEXOFFSETU:

1616

Execute_TexOffsetU(op, diff);

1617

break;

1618

1619

case GE_CMD_TEXOFFSETV:

1620

Execute_TexOffsetV(op, diff);

1621

break;

1622

1623

case GE_CMD_SCISSOR1:

1624

case GE_CMD_SCISSOR2:

1625

Execute_Scissor(op, diff);

1626

break;

1627

1628

///

1629

case GE_CMD_MINZ:

1630

case GE_CMD_MAXZ:

1631

break;

1632

1633

case GE_CMD_FRAMEBUFPTR:

1634

case GE_CMD_FRAMEBUFWIDTH:

1635

case GE_CMD_FRAMEBUFPIXFORMAT:

1636

Execute_FramebufType(op, diff);

1637

break;

1638

1639

case GE_CMD_TEXADDR0:

1640

Execute_TexAddr0(op, diff);

1641

break;

1642

1643

case GE_CMD_TEXADDR1:

1644

case GE_CMD_TEXADDR2:

1645

case GE_CMD_TEXADDR3:

1646

case GE_CMD_TEXADDR4:

1647

case GE_CMD_TEXADDR5:

1648

case GE_CMD_TEXADDR6:

1649

case GE_CMD_TEXADDR7:

1650

Execute_TexAddrN(op, diff);

1651

break;

1652

1653

case GE_CMD_TEXBUFWIDTH0:

1654

Execute_TexBufw0(op, diff);

1655

break;

1656

1657

case GE_CMD_TEXBUFWIDTH1:

1658

case GE_CMD_TEXBUFWIDTH2:

1659

case GE_CMD_TEXBUFWIDTH3:

1660

case GE_CMD_TEXBUFWIDTH4:

1661

case GE_CMD_TEXBUFWIDTH5:

1662

case GE_CMD_TEXBUFWIDTH6:

1663

case GE_CMD_TEXBUFWIDTH7:

1664

Execute_TexBufwN(op, diff);

1665

break;

1666

1667

case GE_CMD_CLUTFORMAT:

1668

Execute_ClutFormat(op, diff);

1669

break;

1670

1671

case GE_CMD_CLUTADDR:

1672

case GE_CMD_CLUTADDRUPPER:

1673

// Hm, LOADCLUT actually changes the CLUT so no need to dirty here.

1674

break;

1675

1676

case GE_CMD_LOADCLUT:

1677

Execute_LoadClut(op, diff);

1678

break;

1679

1680

case GE_CMD_TEXMAPMODE:

1681

Execute_TexMapMode(op, diff);

1682

break;

1683

1684

case GE_CMD_TEXSHADELS:

1685

break;

1686

1687

case GE_CMD_TRANSFERSRC:

1688

case GE_CMD_TRANSFERSRCW:

1689

case GE_CMD_TRANSFERDST:

1690

case GE_CMD_TRANSFERDSTW:

1691

case GE_CMD_TRANSFERSRCPOS:

1692

case GE_CMD_TRANSFERDSTPOS:

1693

break;

1694

1695

case GE_CMD_TRANSFERSIZE:

1696

break;

1697

1698

case GE_CMD_TRANSFERSTART: // Orphis calls this TRXKICK

1699

Execute_BlockTransferStart(op, diff);

1700

break;

1701

1702

case GE_CMD_TEXSIZE0:

1703

Execute_TexSize0(op, diff);

1704

break;

1705

1706

case GE_CMD_TEXSIZE1:

1707

case GE_CMD_TEXSIZE2:

1708

case GE_CMD_TEXSIZE3:

1709

case GE_CMD_TEXSIZE4:

1710

case GE_CMD_TEXSIZE5:

1711

case GE_CMD_TEXSIZE6:

1712

case GE_CMD_TEXSIZE7:

1713

Execute_TexSizeN(op, diff);

1714

break;

1715

1716

case GE_CMD_ZBUFPTR:

1717

case GE_CMD_ZBUFWIDTH:

1718

break;

1719

1720

case GE_CMD_AMBIENTCOLOR:

1721

case GE_CMD_AMBIENTALPHA:

1722

Execute_Ambient(op, diff);

1723

break;

1724

1725

case GE_CMD_MATERIALDIFFUSE:

1726

Execute_MaterialDiffuse(op, diff);

1727

break;

1728

1729

case GE_CMD_MATERIALEMISSIVE:

1730

Execute_MaterialEmissive(op, diff);

1731

break;

1732

1733

case GE_CMD_MATERIALAMBIENT:

1734

case GE_CMD_MATERIALALPHA:

1735

Execute_MaterialAmbient(op, diff);

1736

break;

1737

1738

case GE_CMD_MATERIALSPECULAR:

1739

case GE_CMD_MATERIALSPECULARCOEF:

1740

Execute_MaterialSpecular(op, diff);

1741

break;

1742

1743

case GE_CMD_LIGHTTYPE0:

1744

case GE_CMD_LIGHTTYPE1:

1745

case GE_CMD_LIGHTTYPE2:

1746

case GE_CMD_LIGHTTYPE3:

1747

break;

1748

1749

case GE_CMD_LX0:case GE_CMD_LY0:case GE_CMD_LZ0:

1750

case GE_CMD_LDX0:case GE_CMD_LDY0:case GE_CMD_LDZ0:

1751

case GE_CMD_LKA0:case GE_CMD_LKB0:case GE_CMD_LKC0:

1752

case GE_CMD_LKS0: // spot coef ("conv")

1753

case GE_CMD_LKO0: // light angle ("cutoff")

1754

case GE_CMD_LAC0:

1755

case GE_CMD_LDC0:

1756

case GE_CMD_LSC0:

1757

Execute_Light0Param(op, diff);

1758

break;

1759

case GE_CMD_LX1:case GE_CMD_LY1:case GE_CMD_LZ1:

1760

case GE_CMD_LDX1:case GE_CMD_LDY1:case GE_CMD_LDZ1:

1761

case GE_CMD_LKA1:case GE_CMD_LKB1:case GE_CMD_LKC1:

1762

case GE_CMD_LKS1:

1763

case GE_CMD_LKO1:

1764

case GE_CMD_LAC1:

1765

case GE_CMD_LDC1:

1766

case GE_CMD_LSC1:

1767

Execute_Light1Param(op, diff);

1768

break;

1769

case GE_CMD_LX2:case GE_CMD_LY2:case GE_CMD_LZ2:

1770

case GE_CMD_LDX2:case GE_CMD_LDY2:case GE_CMD_LDZ2:

1771

case GE_CMD_LKA2:case GE_CMD_LKB2:case GE_CMD_LKC2:

1772

case GE_CMD_LKS2:

1773

case GE_CMD_LKO2:

1774

case GE_CMD_LAC2:

1775

case GE_CMD_LDC2:

1776

case GE_CMD_LSC2:

1777

Execute_Light2Param(op, diff);

1778

break;

1779

case GE_CMD_LX3:case GE_CMD_LY3:case GE_CMD_LZ3:

1780

case GE_CMD_LDX3:case GE_CMD_LDY3:case GE_CMD_LDZ3:

1781

case GE_CMD_LKA3:case GE_CMD_LKB3:case GE_CMD_LKC3:

1782

case GE_CMD_LKS3:

1783

case GE_CMD_LKO3:

1784

case GE_CMD_LAC3:

1785

case GE_CMD_LDC3:

1786

case GE_CMD_LSC3:

1787

Execute_Light3Param(op, diff);

1788

break;

1789

1790

case GE_CMD_VIEWPORTX1:

1791

case GE_CMD_VIEWPORTY1:

1792

case GE_CMD_VIEWPORTX2:

1793

case GE_CMD_VIEWPORTY2:

1794

case GE_CMD_VIEWPORTZ1:

1795

case GE_CMD_VIEWPORTZ2:

1796

Execute_ViewportType(op, diff);

1797

break;

1798

1799

case GE_CMD_LIGHTENABLE0:

1800

case GE_CMD_LIGHTENABLE1:

1801

case GE_CMD_LIGHTENABLE2:

1802

case GE_CMD_LIGHTENABLE3:

1803

break;

1804

1805

case GE_CMD_SHADEMODE:

1806

break;

1807

1808

case GE_CMD_PATCHDIVISION:

1809

case GE_CMD_PATCHPRIMITIVE:

1810

case GE_CMD_PATCHFACING:

1811

break;

1812

1813

1814

case GE_CMD_MATERIALUPDATE:

1815

break;

1816

1817

//////////////////////////////////////////////////////////////////

1818

// CLEARING

1819

//////////////////////////////////////////////////////////////////

1820

case GE_CMD_CLEARMODE:

1821

break;

1822

1823

//////////////////////////////////////////////////////////////////

1824

// ALPHA BLENDING

1825

//////////////////////////////////////////////////////////////////

1826

case GE_CMD_ALPHABLENDENABLE:

1827

case GE_CMD_BLENDMODE:

1828

break;

1829

1830

case GE_CMD_BLENDFIXEDA:

1831

case GE_CMD_BLENDFIXEDB:

1832

break;

1833

1834

case GE_CMD_ALPHATESTENABLE:

1835

case GE_CMD_COLORTESTENABLE:

1836

// They are done in the fragment shader.

1837

break;

1838

1839

case GE_CMD_COLORTEST:

1840

break;

1841

1842

case GE_CMD_COLORTESTMASK:

1843

Execute_ColorTestMask(op, diff);

1844

break;

1845

1846

case GE_CMD_ALPHATEST:

1847

Execute_AlphaTest(op, diff);

1848

break;

1849

1850

case GE_CMD_COLORREF:

1851

Execute_ColorRef(op, diff);

1852

break;

1853

1854

case GE_CMD_TEXENVCOLOR:

1855

Execute_TexEnvColor(op, diff);

1856

break;

1857

1858

case GE_CMD_TEXFUNC:

1859

case GE_CMD_TEXFLUSH:

1860

break;

1861

1862

case GE_CMD_TEXFORMAT:

1863

Execute_TexFormat(op, diff);

1864

break;

1865

1866

case GE_CMD_TEXMODE:

1867

case GE_CMD_TEXFILTER:

1868

case GE_CMD_TEXWRAP:

1869

Execute_TexParamType(op, diff);

1870

break;

1871

1872

//////////////////////////////////////////////////////////////////

1873

// DEPTH TESTING

1874

//////////////////////////////////////////////////////////////////

1875

1876

case GE_CMD_ZTESTENABLE:

1877

case GE_CMD_ZTEST:

1878

case GE_CMD_ZWRITEDISABLE:

1879

break;

1880

1881

case GE_CMD_MORPHWEIGHT0:

1882

case GE_CMD_MORPHWEIGHT1:

1883

case GE_CMD_MORPHWEIGHT2:

1884

case GE_CMD_MORPHWEIGHT3:

1885

case GE_CMD_MORPHWEIGHT4:

1886

case GE_CMD_MORPHWEIGHT5:

1887

case GE_CMD_MORPHWEIGHT6:

1888

case GE_CMD_MORPHWEIGHT7:

1889

gstate_c.morphWeights[cmd - GE_CMD_MORPHWEIGHT0] = getFloat24(data);

1890

break;

1891

1892

case GE_CMD_DITH0:

1893

case GE_CMD_DITH1:

1894

case GE_CMD_DITH2:

1895

case GE_CMD_DITH3:

1896

break;

1897

1898

case GE_CMD_WORLDMATRIXNUMBER:

1899

Execute_WorldMtxNum(op, diff);

1900

break;

1901

1902

case GE_CMD_WORLDMATRIXDATA:

1903

Execute_WorldMtxData(op, diff);

1904

break;

1905

1906

case GE_CMD_VIEWMATRIXNUMBER:

1907

Execute_ViewMtxNum(op, diff);

1908

break;

1909

1910

case GE_CMD_VIEWMATRIXDATA:

1911

Execute_ViewMtxData(op, diff);

1912

break;

1913

1914

case GE_CMD_PROJMATRIXNUMBER:

1915

Execute_ProjMtxNum(op, diff);

1916

break;

1917

1918

case GE_CMD_PROJMATRIXDATA:

1919

Execute_ProjMtxData(op, diff);

1920

break;

1921

1922

case GE_CMD_TGENMATRIXNUMBER:

1923

Execute_TgenMtxNum(op, diff);

1924

break;

1925

1926

case GE_CMD_TGENMATRIXDATA:

1927

Execute_TgenMtxData(op, diff);

1928

break;

1929

1930

case GE_CMD_BONEMATRIXNUMBER:

1931

Execute_BoneMtxNum(op, diff);

1932

break;

1933

1934

case GE_CMD_BONEMATRIXDATA:

1935

Execute_BoneMtxData(op, diff);

1936

break;

1937

1938

#ifndef MOBILE_DEVICE

1939

case GE_CMD_ANTIALIASENABLE:

1940

if (data != 0)

1941

WARN_LOG_REPORT_ONCE(antiAlias, G3D, "Unsupported antialias enabled: %06x", data);

1942

break;

1943

1944

case GE_CMD_TEXLODSLOPE:

1945

if (data != 0)

1946

WARN_LOG_REPORT_ONCE(texLodSlope, G3D, "Unsupported texture lod slope: %06x", data);

1947

break;

1948

#endif

1949

1950

case GE_CMD_TEXLEVEL:

1951

Execute_TexLevel(op, diff);

1952

break;

1953

1954

//////////////////////////////////////////////////////////////////

1955

// STENCIL TESTING

1956

//////////////////////////////////////////////////////////////////

1957

1958

case GE_CMD_STENCILTEST:

1959

Execute_StencilTest(op, diff);

1960

break;

1961

1962

case GE_CMD_STENCILTESTENABLE:

1963

case GE_CMD_STENCILOP:

1964

break;

1965

1966

case GE_CMD_MASKRGB:

1967

case GE_CMD_MASKALPHA:

1968

break;

1969

1970

case GE_CMD_REVERSENORMAL:

1971

break;

1972

1973

case GE_CMD_VSCX:

1974

if (data != 0)

1975

WARN_LOG_REPORT_ONCE(vscx, G3D, "Unsupported Vertex Screen Coordinate X : %06x", data);

1976

break;

1977

1978

case GE_CMD_VSCY:

1979

if (data != 0)

1980

WARN_LOG_REPORT_ONCE(vscy, G3D, "Unsupported Vertex Screen Coordinate Y : %06x", data);

1981

break;

1982

1983

case GE_CMD_VSCZ:

1984

if (data != 0)

1985

WARN_LOG_REPORT_ONCE(vscz, G3D, "Unsupported Vertex Screen Coordinate Z : %06x", data);

1986

break;

1987

1988

case GE_CMD_VTCS:

1989

if (data != 0)

1990

WARN_LOG_REPORT_ONCE(vtcs, G3D, "Unsupported Vertex Texture Coordinate S : %06x", data);

1991

break;

1992

1993

case GE_CMD_VTCT:

1994

if (data != 0)

1995

WARN_LOG_REPORT_ONCE(vtct, G3D, "Unsupported Vertex Texture Coordinate T : %06x", data);

1996

break;

1997

1998

case GE_CMD_VTCQ:

1999

if (data != 0)

2000

WARN_LOG_REPORT_ONCE(vtcq, G3D, "Unsupported Vertex Texture Coordinate Q : %06x", data);

2001

break;

2002

2003

case GE_CMD_VCV:

2004

if (data != 0)

2005

WARN_LOG_REPORT_ONCE(vcv, G3D, "Unsupported Vertex Color Value : %06x", data);

2006

break;

2007

2008

case GE_CMD_VAP:

2009

if (data != 0)

2010

WARN_LOG_REPORT_ONCE(vap, G3D, "Unsupported Vertex Alpha and Primitive : %06x", data);

2011

break;

2012

2013

case GE_CMD_VFC:

2014

if (data != 0)

2015

WARN_LOG_REPORT_ONCE(vfc, G3D, "Unsupported Vertex Fog Coefficient : %06x", data);

2016

break;

2017

2018

case GE_CMD_VSCV:

2019

if (data != 0)

2020

WARN_LOG_REPORT_ONCE(vscv, G3D, "Unsupported Vertex Secondary Color Value : %06x", data);

2021

break;

2022

2023

2024

case GE_CMD_UNKNOWN_03:

2025

case GE_CMD_UNKNOWN_0D:

2026

case GE_CMD_UNKNOWN_11:

2027

case GE_CMD_UNKNOWN_29:

2028

case GE_CMD_UNKNOWN_34:

2029

case GE_CMD_UNKNOWN_35:

2030

case GE_CMD_UNKNOWN_39:

2031

case GE_CMD_UNKNOWN_4E:

2032

case GE_CMD_UNKNOWN_4F:

2033

case GE_CMD_UNKNOWN_52:

2034

case GE_CMD_UNKNOWN_59:

2035

case GE_CMD_UNKNOWN_5A:

2036

case GE_CMD_UNKNOWN_B6:

2037

case GE_CMD_UNKNOWN_B7:

2038

case GE_CMD_UNKNOWN_D1:

2039

case GE_CMD_UNKNOWN_ED:

2040

case GE_CMD_UNKNOWN_EF:

2041

case GE_CMD_UNKNOWN_FA:

2042

case GE_CMD_UNKNOWN_FB:

2043

case GE_CMD_UNKNOWN_FC:

2044

case GE_CMD_UNKNOWN_FD:

2045

case GE_CMD_UNKNOWN_FE:

2046

if (data != 0)

2047

WARN_LOG_REPORT_ONCE(unknowncmd, G3D, "Unknown GE command : %08x ", op);

2048

break;

2049

case GE_CMD_UNKNOWN_FF:

2050

// This is hit in quite a few games, supposedly it is a no-op.

2051

// Might be used for debugging or something?

2052

break;

2053

2054

default:

2055

GPUCommon::ExecuteOp(op, diff);

2056

break;

2057

}

2058

}

2059

2060

void GLES_GPU::FastLoadBoneMatrix(u32 target) {

2061

const int num = gstate.boneMatrixNumber & 0x7F;

2062

const int mtxNum = num / 12;

2063

uint32_t uniformsToDirty = DIRTY_BONEMATRIX0 << mtxNum;

2064

if ((num - 12 * mtxNum) != 0) {

2065

uniformsToDirty |= DIRTY_BONEMATRIX0 << ((mtxNum + 1) & 7);

2066

}

2067

2068

if (!g_Config.bSoftwareSkinning || (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) != 0) {

2069

Flush();

2070

shaderManager_->DirtyUniform(uniformsToDirty);

2071

} else {

2072

gstate_c.deferredVertTypeDirty |= uniformsToDirty;

2073

}

2074

gstate.FastLoadBoneMatrix(target);

2075

}

2076

2077

void GLES_GPU::UpdateStats() {

2078

gpuStats.numVertexShaders = shaderManager_->NumVertexShaders();

2079

gpuStats.numFragmentShaders = shaderManager_->NumFragmentShaders();

2080

gpuStats.numShaders = shaderManager_->NumPrograms();

2081

gpuStats.numTextures = (int)textureCache_.NumLoadedTextures();

2082

gpuStats.numFBOs = (int)framebufferManager_.NumVFBs();

2083

}

2084

2085

void GLES_GPU::DoBlockTransfer(u32 skipDrawReason) {

2086

// TODO: This is used a lot to copy data around between render targets and textures,

2087

// and also to quickly load textures from RAM to VRAM. So we should do checks like the following:

2088

// * Does dstBasePtr point to an existing texture? If so maybe reload it immediately.

2089

2090

// * Does srcBasePtr point to a render target, and dstBasePtr to a texture? If so

2091

// either copy between rt and texture or reassign the texture to point to the render target

2092

2093

// etc....

2094

2095

u32 srcBasePtr = gstate.getTransferSrcAddress();

2096

u32 srcStride = gstate.getTransferSrcStride();

2097

2098

u32 dstBasePtr = gstate.getTransferDstAddress();

2099

u32 dstStride = gstate.getTransferDstStride();

2100

2101

int srcX = gstate.getTransferSrcX();

2102

int srcY = gstate.getTransferSrcY();

2103

2104

int dstX = gstate.getTransferDstX();

2105

int dstY = gstate.getTransferDstY();

2106

2107

int width = gstate.getTransferWidth();

2108

int height = gstate.getTransferHeight();

2109

2110

int bpp = gstate.getTransferBpp();

2111

2112

DEBUG_LOG(G3D, "Block transfer: %08x/%x -> %08x/%x, %ix%ix%i (%i,%i)->(%i,%i)", srcBasePtr, srcStride, dstBasePtr, dstStride, width, height, bpp, srcX, srcY, dstX, dstY);

2113

2114

if (!Memory::IsValidAddress(srcBasePtr)) {

2115

ERROR_LOG_REPORT(G3D, "BlockTransfer: Bad source transfer address %08x!", srcBasePtr);

2116

return;

2117

}

2118

2119

if (!Memory::IsValidAddress(dstBasePtr)) {

2120

ERROR_LOG_REPORT(G3D, "BlockTransfer: Bad destination transfer address %08x!", dstBasePtr);

2121

return;

2122

}

2123

2124

// Check that the last address of both source and dest are valid addresses

2125

2126

u32 srcLastAddr = srcBasePtr + ((height - 1 + srcY) * srcStride + (srcX + width - 1)) * bpp;

2127

u32 dstLastAddr = dstBasePtr + ((height - 1 + dstY) * dstStride + (dstX + width - 1)) * bpp;

2128

2129

if (!Memory::IsValidAddress(srcLastAddr)) {

2130

ERROR_LOG_REPORT(G3D, "Bottom-right corner of source of block transfer is at an invalid address: %08x", srcLastAddr);

2131

return;

2132

}

2133

if (!Memory::IsValidAddress(dstLastAddr)) {

2134

ERROR_LOG_REPORT(G3D, "Bottom-right corner of destination of block transfer is at an invalid address: %08x", srcLastAddr);

2135

return;

2136

}

2137

2138

// Tell the framebuffer manager to take action if possible. If it does the entire thing, let's just return.

2139

if (!framebufferManager_.NotifyBlockTransferBefore(dstBasePtr, dstStride, dstX, dstY, srcBasePtr, srcStride, srcX, srcY, width, height, bpp, skipDrawReason)) {

2140

// Do the copy! (Hm, if we detect a drawn video frame (see below) then we could maybe skip this?)

2141

// Can use GetPointerUnchecked because we checked the addresses above. We could also avoid them

2142

// entirely by walking a couple of pointers...

2143

if (srcStride == dstStride && (u32)width == srcStride) {

2144

// Common case in God of War, let's do it all in one chunk.

2145

u32 srcLineStartAddr = srcBasePtr + (srcY * srcStride + srcX) * bpp;

2146

u32 dstLineStartAddr = dstBasePtr + (dstY * dstStride + dstX) * bpp;

2147

const u8 *src = Memory::GetPointerUnchecked(srcLineStartAddr);

2148

u8 *dst = Memory::GetPointerUnchecked(dstLineStartAddr);

2149

memcpy(dst, src, width * height * bpp);

2150

} else {

2151

for (int y = 0; y < height; y++) {

2152

u32 srcLineStartAddr = srcBasePtr + ((y + srcY) * srcStride + srcX) * bpp;

2153

u32 dstLineStartAddr = dstBasePtr + ((y + dstY) * dstStride + dstX) * bpp;

2154

2155

const u8 *src = Memory::GetPointerUnchecked(srcLineStartAddr);

2156

u8 *dst = Memory::GetPointerUnchecked(dstLineStartAddr);

2157

memcpy(dst, src, width * bpp);

2158

}

2159

}

2160

2161

textureCache_.Invalidate(dstBasePtr + (dstY * dstStride + dstX) * bpp, height * dstStride * bpp, GPU_INVALIDATE_HINT);

2162

framebufferManager_.NotifyBlockTransferAfter(dstBasePtr, dstStride, dstX, dstY, srcBasePtr, srcStride, srcX, srcY, width, height, bpp, skipDrawReason);

2163

}

2164

2165

#ifndef MOBILE_DEVICE

2166

CBreakPoints::ExecMemCheck(srcBasePtr + (srcY * srcStride + srcX) * bpp, false, height * srcStride * bpp, currentMIPS->pc);

2167

CBreakPoints::ExecMemCheck(dstBasePtr + (srcY * dstStride + srcX) * bpp, true, height * dstStride * bpp, currentMIPS->pc);

2168

#endif

2169

2170

// TODO: Correct timing appears to be 1.9, but erring a bit low since some of our other timing is inaccurate.

2171

cyclesExecuted += ((height * width * bpp) * 16) / 10;

2172

}

2173

2174

void GLES_GPU::InvalidateCache(u32 addr, int size, GPUInvalidationType type) {

2175

GPUEvent ev(GPU_EVENT_INVALIDATE_CACHE);

2176

ev.invalidate_cache.addr = addr;

2177

ev.invalidate_cache.size = size;

2178

ev.invalidate_cache.type = type;

2179

ScheduleEvent(ev);

2180

}

2181

2182

void GLES_GPU::InvalidateCacheInternal(u32 addr, int size, GPUInvalidationType type) {

2183

if (size > 0)

2184

textureCache_.Invalidate(addr, size, type);

2185

else

2186

textureCache_.InvalidateAll(type);

2187

2188

if (type != GPU_INVALIDATE_ALL && framebufferManager_.MayIntersectFramebuffer(addr)) {

2189

// If we're doing block transfers, we shouldn't need this, and it'll only confuse us.

2190

// Vempire invalidates (with writeback) after drawing, but before blitting.

2191

if (!g_Config.bBlockTransferGPU || type == GPU_INVALIDATE_SAFE) {

2192

framebufferManager_.UpdateFromMemory(addr, size, type == GPU_INVALIDATE_SAFE);

2193

}

2194

}

2195

}

2196

2197

void GLES_GPU::PerformMemoryCopyInternal(u32 dest, u32 src, int size) {

2198

if (!framebufferManager_.NotifyFramebufferCopy(src, dest, size, false, gstate_c.skipDrawReason)) {

2199

// We use a little hack for Download/Upload using a VRAM mirror.

2200

// Since they're identical we don't need to copy.

2201

if (!Memory::IsVRAMAddress(dest) || (dest ^ 0x00400000) != src) {

2202

Memory::Memcpy(dest, src, size);

2203

}

2204

}

2205

InvalidateCache(dest, size, GPU_INVALIDATE_HINT);

2206

}

2207

2208

void GLES_GPU::PerformMemorySetInternal(u32 dest, u8 v, int size) {

2209

if (!framebufferManager_.NotifyFramebufferCopy(dest, dest, size, true, gstate_c.skipDrawReason)) {

2210

InvalidateCache(dest, size, GPU_INVALIDATE_HINT);

2211

}

2212

}

2213

2214

void GLES_GPU::PerformStencilUploadInternal(u32 dest, int size) {

2215

framebufferManager_.NotifyStencilUpload(dest, size);

2216

}

2217

2218

bool GLES_GPU::PerformMemoryCopy(u32 dest, u32 src, int size) {

2219

// Track stray copies of a framebuffer in RAM. MotoGP does this.

2220

if (framebufferManager_.MayIntersectFramebuffer(src) || framebufferManager_.MayIntersectFramebuffer(dest)) {

2221

if (IsOnSeparateCPUThread()) {

2222

GPUEvent ev(GPU_EVENT_FB_MEMCPY);

2223

ev.fb_memcpy.dst = dest;

2224

ev.fb_memcpy.src = src;

2225

ev.fb_memcpy.size = size;

2226

ScheduleEvent(ev);

2227

2228

// This is a memcpy, so we need to wait for it to complete.

2229

SyncThread();

2230

} else {

2231

PerformMemoryCopyInternal(dest, src, size);

2232

}

2233

return true;

2234

}

2235

2236

InvalidateCache(dest, size, GPU_INVALIDATE_HINT);

2237

return false;

2238

}

2239

2240

bool GLES_GPU::PerformMemorySet(u32 dest, u8 v, int size) {

2241

// This may indicate a memset, usually to 0, of a framebuffer.

2242

if (framebufferManager_.MayIntersectFramebuffer(dest)) {

2243

Memory::Memset(dest, v, size);

2244

2245

if (IsOnSeparateCPUThread()) {

2246

GPUEvent ev(GPU_EVENT_FB_MEMSET);

2247

ev.fb_memset.dst = dest;

2248

ev.fb_memset.v = v;

2249

ev.fb_memset.size = size;

2250

ScheduleEvent(ev);

2251

2252

// We don't need to wait for the framebuffer to be updated.

2253

} else {

2254

PerformMemorySetInternal(dest, v, size);

2255

}

2256

return true;

2257

}

2258

2259

// Or perhaps a texture, let's invalidate.

2260

InvalidateCache(dest, size, GPU_INVALIDATE_HINT);

2261

return false;

2262

}

2263

2264

bool GLES_GPU::PerformMemoryDownload(u32 dest, int size) {

2265

// Cheat a bit to force a download of the framebuffer.

2266

// VRAM + 0x00400000 is simply a VRAM mirror.

2267

if (Memory::IsVRAMAddress(dest)) {

2268

return PerformMemoryCopy(dest ^ 0x00400000, dest, size);

2269

}

2270

return false;

2271

}

2272

2273

bool GLES_GPU::PerformMemoryUpload(u32 dest, int size) {

2274

// Cheat a bit to force an upload of the framebuffer.

2275

// VRAM + 0x00400000 is simply a VRAM mirror.

2276

if (Memory::IsVRAMAddress(dest)) {

2277

return PerformMemoryCopy(dest, dest ^ 0x00400000, size);

2278

}

2279

return false;

2280

}

2281

2282

bool GLES_GPU::PerformStencilUpload(u32 dest, int size) {

2283

if (framebufferManager_.MayIntersectFramebuffer(dest)) {

2284

if (IsOnSeparateCPUThread()) {

2285

GPUEvent ev(GPU_EVENT_FB_STENCIL_UPLOAD);

2286

ev.fb_stencil_upload.dst = dest;

2287

ev.fb_stencil_upload.size = size;

2288

ScheduleEvent(ev);

2289

} else {

2290

PerformStencilUploadInternal(dest, size);

2291

}

2292

return true;

2293

}

2294

return false;

2295

}

2296

2297

void GLES_GPU::ClearCacheNextFrame() {

2298

textureCache_.ClearNextFrame();

2299

}

2300

2301

void GLES_GPU::Resized() {

2302

resized_ = true;

2303

framebufferManager_.Resized();

2304

}

2305

2306

void GLES_GPU::ClearShaderCache() {

2307

shaderManager_->ClearCache(true);

2308

}

2309

2310

void GLES_GPU::CleanupBeforeUI() {

2311

// Clear any enabled vertex arrays.

2312

shaderManager_->DirtyLastShader();

2313

glstate.arrayBuffer.bind(0);

2314

glstate.elementArrayBuffer.bind(0);

2315

}

2316

2317

std::vector<FramebufferInfo> GLES_GPU::GetFramebufferList() {

2318

return framebufferManager_.GetFramebufferList();

2319

}

2320

2321

void GLES_GPU::DoState(PointerWrap &p) {

2322

GPUCommon::DoState(p);

2323

2324

// TODO: Some of these things may not be necessary.

2325

// None of these are necessary when saving.

2326

// In Freeze-Frame mode, we don't want to do any of this.

2327

if (p.mode == p.MODE_READ && !PSP_CoreParameter().frozen) {

2328

textureCache_.Clear(true);

2329

depalShaderCache_.Clear();

2330

transformDraw_.ClearTrackedVertexArrays();

2331

2332

gstate_c.textureChanged = TEXCHANGE_UPDATED;

2333

framebufferManager_.DestroyAllFBOs();

2334

shaderManager_->ClearCache(true);

2335

}

2336

}

2337

2338

bool GLES_GPU::GetCurrentFramebuffer(GPUDebugBuffer &buffer) {

2339

u32 fb_address = gstate.getFrameBufRawAddress();

2340

int fb_stride = gstate.FrameBufStride();

2341

GEBufferFormat format = gstate.FrameBufFormat();

2342

return framebufferManager_.GetFramebuffer(fb_address, fb_stride, format, buffer);

2343

}

2344

2345

bool GLES_GPU::GetCurrentDepthbuffer(GPUDebugBuffer &buffer) {

2346

u32 fb_address = gstate.getFrameBufRawAddress();

2347

int fb_stride = gstate.FrameBufStride();

2348

2349

u32 z_address = gstate.getDepthBufRawAddress();

2350

int z_stride = gstate.DepthBufStride();

2351

2352

return framebufferManager_.GetDepthbuffer(fb_address, fb_stride, z_address, z_stride, buffer);

2353

}

2354

2355

bool GLES_GPU::GetCurrentStencilbuffer(GPUDebugBuffer &buffer) {

2356

u32 fb_address = gstate.getFrameBufRawAddress();

2357

int fb_stride = gstate.FrameBufStride();

2358

2359

return framebufferManager_.GetStencilbuffer(fb_address, fb_stride, buffer);

2360

}

2361

2362

bool GLES_GPU::GetCurrentTexture(GPUDebugBuffer &buffer, int level) {

2363

if (!gstate.isTextureMapEnabled()) {

2364

return false;

2365

}

2366

2367

#ifndef USING_GLES2

2368

GPUgstate saved;

2369

if (level != 0) {

2370

saved = gstate;

2371

2372

// The way we set textures is a bit complex. Let's just override level 0.

2373

gstate.texsize[0] = gstate.texsize[level];

2374

gstate.texaddr[0] = gstate.texaddr[level];

2375

gstate.texbufwidth[0] = gstate.texbufwidth[level];

2376

}

2377

2378

textureCache_.SetTexture(true);

2379

int w = gstate.getTextureWidth(level);

2380

int h = gstate.getTextureHeight(level);

2381

glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);

2382

glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &h);

2383

2384

if (level != 0) {

2385

gstate = saved;

2386

}

2387

2388

buffer.Allocate(w, h, GE_FORMAT_8888, gstate_c.flipTexture);

2389

glPixelStorei(GL_PACK_ALIGNMENT, 4);

2390

glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer.GetData());

2391

2392

return true;

2393

#else

2394

return false;

2395

#endif

2396

}

2397

2398

bool GLES_GPU::GetDisplayFramebuffer(GPUDebugBuffer &buffer) {

2399

return FramebufferManager::GetDisplayFramebuffer(buffer);

2400

}

2401

2402

bool GLES_GPU::GetCurrentSimpleVertices(int count, std::vector<GPUDebugVertex> &vertices, std::vector<u16> &indices) {

2403

return transformDraw_.GetCurrentSimpleVertices(count, vertices, indices);

2404

}

2405

2406

bool GLES_GPU::DescribeCodePtr(const u8 *ptr, std::string &name) {

2407

if (transformDraw_.IsCodePtrVertexDecoder(ptr)) {

2408

name = "VertexDecoderJit";

2409

return true;

2410

}

2411

return false;

2412

}