From 88578cc525f6d05d0aa60c578cb0bf683261f4e7 Mon Sep 17 00:00:00 2001 From: raven02 Date: Sat, 22 Dec 2012 00:49:53 +0800 Subject: [PATCH 1/7] Quick add checkitem for option fast memory --- Windows/WndMainWindow.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Windows/WndMainWindow.cpp b/Windows/WndMainWindow.cpp index a80e17345c..246c048244 100644 --- a/Windows/WndMainWindow.cpp +++ b/Windows/WndMainWindow.cpp @@ -479,6 +479,10 @@ namespace MainWindow g_Config.bDisplayFramebuffer = !g_Config.bDisplayFramebuffer; UpdateMenus(); break; + case ID_OPTIONS_FASTMEMORY: + g_Config.bFastMemory = !g_Config.bFastMemory; + UpdateMenus(); + break; ////////////////////////////////////////////////////////////////////////// From 33debd755babfcaf44ae24e3d568f78ac2f17653 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Fri, 21 Dec 2012 11:58:32 -0800 Subject: [PATCH 2/7] Correct sceKernelSetSysClockAlarm timing. Also make refer status work for the tests to be usable. --- Core/CoreTiming.h | 4 +++ Core/HLE/sceKernelAlarm.cpp | 58 +++++++++++++++++++++++++------------ 2 files changed, 44 insertions(+), 18 deletions(-) diff --git a/Core/CoreTiming.h b/Core/CoreTiming.h index f771d7e484..f8883d9b35 100644 --- a/Core/CoreTiming.h +++ b/Core/CoreTiming.h @@ -58,6 +58,10 @@ inline int usToCycles(int us) { return (int)(CPU_HZ / 1000000 * us); } +inline u64 usToCycles(u64 us) { + return (u64)(CPU_HZ / 1000000ULL * us); +} + inline u64 cyclesToUs(u64 cycles) { return cycles / (CPU_HZ / 1000000); } diff --git a/Core/HLE/sceKernelAlarm.cpp b/Core/HLE/sceKernelAlarm.cpp index ee6657e670..4110ef2499 100644 --- a/Core/HLE/sceKernelAlarm.cpp +++ b/Core/HLE/sceKernelAlarm.cpp @@ -21,6 +21,8 @@ #include "HLE.h" #include "../../Core/CoreTiming.h" +const int NATIVEALARM_SIZE = 20; + struct NativeAlarm { SceSize size; @@ -38,7 +40,7 @@ struct Alarm : public KernelObject NativeAlarm alm; }; -void __KernelScheduleAlarm(Alarm *alarm, int ticks); +void __KernelScheduleAlarm(Alarm *alarm, u64 ticks); class AlarmIntrHandler : public SubIntrHandler { @@ -60,9 +62,8 @@ public: virtual void handleResult(int result) { // A non-zero result means to reschedule. - // TODO: Do sysclock alarms return a different value unit? if (result > 0) - __KernelScheduleAlarm(alarm, usToCycles(result)); + __KernelScheduleAlarm(alarm, (u64) usToCycles(result)); else if (result < 0) WARN_LOG(HLE, "Alarm requested reschedule for negative value %u, ignoring", (unsigned) result); } @@ -92,9 +93,9 @@ void __KernelTriggerAlarm(u64 userdata, int cyclesLate) __TriggerInterrupt(PSP_INTR_IMMEDIATE, PSP_SYSTIMER0_INTR, uid); } -void __KernelScheduleAlarm(Alarm *alarm, int ticks) +void __KernelScheduleAlarm(Alarm *alarm, u64 ticks) { - alarm->alm.schedule = CoreTiming::GetTicks() + ticks; + alarm->alm.schedule = (CoreTiming::GetTicks() + ticks) / (u64) CoreTiming::GetClockFrequencyMHz(); CoreTiming::ScheduleEvent((int) ticks, alarmTimer, alarm->GetUID()); } @@ -106,8 +107,7 @@ SceUID __KernelSetAlarm(u64 ticks, u32 handlerPtr, u32 commonPtr) Alarm *alarm = new Alarm; SceUID uid = kernelObjects.Create(alarm); - alarm->alm.size = sizeof(NativeAlarm); - alarm->alm.schedule = CoreTiming::GetTicks() + ticks; + alarm->alm.size = NATIVEALARM_SIZE; alarm->alm.handlerPtr = handlerPtr; alarm->alm.commonPtr = commonPtr; @@ -115,29 +115,28 @@ SceUID __KernelSetAlarm(u64 ticks, u32 handlerPtr, u32 commonPtr) if (error != 0) return error; - __KernelScheduleAlarm(alarm, (int) ticks); + __KernelScheduleAlarm(alarm, ticks); return uid; } SceUID sceKernelSetAlarm(SceUInt micro, u32 handlerPtr, u32 commonPtr) { DEBUG_LOG(HLE, "sceKernelSetAlarm(%d, %08x, %08x)", micro, handlerPtr, commonPtr); - return __KernelSetAlarm(usToCycles((int) micro), handlerPtr, commonPtr); + return __KernelSetAlarm(usToCycles((u64) micro), handlerPtr, commonPtr); } -SceUID sceKernelSetSysClockAlarm(u32 ticksPtr, u32 handlerPtr, u32 commonPtr) +SceUID sceKernelSetSysClockAlarm(u32 microPtr, u32 handlerPtr, u32 commonPtr) { - u64 ticks; + u64 micro; - if (Memory::IsValidAddress(ticksPtr)) - ticks = Memory::Read_U64(ticksPtr); + if (Memory::IsValidAddress(microPtr)) + micro = Memory::Read_U64(microPtr); // TODO: What to do when invalid? else return -1; - ERROR_LOG(HLE, "UNTESTED sceKernelSetSysClockAlarm(%lld, %08x, %08x)", ticks, handlerPtr, commonPtr); - // TODO: Is this precise or is this relative? - return __KernelSetAlarm(ticks, handlerPtr, commonPtr); + DEBUG_LOG(HLE, "sceKernelSetSysClockAlarm(%lld, %08x, %08x)", micro, handlerPtr, commonPtr); + return __KernelSetAlarm(usToCycles(micro), handlerPtr, commonPtr); } int sceKernelCancelAlarm(SceUID uid) @@ -152,6 +151,29 @@ int sceKernelCancelAlarm(SceUID uid) int sceKernelReferAlarmStatus(SceUID uid, u32 infoPtr) { - ERROR_LOG(HLE, "UNIMPL sceKernelReferAlarmStatus(%08x, %08x)", uid, infoPtr); - return -1; + u32 error; + Alarm *alarm = kernelObjects.Get(uid, error); + if (!alarm) + { + ERROR_LOG(HLE, "sceKernelReferAlarmStatus(%08x, %08x): invalid alarm", uid, infoPtr); + return error; + } + + if (!Memory::IsValidAddress(infoPtr)) + return -1; + + u32 size = Memory::Read_U32(infoPtr); + + // Alarms actually respect size and write (kinda) what it can hold. + // Intentionally 1 not 4. + if (size >= 1) + Memory::Write_U32(alarm->alm.size, infoPtr); + if (size >= 12) + Memory::Write_U64(alarm->alm.schedule, infoPtr + 4); + if (size >= 16) + Memory::Write_U32(alarm->alm.handlerPtr, infoPtr + 12); + if (size >= 20) + Memory::Write_U32(alarm->alm.commonPtr, infoPtr + 16); + + return 0; } \ No newline at end of file From 522b16bb89ce4fbed21a07cfea04d539fe1a99fa Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Fri, 21 Dec 2012 12:04:02 -0800 Subject: [PATCH 3/7] Fix error handling for setting alarms. --- Core/HLE/sceKernelAlarm.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Core/HLE/sceKernelAlarm.cpp b/Core/HLE/sceKernelAlarm.cpp index 4110ef2499..a51feaf8df 100644 --- a/Core/HLE/sceKernelAlarm.cpp +++ b/Core/HLE/sceKernelAlarm.cpp @@ -104,6 +104,9 @@ SceUID __KernelSetAlarm(u64 ticks, u32 handlerPtr, u32 commonPtr) if (!alarmInitComplete) __KernelAlarmInit(); + if (!Memory::IsValidAddress(handlerPtr)) + return SCE_KERNEL_ERROR_ILLEGAL_ADDR; + Alarm *alarm = new Alarm; SceUID uid = kernelObjects.Create(alarm); @@ -131,7 +134,6 @@ SceUID sceKernelSetSysClockAlarm(u32 microPtr, u32 handlerPtr, u32 commonPtr) if (Memory::IsValidAddress(microPtr)) micro = Memory::Read_U64(microPtr); - // TODO: What to do when invalid? else return -1; From dbec955a99fea3286bfb1f455e201324e7879f7d Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Fri, 21 Dec 2012 12:28:28 -0800 Subject: [PATCH 4/7] Properly delete alarms after they run. Also fix refer, based on tests. --- Core/HLE/sceKernelAlarm.cpp | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/Core/HLE/sceKernelAlarm.cpp b/Core/HLE/sceKernelAlarm.cpp index a51feaf8df..cfd5b48155 100644 --- a/Core/HLE/sceKernelAlarm.cpp +++ b/Core/HLE/sceKernelAlarm.cpp @@ -64,8 +64,15 @@ public: // A non-zero result means to reschedule. if (result > 0) __KernelScheduleAlarm(alarm, (u64) usToCycles(result)); - else if (result < 0) - WARN_LOG(HLE, "Alarm requested reschedule for negative value %u, ignoring", (unsigned) result); + else + { + if (result < 0) + WARN_LOG(HLE, "Alarm requested reschedule for negative value %u, ignoring", (unsigned) result); + + // Delete the alarm if it's not rescheduled. + __ReleaseSubInterruptHandler(PSP_SYSTIMER0_INTR, alarm->GetUID()); + kernelObjects.Destroy(alarm->GetUID()); + } } Alarm *alarm; @@ -167,14 +174,13 @@ int sceKernelReferAlarmStatus(SceUID uid, u32 infoPtr) u32 size = Memory::Read_U32(infoPtr); // Alarms actually respect size and write (kinda) what it can hold. - // Intentionally 1 not 4. - if (size >= 1) + if (size > 0) Memory::Write_U32(alarm->alm.size, infoPtr); - if (size >= 12) + if (size > 4) Memory::Write_U64(alarm->alm.schedule, infoPtr + 4); - if (size >= 16) + if (size > 12) Memory::Write_U32(alarm->alm.handlerPtr, infoPtr + 12); - if (size >= 20) + if (size > 16) Memory::Write_U32(alarm->alm.commonPtr, infoPtr + 16); return 0; From 6adb29030f54c21797509ee8d286ea6534240d77 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Fri, 21 Dec 2012 12:38:12 -0800 Subject: [PATCH 5/7] Update tests. --- Core/HLE/sceKernelAlarm.cpp | 2 ++ pspautotests | 2 +- test.py | 3 +++ 3 files changed, 6 insertions(+), 1 deletion(-) diff --git a/Core/HLE/sceKernelAlarm.cpp b/Core/HLE/sceKernelAlarm.cpp index cfd5b48155..984c558e04 100644 --- a/Core/HLE/sceKernelAlarm.cpp +++ b/Core/HLE/sceKernelAlarm.cpp @@ -168,6 +168,8 @@ int sceKernelReferAlarmStatus(SceUID uid, u32 infoPtr) return error; } + DEBUG_LOG(HLE, "sceKernelReferAlarmStatus(%08x, %08x)", uid, infoPtr); + if (!Memory::IsValidAddress(infoPtr)) return -1; diff --git a/pspautotests b/pspautotests index 6bd9d261e6..30f1f0698e 160000 --- a/pspautotests +++ b/pspautotests @@ -1 +1 @@ -Subproject commit 6bd9d261e6014d371b917e50d2e18d5fc986a8c3 +Subproject commit 30f1f0698e2ed2f45f4dd1bd199c81cdc379561e diff --git a/test.py b/test.py index 14f3746193..f352ccf50f 100755 --- a/test.py +++ b/test.py @@ -59,6 +59,9 @@ tests_good = [ "string/string", "gpu/callbacks/ge_callbacks", "threads/alarm/alarm", + "threads/alarm/cancel/cancel", + "threads/alarm/refer/refer", + "threads/alarm/set/set", "threads/events/events", "threads/events/cancel/cancel", "threads/events/clear/clear", From ea07c14c4c390f2744edc475f88c9a26892167c2 Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Fri, 21 Dec 2012 17:50:22 +0100 Subject: [PATCH 6/7] Add IndexGenerator.cpp/h which will later be used to combine small draw calls into large indexed draw calls, for better performance. --- CMakeLists.txt | 2 + GPU/CMakeLists.txt | 1 + GPU/GLES/IndexGenerator.cpp | 232 +++++++++++++++++++++++++++++ GPU/GLES/IndexGenerator.h | 57 +++++++ GPU/GLES/VertexShaderGenerator.cpp | 5 - GPU/GPU.vcxproj | 2 + GPU/GPU.vcxproj.filters | 6 + android/jni/Android.mk | 1 + 8 files changed, 301 insertions(+), 5 deletions(-) create mode 100644 GPU/GLES/IndexGenerator.cpp create mode 100644 GPU/GLES/IndexGenerator.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 858bc710c4..adaf9dc6fb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -786,6 +786,8 @@ add_library(GPU OBJECT GPU/GLES/FragmentShaderGenerator.h GPU/GLES/Framebuffer.cpp GPU/GLES/Framebuffer.h + GPU/GLES/IndexGenerator.cpp + GPU/GLES/IndexGenerator.h GPU/GLES/ShaderManager.cpp GPU/GLES/ShaderManager.h GPU/GLES/StateMapping.cpp diff --git a/GPU/CMakeLists.txt b/GPU/CMakeLists.txt index 803200ae6d..ad56972231 100644 --- a/GPU/CMakeLists.txt +++ b/GPU/CMakeLists.txt @@ -4,6 +4,7 @@ set(SRCS GLES/DisplayListInterpreter.cpp GLES/FragmentShaderGenerator.cpp GLES/Framebuffer.cpp + GLES/IndexGenerator.cpp GLES/ShaderManager.cpp GLES/StateMapping.cpp GLES/TextureCache.cpp diff --git a/GPU/GLES/IndexGenerator.cpp b/GPU/GLES/IndexGenerator.cpp new file mode 100644 index 0000000000..7a786488cf --- /dev/null +++ b/GPU/GLES/IndexGenerator.cpp @@ -0,0 +1,232 @@ +// Copyright (c) 2012- PPSSPP Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0 or later versions. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#include "IndexGenerator.h" + +// Points don't need indexing... +const u8 indexedPrimitiveType[7] = { + GE_PRIM_POINTS, + GE_PRIM_LINES, + GE_PRIM_LINES, + GE_PRIM_TRIANGLES, + GE_PRIM_TRIANGLES, + GE_PRIM_TRIANGLES, + GE_PRIM_TRIANGLES, +}; + +void IndexGenerator::Reset() { + prim_ = -1; + inds_ = 0; +} + +bool IndexGenerator::PrimCompatible(int prim) { + if (prim_ == -1) + return true; + return indexedPrimitiveType[prim] == indexedPrimitiveType[prim_]; +} + +void IndexGenerator::Start(u16 *inds, int baseIndex, int prim) +{ + this->inds_ = inds; + index_ = baseIndex; +} + +void IndexGenerator::AddList(int numVerts) +{ + //if we have no vertices return + int numTris = numVerts / 3; + for (int i = 0; i < numTris; i++) + { + *inds_++ = index_ + i*3; + *inds_++ = index_ + i*3 + 1; + *inds_++ = index_ + i*3 + 2; + } + + // ignore overflow verts + index_ += numVerts; +} + +void IndexGenerator::AddStrip(int numVerts) +{ + bool wind = false; + int numTris = numVerts - 2; + for (int i = 0; i < numTris; i++) + { + *inds_++ = index_ + i; + *inds_++ = index_ + i+(wind?2:1); + *inds_++ = index_ + i+(wind?1:2); + wind = !wind; + } + index_ += numVerts; +} + +void IndexGenerator::AddFan(int numVerts) +{ + int numTris = numVerts - 2; + for (int i = 0; i < numTris; i++) + { + *inds_++ = index_; + *inds_++ = index_ + i + 1; + *inds_++ = index_ + i + 2; + } + index_ += numVerts; +} + +void IndexGenerator::TranslateList(int numVerts, const u8 *inds, int offset) +{ + int numTris = numVerts / 3; + for (int i = 0; i < numTris; i++) + { + *inds_++ = index_ + offset + inds[i*3]; + *inds_++ = index_ + offset + inds[i*3 + 1]; + *inds_++ = index_ + offset + inds[i*3 + 2]; + } + index_ += numVerts; +} + +void IndexGenerator::TranslateStrip(int numVerts, const u8 *inds, int offset) +{ + bool wind = false; + int numTris = numVerts - 2; + for (int i = 0; i < numTris; i++) + { + *inds_++ = index_ + offset + inds[i]; + *inds_++ = index_ + offset + inds[i + (wind?2:1)]; + *inds_++ = index_ + offset + inds[i + (wind?1:2)]; + wind = !wind; + } + index_ += numVerts; +} + +void IndexGenerator::TranslateFan(int numVerts, const u8 *inds, int offset) +{ + if (numVerts <= 0) return; + int numTris = numVerts - 2; + for (int i = 0; i < numTris; i++) + { + *inds_++ = index_ + offset + inds[i]; + *inds_++ = index_ + offset + inds[i + 1]; + *inds_++ = index_ + offset + inds[i + 2]; + } + index_ += numVerts; +} + +void IndexGenerator::TranslateList(int numVerts, const u16 *inds, int offset) +{ + int numTris = numVerts / 3; + for (int i = 0; i < numTris; i++) + { + *inds_++ = index_ + offset + inds[i*3]; + *inds_++ = index_ + offset + inds[i*3 + 1]; + *inds_++ = index_ + offset + inds[i*3 + 2]; + } + index_ += numVerts; +} + +void IndexGenerator::TranslateStrip(int numVerts, const u16 *inds, int offset) +{ + bool wind = false; + int numTris = numVerts - 2; + for (int i = 0; i < numTris; i++) + { + *inds_++ = index_ + offset + inds[i]; + *inds_++ = index_ + offset + inds[i + (wind?2:1)]; + *inds_++ = index_ + offset + inds[i + (wind?1:2)]; + wind = !wind; + } + index_ += numVerts; +} + +void IndexGenerator::TranslateFan(int numVerts, const u16 *inds, int offset) +{ + if (numVerts <= 0) return; + int numTris = numVerts - 2; + for (int i = 0; i < numTris; i++) + { + *inds_++ = index_ + offset + inds[i]; + *inds_++ = index_ + offset + inds[i + 1]; + *inds_++ = index_ + offset + inds[i + 2]; + } + index_ += numVerts; +} + +//Lines +void IndexGenerator::AddLineList(int numVerts) +{ + int numLines = numVerts / 2; + for (int i = 0; i < numLines; i++) + { + *inds_++ = index_ + i*2; + *inds_++ = index_ + i*2+1; + } + index_ += numVerts; +} + +void IndexGenerator::AddLineStrip(int numVerts) +{ + int numLines = numVerts - 1; + for (int i = 0; i < numLines; i++) + { + *inds_++ = index_ + i; + *inds_++ = index_ + i + 1; + } + index_ += numVerts; +} + +void IndexGenerator::TranslateLineList(int numVerts, const u8 *inds, int offset) +{ + int numLines = numVerts / 2; + for (int i = 0; i < numLines; i++) + { + *inds_++ = index_ + i*2; + *inds_++ = index_ + i*2+1; + } + index_ += numVerts; +} + +void IndexGenerator::TranslateLineStrip(int numVerts, const u8 *inds, int offset) +{ + int numLines = numVerts - 1; + for (int i = 0; i < numLines; i++) + { + *inds_++ = index_ + i; + *inds_++ = index_ + i + 1; + } + index_ += numVerts; +} + +void IndexGenerator::TranslateLineList(int numVerts, const u16 *inds, int offset) +{ + int numLines = numVerts / 2; + for (int i = 0; i < numLines; i++) + { + *inds_++ = index_ + i*2; + *inds_++ = index_ + i*2+1; + } + index_ += numVerts; +} + +void IndexGenerator::TranslateLineStrip(int numVerts, const u16 *inds, int offset) +{ + int numLines = numVerts - 1; + for (int i = 0; i < numLines; i++) + { + *inds_++ = index_ + i; + *inds_++ = index_ + i + 1; + } + index_ += numVerts; +} \ No newline at end of file diff --git a/GPU/GLES/IndexGenerator.h b/GPU/GLES/IndexGenerator.h new file mode 100644 index 0000000000..45d3a0bad3 --- /dev/null +++ b/GPU/GLES/IndexGenerator.h @@ -0,0 +1,57 @@ +// Copyright (c) 2012- PPSSPP Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0 or later versions. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + + +#pragma once + +#include "CommonTypes.h" +#include "../ge_constants.h" + +class IndexGenerator +{ +public: + void Reset(); + void Start(u16 *indexptr, int baseIndex, int prim); + bool PrimCompatible(int prim); + + // Triangles + void AddList(int numVerts); + void AddStrip(int numVerts); + void AddFan(int numVerts); + // Lines + void AddLineList(int numVerts); + void AddLineStrip(int numVerts); + + // Translates already indexed lists + void TranslateLineList(int numVerts, const u8 *inds, int offset); + void TranslateLineStrip(int numVerts, const u8 *inds, int offset); + void TranslateLineList(int numVerts, const u16 *inds, int offset); + void TranslateLineStrip(int numVerts, const u16 *inds, int offset); + + void TranslateList(int numVerts, const u8 *inds, int offset); + void TranslateStrip(int numVerts, const u8 *inds, int offset); + void TranslateFan(int numVerts, const u8 *inds, int offset); + void TranslateList(int numVerts, const u16 *inds, int offset); + void TranslateStrip(int numVerts, const u16 *inds, int offset); + void TranslateFan(int numVerts, const u16 *inds, int offset); + +private: + u16 *inds_; + int index_; + int prim_; +}; + diff --git a/GPU/GLES/VertexShaderGenerator.cpp b/GPU/GLES/VertexShaderGenerator.cpp index 395021ce56..953b5c684d 100644 --- a/GPU/GLES/VertexShaderGenerator.cpp +++ b/GPU/GLES/VertexShaderGenerator.cpp @@ -15,10 +15,6 @@ // Official git repository and contact information can be found at // https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. -// TODO: We should transition from doing the transform in software, as seen in TransformPipeline.cpp, -// into doing the transform in the vertex shader - except for Rectangles, there we really need to do -// the transforms ourselves. - #include #if defined(_WIN32) && defined(_DEBUG) #include @@ -42,7 +38,6 @@ static char buffer[16384]; #define WRITE p+=sprintf - bool CanUseHardwareTransform(int prim) { if (!g_Config.bHardwareTransform) diff --git a/GPU/GPU.vcxproj b/GPU/GPU.vcxproj index 7b36bc7078..9b3228b826 100644 --- a/GPU/GPU.vcxproj +++ b/GPU/GPU.vcxproj @@ -120,6 +120,7 @@ + @@ -135,6 +136,7 @@ + diff --git a/GPU/GPU.vcxproj.filters b/GPU/GPU.vcxproj.filters index aad3ad15c2..e5a783590f 100644 --- a/GPU/GPU.vcxproj.filters +++ b/GPU/GPU.vcxproj.filters @@ -57,6 +57,9 @@ GLES + + GLES + @@ -95,6 +98,9 @@ GLES + + GLES + diff --git a/android/jni/Android.mk b/android/jni/Android.mk index 13a44e02f1..84ddbce292 100644 --- a/android/jni/Android.mk +++ b/android/jni/Android.mk @@ -72,6 +72,7 @@ LOCAL_SRC_FILES := \ $(SRC)/GPU/GLES/Framebuffer.cpp \ $(SRC)/GPU/GLES/DisplayListInterpreter.cpp \ $(SRC)/GPU/GLES/TextureCache.cpp \ + $(SRC)/GPU/GLES/IndexGenerator.cpp \ $(SRC)/GPU/GLES/TransformPipeline.cpp \ $(SRC)/GPU/GLES/StateMapping.cpp \ $(SRC)/GPU/GLES/VertexDecoder.cpp \ From 61f7986d12b038866ac1b0ae7d751e08e3ba445e Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Fri, 21 Dec 2012 22:53:50 +0100 Subject: [PATCH 7/7] update submodules --- native | 2 +- pspautotests | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/native b/native index 0de5e114f3..ff60f2341b 160000 --- a/native +++ b/native @@ -1 +1 @@ -Subproject commit 0de5e114f337859a03d0763c30beaf6e03af03c4 +Subproject commit ff60f2341b31d3a8764641c9bee5b824c1090b2a diff --git a/pspautotests b/pspautotests index 30f1f0698e..54acddd544 160000 --- a/pspautotests +++ b/pspautotests @@ -1 +1 @@ -Subproject commit 30f1f0698e2ed2f45f4dd1bd199c81cdc379561e +Subproject commit 54acddd54469a88aadbaf0e69088aad504b5e1e4