void ConfigureFOV() { static const double default_ratio = 4.0 / 3.0; const uint32_t width = HorizontalResolution; const uint32_t height = VerticalResolution; WriteJump(SetupScreen, SetupScreenFix); // Taking advantage of a nullsub call. WriteCall((void*)0x00513A88, DisplayVideoFrame_FixAspectRatio); // 4:3 and "tallscreen" (5:4, portrait, etc) // We don't need to do anything since these resolutions work fine with the default code. if ((height * default_ratio) == width || (height * default_ratio) > width) return; fov_rads = 0.96712852; // 55.412382 degrees fov_bams = NJM_RAD_ANG(fov_rads); // Function hooks WriteJump(njSetPerspective, njSetPerspective_hook); WriteJump(njSetScreenDist, njSetScreenDist_hook); // Code patches WriteJump((void*)0x0079124A, SetFOV); WriteData((float**)0x00781525, &dummy); // Dirty hack to disable a write to ClippingRelated and keep the floating point stack balanced. WriteData((Angle**)0x0040872B, &last_bams); // Fixes a case of direct access to HorizontalFOV_BAMS WriteData((Angle**)0x00402F01, &last_bams); // Changes return value of GetHorizontalFOV_BAMS njSetPerspective_hook(bams_default); // Stops the Pause Menu from using horizontal stretch in place of vertical stretch in coordinate calculation // Main Pause Menu WriteData((float**)0x00457F69, &VerticalStretch); // Elipse/Oval WriteData((float**)0x004584EE, &VerticalStretch); // Blue Transparent Box WriteData((float**)0x0045802F, &VerticalStretch); // Pause Menu Options // Camera options WriteData((float**)0x00458D5C, &VerticalStretch); // Blue Transparent Box WriteData((float**)0x00458DF4, &VerticalStretch); // Auto Cam WriteData((float**)0x00458E3A, &VerticalStretch); // Free Cam // Controls WriteData((float**)0x0045905A, &VerticalStretch); // Blue Transparent Box WriteData((float**)0x004590BB, &VerticalStretch); // Each Control Element WriteData((float**)0x00459133, &VerticalStretch); // Default Button }
void VertexLoader::CompileVertexTranslator() { m_VertexSize = 0; const TVtxAttr &vtx_attr = m_VtxAttr; // Reset pipeline m_numPipelineStages = 0; // Colors const u64 col[2] = { m_VtxDesc.Color0, m_VtxDesc.Color1 }; // TextureCoord const u64 tc[8] = { m_VtxDesc.Tex0Coord, m_VtxDesc.Tex1Coord, m_VtxDesc.Tex2Coord, m_VtxDesc.Tex3Coord, m_VtxDesc.Tex4Coord, m_VtxDesc.Tex5Coord, m_VtxDesc.Tex6Coord, m_VtxDesc.Tex7Coord }; u32 components = 0; // Position in pc vertex format. int nat_offset = 0; // Position Matrix Index if (m_VtxDesc.PosMatIdx) { WriteCall(PosMtx_ReadDirect_UByte); components |= VB_HAS_POSMTXIDX; m_native_vtx_decl.posmtx.components = 4; m_native_vtx_decl.posmtx.enable = true; m_native_vtx_decl.posmtx.offset = nat_offset; m_native_vtx_decl.posmtx.type = VAR_UNSIGNED_BYTE; m_native_vtx_decl.posmtx.integer = true; nat_offset += 4; m_VertexSize += 1; } if (m_VtxDesc.Tex0MatIdx) { m_VertexSize += 1; components |= VB_HAS_TEXMTXIDX0; WriteCall(TexMtx_ReadDirect_UByte); } if (m_VtxDesc.Tex1MatIdx) { m_VertexSize += 1; components |= VB_HAS_TEXMTXIDX1; WriteCall(TexMtx_ReadDirect_UByte); } if (m_VtxDesc.Tex2MatIdx) { m_VertexSize += 1; components |= VB_HAS_TEXMTXIDX2; WriteCall(TexMtx_ReadDirect_UByte); } if (m_VtxDesc.Tex3MatIdx) { m_VertexSize += 1; components |= VB_HAS_TEXMTXIDX3; WriteCall(TexMtx_ReadDirect_UByte); } if (m_VtxDesc.Tex4MatIdx) { m_VertexSize += 1; components |= VB_HAS_TEXMTXIDX4; WriteCall(TexMtx_ReadDirect_UByte); } if (m_VtxDesc.Tex5MatIdx) { m_VertexSize += 1; components |= VB_HAS_TEXMTXIDX5; WriteCall(TexMtx_ReadDirect_UByte); } if (m_VtxDesc.Tex6MatIdx) { m_VertexSize += 1; components |= VB_HAS_TEXMTXIDX6; WriteCall(TexMtx_ReadDirect_UByte); } if (m_VtxDesc.Tex7MatIdx) { m_VertexSize += 1; components |= VB_HAS_TEXMTXIDX7; WriteCall(TexMtx_ReadDirect_UByte); } // Write vertex position loader WriteCall(VertexLoader_Position::GetFunction(m_VtxDesc.Position, m_VtxAttr.PosFormat, m_VtxAttr.PosElements)); m_VertexSize += VertexLoader_Position::GetSize(m_VtxDesc.Position, m_VtxAttr.PosFormat, m_VtxAttr.PosElements); int pos_elements = m_VtxAttr.PosElements + 2; m_native_vtx_decl.position.components = pos_elements; m_native_vtx_decl.position.enable = true; m_native_vtx_decl.position.offset = nat_offset; m_native_vtx_decl.position.type = VAR_FLOAT; m_native_vtx_decl.position.integer = false; nat_offset += pos_elements * sizeof(float); // Normals if (m_VtxDesc.Normal != NOT_PRESENT) { m_VertexSize += VertexLoader_Normal::GetSize(m_VtxDesc.Normal, m_VtxAttr.NormalFormat, m_VtxAttr.NormalElements, m_VtxAttr.NormalIndex3); TPipelineFunction pFunc = VertexLoader_Normal::GetFunction(m_VtxDesc.Normal, m_VtxAttr.NormalFormat, m_VtxAttr.NormalElements, m_VtxAttr.NormalIndex3); if (pFunc == nullptr) { PanicAlert("VertexLoader_Normal::GetFunction(%i %i %i %i) returned zero!", (u32)m_VtxDesc.Normal, m_VtxAttr.NormalFormat, m_VtxAttr.NormalElements, m_VtxAttr.NormalIndex3); } WriteCall(pFunc); for (int i = 0; i < (vtx_attr.NormalElements ? 3 : 1); i++) { m_native_vtx_decl.normals[i].components = 3; m_native_vtx_decl.normals[i].enable = true; m_native_vtx_decl.normals[i].offset = nat_offset; m_native_vtx_decl.normals[i].type = VAR_FLOAT; m_native_vtx_decl.normals[i].integer = false; nat_offset += 12; } components |= VB_HAS_NRM0; if (m_VtxAttr.NormalElements == 1) components |= VB_HAS_NRM1 | VB_HAS_NRM2; } for (int i = 0; i < 2; i++) { m_native_vtx_decl.colors[i].components = 4; m_native_vtx_decl.colors[i].type = VAR_UNSIGNED_BYTE; m_native_vtx_decl.colors[i].integer = false; switch (col[i]) { case NOT_PRESENT: break; case DIRECT: switch (m_VtxAttr.color[i].Comp) { case FORMAT_16B_565: m_VertexSize += 2; WriteCall(Color_ReadDirect_16b_565); break; case FORMAT_24B_888: m_VertexSize += 3; WriteCall(Color_ReadDirect_24b_888); break; case FORMAT_32B_888x: m_VertexSize += 4; WriteCall(Color_ReadDirect_32b_888x); break; case FORMAT_16B_4444: m_VertexSize += 2; WriteCall(Color_ReadDirect_16b_4444); break; case FORMAT_24B_6666: m_VertexSize += 3; WriteCall(Color_ReadDirect_24b_6666); break; case FORMAT_32B_8888: m_VertexSize += 4; WriteCall(Color_ReadDirect_32b_8888); break; default: _assert_(0); break; } break; case INDEX8: m_VertexSize += 1; switch (m_VtxAttr.color[i].Comp) { case FORMAT_16B_565: WriteCall(Color_ReadIndex8_16b_565); break; case FORMAT_24B_888: WriteCall(Color_ReadIndex8_24b_888); break; case FORMAT_32B_888x: WriteCall(Color_ReadIndex8_32b_888x); break; case FORMAT_16B_4444: WriteCall(Color_ReadIndex8_16b_4444); break; case FORMAT_24B_6666: WriteCall(Color_ReadIndex8_24b_6666); break; case FORMAT_32B_8888: WriteCall(Color_ReadIndex8_32b_8888); break; default: _assert_(0); break; } break; case INDEX16: m_VertexSize += 2; switch (m_VtxAttr.color[i].Comp) { case FORMAT_16B_565: WriteCall(Color_ReadIndex16_16b_565); break; case FORMAT_24B_888: WriteCall(Color_ReadIndex16_24b_888); break; case FORMAT_32B_888x: WriteCall(Color_ReadIndex16_32b_888x); break; case FORMAT_16B_4444: WriteCall(Color_ReadIndex16_16b_4444); break; case FORMAT_24B_6666: WriteCall(Color_ReadIndex16_24b_6666); break; case FORMAT_32B_8888: WriteCall(Color_ReadIndex16_32b_8888); break; default: _assert_(0); break; } break; } // Common for the three bottom cases if (col[i] != NOT_PRESENT) { components |= VB_HAS_COL0 << i; m_native_vtx_decl.colors[i].offset = nat_offset; m_native_vtx_decl.colors[i].enable = true; nat_offset += 4; } } // Texture matrix indices (remove if corresponding texture coordinate isn't enabled) for (int i = 0; i < 8; i++) { m_native_vtx_decl.texcoords[i].offset = nat_offset; m_native_vtx_decl.texcoords[i].type = VAR_FLOAT; m_native_vtx_decl.texcoords[i].integer = false; const int format = m_VtxAttr.texCoord[i].Format; const int elements = m_VtxAttr.texCoord[i].Elements; if (tc[i] != NOT_PRESENT) { _assert_msg_(VIDEO, DIRECT <= tc[i] && tc[i] <= INDEX16, "Invalid texture coordinates!\n(tc[i] = %d)", (u32)tc[i]); _assert_msg_(VIDEO, FORMAT_UBYTE <= format && format <= FORMAT_FLOAT, "Invalid texture coordinates format!\n(format = %d)", format); _assert_msg_(VIDEO, 0 <= elements && elements <= 1, "Invalid number of texture coordinates elements!\n(elements = %d)", elements); components |= VB_HAS_UV0 << i; WriteCall(VertexLoader_TextCoord::GetFunction(tc[i], format, elements)); m_VertexSize += VertexLoader_TextCoord::GetSize(tc[i], format, elements); } if (components & (VB_HAS_TEXMTXIDX0 << i)) { m_native_vtx_decl.texcoords[i].enable = true; if (tc[i] != NOT_PRESENT) { // if texmtx is included, texcoord will always be 3 floats, z will be the texmtx index m_native_vtx_decl.texcoords[i].components = 3; nat_offset += 12; WriteCall(m_VtxAttr.texCoord[i].Elements ? TexMtx_Write_Float : TexMtx_Write_Float2); } else { m_native_vtx_decl.texcoords[i].components = 3; nat_offset += 12; WriteCall(TexMtx_Write_Float3); } } else { if (tc[i] != NOT_PRESENT) { m_native_vtx_decl.texcoords[i].enable = true; m_native_vtx_decl.texcoords[i].components = vtx_attr.texCoord[i].Elements ? 2 : 1; nat_offset += 4 * (vtx_attr.texCoord[i].Elements ? 2 : 1); } } if (tc[i] == NOT_PRESENT) { // if there's more tex coords later, have to write a dummy call int j = i + 1; for (; j < 8; ++j) { if (tc[j] != NOT_PRESENT) { WriteCall(VertexLoader_TextCoord::GetDummyFunction()); // important to get indices right! break; } } // tricky! if (j == 8 && !((components & VB_HAS_TEXMTXIDXALL) & (VB_HAS_TEXMTXIDXALL << (i + 1)))) { // no more tex coords and tex matrices, so exit loop break; } } } // indexed position formats may skip a the vertex if (m_VtxDesc.Position & 2) { WriteCall(SkipVertex); } m_native_components = components; m_native_vtx_decl.stride = nat_offset; }
int main(int argc, char* argv[]) { struct dirent *pDirent; DIR *pDir; char *dirName; char inputFilename[128]; FILE *inP, *outP; // input and output file Command *vmCommands; // all VM Commands int count=0; // count of instructions int i; // loop index Command *currentCommand = NULL; if(argc != 2) { printf("Usage : VMTranslator <directory>"); return -1; } dirName = argv[1]; // open directory pDir = opendir (dirName); if(pDir == NULL) { printf("Can not open directory '%s'\n", dirName); } vmCommands = (Command*)malloc(sizeof(Command) * MAX_COMMAND_NUM); // create the output file outP = Open(dirName, basename(dirName)); if(!outP) { printf("File open failed!\n"); goto failed; } WriteInit(outP); while ((pDirent = readdir(pDir)) != NULL) { // only open the *.vm files in directory if( CheckFileExtension(pDirent->d_name) ) { sprintf(inputFilename, "%s/%s", dirName, pDirent->d_name); // open the input file inP = fopen(inputFilename, "r"); if(!inP) { printf("File '%s' open failed!\n", inputFilename); continue; } SetFileName(basename(inputFilename)); memset(vmCommands, 0, MAX_COMMAND_NUM); count = Parse(inP, &vmCommands); for( i = 0; i < count; i++) { currentCommand = vmCommands + i; switch(currentCommand->commandType){ case C_ARITHMETIC: WriteArithmetic(outP, currentCommand->arg1); break; case C_LABEL: WriteLabel(outP, currentCommand->arg1); break; case C_GOTO: WriteGoTo(outP, currentCommand->arg1); break; case C_IF: WriteIf(outP, currentCommand->arg1); break; case C_PUSH: case C_POP: WritePushPop(outP, currentCommand->commandType, currentCommand->arg1, currentCommand->arg2); break; case C_FUNCTION: WriteFunction(outP, currentCommand->arg1, currentCommand->arg2); break; case C_CALL: WriteCall(outP, currentCommand->arg1, currentCommand->arg2); break; case C_RETURN: WriteReturn(outP); break; default: break; } } fclose(inP); } } closedir (pDir); Close(outP); failed: free(vmCommands); return 0; }