plugins/gpu_unai/gpu_unai.h

   1 /***************************************************************************
   2 *   Copyright (C) 2010 PCSX4ALL Team                                      *
   3 *   Copyright (C) 2010 Unai                                               *
   4 *   Copyright (C) 2016 Senquack (dansilsby <AT> gmail <DOT> com)          *
   5 *                                                                         *
   6 *   This program is free software; you can redistribute it and/or modify  *
   7 *   it under the terms of the GNU General Public License as published by  *
   8 *   the Free Software Foundation; either version 2 of the License, or     *
   9 *   (at your option) any later version.                                   *
  10 *                                                                         *
  11 *   This program is distributed in the hope that it will be useful,       *
  12 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  13 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  14 *   GNU General Public License for more details.                          *
  15 *                                                                         *
  16 *   You should have received a copy of the GNU General Public License     *
  17 *   along with this program; if not, write to the                         *
  18 *   Free Software Foundation, Inc.,                                       *
  19 *   51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA.           *
  20 ***************************************************************************/
  21
  22 #ifndef GPU_UNAI_H
  23 #define GPU_UNAI_H
  24
  25 #include "gpu.h"
  26
  27 // Header shared between both standalone gpu_unai (gpu.cpp) and new
  28 // gpulib-compatible gpu_unai (gpulib_if.cpp)
  29 // -> Anything here should be for gpu_unai's private use. <-
  30
  31 ///////////////////////////////////////////////////////////////////////////////
  32 //  Compile Options
  33
  34 //#define ENABLE_GPU_NULL_SUPPORT   // Enables NullGPU support
  35 //#define ENABLE_GPU_LOG_SUPPORT    // Enables gpu logger, very slow only for windows debugging
  36 //#define ENABLE_GPU_ARMV7                      // Enables ARMv7 optimized assembly
  37
  38 //Poly routine options (default is integer math and accurate division)
  39 //#define GPU_UNAI_USE_FLOATMATH         // Use float math in poly routines
  40 //#define GPU_UNAI_USE_FLOAT_DIV_MULTINV // If GPU_UNAI_USE_FLOATMATH is defined,
  41                                          //  use multiply-by-inverse for division
  42 //#define GPU_UNAI_USE_INT_DIV_MULTINV   // If GPU_UNAI_USE_FLOATMATH is *not*
  43                                          //  defined, use old inaccurate division
  44
  45
  46 #define GPU_INLINE static inline __attribute__((always_inline))
  47 #define INLINE     static inline __attribute__((always_inline))
  48
  49 #define u8  uint8_t
  50 #define s8  int8_t
  51 #define u16 uint16_t
  52 #define s16 int16_t
  53 #define u32 uint32_t
  54 #define s32 int32_t
  55 #define s64 int64_t
  56
  57 typedef struct {
  58         u32 v;
  59 } le32_t;
  60
  61 typedef struct {
  62         u16 v;
  63 } le16_t;
  64
  65 static inline u32 le32_to_u32(le32_t le)
  66 {
  67         return LE32TOH(le.v);
  68 }
  69
  70 static inline s32 le32_to_s32(le32_t le)
  71 {
  72         return (int32_t) LE32TOH(le.v);
  73 }
  74
  75 static inline u32 le32_raw(le32_t le)
  76 {
  77         return le.v;
  78 }
  79
  80 static inline le32_t u32_to_le32(u32 u)
  81 {
  82         return (le32_t){ .v = HTOLE32(u) };
  83 }
  84
  85 static inline u16 le16_to_u16(le16_t le)
  86 {
  87         return LE16TOH(le.v);
  88 }
  89
  90 static inline s16 le16_to_s16(le16_t le)
  91 {
  92         return (int16_t) LE16TOH(le.v);
  93 }
  94
  95 static inline u16 le16_raw(le16_t le)
  96 {
  97         return le.v;
  98 }
  99
 100 static inline le16_t u16_to_le16(u16 u)
 101 {
 102         return (le16_t){ .v = HTOLE16(u) };
 103 }
 104
 105 union PtrUnion
 106 {
 107         le32_t  *U4;
 108         le16_t  *U2;
 109         u8   *U1;
 110         void *ptr;
 111 };
 112
 113 union GPUPacket
 114 {
 115         le32_t U4[16];
 116         le16_t U2[32];
 117         u8  U1[64];
 118 };
 119
 120 template<class T> static inline void SwapValues(T &x, T &y)
 121 {
 122         T tmp(x);  x = y;  y = tmp;
 123 }
 124
 125 template<typename T>
 126 static inline T Min2 (const T a, const T b)
 127 {
 128         return (a<b)?a:b;
 129 }
 130
 131 template<typename T>
 132 static inline T Min3 (const T a, const T b, const T c)
 133 {
 134         return  Min2(Min2(a,b),c);
 135 }
 136
 137 template<typename T>
 138 static inline T Max2 (const T a, const T b)
 139 {
 140         return  (a>b)?a:b;
 141 }
 142
 143 template<typename T>
 144 static inline T Max3 (const T a, const T b, const T c)
 145 {
 146         return  Max2(Max2(a,b),c);
 147 }
 148
 149
 150 ///////////////////////////////////////////////////////////////////////////////
 151 //  GPU Raster Macros
 152
 153 // Convert 24bpp color parameter of GPU command to 16bpp (15bpp + mask bit)
 154 #define GPU_RGB16(rgb) ((((rgb)&0xF80000)>>9)|(((rgb)&0xF800)>>6)|(((rgb)&0xF8)>>3))
 155
 156 // Sign-extend 11-bit coordinate command param
 157 #define GPU_EXPANDSIGN(x) (((s32)(x)<<(32-11))>>(32-11))
 158
 159 // Max difference between any two X or Y primitive coordinates
 160 #define CHKMAX_X 1024
 161 #define CHKMAX_Y 512
 162
 163 #define FRAME_BUFFER_SIZE       (1024*512*2)
 164 #define FRAME_WIDTH                       1024
 165 #define FRAME_HEIGHT              512
 166 #define FRAME_OFFSET(x,y)       (((y)<<10)+(x))
 167 #define FRAME_BYTE_STRIDE     2048
 168 #define FRAME_BYTES_PER_PIXEL 2
 169
 170 static inline s32 GPU_DIV(s32 rs, s32 rt)
 171 {
 172         return rt ? (rs / rt) : (0);
 173 }
 174
 175 // 'Unsafe' version of above that doesn't check for div-by-zero
 176 #define GPU_FAST_DIV(rs, rt) ((signed)(rs) / (signed)(rt))
 177
 178 struct gpu_unai_t {
 179         u32 GPU_GP1;
 180         GPUPacket PacketBuffer;
 181         le16_t *vram;
 182
 183 #ifdef USE_GPULIB
 184         le16_t *downscale_vram;
 185 #endif
 186         ////////////////////////////////////////////////////////////////////////////
 187         // Variables used only by older standalone version of gpu_unai (gpu.cpp)
 188 #ifndef USE_GPULIB
 189         u32  GPU_GP0;
 190         u32  tex_window;       // Current texture window vals (set by GP0(E2h) cmd)
 191         s32  PacketCount;
 192         s32  PacketIndex;
 193         bool fb_dirty;         // Framebuffer is dirty (according to GPU)
 194
 195         //  Display status
 196         //  NOTE: Standalone older gpu_unai didn't care about horiz display range
 197         u16  DisplayArea[6];   // [0] : Start of display area (in VRAM) X
 198                                // [1] : Start of display area (in VRAM) Y
 199                                // [2] : Display mode resolution HORIZONTAL
 200                                // [3] : Display mode resolution VERTICAL
 201                                // [4] : Vertical display range (on TV) START
 202                                // [5] : Vertical display range (on TV) END
 203
 204         ////////////////////////////////////////////////////////////////////////////
 205         //  Dma Transfers info
 206         struct {
 207                 s32  px,py;
 208                 s32  x_end,y_end;
 209                 le16_t* pvram;
 210                 u32 *last_dma;     // Last dma pointer
 211                 bool FrameToRead;  // Load image in progress
 212                 bool FrameToWrite; // Store image in progress
 213         } dma;
 214
 215         ////////////////////////////////////////////////////////////////////////////
 216         //  Frameskip
 217         struct {
 218                 int  skipCount;    // Frame skip (0,1,2,3...)
 219                 bool isSkip;       // Skip frame (according to GPU)
 220                 bool skipFrame;    // Skip this frame (according to frame skip)
 221                 bool wasSkip;      // Skip frame old value (according to GPU)
 222                 bool skipGPU;      // Skip GPU primitives
 223         } frameskip;
 224 #endif
 225         // END of standalone gpu_unai variables
 226         ////////////////////////////////////////////////////////////////////////////
 227
 228         u32 TextureWindowCur;  // Current setting from last GP0(0xE2) cmd (raw form)
 229         u8  TextureWindow[4];  // [0] : Texture window offset X
 230                                // [1] : Texture window offset Y
 231                                // [2] : Texture window mask X
 232                                // [3] : Texture window mask Y
 233
 234         u16 DrawingArea[4];    // [0] : Drawing area top left X
 235                                // [1] : Drawing area top left Y
 236                                // [2] : Drawing area bottom right X
 237                                // [3] : Drawing area bottom right Y
 238
 239         s16 DrawingOffset[2];  // [0] : Drawing offset X (signed)
 240                                // [1] : Drawing offset Y (signed)
 241
 242         le16_t* TBA;              // Ptr to current texture in VRAM
 243         le16_t* CBA;              // Ptr to current CLUT in VRAM
 244
 245         ////////////////////////////////////////////////////////////////////////////
 246         //  Inner Loop parameters
 247
 248         // 22.10 Fixed-pt texture coords, mask, scanline advance
 249         // NOTE: U,V are no longer packed together into one u32, this proved to be
 250         //  too imprecise, leading to pixel dropouts.  Example: NFS3's skybox.
 251         u32 u, v;
 252         u32 u_msk, v_msk;
 253         s32 u_inc, v_inc;
 254
 255         // Color for Gouraud-shaded prims
 256         // Packed fixed-pt 8.3:8.3:8.2 rgb triplet
 257         //  layout:  rrrrrrrrXXXggggggggXXXbbbbbbbbXX
 258         //           ^ bit 31                       ^ bit 0
 259         u32 gCol;
 260         u32 gInc;          // Increment along scanline for gCol
 261
 262         // Color for flat-shaded, texture-blended prims
 263         u8  r5, g5, b5;    // 5-bit light for undithered prims
 264         u8  r8, g8, b8;    // 8-bit light for dithered prims
 265
 266         // Color for flat-shaded, untextured prims
 267         u16 PixelData;      // bgr555 color for untextured flat-shaded polys
 268
 269         // End of inner Loop parameters
 270         ////////////////////////////////////////////////////////////////////////////
 271
 272
 273         u8 blit_mask;           // Determines what pixels to skip when rendering.
 274                                 //  Only useful on low-resolution devices using
 275                                 //  a simple pixel-dropping downscaler for PS1
 276                                 //  high-res modes. See 'pixel_skip' option.
 277
 278         u8 ilace_mask;          // Determines what lines to skip when rendering.
 279                                 //  Normally 0 when PS1 240 vertical res is in
 280                                 //  use and ilace_force is 0. When running in
 281                                 //  PS1 480 vertical res on a low-resolution
 282                                 //  device (320x240), will usually be set to 1
 283                                 //  so odd lines are not rendered. (Unless future
 284                                 //  full-screen scaling option is in use ..TODO)
 285
 286         bool prog_ilace_flag;   // Tracks successive frames for 'prog_ilace' option
 287
 288         u8 BLEND_MODE;
 289         u8 TEXT_MODE;
 290         u8 Masking;
 291
 292         u16 PixelMSB;
 293
 294         gpu_unai_config_t config;
 295
 296         u8  LightLUT[32*32];    // 5-bit lighting LUT (gpu_inner_light.h)
 297         u32 DitherMatrix[64];   // Matrix of dither coefficients
 298 };
 299
 300 static gpu_unai_t gpu_unai;
 301
 302 // Global config that frontend can alter.. Values are read in GPU_init().
 303 // TODO: if frontend menu modifies a setting, add a function that can notify
 304 // GPU plugin to use new setting.
 305 gpu_unai_config_t gpu_unai_config_ext;
 306
 307 ///////////////////////////////////////////////////////////////////////////////
 308 // Internal inline funcs to get option status: (Allows flexibility)
 309 static inline bool LightingEnabled()
 310 {
 311         return gpu_unai.config.lighting;
 312 }
 313
 314 static inline bool FastLightingEnabled()
 315 {
 316         return gpu_unai.config.fast_lighting;
 317 }
 318
 319 static inline bool BlendingEnabled()
 320 {
 321         return gpu_unai.config.blending;
 322 }
 323
 324 static inline bool DitheringEnabled()
 325 {
 326         return gpu_unai.config.dithering;
 327 }
 328
 329 // For now, this is just for development/experimentation purposes..
 330 // If modified to return true, it will allow ignoring the status register
 331 //  bit 9 setting (dither enable). It will still restrict dithering only
 332 //  to Gouraud-shaded or texture-blended polys.
 333 static inline bool ForcedDitheringEnabled()
 334 {
 335         return false;
 336 }
 337
 338 static inline bool ProgressiveInterlaceEnabled()
 339 {
 340 #ifdef USE_GPULIB
 341         // Using this old option greatly decreases quality of image. Disabled
 342         //  for now when using new gpulib, since it also adds more work in loops.
 343         return false;
 344 #else
 345         return gpu_unai.config.prog_ilace;
 346 #endif
 347 }
 348
 349 // For now, 320x240 output resolution is assumed, using simple line-skipping
 350 //  and pixel-skipping downscaler.
 351 // TODO: Flesh these out so they return useful values based on whether
 352 //       running on higher-res device or a resampling downscaler is enabled.
 353 static inline bool PixelSkipEnabled()
 354 {
 355         return gpu_unai.config.pixel_skip || gpu_unai.config.scale_hires;
 356 }
 357
 358 static inline bool LineSkipEnabled()
 359 {
 360         return true;
 361 }
 362
 363 #endif // GPU_UNAI_H