Game-Decompilation/CTR-ModSDK
1
0
Fork 0
mirror of https://github.com/CTR-tools/CTR-ModSDK.git synced 2025-02-17 03:37:47 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

rebuild_PC: move to cmake (adding submodule dependencies fallback) (#114)

Browse Source 
* rebuild_PC: adopt thirdparty as submodules

* rebuild_PC: drop nested PsyCross files

* rebuild_PC: update PsyCross in VCXPROJ

* move to cmake (adding vendored dependencies fallback)

* ci: fetch submodules

* ci: build with submodules

* rebuild_PC: fix mingw
This commit is contained in:
Pedro Lara Campos 2024-04-11 08:42:00 -03:00 committed by GitHub
parent b201442b2e
commit 0a217a9fb2
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
45 changed files with 164 additions and 8167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.editorconfig
View File

@ -11,6 +11,12 @@ end_of_line = lf
indent_style = space
indent_size = 2
[CMakeLists.txt]
insert_final_newline = true
end_of_line = lf
indent_style = space
indent_size = 2
[*.{c,C,h,H}]
indent_style = tab
indent_size = 4

3
.github/workflows/main.yml vendored
View File

@ -17,7 +17,8 @@ jobs:
- uses: actions/checkout@v4
with:
fetch-depth: 0
submodules: true
- uses: DeterminateSystems/nix-installer-action@main
- uses: DeterminateSystems/magic-nix-cache-action@main
- name: Build
run: nix build -L --no-link --keep-going .#all
run: nix build -L --no-link --keep-going '.?submodules=1#all'

9
.gitmodules vendored Normal file
View File

@ -0,0 +1,9 @@
[submodule "rebuild_PC/thirdparty/PsyCross"]
path = rebuild_PC/thirdparty/PsyCross
url = https://github.com/OpenDriver2/PsyCross.git
[submodule "rebuild_PC/thirdparty/SDL"]
path = rebuild_PC/thirdparty/SDL
url = https://github.com/libsdl-org/SDL.git
[submodule "rebuild_PC/thirdparty/openal-soft"]
path = rebuild_PC/thirdparty/openal-soft
url = https://github.com/kcat/openal-soft.git

2
flake.nix
View File

@ -8,7 +8,7 @@
};
mingw32 = with pkgsCross.mingw32; {
gcc = callPackage ./rebuild_PC { ctrModSDK = self; };
clang = callPackage ./rebuild_PC { ctrModSDK = self; stdenv = clangStdenv; };
clang = callPackage ./rebuild_PC { ctrModSDK = self; stdenv = clangStdenv; trustCompiler = true; };
};
all = stdenvNoCC.mkDerivation {
name = "ctr-join";

111
rebuild_PC/CMakeLists.txt Normal file
View File

@ -0,0 +1,111 @@
cmake_minimum_required(VERSION 3.20)
project(CTR-PC)
# === OPTIONS ===
set(CTR_16BY9 ON)
set(CTR_60FPS ON)
set(CTR_NEW2P ON)
set(CTR_PRIM 0)
# === BASICS ===
set_source_files_properties("CrashTeamRacingPC.c" PROPERTIES LANGUAGE C)
add_executable(ctr_bin "CrashTeamRacingPC.c")
set_target_properties(ctr_bin PROPERTIES OUTPUT_NAME "CrashTeamRacingPC")
target_include_directories(ctr_bin PUBLIC "../include")
# === COMPILER OPTIONS ===
set_property(TARGET ctr_bin PROPERTY C_STANDARD 99)
target_compile_options(ctr_bin PUBLIC -DUSE_EXTENDED_PRIM_POINTERS=${CTR_PRIM})
if(CTR_16BY9)
target_compile_options(ctr_bin PUBLIC -DUSE_16BY9 -DUSE_NEW2P)
endif()
if(CTR_60FPS)
target_compile_options(ctr_bin PUBLIC -DUSE_60FPS)
endif()
# Clang is rigorous
if(CMAKE_C_COMPILER_ID MATCHES "Clang")
target_compile_options(ctr_bin PUBLIC -Wno-int-conversion -Wno-incompatible-function-pointer-types -Wno-implicit-function-declaration -Wno-return-type)
if(MINGW OR CYGWIN)
if(NOT CMAKE_VERSION VERSION_LESS "3.13")
target_link_options(ctr_bin PUBLIC -static-libgcc)
endif()
endif()
endif()
if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
target_compile_options(ctr_bin PUBLIC -g -gdwarf-2 -O0)
else()
target_compile_options(ctr_bin PUBLIC -O2)
endif()
# === LINKER OPTIONS ===
# Clang always needs "no-pie", but some distros might add PIE to GCC too.
target_link_options(ctr_bin PUBLIC -fno-pie -no-pie -Wl,-Ttext,0x00D00000)
# === DEPENDENCIES ===
find_package(SDL2 QUIET)
if(NOT SDL2_FOUND)
add_subdirectory("thirdparty/SDL")
set(SDL2_LIBRARIES SDL2 SDL2main)
set(SDL2_INCLUDE_DIR "thirdparty/SDL/include")
endif()
target_link_libraries(ctr_bin ${SDL2_LIBRARIES})
target_include_directories(ctr_bin PRIVATE ${SDL2_INCLUDE_DIRS})
find_package(OpenAL QUIET)
if(NOT OpenAL_FOUND)
add_subdirectory("thirdparty/openal-soft")
set(OPENAL_LIBRARY OpenAL)
set(OPENAL_INCLUDE_DIR "thirdparty/openal-soft/include")
endif()
# === PsyCross ===
file(GLOB_RECURSE PSYCROSS_SRCS_C
"thirdparty/PsyCross/*.c" "thirdparty/PsyCross/*.C"
)
file(GLOB_RECURSE PSYCROSS_SRCS_CPP
"thirdparty/PsyCross/*.cpp"
)
set_source_files_properties(${PSYCROSS_SRCS_C} PROPERTIES LANGUAGE C)
set_source_files_properties(${PSYCROSS_SRCS_CPP} PROPERTIES LANGUAGE CXX)
add_library(psycross_static STATIC ${PSYCROSS_SRCS_C} ${PSYCROSS_SRCS_CPP})
set_target_properties(psycross_static PROPERTIES OUTPUT_NAME "psycross")
target_include_directories(psycross_static PUBLIC "thirdparty/PsyCross/include")
target_compile_options(psycross_static PRIVATE -Wno-narrowing)
target_link_libraries(psycross_static ${SDL2_LIBRARIES})
target_include_directories(psycross_static PRIVATE ${SDL2_INCLUDE_DIRS})
target_link_libraries(psycross_static ${OPENAL_LIBRARY})
target_include_directories(psycross_static PRIVATE ${OPENAL_INCLUDE_DIR})
# === OUR PsyCross USAGE ===
target_compile_options(psycross_static PUBLIC -DUSE_EXTENDED_PRIM_POINTERS=${CTR_PRIM} -O2)
if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
target_compile_options(psycross_static PUBLIC -g -gdwarf-2)
endif()
# Clang is rigorous
if(CMAKE_C_COMPILER_ID MATCHES "Clang")
target_compile_options(psycross_static PRIVATE -Wno-int-conversion -Wno-implicit-function-declaration)
endif()
target_link_libraries(ctr_bin psycross_static)
target_include_directories(ctr_bin PRIVATE ${PsyCross_SOURCE_DIR}/include)
#target_link_libraries(ctr_bin stdc++ m)

4
rebuild_PC/CrashTeamRacingPC.vcxproj
View File

@ -76,7 +76,7 @@
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>$(ProjectDir)\PsyCross\include;$(ProjectDir)\..\include</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>$(ProjectDir)\thirdparty\PsyCross\include;$(ProjectDir)\..\include</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
@ -96,7 +96,7 @@
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>$(ProjectDir)\PsyCross\include;$(ProjectDir)\..\include</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>$(ProjectDir)\thirdparty\PsyCross\include;$(ProjectDir)\..\include</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>

20
rebuild_PC/Makefile
View File

@ -1,20 +0,0 @@
.PHONY: all
CFLAGS+=-std=c99 -DUSE_16BY9=1 -O2 \
-I./PsyCross/include -I../include \
`${PKG_CONFIG} --cflags sdl2`
# Clang is rigorous
CFLAGS+=-Wno-int-conversion -Wno-incompatible-function-pointer-types -Wno-implicit-function-declaration -Wno-return-type
LDLIBS+=-lpsycross \
`${PKG_CONFIG} --libs sdl2` \
`${PKG_CONFIG} --libs openal` \
-lstdc++ -lm
# Clang always needs "no-pie", some distros might add PIE to GCC too.
LDFLAGS+=-fno-pie -no-pie -Wl,-Ttext,0x00D00000
CrashTeamRacingPC: CrashTeamRacingPC.o
all: CrashTeamRacingPC

77
rebuild_PC/PsyCross.nix
View File

@ -1,77 +0,0 @@
{ lib
, stdenv
, pkg-config
, cmake
, SDL2
, openal
, fetchFromGitHub
, psyCrossDebug ? false
}:
let
isWindows = stdenv.hostPlatform.uname.system == "Windows";
openalWithWindows =
if isWindows then
(openal.override {
alsaSupport = false;
dbusSupport = false;
pipewireSupport = false;
pulseSupport = false;
inherit stdenv;
}).overrideAttrs (prevAttrs: {
meta = prevAttrs.meta // { inherit (SDL2.meta) platforms; };
})
else openal.override { inherit stdenv; };
in
stdenv.mkDerivation (finalAttrs: {
pname = "PsyCross";
version = "unstable-2024-02-14-0ce306d6c";
src = fetchFromGitHub {
owner = "OpenDriver2";
repo = "PsyCross";
rev = "0ce306d6c32412986037e7e5e1dbdc1bf72e066a";
hash = "sha256-c57xyzM7GkL9SazUUxAM4DVXxb7cTcjJxgJpZ7UMBVQ=";
};
# Shows the proper compile date in the logs (taken from commit date)
env.SOURCE_DATE_EPOCH = "1712578640";
nativeBuildInputs = [ pkg-config cmake ];
propagatedBuildInputs = [ (SDL2.override { inherit stdenv; }) openalWithWindows ];
hardeningDisable = [ "format" ];
CFLAGS = "-Wno-implicit-function-declaration" + lib.strings.optionalString psyCrossDebug "-D_DEBUG=1 -g -gdwarf-2 -O0";
CXXFLAGS = lib.strings.optionalString psyCrossDebug "-D_DEBUG=1 -g -gdwarf-2 -O0";
dontStrip = psyCrossDebug;
postPatch = ''
substituteInPlace 'include/PsyX/PsyX_config.h' \
--replace-fail 'USE_EXTENDED_PRIM_POINTERS 1' 'USE_EXTENDED_PRIM_POINTERS 0'
'';
installPhase = ''
runHook preInstall
mkdir "$out"
cp -r ../include "$out/include"
cp libpsycross.a "$out/libpsycross.a"
runHook postInstall
'';
passthru = {
inherit SDL2;
openal = openalWithWindows;
};
meta = {
description = "Compatibility framework for building and running Psy-Q SDK";
homepage = "https://github.com/OpenDriver2/PsyCross";
license = lib.licenses.mit;
maintainers = with lib.maintainers; [ pedrohlc ];
inherit (SDL2.meta) platforms;
};
})

21
rebuild_PC/PsyCross/LICENSE
View File

@ -1,21 +0,0 @@
MIT License
Copyright (c) 2020 REDRIVER2 Project
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

39
rebuild_PC/PsyCross/README.md
View File

@ -1,39 +0,0 @@
# Psy-Cross (Psy-X)
![](https://i.ibb.co/PFNnw4G/PsyCross.jpg)
Compatibility framework for building and running Psy-Q SDK - based Playstation games across other platforms
### Implementation details
- High-level *Playstation API* reimplementation which translates it's calls into modern/compatible APIs
- Psy-Q - compatible headers
- Implements Geometry Transformation Engine (GTE) in software and adapts it's macros and calls
- Optimized Precise GTE Vertex Cache with *modern 3D hardware perspective transform* and *Z-buffer* support (PGXP-Z)
- *LibSPU* with ADPCM decoding on OpenAL (SPU-AL)
- *LibGPU* with Playstation-style polygon and image handling
- *LibCD* with ISO 9660 BIN/CUE image support by Playstation CD API
- Already proven to be *95% compatible* with the Psy-Q Playstation SDK - Psy-X game look almost identical to the Playstation game
- You can bring your game to *Web with Emscripten* support
### Folder structure
- `src/gpu`: PSX GPU linked lists and polygon handling routines
- `src/gte`: PSX GTE and PGXP-Z implementation
- `src/render`: OpenGL renderer and PSX VRAM emulation
- `src/pad`: Controller handling
- `src/psx`: Implementations of PsyQ - compatible libraries (**libgte, libgpu, libspu, libcd ...**)
- `include/psx`: Headers of PsyQ - compatible libraries (**libgte, libgpu, libspu, libcd ...**)
- `include/PsyX`: PsyCross interfaces (**window management, configuration, renderer, PGXP-Z**)
### Dependencies
- OpenAL-soft (1.21.x or newer)
- SDL2 (2.0.16 or newer)
## TODO
- CMake dependency/build scripts
- Add some missing **LibGTE** functions
- MDEC implementation in **LibPress**
- CD Audio/XA decoding and playback
- SPU Attack-Decay-Sustain-Release (ADSR) support, *maybe through own mixer?*
### Credits
- SoapyMan - more GTE functions, SPU-AL, PGXP-Z
- Gh0stBlade - original source/base [(link)](https://github.com/TOMB5/TOMB5/tree/master/EMULATOR)

16
rebuild_PC/PsyCross/include/PsyX/PsyX_config.h
View File

@ -1,16 +0,0 @@
#ifndef PSYX_CONFIG_H
#define PSYX_CONFIG_H
// Uses 32 bit pointers on P_TAG and other primitives
// When turned off also disables PGXP
#ifndef USE_EXTENDED_PRIM_POINTERS
#define USE_EXTENDED_PRIM_POINTERS 0
#endif
// PGXP-Z: Precise GTE transform pipeline with Z-depth and widescreen fixes. Recommended for game mode
#ifndef USE_PGXP
#define USE_PGXP USE_EXTENDED_PRIM_POINTERS
#endif
#endif // PSYX_CONFIG_H

35
rebuild_PC/PsyCross/include/PsyX/PsyX_globals.h
View File

@ -1,35 +0,0 @@
#ifndef EMULATOR_GLOBALS_H
#define EMULATOR_GLOBALS_H
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
#define VBLANK_FREQUENCY_NTSC 60
#define VBLANK_FREQUENCY_PAL 50
#define FIXED_TIME_STEP_NTSC (1.0/float(VBLANK_FREQUENCY_NTSC)) // 60 FPS clock
#define FIXED_TIME_STEP_PAL (1.0/float(VBLANK_FREQUENCY_PAL)) // 50 FPS clock
/* runtime states */
extern int g_windowWidth;
extern int g_windowHeight;
extern int g_swapInterval;
/* debug runtime stuff */
extern int g_dbg_emulatorPaused;
extern int g_dbg_wireframeMode;
extern int g_dbg_texturelessMode;
/* Logging functions */
extern void PsyX_Log(const char* fmt, ...);
extern void PsyX_Log_Info(const char* fmt, ...);
extern void PsyX_Log_Warning(const char* fmt, ...);
extern void PsyX_Log_Error(const char* fmt, ...);
extern void PsyX_Log_Success(const char* fmt, ...);
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
#endif

110
rebuild_PC/PsyCross/include/PsyX/PsyX_public.h
View File

@ -1,110 +0,0 @@
#ifndef EMULATOR_PUBLIC_H
#define EMULATOR_PUBLIC_H
#define CONTROLLER_MAP_FLAG_AXIS 0x4000
#define CONTROLLER_MAP_FLAG_INVERSE 0x8000
typedef struct
{
int id;
int kc_square, kc_circle, kc_triangle, kc_cross;
int kc_l1, kc_l2, kc_l3;
int kc_r1, kc_r2, kc_r3;
int kc_start, kc_select;
int kc_dpad_left, kc_dpad_right, kc_dpad_up, kc_dpad_down;
} PsyXKeyboardMapping;
typedef struct
{
int id;
// you can bind axis by adding CONTROLLER_MAP_AXIS_FLAG
int gc_square, gc_circle, gc_triangle, gc_cross;
int gc_l1, gc_l2, gc_l3;
int gc_r1, gc_r2, gc_r3;
int gc_start, gc_select;
int gc_dpad_left, gc_dpad_right, gc_dpad_up, gc_dpad_down;
int gc_axis_left_x, gc_axis_left_y;
int gc_axis_right_x, gc_axis_right_y;
} PsyXControllerMapping;
typedef void(*GameDebugKeysHandlerFunc)(int nKey, char down);
typedef void(*GameDebugMouseHandlerFunc)(int x, int y);
typedef void(*GameOnTextInputHandler)(const char* buf);
//------------------------------------------------------------------------
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
/* Mapped inputs */
extern PsyXControllerMapping g_cfg_controllerMapping;
extern PsyXKeyboardMapping g_cfg_keyboardMapping;
extern int g_cfg_controllerToSlotMapping[2];
/* Game inputs */
extern GameOnTextInputHandler g_cfg_gameOnTextInput;
/* Graphics configuration */
extern int g_cfg_swapInterval;
extern int g_cfg_pgxpZBuffer;
extern int g_cfg_bilinearFiltering;
extern int g_cfg_pgxpTextureCorrection;
/* Debug inputs */
extern GameDebugKeysHandlerFunc g_dbg_gameDebugKeys;
extern GameDebugMouseHandlerFunc g_dbg_gameDebugMouse;
/* Usually called at the beginning of main function */
extern void PsyX_Initialise(char* windowName, int screenWidth, int screenHeight, int fullscreen);
/* Cleans all resources and closes open instances */
extern void PsyX_Shutdown(void);
/* Returns the screen size dimensions */
extern void PsyX_GetScreenSize(int* screenWidth, int* screenHeight);
/* Sets mouse cursor position */
extern void PsyX_SetCursorPosition(int x, int y);
/* Usually called after ClearOTag/ClearOTagR */
extern char PsyX_BeginScene(void);
/* Usually called after DrawOTag/DrawOTagEnv */
extern void PsyX_EndScene(void);
/* Explicitly updates emulator input loop */
extern void PsyX_UpdateInput(void);
/* Returns keyboard mapping index */
extern int PsyX_LookupKeyboardMapping(const char* str, int default_value);
/* Returns controller mapping index */
extern int PsyX_LookupGameControllerMapping(const char* str, int default_value);
/* Screen size of emulated PSX viewport with widescreen offsets */
extern void PsyX_GetPSXWidescreenMappedViewport(struct _RECT16* rect);
/* Waits for timer */
extern void PsyX_WaitForTimestep(int count);
/* Changes swap interval state */
extern void PsyX_EnableSwapInterval(int enable);
/* Changes swap interval interval interval */
extern void PsyX_SetSwapInterval(int interval);
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
#endif

212
rebuild_PC/PsyCross/include/PsyX/PsyX_render.h
View File

@ -1,212 +0,0 @@
#ifndef EMULATOR_H
#define EMULATOR_H
#include "PsyX/PsyX_config.h"
/*
* Platform specific emulator setup
*/
#if (defined(_WIN32) || defined(__APPLE__) || defined(__linux__)) && !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__RPI__)
# define RENDERER_OGL
# define USE_GLAD
#elif defined(__RPI__)
# define RENDERER_OGLES
# define OGLES_VERSION (3)
#elif defined(__EMSCRIPTEN__)
# define RENDERER_OGLES
# define OGLES_VERSION (2)
#elif defined(__ANDROID__)
# define RENDERER_OGLES
# define OGLES_VERSION (3)
#endif
#if defined(RENDERER_OGL) || defined(RENDERER_OGLES)
# define USE_OPENGL 1
#else
# define USE_OPENGL 0
#endif
#if OGLES_VERSION == 2
# define ES2_SHADERS
#elif OGLES_VERSION == 3
# define ES3_SHADERS
#endif
/*
* OpenGL
*/
#if defined (RENDERER_OGL)
# define GL_GLEXT_PROTOTYPES
# include "common/glad.h"
#elif defined (RENDERER_OGLES)
# define GL_GLEXT_PROTOTYPES
# ifdef __EMSCRIPTEN__
# include <GL/gl.h>
# else
# if OGLES_VERSION == 2
# include <GLES2/gl2.h>
# include <GLES2/gl2ext.h>
# elif OGLES_VERSION == 3
# include <GLES3/gl3.h>
# endif
# endif
# include <EGL/egl.h>
#endif
// setup renderer texture formats
#if defined(RENDERER_OGL)
# define TEXTURE_FORMAT GL_UNSIGNED_SHORT_1_5_5_5_REV
#elif defined(RENDERER_OGLES)
# define TEXTURE_FORMAT GL_UNSIGNED_SHORT_5_5_5_1
#endif
#include "psx/types.h"
#include "common/pgxp_defs.h"
#include "psx/libgte.h"
#include "psx/libgpu.h"
#include <stdio.h>
#include <stddef.h>
#ifndef NULL
#define NULL 0
#endif
/*
// FIXME: enable when needed
#if defined(RENDERER_OGLES)
# define glGenVertexArrays glGenVertexArraysOES
# define glBindVertexArray glBindVertexArrayOES
# define glDeleteVertexArrays glDeleteVertexArraysOES
#endif
*/
#if defined(RENDERER_OGL)
# define VRAM_FORMAT GL_RG
# define VRAM_INTERNAL_FORMAT GL_RG32F
#elif defined(RENDERER_OGLES)
# define VRAM_FORMAT GL_LUMINANCE_ALPHA
# define VRAM_INTERNAL_FORMAT GL_LUMINANCE_ALPHA
#endif
#define VRAM_WIDTH (1024)
#define VRAM_HEIGHT (512)
#define TPAGE_WIDTH (256)
#define TPAGE_HEIGHT (256)
#define MAX_VERTEX_BUFFER_SIZE (1 << (sizeof(ushort) * 8))
#pragma pack(push,1)
typedef struct
{
#if USE_PGXP
float x, y, page, clut;
float z, scr_h, ofsX, ofsY;
#else
short x, y, page, clut;
#endif
u_char u, v, bright, dither;
u_char r, g, b, a;
char tcx, tcy, _p0, _p1;
} GrVertex;
#pragma pack(pop)
typedef enum
{
a_position,
a_zw,
a_texcoord,
a_color,
a_extra,
} ShaderAttrib;
typedef enum
{
BM_NONE,
BM_AVERAGE,
BM_ADD,
BM_SUBTRACT,
BM_ADD_QUATER_SOURCE
} BlendMode;
typedef enum
{
TF_4_BIT,
TF_8_BIT,
TF_16_BIT,
TF_32_BIT_RGBA // custom texture
} TexFormat;
#if defined(RENDERER_OGLES) || defined(RENDERER_OGL)
typedef uint TextureID;
typedef uint ShaderID;
#else
#error
#endif
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
extern TextureID g_whiteTexture;
extern TextureID g_vramTexture;
extern void GR_SwapWindow();
// PSX VRAM operations
extern void GR_SaveVRAM(const char* outputFileName, int x, int y, int width, int height, int bReadFromFrameBuffer);
extern void GR_CopyVRAM(unsigned short* src, int x, int y, int w, int h, int dst_x, int dst_y);
extern void GR_ReadVRAM(unsigned short* dst, int x, int y, int dst_w, int dst_h);
extern void GR_StoreFrameBuffer(int x, int y, int w, int h);
extern void GR_UpdateVRAM();
extern void GR_ReadFramebufferDataToVRAM();
extern TextureID GR_CreateRGBATexture(int width, int height, u_char* data /*= nullptr*/);
extern ShaderID GR_Shader_Compile(const char* source);
extern void GR_SetShader(const ShaderID shader);
extern void GR_Perspective3D(const float fov, const float width, const float height, const float zNear, const float zFar);
extern void GR_Ortho2D(float left, float right, float bottom, float top, float znear, float zfar);
extern void GR_SetBlendMode(BlendMode blendMode);
extern void GR_SetPolygonOffset(float ofs);
extern void GR_SetStencilMode(int drawPrim);
extern void GR_EnableDepth(int enable);
extern void GR_SetScissorState(int enable);
extern void GR_SetOffscreenState(const RECT16* offscreenRect, int enable);
extern void GR_SetupClipMode(const RECT16* clipRect, int enable);
extern void GR_SetViewPort(int x, int y, int width, int height);
extern void GR_SetTexture(TextureID texture, TexFormat texFormat);
extern void GR_SetOverrideTextureSize(int width, int height);
extern void GR_SetWireframe(int enable);
extern void GR_DestroyTexture(TextureID texture);
extern void GR_Clear(int x, int y, int w, int h, unsigned char r, unsigned char g, unsigned char b);
extern void GR_ClearVRAM(int x, int y, int w, int h, unsigned char r, unsigned char g, unsigned char b);
extern void GR_UpdateVertexBuffer(const GrVertex* vertices, int count);
extern void GR_DrawTriangles(int start_vertex, int triangles);
extern void GR_PushDebugLabel(const char* label);
extern void GR_PopDebugLabel();
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
#endif

16
rebuild_PC/PsyCross/include/PsyX/PsyX_version.h
View File

@ -1,16 +0,0 @@
#ifndef PSYX_VERSION_H
#define PSYX_VERSION_H
/* Emulator version */
#define PSYX_MAJOR_VERSION (2)
#define PSYX_MINOR_VERSION (8)
/* Compile date and time */
#define PSYX_COMPILE_DATE (__DATE__)
#define PSYX_COMPILE_TIME (__TIME__)
/* Psy-Q version */
#define PSYQ_MAJOR_VERSION (4)
#define PSYQ_MINOR_VERSION (7)
#endif

3538
rebuild_PC/PsyCross/include/PsyX/common/glad.h
View File

File diff suppressed because it is too large Load Diff

36
rebuild_PC/PsyCross/include/PsyX/common/half_float.h
View File

@ -1,36 +0,0 @@
#ifndef HALF_FLOAT
#define HALF_FLOAT
typedef struct half
{
unsigned short sh;
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
half() {};
half(const float x);
half(const half& other);
operator float() const;
half& operator=(const half& other)
{
sh = other.sh;
return *this;
}
#endif
} half;
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
extern short to_half_float(const float x);
extern float from_half_float(const short x);
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
#endif // HALF_FLOAT

78
rebuild_PC/PsyCross/include/PsyX/common/pgxp_defs.h
View File

@ -1,78 +0,0 @@
#ifndef PGXP_DEFS_H
#define PGXP_DEFS_H
#include "PsyX/PsyX_config.h"
#if USE_PGXP
#include "PsyX/common/half_float.h"
// Helpful macro
#define PGXP_LOOKUP_VALUE(x, y) (*(u_short*)&(x) | (*(u_short*)&(y) << 16))
//-------------------------------------
// in C++, VERTTYPE can be declared as half
// use `_HF` to convert to half whenever you in C mode.
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
typedef half VERTTYPE;
#define _HF(x) x
#else
typedef short VERTTYPE;
#define _HF(x) to_half_float(x)
#endif
typedef struct
{
float px, py, pz; // 32 bit values
VERTTYPE x, y, z; // 16 bit values (for lookup and backwards compat if not found in cache)
} PGXPVector3D;
typedef struct
{
uint lookup;
float px, py, pz;
float scr_h, ofx, ofy;
} PGXPVData;
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
extern PGXPVector3D g_FP_SXYZ0; // direct access PGXP without table lookup
extern PGXPVector3D g_FP_SXYZ1;
extern PGXPVector3D g_FP_SXYZ2;
/* clears PGXP vertex buffer */
void PGXP_ClearCache();
/* emits new PGXP vertex */
ushort PGXP_EmitCacheData(PGXPVData* newData);
/* sets Z offset (works like Z bias) */
void PGXP_SetZOffsetScale(float offset, float scale);
/* searches for vertex with given lookup value */
int PGXP_GetCacheData(PGXPVData* out, uint lookup, ushort indexhint /* = 0xFFFF */);
/* used by primitive setup */
ushort PGXP_GetIndex(int checkTransform);
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
// special PGXP type
typedef struct { /* 2D short vector */
half vx, vy;
ushort pgxp_index;
} DVECTORF;
#else
typedef short VERTTYPE;
#define _HF(x) x
#endif
#endif // PGXP_DEFS

30
rebuild_PC/PsyCross/include/PsyX/util/timer.h
View File

@ -1,30 +0,0 @@
#ifndef UTIL_TIMER_H
#define UTIL_TIMER_H
#ifdef _WIN32
#include <stdint.h>
#else
#include <sys/time.h>
#endif
typedef struct
{
#ifdef _WIN32
uint64_t clockStart;
#else
struct timeval timeStart;
#endif // _WIN32
} timerCtx_t;
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
extern void Util_InitHPCTimer(timerCtx_t* timer);
extern double Util_GetHPCTime(timerCtx_t* timer, int reset /*= 0*/);
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
#endif

18
rebuild_PC/PsyCross/include/psx/abs.h
View File

@ -1,18 +0,0 @@
#ifndef ABS_H
#define ABS_H
#ifndef ABS
#define ABS(x) fst_abs(x)
#endif
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
extern int fst_abs(int x);
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
#endif

12
rebuild_PC/PsyCross/include/psx/asm.h
View File

@ -1,12 +0,0 @@
#ifndef ASM_H
#define ASM_H
/*
This header must be empty
*/
#define NREGS 40
#endif

360
rebuild_PC/PsyCross/include/psx/gtemac.h
View File

@ -1,360 +0,0 @@
#ifndef GTEMAC_H
#define GTEMAC_H
/*
* GTE inline functions(Simple)
*/
#define gte_RotTransPers(r1,r2,r3,r4,r5) \
{ gte_ldv0(r1); \
gte_rtps(); \
gte_stsxy(r2); \
gte_stdp(r3); \
gte_stflg(r4); \
gte_stszotz(r5); }
#define gte_RotTransPers3(r1,r2,r3,r4,r5,r6,r7,r8,r9) \
{ gte_ldv3(r1,r2,r3); \
gte_rtpt(); \
gte_stsxy3(r4,r5,r6); \
gte_stdp(r7); \
gte_stflg(r8); \
gte_stszotz(r9); }
#define gte_RotTrans(r1,r2,r3) \
{ gte_ldv0(r1); \
gte_rt(); \
gte_stlvnl(r2); \
gte_stflg(r3); }
#define gte_LocalLight(r1,r2) \
{ gte_ldv0(r1); \
gte_ll(); \
gte_stlvl(r2); }
#define gte_LightColor(r1,r2) \
{ gte_ldlvl(r1); \
gte_lc(); \
gte_stlvl(r2); }
#define gte_DpqColorLight(r1,r2,r3,r4) \
{ gte_ldlvl(r1); \
gte_ldrgb(r2); \
gte_lddp(r3); \
gte_dpcl(); \
gte_strgb(r4); }
#define gte_DpqColor(r1,r2,r3) \
{ gte_ldrgb(r1); \
gte_lddp(r2); \
gte_dpcs(); \
gte_strgb(r3); }
#define gte_DpqColor3(r1,r2,r3,r4,r5,r6,r7) \
{ gte_ldrgb3(r1,r2,r3); \
gte_lddp(r4); \
gte_dpct(); \
gte_strgb3(r5,r6,r7); }
#define gte_Intpl(r1,r2,r3) \
{ gte_ldlvl(r1); \
gte_lddp(r2); \
gte_intpl(); \
gte_strgb(r3); }
#define gte_Square12(r1,r2) \
{ gte_ldlvl(r1); \
gte_sqr12(); \
gte_stlvnl(r2); }
#define gte_Square0(r1,r2) \
{ gte_ldlvl(r1); \
gte_sqr0(); \
gte_stlvnl(r2); }
#define gte_NormalColor(r1,r2) \
{ gte_ldv0(r1); \
gte_ncs(); \
gte_strgb(r2); }
#define gte_NormalColor3(r1,r2,r3,r4,r5,r6) \
{ gte_ldv3(r1,r2,r3); \
gte_nct(); \
gte_strgb3(r4,r5,r6); }
#define gte_NormalColorDpq(r1,r2,r3,r4) \
{ gte_ldv0(r1); \
gte_ldrgb(r2); \
gte_lddp(r3); \
gte_ncds(); \
gte_strgb(r4); }
#define gte_NormalColorDpq3(r1,r2,r3,r4,r5,r6,r7,r8) \
{ gte_ldv3(r1,r2,r3); \
gte_ldrgb(r4); \
gte_lddp(r5); \
gte_ncdt(); \
gte_strgb3(r6,r7,r8); }
#define gte_NormalColorCol(r1,r2,r3) \
{ gte_ldv0(r1); \
gte_ldrgb(r2); \
gte_nccs(); \
gte_strgb(r3); }
#define gte_NormalColorCol3(r1,r2,r3,r4,r5,r6,r7) \
{ gte_ldv3(r1,r2,r3); \
gte_ldrgb(r4); \
gte_ncct(); \
gte_strgb3(r5,r6,r7); }
#define gte_ColorDpq(r1,r2,r3,r4) \
{ gte_ldlvl(r1); \
gte_ldrgb(r2); \
gte_lddp(r3); \
gte_cdp(); \
gte_strgb(r4); }
#define gte_ColorCol(r1,r2,r3) \
{ gte_ldlvl(r1); \
gte_ldrgb(r2); \
gte_cc(); \
gte_strgb(r3); }
#define gte_NormalClip(r1,r2,r3,r4) \
{ gte_ldsxy3(r1,r2,r3); \
gte_nclip(); \
gte_stopz(r4); }
#define gte_AverageZ3(r1,r2,r3,r4) \
{ gte_ldsz3(r1,r2,r3); \
gte_avsz3(); \
gte_stotz(r4); }
#define gte_AverageZ4(r1,r2,r3,r4,r5) \
{ gte_ldsz4(r1,r2,r3,r4); \
gte_avsz4(); \
gte_stotz(r5); }
#define gte_OuterProduct12(r1,r2,r3) \
{ gte_ldopv1(r1); \
gte_ldopv2(r2); \
gte_op12(); \
gte_stlvnl(r3); }
#define gte_OuterProduct0(r1,r2,r3) \
{ gte_ldopv1(r1); \
gte_ldopv2(r2); \
gte_op0(); \
gte_stlvnl(r3); }
#define gte_OuterProduct12SVL(r1,r2,r3) \
{ gte_ldopv1SV(r1); \
gte_ldopv2SV(r2); \
gte_op12(); \
gte_stlvnl(r3); }
#define gte_OuterProduct0SVL(r1,r2,r3) \
{ gte_ldopv1SV(r1); \
gte_ldopv2SV(r2); \
gte_op0(); \
gte_stlvnl(r3); }
#define gte_OuterProduct12SV(r1,r2,r3) \
{ gte_ldopv1SV(r1); \
gte_ldopv2SV(r2); \
gte_op12(); \
gte_stsv(r3); }
#define gte_OuterProduct0SV(r1,r2,r3) \
{ gte_ldopv1SV(r1); \
gte_ldopv2SV(r2); \
gte_op0(); \
gte_stsv(r3); }
#define gte_Lzc(r1,r2) \
{ gte_ldlzc(r1); \
gte_nop(); \
gte_nop(); \
gte_stlzc(r2); }
/*
* GTE inline functions(Combination)
* 4 vertices functions can't be replaced by equivalent macros
* because they use OR of flags after rtpt & rtps
* Please write directry in your program.
*/
#define gte_RotAverage3(r1,r2,r3,r4,r5,r6,r7,r8,r9) \
{ gte_ldv3(r1,r2,r3); \
gte_rtpt(); \
gte_stsxy3(r4,r5,r6); \
gte_stdp(r7); \
gte_stflg(r8); \
gte_avsz3(); \
gte_stotz(r9); }
#define gte_RotNclip3(r1,r2,r3,r4,r5,r6,r7,r8,r9,r10) \
{ gte_ldv3(r1,r2,r3); \
gte_rtpt(); \
gte_stflg(r9); \
gte_nclip(); \
gte_stopz(r10); \
gte_stsxy3(r4,r5,r6); \
gte_stdp(r7); \
gte_stszotz(r8); }
#define gte_RotAverageNclip3(r1,r2,r3,r4,r5,r6,r7,r8,r9,r10) \
{ gte_ldv3(r1,r2,r3); \
gte_rtpt(); \
gte_stflg(r9); \
gte_nclip(); \
gte_stopz(r10); \
gte_stsxy3(r4,r5,r6); \
gte_stdp(r7); \
gte_avsz3(); \
gte_stotz(r8); }
#define gte_RotColorDpq(r1,r2,r3,r4,r5,r6,r7) \
{ gte_ldv0(r1); \
gte_rtps(); \
gte_stsxy(r4); \
gte_stflg(r6); \
gte_ldv0(r2); \
gte_ldrgb(r3); \
gte_ncds(); \
gte_strgb(r5); \
gte_stszotz(r7); }
#define gte_RotColorDpq3(r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15) \
{ gte_ldv3(r1,r2,r3); \
gte_rtpt(); \
gte_stsxy3(r8,r9,r10); \
gte_stflg(r14); \
gte_ldv3(r4,r5,r6); \
gte_ldrgb(r7); \
gte_ncdt(); \
gte_strgb3(r11,r12,r13);\
gte_stszotz(r15); }
#define gte_RotAverageNclipColorDpq3(r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16) \
{ gte_ldv3(r1,r2,r3); \
gte_rtpt(); \
gte_stflg(r15); \
gte_nclip(); \
gte_stopz(r16); \
gte_ldv3(r4,r5,r6); \
gte_ldrgb(r7); \
gte_ncdt(); \
gte_stsxy3(r8,r9,r10); \
gte_strgb3(r11,r12,r13);\
gte_avsz3(); \
gte_stotz(r14); }
#define gte_RotAverageNclipColorCol3(r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16) \
{ gte_ldv3(r1,r2,r3); \
gte_rtpt(); \
gte_stflg(r15); \
gte_nclip(); \
gte_stopz(r16); \
gte_ldv3(r4,r5,r6); \
gte_ldrgb(r7); \
gte_ncct(); \
gte_stsxy3(r8,r9,r10); \
gte_strgb3(r11,r12,r13);\
gte_avsz3(); \
gte_stotz(r14); }
#define gte_LoadAverage12(r1,r2,r3,r4,r5) \
{ gte_lddp(r3); \
gte_ldlvl(r1); \
gte_gpf12(); \
gte_lddp(r4); \
gte_ldlvl(r2); \
gte_gpl12(); \
gte_stlvl(r5); }
#define gte_LoadAverage0(r1,r2,r3,r4,r5) \
{ gte_lddp(r3); \
gte_ldlvl(r1); \
gte_gpf0(); \
gte_lddp(r4); \
gte_ldlvl(r2); \
gte_gpl0(); \
gte_stlvl(r5); }
#define gte_LoadAverageShort12(r1,r2,r3,r4,r5) \
{ gte_lddp(r3); \
gte_ldsv(r1); \
gte_gpf12(); \
gte_lddp(r4); \
gte_ldsv(r2); \
gte_gpl12(); \
gte_stsv(r5); }
#define gte_LoadAverageShort0(r1,r2,r3,r4,r5) \
{ gte_lddp(r3); \
gte_ldsv(r1); \
gte_gpf0(); \
gte_lddp(r4); \
gte_ldsv(r2); \
gte_gpl0(); \
gte_stsv(r5); }
#define gte_LoadAverageByte(r1,r2,r3,r4,r5) \
{ gte_lddp(r3); \
gte_ldbv(r1); \
gte_gpf12(); \
gte_lddp(r4); \
gte_ldbv(r2); \
gte_gpl12(); \
gte_stbv(r5); }
#define gte_LoadAverageCol(r1,r2,r3,r4,r5) \
{ gte_lddp(r3); \
gte_ldcv(r1); \
gte_gpf12(); \
gte_lddp(r4); \
gte_ldcv(r2); \
gte_gpl12(); \
gte_stcv(r5); }
/*
*
*/
#define gte_MulMatrix0(r1,r2,r3) \
{ gte_SetRotMatrix(r1); \
gte_ldclmv(r2); \
gte_rtir(); \
gte_stclmv(r3); \
gte_ldclmv((char*)r2+2);\
gte_rtir(); \
gte_stclmv((char*)r3+2);\
gte_ldclmv((char*)r2+4);\
gte_rtir(); \
gte_stclmv((char*)r3+4); }
#define gte_ApplyMatrix(r1,r2,r3) \
{ gte_SetRotMatrix(r1); \
gte_ldv0(r2); \
gte_rtv0(); \
gte_stlvnl(r3); }
#define gte_ApplyMatrixSV(r1,r2,r3) \
{ gte_SetRotMatrix(r1); \
gte_ldv0(r2); \
gte_rtv0(); \
gte_stsv(r3); }
#define gte_CompMatrix(r1,r2,r3) \
{ gte_MulMatrix0(r1,r2,r3);\
gte_SetTransMatrix(r1); \
gte_ldlv0((char*)r2+20);\
gte_rt(); \
gte_stlvnl((char*)r3+20); }
#define gte_ApplyRotMatrix(r1,r2) \
{ gte_ldv0(r1); \
gte_rtv0(); \
gte_stlvnl(r2); }
#endif

222
rebuild_PC/PsyCross/include/psx/gtereg.h
View File

@ -1,222 +0,0 @@
#ifndef GTEREG_H
#define GTEREG_H
#ifdef Status
// Fix for stupid GLES headers in RPI or MESA, whatever... just get rid of this dumb shit
#undef Status
#endif
typedef union
{
struct { unsigned char l, h, h2, h3; } b;
struct { unsigned short l, h; } w;
struct { char l, h, h2, h3; } sb;
struct { short l, h; } sw;
unsigned int d;
int sd;
} PAIR;
typedef struct {
unsigned char r, g, b, c;
} CBGR;
typedef struct {
short x, y, z, pad;
} SVector3D;
typedef struct {
short x, y;
} SVector2D;
typedef struct {
short z, pad;
} SVector2Dz;
typedef struct {
short m11, m12, m13, m21, m22, m23, m31, m32, m33, pad;
} SMatrix3D;
typedef union
{
struct
{
SVector3D v0, v1, v2;
CBGR rgb;
int otz;
int ir0, ir1, ir2, ir3;
SVector2D sxy0, sxy1, sxy2, sxyp;
SVector2Dz sz0, sz1, sz2, sz3;
CBGR rgb0, rgb1, rgb2;
int reserved;
int mac0, mac1, mac2, mac3;
unsigned int irgb, orgb;
int lzcs, lzcr;
} n;
unsigned int r[32];
PAIR p[32];
} psxCP2Data;
typedef union
{
struct {
SMatrix3D rMatrix;
int trX, trY, trZ;
SMatrix3D lMatrix;
int rbk, gbk, bbk;
SMatrix3D cMatrix;
int rfc, gfc, bfc;
int ofx, ofy;
int h;
int dqa, dqb;
int zsf3, zsf4;
int flag;
} n;
unsigned int r[32];
PAIR p[32];
} psxCP2Ctrl;
typedef union {
struct {
unsigned int Index, Random, EntryLo0, BPC,
Context, BDA, PIDMask, DCIC,
BadVAddr, BDAM, EntryHi, BPCM,
Status, Cause, EPC, PRid,
Config, LLAddr, WatchLO, WatchHI,
XContext, Reserved1, Reserved2, Reserved3,
Reserved4, Reserved5, ECC, CacheErr,
TagLo, TagHi, ErrorEPC, Reserved6;
} n;
unsigned int r[32];
} psxCP0Regs;
typedef struct
{
psxCP0Regs CP0; /* Coprocessor0 Registers */
psxCP2Data CP2D; /* Cop2 data registers */
psxCP2Ctrl CP2C; /* Cop2 control registers */
} GTERegisters;
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
extern GTERegisters gteRegs;
extern int GTE_operator(int);
extern int LIM(int value, int max, int min, unsigned int flag);
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
/* Data Registers mtc2 mfc2 */
#define C2_VX0 (gteRegs.CP2D.p[ 0 ].sw.l)
#define C2_VY0 (gteRegs.CP2D.p[ 0 ].sw.h)
#define C2_VZ0 (gteRegs.CP2D.p[ 1 ].sw.l)
#define C2_VX1 (gteRegs.CP2D.p[ 2 ].w.l)
#define C2_VY1 (gteRegs.CP2D.p[ 2 ].w.h)
#define C2_VZ1 (gteRegs.CP2D.p[ 3 ].w.l)
#define C2_VX2 (gteRegs.CP2D.p[ 4 ].w.l)
#define C2_VY2 (gteRegs.CP2D.p[ 4 ].w.h)
#define C2_VZ2 (gteRegs.CP2D.p[ 5 ].w.l)
#define C2_R (gteRegs.CP2D.p[ 6 ].b.l)
#define C2_G (gteRegs.CP2D.p[ 6 ].b.h)
#define C2_B (gteRegs.CP2D.p[ 6 ].b.h2)
#define C2_CODE (gteRegs.CP2D.p[ 6 ].b.h3)
#define C2_OTZ (gteRegs.CP2D.p[ 7 ].w.l)
#define C2_IR0 (gteRegs.CP2D.p[ 8 ].sw.l)
#define C2_IR1 (gteRegs.CP2D.p[ 9 ].sw.l)
#define C2_IR2 (gteRegs.CP2D.p[ 10 ].sw.l)
#define C2_IR3 (gteRegs.CP2D.p[ 11 ].sw.l)
#define C2_SXY0 (gteRegs.CP2D.p[ 12 ].d)
#define C2_SX0 (gteRegs.CP2D.p[ 12 ].sw.l)
#define C2_SY0 (gteRegs.CP2D.p[ 12 ].sw.h)
#define C2_SXY1 (gteRegs.CP2D.p[ 13 ].d)
#define C2_SX1 (gteRegs.CP2D.p[ 13 ].sw.l)
#define C2_SY1 (gteRegs.CP2D.p[ 13 ].sw.h)
#define C2_SXY2 (gteRegs.CP2D.p[ 14 ].d)
#define C2_SX2 (gteRegs.CP2D.p[ 14 ].sw.l)
#define C2_SY2 (gteRegs.CP2D.p[ 14 ].sw.h)
#define C2_SXYP (gteRegs.CP2D.p[ 15 ].d)
#define C2_SXP (gteRegs.CP2D.p[ 15 ].sw.l)
#define C2_SYP (gteRegs.CP2D.p[ 15 ].sw.h)
#define C2_SZ0 (gteRegs.CP2D.p[ 16 ].w.l)
#define C2_SZ1 (gteRegs.CP2D.p[ 17 ].w.l)
#define C2_SZ2 (gteRegs.CP2D.p[ 18 ].w.l)
#define C2_SZ3 (gteRegs.CP2D.p[ 19 ].w.l)
#define C2_RGB0 (gteRegs.CP2D.p[ 20 ].d)
#define C2_R0 (gteRegs.CP2D.p[ 20 ].b.l)
#define C2_G0 (gteRegs.CP2D.p[ 20 ].b.h)
#define C2_B0 (gteRegs.CP2D.p[ 20 ].b.h2)
#define C2_CD0 (gteRegs.CP2D.p[ 20 ].b.h3)
#define C2_RGB1 (gteRegs.CP2D.p[ 21 ].d)
#define C2_R1 (gteRegs.CP2D.p[ 21 ].b.l)
#define C2_G1 (gteRegs.CP2D.p[ 21 ].b.h)
#define C2_B1 (gteRegs.CP2D.p[ 21 ].b.h2)
#define C2_CD1 (gteRegs.CP2D.p[ 21 ].b.h3)
#define C2_RGB2 (gteRegs.CP2D.p[ 22 ].d)
#define C2_R2 (gteRegs.CP2D.p[ 22 ].b.l)
#define C2_G2 (gteRegs.CP2D.p[ 22 ].b.h)
#define C2_B2 (gteRegs.CP2D.p[ 22 ].b.h2)
#define C2_CD2 (gteRegs.CP2D.p[ 22 ].b.h3)
#define C2_RES1 (gteRegs.CP2D.p[ 23 ].d)
#define C2_MAC0 (gteRegs.CP2D.p[ 24 ].sd)
#define C2_MAC1 (gteRegs.CP2D.p[ 25 ].sd)
#define C2_MAC2 (gteRegs.CP2D.p[ 26 ].sd)
#define C2_MAC3 (gteRegs.CP2D.p[ 27 ].sd)
#define C2_IRGB (gteRegs.CP2D.p[ 28 ].d)
#define C2_ORGB (gteRegs.CP2D.p[ 29 ].d)
#define C2_LZCS (gteRegs.CP2D.p[ 30 ].d)
#define C2_LZCR (gteRegs.CP2D.p[ 31 ].d)
/* Control Registers ctc2 cfc2*/
#define C2_R11 (gteRegs.CP2C.p[ 0 ].sw.l)
#define C2_R12 (gteRegs.CP2C.p[ 0 ].sw.h)
#define C2_R13 (gteRegs.CP2C.p[ 1 ].sw.l)
#define C2_R21 (gteRegs.CP2C.p[ 1 ].sw.h)
#define C2_R22 (gteRegs.CP2C.p[ 2 ].sw.l)
#define C2_R23 (gteRegs.CP2C.p[ 2 ].sw.h)
#define C2_R31 (gteRegs.CP2C.p[ 3 ].sw.l)
#define C2_R32 (gteRegs.CP2C.p[ 3 ].sw.h)
#define C2_R33 (gteRegs.CP2C.p[ 4 ].sw.l)
#define C2_TRX (gteRegs.CP2C.p[ 5 ].sd)
#define C2_TRY (gteRegs.CP2C.p[ 6 ].sd)
#define C2_TRZ (gteRegs.CP2C.p[ 7 ].sd)
#define C2_L11 (gteRegs.CP2C.p[ 8 ].sw.l)
#define C2_L12 (gteRegs.CP2C.p[ 8 ].sw.h)
#define C2_L13 (gteRegs.CP2C.p[ 9 ].sw.l)
#define C2_L21 (gteRegs.CP2C.p[ 9 ].sw.h)
#define C2_L22 (gteRegs.CP2C.p[ 10 ].sw.l)
#define C2_L23 (gteRegs.CP2C.p[ 10 ].sw.h)
#define C2_L31 (gteRegs.CP2C.p[ 11 ].sw.l)
#define C2_L32 (gteRegs.CP2C.p[ 11 ].sw.h)
#define C2_L33 (gteRegs.CP2C.p[ 12 ].sw.l)
#define C2_RBK (gteRegs.CP2C.p[ 13 ].sd)
#define C2_GBK (gteRegs.CP2C.p[ 14 ].sd)
#define C2_BBK (gteRegs.CP2C.p[ 15 ].sd)
#define C2_LR1 (gteRegs.CP2C.p[ 16 ].sw.l)
#define C2_LR2 (gteRegs.CP2C.p[ 16 ].sw.h)
#define C2_LR3 (gteRegs.CP2C.p[ 17 ].sw.l)
#define C2_LG1 (gteRegs.CP2C.p[ 17 ].sw.h)
#define C2_LG2 (gteRegs.CP2C.p[ 18 ].sw.l)
#define C2_LG3 (gteRegs.CP2C.p[ 18 ].sw.h)
#define C2_LB1 (gteRegs.CP2C.p[ 19 ].sw.l)
#define C2_LB2 (gteRegs.CP2C.p[ 19 ].sw.h)
#define C2_LB3 (gteRegs.CP2C.p[ 20 ].sw.l)
#define C2_RFC (gteRegs.CP2C.p[ 21 ].sd)
#define C2_GFC (gteRegs.CP2C.p[ 22 ].sd)
#define C2_BFC (gteRegs.CP2C.p[ 23 ].sd)
#define C2_OFX (gteRegs.CP2C.p[ 24 ].sd)
#define C2_OFY (gteRegs.CP2C.p[ 25 ].sd)
#define C2_H (gteRegs.CP2C.p[ 26 ].sw.l)
#define C2_DQA (gteRegs.CP2C.p[ 27 ].sw.l)
#define C2_DQB (gteRegs.CP2C.p[ 28 ].sd)
#define C2_ZSF3 (gteRegs.CP2C.p[ 29 ].sw.l)
#define C2_ZSF4 (gteRegs.CP2C.p[ 30 ].sw.l)
#define C2_FLAG (gteRegs.CP2C.p[ 31 ].d)
#endif

719
rebuild_PC/PsyCross/include/psx/inline_c.h
View File

@ -1,719 +0,0 @@
#ifndef INLINE_C_H
#define INLINE_C_H
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
/* Psy-X specific calls */
/* sets cop2 data register value. LWC2 is the same kind*/
extern void MTC2(unsigned int value, int reg);
extern void MTC2_S(int value, int reg);
/* sets cop2 control register value */
extern void CTC2(unsigned int value, int reg);
extern void CTC2_S(int value, int reg);
/* returns cop2 register value. SWC2 is the same kind */
extern unsigned int MFC2(int reg);
extern int MFC2_S(int reg);
/* returns cop2 control register value */
extern unsigned int CFC2(int reg);
extern int CFC2_S(int reg);
/* performs cop2 opcode */
extern int doCOP2(int op);
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
/*
* Type 1 functions
*/
// ctc2 21-23
#define gte_ldfc( r0 ) \
{ CTC2(*(uint*)((char*)(r0)+0), 21);\
CTC2(*(uint*)((char*)(r0)+4), 22);\
CTC2(*(uint*)((char*)(r0)+8), 23);}
// mtc2 0-1
#define gte_ldv0( r0 )\
{ MTC2(*(uint*)((char*)(r0)+0), 0);\
MTC2(*(uint*)((char*)(r0)+4), 1);}
// mtc2 2-3
#define gte_ldv1( r0 )\
{ MTC2(*(uint*)((char*)(r0)+0), 2);\
MTC2(*(uint*)((char*)(r0)+4), 3);}
// mtc2 4-5
#define gte_ldv2( r0 )\
{ MTC2(*(uint*)((char*)(r0)+0), 4);\
MTC2(*(uint*)((char*)(r0)+4), 5);}
// mtc2 0-5
#define gte_ldv3( r0, r1, r2 ) \
{ MTC2(*(uint*)((char*)(r0)+0), 0);\
MTC2(*(uint*)((char*)(r0)+4), 1);\
MTC2(*(uint*)((char*)(r1)+0), 2);\
MTC2(*(uint*)((char*)(r1)+4), 3);\
MTC2(*(uint*)((char*)(r2)+0), 4);\
MTC2(*(uint*)((char*)(r2)+4), 5);}
// load mtc2 9,10,11
#define gte_ldclmv( r0 ) \
{ MTC2(*(ushort*)((char*)(r0)), 9); \
MTC2(*(ushort*)((char*)(r0)+6), 10); \
MTC2(*(ushort*)((char*)(r0)+12), 11); }
// lwc2 9-11
#define gte_ldlvl( r0 ) \
{ MTC2(*(uint*)((char*)(r0)), 9); \
MTC2(*(uint*)((char*)(r0)+4), 10);\
MTC2(*(uint*)((char*)(r0)+8), 11);}
// mtc2 9,10,11
#define gte_ldsv( r0 ) \
{ MTC2(*(ushort*)((char*)(r0)), 9);\
MTC2(*(ushort*)((char*)(r0)+2), 10);\
MTC2(*(ushort*)((char*)(r0)+4), 11); }
// mtc2 9,10
#define gte_ldbv( r0 ) \
{ MTC2(*((char*)(r0)), 9);\
MTC2(*((char*)(r0)+1), 10); }
// mtc2 9,10,11
#define gte_ldcv( r0 ) \
{ MTC2(*((char*)(r0)), 9);\
MTC2(*((char*)(r0)+1), 10);\
MTC2(*((char*)(r0)+2), 11); }
// lwc2 6
#define gte_ldrgb( r0 ) \
{ MTC2(*(uint*)((char*)(r0)), 6); }
// lwc2 6,20,21,22
#define gte_ldrgb3( r0, r1, r2 ) \
{ MTC2(*(uint*)((char*)(r0)), 20); \
MTC2(*(uint*)((char*)(r1)), 21); \
MTC2(*(uint*)((char*)(r2)), 22); \
MTC2(*(uint*)((char*)(r2)), 6); }
// mtc2 0, lwc2 1
#define gte_ldlv0( r0 ) \
{ MTC2((*(ushort*)((char*)(r0)+4) << 16) | *(ushort*)((char*)(r0)));\
MTC2(*(ushort*)((char*)(r0)+8) << 16); }
// mtc2 8
#define gte_lddp( r0 ) \
{ MTC2(*(uint*)(r0), 8); }
// ctc2 13 14 15
#define gte_ldbkdir( r0, r1, r2 ) \
{ CTC2(r0, 13); \
CTC2(r1, 14); \
CTC2(r2, 15); }
// mtc2 12,13,14
#define gte_ldsxy3( r0, r1, r2 )\
{ MTC2(*(uint*)(r0), 12); \
MTC2(*(uint*)(r2), 14); \
MTC2(*(uint*)(r1), 13); }
// mtc2 12,13,14
#define gte_ldsxy3c( r0 ) \
{ MTC2(*(uint*)((char*)(r0)+0), 12 ); \
MTC2(*(uint*)((char*)(r0)+4), 13 ); \
MTC2(*(uint*)((char*)(r0)+8), 14 ); }
// mtc2 17,18,19
#define gte_ldsz3( r0, r1, r2 ) \
{ MTC2(*(uint*)((char*)(r0)), 17 ); \
MTC2(*(uint*)((char*)(r1)), 18 ); \
MTC2(*(uint*)((char*)(r2)), 19 ); }
// mtc2 16,17,18,19
#define gte_ldsz4( r0, r1, r2, r3 ) \
{ MTC2(*(uint*)((char*)(r0)), 16 ); \
MTC2(*(uint*)((char*)(r1)), 17 ); \
MTC2(*(uint*)((char*)(r2)), 18 ); \
MTC2(*(uint*)((char*)(r3)), 19 ); }
// ctc2 0,2,4
#define gte_ldopv1( r0 ) \
{ CTC2(*(uint*)((char*)(r0)), 0);\
CTC2(*(uint*)((char*)(r0)+4), 2);\
CTC2(*(uint*)((char*)(r0 +8), 4);}
// lwc2 9,10,11
#define gte_ldopv2( r0 ) \
{ MTC2(*(uint*)((char*)(r0)), 9);\
MTC2(*(uint*)((char*)(r0)+4), 10);\
MTC2(*(uint*)((char*)(r0)+8), 11);}
// ctc2 26
#define gte_SetGeomScreen( r0 ) \
{ CTC2(r0, 26); }
// ctc2 24,25
#define gte_SetGeomOffset( r0, r1 )\
{ CTC2(r0 << 16, 24); \
CTC2(r1 << 16, 25);}
// ctc2 13,14,15
#define gte_SetBackColor( r0, r1, r2 ) \
{ CTC2(r0 << 4, 13); \
CTC2(r1 << 4, 14); \
CTC2(r2 << 4, 15); }
// ctc2 21, 22, 23
#define gte_SetFarColor( r0, r1, r2 ) \
{ CTC2(r0 << 4, 21); \
CTC2(r1 << 4, 22); \
CTC2(r2 << 4, 23); }
// load ctc2 8-11
#define gte_SetLightMatrix( r0 ) \
{ CTC2(*(uint*)((char*)(r0)), 8);\
CTC2(*(uint*)((char*)(r0)+4), 9);\
CTC2(*(uint*)((char*)(r0)+8), 10);\
CTC2(*(uint*)((char*)(r0)+12), 11);\
CTC2(*(uint*)((char*)(r0)+16), 12);}
// load ctc2 16-20
#define gte_SetColorMatrix( r0 ) \
{ CTC2(*(uint*)((char*)(r0)), 16);\
CTC2(*(uint*)((char*)(r0)+4), 17);\
CTC2(*(uint*)((char*)(r0)+8), 18);\
CTC2(*(uint*)((char*)(r0)+12), 19);\
CTC2(*(uint*)((char*)(r0)+16), 20);}
// load ctc2 0-4
#define gte_SetRotMatrix( r0 ) \
{ CTC2(*(uint*)((char*)(r0)), 0);\
CTC2(*(uint*)((char*)(r0)+4), 1);\
CTC2(*(uint*)((char*)(r0)+8), 2);\
CTC2(*(uint*)((char*)(r0)+12), 3);\
CTC2(*(uint*)((char*)(r0)+16), 4);}
// load ctc2 5-7
#define gte_SetTransVector( r0 )\
{ CTC2_S(*(int*)((char*)(r0)+0), 5);\
CTC2_S(*(int*)((char*)(r0)+4), 6);\
CTC2_S(*(int*)((char*)(r0)+8), 7);}
// load ctc2 5-7
#define gte_SetTransMatrix( r0 ) \
{ CTC2(*(uint*)((char*)(r0)+20), 5);\
CTC2(*(uint*)((char*)(r0)+24), 6);\
CTC2(*(uint*)((char*)(r0)+28), 7);}
// ctc2 8-12
#define gte_SetLightMatrix( r0 )\
{ CTC2(*(uint*)((char*)(r0)), 8);\
CTC2(*(uint*)((char*)(r0)+4), 9);\
CTC2(*(uint*)((char*)(r0)+8), 10);\
CTC2(*(uint*)((char*)(r0)+12), 11);\
CTC2(*(uint*)((char*)(r0)+16), 12);}
// ctc2 16-20
#define gte_SetColorMatrix( r0 )\
{ CTC2(*(uint*)((char*)(r0)), 16);\
CTC2(*(uint*)((char*)(r0)+4), 17);\
CTC2(*(uint*)((char*)(r0)+8), 18);\
CTC2(*(uint*)((char*)(r0)+12), 19);\
CTC2(*(uint*)((char*)(r0)+16), 20);}
// mtc2 9,10,11
#define gte_ldopv2SV( r0 ) \
{ MTC2(*(ushort*)((char*)(r0)), 9);\
MTC2(*(ushort*)((char*)(r0) + 2), 10);\
MTC2(*(ushort*)((char*)(r0) + 4), 11);}
// ctc2 0,2,4
#define gte_ldopv1SV( r0 )\
{ CTC2(*(ushort*)((char*)(r0)), 0);\
CTC2(*(ushort*)((char*)(r0) + 2), 2);\
CTC2(*(ushort*)((char*)(r0) + 4), 4);}
// mtc2 30
#define gte_ldlzc( r0 ) \
MTC2(*(uint*)((char*)(r0)), 30);
/*
* Type 2 functions
*/
// FIXME: there is lack of some macros
// please refer to official Psy-Q PSX SDK headers
// and this: https://github.com/ogamespec/pops-gte/blob/master/docs/gte.txt
#define gte_nop()
#define gte_rtps() doCOP2(0x0180001);
#define gte_rtpt() doCOP2(0x0280030);
#define gte_rt() doCOP2(0x0480012);
#define gte_rtv0() doCOP2(0x0486012);
#define gte_rtv1() doCOP2(0x048E012);
#define gte_rtv2() doCOP2(0x0496012);
#define gte_rtir() doCOP2(0x049E012);
#define gte_rtir_sf0() doCOP2(0x041E012);
#define gte_rtv0tr() doCOP2(0x0480012);
#define gte_rtv1tr() doCOP2(0x0488012);
#define gte_rtv2tr() doCOP2(0x0490012);
#define gte_rtirtr() op2 0x0498012);
#define gte_rtv0bk() doCOP2(0x0482012);
#define gte_rtv1bk() doCOP2(0x048A012);
#define gte_rtv2bk() doCOP2(0x0492012);
#define gte_rtirbk() doCOP2(0x049A012);
#define gte_ll() doCOP2(0x04A6412);
#define gte_llv0() doCOP2(0x04A6012);
#define gte_llv1() doCOP2(0x04AE012);
#define gte_llv2() doCOP2(0x04B6012);
#define gte_llir() doCOP2(0x04BE012);
#define gte_llv0tr() doCOP2(0x04A0012);
#define gte_llv1tr() doCOP2(0x04A8012);
#define gte_llv2tr() doCOP2(0x04B0012);
#define gte_llirtr() doCOP2(0x04B8012);
#define gte_llv0bk() doCOP2(0x04A2012);
#define gte_llv1bk() doCOP2(0x4AA012);
#define gte_llv2bk() doCOP2(0x04B2012);
#define gte_llirbk() doCOP2(0x04BA012);
#define gte_lc() doCOP2(0x04DA412);
#define gte_lcv0() doCOP2(0x04C6012);
#define gte_lcv1() doCOP2(0x04CE012);
#define gte_lcv2() doCOP2(0x04D6012);
#define gte_lcir() doCOP2(0x04DE012);
#define gte_lcv0tr() doCOP2(0x04C0012);
#define gte_lcv1tr() doCOP2(0x04C8012);
#define gte_lcv2tr() doCOP2(0x04D0012);
#define gte_lcirtr() doCOP2(0x04D8012);
#define gte_lcv0bk() doCOP2(0x04C2012);
#define gte_lcv1bk() doCOP2(0x04CA012);
#define gte_lcv2bk() doCOP2(0x04D2012);
#define gte_lcirbk() doCOP2(0x04DA012);
#define gte_dpcl() doCOP2(0x0680029);
#define gte_dpcs() doCOP2(0x0780010);
#define gte_dpct() doCOP2(0x0F8002A);
#define gte_intpl() doCOP2(0x0980011);
#define gte_sqr12() doCOP2(0x0A80428);
#define gte_sqr0() doCOP2(0x0A00428);
#define gte_ncs() doCOP2(0x0C8041E);
#define gte_nct() doCOP2(0x0D80420);
#define gte_ncds() doCOP2(0x0E80413);
#define gte_ncdt() doCOP2(0x0F80416);
#define gte_nccs() doCOP2(0x0108041B);
#define gte_ncct() doCOP2(0x0118043F);
#define gte_cdp() doCOP2(0x01280414);
#define gte_cc() doCOP2(0x0138041C);
#define gte_nclip() doCOP2(0x01400006);
#define gte_avsz3() doCOP2(0x0158002D);
#define gte_avsz4() doCOP2(0x0168002E);
#define gte_op12() doCOP2(0x0178000C);
#define gte_op0() doCOP2(0x0170000C);
#define gte_gpf12() doCOP2(0x0198003D);
#define gte_gpf0() doCOP2(0x0190003D);
#define gte_gpl12() doCOP2(0x01A8003E);
#define gte_gpl0() doCOP2(0x01A0003E0);
#define gte_mvmva_core( r0 ) doCOP2(r0)
#define gte_mvmva(sf,mx,v,cv,lm) gte_mvmva_core( 0x0400012 | \
((sf)<<19) | ((mx)<<17) | ((v)<<15) | ((cv)<<13) | ((lm)<<10) )
/*
* Type 2 functions without nop
*/
#define gte_rtps_b() doCOP2(0x0180001);
#define gte_rtpt_b() doCOP2(0x0280030);
#define gte_rt_b() doCOP2(0x0480012);
#define gte_rtv0_b() doCOP2(0x0486012);
#define gte_rtv1_b() doCOP2(0x048E012);
#define gte_rtv2_b() doCOP2(0x0496012);
#define gte_rtir_b() doCOP2(0x049E012);
#define gte_rtir_sf0_b() doCOP2(0x041E012);
#define gte_rtv0tr_b() doCOP2(0x0480012);
#define gte_rtv1tr_b() doCOP2(0x0488012);
#define gte_rtv2tr_b() doCOP2(0x0490012);
#define gte_rtirtr_b() doCOP2(0x0498012);
#define gte_rtv0bk_b() doCOP2(0x0482012);
#define gte_rtv1bk_b() doCOP2(0x048A012);
#define gte_rtv2bk_b() doCOP2(0x0492012);
#define gte_rtirbk_b() doCOP2(0x049A012);
#define gte_ll_b() doCOP2(0x04A6412);
#define gte_llv0_b() doCOP2(0x04A6012);
#define gte_llv1_b() doCOP2(0x04AE012);
#define gte_llv2_b() doCOP2(0x04B6012);
#define gte_llir_b() doCOP2(0x04BE012);
#define gte_llv0tr_b() doCOP2(0x04A0012);
#define gte_llv1tr_b() doCOP2(0x04A8012);
#define gte_llv2tr_b() doCOP2(0x04B0012);
#define gte_llirtr_b() doCOP2(0x04B8012);
#define gte_llv0bk_b() doCOP2(0x04A2012);
#define gte_llv1bk_b() doCOP2(0x4AA012);
#define gte_llv2bk_b() doCOP2(0x04B2012);
#define gte_llirbk_b() doCOP2(0x04BA012);
#define gte_lc_b() doCOP2(0x04DA412);
#define gte_lcv0_b() doCOP2(0x04C6012);
#define gte_lcv1_b() doCOP2(0x04CE012);
#define gte_lcv2_b() doCOP2(0x04D6012);
#define gte_lcir_b() doCOP2(0x04DE012);
#define gte_lcv0tr_b() doCOP2(0x04C0012);
#define gte_lcv1tr_b() doCOP2(0x04C8012);
#define gte_lcv2tr_b() doCOP2(0x04D0012);
#define gte_lcirtr_b() doCOP2(0x04D8012);
#define gte_lcv0bk_b() doCOP2(0x04C2012);
#define gte_lcv1bk_b() doCOP2(0x04CA012);
#define gte_lcv2bk_b() doCOP2(0x04D2012);
#define gte_lcirbk_b() doCOP2(0x04DA012);
#define gte_dpcl_b() doCOP2(0x0680029);
#define gte_dpcs_b() doCOP2(0x0780010);
#define gte_dpct_b() doCOP2(0x0F8002A);
#define gte_intpl_b() doCOP2(0x0980011);
#define gte_sqr12_b() doCOP2(0x0A80428);
#define gte_sqr0_b() doCOP2(0x0A00428);
#define gte_ncs_b() doCOP2(0x0C8041E);
#define gte_nct_b() doCOP2(0x0D80420);
#define gte_ncds_b() doCOP2(0x0E80413);
#define gte_ncdt_b() doCOP2(0x0F80416);
#define gte_nccs_b() doCOP2(0x0108041B);
#define gte_ncct_b() doCOP2(0x0118043F);
#define gte_cdp_b() doCOP2(0x01280414);
#define gte_cc_b() doCOP2(0x0138041C);
#define gte_nclip_b() doCOP2(0x01400006);
#define gte_avsz3_b() doCOP2(0x0158002D);
#define gte_avsz4_b() doCOP2(0x0168002E);
#define gte_op12_b() doCOP2(0x0178000C);
#define gte_op0_b() doCOP2(0x0170000C);
#define gte_gpf12_b() doCOP2(0x0198003D);
#define gte_gpf0_b() doCOP2(0x0190003D);
#define gte_gpl12_b() doCOP2(0x01A8003E);
#define gte_gpl0_b() doCOP2(0x01A0003E0);
#define gte_mvmva_core_b( r0 ) doCOP2(r0)
#define gte_mvmva_b(sf,mx,v,cv,lm) gte_mvmva_core_b( 0x0400012 | \
((sf)<<19) | ((mx)<<17) | ((v)<<15) | ((cv)<<13) | ((lm)<<10) )
/*
* Type 3 functions
*/
// store mfc2 9,10,11
#define gte_stclmv( r0 ) \
{ *(ushort*)((char*)(r0)) = MFC2(9) & 0xFFFF; \
*(ushort*)((char*)(r0)+6) = MFC2(10) & 0xFFFF; \
*(ushort*)((char*)(r0)+12) = MFC2(11) & 0xFFFF;}
#if USE_PGXP
// swc2 14
#define gte_stsxy( r0 ) \
{*(uint*)((char*)(r0)) = *(uint*)&g_FP_SXYZ2.x;}
// mfc2 12-14
#define gte_stsxy3( r0, r1, r2 ) \
{ *(uint*)((char*)(r0)) = *(uint*)&g_FP_SXYZ0.x;\
*(uint*)((char*)(r1)) = *(uint*)&g_FP_SXYZ1.x;\
*(uint*)((char*)(r2)) = *(uint*)&g_FP_SXYZ2.x;}
// swc2 14
#define gte_stsxy2( r0 ) gte_stsxy(r0)
// swc2 13
#define gte_stsxy1( r0 ) \
{ *(uint*)((char*)(r0)) = *(uint*)&g_FP_SXYZ1.x;}
// swc2 12
#define gte_stsxy0( r0 ) \
{ *(uint*)((char*)(r0)) = *(uint*)&g_FP_SXYZ0.x;}
#else
// swc2 14
#define gte_stsxy( r0 ) \
{ *(uint*)((char*)(r0)) = MFC2(14);}
// mfc2 12-14
#define gte_stsxy3( r0, r1, r2 ) \
{ *(uint*)((char*)(r0)) = MFC2(12);\
*(uint*)((char*)(r1)) = MFC2(13);\
*(uint*)((char*)(r2)) = MFC2(14);}
// swc2 14
#define gte_stsxy2( r0 ) gte_stsxy(r0)
// swc2 13
#define gte_stsxy1( r0 ) \
{ *(uint*)((char*)(r0)) = MFC2(13);}
// swc2 12
#define gte_stsxy0( r0 ) \
{ *(uint*)((char*)(r0)) = MFC2(12);}
#endif // USE_PGXP
// swc2 8
#define gte_stdp( r0 ) \
{ *(uint*)((char*)(r0)) = MFC2(8);}
// cfc2 31
#define gte_stflg( r0 ) \
{ *(uint*)((char*)(r0)) = CFC2(31);}
// swc2 7
#define gte_stotz( r0 ) \
{ *(uint*)((char*)(r0)) = MFC2(7);}
// mfc2 19
#define gte_stszotz( r0 ) \
{ *(uint*)((char*)(r0)) = MFC2(19) >> 2;}
// swc2 24
#define gte_stopz( r0 ) \
{ *(uint*)((char*)(r0)) = MFC2(24);}
// swc2 19
#define gte_stsz( r0 ) \
{ *(uint*)((char*)(r0)) = MFC2(19);}
// swc2 9-11
#define gte_stlvl( r0 ) \
{ *(uint*)((char*)(r0)) = MFC2(9); \
*(uint*)((char*)(r0)+4) = MFC2(10);\
*(uint*)((char*)(r0)+8) = MFC2(11);}
// mfc2 9, 10, 11
#define gte_stsv( r0 ) \
{ *(ushort*)((char*)(r0)) = MFC2(9) & 0xFFFF; \
*(ushort*)((char*)(r0)+2) = MFC2(10) & 0xFFFF;\
*(ushort*)((char*)(r0)+4) = MFC2(11) & 0xFFFF;}
// mfc2 9,10
#define gte_stbv( r0 ) \
{ *((char*)(r0)) = MFC2(9) & 0xFF; \
*((char*)(r0)+1) = MFC2(10) & 0xFF;}
// mfc2 9,10,11
#define gte_stcv( r0 ) \
{ *((char*)(r0)) = MFC2(9) & 0xFF; \
*((char*)(r0)+1) = MFC2(10) & 0xFF;\
*((char*)(r0)+2) = MFC2(11) & 0xFF;}
// swc2 17,18,19
#define gte_stsz3( r0, r1, r2 ) \
{ *(uint*)((char*)(r0)) = MFC2(17);\
*(uint*)((char*)(r1)) = MFC2(18);\
*(uint*)((char*)(r2)) = MFC2(19);}
// swc2 25,26,27
#define gte_stlvnl( r0 ) \
{ *(uint*)((char*)(r0)+0) = MFC2(25);\
*(uint*)((char*)(r0)+4) = MFC2(26);\
*(uint*)((char*)(r0)+8) = MFC2(27);}
// ctc2 5,6,7
#define gte_ldtr( r0, r1, r2 ) \
{ CTC2(r0, 5);\
CTC2(r1, 6);\
CTC2(r2, 7);}
// cfc2 5,6,7
#define gte_sttr( r0 ) \
{ *(uint*)((char*)(r0)+0) = CFC2(5);\
*(uint*)((char*)(r0)+4) = CFC2(6);\
*(uint*)((char*)(r0)+8) = CFC2(7);}
// swc2 22
#define gte_strgb( r0 )\
{ *(uint*)((char*)(r0)) = MFC2(22);}
// swc2 20 21 22
#define gte_strgb3( r0, r1, r2 )\
{ *(uint*)((char*)(r0)) = MFC2(20);\
*(uint*)((char*)(r1)) = MFC2(21);\
*(uint*)((char*)(r2)) = MFC2(22);}
// store cfc2 0-7
#define gte_ReadRotMatrix( r0 ) \
{ *(uint*)((char*)(r0)) = CFC2(0); \
*(uint*)((char*)(r0)+4) = CFC2(1); \
*(uint*)((char*)(r0)+8) = CFC2(2); \
*(uint*)((char*)(r0)+12) = CFC2(3); \
*(uint*)((char*)(r0)+16) = CFC2(4); \
*(uint*)((char*)(r0)+20) = CFC2(5); \
*(uint*)((char*)(r0)+24) = CFC2(6); \
*(uint*)((char*)(r0)+28) = CFC2(7);}
// cfc2 16-23
#define gte_ReadColorMatrix( r0 ) \
{ *(uint*)((char*)(r0)) = CFC2(16); \
*(uint*)((char*)(r0)+4) = CFC2(17); \
*(uint*)((char*)(r0)+8) = CFC2(18); \
*(uint*)((char*)(r0)+12) = CFC2(19); \
*(uint*)((char*)(r0)+16) = CFC2(20); \
*(uint*)((char*)(r0)+20) = CFC2(21); \
*(uint*)((char*)(r0)+24) = CFC2(22); \
*(uint*)((char*)(r0)+28) = CFC2(23);}
// cfc2 8-15
#define gte_ReadLightMatrix( r0 ) \
{ *(uint*)((char*)(r0)) = CFC2(8); \
*(uint*)((char*)(r0)+4) = CFC2(9); \
*(uint*)((char*)(r0)+8) = CFC2(10); \
*(uint*)((char*)(r0)+12) = CFC2(11); \
*(uint*)((char*)(r0)+16) = CFC2(12); \
*(uint*)((char*)(r0)+20) = CFC2(13); \
*(uint*)((char*)(r0)+24) = CFC2(14); \
*(uint*)((char*)(r0)+28) = CFC2(15);}
// swc2 31
#define gte_stlzc( r0 ) \
*(ushort*)((char*)(r0)) = MFC2(31);
// cfc2 21,22,23
#define gte_stfc( r0 )\
{ *(uint*)((char*)(r0)+0) = CFC2(21);\
*(uint*)((char*)(r0)+4) = CFC2(22);\
*(uint*)((char*)(r0)+8) = CFC2(23);}
#endif

157
rebuild_PC/PsyCross/include/psx/kernel.h
View File

@ -1,157 +0,0 @@
#ifndef KERNEL_H
#define KERNEL_H
#ifndef R3000_H
#include "r3000.h"
#endif
#ifndef ASM_H
#include "asm.h"
#endif
#define DescMask 0xff000000
#define DescTH DescMask
#define DescHW 0xf0000000
#define DescEV 0xf1000000
#define DescRC 0xf2000000
#define DescUEV 0xf3000000
#define DescSW 0xf4000000
#define HwVBLANK (DescHW|0x01)
#define HwGPU (DescHW|0x02)
#define HwCdRom (DescHW|0x03)
#define HwDMAC (DescHW|0x04)
#define HwRTC0 (DescHW|0x05)
#define HwRTC1 (DescHW|0x06)
#define HwRTC2 (DescHW|0x07)
#define HwCNTL (DescHW|0x08)
#define HwSPU (DescHW|0x09)
#define HwPIO (DescHW|0x0a)
#define HwSIO (DescHW|0x0b)
#define HwCPU (DescHW|0x10)
#define HwCARD (DescHW|0x11)
#define HwCARD_0 (DescHW|0x12)
#define HwCARD_1 (DescHW|0x13)
#define SwCARD (DescSW|0x01)
#define SwMATH (DescSW|0x02)
#define RCntCNT0 (DescRC|0x00)
#define RCntCNT1 (DescRC|0x01)
#define RCntCNT2 (DescRC|0x02)
#define RCntCNT3 (DescRC|0x03)
#define RCntMdINTR 0x1000
#define RCntMdNOINTR 0x2000
#define RCntMdSC 0x0001
#define RCntMdSP 0x0000
#define RCntMdFR 0x0000
#define RCntMdGATE 0x0010
#define EvSpCZ 0x0001 /* counter becomes zero */
#define EvSpINT 0x0002 /* interrupted */
#define EvSpIOE 0x0004 /* end of i/o */
#define EvSpCLOSE 0x0008 /* file was closed */
#define EvSpACK 0x0010 /* command acknowledged */
#define EvSpCOMP 0x0020 /* command completed */
#define EvSpDR 0x0040 /* data ready */
#define EvSpDE 0x0080 /* data end */
#define EvSpTIMOUT 0x0100 /* time out */
#define EvSpUNKNOWN 0x0200 /* unknown command */
#define EvSpIOER 0x0400 /* end of read buffer */
#define EvSpIOEW 0x0800 /* end of write buffer */
#define EvSpTRAP 0x1000 /* general interrupt */
#define EvSpNEW 0x2000 /* new device */
#define EvSpSYSCALL 0x4000 /* system call instruction */
#define EvSpERROR 0x8000 /* error happned */
#define EvSpPERROR 0x8001 /* previous write error happned */
#define EvSpEDOM 0x0301 /* domain error in libmath */
#define EvSpERANGE 0x0302 /* range error in libmath */
#define EvMdINTR 0x1000
#define EvMdNOINTR 0x2000
#define EvStUNUSED 0x0000
#define EvStWAIT 0x1000
#define EvStACTIVE 0x2000
#define EvStALREADY 0x4000
#define TcbMdRT 0x1000 /* reserved by system */
#define TcbMdPRI 0x2000 /* reserved by system */
#define TcbStUNUSED 0x1000
#define TcbStACTIVE 0x4000
struct ToT {
unsigned long *head;
long size;
};
struct TCBH {
struct TCB *entry; /* NULL */
long flag;
};
struct TCB {
long status;
long mode;
unsigned long reg[NREGS]; /* never change the offset of this */
long system[6]; /* reserved by system */
};
struct EvCB {
unsigned long desc;
long status;
long spec;
long mode;
long (*FHandler)();
long system[2]; /* reserved by system */
};
//#if !defined(D3D9)
#if 0///@FIXME Really not defined D3D9 :/
struct EXEC {
unsigned long pc0;
unsigned long gp0;
unsigned long t_addr;
unsigned long t_size;
unsigned long d_addr;
unsigned long d_size;
unsigned long b_addr;
unsigned long b_size;
unsigned long s_addr;
unsigned long s_size;
unsigned long sp,fp,gp,ret,base;
};
struct XF_HDR {
char key[8];
unsigned long text;
unsigned long data;
struct EXEC exec;
char title[60]; /* "PlayStation(tm) Executable A1" */
};
#endif
struct DIRENTRY {
char name[20];
long attr;
long size;
struct DIRENTRY *next;
long head;
char system[4];
};
extern struct ToT SysToT[32];
extern long SysClearRCnt[];
#ifndef NULL
#define NULL (0)
#endif
#endif /* _KERNEL_H */

116
rebuild_PC/PsyCross/include/psx/libapi.h
View File

@ -1,116 +0,0 @@
#ifndef LIBAPI_H
#define LIBAPI_H
#ifndef KERNEL_H
#include "kernel.h"
#endif
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
extern long SetRCnt(long spec, unsigned short target, long mode);
extern long GetRCnt(long spec);
extern long ResetRCnt(long spec);
extern long StartRCnt(long spec);
extern long StopRCnt(long spec);
extern long OpenEvent(unsigned long desc,long spec,long mode,long(*func)());
extern long CloseEvent(unsigned long event);
extern long WaitEvent(unsigned long event);
extern long TestEvent(unsigned long event);
extern long EnableEvent(unsigned long event);
extern long DisableEvent(unsigned long event);
extern void DeliverEvent(unsigned long ev1, long ev2);
extern void UnDeliverEvent(unsigned long ev1, long ev2);
extern long OpenTh(long (*func)(), unsigned long , unsigned long);
extern int CloseTh(long unk00);
extern int ChangeTh(long unk00);
/*
extern long open(char* unk00, unsigned long);
extern long close(long unk00);
extern long lseek(long unk00, long, long);
extern long read(long unk00, void *, long);
extern long write(long unk00, void *, long);
extern long ioctl(long unk00, long, long);
extern struct DIRENTRY* firstfile(char* unk00, struct DIRENTRY *);
extern struct DIRENTRY* nextfile(struct DIRENTRY* unk00);
extern long erase(char* unk00);
extern long undelete(char* unk00);
extern long format(char* unk00);
extern long rename(char* unk00, char *);
extern long cd(char* unk00);
*/
extern long LoadTest(char* unk00, struct EXEC *);
extern long Load(char * unk00, struct EXEC *);
extern long Exec(struct EXEC * unk00, long, char **);
extern long LoadExec(char * unk00, unsigned long, unsigned long);
extern long InitPAD(char * unk00,long ,char *,long);
extern long StartPAD();
extern void StopPAD();
extern void EnablePAD();
extern void DisablePAD();
extern void FlushCache();
extern void ReturnFromException();
extern int EnterCriticalSection();
extern void ExitCriticalSection();
extern void Exception();
extern void SwEnterCriticalSection();
extern void SwExitCriticalSection();
extern unsigned long SetSp(unsigned long newsp);
extern unsigned long GetSp();
extern unsigned long GetGp();
extern unsigned long GetCr();
extern unsigned long GetSr();
extern unsigned long GetSysSp();
extern long SetConf(unsigned long,unsigned long,unsigned long);
extern void GetConf(unsigned long *,unsigned long *,unsigned long *);
/*
extern long _get_errno(void);
extern long _get_error(long);
*/
extern void SystemError( char, long);
extern void SetMem(long);
extern long Krom2RawAdd( unsigned long );
extern long Krom2RawAdd2(unsigned short);
extern void _96_init(void);
extern void _96_remove(void);
extern void _boot(void);
extern void ChangeClearPAD( long );
/* prototypes added by shino 96/05/22 */
extern void InitCARD(long val);
extern long StartCARD();
extern long StopCARD();
extern void _bu_init();
extern long _card_info(long chan);
extern long _card_clear(long chan);
extern long _card_load(long chan);
extern long _card_auto(long val);
extern void _new_card();
extern long _card_status(long drv);
extern long _card_wait(long drv);
extern unsigned long _card_chan(void);
extern long _card_write(long chan, long block, unsigned char *buf);
extern long _card_read(long chan, long block, unsigned char *buf);
extern long _card_format(long chan);
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
#endif

262
rebuild_PC/PsyCross/include/psx/libcd.h
View File

@ -1,262 +0,0 @@
#ifndef LIBCD_H
#define LIBCD_H
#include "types.h"
#define DECODE_BCD(x) (((x) >> 4) * 10 + ((x) & 0xF))
#define ENCODE_BCD(x) ((((x) / 10) << 4) | ((x) % 10))
#define CdlModeStream 0x100 /* Normal Streaming */
#define CdlModeStream2 0x120 /* SUB HEADER information includes */
#define CdlModeSpeed 0x80 /* 0: normal speed 1: double speed */
#define CdlModeRT 0x40 /* 0: ADPCM off 1: ADPCM on */
#define CdlModeSize1 0x20 /* 0: 2048 byte 1: 2340byte */
#define CdlModeSize0 0x10 /* 0: - 1: 2328byte */
#define CdlModeSF 0x08 /* 0: Channel off 1: Channel on */
#define CdlModeRept 0x04 /* 0: Report off 1: Report on */
#define CdlModeAP 0x02 /* 0: AutoPause off 1: AutoPause on */
#define CdlModeDA 0x01 /* 0: CD-DA off 1: CD-DA on */
/*
* Status Contents
*/
#define CdlStatPlay 0x80 /* playing CD-DA */
#define CdlStatSeek 0x40 /* seeking */
#define CdlStatRead 0x20 /* reading data sectors */
#define CdlStatShellOpen 0x10 /* once shell open */
#define CdlStatSeekError 0x04 /* seek error detected */
#define CdlStatStandby 0x02 /* spindle motor rotating */
#define CdlStatError 0x01 /* command error detected */
/*
* Macros for CdGetDiskType()
*/
#define CdlStatNoDisk 0
#define CdlOtherFormat 1
#define CdlCdromFormat 2
/*
* CD-ROM Primitive Commands
*/
#define CdlNop 0x01
#define CdlSetloc 0x02
#define CdlPlay 0x03
#define CdlForward 0x04
#define CdlBackward 0x05
#define CdlReadN 0x06
#define CdlStandby 0x07
#define CdlStop 0x08
#define CdlPause 0x09
#define CdlMute 0x0b
#define CdlDemute 0x0c
#define CdlSetfilter 0x0d
#define CdlSetmode 0x0e
#define CdlGetparam 0x0f
#define CdlGetlocL 0x10
#define CdlGetlocP 0x11
#define CdlGetTN 0x13
#define CdlGetTD 0x14
#define CdlSeekL 0x15
#define CdlSeekP 0x16
#define CdlReadS 0x1B
/*
* Interrupts
*/
#define CdlNoIntr 0x00 /* No interrupt */
#define CdlDataReady 0x01 /* Data Ready */
#define CdlComplete 0x02 /* Command Complete */
#define CdlAcknowledge 0x03 /* Acknowledge (reserved) */
#define CdlDataEnd 0x04 /* End of Data Detected */
#define CdlDiskError 0x05 /* Error Detected */
/*
* Library Macros
*/
#ifndef btoi
#define btoi(b) ((b)/16*10 + (b)%16) /* BCD to u_char */
#endif
#ifndef itob
#define itob(i) ((i)/10*16 + (i)%10) /* u_char to BCD */
#endif
#define CdSeekL(p) CdControl(CdlSeekL, (u_char *)p, 0)
#define CdSeekP(p) CdControl(CdlSeekP, (u_char *)p, 0)
#define CdStandby() CdControl(CdlStandby, 0, 0)
#define CdPause() CdControl(CdlPause, 0, 0)
#define CdStop() CdControl(CdlStop, 0, 0)
#define CdMute() CdControl(CdlMute, 0, 0)
#define CdDeMute() CdControl(CdlDemute, 0, 0)
#define CdForward() CdControl(CdlForward, 0, 0)
#define CdBackward() CdControl(CdlBackward, 0, 0)
/*
* Position
*/
#define CdlMAXTOC 100
/*
* Callback
*/
typedef void (*CdlCB)(u_char,u_char *);
/*
* Location
*/
typedef struct {
u_char minute; /* minute (BCD) */
u_char second; /* second (BCD) */
u_char sector; /* sector (BCD) */
u_char track; /* track (void) */
} CdlLOC;
/*
* ADPCM Filter
*/
typedef struct {
u_char file; /* file ID (always 1) */
u_char chan; /* channel ID */
u_short pad;
} CdlFILTER;
/*
* Attenuator
*/
typedef struct {
u_char val0; /* volume for CD(L) -> SPU (L) */
u_char val1; /* volume for CD(L) -> SPU (R) */
u_char val2; /* volume for CD(R) -> SPU (L) */
u_char val3; /* volume for CD(R) -> SPU (R) */
} CdlATV;
/*
* Low Level File System for CdSearchFile()
*/
#define CdlMAXFILE 64 /* max number of files in a diRECT16ory */
#define CdlMAXDIR 128 /* max number of total diRECT16ories */
#define CdlMAXLEVEL 8 /* max levels of diRECT16ories */
typedef struct {
CdlLOC pos; /* file location */
u_long size; /* file size */
char name[16]; /* file name (body) */
} CdlFILE;
/*#define MULTI_INTERRUPT */
#ifndef MULTI_INTERRUPT
#define pauseMULI()
#define restartMULI()
#endif
/*
* Streaming Structures
*/
typedef struct {
u_short id;
u_short type;
u_short secCount;
u_short nSectors;
u_long frameCount;
u_long frameSize;
u_short width;
u_short height;
u_long dummy1;
u_long dummy2;
CdlLOC loc;
} StHEADER; /* CD-ROM STR structure */
#define StFREE 0x0000
#define StREWIND 0x0001
#define StCOMPLETE 0x0002
#define StBUSY 0x0003
#define StLOCK 0x0004
#define EDC 0
#define SECTOR_SIZE (512) /* Sector Size (word) */
#define HEADER_SIZE (8) /* Header Size (word) */
#define StSTATUS 0x00
#define StVER 0x00
#define StTYPE 0x01
#define StSECTOR_OFFSET 0x02
#define StSECTOR_SIZE 0x03
#define StFRAME_NO 0x04
#define StFRAME_SIZE 0x06
#define StMOVIE_WIDTH 0x08
#define StMOVIE_HEIGHT 0x09
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
/* Initializes CD filesystem using ISO 9660 compliant file */
extern void PsyX_CDFS_Init(const char* imageFileName, int track /*= 0*/, int sectorSize /*= 0*/);
/* Initializes CD filesystem using ISO 9660 compliant stream */
extern void PsyX_CDFS_Init_Mem(const u_long* data, int size, int track /*= 0*/, int sectorSize /*= 0*/);
void StSetRing(u_long *ring_addr,u_long ring_size);
void StClearRing(void);
void StUnSetRing(void);
void StSetStream(u_long mode,u_long start_frame,u_long end_frame,
void (*func1)(),void (*func2)());
void StSetEmulate(u_long *addr,u_long mode,u_long start_frame,
u_long end_frame,void (*func1)(),void (*func2)());
u_long StFreeRing(u_long *base);
u_long StGetNext(u_long **addr,u_long **header);
u_long StGetNextS(u_long **addr,u_long **header);
u_short StNextStatus(u_long **addr,u_long **header);
void StRingStatus(short *free_sectors,short *over_sectors);
void StSetMask(u_long mask,u_long start,u_long end);
void StCdInterrupt(void);
int StGetBackloc(CdlLOC *loc);
int StSetChannel(u_long channel);
void CdFlush(void);
CdlFILE *CdSearchFile(CdlFILE *fp, char *name);
CdlLOC *CdIntToPos(int i, CdlLOC *p) ;
char *CdComstr(u_char com);
char *CdIntstr(u_char intr);
int CdControl(u_char com, u_char *param, u_char *result);
int CdControlB(u_char com, u_char *param, u_char *result);
int CdControlF(u_char com, u_char *param);
int CdGetSector(void *madr, int size);
int CdGetSector2( void* madr, int size );
int CdDataSync(int mode);
int CdGetToc(CdlLOC *loc) ;
int CdPlay(int mode, int *track, int offset);
int CdMix(CdlATV *vol);
int CdPosToInt(CdlLOC *p);
int CdRead(int sectors, u_long *buf, int mode);
int CdRead2(long mode);
int CdReadFile(char *file, u_long *addr, int nbyte);
int CdReadSync(int mode, u_char *result);
int CdReady(int mode, u_char *result) ;
int CdSetDebug(int level);
int CdSync(int mode, u_char *result) ;
void (*CdDataCallback(void (*func)()));
CdlCB CdReadCallback(CdlCB func);
CdlCB CdReadyCallback(CdlCB func);
CdlCB CdSyncCallback(CdlCB func);
int CdInit(void);
int CdReset(int mode);
int CdStatus(void);
int CdLastCom(void);
CdlLOC *CdLastPos(void);
int CdMode(void);
int CdDiskReady( int mode );
int CdGetDiskType( void );
struct EXEC *CdReadExec(char *file);
void CdReadBreak( void );
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
#endif

67
rebuild_PC/PsyCross/include/psx/libetc.h
View File

@ -1,67 +0,0 @@
#ifndef LIBETC_H
#define LIBETC_H
#include "types.h"
extern int PadIdentifier;
#define PADLup (1<<12)
#define PADLdown (1<<14)
#define PADLleft (1<<15)
#define PADLright (1<<13)
#define PADRup (1<< 4)
#define PADRdown (1<< 6)
#define PADRleft (1<< 7)
#define PADRright (1<< 5)
#define PADi (1<< 9)
#define PADj (1<<10)
#define PADk (1<< 8)
#define PADl (1<< 3)
#define PADm (1<< 1)
#define PADn (1<< 2)
#define PADo (1<< 0)
#define PADh (1<<11)
#define PADL1 PADn
#define PADL2 PADo
#define PADR1 PADl
#define PADR2 PADm
#define PADstart PADh
#define PADselect PADk
#define MOUSEleft (1<<3)
#define MOUSEright (1<<2)
#define _PAD(x,y) ((y)<<((x)<<4))
#define getScratchAddr(offset) ((u_long *)(_scratchData+(offset)*4))
#define MODE_NTSC 0
#define MODE_PAL 1
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
extern char* _scratchData;
extern int CheckCallback(void);
extern void PadInit(int mode);
extern int ResetCallback(void);
extern int RestartCallback(void);
extern int StopCallback(void);
extern int VSync(int mode);
extern int VSyncCallback(void (*f)(void)) ;
extern long GetVideoMode (void);
extern long SetVideoMode (long mode);
extern u_long PadRead(int id);
extern void PadStop(void);
extern void(*vsync_callback)(void);
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
#endif

887
rebuild_PC/PsyCross/include/psx/libgpu.h
View File

@ -1,887 +0,0 @@
#ifndef LIBGPU_H
#define LIBGPU_H
#include "types.h"
#include "PsyX/common/pgxp_defs.h"
extern int (*GPU_printf)(const char *fmt, ...);
#define WAIT_TIME 0x800000
#define limitRange(x, l, h) ((x)=((x)<(l)?(l):(x)>(h)?(h):(x)))
#define setVector(v, _x, _y, _z) \
(v)->vx = _x, (v)->vy = _y, (v)->vz = _z
#define applyVector(v, _x, _y, _z, op) \
(v)->vx op _x, (v)->vy op _y, (v)->vz op _z
#define copyVector(v0, v1) \
(v0)->vx = (v1)->vx, (v0)->vy = (v1)->vy, (v0)->vz = (v1)->vz
#define addVector(v0, v1) \
(v0)->vx += (v1)->vx, \
(v0)->vy += (v1)->vy, \
(v0)->vz += (v1)->vz
#define dumpVector(str, v) \
GPU_printf("%s=(%d,%d,%d)\n", str, (v)->vx, (v)->vy, (v)->vz)
#define dumpMatrix(x) \
GPU_printf("\t%5d,%5d,%5d\n",(x)->m[0][0],(x)->m[0][1],(x)->m[0][2]),\
GPU_printf("\t%5d,%5d,%5d\n",(x)->m[1][0],(x)->m[1][1],(x)->m[1][2]),\
GPU_printf("\t%5d,%5d,%5d\n",(x)->m[2][0],(x)->m[2][1],(x)->m[2][2])
#define setRECT(r, _x, _y, _w, _h) \
(r)->x = (_x),(r)->y = (_y),(r)->w = (_w),(r)->h = (_h)
/*
* Set Primitive Attributes
*/
#define setTPage(p,tp,abr,x,y) \
((p)->tpage = getTPage(tp,abr,x,y))
#define setClut(p,x,y) \
((p)->clut = getClut(x,y))
/*
* Set Primitive Colors
*/
#define setRGB0(p,_r0,_g0,_b0) \
(p)->r0 = _r0,(p)->g0 = _g0,(p)->b0 = _b0
#define setRGB1(p,_r1,_g1,_b1) \
(p)->r1 = _r1,(p)->g1 = _g1,(p)->b1 = _b1
#define setRGB2(p,_r2,_g2,_b2) \
(p)->r2 = _r2,(p)->g2 = _g2,(p)->b2 = _b2
#define setRGB3(p,_r3,_g3,_b3) \
(p)->r3 = _r3,(p)->g3 = _g3,(p)->b3 = _b3
#define setRGBP0(p,_r0,_g0,_b0,_p0) \
(p)->r0 = _r0,(p)->g0 = _g0,(p)->b0 = _b0,(p)->p0 = _p0
#define setRGBP1(p,_r1,_g1,_b1,_p1) \
(p)->r1 = _r1,(p)->g1 = _g1,(p)->b1 = _b1,(p)->p1 = _p1
#define setRGBP2(p,_r2,_g2,_b2,_p2) \
(p)->r2 = _r2,(p)->g2 = _g2,(p)->b2 = _b2,(p)->p2 = _p2
#define setRGBP3(p,_r3,_g3,_b3,_p3) \
(p)->r3 = _r3,(p)->g3 = _g3,(p)->b3 = _b3,(p)->p3 = _p3
/*
* Set Primitive Screen Points
*/
#define setXY0(p,_x0,_y0) \
(p)->x0 = (_x0), (p)->y0 = (_y0) \
#define setXY2(p,_x0,_y0,_x1,_y1) \
(p)->x0 = (_x0), (p)->y0 = (_y0), \
(p)->x1 = (_x1), (p)->y1 = (_y1)
#define setXY3(p,_x0,_y0,_x1,_y1,_x2,_y2) \
(p)->x0 = (_x0), (p)->y0 = (_y0), \
(p)->x1 = (_x1), (p)->y1 = (_y1), \
(p)->x2 = (_x2), (p)->y2 = (_y2)
#define setXY4(p,_x0,_y0,_x1,_y1,_x2,_y2,_x3,_y3) \
(p)->x0 = (_x0), (p)->y0 = (_y0), \
(p)->x1 = (_x1), (p)->y1 = (_y1), \
(p)->x2 = (_x2), (p)->y2 = (_y2), \
(p)->x3 = (_x3), (p)->y3 = (_y3)
#define setXYWH(p,_x0,_y0,_w,_h) \
(p)->x0 = (_x0), (p)->y0 = (_y0), \
(p)->x1 = (_x0)+(_w), (p)->y1 = (_y0), \
(p)->x2 = (_x0), (p)->y2 = (_y0)+(_h), \
(p)->x3 = (_x0)+(_w), (p)->y3 = (_y0)+(_h)
/*
* Set Primitive Width/Height
*/
#define setWH(p,_w,_h) (p)->w = _w, (p)->h = _h
/*
* Set Primitive Texture Points
*/
#define setUV0(p,_u0,_v0) \
(p)->u0 = (_u0), (p)->v0 = (_v0) \
#define setUV3(p,_u0,_v0,_u1,_v1,_u2,_v2) \
(p)->u0 = (_u0), (p)->v0 = (_v0), \
(p)->u1 = (_u1), (p)->v1 = (_v1), \
(p)->u2 = (_u2), (p)->v2 = (_v2)
#define setUV4(p,_u0,_v0,_u1,_v1,_u2,_v2,_u3,_v3) \
(p)->u0 = (_u0), (p)->v0 = (_v0), \
(p)->u1 = (_u1), (p)->v1 = (_v1), \
(p)->u2 = (_u2), (p)->v2 = (_v2), \
(p)->u3 = (_u3), (p)->v3 = (_v3)
#define setUVWH(p,_u0,_v0,_w,_h) \
(p)->u0 = (_u0), (p)->v0 = (_v0), \
(p)->u1 = (_u0)+(_w), (p)->v1 = (_v0), \
(p)->u2 = (_u0), (p)->v2 = (_v0)+(_h), \
(p)->u3 = (_u0)+(_w), (p)->v3 = (_v0)+(_h)
/*
* Dump Primivie Parameters
*/
#define dumpRECT16(r) \
GPU_printf("(%d,%d)-(%d,%d)\n", (r)->x,(r)->y,(r)->w,(r)->h)
#define dumpWH(p) GPU_printf("(%d,%d)\n", (p)->w, (p)->h )
#define dumpXY0(p) GPU_printf("(%d,%d)\n", (p)->x0, (p)->y0)
#define dumpUV0(p) GPU_printf("(%d,%d)\n", (p)->u0, (p)->v0)
#define dumpXY2(p) \
GPU_printf("(%d,%d)-(%d,%d)\n", \
(p)->x0, (p)->y0, (p)->x1, (p)->y1)
#define dumpXY3(p) \
GPU_printf("(%d,%d)-(%d,%d)-(%d,%d)\n", \
(p)->x0, (p)->y0, (p)->x1, (p)->y1, \
(p)->x2, (p)->y2)
#define dumpUV3(p) \
GPU_printf("(%d,%d)-(%d,%d)-(%d,%d)\n", \
(p)->u0, (p)->v0, (p)->u1, (p)->v1, \
(p)->u2, (p)->v2)
#define dumpXY4(p) \
GPU_printf("(%d,%d)-(%d,%d)-(%d,%d)-(%d,%d)\n", \
(p)->x0, (p)->y0, (p)->x1, (p)->y1, \
(p)->x2, (p)->y2, (p)->x3, (p)->y3)
#define dumpUV4(p) \
GPU_printf("(%d,%d)-(%d,%d)-(%d,%d)-(%d,%d)\n", \
(p)->u0, (p)->v0, (p)->u1, (p)->v1, \
(p)->u2, (p)->v2, (p)->u3, (p)->v3)
#define dumpRGB0(p) \
GPU_printf("(%3d,%3d,%3d)\n", (p)->r0, (p)->g0, (p)->b0)
#define dumpRGB1(p) \
GPU_printf("(%3d,%3d,%3d)\n", (p)->r1, (p)->g1, (p)->b1)
#define dumpRGB2(p) \
GPU_printf("(%3d,%3d,%3d)\n", (p)->r2, (p)->g2, (p)->b2)
#define dumpRGB3(p) \
GPU_printf("(%3d,%3d,%3d)\n", (p)->r3, (p)->g3, (p)->b3)
/*
* Primitive Handling Macros
*/
#if USE_EXTENDED_PRIM_POINTERS
#define isendprim(p) ((((P_TAG *)(p))->addr) == (uintptr_t)&prim_terminator)
#define nextPrim(p) (void *)(((P_TAG *)(p))->addr)
#define setaddr(p, _addr) (((P_TAG *)(p))->addr = (uintptr_t)((u_long*)_addr))
#define getaddr(p) (uintptr_t)(((P_TAG *)(p))->addr)
#else
#define isendprim(p) ((((P_TAG *)(p))->addr)==0xffffff)
#define nextPrim(p) (void *)((((P_TAG *)(p))->addr))
#define setaddr(p, _addr) (((P_TAG *)(p))->addr = (u_long)((u_long*)_addr))
#define getaddr(p) (u_long)(((P_TAG *)(p))->addr)
#endif
#define setlen( p, _len) (((P_TAG *)(p))->len = (u_char)(_len))
#define setcode(p, _code) (((P_TAG *)(p))->code = (u_char)(_code))
#define getlen(p) (u_char)(((P_TAG *)(p))->len)
#define getcode(p) (u_char)(((P_TAG *)(p))->code)
#if USE_PGXP && USE_EXTENDED_PRIM_POINTERS
#define setpgxpindex(p, i) (((P_TAG *)(p))->pgxp_index = (u_short)(i))
#define addPrim(ot, p) setaddr(p, getaddr(ot)), setaddr(ot, p), setpgxpindex(p, PGXP_GetIndex(1))
#else
#define addPrim(ot, p) setaddr(p, getaddr(ot)), setaddr(ot, p)
#endif
#define addPrims(ot, p0, p1) setaddr(p1, getaddr(ot)),setaddr(ot, p0)
#define catPrim(p0, p1) setaddr(p0, p1)
#if USE_EXTENDED_PRIM_POINTERS
#define termPrim(p) setaddr(p, &prim_terminator)
#else
#define termPrim(p) setaddr(p, 0xffffffff)
#endif
#define setSemiTrans(p, abe) \
((abe)?setcode(p, getcode(p)|0x02):setcode(p, getcode(p)&~0x02))
#define setShadeTex(p, tge) \
((tge)?setcode(p, getcode(p)|0x01):setcode(p, getcode(p)&~0x01))
#define getTPage(tp, abr, x, y) \
((((tp)&0x3)<<7)|(((abr)&0x3)<<5)|(((y)&0x100)>>4)|(((x)&0x3ff)>>6)| \
(((y)&0x200)<<2))
#define getClut(x, y) \
(((y)<<6)|(((x)>>4)&0x3f))
#define dumpTPage(tpage) \
GPU_printf("tpage: (%d,%d,%d,%d)\n", \
((tpage)>>7)&0x3,((tpage)>>5)&0x3, \
((tpage)<<6)&0x3c0, \
(((tpage)<<4)&0x100)+(((tpage)>>2)&0x200))
#define dumpClut(clut) \
GPU_printf("clut: (%d,%d)\n", (clut&0x3f)<<4, (clut>>6))
#define _get_mode(dfe, dtd, tpage) \
((0xe1000000)|((dtd)?0x0200:0)| \
((dfe)?0x0400:0)|((tpage)&0x9ff))
#if USE_EXTENDED_PRIM_POINTERS
#define setDrawTPage(p, dfe, dtd, tpage) \
setlen(p, 1), \
((u_long *)(p))[2] = _get_mode(dfe, dtd, tpage)
#else
#define setDrawTPage(p, dfe, dtd, tpage) \
setlen(p, 1), \
((u_long *)(p))[1] = _get_mode(dfe, dtd, tpage)
#endif
#define _get_tw(tw) \
(tw ? ((0xe2000000)|((((tw)->y&0xff)>>3)<<15)| \
((((tw)->x&0xff)>>3)<<10)|(((~((tw)->h-1)&0xff)>>3)<<5)| \
(((~((tw)->w-1)&0xff)>>3))) : 0)
#define setTexWindow(p, tw) \
setlen(p, 2), \
((u_long *)(p))[1] = _get_tw(tw), \
((u_long *)(p))[2] = 0
#define _get_len(rect) \
(((RECT16)->w*(rect)->h+1)/2+4)
#define setDrawLoad(pt, rect) \
(_get_len(RECT16) <= 16) ? ( \
(setlen(pt, _get_len(rect))), \
((pt)->code[0] = 0xa0000000), \
((pt)->code[1] = *((u_long *)&(rect)->x)), \
((pt)->code[2] = *((u_long *)&(rect)->w)), \
((pt)->p[_get_len(rect)-4] = 0x01000000) \
) : ( \
(setlen(pt,0)) \
)
#define setDrawStp(p, pbw) \
setlen(p, 2), \
((u_long *)p)[1] = 0xe6000000|(pbw?0x01:0), \
((u_long *)p)[2] = 0
#if USE_EXTENDED_PRIM_POINTERS
#define setDrawMode(p, dfe, dtd, tpage, tw) \
setlen(p, 3), \
((u_long *)p)[2] = _get_mode(dfe, dtd, tpage), \
((u_long *)p)[3] = _get_tw((RECT16 *)tw)
#else
#define setDrawMode(p, dfe, dtd, tpage, tw) \
setlen(p, 2), \
((u_long *)p)[1] = _get_mode(dfe, dtd, tpage), \
((u_long *)p)[2] = _get_tw((RECT16 *)tw)
#endif
/* Primitive Lentgh Code */
/*-------------------------------------------------------------------- */
/* */
#define setPolyF3(p) setlen(p, 4), setcode(p, 0x20)
#define setPolyFT3(p) setlen(p, 7), setcode(p, 0x24)
#define setPolyG3(p) setlen(p, 6), setcode(p, 0x30)
#define setPolyGT3(p) setlen(p, 9), setcode(p, 0x34)
#define setPolyF4(p) setlen(p, 5), setcode(p, 0x28)
#define setPolyFT4(p) setlen(p, 9), setcode(p, 0x2c)
#define setPolyG4(p) setlen(p, 8), setcode(p, 0x38)
#define setPolyGT4(p) setlen(p, 12), setcode(p, 0x3c)
#define setSprt8(p) setlen(p, 3), setcode(p, 0x74)
#define setSprt16(p) setlen(p, 3), setcode(p, 0x7c)
#define setSprt(p) setlen(p, 4), setcode(p, 0x64)
#define setTile1(p) setlen(p, 2), setcode(p, 0x68)
#define setTile8(p) setlen(p, 2), setcode(p, 0x70)
#define setTile16(p) setlen(p, 2), setcode(p, 0x78)
#define setTile(p) setlen(p, 3), setcode(p, 0x60)
#define setLineF2(p) setlen(p, 3), setcode(p, 0x40)
#define setLineG2(p) setlen(p, 4), setcode(p, 0x50)
#define setLineF3(p) setlen(p, 5), setcode(p, 0x48),(p)->pad = 0x55555555
#define setLineG3(p) setlen(p, 7), setcode(p, 0x58),(p)->pad = 0x55555555, \
(p)->p2 = 0
#define setLineF4(p) setlen(p, 6), setcode(p, 0x4c),(p)->pad = 0x55555555
#define setLineG4(p) setlen(p, 9), setcode(p, 0x5c),(p)->pad = 0x55555555, \
(p)->p2 = 0, (p)->p3 = 0
/*
* RECT16angle:
*/
#pragma pack(push,1)
typedef struct _RECT16 {
short x, y; /* offset point on VRAM */
short w, h; /* width and height */
} RECT16;
// Psy-X custom struct to handle polygons
#if USE_EXTENDED_PRIM_POINTERS
#if defined(_M_X64) || defined(__amd64__)
#define DECLARE_P_ADDR \
uintptr_t addr; \
uint len : 16; \
uint pgxp_index : 16;
#define P_LEN 3 // 4 longs
#else
#define DECLARE_P_ADDR \
uintptr_t addr; \
uint len : 16; \
uint pgxp_index : 16;
#define P_LEN 2 // 2 longs
#endif // _M_X64 || __amd64__
#define DECLARE_P_ADDR_PTAG DECLARE_P_ADDR
#else // just don't use that, okay... it's just for reference
#define DECLARE_P_ADDR_PTAG \
unsigned addr : 24; \
unsigned len : 8;
#define DECLARE_P_ADDR \
u_long tag;
#define P_LEN 1 // 1 long
#endif
/*
* Polygon Primitive Definitions
*/
typedef struct {
DECLARE_P_ADDR_PTAG
} OT_TAG;
typedef struct {
DECLARE_P_ADDR_PTAG
u_char pad0, pad1, pad2, code;
} P_TAG;
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
VERTTYPE x1, y1;
VERTTYPE x2, y2;
} POLY_F3; /* Flat Triangle */
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
VERTTYPE x1, y1;
VERTTYPE x2, y2;
VERTTYPE x3, y3;
} POLY_F4; /* Flat Quadrangle */
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
u_char u0, v0; u_short clut;
VERTTYPE x1, y1;
u_char u1, v1; u_short tpage;
VERTTYPE x2, y2;
u_char u2, v2; u_short pad1;
} POLY_FT3; /* Flat Textured Triangle */
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
u_char u0, v0; u_short clut;
VERTTYPE x1, y1;
u_char u1, v1; u_short tpage;
VERTTYPE x2, y2;
u_char u2, v2; u_short pad1;
VERTTYPE x3, y3;
u_char u3, v3; u_short pad2;
} POLY_FT4; /* Flat Textured Quadrangle */
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
u_char r1, g1, b1, pad1;
VERTTYPE x1, y1;
u_char r2, g2, b2, pad2;
VERTTYPE x2, y2;
} POLY_G3; /* Gouraud Triangle */
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
u_char r1, g1, b1, pad1;
VERTTYPE x1, y1;
u_char r2, g2, b2, pad2;
VERTTYPE x2, y2;
u_char r3, g3, b3, pad3;
VERTTYPE x3, y3;
} POLY_G4; /* Gouraud Quadrangle */
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
u_char u0, v0; u_short clut;
u_char r1, g1, b1, p1;
VERTTYPE x1, y1;
u_char u1, v1; u_short tpage;
u_char r2, g2, b2, p2;
VERTTYPE x2, y2;
u_char u2, v2; u_short pad2;
} POLY_GT3; /* Gouraud Textured Triangle */
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
u_char u0, v0; u_short clut;
u_char r1, g1, b1, p1;
VERTTYPE x1, y1;
u_char u1, v1; u_short tpage;
u_char r2, g2, b2, p2;
VERTTYPE x2, y2;
u_char u2, v2; u_short pad2;
u_char r3, g3, b3, p3;//10
VERTTYPE x3, y3;//11
u_char u3, v3; u_short pad3;
} POLY_GT4; /* Gouraud Textured Quadrangle */
/*
* Line Primitive Definitions
*/
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
VERTTYPE x1, y1;
} LINE_F2; /* Unconnected Flat Line */
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
u_char r1, g1, b1, p1;
VERTTYPE x1, y1;
} LINE_G2; /* Unconnected Gouraud Line */
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
VERTTYPE x1, y1;
VERTTYPE x2, y2;
u_long pad;
} LINE_F3; /* 2 connected Flat Line */
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
u_char r1, g1, b1, p1;
VERTTYPE x1, y1;
u_char r2, g2, b2, p2;
VERTTYPE x2, y2;
u_long pad;
} LINE_G3; /* 2 connected Gouraud Line */
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
VERTTYPE x1, y1;
VERTTYPE x2, y2;
VERTTYPE x3, y3;
u_long pad;
} LINE_F4; /* 3 connected Flat Line Quadrangle */
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
u_char r1, g1, b1, p1;
VERTTYPE x1, y1;
u_char r2, g2, b2, p2;
VERTTYPE x2, y2;
u_char r3, g3, b3, p3;
VERTTYPE x3, y3;
u_long pad;
} LINE_G4; /* 3 connected Gouraud Line */
/*
* Sprite Primitive Definitions
*/
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
u_char u0, v0; u_short clut;
VERTTYPE w, h;
} SPRT; /* free size Sprite */
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
u_char u0, v0; u_short clut;
} SPRT_16; /* 16x16 Sprite */
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
u_char u0, v0; u_short clut;
} SPRT_8; /* 8x8 Sprite */
/*
* Tile Primitive Definitions
*/
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
VERTTYPE w, h;
} TILE; /* free size Tile */
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
} TILE_16; /* 16x16 Tile */
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
} TILE_8; /* 8x8 Tile */
typedef struct {
DECLARE_P_ADDR
u_char r0, g0, b0, code;
VERTTYPE x0, y0;
} TILE_1; /* 1x1 Tile */
/*
* Special Primitive Definitions
*/
typedef struct {
DECLARE_P_ADDR
u_long code[2];
} DR_MODE; /* Drawing Mode */
typedef struct {
DECLARE_P_ADDR
u_long code[2];
} DR_TWIN; /* Texture Window */
typedef struct {
DECLARE_P_ADDR
u_long code[2];
} DR_AREA; /* Drawing Area */
typedef struct {
DECLARE_P_ADDR
u_long code[2];
} DR_OFFSET; /* Drawing Offset */
typedef struct { /* MoveImage */
DECLARE_P_ADDR
u_long code[5];
} DR_MOVE;
typedef struct { /* LoadImage */
DECLARE_P_ADDR
u_long code[3];
u_long p[13];
} DR_LOAD;
typedef struct {
DECLARE_P_ADDR
u_long code[1];
} DR_TPAGE; /* Drawing TPage */
typedef struct {
DECLARE_P_ADDR
u_long code[2];
} DR_STP; /* Drawing STP */
/*
* PSY-X commands
*/
typedef struct {
DECLARE_P_ADDR
u_long code[2];
} DR_PSYX_TEX;
typedef struct {
DECLARE_P_ADDR
u_long code;
const char* text;
} DR_PSYX_DBGMARKER;
/*
* Environment
*/
typedef struct {
DECLARE_P_ADDR
u_long code[15];
} DR_ENV; /* Packed Drawing Environment */
typedef struct {
RECT16 clip; /* clip area */
short ofs[2]; /* drawing offset */
RECT16 tw; /* texture window */
u_short tpage; /* texture page */
u_char dtd; /* dither flag (0:off, 1:on) */
u_char dfe; /* flag to draw on display area (0:off 1:on) */
u_char drt;
u_char isbg; /* enable to auto-clear */
u_char r0, g0, b0; /* initital background color */
DR_ENV dr_env; /* reserved */
} DRAWENV;
typedef struct {
RECT16 disp; /* display area */
RECT16 screen; /* display start point */
u_char isinter; /* interlace 0: off 1: on */
u_char isrgb24; /* RGB24 bit mode */
u_char pad0, pad1; /* reserved */
} DISPENV;
/*
* Font Stream Parameters
*/
#define FNT_MAX_ID 8 /* max number of stream ID */
#define FNT_MAX_SPRT 1024 /* max number of sprites in all streams */
/*
* Multi-purpose Sony-TMD primitive
*/
typedef struct {
u_long id;
u_char r0, g0, b0, p0; /* Color of vertex 0 */
u_char r1, g1, b1, p1; /* Color of vertex 1 */
u_char r2, g2, b2, p2; /* Color of vertex 2 */
u_char r3, g3, b3, p3; /* Color of vertex 3 */
u_short tpage, clut; /* texture page ID, clut ID */
u_char u0, v0, u1, v1; /* texture corner point */
u_char u2, v2, u3, v3;
/* independent vertex model */
SVECTOR x0, x1, x2, x3; /* 3D corner point */
SVECTOR n0, n1, n2, n3; /* 3D corner normal vector */
/* Common vertex model */
SVECTOR *v_ofs; /* offset to vertex database */
SVECTOR *n_ofs; /* offset to normal database */
u_short vert0, vert1; /* index of vertex */
u_short vert2, vert3;
u_short norm0, norm1; /* index of normal */
u_short norm2, norm3;
} TMD_PRIM;
/*
* Multi-purpose TIM image
*/
typedef struct {
u_long mode; /* pixel mode */
RECT16 *cRECT16; /* CLUT RECT16angle on frame buffer */
u_long *caddr; /* CLUT address on main memory */
RECT16 *pRECT16; /* texture image RECT16angle on frame buffer */
u_long *paddr; /* texture image address on main memory */
} TIM_IMAGE;
#pragma pack(pop)
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
#if USE_EXTENDED_PRIM_POINTERS
extern OT_TAG prim_terminator;
#endif
#ifdef LoadImage
#undef LoadImage
#endif
/*
* Prototypes
*/
#ifndef _FNTPRINT_
#define _FNTPRINT_
extern int FntPrint(char* fmt, ...);
#endif /* _FNTPRINT_ */
#ifndef _KANJIFNTPRINT_
#define _KANJIFNTPRINT_
extern int KanjiFntPrint(char* text, ...);
#endif /* _KANJIFNTPRINT_ */
extern DISPENV *GetDispEnv(DISPENV *env);
extern DISPENV *PutDispEnv(DISPENV *env);
extern DISPENV *SetDefDispEnv(DISPENV *env, int x, int y, int w, int h);
extern DRAWENV *GetDrawEnv(DRAWENV *env);
extern DRAWENV *PutDrawEnv(DRAWENV *env);
extern DRAWENV *SetDefDrawEnv(DRAWENV *env, int x, int y, int w, int h);
extern TIM_IMAGE *ReadTIM(TIM_IMAGE *timimg);
extern TMD_PRIM *ReadTMD(TMD_PRIM *tmdprim);
extern int CheckPrim(char *s, u_long *p);
extern int ClearImage(RECT16 *RECT16, u_char r, u_char g, u_char b);
extern int ClearImage2(RECT16 *RECT16, u_char r, u_char g, u_char b);
extern int DrawSync(int mode);
extern int FntOpen(int x, int y, int w, int h, int isbg, int n);
extern int GetGraphDebug(void);
extern int GetTimSize(u_char *sjis);
extern int IsEndPrim(void *p);
extern int KanjiFntOpen(int x, int y, int w, int h, int dx, int dy, int cx, int cy, int isbg, int n);
extern void KanjiFntClose(void);
extern int Krom2Tim(u_char *sjis, u_long *taddr, int dx, int dy, int cdx, int cdy, u_int fg, u_int bg);
extern int LoadImagePSX(RECT16 *rect, u_long *p);
extern int LoadImage(RECT16* rect, u_long* p);
extern int LoadImage2(RECT16* rect, u_long* p);
extern int MargePrim(void *p0, void *p1);
extern int MoveImage(RECT16* rect, int x, int y);
extern int OpenTIM(u_long *addr);
extern int OpenTMD(u_long *tmd, int obj_no);
extern int ResetGraph(int mode);
extern int SetGraphDebug(int level);
extern int StoreImage(RECT16 *rect, u_long *p);
extern u_long *ClearOTag(u_long *ot, int n);
extern u_long *ClearOTagR(u_long *ot, int n);
extern u_long *FntFlush();
extern u_long *KanjiFntFlush(int id);
extern u_long DrawSyncCallback(void (*func)(void));
extern u_short GetClut(int x, int y);
extern u_short GetTPage(int tp, int abr, int x, int y);
extern u_short LoadClut(u_long *clut, int x, int y);
extern u_short LoadClut2(u_long *clut, int x, int y);
extern u_short LoadTPage(u_long *pix, int tp, int abr, int x, int y, int w, int h);
extern void *NextPrim(void *p);
extern void AddPrim(void *ot, void *p);
extern void AddPrims(void *ot, void *p0, void *p1);
extern void CatPrim(void *p0, void *p1);
extern void DrawOTag(u_long *p);
extern void DrawOTagIO(u_long *p);
extern void DrawOTagEnv(u_long *p, DRAWENV *env);
extern void DrawPrim(void *p);
extern void DumpClut(u_short clut);
extern void DumpDispEnv(DISPENV *env);
extern void DumpDrawEnv(DRAWENV *env);
extern void DumpOTag(u_long *p);
extern void DumpTPage(u_short tpage);
extern void FntLoad(int x, int y);
extern void SetDispMask(int mask);
extern void SetDrawArea(DR_AREA *p, RECT16 *r);
extern void SetDrawEnv(DR_ENV *dr_env, DRAWENV *env);
extern void SetDrawLoad(DR_LOAD *p, RECT16 *RECT16);
extern void SetDrawMode(DR_MODE *p, int dfe, int dtd, int tpage, RECT16 *tw);
extern void SetDrawTPage(DR_TPAGE *p, int dfe, int dtd, int tpage);
extern void SetDrawMove(DR_MOVE *p, RECT16 *RECT16, int x, int y);
extern void SetDrawOffset(DR_OFFSET *p, u_short *ofs);
extern void SetDrawStp(DR_STP *p, int pbw);
extern void SetDumpFnt(int id);
extern void SetLineF2(LINE_F2 *p);
extern void SetLineF3(LINE_F3 *p);
extern void SetLineF4(LINE_F4 *p);
extern void SetLineG2(LINE_G2 *p);
extern void SetLineG3(LINE_G3 *p);
extern void SetLineG4(LINE_G4 *p);
extern void SetPolyF3(POLY_F3 *p);
extern void SetPolyF4(POLY_F4 *p);
extern void SetPolyFT3(POLY_FT3 *p);
extern void SetPolyFT4(POLY_FT4 *p);
extern void SetPolyG3(POLY_G3 *p);
extern void SetPolyG4(POLY_G4 *p);
extern void SetPolyGT3(POLY_GT3 *p);
extern void SetPolyGT4(POLY_GT4 *p);
extern void SetSemiTrans(void *p, int abe);
extern void SetShadeTex(void *p, int tge);
extern void SetSprt(SPRT *p);
extern void SetSprt16(SPRT_16 *p);
extern void SetSprt8(SPRT_8 *p);
extern void SetTexWindow(DR_TWIN *p, RECT16 *tw);
extern void SetTile(TILE *p);
extern void SetTile1(TILE_1 *p);
extern void SetTile16(TILE_16 *p);
extern void SetTile8(TILE_8 *p);
extern void TermPrim(void *p);
extern u_long *BreakDraw(void);
extern void ContinueDraw(u_long *insaddr, u_long *contaddr);
extern int IsIdleGPU(int max_count);
extern int GetODE(void);
extern int LoadImage2(RECT16 *RECT16, u_long *p);
extern int StoreImage2(RECT16 *RECT16, u_long *p);
extern int MoveImage2(RECT16 *RECT16, int x, int y);
extern int DrawOTag2(u_long *p);
extern void GetDrawMode(DR_MODE *p);
extern void GetTexWindow(DR_TWIN *p);
extern void GetDrawArea(DR_AREA *p);
extern void GetDrawOffset(DR_OFFSET *p);
extern void GetDrawEnv2(DR_ENV *p);
/*
* PSY-X commands
*/
extern void SetPsyXTexture(DR_PSYX_TEX *p, uint grTextureId, int width, int height);
extern void SetPsyXDebugMarker(DR_PSYX_DBGMARKER* p, const char* str);
#ifdef _DEBUG
#define PSYX_DBG_MARKER_TEXT(primptr, ot, text) \
{ \
DR_PSYX_DBGMARKER* marker; \
marker = (DR_PSYX_DBGMARKER*)(primptr); \
SetPsyXDebugMarker(marker, text); \
(primptr) += sizeof(DR_PSYX_DBGMARKER); \
addPrim((ot), marker); \
}
#else
#define PSYX_DBG_MARKER_TEXT(primptr, ot, text)
#endif
#define PSYX_DBG_MARKER_RESET(primptr, ot) PSYX_DBG_MARKER_TEXT(primptr, ot, nullptr)
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
#endif

93
rebuild_PC/PsyCross/include/psx/libgte.h
View File

@ -1,93 +0,0 @@
#ifndef LIBGTE_H
#define LIBGTE_H
#include "types.h"
#include "PsyX/common/pgxp_defs.h"
typedef struct {
short m[3][3]; /* 3x3 rotation matrix */
long t[3]; /* transfer vector */
} MATRIX;
typedef struct { /* long word type 3D vector */
long vx, vy;
long vz, pad;
} VECTOR;
typedef struct { /* short word type 3D vector */
short vx, vy;
short vz, pad;
} SVECTOR;
typedef struct { /* color type vector */
unsigned char r, g, b, cd;
} CVECTOR;
typedef struct { /* 2D short vector */
short vx, vy;
} DVECTOR;
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
extern void InitGeom();
extern void SetGeomOffset(int ofx, int ofy);
extern void SetGeomScreen(int h);
extern void SetRotMatrix(MATRIX* m);
extern void SetLightMatrix(MATRIX* m);
extern void SetColorMatrix(MATRIX* m);
extern void SetTransMatrix(MATRIX* m);
extern void PushMatrix();
extern void PopMatrix();
VECTOR *ApplyMatrix(MATRIX *m, SVECTOR *v0, VECTOR *v1);
VECTOR *ApplyRotMatrix(SVECTOR *v0, VECTOR *v1);
VECTOR *ApplyRotMatrixLV(VECTOR *v0, VECTOR *v1);
SVECTOR *ApplyMatrixSV(MATRIX *m, SVECTOR *v0, SVECTOR *v1);
VECTOR *ApplyMatrixLV(MATRIX *m, VECTOR *v0, VECTOR *v1);
extern void RotTrans(SVECTOR* v0, VECTOR* v1, long* flag);
extern void RotTransSV(SVECTOR* v0, SVECTOR* v1, long* flag);
extern long RotTransPers(SVECTOR* v0, long* sxy, long* p, long* flag);
extern long RotTransPers3(SVECTOR* v0, SVECTOR* v1, SVECTOR* v2, long* sxy0, long* sxy1, long* sxy2, long* p, long* flag);
extern long RotTransPers4(SVECTOR* v0, SVECTOR* v1, SVECTOR* v2, SVECTOR* v3, long* sxy0, long* sxy1, long* sxy2, long* sxy3, long* p, long* flag);
extern void NormalColor(SVECTOR* v0, CVECTOR* v1);
extern void NormalColor3(SVECTOR* v0, SVECTOR* v1, SVECTOR* v2, CVECTOR* v3, CVECTOR* v4, CVECTOR* v5);
extern void NormalColorDpq(SVECTOR* v0, CVECTOR* v1, long p, CVECTOR* v2);
extern void NormalColorCol(SVECTOR* v0, CVECTOR* v1, CVECTOR* v2);
extern void NormalColorCol3(SVECTOR* v0, SVECTOR* v1, SVECTOR* v2, CVECTOR* v3, CVECTOR* v4, CVECTOR* v5, CVECTOR* v6);
extern void LocalLight(SVECTOR* v0, VECTOR* v1);
extern long RotAverageNclip4(SVECTOR* v0, SVECTOR* v1, SVECTOR* v2, SVECTOR* v3, long* sxy0/*arg_10*/, long* sxy1/*arg_14*/, long* sxy2/*arg_18*/, long* sxy3/*arg_1C*/, long* p/*arg_20*/, long* otz/*arg_24*/, long* flag/*arg_28*/);
extern MATRIX* MulMatrix0(MATRIX* m0, MATRIX* m1, MATRIX* m2);
extern MATRIX* MulMatrix(MATRIX* m0, MATRIX* m1);
extern MATRIX* MulMatrix2(MATRIX* m0, MATRIX* m1);
extern void SetBackColor(long rbk, long gbk, long bbk);
extern void SetFarColor(long rfc, long gfc, long bfc);
extern MATRIX* RotMatrix(SVECTOR* r, MATRIX* m);
extern MATRIX* RotMatrixYXZ(SVECTOR* r, MATRIX* m);
extern MATRIX* RotMatrixZYX_gte(SVECTOR* r, MATRIX* m);
extern MATRIX* RotMatrixX(long r, MATRIX *m);
extern MATRIX* RotMatrixY(long r, MATRIX *m);
extern MATRIX* RotMatrixZ(long r, MATRIX *m);
extern MATRIX* TransMatrix(MATRIX* m, VECTOR* v);
extern MATRIX* CompMatrix(MATRIX* m0, MATRIX* m1, MATRIX* m2);
extern MATRIX* ScaleMatrix(MATRIX* m, VECTOR* v);
extern MATRIX* MulRotMatrix(MATRIX* m0);
extern void ColorDpq(VECTOR* v0, CVECTOR* v1, long p, CVECTOR* v2);
extern void ColorCol(VECTOR* v0, CVECTOR* v1, CVECTOR* v2);
extern long NormalClip(long sxy0, long sxy1, long sxy2);
extern void SetDQA(int iDQA);
extern void SetDQB(int iDQB);
extern void SetFogNear(long a, long h);
extern void SetFogNearFar(long a, long b, long h);
extern long SquareRoot0(long a);
extern int rsin(int a);
extern int rcos(int a);
extern long ratan2(long y, long x);
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
#endif

12
rebuild_PC/PsyCross/include/psx/libmath.h
View File

@ -1,12 +0,0 @@
#ifndef LIBMATH_H
#define LIBMATH_H
#define _USE_MATH_DEFINES
#ifdef __GNUC__
#include <stdint.h>
#endif
#include <math.h>
#endif

53
rebuild_PC/PsyCross/include/psx/libmcrd.h
View File

@ -1,53 +0,0 @@
#ifndef LIBMCRD_H
#define LIBMCRD_H
#include "kernel.h"
typedef void (*MemCB)( long cmds, long rslt );
#define McFuncExist (1)
#define McFuncAccept (2)
#define McFuncReadFile (3)
#define McFuncWriteFile (4)
#define McFuncReadData (5)
#define McFuncWriteData (6)
#define McErrNone (0)
#define McErrCardNotExist (1)
#define McErrCardInvalid (2)
#define McErrNewCard (3)
#define McErrNotFormat (4)
#define McErrFileNotExist (5)
#define McErrAlreadyExist (6)
#define McErrBlockFull (7)
#define McErrExtend (0x8000)
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
extern void MemCardInit( long val );
extern void MemCardEnd( void );
extern void MemCardStart(void);
extern void MemCardStop(void);
extern long MemCardExist( long chan );
extern long MemCardAccept( long chan );
extern long MemCardOpen( long chan, char* file, long flag );
extern void MemCardClose(void);
extern long MemCardReadData( unsigned long* adrs, long ofs, long bytes );
extern long MemCardReadFile( long chan, char* file, unsigned long* adrs, long ofs, long bytes );
extern long MemCardWriteData( unsigned long* adrs, long ofs, long bytes );
extern long MemCardWriteFile( long chan, char* file, unsigned long* adrs, long ofs ,long bytes );
extern long MemCardCreateFile( long chan, char* file, long blocks );
extern long MemCardDeleteFile( long chan, char* file );
extern long MemCardFormat( long chan );
extern long MemCardUnformat(long chan);
extern long MemCardSync( long mode, long* cmds, long* rslt );
extern MemCB MemCardCallback( MemCB func );
extern long MemCardGetDirentry( long chan, char* name, struct DIRENTRY* dir, long* files, long ofs, long max );
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
#endif

61
rebuild_PC/PsyCross/include/psx/libpad.h
View File

@ -1,61 +0,0 @@
#ifndef LIBPAD_H
#define LIBPAD_H
#define PadStateDiscon 0
#define PadStateFindPad 1
#define PadStateFindCTP1 2
#define PadStateFindCTP2 3
#define PadStateReqInfo 4
#define PadStateExecCmd 5
#define PadStateStable 6
#define InfoModeCurID 1
#define InfoModeCurExID 2
#define InfoModeCurExOffs 3
#define InfoModeIdTable 4
#define InfoActFunc 1
#define InfoActSub 2
#define InfoActSize 3
#define InfoActCurr 4
#define InfoActSign 5
#define PadMaxCurr 60
#define PadCurrCTP1 10
#define MAX_CONTROLLERS 2 // TODO: multi-tap (2 ports * 5 taps (1st is Direct))
typedef struct PADRAW
{
unsigned char status; // size=0, offset=0
unsigned char id; // size=0, offset=1
unsigned char buttons[2]; // size=2, offset=2
unsigned char analog[4]; // size=4, offset=4
} *LPPADRAW;
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
extern void PadInitDirect(unsigned char* pad1, unsigned char* pad2);
extern void PadInitMtap(unsigned char* unk00, unsigned char* unk01);
extern void PadInitGun(unsigned char* unk00, int unk01);
extern int PadChkVsync();
extern void PadStartCom();
extern void PadStopCom();
extern unsigned int PadEnableCom(unsigned int unk00);
extern void PadEnableGun(unsigned char unk00);
extern void PadRemoveGun();
extern int PadGetState(int port);
extern int PadInfoMode(int port, int term, int offs);
extern int PadInfoAct(int port, int acno, int term);
extern int PadInfoComb(int unk00, int, int unk01);
extern int PadSetActAlign(int port, unsigned char* table);
extern int PadSetMainMode(int socket, int offs, int lock);
extern void PadSetAct(int port, unsigned char* table, int len);
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
#endif

21
rebuild_PC/PsyCross/include/psx/libpress.h
View File

@ -1,21 +0,0 @@
#ifndef LIBPRESS_H
#define LIBPRESS_H
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
extern void DecDCTReset(int mode);
extern int DecDCTBufSize(u_long *bs);
extern void DecDCTvlc(u_long *bs, u_long *buf);
extern void DecDCTin(u_long *buf, int mode);
extern void DecDCTout(u_long *buf, int size);
extern int DecDCTinSync( int mode) ;
extern int DecDCToutSync( int mode) ;
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
#endif

23
rebuild_PC/PsyCross/include/psx/libsn.h
View File

@ -1,23 +0,0 @@
#ifndef LIBSN_H
#define LIBSN_H
#include <stdint.h>
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
extern int PCinit();
extern uintptr_t PCopen(char* name, int flags, int perms);
extern int PCcreat(char* name, int perms);
extern int PClseek(uintptr_t fd, int offset, int mode);
extern int PCread(uintptr_t fd, char* buff, int len);
extern int PCwrite(uintptr_t fd, char* buff, int len);
extern int PCclose(uintptr_t fd);
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
#endif

533
rebuild_PC/PsyCross/include/psx/libspu.h
View File

@ -1,533 +0,0 @@
#ifndef LIBSPU_H
#define LIBSPU_H
/* ----------------------------------------------------------------
* CONSTANT
* ---------------------------------------------------------------- */
#define SPU_SUCCESS 0
#define SPU_INVALID_ARGS (-3)
#define SPU_DIAG (-2)
#define SPU_CHECK (-1)
#define SPU_OFF 0
#define SPU_ON 1
#define SPU_CLEAR 2
#define SPU_RESET 3
#define SPU_DONT_CARE 4
#define SPU_ALL 0
#define SPU_CDONLY 5
#define SPU_VOICEONLY 6
#define SPU_CONT 7
#define SPU_BIT 8
#define SPU_NULL 0
/* Macros below will be obsoleted. */
#define SpuDiag SPU_DIAG
#define SpuCheck SPU_CHECK
#define SpuOff SPU_OFF
#define SpuOn SPU_ON
#define SpuClear SPU_CLEAR
#define SpuReset SPU_RESET
#define SpuDontCare SPU_DONT_CARE
#define SpuALL SPU_ALL
#define SpuCDOnly SPU_CDONLY
#define SpuVoiceOnly SPU_VOICEONLY
#define SpuCont SPU_CONT
#define SpuNull SPU_NULL
#define SPU_OFF_ENV_ON 2
#define SPU_ON_ENV_OFF 3
/* Macros below will be obsoleted. */
#define SpuOffEnvOn SPU_OFF_ENV_ON
#define SpuOnEnvOff SPU_ON_ENV_OFF
#define SPU_ERROR (-1)
/* Macros below will be obsoleted. */
#define SpuError SPU_ERROR
#define SPU_TRANSFER_BY_DMA 0L
#define SPU_TRANSFER_BY_IO 1L
/* Macros below will be obsoleted. */
#define SpuTransferByDMA SPU_TRANSFER_BY_DMA
#define SpuTransferByIO SPU_TRANSFER_BY_IO
#define SpuTransByDMA SpuTransferByDMA
#define SpuTransByIO SpuTransferByIO
#define SPU_TRANSFER_WAIT 1
#define SPU_TRANSFER_PEEK 0
#define SPU_TRANSFER_GLANCE SPU_TRANSFER_PEEK
/*
* Voice designate
*/
#ifndef __SPU_VOICE
#define __SPU_VOICE
#define SPU_00CH (0x1L<< 0)
#define SPU_01CH (0x1L<< 1)
#define SPU_02CH (0x1L<< 2)
#define SPU_03CH (0x1L<< 3)
#define SPU_04CH (0x1L<< 4)
#define SPU_05CH (0x1L<< 5)
#define SPU_06CH (0x1L<< 6)
#define SPU_07CH (0x1L<< 7)
#define SPU_08CH (0x1L<< 8)
#define SPU_09CH (0x1L<< 9)
#define SPU_10CH (0x1L<<10)
#define SPU_11CH (0x1L<<11)
#define SPU_12CH (0x1L<<12)
#define SPU_13CH (0x1L<<13)
#define SPU_14CH (0x1L<<14)
#define SPU_15CH (0x1L<<15)
#define SPU_16CH (0x1L<<16)
#define SPU_17CH (0x1L<<17)
#define SPU_18CH (0x1L<<18)
#define SPU_19CH (0x1L<<19)
#define SPU_20CH (0x1L<<20)
#define SPU_21CH (0x1L<<21)
#define SPU_22CH (0x1L<<22)
#define SPU_23CH (0x1L<<23)
#define SPU_0CH SPU_00CH
#define SPU_1CH SPU_01CH
#define SPU_2CH SPU_02CH
#define SPU_3CH SPU_03CH
#define SPU_4CH SPU_04CH
#define SPU_5CH SPU_05CH
#define SPU_6CH SPU_06CH
#define SPU_7CH SPU_07CH
#define SPU_8CH SPU_08CH
#define SPU_9CH SPU_09CH
#define SPU_ALLCH (SPU_00CH | SPU_01CH | SPU_02CH | SPU_03CH | SPU_04CH | \
SPU_05CH | SPU_06CH | SPU_07CH | SPU_08CH | SPU_09CH | \
SPU_10CH | SPU_11CH | SPU_12CH | SPU_13CH | SPU_14CH | \
SPU_15CH | SPU_16CH | SPU_17CH | SPU_18CH | SPU_19CH | \
SPU_20CH | SPU_21CH | SPU_22CH | SPU_23CH)
#define SPU_KEYCH(x) (0x1L<<(x))
#define SPU_VOICECH(x) SPU_KEYCH(x)
#endif /* __SPU_VOICE */
/* for Voice setting */
#define SPU_VOICE_VOLL (0x01 << 0) /* volume (left) */
#define SPU_VOICE_VOLR (0x01 << 1) /* volume (right) */
#define SPU_VOICE_VOLMODEL (0x01 << 2) /* volume mode (left) */
#define SPU_VOICE_VOLMODER (0x01 << 3) /* volume mode (right) */
#define SPU_VOICE_PITCH (0x01 << 4) /* tone (pitch setting) */
#define SPU_VOICE_NOTE (0x01 << 5) /* tone (note setting) */
#define SPU_VOICE_SAMPLE_NOTE (0x01 << 6) /* waveform data sample note */
#define SPU_VOICE_WDSA (0x01 << 7) /* waveform data start address */
#define SPU_VOICE_ADSR_AMODE (0x01 << 8) /* ADSR Attack rate mode */
#define SPU_VOICE_ADSR_SMODE (0x01 << 9) /* ADSR Sustain rate mode */
#define SPU_VOICE_ADSR_RMODE (0x01 << 10) /* ADSR Release rate mode */
#define SPU_VOICE_ADSR_AR (0x01 << 11) /* ADSR Attack rate */
#define SPU_VOICE_ADSR_DR (0x01 << 12) /* ADSR Decay rate */
#define SPU_VOICE_ADSR_SR (0x01 << 13) /* ADSR Sustain rate */
#define SPU_VOICE_ADSR_RR (0x01 << 14) /* ADSR Release rate */
#define SPU_VOICE_ADSR_SL (0x01 << 15) /* ADSR Sustain level */
#define SPU_VOICE_LSAX (0x01 << 16) /* start address for loop */
#define SPU_VOICE_ADSR_ADSR1 (0x01 << 17) /* ADSR adsr1 for `VagAtr' */
#define SPU_VOICE_ADSR_ADSR2 (0x01 << 18) /* ADSR adsr2 for `VagAtr' */
#define SPU_VOICE_DIRECT16 0
#define SPU_VOICE_LINEARIncN 1
#define SPU_VOICE_LINEARIncR 2
#define SPU_VOICE_LINEARDecN 3
#define SPU_VOICE_LINEARDecR 4
#define SPU_VOICE_EXPIncN 5
#define SPU_VOICE_EXPIncR 6
#define SPU_VOICE_EXPDec 7
#define SPU_VOICE_EXPDecN SPU_VOICE_EXPDec
#define SPU_VOICE_EXPDecR SPU_VOICE_EXPDec
#define SPU_DECODED_FIRSTHALF 0
#define SPU_DECODED_SECONDHALF 1
#define SPU_DECODE_FIRSTHALF SPU_DECODED_FIRSTHALF
#define SPU_DECODE_SECONDHALF SPU_DECODED_SECONDHALF
#define SPU_COMMON_MVOLL (0x01 << 0) /* master volume (left) */
#define SPU_COMMON_MVOLR (0x01 << 1) /* master volume (right) */
#define SPU_COMMON_MVOLMODEL (0x01 << 2) /* master volume mode (left) */
#define SPU_COMMON_MVOLMODER (0x01 << 3) /* master volume mode (right) */
#define SPU_COMMON_RVOLL (0x01 << 4) /* reverb volume (left) */
#define SPU_COMMON_RVOLR (0x01 << 5) /* reverb volume (right) */
#define SPU_COMMON_CDVOLL (0x01 << 6) /* CD input volume (left) */
#define SPU_COMMON_CDVOLR (0x01 << 7) /* CD input volume (right) */
#define SPU_COMMON_CDREV (0x01 << 8) /* CD input reverb on/off */
#define SPU_COMMON_CDMIX (0x01 << 9) /* CD input on/off */
#define SPU_COMMON_EXTVOLL (0x01 << 10) /* external digital input volume (left) */
#define SPU_COMMON_EXTVOLR (0x01 << 11) /* external digital input volume (right) */
#define SPU_COMMON_EXTREV (0x01 << 12) /* external digital input reverb on/off */
#define SPU_COMMON_EXTMIX (0x01 << 13) /* external digital input on/off */
/* for Reverb setting */
#define SPU_REV_MODE (0x01 << 0) /* mode setting */
#define SPU_REV_DEPTHL (0x01 << 1) /* reverb depth (left) */
#define SPU_REV_DEPTHR (0x01 << 2) /* reverb depth (right) */
#define SPU_REV_DELAYTIME (0x01 << 3) /* Delay Time (ECHO, DELAY only) */
#define SPU_REV_FEEDBACK (0x01 << 4) /* Feedback (ECHO only) */
#define SPU_REV_MODE_CHECK (-1)
#define SPU_REV_MODE_OFF 0
#define SPU_REV_MODE_ROOM 1
#define SPU_REV_MODE_STUDIO_A 2
#define SPU_REV_MODE_STUDIO_B 3
#define SPU_REV_MODE_STUDIO_C 4
#define SPU_REV_MODE_HALL 5
#define SPU_REV_MODE_SPACE 6
#define SPU_REV_MODE_ECHO 7
#define SPU_REV_MODE_DELAY 8
#define SPU_REV_MODE_PIPE 9
#define SPU_REV_MODE_MAX 10
#define SPU_REV_MODE_CLEAR_WA 0x100
/* ----------------------------------------------------------------
* Event flushing
* ---------------------------------------------------------------- */
#define SPU_EVENT_KEY (0x01 << 0)
#define SPU_EVENT_PITCHLFO (0x01 << 1)
#define SPU_EVENT_NOISE (0x01 << 2)
#define SPU_EVENT_REVERB (0x01 << 3)
#define SPU_EVENT_ALL 0
/* ----------------------------------------------------------------
* Structure
* ---------------------------------------------------------------- */
typedef struct {
short left; /* Lch */
short right; /* Rch */
} SpuVolume;
typedef struct {
unsigned long voice; /* set voice:
SpuSetVoiceAttr: each voice is a bit array
SpuGetVoiceAttr: voice is a bit value */
unsigned long mask; /* settings attribute bit (invalid with Get) */
SpuVolume volume; /* volume */
SpuVolume volmode; /* volume mode */
SpuVolume volumex; /* current volume (invalid with Set) */
unsigned short pitch; /* tone (pitch setting) */
unsigned short note; /* tone (note setting) */
unsigned short sample_note; /* tone (note setting) */
short envx; /* current envelope value (invalid with Set) */
unsigned long addr; /* waveform data start address */
unsigned long loop_addr; /* loop start address */
long a_mode; /* Attack rate mode */
long s_mode; /* Sustain rate mode */
long r_mode; /* Release rate mode */
unsigned short ar; /* Attack rate */
unsigned short dr; /* Decay rate */
unsigned short sr; /* Sustain rate */
unsigned short rr; /* Release rate */
unsigned short sl; /* Sustain level */
unsigned short adsr1; /* adsr1 for `VagAtr' */
unsigned short adsr2; /* adsr2 for `VagAtr' */
} SpuVoiceAttr;
typedef struct {
short voiceNum; /* voice number */
short pad; /* padding */
SpuVoiceAttr attr; /* voice attribute */
} SpuLVoiceAttr;
typedef struct {
unsigned long mask; /* settings mask */
long mode; /* reverb mode */
SpuVolume depth; /* reverb depth */
long delay; /* Delay Time (ECHO, DELAY only) */
long feedback; /* Feedback (ECHO only) */
} SpuReverbAttr;
#define SPU_DECODEDDATA_SIZE 0x200
#define SPU_DECODEDATA_SIZE SPU_DECODEDDATA_SIZE
typedef struct {
short cd_left [SPU_DECODEDDATA_SIZE];
short cd_right [SPU_DECODEDDATA_SIZE];
short voice1 [SPU_DECODEDDATA_SIZE];
short voice3 [SPU_DECODEDDATA_SIZE];
} SpuDecodedData;
typedef SpuDecodedData SpuDecodeData;
typedef struct {
SpuVolume volume; /* volume */
long reverb; /* reverb on/off */
long mix; /* mixing on/off */
} SpuExtAttr;
typedef struct {
unsigned long mask; /* settings mask */
SpuVolume mvol; /* master volume */
SpuVolume mvolmode; /* master volume mode */
SpuVolume mvolx; /* current master volume */
SpuExtAttr cd; /* CD input attributes */
SpuExtAttr ext; /* external digital input attributes */
} SpuCommonAttr;
#ifndef __SPU_IRQCALLBACK_PROC
#define __SPU_IRQCALLBACK_PROC
typedef void (*SpuIRQCallbackProc)(void);
#endif /* __SPU_IRQCALLBACK_PROC */
#ifndef __SPU_TRANSFERCALLBACK_PROC
#define __SPU_TRANSFERCALLBACK_PROC
typedef void (*SpuTransferCallbackProc)(void);
#endif /* __SPU_TRANSFERCALLBACK_PROC */
/* ----------------------------------------------------------------
* for SPU Malloc (used in SpuInitMalloc())
* ---------------------------------------------------------------- */
#define SPU_MALLOC_RECSIZ 8
/* ----------------------------------------------------------------
* User specifiable global environment
* ---------------------------------------------------------------- */
typedef struct {
unsigned long mask;
unsigned long queueing;
} SpuEnv;
#define SPU_ENV_EVENT_QUEUEING (0x01 << 0)
/* ----------------------------------------------------------------
* prototype declaration
* ---------------------------------------------------------------- */
#if defined(_LANGUAGE_C_PLUS_PLUS) || defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern void SpuInit (void);
extern void SpuInitHot (void);
extern void SpuStart (void);
extern void SpuQuit (void);
extern long SpuSetMute (long on_off);
extern long SpuGetMute (void);
extern void SpuSetEnv (SpuEnv *env);
extern long SpuSetNoiseClock (long n_clock);
extern long SpuGetNoiseClock (void);
extern unsigned long SpuSetNoiseVoice (long on_off, unsigned long voice_bit);
extern unsigned long SpuGetNoiseVoice (void);
extern long SpuSetReverb (long on_off);
extern long SpuGetReverb (void);
extern long SpuSetReverbModeParam (SpuReverbAttr *attr);
extern void SpuGetReverbModeParam (SpuReverbAttr *attr);
extern long SpuSetReverbDepth (SpuReverbAttr *attr);
extern long SpuReserveReverbWorkArea (long on_off);
extern long SpuIsReverbWorkAreaReserved (long on_off);
extern unsigned long SpuSetReverbVoice (long on_off, unsigned long voice_bit);
extern unsigned long SpuGetReverbVoice (void);
extern long SpuClearReverbWorkArea (long mode);
extern unsigned long SpuWrite (unsigned char *addr, unsigned long size);
extern unsigned long SpuWrite0 (unsigned long size);
extern unsigned long SpuRead (unsigned char *addr, unsigned long size);
extern long SpuSetTransferMode (long mode);
#define SpuSetTransMode(mode) SpuSetTransferMode((mode))
extern long SpuGetTransferMode (void);
#define SpuGetTransMode() SpuGetTransferMode()
extern unsigned long SpuSetTransferStartAddr (unsigned long addr);
#define SpuSetTransStartAddr(addr) SpuSetTransferStartAddr((addr))
extern unsigned long SpuGetTransferStartAddr (void);
#define SpuGetTransStartAddr() SpuGetTransferStartAddr()
extern unsigned long SpuWritePartly (unsigned char *addr, unsigned long size);
extern long SpuIsTransferCompleted (long flag);
extern SpuTransferCallbackProc SpuSetTransferCallback (SpuTransferCallbackProc func);
extern long SpuReadDecodedData (SpuDecodedData *d_data, long flag);
#define SpuReadDecodeData(d_data,flag) SpuReadDecodedData((d_data), (flag))
extern long SpuSetIRQ (long on_off);
extern long SpuGetIRQ (void);
extern unsigned long SpuSetIRQAddr (unsigned long);
extern unsigned long SpuGetIRQAddr (void);
extern SpuIRQCallbackProc SpuSetIRQCallback (SpuIRQCallbackProc);
extern void SpuSetVoiceAttr (SpuVoiceAttr *arg);
extern void SpuGetVoiceAttr (SpuVoiceAttr *arg);
extern void SpuSetKey (long on_off, unsigned long voice_bit);
extern void SpuSetKeyOnWithAttr (SpuVoiceAttr *attr);
extern long SpuGetKeyStatus (unsigned long voice_bit);
extern void SpuGetAllKeysStatus (char *status);
extern unsigned long SpuFlush (unsigned long ev);
extern unsigned long SpuSetPitchLFOVoice (long on_off, unsigned long voice_bit);
extern unsigned long SpuGetPitchLFOVoice (void);
extern void SpuSetCommonAttr (SpuCommonAttr *attr);
extern void SpuGetCommonAttr (SpuCommonAttr *attr);
extern long SpuInitMalloc (long num, char *top);
extern long SpuMalloc (long size);
extern long SpuMallocWithStartAddr (unsigned long addr, long size);
extern void SpuFree (unsigned long addr);
extern long SpuRGetAllKeysStatus (long min_, long max_, char *status);
extern long SpuRSetVoiceAttr (long min_, long max_, SpuVoiceAttr *arg);
extern void SpuNSetVoiceAttr (int vNum, SpuVoiceAttr *arg);
extern void SpuNGetVoiceAttr (int vNum, SpuVoiceAttr *arg);
extern void SpuLSetVoiceAttr (int num, SpuLVoiceAttr *argList);
extern void SpuSetVoiceVolume (int vNum, short volL, short volR);
extern void SpuSetVoiceVolumeAttr (int vNum, short volL, short volR,
short volModeL, short volModeR);
extern void SpuSetVoicePitch (int vNum, unsigned short pitch);
extern void SpuSetVoiceNote (int vNum, unsigned short note);
extern void SpuSetVoiceSampleNote (int vNum, unsigned short sampleNote);
extern void SpuSetVoiceStartAddr (int vNum, unsigned long startAddr);
extern void SpuSetVoiceLoopStartAddr (int vNum, unsigned long lsa);
extern void SpuSetVoiceAR (int vNum, unsigned short AR);
extern void SpuSetVoiceDR (int vNum, unsigned short DR);
extern void SpuSetVoiceSR (int vNum, unsigned short SR);
extern void SpuSetVoiceRR (int vNum, unsigned short RR);
extern void SpuSetVoiceSL (int vNum, unsigned short SL);
extern void SpuSetVoiceARAttr (int vNum, unsigned short AR, long ARmode);
extern void SpuSetVoiceSRAttr (int vNum, unsigned short SR, long SRmode);
extern void SpuSetVoiceRRAttr (int vNum, unsigned short RR, long RRmode);
extern void SpuSetVoiceADSR (int vNum, unsigned short AR, unsigned short DR,
unsigned short SR, unsigned short RR,
unsigned short SL);
extern void SpuSetVoiceADSRAttr (int vNum,
unsigned short AR, unsigned short DR,
unsigned short SR, unsigned short RR,
unsigned short SL,
long ARmode, long SRmode, long RRmode);
extern void SpuGetVoiceVolume (int vNum, short *volL, short *volR);
extern void SpuGetVoiceVolumeAttr (int vNum, short *volL, short *volR,
short *volModeL, short *volModeR);
extern void SpuGetVoiceVolumeX (int vNum, short *volXL, short *volXR);
extern void SpuGetVoicePitch (int vNum, unsigned short *pitch);
extern void SpuGetVoiceNote (int vNum, unsigned short *note);
extern void SpuGetVoiceSampleNote (int vNum, unsigned short *sampleNote);
extern void SpuGetVoiceEnvelope (int vNum, short *envx);
extern void SpuGetVoiceStartAddr (int vNum, unsigned long *startAddr);
extern void SpuGetVoiceLoopStartAddr (int vNum, unsigned long *loopStartAddr);
extern void SpuGetVoiceAR (int vNum, unsigned short *AR);
extern void SpuGetVoiceDR (int vNum, unsigned short *DR);
extern void SpuGetVoiceSR (int vNum, unsigned short *SR);
extern void SpuGetVoiceRR (int vNum, unsigned short *RR);
extern void SpuGetVoiceSL (int vNum, unsigned short *SL);
extern void SpuGetVoiceARAttr (int vNum, unsigned short *AR, long *ARmode);
extern void SpuGetVoiceSRAttr (int vNum, unsigned short *SR, long *SRmode);
extern void SpuGetVoiceRRAttr (int vNum, unsigned short *RR, long *RRmode);
extern void SpuGetVoiceADSR (int vNum,
unsigned short *AR, unsigned short *DR,
unsigned short *SR, unsigned short *RR,
unsigned short *SL);
extern void SpuGetVoiceADSRAttr (int vNum,
unsigned short *AR, unsigned short *DR,
unsigned short *SR, unsigned short *RR,
unsigned short *SL,
long *ARmode, long *SRmode, long *RRmode);
extern void SpuGetVoiceEnvelopeAttr (int vNum, long *keyStat, short *envx );
extern void SpuSetCommonMasterVolume (short mvol_left, short mvol_right);
extern void SpuSetCommonMasterVolumeAttr (short mvol_left, short mvol_right,
short mvolmode_left,
short mvolmode_right);
extern void SpuSetCommonCDMix (long cd_mix);
extern void SpuSetCommonCDVolume (short cd_left, short cd_right);
extern void SpuSetCommonCDReverb (long cd_reverb);
extern void SpuGetCommonMasterVolume (short *mvol_left, short *mvol_right);
extern void SpuGetCommonMasterVolumeX (short *mvolx_left, short *mvolx_right);
extern void SpuGetCommonMasterVolumeAttr (short *mvol_left, short *mvol_right,
short *mvolmode_left,
short *mvolmode_right);
extern void SpuGetCommonCDMix (long *cd_mix);
extern void SpuGetCommonCDVolume (short *cd_left, short *cd_right);
extern void SpuGetCommonCDReverb (long *cd_reverb);
extern long SpuSetReverbModeType (long mode);
extern void SpuSetReverbModeDepth (short depth_left, short depth_right);
extern void SpuSetReverbModeDelayTime (long delay);
extern void SpuSetReverbModeFeedback (long feedback);
extern void SpuGetReverbModeType (long *mode);
extern void SpuGetReverbModeDepth (short *depth_left, short *depth_right);
extern void SpuGetReverbModeDelayTime (long *delay);
extern void SpuGetReverbModeFeedback (long *feedback);
extern void SpuSetESA( long revAddr );
#if defined(_LANGUAGE_C_PLUS_PLUS) || defined(__cplusplus) || defined(c_plusplus)
}
#endif
/* ---------------------------------------------------------------- */
#define SPU_ST_NOT_AVAILABLE 0
#define SPU_ST_ACCEPT 1
#define SPU_ST_ERROR (-1)
#define SPU_ST_INVALID_ARGUMENT (-2)
#define SPU_ST_WRONG_STATUS (-3)
#define SPU_ST_STOP 2
#define SPU_ST_IDLE 3
#define SPU_ST_PREPARE 4
#define SPU_ST_START 5
#define SPU_ST_PLAY 6
#define SPU_ST_TRANSFER 7
#define SPU_ST_FINAL 8
/* VAG's header size */
#define SPU_ST_VAG_HEADER_SIZE 0x30
typedef struct {
char status; /* stream status */
char pad1; /* padding */
char pad2; /* padding */
char pad3; /* padding */
long last_size; /* the size of last transferring
(last_size <= (size / 2)) */
unsigned long buf_addr; /* The start address of stream buffer */
unsigned long data_addr; /* The start address of SPU streaming
data in main memory */
} SpuStVoiceAttr;
typedef struct {
long size; /* The size of stream buffer */
long low_priority; /* transfer priority */
SpuStVoiceAttr voice [24];
} SpuStEnv;
#ifndef __SPU_ST_TRANSFERCALLBACK_PROC
#define __SPU_ST_TRANSFERCALLBACK_PROC
typedef void (*SpuStCallbackProc)(unsigned long, long);
#endif /* __SPU_TRANSFERCALLBACK_PROC */
#if defined(_LANGUAGE_C_PLUS_PLUS) || defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern SpuStEnv *SpuStInit (long);
extern long SpuStQuit (void);
extern long SpuStGetStatus (void);
extern unsigned long SpuStGetVoiceStatus (void);
extern long SpuStTransfer (long flag, unsigned long voice_bit);
extern SpuStCallbackProc SpuStSetPreparationFinishedCallback (SpuStCallbackProc func);
extern SpuStCallbackProc SpuStSetTransferFinishedCallback (SpuStCallbackProc func);
extern SpuStCallbackProc SpuStSetStreamFinishedCallback (SpuStCallbackProc func);
#if defined(_LANGUAGE_C_PLUS_PLUS) || defined(__cplusplus) || defined(c_plusplus)
}
#endif
/* ----------------------------------------------------------------
* End on File
* ---------------------------------------------------------------- */
#endif /* _LIBSPU_H_ */
/* DON'T ADD STUFF AFTER THIS */

235
rebuild_PC/PsyCross/include/psx/r3000.h
View File

@ -1,235 +0,0 @@
#ifndef R3000_H
#define R3000_H
#define K0BASE 0x80000000
#define K0SIZE 0x20000000
#define K1BASE 0xA0000000
#define K1SIZE 0x20000000
#define K2BASE 0xC0000000
#define K2SIZE 0x20000000
#define UT_VEC K0BASE /* utlbmiss vector */
#define E_VEC (K0BASE+0x80) /* exception vector */
#define R_VEC (K1BASE+0x1fc00000) /* reset vector */
/*
* Address conversion macros
*/
#define K0_TO_K1(x) ((unsigned)(x)|0xA0000000) /* kseg0 to kseg1 */
#define K1_TO_K0(x) ((unsigned)(x)&0x9FFFFFFF) /* kseg1 to kseg0 */
#define K0_TO_PHYS(x) ((unsigned)(x)&0x1FFFFFFF) /* kseg0 to physical */
#define K1_TO_PHYS(x) ((unsigned)(x)&0x1FFFFFFF) /* kseg1 to physical */
#define PHYS_TO_K0(x) ((unsigned)(x)|0x80000000) /* physical to kseg0 */
#define PHYS_TO_K1(x) ((unsigned)(x)|0xA0000000) /* physical to kseg1 */
/*
* Address predicates
*/
#define IS_KSEG0(x) ((unsigned)(x) >= K0BASE && (unsigned)(x) < K1BASE)
#define IS_KSEG1(x) ((unsigned)(x) >= K1BASE && (unsigned)(x) < K2BASE)
#define IS_KSEG2(x) ((unsigned)(x) >= K2BASE && (unsigned)(x) < KPTEBASE)
#define IS_KPTESEG(x) ((unsigned)(x) >= KPTEBASE)
#define IS_KUSEG(x) ((unsigned)(x) < K0BASE)
/*
* Cache size constants
*/
#define MINCACHE +(4*1024) /* leading plus for mas's benefit */
#define MAXCACHE +(64*1024) /* leading plus for mas's benefit */
/*
* Status register
*/
#define SR_CUMASK 0xf0000000 /* coproc usable bits */
#define SR_CU3 0x80000000 /* Coprocessor 3 usable */
#define SR_CU2 0x40000000 /* Coprocessor 2 usable */
#define SR_CU1 0x20000000 /* Coprocessor 1 usable */
#define SR_CU0 0x10000000 /* Coprocessor 0 usable */
#define SR_BEV 0x00400000 /* use boot exception vectors */
/* Cache control bits */
#define SR_TS 0x00200000 /* TLB shutdown */
#define SR_PE 0x00100000 /* cache parity error */
#define SR_CM 0x00080000 /* cache miss */
#define SR_PZ 0x00040000 /* cache parity zero */
#define SR_SWC 0x00020000 /* swap cache */
#define SR_ISC 0x00010000 /* Isolate data cache */
#define SR_MM_MODE 0x00010000 /* lwl/swl/etc become scache/etc */
#define lcache lwl
#define scache swl
#define flush lwr $0,
#define inval swr $0,
/*
* Interrupt enable bits
* (NOTE: bits set to 1 enable the corresponding level interrupt)
*/
#define SR_IMASK 0x0000ff00 /* Interrupt mask */
#define SR_IMASK8 0x00000000 /* mask level 8 */
#define SR_IMASK7 0x00008000 /* mask level 7 */
#define SR_IMASK6 0x0000c000 /* mask level 6 */
#define SR_IMASK5 0x0000e000 /* mask level 5 */
#define SR_IMASK4 0x0000f000 /* mask level 4 */
#define SR_IMASK3 0x0000f800 /* mask level 3 */
#define SR_IMASK2 0x0000fc00 /* mask level 2 */
#define SR_IMASK1 0x0000fe00 /* mask level 1 */
#define SR_IMASK0 0x0000ff00 /* mask level 0 */
#define SR_IBIT8 0x00008000 /* bit level 8 */
#define SR_IBIT7 0x00004000 /* bit level 7 */
#define SR_IBIT6 0x00002000 /* bit level 6 */
#define SR_IBIT5 0x00001000 /* bit level 5 */
#define SR_IBIT4 0x00000800 /* bit level 4 */
#define SR_IBIT3 0x00000400 /* bit level 3 */
#define SR_IBIT2 0x00000200 /* bit level 2 */
#define SR_IBIT1 0x00000100 /* bit level 1 */
#define SR_KUO 0x00000020 /* old kernel/user, 0 => k, 1 => u */
#define SR_IEO 0x00000010 /* old interrupt enable, 1 => enable */
#define SR_KUP 0x00000008 /* prev kernel/user, 0 => k, 1 => u */
#define SR_IEP 0x00000004 /* prev interrupt enable, 1 => enable */
#define SR_KUC 0x00000002 /* cur kernel/user, 0 => k, 1 => u */
#define SR_IEC 0x00000001 /* cur interrupt enable, 1 => enable */
#define SR_IMASKSHIFT 8
#define SR_FMT "\20\40BD\26TS\25PE\24CM\23PZ\22SwC\21IsC\20IM7\17IM6\16IM5\15IM4\14IM3\13IM2\12IM1\11IM0\6KUo\5IEo\4KUp\3IEp\2KUc\1IEc"
/*
* Cause Register
*/
#define CAUSE_BD 0x80000000 /* Branch delay slot */
#define CAUSE_CEMASK 0x30000000 /* coprocessor error */
#define CAUSE_CESHIFT 28
/* Interrupt pending bits */
#define CAUSE_IP8 0x00008000 /* External level 8 pending */
#define CAUSE_IP7 0x00004000 /* External level 7 pending */
#define CAUSE_IP6 0x00002000 /* External level 6 pending */
#define CAUSE_IP5 0x00001000 /* External level 5 pending */
#define CAUSE_IP4 0x00000800 /* External level 4 pending */
#define CAUSE_IP3 0x00000400 /* External level 3 pending */
#define CAUSE_SW2 0x00000200 /* Software level 2 pending */
#define CAUSE_SW1 0x00000100 /* Software level 1 pending */
#define CAUSE_IPMASK 0x0000FF00 /* Pending interrupt mask */
#define CAUSE_IPSHIFT 8
#define CAUSE_EXCMASK 0x0000003C /* Cause code bits */
#define CAUSE_EXCSHIFT 2
#define CAUSE_FMT "\20\40BD\36CE1\35CE0\20IP8\17IP7\16IP6\15IP5\14IP4\13IP3\12SW2\11SW1\1INT"
/* Cause register exception codes */
#define EXC_CODE(x) ((x)<<2)
/* Hardware exception codes */
#define EXC_INT EXC_CODE(0) /* interrupt */
#define EXC_MOD EXC_CODE(1) /* TLB mod */
#define EXC_RMISS EXC_CODE(2) /* Read TLB Miss */
#define EXC_WMISS EXC_CODE(3) /* Write TLB Miss */
#define EXC_RADE EXC_CODE(4) /* Read Address Error */
#define EXC_WADE EXC_CODE(5) /* Write Address Error */
#define EXC_IBE EXC_CODE(6) /* Instruction Bus Error */
#define EXC_DBE EXC_CODE(7) /* Data Bus Error */
#define EXC_SYSCALL EXC_CODE(8) /* SYSCALL */
#define EXC_BREAK EXC_CODE(9) /* BREAKpoint */
#define EXC_II EXC_CODE(10) /* Illegal Instruction */
#define EXC_CPU EXC_CODE(11) /* CoProcessor Unusable */
#define EXC_OV EXC_CODE(12) /* OVerflow */
/* software exception codes */
#define SEXC_SEGV EXC_CODE(16) /* Software detected seg viol */
#define SEXC_RESCHED EXC_CODE(17) /* resched request */
#define SEXC_PAGEIN EXC_CODE(18) /* page-in request */
#define SEXC_CPU EXC_CODE(19) /* coprocessor unusable */
/*
* Coprocessor 0 registers
*/
#define C0_INX $0 /* tlb index */
#define C0_RAND $1 /* tlb random */
#define C0_TLBLO $2 /* tlb entry low */
#define C0_CTXT $4 /* tlb context */
#define C0_PIDMASK $6 /* Mips2 */
#define C0_BADVADDR $8 /* bad virtual address */
#define C0_TLBHI $10 /* tlb entry hi */
#define C0_PID $10 /* Mips2 */
#define C0_SR $12 /* status register */
#define C0_CAUSE $13 /* exception cause */
#define C0_EPC $14 /* exception pc */
#define C0_PRID $15 /* revision identifier */
#define C0_ERREG $16 /* Mips2 */
/*
* Coprocessor 0 operations
*/
#define C0_READI 0x1 /* read ITLB entry addressed by C0_INDEX */
#define C0_WRITEI 0x2 /* write ITLB entry addressed by C0_INDEX */
#define C0_WRITER 0x6 /* write ITLB entry addressed by C0_RAND */
#define C0_PROBE 0x8 /* probe for ITLB entry addressed by TLBHI */
#define C0_RFE 0x10 /* restore for exception */
/*
* Flags for the nofault handler. 0 means no fault is expected.
*/
#define NF_BADADDR 1 /* badaddr, wbadaddr */
#define NF_COPYIO 2 /* copyin, copyout */
#define NF_ADDUPC 3 /* addupc */
#define NF_FSUMEM 4 /* fubyte, subyte, fuword, suword */
#define NF_USERACC 5 /* useracc */
#define NF_SOFTFP 6 /* softfp */
#define NF_REVID 7 /* revision ids */
#define NF_NENTRIES 8
/*
* TLB size constants
*/
#define TLBWIREDBASE 0 /* WAG for now */
#define NWIREDENTRIES 8 /* WAG for now */
#define TLBRANDOMBASE NWIREDENTRIES
#define NRANDOMENTRIES (NTLBENTRIES-NWIREDENTRIES)
#define NTLBENTRIES 64 /* WAG for now */
#define TLBRAND_RANDMASK 0x00003f00
#define TLBRAND_RANDSHIFT 8
/*
* Chip interrupt vector
*/
#define NC0VECS 8
#ifndef LOCORE
#ifdef KERNEL
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
extern "C" {
#endif
extern int (*c0vec_tbl[])();
#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
}
#endif
#endif
#endif /* !LOCORE */
#define BRK_KERNEL 0xf1
#define EXCEPT_NORM 1
#define EXCEPT_UTLB 2
#define EXCEPT_BRKPT 3
#define EXCEPT_DB 4
#define EXCEPT_GDB 4
#define EXCEPT_INT 9
#define EXCEPT_ELSE 0xff
#endif /* _R3000_H */

7
rebuild_PC/PsyCross/include/psx/rand.h
View File

@ -1,7 +0,0 @@
#ifndef RAND_H
#define RAND_H
#include <stdint.h>
#include <stdlib.h>
#endif

7
rebuild_PC/PsyCross/include/psx/strings.h
View File

@ -1,7 +0,0 @@
#ifndef STRINGS_H
#define STRINGS_H
#include <string.h> // temp
#include <ctype.h> // temp
#endif

52
rebuild_PC/PsyCross/include/psx/types.h
View File

@ -1,52 +0,0 @@
#ifndef TYPES_H
#define TYPES_H
#include <stdint.h>
#include <stddef.h>
#if !defined(__APPLE__)
/* major part of a device */
#define major(x) ((int)(((unsigned)(x)>>8)&0377))
/* minor part of a device */
#define minor(x) ((int)((x)&0377))
/* make a device number */
#define makedev(x,y) ((dev_t)(((x)<<8) | (y)))
#endif
#ifndef _UCHAR_T
#define _UCHAR_T
typedef unsigned char u_char;
#endif
#ifndef _USHORT_T
#define _USHORT_T
typedef unsigned short u_short;
#endif
#ifndef _UINT_T
#define _UINT_T
typedef unsigned int u_int;
#endif
#ifndef _ULONG_T
#define _ULONG_T
typedef unsigned long u_long;
#endif
#ifndef _SYSIII_USHORT
#define _SYSIII_USHORT
typedef unsigned short ushort; /* sys III compat */
#endif
#ifndef __psx__
#ifndef _SYSV_UINT
#define _SYSV_UINT
typedef unsigned int uint; /* sys V compat */
#endif
#ifndef _SYSV_ULONG
#define _SYSV_ULONG
typedef unsigned long ulong; /* sys V compat */
#endif
#endif /* ! __psx__ */
#define NBBY 8
#endif

2
rebuild_PC/build-mingw-clang.nix
View File

@ -3,4 +3,4 @@
, pkgsCross ? pkgs.pkgsCross.mingw32
}:
pkgsCross.callPackage ./default.nix { stdenv = pkgsCross.clangStdenv; }
pkgsCross.callPackage ./default.nix { stdenv = pkgsCross.clangStdenv; trustCompiler = true; }

46
rebuild_PC/default.nix
View File

@ -2,14 +2,29 @@
, stdenv
, callPackage
, pkg-config
, cmake
, openal
, SDL2
, ctrModSDK ? ./..
, psyCross ? callPackage ./PsyCross.nix { inherit psyCrossDebug; }
, psyCrossDebug ? false
, withDebug ? true
, trustCompiler ? false
}:
let
isWindows = stdenv.hostPlatform.uname.system == "Windows";
openalWithWindows =
if isWindows then
(openal.override {
alsaSupport = false;
dbusSupport = false;
pipewireSupport = false;
pulseSupport = false;
}).overrideAttrs (prevAttrs: {
meta = prevAttrs.meta // { inherit (SDL2.meta) platforms; };
})
else openal;
mainProgram = if isWindows then "CrashTeamRacingPC.exe" else "CrashTeamRacingPC";
in
stdenv.mkDerivation (finalAttrs: {
@ -21,36 +36,33 @@ stdenv.mkDerivation (finalAttrs: {
if ctrModSDK == ./.. then "CTR-ModSDK/rebuild_PC"
else "source/rebuild_PC";
nativeBuildInputs = [ pkg-config ];
buildInputs = psyCross.propagatedBuildInputs;
LDLIBS = "-L./PsyCross";
nativeBuildInputs = [ pkg-config cmake ];
buildInputs = [ openalWithWindows SDL2 ];
# Disables incompatible hardening
hardeningDisable = [ "format" ];
postPatch = ''
rm -r PsyCross
ln -s ${psyCross} PsyCross
'';
installPhase = ''
runHook preInstall
mkdir -p $out/bin
'' + lib.strings.optionalString isWindows ''
cp ${psyCross.openal}/bin/*.dll $out/bin/
cp ${psyCross.SDL2}/bin/*.dll $out/bin/
cp ${openalWithWindows}/bin/*.dll $out/bin/
cp ${SDL2}/bin/*.dll $out/bin/
'' + ''
cp ${mainProgram} $out/bin/
runHook postInstall
'';
# If you need vendored deps
#cmakeFlags = [ "-DCMAKE_SKIP_BUILD_RPATH=TRUE" ];
# Debug
CFLAGS = "-g -gdwarf-2";
dontStrip = true;
passthru = { inherit psyCross; };
cmakeFlags = lib.optionals withDebug [ "-DCMAKE_BUILD_TYPE=Debug" ]
++ lib.optionals trustCompiler [ "-DCMAKE_C_COMPILER_WORKS=1" "-DCMAKE_CXX_COMPILER_WORKS=1" ];
dontStrip = withDebug;
passthru = { openal = openalWithWindows; };
# Shows the proper compile date in the logs
env.SOURCE_DATE_EPOCH = (builtins.currentTime or ctrModSDK.lastModified);
@ -61,6 +73,6 @@ stdenv.mkDerivation (finalAttrs: {
license = lib.licenses.publicDomain;
maintainers = with lib.maintainers; [ pedrohlc ];
inherit mainProgram;
inherit (psyCross.meta) platforms;
inherit (SDL2.meta) platforms;
};
})

1
rebuild_PC/thirdparty/PsyCross vendored Submodule

@ -0,0 +1 @@
Subproject commit 0ce306d6c32412986037e7e5e1dbdc1bf72e066a

1
rebuild_PC/thirdparty/SDL vendored Submodule

@ -0,0 +1 @@
Subproject commit f461d91cd265d7b9a44b4d472b1df0c0ad2855a0

1
rebuild_PC/thirdparty/openal-soft vendored Submodule

@ -0,0 +1 @@
Subproject commit d3875f333fb6abe2f39d82caca329414871ae53b