/*************************************************************************** * * * Project64-video - A Nintendo 64 gfx plugin. * * http://www.pj64-emu.com/ * * Copyright (C) 2017 Project64. All rights reserved. * * Copyright (C) 2003-2009 Sergey 'Gonetz' Lipski * * Copyright (C) 2002 Dave2001 * * * * License: * * GNU/GPLv2 http://www.gnu.org/licenses/gpl-2.0.html * * version 2 of the License, or (at your option) any later version. * * * ****************************************************************************/ #pragma once #include #include extern char out_buf[2048]; extern uint32_t frame_count; // frame counter //GlideHQ support #include "Ext_TxFilter.h" enum { MAX_CACHE = 1024 * 4, MAX_TRI_CACHE = 768, // this is actually # of vertices, not triangles MAX_VTX = 256, MAX_TMU = 2, }; #define MAXCMD 0x100000 const unsigned int maxCMDMask = MAXCMD - 1; #define TEXMEM_2MB_EDGE 2097152 // Supported flags #define SUP_TEXMIRROR 0x00000001 // Clipping flags #define CLIP_XMAX 0x00000001 #define CLIP_XMIN 0x00000002 #define CLIP_YMAX 0x00000004 #define CLIP_YMIN 0x00000008 #define CLIP_WMIN 0x00000010 #define CLIP_ZMAX 0x00000020 #define CLIP_ZMIN 0x00000040 // Flags #define ZBUF_ENABLED 0x00000001 #define ZBUF_DECAL 0x00000002 #define ZBUF_COMPARE 0x00000004 #define ZBUF_UPDATE 0x00000008 #define ALPHA_COMPARE 0x00000010 #define FORCE_BL 0x00000020 #define CULL_FRONT 0x00001000 // * must be here #define CULL_BACK 0x00002000 // * must be here #define FOG_ENABLED 0x00010000 #define CULLMASK 0x00003000 #define CULLSHIFT 12 // Update flags #define UPDATE_ZBUF_ENABLED 0x00000001 #define UPDATE_TEXTURE 0x00000002 // \ Same thing! #define UPDATE_COMBINE 0x00000002 // / #define UPDATE_CULL_MODE 0x00000004 #define UPDATE_LIGHTS 0x00000010 #define UPDATE_BIASLEVEL 0x00000020 #define UPDATE_ALPHA_COMPARE 0x00000040 #define UPDATE_VIEWPORT 0x00000080 #define UPDATE_MULT_MAT 0x00000100 #define UPDATE_SCISSOR 0x00000200 #define UPDATE_FOG_ENABLED 0x00010000 #define CMB_MULT 0x00000001 #define CMB_SET 0x00000002 #define CMB_SUB 0x00000004 #define CMB_ADD 0x00000008 #define CMB_A_MULT 0x00000010 #define CMB_A_SET 0x00000020 #define CMB_A_SUB 0x00000040 #define CMB_A_ADD 0x00000080 #define CMB_SETSHADE_SHADEALPHA 0x00000100 #define CMB_INTER 0x00000200 #define CMB_MULT_OWN_ALPHA 0x00000400 #define CMB_COL_SUB_OWN 0x00000800 #define uc(x) coord[x<<1] #define vc(x) coord[(x<<1)+1] #if defined(_MSC_VER) #define DECLAREALIGN16VAR(var) __declspec(align(16)) float var #elif defined(__GNUG__) #define DECLAREALIGN16VAR(var) float (var) __attribute__ ((aligned(16))) #endif // Vertex structure typedef struct { float x, y, z, q; float u0, v0, u1, v1; float coord[4]; float w; uint16_t flags; uint8_t b; // These values are arranged like this so that *(uint32_t*)(VERTEX+?) is uint8_t g; // ARGB format that glide can use. uint8_t r; uint8_t a; float f; //fog float vec[3]; // normal vector float sx, sy, sz; float x_w, y_w, z_w, u0_w, v0_w, u1_w, v1_w, oow; uint8_t not_zclipped; uint8_t screen_translated; uint8_t uv_scaled; uint32_t uv_calculated; // like crc uint32_t shade_mod; uint32_t color_backup; float ou, ov; int number; // way to identify it int scr_off, z_off; // off the screen? } VERTEX; // Clipping (scissors) typedef struct { uint32_t ul_x; uint32_t ul_y; uint32_t lr_x; uint32_t lr_y; } SCISSOR; typedef struct { uint16_t tile_ul_s; uint16_t tile_ul_t; uint16_t tile_width; uint16_t tile_height; uint16_t tex_width; uint16_t tex_size; uint32_t dxt; } LOAD_TILE_INFO; typedef struct { int max_tex_size; int sup_large_tex; int sup_mirroring; int sup_32bit_tex; int has_2mb_tex_boundary; int gamma_correction; int32_t gamma_table_size; uint32_t *gamma_table_r; uint32_t *gamma_table_g; uint32_t *gamma_table_b; uint32_t tmem_ptr[MAX_TMU]; uint32_t tex_min_addr[MAX_TMU]; uint32_t tex_max_addr[MAX_TMU]; } VOODOO; // This structure is what is passed in by rdp:settextureimage typedef struct { uint8_t format; // format: ARGB, IA, ... uint8_t size; // size: 4,8,16, or 32 bit uint16_t width; // used in settextureimage uint32_t addr; // address in RDRAM to load the texture from int set_by; // 0-loadblock 1-loadtile } TEXTURE_IMAGE; // This structure is a tile descriptor (as used by rdp:settile and rdp:settilesize) typedef struct { // rdp:settile uint8_t format; // format: ARGB, IA, ... uint8_t size; // size: 4,8,16, or 32 bit uint16_t line; // size of one row (x axis) in 64 bit words uint16_t t_mem; // location in texture memory (in 64 bit words, max 512 (4MB)) uint8_t palette; // palette # to use uint8_t clamp_t; // clamp or wrap (y axis)? uint8_t mirror_t; // mirroring on (y axis)? uint8_t mask_t; // mask to wrap around (ex: 5 would wrap around 32) (y axis) uint8_t shift_t; // ??? (scaling) uint8_t clamp_s; // clamp or wrap (x axis)? uint8_t mirror_s; // mirroring on (x axis)? uint8_t mask_s; // mask to wrap around (x axis) uint8_t shift_s; // ??? (scaling) // rdp:settilesize uint16_t ul_s; // upper left s coordinate uint16_t ul_t; // upper left t coordinate uint16_t lr_s; // lower right s coordinate uint16_t lr_t; // lower right t coordinate float f_ul_s; float f_ul_t; // these are set by loadtile uint16_t t_ul_s; // upper left s coordinate uint16_t t_ul_t; // upper left t coordinate uint16_t t_lr_s; // lower right s coordinate uint16_t t_lr_t; // lower right t coordinate uint32_t width; uint32_t height; // uc0:texture uint8_t on; float s_scale; float t_scale; uint16_t org_s_scale; uint16_t org_t_scale; } TILE; // This structure forms the lookup table for cached textures typedef struct { uint32_t addr; // address in RDRAM uint32_t crc; // CRC check uint32_t palette; // Palette # uint32_t width; // width uint32_t height; // height uint32_t format; // format uint32_t size; // size uint32_t last_used; // what frame # was this texture last used (used for replacing) uint32_t line; uint32_t flags; // clamp/wrap/mirror flags uint32_t realwidth; // width of actual texture uint32_t realheight; // height of actual texture uint32_t lod; uint32_t aspect; uint8_t set_by; uint8_t texrecting; int f_mirror_s; int f_mirror_t; int f_wrap_s; int f_wrap_t; float scale_x; // texture scaling float scale_y; float scale; // general scale to 256 gfxTexInfo t_info; // texture info (glide) uint32_t tmem_addr; // addres in texture memory (glide) int uses; // 1 triangle that uses this texture int splits; // number of splits int splitheight; float c_off; // ul center texel offset (both x and y) float c_scl_x; // scale to lower-right center-texel x float c_scl_y; // scale to lower-right center-texel y uint32_t mod, mod_color, mod_color1, mod_color2, mod_factor; uint64_t ricecrc; int is_hires_tex; } CACHE_LUT; // Lights typedef struct { float r, g, b, a; // color float dir_x, dir_y, dir_z; // direction towards the light source float x, y, z, w; // light position float ca, la, qa; uint32_t nonblack; uint32_t nonzero; } LIGHT; typedef enum { ci_main, //0, main color image ci_zimg, //1, depth image ci_unknown, //2, status is unknown ci_useless, //3, status is unclear ci_old_copy, //4, auxiliary color image, copy of last color image from previous frame ci_copy, //5, auxiliary color image, copy of previous color image ci_copy_self, //6, main color image, it's content will be used to draw into itself ci_zcopy, //7, auxiliary color image, copy of depth image ci_aux, //8, auxiliary color image ci_aux_copy //9, auxiliary color image, partial copy of previous color image } CI_STATUS; // Frame buffers typedef struct { uint32_t addr; //color image address uint8_t format; uint8_t size; uint16_t width; uint16_t height; CI_STATUS status; int changed; } COLOR_IMAGE; typedef struct { gfxChipID_t tmu; uint32_t addr; //address of color image uint32_t end_addr; uint32_t tex_addr; //address in video memory uint32_t width; //width of color image uint32_t height; //height of color image uint8_t format; //format of color image uint8_t size; //format of color image uint8_t clear; //flag. texture buffer must be cleared uint8_t drawn; //flag. if equal to 1, this image was already drawn in current frame uint32_t crc; //checksum of the color image float scr_width; //width of rendered image float scr_height; //height of rendered image uint32_t tex_width; //width of texture buffer uint32_t tex_height; //height of texture buffer int tile; // uint16_t tile_uls; //shift from left bound of the texture uint16_t tile_ult; //shift from top of the texture uint32_t v_shift; //shift from top of the texture uint32_t u_shift; //shift from left of the texture float lr_u; float lr_v; float u_scale; //used to map vertex u,v coordinates into hires texture float v_scale; //used to map vertex u,v coordinates into hires texture CACHE_LUT * cache; //pointer to texture cache item gfxTexInfo info; uint16_t t_mem; } TBUFF_COLOR_IMAGE; typedef struct { gfxChipID_t tmu; uint32_t begin; //start of the block in video memory uint32_t end; //end of the block in video memory uint8_t count; //number of allocated texture buffers int clear_allowed; //stack of buffers can be cleared TBUFF_COLOR_IMAGE images[256]; } TEXTURE_BUFFER; #define NUMTEXBUF 92 class CRDP { public: CRDP(); ~CRDP(); bool init(); void free(); inline VERTEX & vtx(int index) const { return m_vtx[index]; } inline TILE & tiles(int index) { return m_tiles[index]; } // Clipping int clip; // clipping flags VERTEX *vtx1; //[256] copy vertex buffer #1 (used for clipping) VERTEX *vtx2; //[256] copy vertex buffer #2 VERTEX *vtxbuf; // current vertex buffer (reset to vtx, used to determine current vertex buffer) VERTEX *vtxbuf2; int n_global; // Used to pass the number of vertices from clip_z to clip_tri int vtx_buffer; CACHE_LUT *cache[MAX_TMU]; //[MAX_CACHE] CACHE_LUT *cur_cache[MAX_TMU]; uint32_t cur_cache_n[MAX_TMU]; int n_cached[MAX_TMU]; // Vertices private: VERTEX * m_vtx; //[MAX_VTX] public: int v0, vn; COLOR_IMAGE *frame_buffers; //[NUMTEXBUF+2] TEXTURE_BUFFER texbufs[2]; char RomName[21]; float vi_width; float vi_height; int window_changed; float offset_x, offset_y, offset_x_bak, offset_y_bak; float scale_x, scale_x_bak; float scale_y, scale_y_bak; float view_scale[3]; float view_trans[3]; float clip_min_x, clip_max_x, clip_min_y, clip_max_y; float clip_ratio; int updatescreen; uint32_t tri_n; // triangle counter uint32_t debug_n; // Program counter uint32_t pc[10]; // DList PC stack uint32_t pc_i; // current PC index in the stack int dl_count; // number of instructions before returning int LLE; // Segments uint32_t segment[16]; // Segment pointer // Marks the end of DList execution (done in uc?:enddl) bool halt; // Next command uint32_t cmd0; uint32_t cmd1; uint32_t cmd2; uint32_t cmd3; // Clipping SCISSOR scissor_o; SCISSOR scissor; int scissor_set; // Colors uint32_t fog_color; uint32_t fill_color; uint32_t prim_color; uint32_t blend_color; uint32_t env_color; uint32_t SCALE; uint32_t CENTER; uint32_t prim_lodmin, prim_lodfrac; uint16_t prim_depth; uint16_t prim_dz; uint8_t K4; uint8_t K5; enum { noise_none, noise_combine, noise_texture } noise; float col[4]; // color multiplier float coladd[4]; // color add/subtract float shade_factor; float col_2[4]; uint32_t cmb_flags, cmb_flags_2; // othermode_l flags int acmp; // 0 = none, 1 = threshold, 2 = dither int zsrc; // 0 = pixel, 1 = prim uint8_t alpha_dither_mode; // Matrices #pragma warning(push) #pragma warning(disable:4324) //structure was padded due to __declspec(align()) DECLAREALIGN16VAR(model[4][4]); #pragma warning(pop) DECLAREALIGN16VAR(proj[4][4]); DECLAREALIGN16VAR(combined[4][4]); DECLAREALIGN16VAR(dkrproj[3][4][4]); DECLAREALIGN16VAR(model_stack[32][4][4]); // 32 deep, will warn if overflow int model_i; // index in the model matrix stack int model_stack_size; // Textures TEXTURE_IMAGE timg; // 1 for each tmem address private: TILE m_tiles[8]; // 8 tile descriptors public: uint8_t tmem[4096]; // 4k tmem uint32_t addr[512]; // 512 addresses (used to determine address loaded from) LOAD_TILE_INFO load_info[512]; // 512 addresses. inforamation about tile loading. int cur_tile; // current tile int mipmap_level; int last_tile; // last tile set int last_tile_size; // last tile size set gfxChipID_t t0, t1; int best_tex; // if no 2-tmus, which texture? (0 or 1) int tex; int filter_mode; // Texture palette uint16_t pal_8[256]; uint32_t pal_8_crc[16]; uint32_t pal_256_crc; uint8_t tlut_mode; int LOD_en; int Persp_en; int persp_supported; int force_wrap; uint16_t pal_8_rice[512]; // Lighting uint32_t num_lights; LIGHT light[12]; float light_vector[12][3]; float lookat[2][3]; int use_lookat; // Combine modes uint32_t cycle1, cycle2, cycle_mode; uint8_t c_a0, c_b0, c_c0, c_d0, c_Aa0, c_Ab0, c_Ac0, c_Ad0; uint8_t c_a1, c_b1, c_c1, c_d1, c_Aa1, c_Ab1, c_Ac1, c_Ad1; uint8_t fbl_a0, fbl_b0, fbl_c0, fbl_d0; uint8_t fbl_a1, fbl_b1, fbl_c1, fbl_d1; uint8_t uncombined; // which is uncombined: 0x01=color 0x02=alpha 0x03=both // float YUV_C0, YUV_C1, YUV_C2, YUV_C3, YUV_C4; //YUV textures conversion coefficients // What needs updating uint32_t update; uint32_t flags; int first; uint32_t tex_ctr; // incremented every time textures are updated int allow_combine; // allow combine updating? int s2dex_tex_loaded; uint16_t bg_image_height; // Debug stuff uint32_t rm; // use othermode_l instead, this just as a check for changes uint32_t render_mode_changed; uint32_t geom_mode; uint32_t othermode_h; uint32_t othermode_l; // used to check if in texrect while loading texture uint8_t texrecting; //frame buffer related slots. Added by Gonetz uint32_t cimg, ocimg, zimg, tmpzimg, vi_org_reg; COLOR_IMAGE maincimg[2]; uint32_t last_drawn_ci_addr; uint32_t main_ci, main_ci_end, main_ci_bg, main_ci_last_tex_addr, zimg_end, last_bg; uint32_t ci_width, ci_height, ci_size, ci_end; uint32_t zi_width; int zi_lrx, zi_lry; uint8_t ci_count, num_of_ci, main_ci_index, copy_ci_index, copy_zi_index; int swap_ci_index, black_ci_index; uint32_t ci_upper_bound, ci_lower_bound; int motionblur, fb_drawn, fb_drawn_front, read_previous_ci, read_whole_frame; CI_STATUS ci_status; TBUFF_COLOR_IMAGE * cur_image; //image currently being drawn TBUFF_COLOR_IMAGE * tbuff_tex; //image, which corresponds to currently selected texture TBUFF_COLOR_IMAGE * aTBuffTex[2]; uint8_t cur_tex_buf; uint8_t acc_tex_buf; int skip_drawing; //rendering is not required. used for frame buffer emulation //fog related slots. Added by Gonetz float fog_multiplier, fog_offset; enum { fog_disabled, fog_enabled, fog_blend, fog_blend_inverse } fog_mode; }; void SetWireframeCol(); void ChangeSize(); void GoToFullScreen(); extern CRDP rdp; extern VOODOO voodoo; extern gfxTexInfo fontTex; extern gfxTexInfo cursorTex; extern uint32_t offset_font; extern uint32_t offset_cursor; extern uint32_t offset_textures; extern uint32_t offset_texbuf1; extern bool g_ucode_error_report; // RDP functions void rdp_reset(); extern const char *ACmp[]; extern const char *Mode0[]; extern const char *Mode1[]; extern const char *Mode2[]; extern const char *Mode3[]; extern const char *Alpha0[]; #define Alpha1 Alpha0 extern const char *Alpha2[]; #define Alpha3 Alpha0 extern const char *FBLa[]; extern const char *FBLb[]; extern const char *FBLc[]; extern const char *FBLd[]; extern const char *str_zs[]; extern const char *str_yn[]; extern const char *str_offon[]; extern const char *str_cull[]; // I=intensity probably extern const char *str_format[]; extern const char *str_size[]; extern const char *str_cm[]; extern const char *str_lod[]; extern const char *str_aspect[]; extern const char *str_filter[]; extern const char *str_tlut[]; extern const char *CIStatus[]; #define FBL_D_1 2 #define FBL_D_0 3 #ifndef maxval #define maxval(a, b) (((a) > (b)) ? (a) : (b)) #endif #ifndef minval #define minval(a, b) (((a) < (b)) ? (a) : (b)) #endif #ifndef TRUE #define TRUE 1 #endif #ifndef FALSE #define FALSE 0 #endif #ifndef HIWORD #define HIWORD(a) ((unsigned int)(a) >> 16) #endif #ifndef LOWORD #define LOWORD(a) ((a) & 0xFFFF) #endif // Convert from u0/v0/u1/v1 to the real coordinates without regard to tmu __inline void ConvertCoordsKeep(VERTEX *v, int n) { for (int i = 0; i < n; i++) { v[i].uc(0) = v[i].u0; v[i].vc(0) = v[i].v0; v[i].uc(1) = v[i].u1; v[i].vc(1) = v[i].v1; } } // Convert from u0/v0/u1/v1 to the real coordinates based on the tmu they are on __inline void ConvertCoordsConvert(VERTEX *v, int n) { for (int i = 0; i < n; i++) { v[i].uc(rdp.t0) = v[i].u0; v[i].vc(rdp.t0) = v[i].v0; v[i].uc(rdp.t1) = v[i].u1; v[i].vc(rdp.t1) = v[i].v1; } } __inline void AllowShadeMods(VERTEX *v, int n) { for (int i = 0; i < n; i++) { v[i].shade_mod = 0; } } __inline void AddOffset(VERTEX *v, int n) { for (int i = 0; i < n; i++) { v[i].x += rdp.offset_x; v[i].y += rdp.offset_y; } } __inline void CalculateFog(VERTEX &v) { if (rdp.flags & FOG_ENABLED) { if (v.w < 0.0f) v.f = 0.0f; else v.f = minval(255.0f, maxval(0.0f, v.z_w * rdp.fog_multiplier + rdp.fog_offset)); v.a = (uint8_t)v.f; } else { v.f = 1.0f; } } void newSwapBuffers(); extern int SwapOK; // ** utility functions void load_palette(uint32_t addr, uint16_t start, uint16_t count); void setTBufTex(uint16_t t_mem, uint32_t cnt); // ** RDP graphics functions ** void undef(); void spnoop(); void rdp_noop(); void rdp_texrect(); //void rdp_texrectflip(); void rdp_loadsync(); void rdp_pipesync(); void rdp_tilesync(); void rdp_fullsync(); void rdp_setkeygb(); void rdp_setkeyr(); void rdp_setconvert(); void rdp_setscissor(); void rdp_setprimdepth(); void rdp_loadtlut(); void rdp_settilesize(); void rdp_loadblock(); void rdp_loadtile(); void rdp_settile(); void rdp_fillrect(); void rdp_setfillcolor(); void rdp_setfogcolor(); void rdp_setblendcolor(); void rdp_setprimcolor(); void rdp_setenvcolor(); void rdp_setcombine(); void rdp_settextureimage(); void rdp_setdepthimage(); void rdp_setcolorimage(); void rdp_setothermode(); void rdp_trifill(); void rdp_trishade(); void rdp_tritxtr(); void rdp_trishadetxtr(); void rdp_trifillz(); void rdp_trishadez(); void rdp_tritxtrz(); void rdp_trishadetxtrz(); void rdphalf_1(); void rdphalf_2(); void rdphalf_cont(); void rsp_reserved0(); void rsp_reserved1(); void rsp_reserved2(); void rsp_reserved3(); void ys_memrect(); void microcheck(); extern const char *str_dither[]; extern uint8_t microcode[4096];