Can now switch between them during gameplay.
Specify GPU_UNAI_NO_OLD=1 to prevent compiling this in to save memory or
whatever. No big endian support.
plugins/dfxvideo/gpulib_if.o: plugins/dfxvideo/prim.c plugins/dfxvideo/soft.c
OBJS += plugins/dfxvideo/gpulib_if.o
endif
-ifeq "$(BUILTIN_GPU)" "unai_old"
-OBJS += plugins/gpu_unai_old/gpulib_if.o
-ifeq "$(ARCH)" "arm"
-OBJS += plugins/gpu_unai_old/gpu_arm.o
-endif
-plugins/gpu_unai_old/gpulib_if.o: CFLAGS += -DREARMED -O3
-CC_LINK = $(CXX)
-endif
ifeq "$(BUILTIN_GPU)" "unai"
OBJS += plugins/gpu_unai/gpulib_if.o
ifeq "$(ARCH)" "arm"
OBJS += plugins/gpu_unai/gpu_arm.o
endif
-plugins/gpu_unai/gpulib_if.o: CFLAGS += -DREARMED -DUSE_GPULIB=1 -O3
+ifeq "$(THREAD_RENDERING)" "1"
+CFLAGS += -DTHREAD_RENDERING
+OBJS += plugins/gpulib/gpulib_thread_if.o
+endif
+ifneq "$(GPU_UNAI_NO_OLD)" "1"
+OBJS += plugins/gpu_unai/old/if.o
+else
+CFLAGS += -DGPU_UNAI_NO_OLD
+endif
+plugins/gpu_unai/gpulib_if.o: CFLAGS += -DREARMED -DUSE_GPULIB=1
+plugins/gpu_unai/gpulib_if.o \
+plugins/gpu_unai/old/if.o: CFLAGS += -O3
CC_LINK = $(CXX)
endif
platform_list="generic pandora maemo caanoo"
platform="generic"
-builtin_gpu_list="neon peops unai unai_old"
+builtin_gpu_list="neon peops unai"
dynarec_list="ari64 lightrec none"
builtin_gpu=""
sound_driver_list="oss alsa pulseaudio sdl"
sound_drivers=""
plugins="plugins/spunull/spunull.so \
-plugins/dfxvideo/gpu_peops.so plugins/gpu_unai_old/gpu_unai_old.so plugins/gpu_unai/gpu_unai.so"
+plugins/dfxvideo/gpu_peops.so plugins/gpu_unai/gpu_unai.so"
drc_cache_base="no"
have_armv5=""
have_armv6=""
builtin_gpu="neon"
elif [ "$have_armv7" != "yes" ]; then
# pre-ARMv7 hardware is usually not fast enough for peops
- builtin_gpu="unai_old"
+ builtin_gpu="unai"
else
builtin_gpu="peops"
fi
* pcsx_rearmed_gpu_unai_scale_hires */
pl_rearmed_cbs.gpu_unai.pixel_skip = 0;
+ var.key = "pcsx_rearmed_gpu_unai_old_renderer";
+ var.value = NULL;
+
+ if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+ {
+ if (strcmp(var.value, "enabled") == 0)
+ pl_rearmed_cbs.gpu_unai.old_renderer = 1;
+ else
+ pl_rearmed_cbs.gpu_unai.old_renderer = 0;
+ }
+
var.key = "pcsx_rearmed_gpu_unai_lighting";
var.value = NULL;
},
"disabled",
},
+#ifndef GPU_UNAI_NO_OLD
+ {
+ "pcsx_rearmed_gpu_unai_old_renderer",
+ "(GPU) Old renderer",
+ "Old renderer",
+ "This enables faster, but less accurate code.",
+ NULL,
+ "gpu_unai",
+ {
+ { "disabled", NULL },
+ { "enabled", NULL },
+ { NULL, NULL},
+ },
+ "disabled",
+ },
+#endif
{
"pcsx_rearmed_gpu_unai_blending",
"(GPU) Texture Blending",
pl_rearmed_cbs.gpu_neon.enhancement_tex_adj = 1;
pl_rearmed_cbs.gpu_peops.iUseDither = 0;
pl_rearmed_cbs.gpu_peops.dwActFixes = 1<<7;
+ pl_rearmed_cbs.gpu_unai.old_renderer = 0;
pl_rearmed_cbs.gpu_unai.ilace_force = 0;
pl_rearmed_cbs.gpu_unai.pixel_skip = 0;
pl_rearmed_cbs.gpu_unai.lighting = 1;
pl_rearmed_cbs.gpu_unai.fast_lighting = 0;
pl_rearmed_cbs.gpu_unai.blending = 1;
pl_rearmed_cbs.gpu_unai.dithering = 0;
- pl_rearmed_cbs.gpu_unai_old.abe_hack =
- pl_rearmed_cbs.gpu_unai_old.no_light =
- pl_rearmed_cbs.gpu_unai_old.no_blend = 0;
memset(&pl_rearmed_cbs.gpu_peopsgl, 0, sizeof(pl_rearmed_cbs.gpu_peopsgl));
pl_rearmed_cbs.gpu_peopsgl.iVRamSize = 64;
pl_rearmed_cbs.gpu_peopsgl.iTexGarbageCollection = 1;
CE_INTVAL_V(frameskip, 4),
CE_INTVAL_P(gpu_peops.iUseDither),
CE_INTVAL_P(gpu_peops.dwActFixes),
- CE_INTVAL_P(gpu_unai_old.lineskip),
- CE_INTVAL_P(gpu_unai_old.abe_hack),
- CE_INTVAL_P(gpu_unai_old.no_light),
- CE_INTVAL_P(gpu_unai_old.no_blend),
+ CE_INTVAL_P(gpu_unai.old_renderer),
CE_INTVAL_P(gpu_unai.ilace_force),
CE_INTVAL_P(gpu_unai.pixel_skip),
CE_INTVAL_P(gpu_unai.lighting),
#endif
-static menu_entry e_menu_plugin_gpu_unai_old[] =
-{
- mee_onoff ("Skip every 2nd line", 0, pl_rearmed_cbs.gpu_unai_old.lineskip, 1),
- mee_onoff ("Abe's Odyssey hack", 0, pl_rearmed_cbs.gpu_unai_old.abe_hack, 1),
- mee_onoff ("Disable lighting", 0, pl_rearmed_cbs.gpu_unai_old.no_light, 1),
- mee_onoff ("Disable blending", 0, pl_rearmed_cbs.gpu_unai_old.no_blend, 1),
- mee_end,
-};
-
-static int menu_loop_plugin_gpu_unai_old(int id, int keys)
-{
- int sel = 0;
- me_loop(e_menu_plugin_gpu_unai_old, &sel);
- return 0;
-}
-
static menu_entry e_menu_plugin_gpu_unai[] =
{
+ mee_onoff ("Old renderer", 0, pl_rearmed_cbs.gpu_unai.old_renderer, 1),
mee_onoff ("Interlace", 0, pl_rearmed_cbs.gpu_unai.ilace_force, 1),
mee_onoff ("Dithering", 0, pl_rearmed_cbs.gpu_unai.dithering, 1),
mee_onoff ("Lighting", 0, pl_rearmed_cbs.gpu_unai.lighting, 1),
"builtin_gpu is the NEON GPU, very fast and accurate\n"
#endif
"gpu_peops is Pete's soft GPU, slow but accurate\n"
- "gpu_unai_old is from old PCSX4ALL, fast but glitchy\n"
- "gpu_unai is newer, more accurate but slower\n"
+ "gpu_unai is the GPU renderer from PCSX4ALL\n"
"gpu_gles Pete's hw GPU, uses 3D chip but is glitchy\n"
"must save config and reload the game if changed";
static const char h_plugin_spu[] = "spunull effectively disables sound\n"
"must save config and reload the game if changed";
static const char h_gpu_peops[] = "Configure P.E.Op.S. SoftGL Driver V1.17";
static const char h_gpu_peopsgl[]= "Configure P.E.Op.S. MesaGL Driver V1.78";
-static const char h_gpu_unai_old[] = "Configure Unai/PCSX4ALL Team GPU plugin (old)";
static const char h_gpu_unai[] = "Configure Unai/PCSX4ALL Team plugin (new)";
static const char h_spu[] = "Configure built-in P.E.Op.S. Sound Driver V1.7";
mee_handler_h ("Configure built-in GPU plugin", menu_loop_plugin_gpu_neon, h_gpu_neon),
#endif
mee_handler_h ("Configure gpu_peops plugin", menu_loop_plugin_gpu_peops, h_gpu_peops),
- mee_handler_h ("Configure gpu_unai_old GPU plugin", menu_loop_plugin_gpu_unai_old, h_gpu_unai_old),
mee_handler_h ("Configure gpu_unai GPU plugin", menu_loop_plugin_gpu_unai, h_gpu_unai),
mee_handler_h ("Configure gpu_gles GPU plugin", menu_loop_plugin_gpu_peopsgl, h_gpu_peopsgl),
mee_handler_h ("Configure built-in SPU plugin", menu_loop_plugin_spu, h_spu),
int dwFrameRateTicks;
} gpu_peops;
struct {
- int abe_hack;
- int no_light, no_blend;
- int lineskip;
- } gpu_unai_old;
- struct {
+ int old_renderer;
int ilace_force;
int pixel_skip;
int lighting;
include ../../config.mak
SRC_STANDALONE += gpu.cpp
-SRC_GPULIB += gpulib_if.cpp
+SRC_GPULIB += gpulib_if.cpp old/if.cpp
ifeq "$(ARCH)" "arm"
SRC += gpu_arm.S
uint8_t fast_lighting:1;
uint8_t blending:1;
uint8_t dithering:1;
+ uint8_t old_renderer:1;
//senquack Only PCSX Rearmed's version of gpu_unai had this, and I
// don't think it's necessary. It would require adding 'AH' flag to
///////////////////////////////////////////////////////////////////////////
// --- BEGIN INVERSE APPROXIMATION SECTION ---
///////////////////////////////////////////////////////////////////////////
-#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+#if defined(GPU_UNAI_USE_INT_DIV_MULTINV) || !defined(GPU_UNAI_NO_OLD)
// big precision inverse table.
#define TABLE_BITS 16
s32 s_invTable[(1<<TABLE_BITS)];
+#endif
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
//senquack - MIPS32 happens to have same instruction/format:
#if defined(__arm__) || (__mips == 32)
INLINE u32 Log2(u32 x) { u32 res; asm("clz %0,%1" : "=r" (res) : "r" (x)); return 32-res; }
#include <stdlib.h>
#include <string.h>
#include "../gpulib/gpu.h"
+#include "old/if.h"
#ifdef THREAD_RENDERING
#include "../gpulib/gpulib_thread_if.h"
/////////////////////////////////////////////////////////////////////////////
+#ifndef GPU_UNAI_NO_OLD
+#define IS_OLD_RENDERER() gpu_unai.config.old_renderer
+#else
+#define IS_OLD_RENDERER() false
+#endif
+
#define DOWNSCALE_VRAM_SIZE (1024 * 512 * 2 * 2 + 4096)
INLINE void scale_640_to_320(le16_t *dest, const le16_t *src, bool isRGB24) {
//gpu_unai.config.enableAbbeyHack = gpu_unai_config_ext.abe_hack;
gpu_unai.ilace_mask = gpu_unai.config.ilace_force;
-#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+#if defined(GPU_UNAI_USE_INT_DIV_MULTINV) || !defined(GPU_UNAI_NO_OLD)
// s_invTable
for(int i=1;i<=(1<<TABLE_BITS);++i)
{
le32_t *list_start = list;
le32_t *list_end = list + list_len;
+ if (IS_OLD_RENDERER())
+ return oldunai_do_cmd_list(list_, list_len, cycles_sum_out, cycles_last, last_cmd);
+
//TODO: set ilace_mask when resolution changes instead of every time,
// eliminate #ifdef below.
gpu_unai.ilace_mask = gpu_unai.config.ilace_force;
void renderer_sync_ecmds(u32 *ecmds)
{
- int dummy;
- do_cmd_list(&ecmds[1], 6, &dummy, &dummy, &dummy);
+ if (!IS_OLD_RENDERER()) {
+ int dummy;
+ do_cmd_list(&ecmds[1], 6, &dummy, &dummy, &dummy);
+ }
+ else
+ oldunai_renderer_sync_ecmds(ecmds);
}
void renderer_update_caches(int x, int y, int w, int h, int state_changed)
void renderer_set_config(const struct rearmed_cbs *cbs)
{
gpu_unai.vram = (le16_t *)gpu.vram;
+ gpu_unai.config.old_renderer = cbs->gpu_unai.old_renderer;
gpu_unai.config.ilace_force = cbs->gpu_unai.ilace_force;
gpu_unai.config.pixel_skip = cbs->gpu_unai.pixel_skip;
gpu_unai.config.lighting = cbs->gpu_unai.lighting;
} else {
unmap_downscale_buffer();
}
+ oldunai_renderer_set_config(cbs);
}
void renderer_sync(void)
#define fixed_HALF ((fixed)((1<<FIXED_BITS)>>1))
// big precision inverse table.
-s32 s_invTable[(1<<TABLE_BITS)];
+extern s32 s_invTable[(1<<TABLE_BITS)];
INLINE fixed i2x(const int _x) { return ((_x)<<FIXED_BITS); }
INLINE fixed x2i(const fixed _x) { return ((_x)>>FIXED_BITS); }
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#include "../gpulib/gpu.h"
+#include "../../gpulib/gpu.h"
#include "arm_features.h"
+#include "if.h"
#define u8 uint8_t
#define s8 int8_t
static bool FrameToRead = false; /* load image in progress */
static bool FrameToWrite = false; /* store image in progress */
-static bool enableAbbeyHack = false; /* Abe's Odyssey hack */
+//static bool enableAbbeyHack = false; /* Abe's Odyssey hack */
+#define enableAbbeyHack false
static u8 BLEND_MODE;
static u8 TEXT_MODE;
/////////////////////////////////////////////////////////////////////////////
-int renderer_init(void)
+void oldunai_renderer_init(void)
{
GPU_FrameBuffer = (u16 *)gpu.vram;
+#if 0 // shared with "new" unai
// s_invTable
for(int i=1;i<=(1<<TABLE_BITS);++i)
{
#endif
s_invTable[i-1]=s32(v);
}
-
- return 0;
-}
-
-void renderer_finish(void)
-{
-}
-
-void renderer_notify_res_change(void)
-{
-}
-
-void renderer_notify_scanout_change(int x, int y)
-{
+#endif
}
extern const unsigned char cmd_lengths[256];
-int do_cmd_list(uint32_t *list, int list_len,
+int oldunai_do_cmd_list(uint32_t *list, int list_len,
int *cycles_sum_out, int *cycles_last, int *last_cmd)
{
unsigned int cmd = 0, len, i;
- unsigned int *list_start = list;
- unsigned int *list_end = list + list_len;
+ uint32_t *list_start = list;
+ uint32_t *list_end = list + list_len;
linesInterlace = force_interlace;
#ifdef HAVE_PRE_ARMV7 /* XXX */
return list - list_start;
}
-void renderer_sync_ecmds(uint32_t *ecmds)
+void oldunai_renderer_sync_ecmds(uint32_t *ecmds)
{
int dummy;
do_cmd_list(&ecmds[1], 6, &dummy, &dummy, &dummy);
}
-void renderer_update_caches(int x, int y, int w, int h, int state_changed)
-{
-}
-
-void renderer_flush_queues(void)
-{
-}
-
-void renderer_set_interlace(int enable, int is_odd)
-{
-}
-
#ifndef TEST
-#include "../../frontend/plugin_lib.h"
+#include "../../../frontend/plugin_lib.h"
-void renderer_set_config(const struct rearmed_cbs *cbs)
+void oldunai_renderer_set_config(const struct rearmed_cbs *cbs)
{
- force_interlace = cbs->gpu_unai_old.lineskip;
- enableAbbeyHack = cbs->gpu_unai_old.abe_hack;
- light = !cbs->gpu_unai_old.no_light;
- blend = !cbs->gpu_unai_old.no_blend;
+ force_interlace = cbs->gpu_unai.ilace_force;
+ //enableAbbeyHack = cbs->gpu_unai_old.abe_hack;
+ light = cbs->gpu_unai.lighting;
+ blend = cbs->gpu_unai.blending;
GPU_FrameBuffer = (u16 *)gpu.vram;
}
--- /dev/null
+#ifndef GPU_UNAI_NO_OLD
+
+struct rearmed_cbs;
+
+void oldunai_renderer_init(void);
+int oldunai_do_cmd_list(uint32_t *list, int list_len,
+ int *cycles_sum_out, int *cycles_last, int *last_cmd);
+void oldunai_renderer_sync_ecmds(uint32_t *ecmds);
+void oldunai_renderer_set_config(const struct rearmed_cbs *cbs);
+
+#else
+
+#define oldunai_renderer_init()
+#define oldunai_do_cmd_list(...) 0
+#define oldunai_renderer_sync_ecmds(x)
+#define oldunai_renderer_set_config(x)
+
+#endif
+++ /dev/null
-CFLAGS += -ggdb -Wall -O3 -ffast-math
-CFLAGS += -DREARMED
-CFLAGS += -I../../include
-
-include ../../config.mak
-
-SRC_STANDALONE += gpu.cpp
-SRC_GPULIB += gpulib_if.cpp
-
-ifeq "$(ARCH)" "arm"
-SRC += gpu_arm.s
-endif
-
-#BIN_STANDALONE = gpuPCSX4ALL.so
-BIN_GPULIB = gpu_unai_old.so
-include ../gpulib/gpulib.mak
gpu_peops or gpu_unai (depends on compile options).
gpu_peops.so - P.E.Op.S. soft GPU, reasonably accurate but slow
(also found with older emulators on PC)
-gpu_unai_old.so- Unai's plugin from PCSX4ALL project. Faster than P.E.Op.S.
- but has some glitches (old version).
gpu_gles.so - experimental port of P.E.Op.S. MesaGL plugin to OpenGL ES.
Occasionally faster but has lots of glitches and seems to
be rather unstable (may crash the driver/system).