├── src ├── graphics │ ├── mod.rs │ └── gxm.rs ├── dialog │ ├── mod.rs │ ├── common.rs │ └── message.rs ├── io │ ├── mod.rs │ ├── dirent.rs │ ├── devctl.rs │ ├── stat.rs │ └── fcntl.rs ├── kernel │ ├── mod.rs │ ├── processmgr.rs │ ├── rng.rs │ ├── clib.rs │ ├── sysmem.rs │ └── threadmgr.rs ├── lib.rs ├── system_param.rs ├── display.rs ├── types.rs └── ctrl.rs ├── .gitignore ├── examples └── hello_rust_world │ ├── src │ ├── debug │ │ ├── mod.rs │ │ ├── font.bin │ │ ├── font.rs │ │ └── screen.rs │ └── lib.rs │ ├── .gitignore │ ├── static │ └── sce_sys │ │ ├── icon0.png │ │ └── livearea │ │ └── contents │ │ ├── bg.png │ │ ├── startup.png │ │ └── template.xml │ ├── Cargo.toml │ ├── Makefile.toml │ └── README.md ├── Cargo.toml ├── COPYING ├── Makefile.toml ├── .travis.yml ├── README.md └── CHANGELOG.md /src/graphics/mod.rs: -------------------------------------------------------------------------------- 1 | pub mod gxm; 2 | -------------------------------------------------------------------------------- /src/dialog/mod.rs: -------------------------------------------------------------------------------- 1 | pub mod common; 2 | pub mod message; 3 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | **/*.rs.bk 3 | Cargo.lock 4 | common.toml 5 | -------------------------------------------------------------------------------- /examples/hello_rust_world/src/debug/mod.rs: -------------------------------------------------------------------------------- 1 | pub mod font; 2 | pub mod screen; 3 | -------------------------------------------------------------------------------- /src/io/mod.rs: -------------------------------------------------------------------------------- 1 | pub mod devctl; 2 | pub mod dirent; 3 | pub mod fcntl; 4 | pub mod stat; 5 | -------------------------------------------------------------------------------- /examples/hello_rust_world/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | **/*.rs.bk 3 | Cargo.lock 4 | common.toml 5 | armv7-vita-eabihf 6 | -------------------------------------------------------------------------------- /src/kernel/mod.rs: -------------------------------------------------------------------------------- 1 | pub mod clib; 2 | pub mod processmgr; 3 | pub mod rng; 4 | pub mod sysmem; 5 | pub mod threadmgr; 6 | -------------------------------------------------------------------------------- /examples/hello_rust_world/src/debug/font.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vita-rust/psp2-sys/HEAD/examples/hello_rust_world/src/debug/font.bin -------------------------------------------------------------------------------- /examples/hello_rust_world/static/sce_sys/icon0.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vita-rust/psp2-sys/HEAD/examples/hello_rust_world/static/sce_sys/icon0.png -------------------------------------------------------------------------------- /examples/hello_rust_world/static/sce_sys/livearea/contents/bg.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vita-rust/psp2-sys/HEAD/examples/hello_rust_world/static/sce_sys/livearea/contents/bg.png -------------------------------------------------------------------------------- /examples/hello_rust_world/static/sce_sys/livearea/contents/startup.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vita-rust/psp2-sys/HEAD/examples/hello_rust_world/static/sce_sys/livearea/contents/startup.png -------------------------------------------------------------------------------- /src/kernel/processmgr.rs: -------------------------------------------------------------------------------- 1 | #[cfg_attr( 2 | not(feature = "dox"), 3 | link(kind = "static", name = "SceLibKernel_stub") 4 | )] 5 | extern "C" { 6 | pub fn sceKernelExitProcess(res: i32) -> i32; 7 | } 8 | -------------------------------------------------------------------------------- /src/kernel/rng.rs: -------------------------------------------------------------------------------- 1 | #[cfg_attr( 2 | not(feature = "dox"), 3 | link(kind = "static", name = "SceLibKernel_stub") 4 | )] 5 | extern "C" { 6 | pub fn sceKernelGetRandomNumber(output: *mut crate::void, size: u32); 7 | } 8 | -------------------------------------------------------------------------------- /examples/hello_rust_world/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "bare_metal_rust" 3 | version = "0.1.0" 4 | authors = ["Martin Larralde "] 5 | edition = "2018" 6 | 7 | [lib] 8 | crate-type = ["staticlib"] 9 | 10 | [dependencies] 11 | psp2-sys = { path = "../.." } 12 | 13 | [profile.release] 14 | lto = true 15 | panic = 'abort' 16 | -------------------------------------------------------------------------------- /examples/hello_rust_world/static/sce_sys/livearea/contents/template.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | bg.png 6 | 7 | 8 | 9 | startup.png 10 | 11 | 12 | -------------------------------------------------------------------------------- /examples/hello_rust_world/Makefile.toml: -------------------------------------------------------------------------------- 1 | extend = "common.toml" 2 | 3 | [env] 4 | # Project information 5 | TITLE = "Rust Hello World" 6 | TITLEID = "RUST00001" 7 | 8 | [config] 9 | load_script = [ 10 | """ 11 | if [ ! -f common.toml ]; then 12 | curl -SsL https://github.com/vita-rust/common/raw/master/common.toml > common.toml 13 | fi 14 | """ 15 | ] 16 | -------------------------------------------------------------------------------- /src/lib.rs: -------------------------------------------------------------------------------- 1 | #![feature(extern_types)] 2 | #![allow(non_camel_case_types)] 3 | #![allow(non_snake_case)] 4 | #![allow(dead_code)] 5 | #![no_std] 6 | 7 | pub mod ctrl; 8 | pub mod dialog; 9 | pub mod display; 10 | pub mod graphics; 11 | pub mod io; 12 | pub mod kernel; 13 | pub mod system_param; 14 | pub mod types; 15 | 16 | /// A placeholder enum for functions with `*void` arguments. 17 | /// 18 | /// Only manipulate behind pointers ! 19 | pub enum void {} 20 | -------------------------------------------------------------------------------- /examples/hello_rust_world/src/debug/font.rs: -------------------------------------------------------------------------------- 1 | pub struct PsvDebugScreenFont { 2 | pub glyphs: &'static [u8], 3 | pub width: usize, 4 | pub height: usize, 5 | pub first: u8, 6 | pub last: u8, 7 | pub size_w: usize, 8 | pub size_h: usize, 9 | } 10 | 11 | pub const DEBUG_FONT: PsvDebugScreenFont = PsvDebugScreenFont { 12 | glyphs: include_bytes!("font.bin"), 13 | width: 8, 14 | height: 8, 15 | first: 0, 16 | last: 255, 17 | size_w: 8, 18 | size_h: 8, 19 | }; 20 | -------------------------------------------------------------------------------- /src/io/dirent.rs: -------------------------------------------------------------------------------- 1 | use crate::types::SceUID; 2 | 3 | use super::stat::SceIoStat; 4 | 5 | #[repr(C)] 6 | pub struct SceIoDirent { 7 | pub d_stat: SceIoStat, 8 | pub d_name: [u8; 256], 9 | pub d_private: *mut crate::void, 10 | pub dummy: i32, 11 | } 12 | 13 | #[cfg_attr( 14 | not(feature = "dox"), 15 | link(kind = "static", name = "SceLibKernel_stub") 16 | )] 17 | extern "C" { 18 | pub fn sceIoDopen(dirname: *const u8) -> SceUID; 19 | pub fn sceIoDread(fd: SceUID, dir: *mut SceIoDirent) -> i32; 20 | pub fn sceIoDclose(fd: SceUID) -> i32; 21 | } 22 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "psp2-sys" 3 | version = "0.2.2" 4 | authors = ["Martin Larralde "] 5 | edition = "2018" 6 | license = "MIT" 7 | description = "Unsafe Rust FFI bindings to the psp2 headers" 8 | repository = "https://github.com/vita-rust/psp2-sys" 9 | readme = "README.md" 10 | keywords = ["ps-vita", "psp2"] 11 | categories = ["no-std", "external-ffi-bindings", "os", "hardware-support"] 12 | exclude = ["ci/travis/setup.sh", "Makefile.toml"] 13 | 14 | [package.metadata.docs.rs] 15 | features = ["dox"] 16 | 17 | [lib] 18 | name = "psp2_sys" 19 | path = "src/lib.rs" 20 | 21 | [badges] 22 | travis-ci = { repository = "vita-rust/psp2-sys" } 23 | maintenance = { status = "actively-developed" } 24 | 25 | [features] 26 | default = [] 27 | unsafe = [] 28 | dox = [] 29 | -------------------------------------------------------------------------------- /examples/hello_rust_world/README.md: -------------------------------------------------------------------------------- 1 | # `hello_rust_world` 2 | 3 | An example app that will show a Hello World message using the 4 | [debug screen](https://github.com/vitasdk/samples/tree/master/debugscreen) from 5 | the [VitaSDK samples](https://github.com/vitasdk/samples). 6 | 7 | ## Compiling 8 | 9 | Make sure [`cargo-make`](https://sagiegurari.github.io/cargo-make/) is installed, 10 | and run: 11 | ```console 12 | $ cargo make vpk 13 | ``` 14 | 15 | This will generate a file named `bare_metal_rust.vpk` in `target/armv7-vita-eabihf/release/` 16 | without linking to any library other than the `psp2-sys` `sceKernel` library stubs. 17 | 18 | ## Deploying 19 | 20 | Transfer the *VPK* to the `ux0:` partition of a PS Vita running under 21 | [Henkaku](https://github.com/henkaku/henkaku) or 22 | [h-encore](https://github.com/TheOfficialFloW/h-encore) and install through 23 | [VitaShell](https://github.com/TheOfficialFloW/VitaShell). The resulting app is 24 | flagged as *safe* and should not trigger warnings during installation. 25 | -------------------------------------------------------------------------------- /src/io/devctl.rs: -------------------------------------------------------------------------------- 1 | use crate::types::SceOff; 2 | use crate::types::SceSize; 3 | use crate::types::SceUID; 4 | 5 | #[repr(C)] 6 | pub struct SceIoDevInfo { 7 | pub max_size: SceOff, 8 | pub free_size: SceOff, 9 | pub cluster_size: SceSize, 10 | pub unk: *mut crate::void, 11 | } 12 | 13 | #[cfg_attr( 14 | not(feature = "dox"), 15 | link(kind = "static", name = "SceLibKernel_stub") 16 | )] 17 | extern "C" { 18 | pub fn sceIoDevctl( 19 | dev: *const u8, 20 | cmd: u32, 21 | indata: *mut crate::void, 22 | inlen: i32, 23 | outdata: *mut crate::void, 24 | outlen: i32, 25 | ) -> i32; 26 | pub fn sceIoIoctl( 27 | fd: SceUID, 28 | cmd: u32, 29 | indata: *mut crate::void, 30 | inlen: i32, 31 | outdata: *mut crate::void, 32 | outlen: i32, 33 | ) -> i32; 34 | pub fn sceIoIoctlAsync( 35 | fd: SceUID, 36 | cmd: u32, 37 | indata: *mut crate::void, 38 | inlen: i32, 39 | outdata: *mut crate::void, 40 | outlen: i32, 41 | ) -> i32; 42 | } 43 | -------------------------------------------------------------------------------- /COPYING: -------------------------------------------------------------------------------- 1 | Copyright (c) 2018 Martin Larralde (martin.larralde@ens-cachan.fr) 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining a copy 4 | of this software and associated documentation files (the "Software"), to deal 5 | in the Software without restriction, including without limitation the rights 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 7 | copies of the Software, and to permit persons to whom the Software is 8 | furnished to do so, subject to the following conditions: 9 | 10 | The above copyright notice and this permission notice shall be included in all 11 | copies or substantial portions of the Software. 12 | 13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 14 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 15 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 16 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 17 | DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 18 | OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE 19 | OR OTHER DEALINGS IN THE SOFTWARE. 20 | -------------------------------------------------------------------------------- /Makefile.toml: -------------------------------------------------------------------------------- 1 | extend = "common.toml" 2 | 3 | [config] 4 | load_script = [ 5 | """ 6 | if [ ! -f common.toml ]; then 7 | curl -SsL https://github.com/vita-rust/common/raw/master/common.toml > common.toml; 8 | fi 9 | """ 10 | ] 11 | 12 | [tasks.default] 13 | alias = "build" 14 | 15 | 16 | ### TESTING #################################################################### 17 | 18 | [tasks.build-native] 19 | command = "cargo" 20 | args = ["build"] 21 | 22 | [tasks.test-native] 23 | command = "cargo" 24 | args = ["test"] 25 | 26 | 27 | ### RELEASE FLOW ############################################################### 28 | 29 | [tasks.pre-publish] 30 | dependencies = ["verify-project"] 31 | 32 | [tasks.publish] 33 | alias = 'crates-publish' 34 | 35 | [tasks.crates-publish] 36 | script = ['cargo publish --token $CRATES_IO_TOKEN'] 37 | 38 | [tasks.post-publish] 39 | dependencies = ["chandler"] 40 | 41 | [tasks.chandler] 42 | description = "Update GitHub release notes with appropriate CHANGELOG sections" 43 | install_script = ["gem install chandler -n target/gems"] 44 | script = [ 45 | ''' 46 | target/gems/chandler push --github=$(echo $CARGO_MAKE_CRATE_REPOSITORY | cut -d/ -f4-5) 47 | ''' 48 | ] 49 | -------------------------------------------------------------------------------- /examples/hello_rust_world/src/lib.rs: -------------------------------------------------------------------------------- 1 | #![allow(dead_code, unused_imports, unused_variables, unused_macros, unused_parens)] 2 | #![feature(lang_items, core_intrinsics, start)] 3 | #![no_std] 4 | 5 | extern crate psp2_sys as psp2; 6 | 7 | mod debug; 8 | 9 | use core::fmt::Write; 10 | use core::intrinsics; 11 | use core::panic::PanicInfo; 12 | 13 | #[lang = "eh_personality"] 14 | #[no_mangle] 15 | pub extern "C" fn eh_personality() {} 16 | 17 | #[panic_handler] 18 | #[no_mangle] 19 | fn panic(_info: &PanicInfo) -> ! { 20 | intrinsics::abort() 21 | } 22 | 23 | #[no_mangle] 24 | pub unsafe fn main(_argc: isize, _argv: *const *const u8) -> isize { 25 | let mut screen = debug::screen::DebugScreen::new(); 26 | write!(screen, "This bare-metal is starting to rust!\n").ok(); 27 | psp2::kernel::threadmgr::sceKernelDelayThread(1 * 1000000); // Wait for 1 second 28 | write!(screen, "See ? I told you !\n").ok(); 29 | psp2::kernel::threadmgr::sceKernelDelayThread(3 * 1000000); 30 | psp2::kernel::processmgr::sceKernelExitProcess(0); 31 | return 0; 32 | } 33 | 34 | #[start] 35 | #[no_mangle] 36 | pub unsafe fn _start(argc: isize, argv: *const *const u8) -> isize { 37 | main(argc, argv) 38 | } 39 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | language: rust 3 | cache: 4 | cargo: true 5 | directories: 6 | - "$SCCACHE_DIR" 7 | - "$HOME/.xargo" 8 | 9 | addons: 10 | apt: 11 | packages: 12 | - libc6-i386 13 | - lib32stdc++6 14 | - lib32gcc1 15 | - patch 16 | 17 | rust: 18 | - nightly 19 | 20 | env: 21 | global: 22 | # sccache 23 | - CARGO_HOME="$HOME/.cargo" 24 | - RUSTC_WRAPPER="sccache" 25 | - SCCACHE_DIR="$HOME/.cache/sccache" 26 | # vitasdk 27 | - VITASDK="$HOME/.local/share/vitasdk" 28 | - PATH="$VITASDK/bin:$PATH" 29 | 30 | install: 31 | - curl -SsL "https://raw.githubusercontent.com/vita-rust/common/master/ci/travis/setup.sh" | sh 32 | 33 | script: 34 | - cargo make build # Compile natively 35 | - cargo make xbuild # Cross-compile 36 | - cd examples/hello_rust_world && cargo make vpk # Build example VPK 37 | 38 | before_deploy: 39 | - cd $TRAVIS_BUILD_DIR 40 | 41 | deploy: 42 | provider: script 43 | script: cargo make publish-flow 44 | on: 45 | tags: true 46 | repo: vita-rust/psp2-sys 47 | rust: nightly 48 | 49 | notifications: 50 | email: 51 | - althonosdev@gmail.com 52 | -------------------------------------------------------------------------------- /src/kernel/clib.rs: -------------------------------------------------------------------------------- 1 | use crate::types::SceSize; 2 | 3 | #[cfg_attr( 4 | not(feature = "dox"), 5 | link(kind = "static", name = "SceLibKernel_stub") 6 | )] 7 | extern "C" { 8 | 9 | pub type va_list; 10 | 11 | pub fn sceClibStrcmp(s1: *const u8, s2: *const u8) -> i32; 12 | pub fn sceClibStrncmp(s1: *const u8, s2: *const u8, n: SceSize) -> *mut crate::void; 13 | pub fn sceClibStrncasecmp(s1: *const u8, s2: *const u8) -> i32; 14 | pub fn sceClibStrncpy(dest: *mut u8, src: *const u8, n: SceSize) -> *mut u8; 15 | pub fn sceClibStrncat(dest: *mut u8, src: *const u8, n: SceSize) -> *mut u8; 16 | pub fn sceClibStrnlen(s: *const u8, maxlen: SceSize) -> SceSize; 17 | pub fn sceClibStrrchr(s: *const u8, c: i32) -> *mut u8; 18 | 19 | pub fn sceClibPrintf(format: *const u8, ...) -> i32; 20 | pub fn sceClibSnprintf(s: *mut u8, size: SceSize, format: *const u8, ...) -> i32; 21 | pub fn sceClibVsnprintf(s: *mut u8, size: SceSize, format: *const u8, ap: va_list) -> i32; 22 | 23 | pub fn sceClibMemset(s: *mut crate::void, c: i32, n: SceSize) -> *mut crate::void; 24 | pub fn sceClibMemcpy(dest: *mut crate::void, src: *const crate::void, n: SceSize) -> *mut crate::void; 25 | pub fn sceClibMemmove(dest: *mut crate::void, src: *const crate::void, n: SceSize) -> *mut crate::void; 26 | } 27 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # `psp2-sys` 2 | 3 | *Unsafe Rust FFI bindings to the [`psp2` headers](https://github.com/vitasdk/vita-headers/)*. 4 | 5 | [![TravisCI](https://img.shields.io/travis/vita-rust/psp2-sys/master.svg?maxAge=600&style=flat-square)](https://travis-ci.org/vita-rust/psp2-sys/builds) 6 | [![Source](https://img.shields.io/badge/source-GitHub-303030.svg?maxAge=86400&style=flat-square)](https://github.com/vita-rust/psp2-sys) 7 | [![Changelog](https://img.shields.io/badge/keep%20a-changelog-8A0707.svg?maxAge=86400&style=flat-square)](http://keepachangelog.com/) 8 | [![Crate](https://img.shields.io/crates/v/psp2-sys.svg?maxAge=86400&style=flat-square)](https://crates.io/crates/psp2-sys) 9 | [![Documentation](https://img.shields.io/badge/docs-latest-4d76ae.svg?maxAge=86400&style=flat-square)](https://docs.rs/psp2-sys) 10 | [![CargoMake](https://img.shields.io/badge/built%20with-cargo--make-yellow.svg?maxAge=86400&style=flat-square)](https://sagiegurari.github.io/cargo-make) 11 | 12 | ## Deprecation notice 13 | 14 | Deprecated in favor of [vitasdk-sys](https://github.com/vita-rust/vitasdk-sys) 15 | 16 | ## Usage 17 | 18 | This crate will link statically to the required library stubs, so you'll need the 19 | [`vitasdk`](https://vitasdk.org) set up and the `$VITASDK` environment variable set. 20 | 21 | See the [examples](https://github.com/vita-rust/psp2-sys/tree/master/examples) 22 | to see how to setup a project using the raw bindings, or use the 23 | [`vita`](https://github.com/vita-rust/vita) crate for a safe API closer to the 24 | Rust [`std`](http://doc.rust-lang.org/nightly/std/) library. 25 | 26 | The submodules in this crate follow the file hierarchy of the `psp2` headers: 27 | so the FFI in the `psp2_sys::kernel::threadmgr` are the ones you would get in C 28 | after including `psp2/kernel/threadmgr.h`. 29 | 30 | ## Credits 31 | 32 | * [**VitaSDK team**](http://vitasdk.org/) for the `arm-vita-eabi` toolchain, `psp2` headers, ... 33 | * [**Team Molecule**](http://henkaku.xyz/) for the `Henkaku` hard work. 34 | 35 | 36 | ## Disclaimer 37 | 38 | *`psp2-sys` is not affiliated, sponsored, or otherwise endorsed by Sony 39 | Interactive Entertainment, LLC. PlayStation and PS Vita are trademarks or 40 | registered trademarks of Sony Interactive Entertainment, LLC. This software is 41 | provided "as is" without warranty of any kind under the MIT License.* 42 | -------------------------------------------------------------------------------- /src/io/stat.rs: -------------------------------------------------------------------------------- 1 | use crate::types::SceDateTime; 2 | use crate::types::SceMode; 3 | use crate::types::SceOff; 4 | use crate::types::SceUID; 5 | 6 | #[repr(i32)] 7 | pub enum SceIoAccessMode { 8 | SCE_S_IXUSR = 0x0001, // User execute permission 9 | SCE_S_IWUSR = 0x0002, // User write permission 10 | SCE_S_IRUSR = 0x0004, // User read permission 11 | SCE_S_IRWXU = 0x0007, // User access rights mask 12 | 13 | SCE_S_IXGRP = 0x0008, // Group execute permission 14 | SCE_S_IWGRP = 0x0010, // Group write permission 15 | SCE_S_IRGRP = 0x0020, // Group read permission 16 | SCE_S_IRWXG = 0x0038, // Group access rights mask 17 | 18 | SCE_S_IXOTH = 0x0040, // Others execute permission 19 | SCE_S_IWOTH = 0x0080, // Others write permission 20 | SCE_S_IROTH = 0x0100, // Others read permission 21 | SCE_S_IRWXO = 0x01C0, // Others access rights mask 22 | 23 | SCE_S_ISVTX = 0x0200, // Sticky 24 | SCE_S_ISGID = 0x0400, // Set GID 25 | SCE_S_ISUID = 0x0800, // Set UID 26 | 27 | SCE_S_IFDIR = 0x1000, // Directory 28 | SCE_S_IFREG = 0x2000, // Regular file 29 | SCE_S_IFLNK = 0x4000, // Symbolic link 30 | SCE_S_IFMT = 0xF000, // Format bits mask 31 | } 32 | 33 | #[repr(i32)] 34 | pub enum SceIoFileMode { 35 | SCE_SO_IXOTH = 0x0001, // Hidden execute permission 36 | SCE_SO_IWOTH = 0x0002, // Hidden write permission 37 | SCE_SO_IROTH = 0x0004, // Hidden read permission 38 | SCE_SO_IFLNK = 0x0008, // Symbolic link 39 | SCE_SO_IFDIR = 0x0010, // Directory 40 | SCE_SO_IFREG = 0x0020, // Regular file 41 | SCE_SO_IFMT = 0x0038, // Format mask 42 | } 43 | 44 | #[repr(C)] 45 | pub struct SceIoStat { 46 | pub st_mode: SceMode, // One or more ::SceIoAccessMode 47 | pub st_attr: u32, // One or more ::SceIoFileMode 48 | pub st_size: SceOff, // Size of the file in bytes 49 | pub st_ctime: SceDateTime, // Creation time 50 | pub st_atime: SceDateTime, // Last access time 51 | pub st_mtime: SceDateTime, // Last modification time 52 | pub st_private: [u32; 6], // Device-specific data 53 | } 54 | 55 | #[cfg_attr( 56 | not(feature = "dox"), 57 | link(kind = "static", name = "SceLibKernel_stub") 58 | )] 59 | extern "C" { 60 | pub fn sceIoMkdir(dir: *const u8, mode: SceMode) -> i32; 61 | pub fn sceIoRmdir(path: *const u8) -> i32; 62 | pub fn sceIoGetstatbyFd(fd: SceUID, stat: *mut SceIoStat) -> i32; 63 | pub fn sceIoChstat(file: *const u8, stat: *mut SceIoStat, bits: i32) -> i32; 64 | pub fn sceIoChstatByFd(fd: SceUID, buf: *const SceIoStat, cbit: u32) -> i32; 65 | } 66 | -------------------------------------------------------------------------------- /src/system_param.rs: -------------------------------------------------------------------------------- 1 | #[repr(u32)] 2 | pub enum SceSystemParamId { 3 | /// Language settings 4 | SCE_SYSTEM_PARAM_ID_LANG = 1, 5 | /// Enter button assignment 6 | SCE_SYSTEM_PARAM_ID_ENTER_BUTTON, 7 | /// Username string 8 | SCE_SYSTEM_PARAM_ID_USERNAME, 9 | /// Date format 10 | SCE_SYSTEM_PARAM_ID_DATE_FORMAT, 11 | /// Time format 12 | SCE_SYSTEM_PARAM_ID_TIME_FORMAT, 13 | /// Time zone 14 | SCE_SYSTEM_PARAM_ID_TIME_ZONE, 15 | /// Daylight savings time (0 = Disabled, 1 = Enabled) 16 | SCE_SYSTEM_PARAM_ID_DAYLIGHT_SAVINGS, 17 | /// Max allowed value 18 | SCE_SYSTEM_PARAM_ID_MAX_VALUE = 0xFFFFFFFF, 19 | } 20 | 21 | #[repr(u32)] 22 | pub enum SceSystemParamLang { 23 | /// Japanese 24 | SCE_SYSTEM_PARAM_LANG_JAPANESE, 25 | /// American English 26 | SCE_SYSTEM_PARAM_LANG_ENGLISH_US, 27 | /// French 28 | SCE_SYSTEM_PARAM_LANG_FRENCH, 29 | /// Spanish 30 | SCE_SYSTEM_PARAM_LANG_SPANISH, 31 | /// German 32 | SCE_SYSTEM_PARAM_LANG_GERMAN, 33 | /// Italian 34 | SCE_SYSTEM_PARAM_LANG_ITALIAN, 35 | /// Dutch 36 | SCE_SYSTEM_PARAM_LANG_DUTCH, 37 | /// Portugal Portuguese 38 | SCE_SYSTEM_PARAM_LANG_PORTUGUESE_PT, 39 | /// Russian 40 | SCE_SYSTEM_PARAM_LANG_RUSSIAN, 41 | /// Korean 42 | SCE_SYSTEM_PARAM_LANG_KOREAN, 43 | /// Traditional Chinese 44 | SCE_SYSTEM_PARAM_LANG_CHINESE_T, 45 | /// Simplified Chinese 46 | SCE_SYSTEM_PARAM_LANG_CHINESE_S, 47 | /// Finnish 48 | SCE_SYSTEM_PARAM_LANG_FINNISH, 49 | /// Swedish 50 | SCE_SYSTEM_PARAM_LANG_SWEDISH, 51 | /// Danish 52 | SCE_SYSTEM_PARAM_LANG_DANISH, 53 | /// Norwegian 54 | SCE_SYSTEM_PARAM_LANG_NORWEGIAN, 55 | /// Polish 56 | SCE_SYSTEM_PARAM_LANG_POLISH, 57 | /// Brazil Portuguese 58 | SCE_SYSTEM_PARAM_LANG_PORTUGUESE_BR, 59 | /// British English 60 | SCE_SYSTEM_PARAM_LANG_ENGLISH_GB, 61 | /// Turkish 62 | SCE_SYSTEM_PARAM_LANG_TURKISH, 63 | /// Max allowed value 64 | SCE_SYSTEM_PARAM_LANG_MAX_VALUE = 0xFFFFFFFF, 65 | } 66 | 67 | #[repr(u32)] 68 | pub enum SceSystemParamEnterButtonAssign { 69 | SCE_SYSTEM_PARAM_ENTER_BUTTON_CIRCLE, 70 | SCE_SYSTEM_PARAM_ENTER_BUTTON_CROSS, 71 | SCE_SYSTEM_PARAM_ENTER_BUTTON_MAX_VALUE = 0xFFFFFFFF, 72 | } 73 | 74 | pub const SCE_SYSTEM_PARAM_USERNAME_MAXSIZE: usize = 17; 75 | 76 | #[repr(C)] 77 | pub enum SceSystemParamDateFormat { 78 | SCE_SYSTEM_PARAM_DATE_FORMAT_YYYYMMDD, 79 | SCE_SYSTEM_PARAM_DATE_FORMAT_DDMMYYYY, 80 | SCE_SYSTEM_PARAM_DATE_FORMAT_MMDDYYYY, 81 | } 82 | 83 | #[repr(C)] 84 | pub enum SceSystemParamTimeFormat { 85 | SCE_SYSTEM_PARAM_TIME_FORMAT_12HR, 86 | SCE_SYSTEM_PARAM_TIME_FORMAT_24HR, 87 | } 88 | -------------------------------------------------------------------------------- /src/display.rs: -------------------------------------------------------------------------------- 1 | use crate::types::SceSize; 2 | use crate::types::SceUID; 3 | 4 | #[repr(u32)] 5 | pub enum SceDisplayErrorCode { 6 | SCE_DISPLAY_ERROR_OK = 0, 7 | SCE_DISPLAY_ERROR_INVALID_HEAD = 0x80290000, 8 | SCE_DISPLAY_ERROR_INVALID_VALUE = 0x80290001, 9 | SCE_DISPLAY_ERROR_INVALID_ADDR = 0x80290002, 10 | SCE_DISPLAY_ERROR_INVALID_PIXELFORMAT = 0x80290003, 11 | SCE_DISPLAY_ERROR_INVALID_PITCH = 0x80290004, 12 | SCE_DISPLAY_ERROR_INVALID_RESOLUTION = 0x80290005, 13 | SCE_DISPLAY_ERROR_INVALID_UPDATETIMING = 0x80290006, 14 | SCE_DISPLAY_ERROR_NO_FRAME_BUFFER = 0x80290007, 15 | SCE_DISPLAY_ERROR_NO_PIXEL_DATA = 0x80290008, 16 | SCE_DISPLAY_ERROR_NO_OUTPUT_SIGNAL = 0x80290009, 17 | } 18 | 19 | #[repr(i32)] 20 | pub enum SceDisplayPixelFormat { 21 | SCE_DISPLAY_PIXELFORMAT_A8B8G8R8 = 0x00000000, 22 | } 23 | 24 | #[repr(i32)] 25 | pub enum SceDisplaySetBufSync { 26 | SCE_DISPLAY_SETBUF_IMMEDIATE = 0, 27 | SCE_DISPLAY_SETBUF_NEXTFRAME = 1, 28 | } 29 | 30 | #[repr(C)] 31 | pub struct SceDisplayFrameBuf { 32 | pub size: SceSize, // sizeof(SceDisplayFrameBuf) 33 | pub base: *mut crate::void, // Pointer to framebuffer 34 | pub pitch: u32, // pitch pixels 35 | pub pixelformat: u32, // pixel format (one of ::SceDisplayPixelFormat) 36 | pub width: u32, // framebuffer width 37 | pub height: u32, // framebuffer height 38 | } 39 | 40 | #[cfg_attr( 41 | not(feature = "dox"), 42 | link(kind = "static", name = "SceDisplay_stub") 43 | )] 44 | extern "C" { 45 | pub fn sceDisplaySetFrameBuf( 46 | pParam: *const SceDisplayFrameBuf, 47 | sync: SceDisplaySetBufSync, 48 | ) -> i32; 49 | pub fn sceDisplayGetFrameBuf( 50 | pParam: *mut SceDisplayFrameBuf, 51 | sync: SceDisplaySetBufSync, 52 | ) -> i32; 53 | pub fn sceDisplayGetPrimaryHead() -> i32; 54 | pub fn sceDisplayGetRefreshRate(pFps: *mut f32) -> i32; 55 | pub fn sceDisplayGetMaximumFrameBufResolution(width: *mut i32, height: *mut i32) -> i32; 56 | pub fn sceDisplayGetVcount() -> i32; 57 | pub fn sceDisplayGetVcountInternal(display: i32) -> i32; 58 | pub fn sceDisplayWaitVblankStart() -> i32; 59 | pub fn sceDisplayWaitVblankStartCB() -> i32; 60 | pub fn sceDisplayWaitVblankStartMulti(vcount: u32) -> i32; 61 | pub fn sceDisplayWaitVblankStartMultiCB(vcount: u32) -> i32; 62 | pub fn sceDisplayWaitSetFrameBuf() -> i32; 63 | pub fn sceDisplayWaitSetFrameBufCB() -> i32; 64 | pub fn sceDisplayWaitSetFrameBufMulti(vcount: u32) -> i32; 65 | pub fn sceDisplayWaitSetFrameBufMultiCB(vcount: u32) -> i32; 66 | pub fn sceDisplayRegisterVblankStartCallback(uid: SceUID) -> i32; 67 | pub fn sceDisplayUnregisterVblankStartCallback(uid: SceUID) -> i32; 68 | } 69 | -------------------------------------------------------------------------------- /src/io/fcntl.rs: -------------------------------------------------------------------------------- 1 | use crate::types::SceOff; 2 | use crate::types::SceSize; 3 | use crate::types::SceUID; 4 | 5 | #[repr(i32)] 6 | pub enum SceIoMode { 7 | SCE_O_RDONLY = 0x0001, // Read-only 8 | SCE_O_WRONLY = 0x0002, // Write-only 9 | SCE_O_RDWR = 0x0003, // Read/Write 10 | SCE_O_NBLOCK = 0x0004, // Non blocking 11 | SCE_O_DIROPEN = 0x0008, // Internal use for ::sceIoDopen 12 | SCE_O_RDLOCK = 0x0010, // Read locked (non-shared) 13 | SCE_O_WRLOCK = 0x0020, // Write locked (non-shared) 14 | SCE_O_APPEND = 0x0100, // Append 15 | SCE_O_CREAT = 0x0200, // Create 16 | SCE_O_TRUNC = 0x0400, // Truncate 17 | SCE_O_EXCL = 0x0800, // Exclusive create 18 | SCE_O_SCAN = 0x1000, // Scan type 19 | SCE_O_RCOM = 0x2000, // Remote command entry 20 | SCE_O_NOBUF = 0x4000, // Number device buffer 21 | SCE_O_NOWAIT = 0x8000, // Asynchronous I/O 22 | SCE_O_FDEXCL = 0x01000000, // Exclusive access 23 | SCE_O_PWLOCK = 0x02000000, // Power control lock 24 | SCE_O_FGAMEDATA = 0x40000000, // Gamedata access 25 | } 26 | 27 | #[repr(i32)] 28 | pub enum SceIoSeekMode { 29 | SCE_SEEK_SET, 30 | SCE_SEEK_CUR, 31 | SCE_SEEk_END, 32 | } 33 | 34 | #[repr(i32)] 35 | pub enum SceIoDevType { 36 | SCE_DEV_TYPE_NULL = 0x00, // Dummy device 37 | SCE_DEV_TYPE_CHAR = 0x01, // Character device 38 | SCE_DEV_TYPE_BLOCK = 0x04, // Block device 39 | SCE_DEV_TYPE_FS = 0x10, // File system device 40 | SCE_DEV_TYPE_ALIAS = 0x20, // Alias name 41 | SCE_DEV_TYPE_MOUNTPT = 0x40, // Mount point 42 | } 43 | 44 | #[cfg_attr( 45 | not(feature = "dox"), 46 | link(kind = "static", name = "SceIofilemgr_stub") 47 | )] 48 | extern "C" { 49 | pub fn sceIoOpen(file: *const u8, flags: i32, mode: SceIoMode) -> SceUID; 50 | pub fn sceIoOpenAsync(file: *const u8, flags: i32, mode: SceIoMode) -> SceUID; 51 | pub fn sceIoClose(fd: SceUID) -> i32; 52 | pub fn sceIoCloseAsync(fd: SceUID) -> i32; 53 | pub fn sceIoRead(fd: SceUID, data: *mut crate::void, size: SceSize) -> i32; 54 | pub fn sceIoReadAsync(fd: SceUID, data: *mut crate::void, size: SceSize) -> i32; 55 | pub fn sceIoPread(fd: SceUID, data: *mut crate::void, size: SceSize, offset: SceOff) -> i32; 56 | pub fn sceIoWrite(fd: SceUID, data: *const crate::void, size: SceSize) -> i32; 57 | pub fn sceIoWriteAsync(fd: SceUID, data: *const crate::void, size: SceSize) -> i32; 58 | pub fn sceIoPwrite(fd: SceUID, data: *const crate::void, size: SceSize, offset: SceOff) -> i32; 59 | pub fn sceIoLseek(fd: SceUID, offset: SceOff, whence: SceIoSeekMode) -> SceOff; 60 | pub fn sceIoLseekAsync(fd: SceUID, offset: SceOff, whence: SceIoSeekMode) -> SceOff; 61 | pub fn sceIoLseek32(fd: SceUID, offset: i32, whence: SceIoSeekMode) -> SceOff; 62 | pub fn sceIoRemove(file: *const u8) -> i32; 63 | pub fn sceIoSync(device: *const u8, unk: u32) -> i32; 64 | pub fn sceIoSyncByFd(fd: SceUID) -> i32; 65 | pub fn sceIoCancel(fd: SceUID) -> i32; 66 | } 67 | -------------------------------------------------------------------------------- /src/kernel/sysmem.rs: -------------------------------------------------------------------------------- 1 | use crate::types::SceSize; 2 | use crate::types::SceUID; 3 | use crate::types::SceUInt32; 4 | 5 | #[repr(i32)] 6 | pub enum SceKernelMemBlockType { 7 | SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE = 0x0C208060, 8 | SCE_KERNEL_MEMBLOCK_TYPE_USER_RW = 0x0C20D060, 9 | SCE_KERNEL_MEMBLOCK_TYPE_USER_MAIN_PHYCONT_RW = 0x0C80D060, 10 | SCE_KERNEL_MEMBLOCK_TYPE_USER_MAIN_PHYCONT_NC_RW = 0x0D808060, 11 | SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW = 0x09408060, 12 | } 13 | 14 | #[repr(C)] 15 | pub struct SceKernelAllocMemBlockOpt { 16 | pub size: SceSize, 17 | pub attr: SceUInt32, 18 | pub alignment: SceSize, 19 | pub uidBaseBlock: SceUInt32, 20 | pub strBaseBlockName: *const u8, 21 | pub flags: i32, 22 | pub reserved: [i32; 10], 23 | } 24 | 25 | #[repr(C)] 26 | pub struct SceKernelFreeMemorySizeInfo { 27 | /// sizeof(SceKernelFreeMemorySizeInfo) 28 | pub size: i32, 29 | /// Free memory size for *_USER_RW memory 30 | pub size_user: i32, 31 | /// Free memory size for USER_CDRAM_RW memory 32 | pub size_cdram: i32, 33 | ///Free memory size for USER_MAIN_PHYCONT_*_RW memory 34 | pub size_phycont: i32, 35 | } 36 | 37 | #[repr(i32)] 38 | pub enum SceKernelModel { 39 | SCE_KERNEL_MODEL_VITA = 0x10000, 40 | SCE_KERNEL_MODEL_VITATV = 0x20000, 41 | } 42 | 43 | #[repr(C)] 44 | pub struct SceKernelMemBlockInfo { 45 | pub size: SceSize, 46 | pub mappedBase: *mut crate::void, 47 | pub mappedSize: SceSize, 48 | pub memory_type: SceKernelMemoryType, 49 | pub access: SceUInt32, 50 | pub block_type: SceKernelMemBlockType, 51 | } 52 | 53 | #[repr(i32)] 54 | pub enum SceKernelMemoryAccessType { 55 | SCE_KERNEL_MEMORY_ACCESS_X = 0x01, 56 | SCE_KERNEL_MEMORY_ACCESS_W = 0x02, 57 | SCE_KERNEL_MEMORY_ACCESS_R = 0x04, 58 | } 59 | 60 | #[repr(i32)] 61 | pub enum SceKernelMemoryType { 62 | SCE_KERNEL_MEMORY_TYPE_NORMAL_NC = 0x80, 63 | SCE_KERNEL_MEMORY_TYPE_NORMAL = 0xD0, 64 | } 65 | 66 | #[cfg_attr( 67 | not(feature = "dox"), 68 | link(kind = "static", name = "SceLibKernel_stub") 69 | )] 70 | extern "C" { 71 | pub fn sceKernelAllocMemBlock( 72 | name: *const u8, 73 | type_: SceKernelMemBlockType, 74 | size: i32, 75 | optp: *mut SceKernelAllocMemBlockOpt, 76 | ) -> SceUID; 77 | pub fn sceKernelFreeMemBlock(uid: SceUID) -> i32; 78 | pub fn sceKernelGetMemBlockBase(uid: SceUID, basep: *mut *mut crate::void) -> i32; 79 | pub fn sceKernelFindMemBlockByAddr(addr: *const crate::void, size: SceSize) -> SceUID; 80 | pub fn sceKernelGetMemBlockInfoByAddr( 81 | base: *mut crate::void, 82 | info: *mut SceKernelMemBlockInfo, 83 | ) -> i32; 84 | pub fn sceKernelGetMemBlockInfoByRange( 85 | base: *mut crate::void, 86 | size: SceSize, 87 | info: *mut SceKernelMemBlockInfo, 88 | ) -> i32; 89 | pub fn sceKernelAllocMemBlockForVM(name: *const u8, size: SceSize) -> SceUID; 90 | pub fn sceKernelSyncVMDomain(uid: SceUID, data: *const crate::void, size: SceSize) -> i32; 91 | pub fn sceKernelOpenVMDomain() -> i32; 92 | pub fn sceKernelCloseVMDomain() -> i32; 93 | pub fn sceKernelOpenMemBlock(name: *const u8, flags: i32) -> i32; 94 | pub fn sceKernelCloseMemBlock(uid: SceUID) -> i32; 95 | pub fn sceKernelGetModelForCDialog() -> SceKernelModel; 96 | pub fn sceKernelGetModel() -> SceKernelModel; 97 | pub fn sceKernelGetFreeMemorySize(info: *mut SceKernelFreeMemorySizeInfo) -> i32; 98 | } 99 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Changelog 2 | All notable changes to this project will be documented in this file. 3 | 4 | The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) 5 | and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html). 6 | 7 | 8 | ## [Unreleased] 9 | ### Added 10 | - Complete **userspace** bindings to: 11 | * the [Control Library] 12 | 13 | ### Fixed 14 | - Fix `i32` being used instead of `u32` as `psp2_sys::types::SceUInt` 15 | 16 | [Control Library]: https://docs.vitasdk.org/group__SceCtrlUser.html 17 | 18 | 19 | ## [v0.2.2] - 2018-09-12 20 | ### Fixed 21 | - Fix missing `#[cfg_attr(...)]` in `psp_sys::kernel` 22 | 23 | ## [v0.2.1] - 2018-09-12 24 | ### Added 25 | - `dox` feature to disable linking to `vitasdk` stubs during compilation (use in `docs.rs`) 26 | 27 | ### Fixed 28 | - Links in `CHANGELOG.md` file. 29 | 30 | 31 | ## [v0.2.0] - 2018-07-06 32 | ### Added 33 | 34 | - Complete **userspace** bindings to: 35 | * the [Device Control Library] 36 | * the [Directory Entries Library] 37 | * the [File Control Library] 38 | * the [File Status Library] 39 | * the [C Standard Library] 40 | * the [Random Number Library] 41 | - Partial **userspace** bindings to: 42 | * the *threading* part of the [Thread Manager Library] 43 | * the *semaphore* part of the [Thread Manager Library] 44 | 45 | [Random Number Library]: https://docs.vitasdk.org/group__SceRngUser.html 46 | [Device Control Library]: https://docs.vitasdk.org/group__SceDevCtlUser.html 47 | [Directory Entries Library]: https://docs.vitasdk.org/group__SceDirEntUser.html 48 | [File Control Library]: https://docs.vitasdk.org/group__SceFcntlUser.html 49 | [File Status Library]: https://docs.vitasdk.org/group__SceStatUser.html 50 | [C Standard Library]: https://docs.vitasdk.org/group__SceCLibUser.html 51 | [Thread Manager Library]: https://docs.vitasdk.org/group__SceThreadMgrUser.html 52 | 53 | 54 | ## [v0.1.1] - 2018-07-04 55 | ### Changed 56 | 57 | - `build.rs` only to warn about missing `$VITASDK` environment variable 58 | (allows `cargo doc` without `$VITASDK` set) 59 | 60 | 61 | ## [v0.1.0] - 2018-07-04 62 | ### Added 63 | 64 | - Complete **userspace** bindings to: 65 | * the [System Memory Library] 66 | * the [System Parameters Defines] 67 | * the [Type Defines] 68 | * the [Common Dialog Library] 69 | * the [Message Dialog Library] 70 | - Partial **userspace** bindings to: 71 | * the *mutex* part of the [Thread Manager Library] 72 | * the *color formats* of the [GPU Graphics Library] 73 | - A basic README with links to other `vita-rust` projects. 74 | - This CHANGELOG file. 75 | 76 | [Common Dialog Library]: https://docs.vitasdk.org/group__SceCommonDialogUser.html 77 | [Message Dialog Library]: https://docs.vitasdk.org/group__SceMessageDialogUser.html 78 | [GPU Graphics Library]: https://docs.vitasdk.org/group__SceGxmUser.html 79 | [System Parameters Defines]: https://docs.vitasdk.org/group__SceSystemParamUser.html 80 | [System Memory Library]: https://docs.vitasdk.org/group__SceSysmemUser.html 81 | [Thread Manager Library]: https://docs.vitasdk.org/group__SceThreadMgrUser.html 82 | [Type Defines]: https://docs.vitasdk.org/group__SceTypesUser.html 83 | 84 | 85 | [Unreleased]: https://github.com/vita-rust/psp2-sys/compare/v0.2.2...HEAD 86 | [v0.2.2]: https://github.com/vita-rust/psp2-sys/compare/v0.2.1...v0.2.2 87 | [v0.2.1]: https://github.com/vita-rust/psp2-sys/compare/v0.2.0...v0.2.1 88 | [v0.2.0]: https://github.com/vita-rust/psp2-sys/compare/v0.1.1...v0.2.0 89 | [v0.1.1]: https://github.com/vita-rust/psp2-sys/compare/v0.1.0...v0.1.1 90 | [v0.1.0]: https://github.com/vita-rust/psp2-sys/compare/147a58f...v0.1.0 91 | -------------------------------------------------------------------------------- /src/dialog/common.rs: -------------------------------------------------------------------------------- 1 | use crate::graphics::gxm::SceGxmColorFormat; 2 | use crate::graphics::gxm::SceGxmColorSurfaceType; 3 | use crate::graphics::gxm::SceGxmSyncObject; 4 | use crate::system_param::SceSystemParamEnterButtonAssign; 5 | use crate::system_param::SceSystemParamLang; 6 | use crate::types::SceInt32; 7 | use crate::types::ScePVoid; 8 | use crate::types::SceUInt32; 9 | use crate::types::SceUInt8; 10 | 11 | #[repr(u32)] 12 | pub enum SceCommonDialogErrorCode { 13 | SCE_COMMON_DIALOG_ERROR_BUSY = 0x80020401, 14 | SCE_COMMON_DIALOG_ERROR_NULL = 0x80020402, 15 | SCE_COMMON_DIALOG_ERROR_INVALID_ARGUMENT = 0x80020403, 16 | SCE_COMMON_DIALOG_ERROR_NOT_RUNNING = 0x80020404, 17 | SCE_COMMON_DIALOG_ERROR_NOT_SUPPORTED = 0x80020405, 18 | SCE_COMMON_DIALOG_ERROR_ILLEGAL_CALLER_THREAD = 0x80020406, 19 | SCE_COMMON_DIALOG_ERROR_NOT_CONFIGURED = 0x80020407, 20 | SCE_COMMON_DIALOG_ERROR_NOT_AVAILABLE = 0x80020408, 21 | SCE_COMMON_DIALOG_ERROR_NOT_FINISHED = 0x80020410, 22 | SCE_COMMON_DIALOG_ERROR_NOT_IN_USE = 0x80020411, 23 | SCE_COMMON_DIALOG_ERROR_INVALID_COLOR_FORMAT = 0x80020420, 24 | SCE_COMMON_DIALOG_ERROR_INVALID_SURFACE_RESOLUTION = 0x80020421, 25 | SCE_COMMON_DIALOG_ERROR_INVALID_SURFACE_STRIDE = 0x80020422, 26 | SCE_COMMON_DIALOG_ERROR_INVALID_SURFACE_TYPE = 0x80020423, 27 | SCE_COMMON_DIALOG_ERROR_WITHIN_SCENE = 0x80020424, 28 | SCE_COMMON_DIALOG_ERROR_IME_IN_USE = 0x80020430, 29 | SCE_COMMON_DIALOG_ERROR_INVALID_LANGUAGE = 0x80020431, 30 | SCE_COMMON_DIALOG_ERROR_INVALID_ENTER_BUTTON_ASSIGN = 0x80020432, 31 | SCE_COMMON_DIALOG_ERROR_INVALID_INFOBAR_PARAM = 0x80020433, 32 | SCE_COMMON_DIALOG_ERROR_INVALID_BG_COLOR = 0x80020434, 33 | SCE_COMMON_DIALOG_ERROR_INVALID_DIMMER_COLOR = 0x80020435, 34 | SCE_COMMON_DIALOG_ERROR_UNEXPECTED_FATAL = 0x8002047F, 35 | } 36 | 37 | #[repr(C)] 38 | pub struct SceCommonDialogConfigParam { 39 | pub sdkVersion: SceUInt32, 40 | pub language: SceSystemParamLang, 41 | pub enterButtonAssign: SceSystemParamEnterButtonAssign, 42 | pub reserved: [SceUInt8; 32], 43 | } 44 | 45 | #[repr(C)] 46 | pub enum SceCommonDialogStatus { 47 | SCE_COMMON_DIALOG_STATUS_NONE = 0, 48 | SCE_COMMON_DIALOG_STATUS_RUNNING = 1, 49 | SCE_COMMON_DIALOG_STATUS_FINISHED = 2, 50 | } 51 | 52 | #[repr(C)] 53 | pub enum SceCommonDialogResult { 54 | SCE_COMMON_DIALOG_RESULT_OK, 55 | SCE_COMMON_DIALOG_RESULT_USER_CANCELED, 56 | SCE_COMMON_DIALOG_RESULT_ABORTED, 57 | } 58 | 59 | #[repr(C)] 60 | pub struct SceCommonDialogRenderTargetInfo { 61 | pub depthSurfaceData: ScePVoid, 62 | pub colorSurfaceData: ScePVoid, 63 | pub surfaceType: SceGxmColorSurfaceType, 64 | pub colorFormat: SceGxmColorFormat, 65 | pub width: SceUInt32, 66 | pub height: SceUInt32, 67 | pub strideInPixels: SceUInt32, 68 | pub reserved: [SceUInt8; 32], 69 | } 70 | 71 | #[repr(C)] 72 | pub struct SceCommonDialogUpdateParam { 73 | pub renderTarget: SceCommonDialogRenderTargetInfo, 74 | pub displaySyncObject: *mut SceGxmSyncObject, 75 | pub reserved: [SceUInt8; 32], 76 | } 77 | 78 | #[repr(C)] 79 | pub struct SceCommonDialogInfobarParam { 80 | pub visibility: SceInt32, 81 | pub color: SceInt32, 82 | pub transparency: SceInt32, 83 | pub reserved: [SceUInt8; 32], 84 | } 85 | 86 | #[repr(C)] 87 | pub struct SceCommonDialogColor { 88 | pub r: SceUInt8, 89 | pub g: SceUInt8, 90 | pub b: SceUInt8, 91 | pub a: SceUInt8, 92 | } 93 | 94 | pub type SceCommonDialogBgColor = SceCommonDialogColor; 95 | 96 | #[repr(C)] 97 | pub struct SceCommonDialogParam { 98 | pub infobarParam: *mut SceCommonDialogInfobarParam, 99 | pub bgColor: *mut SceCommonDialogColor, 100 | pub dimmerColor: *mut SceCommonDialogColor, 101 | pub reserved: [SceUInt8; 60], 102 | pub magic: SceUInt32, 103 | } 104 | 105 | #[cfg_attr( 106 | not(feature = "dox"), 107 | link(name = "SceCommonDialog_stub", kind = "static") 108 | )] 109 | extern "C" { 110 | pub fn sceCommonDialogSetConfigParam(configParam: *const SceCommonDialogConfigParam) -> i32; 111 | pub fn sceCommonDialogUpdate(updateParam: *const SceCommonDialogUpdateParam) -> i32; 112 | } 113 | 114 | pub const SCE_COMMON_DIALOG_MAGIC_NUMBER: u32 = 0xC0D1A109; 115 | 116 | // static inline 117 | // void _sceCommonDialogSetMagicNumber(SceCommonDialogParam *param) 118 | // { 119 | // param->magic = SCE_COMMON_DIALOG_MAGIC_NUMBER + *(SceUInt32*)¶m; 120 | // } 121 | // 122 | // static inline 123 | // void sceCommonDialogConfigParamInit(SceCommonDialogConfigParam *param) 124 | // { 125 | // memset(param, 0x0, sizeof(SceCommonDialogConfigParam)); 126 | // param->language = SCE_SYSTEM_PARAM_LANG_MAX_VALUE; 127 | // param->enterButtonAssign = SCE_SYSTEM_PARAM_ENTER_BUTTON_MAX_VALUE; 128 | // param->sdkVersion = 0x03150021; 129 | // }; 130 | -------------------------------------------------------------------------------- /src/types.rs: -------------------------------------------------------------------------------- 1 | pub type SceChar8 = i8; 2 | pub type SceUChar8 = u8; 3 | 4 | pub type SceInt8 = i8; 5 | pub type SceUInt8 = u8; 6 | 7 | pub type SceShort16 = i16; 8 | pub type SceUShort16 = u16; 9 | 10 | pub type SceInt32 = i32; 11 | pub type SceUInt32 = u32; 12 | 13 | pub type SceInt = i32; 14 | pub type SceUInt = u32; 15 | 16 | pub type SceInt64 = i64; 17 | pub type SceUInt64 = u64; 18 | 19 | pub type SceLong64 = i64; 20 | pub type SceULong64 = u64; 21 | 22 | pub type SceSize = u32; 23 | pub type SceSSize = i32; 24 | 25 | #[derive(Copy, Clone, Debug)] 26 | #[repr(i32)] 27 | pub enum SceBool { 28 | SCE_FALSE = 0, 29 | SCE_TRUE = 1, 30 | } 31 | 32 | pub type SceFloat = f32; 33 | pub type SceFloat32 = f32; 34 | 35 | pub type SceDouble = f64; 36 | pub type SceDouble64 = f64; 37 | 38 | pub type SceSByte = i8; 39 | pub type SceSByte8 = i8; 40 | 41 | pub type SceByte = u8; 42 | pub type SceByte8 = u8; 43 | 44 | pub type SceWChar16 = u16; 45 | pub type SceWChar32 = u32; 46 | 47 | pub type SceVoid = crate::void; 48 | pub type ScePVoid = *mut crate::void; 49 | 50 | pub type SceIntPtr = i32; 51 | pub type SceUIntPtr = u32; 52 | pub type SceUIntVAddr = SceUIntPtr; 53 | 54 | #[derive(Copy, Clone, Debug)] 55 | #[repr(C)] 56 | pub struct SceIVector2 { 57 | x: SceInt, 58 | y: SceInt, 59 | } 60 | 61 | #[derive(Copy, Clone, Debug)] 62 | #[repr(C)] 63 | pub struct SceFVector2 { 64 | x: SceFloat, 65 | y: SceFloat, 66 | } 67 | 68 | #[derive(Copy, Clone, Debug)] 69 | #[repr(C)] 70 | pub struct SceIVector3 { 71 | x: SceInt, 72 | y: SceInt, 73 | z: SceInt, 74 | } 75 | 76 | #[derive(Copy, Clone, Debug)] 77 | #[repr(C)] 78 | pub struct SceFVector3 { 79 | x: SceFloat, 80 | y: SceFloat, 81 | z: SceFloat, 82 | } 83 | 84 | #[derive(Copy, Clone, Debug)] 85 | #[repr(C)] 86 | pub struct SceIVector4 { 87 | x: SceInt, 88 | y: SceInt, 89 | z: SceInt, 90 | w: SceInt, 91 | } 92 | 93 | #[derive(Copy, Clone, Debug)] 94 | #[repr(C)] 95 | pub struct SceUVector4 { 96 | x: SceUInt, 97 | y: SceUInt, 98 | z: SceUInt, 99 | w: SceUInt, 100 | } 101 | 102 | #[derive(Copy, Clone, Debug)] 103 | #[repr(C)] 104 | pub struct SceFVector4 { 105 | x: SceFloat, 106 | y: SceFloat, 107 | z: SceFloat, 108 | w: SceFloat, 109 | } 110 | 111 | #[derive(Copy, Clone, Debug)] 112 | #[repr(C)] 113 | pub struct SceIMatrix2 { 114 | x: SceIVector2, 115 | y: SceIVector2, 116 | } 117 | 118 | #[derive(Copy, Clone, Debug)] 119 | #[repr(C)] 120 | pub struct SceFMatrix2 { 121 | x: SceFVector2, 122 | y: SceFVector2, 123 | } 124 | 125 | #[derive(Copy, Clone, Debug)] 126 | #[repr(C)] 127 | pub struct SceIMatrix3 { 128 | x: SceIVector3, 129 | y: SceIVector3, 130 | z: SceIVector3, 131 | } 132 | 133 | #[derive(Copy, Clone, Debug)] 134 | #[repr(C)] 135 | pub struct SceFMatrix3 { 136 | x: SceFVector3, 137 | y: SceFVector3, 138 | z: SceFVector3, 139 | } 140 | 141 | #[derive(Copy, Clone, Debug)] 142 | #[repr(C)] 143 | pub struct SceIMatrix4 { 144 | x: SceIVector4, 145 | y: SceIVector4, 146 | z: SceIVector4, 147 | w: SceIVector4, 148 | } 149 | 150 | #[derive(Copy, Clone, Debug)] 151 | #[repr(C)] 152 | pub struct SceUMatrix4 { 153 | x: SceUVector4, 154 | y: SceUVector4, 155 | z: SceUVector4, 156 | w: SceUVector4, 157 | } 158 | 159 | #[derive(Copy, Clone, Debug)] 160 | #[repr(C)] 161 | pub struct SceFMatrix4 { 162 | x: SceFVector4, 163 | y: SceFVector4, 164 | z: SceFVector4, 165 | w: SceFVector4, 166 | } 167 | 168 | #[derive(Copy, Clone, Debug)] 169 | #[repr(C)] 170 | pub struct SceFQuaternion { 171 | x: SceFloat, 172 | y: SceFloat, 173 | z: SceFloat, 174 | w: SceFloat, 175 | } 176 | 177 | #[derive(Copy, Clone, Debug)] 178 | #[repr(C)] 179 | pub struct SceFColor { 180 | r: SceFloat, 181 | g: SceFloat, 182 | b: SceFloat, 183 | a: SceFloat, 184 | } 185 | 186 | #[derive(Copy, Clone, Debug)] 187 | #[repr(C)] 188 | pub struct SceFPlane { 189 | a: SceFloat, 190 | b: SceFloat, 191 | c: SceFloat, 192 | d: SceFloat, 193 | } 194 | 195 | #[derive(Copy, Clone)] 196 | #[repr(C)] 197 | pub union SceUnion32 { 198 | ui: u32, 199 | i: u32, 200 | us: [u16; 2], 201 | s: [i16; 2], 202 | uc: [u8; 4], 203 | c: [i8; 4], 204 | f: f32, 205 | p: *mut crate::void, 206 | } 207 | 208 | #[derive(Copy, Clone)] 209 | #[repr(C)] 210 | pub union SceUnion64 { 211 | ull: SceULong64, 212 | ll: SceLong64, 213 | ui: [u32; 2], 214 | i: [i32; 2], 215 | us: [u16; 4], 216 | s: [i16; 4], 217 | uc: [u8; 8], 218 | c: [i8; 8], 219 | f: [f32; 2], 220 | fv: SceFVector2, 221 | iv: SceIVector2, 222 | } 223 | 224 | #[derive(Copy, Clone)] 225 | #[repr(C)] 226 | pub union SceUnion128 { 227 | ull: [SceULong64; 2], 228 | ll: [SceLong64; 2], 229 | ui: [u32; 4], 230 | i: [i32; 4], 231 | us: [u16; 8], 232 | s: [i16; 8], 233 | uc: [u8; 16], 234 | c: [u8; 16], 235 | f: [f32; 4], 236 | fv: SceFVector4, 237 | fq: SceFQuaternion, 238 | fp: SceFPlane, 239 | fc: SceFColor, 240 | iv: SceIVector4, 241 | } 242 | 243 | #[derive(Copy, Clone, Debug)] 244 | #[repr(C)] 245 | pub struct SceDateTime { 246 | year: u16, 247 | month: u16, 248 | day: u16, 249 | hour: u16, 250 | minute: u16, 251 | second: u16, 252 | microsecond: u32, 253 | } 254 | 255 | pub type SceMode = i32; 256 | pub type SceOff = SceInt64; 257 | 258 | pub type SceUID = i32; 259 | 260 | pub type ScePID = i32; 261 | 262 | pub type SceName = *mut u8; 263 | -------------------------------------------------------------------------------- /src/ctrl.rs: -------------------------------------------------------------------------------- 1 | #[repr(u32)] 2 | pub enum SceCtrlErrorCode { 3 | SCE_CTRL_ERROR_INVALID_ARG = 0x80340001, 4 | SCE_CTRL_ERROR_PRIV_REQUIRED = 0x80340002, 5 | SCE_CTRL_ERROR_NO_DEVICE = 0x80340020, 6 | SCE_CTRL_ERROR_NOT_SUPPORTED = 0x80340021, 7 | SCE_CTRL_ERROR_INVALID_MODE = 0x80340022, 8 | SCE_CTRL_ERROR_FATAL = 0x803400FF, 9 | } 10 | 11 | #[repr(C)] 12 | pub enum SceCtrlButtons { 13 | /// Select button. 14 | SCE_CTRL_SELECT = 0x00000001, 15 | /// L3 button. 16 | SCE_CTRL_L3 = 0x00000002, 17 | /// R3 button. 18 | SCE_CTRL_R3 = 0x00000004, 19 | /// Start button. 20 | SCE_CTRL_START = 0x00000008, 21 | /// Up D-Pad button. 22 | SCE_CTRL_UP = 0x00000010, 23 | /// Right D-Pad button. 24 | SCE_CTRL_RIGHT = 0x00000020, 25 | /// Down D-Pad button. 26 | SCE_CTRL_DOWN = 0x00000040, 27 | /// Left D-Pad button. 28 | SCE_CTRL_LEFT = 0x00000080, 29 | /// Left trigger. 30 | SCE_CTRL_LTRIGGER = 0x00000100, 31 | // /// L2 button. 32 | // SCE_CTRL_L2 = SCE_CTRL_LTRIGGER, 33 | /// Right trigger. 34 | SCE_CTRL_RTRIGGER = 0x00000200, 35 | // /// R2 button. 36 | // SCE_CTRL_R2 = SCE_CTRL_RTRIGGER, 37 | /// L1 button. 38 | SCE_CTRL_L1 = 0x00000400, 39 | /// R1 button. 40 | SCE_CTRL_R1 = 0x00000800, 41 | /// Triangle button. 42 | SCE_CTRL_TRIANGLE = 0x00001000, 43 | /// Circle button. 44 | SCE_CTRL_CIRCLE = 0x00002000, 45 | /// Cross button. 46 | SCE_CTRL_CROSS = 0x00004000, 47 | /// Square button. 48 | SCE_CTRL_SQUARE = 0x00008000, 49 | /// Input not available because intercercepted by another application 50 | SCE_CTRL_INTERCEPTED = 0x00010000, 51 | // /// Playstation (Home) button. 52 | // SCE_CTRL_PSBUTTON = SCE_CTRL_INTERCEPTED, 53 | /// Headphone plugged in. 54 | SCE_CTRL_HEADPHONE = 0x00080000, 55 | /// Volume up button. 56 | SCE_CTRL_VOLUP = 0x00100000, 57 | /// Volume down button. 58 | SCE_CTRL_VOLDOWN = 0x00200000, 59 | /// Power button. 60 | SCE_CTRL_POWER = 0x40000000, 61 | } 62 | 63 | #[repr(u8)] 64 | pub enum SceCtrlExternalInputMode { 65 | /// Unpaired controller 66 | SCE_CTRL_TYPE_UNPAIRED = 0, 67 | /// Physical controller for VITA 68 | SCE_CTRL_TYPE_PHY = 1, 69 | /// Virtual controller for PSTV 70 | SCE_CTRL_TYPE_VIRT = 2, 71 | /// DualShock 3 72 | SCE_CTRL_TYPE_DS3 = 4, 73 | /// DualShock 4 74 | SCE_CTRL_TYPE_DS4 = 8, 75 | } 76 | 77 | #[repr(C)] 78 | pub enum SceCtrlPadInputMode { 79 | /// Digital buttons only. 80 | SCE_CTRL_MODE_DIGITAL = 0, 81 | /// Digital buttons + Analog support. 82 | SCE_CTRL_MODE_ANALOG = 1, 83 | /// Same as ::SCE_CTRL_MODE_ANALOG, but with larger range for analog sticks. 84 | SCE_CTRL_MODE_ANALOG_WIDE = 2, 85 | } 86 | 87 | #[repr(C)] 88 | pub struct SceCtrlData { 89 | /// The current read frame. 90 | pub timeStamp: u64, 91 | /** Bit mask containing zero or more of ::SceCtrlButtons. */ 92 | pub buttons: u32, 93 | /** Left analogue stick, X axis. */ 94 | pub lx: u8, 95 | /** Left analogue stick, Y axis. */ 96 | pub ly: u8, 97 | /** Right analogue stick, X axis. */ 98 | pub rx: u8, 99 | /** Right analogue stick, Y axis. */ 100 | pub ry: u8, 101 | /** Up button */ 102 | pub up: u8, 103 | /** Right button */ 104 | pub right: u8, 105 | /** Down button */ 106 | pub down: u8, 107 | /** Left button */ 108 | pub left: u8, 109 | /** Left trigger (L2) */ 110 | pub lt: u8, 111 | /** Right trigger (R2) */ 112 | pub rt: u8, 113 | /** Left button (L1) */ 114 | pub l1: u8, 115 | /** Right button (R1) */ 116 | pub r1: u8, 117 | /** Triangle button */ 118 | pub triangle: u8, 119 | /// Circle button 120 | pub circle: u8, 121 | /** Cross button */ 122 | pub cross: u8, 123 | /** Square button */ 124 | pub square: u8, 125 | /** Reserved. */ 126 | _reserved: [u8; 4], 127 | } 128 | 129 | #[repr(C)] 130 | pub struct SceCtrlRapidFireRule { 131 | pub Mask: u32, 132 | pub Trigger: u32, 133 | pub Target: u32, 134 | pub Delay: u32, 135 | pub Make: u32, 136 | pub Break: u32, 137 | } 138 | 139 | #[repr(C)] 140 | pub struct SceCtrlActuator { 141 | pub small: u8, 142 | pub large: u8, 143 | unk: [u8; 6], 144 | } 145 | 146 | #[repr(C)] 147 | pub struct SceCtrlPortInfo { 148 | pub port: [SceCtrlExternalInputMode; 5], 149 | unk: [u8; 11], 150 | } 151 | 152 | #[cfg_attr(not(feature = "dox"), link(kind = "static", name = "SceCtrl_stub"))] 153 | extern "C" { 154 | pub fn sceCtrlSetSamplingMode(mode: SceCtrlPadInputMode) -> i32; 155 | pub fn sceCtrlSetSamplingModeExt(mode: SceCtrlPadInputMode) -> i32; 156 | pub fn sceCtrlGetSamplingMode(pMode: *mut SceCtrlPadInputMode) -> i32; 157 | pub fn sceCtrlPeekBufferPositive(port: i32, pad_data: *mut SceCtrlData, count: i32) -> i32; 158 | pub fn sceCtrlPeekBufferPositiveExt2(port: i32, pad_data: *mut SceCtrlData, count: i32) -> i32; 159 | pub fn sceCtrlPeekBufferNegative(port: i32, pad_data: *mut SceCtrlData, count: i32) -> i32; 160 | pub fn sceCtrlReadBufferPositive(port: i32, pad_data: *mut SceCtrlData, count: i32) -> i32; 161 | pub fn sceCtrlReadBufferPositiveExt2(port: i32, pad_data: *mut SceCtrlData, count: i32) -> i32; 162 | pub fn sceCtrlReadBufferNegative(port: i32, pad_data: *mut SceCtrlData, count: i32) -> i32; 163 | pub fn sceCtrlSetRapidFire(port: i32, idx: i32, pRule: *const SceCtrlRapidFireRule); 164 | pub fn sceCtrlClearRapidFire(port: i32, idx: i32) -> i32; 165 | pub fn sceCtrlSetActuator(port: i32, pState: *const SceCtrlActuator) -> i32; 166 | pub fn sceCtrlSetLightBar(port: i32, r: u8, g: u8, b: u8) -> i32; 167 | pub fn sceCtrlGetControllerPortInfo(info: *mut SceCtrlPortInfo) -> i32; 168 | pub fn sceCtrlGetBatteryInfo(port: i32, batt: *mut u8) -> i32; 169 | pub fn sceCtrlSetButtonIntercept(intercept: i32) -> i32; 170 | pub fn sceCtrlGetButtonIntercept(intercept: *mut i32) -> i32; 171 | pub fn sceCtrlIsMultiControllerSupported() -> i32; 172 | } 173 | -------------------------------------------------------------------------------- /src/kernel/threadmgr.rs: -------------------------------------------------------------------------------- 1 | use crate::types::SceSize; 2 | use crate::types::SceUID; 3 | use crate::types::SceUInt; 4 | use crate::types::SceUInt32; 5 | use crate::types::SceUInt64; 6 | 7 | type SceKernelSysClock = SceUInt64; 8 | 9 | // Mutexes 10 | 11 | #[repr(C)] 12 | pub struct SceKernelMutexOptParam { 13 | pub size: SceSize, 14 | pub ceilingPriority: i32, 15 | } 16 | 17 | #[repr(C)] 18 | pub struct SceKernelMutexInfo { 19 | pub size: SceSize, 20 | pub mutexId: SceUID, 21 | pub name: [u8; 32], 22 | pub attr: SceUInt, 23 | pub initCount: i32, 24 | pub currentCount: i32, 25 | pub currentOwnerId: SceUID, 26 | pub numWaitThreads: i32, 27 | } 28 | 29 | #[repr(i32)] 30 | pub enum SceKernelMutexAttribute { 31 | SCE_KERNEL_MUTEX_ATTR_RECURSIVE = 0x02, 32 | } 33 | 34 | // Threads 35 | 36 | type SceKernelThreadEntry = extern "C" fn(SceSize, *mut crate::void) -> i32; 37 | 38 | #[repr(C)] 39 | pub struct SceKernelThreadOptParam { 40 | pub size: SceSize, 41 | pub attr: SceUInt32, 42 | } 43 | 44 | #[repr(C)] 45 | pub struct SceKernelThreadInfo { 46 | pub size: SceSize, 47 | pub processId: SceUID, 48 | pub name: [u8; 32], 49 | pub attr: SceUInt, 50 | pub status: i32, 51 | pub entry: SceKernelThreadEntry, 52 | pub stack: *mut crate::void, 53 | pub stackSize: i32, 54 | pub initPriority: i32, 55 | pub currentPriority: i32, 56 | pub initCpuAffinityMask: i32, 57 | pub currentCpuAffinityMask: i32, 58 | pub currentCpuId: i32, 59 | pub lastExecutedCpuId: i32, 60 | pub waitType: i32, 61 | pub waitId: SceUID, 62 | pub exitStatus: i32, 63 | pub runClocks: SceKernelSysClock, 64 | pub intrPreemptCount: SceUInt, 65 | pub threadPreemptCount: SceUInt, 66 | pub threadReleaseCount: SceUInt, 67 | pub fNotifyCallback: SceUID, 68 | pub reserved: i32, 69 | } 70 | 71 | #[repr(C)] 72 | pub struct SceKernelThreadCpuInfo { 73 | pub processId: SceUID, 74 | pub threadId: SceUID, 75 | pub priority: i32, 76 | } 77 | 78 | #[repr(C)] 79 | pub struct SceKernelThreadRunStatus { 80 | pub size: SceSize, 81 | pub cpuInfo: [SceKernelThreadCpuInfo; 4], 82 | } 83 | 84 | #[repr(i32)] 85 | pub enum SceThreadStatus { 86 | SCE_THREAD_RUNNING = 1, 87 | SCE_THREAD_READY = 2, 88 | SCE_THREAD_WAITING = 4, 89 | SCE_THREAD_SUSPEND = 8, 90 | SCE_THREAD_STOPPED = 16, 91 | SCE_THREAD_KILLED = 32, 92 | } 93 | 94 | // Semaphores 95 | 96 | #[repr(C)] 97 | pub struct SceKernelSemaOptParam { 98 | size: SceSize, 99 | } 100 | 101 | #[repr(C)] 102 | pub struct SceKernelSemaInfo { 103 | pub size: SceSize, 104 | pub semaId: SceUID, 105 | pub name: [u8; 32], 106 | pub attr: SceUInt, 107 | pub initCount: i32, 108 | pub currentCount: i32, 109 | pub maxCount: i32, 110 | pub numWaitThreads: i32, 111 | } 112 | 113 | #[cfg_attr( 114 | not(feature = "dox"), 115 | link(kind = "static", name = "SceLibKernel_stub") 116 | )] 117 | extern "C" { 118 | 119 | // Mutexes 120 | 121 | pub fn sceKernelCreateMutex( 122 | name: *const u8, 123 | attr: SceUInt, 124 | initCount: i32, 125 | option: *mut SceKernelMutexOptParam, 126 | ) -> SceUID; 127 | pub fn sceKernelOpenMutex(name: *const u8) -> i32; 128 | pub fn sceKernelCloseMutex(mutexid: SceUID) -> i32; 129 | pub fn sceKernelDeleteMutex(mutexid: SceUID) -> i32; 130 | pub fn sceKernelLockMutex(mutexid: SceUID, lockCount: i32, timeout: *mut u32) -> i32; 131 | pub fn sceKernelLockMutexCB(mutexid: SceUID, lockCount: i32, timeout: *mut u32) -> i32; 132 | pub fn sceKernelTryLockMutex(mutexid: SceUID, lockCount: i32) -> i32; 133 | pub fn sceKernelUnlockMutex(mutexid: SceUID, unlockCount: i32) -> i32; 134 | pub fn sceKernelCancelMutex(mutexid: SceUID, lockCount: i32, numWaitThreads: *mut i32) -> i32; 135 | pub fn sceKernelGetMutexInfo(mutexid: SceUID, info: *mut SceKernelMutexInfo) -> i32; 136 | 137 | // Threads 138 | 139 | pub fn sceKernelCreateThread( 140 | name: *const u8, 141 | entry: SceKernelThreadEntry, 142 | initPriority: i32, 143 | stackSize: i32, 144 | attr: SceUInt, 145 | cpuAffinityMask: i32, 146 | option: *const SceKernelThreadOptParam, 147 | ) -> SceUID; 148 | pub fn sceKernelDeleteThread(thid: SceUID) -> i32; 149 | pub fn sceKernelStartThread(thid: SceUID, arglen: SceSize, argp: *mut crate::void) -> i32; 150 | pub fn sceKernelWaitThreadEnd(thid: SceUID, stat: *mut i32, timeout: *mut SceUInt) -> i32; 151 | pub fn sceKernelWaitThreadEndCB(thid: SceUID, stat: *mut i32, timeout: *mut SceUInt) -> i32; 152 | pub fn sceKernelDelayThread(delay: SceUInt) -> i32; 153 | pub fn sceKernelDelayThreadCB(delay: SceUInt) -> i32; 154 | pub fn sceKernelChangeCurrentThreadAttr(unknown: i32, attr: SceUInt) -> i32; 155 | pub fn sceKernelChangeThreadPriority(thid: SceUID, priority: i32) -> i32; 156 | pub fn sceKernelGetThreadId() -> SceUID; 157 | pub fn sceKernelGetThreadCurrentPriority() -> i32; 158 | pub fn sceKernelGetThreadExitStatus(thid: SceUID) -> i32; 159 | pub fn sceKernelCheckThreadStack() -> i32; 160 | pub fn sceKernelGetThreadStackFreeSize(thid: SceUID) -> i32; 161 | pub fn sceKernelGetThreadInfo(thid: SceUID, info: *mut SceKernelThreadInfo) -> i32; 162 | pub fn sceKernelGetThreadRunStatus(thid: SceUID, status: *mut SceKernelThreadRunStatus) -> i32; 163 | 164 | // Semaphores 165 | 166 | pub fn sceKernelCreateSema( 167 | name: *const u8, 168 | attr: SceUInt, 169 | initVal: i32, 170 | maxVal: i32, 171 | option: *mut SceKernelSemaOptParam, 172 | ) -> SceUID; 173 | pub fn sceKernelDeleteSema(semaid: SceUID) -> i32; 174 | pub fn sceKernelSignalSema(semaid: SceUID, signal: i32) -> i32; 175 | pub fn sceKernelWaitSema(semaid: SceUID, signal: i32, timeout: *mut SceUInt) -> i32; 176 | pub fn sceKernelWaitSemaCB(semaid: SceUID, signal: i32, timeout: *mut SceUInt) -> i32; 177 | pub fn sceKernelPollSema(semaid: SceUID, signal: i32) -> i32; 178 | pub fn sceKernelCancelSema(semaid: SceUID, setCount: i32, numWaitThreads: *mut i32) -> i32; 179 | pub fn sceKernelGetSemaInfo(semaid: SceUID, info: *mut SceKernelSemaInfo) -> i32; 180 | 181 | } 182 | -------------------------------------------------------------------------------- /examples/hello_rust_world/src/debug/screen.rs: -------------------------------------------------------------------------------- 1 | use core::fmt::Result; 2 | use core::fmt::Write; 3 | use core::mem::size_of; 4 | use core::slice::from_raw_parts_mut; 5 | 6 | use crate::psp2::display::sceDisplaySetFrameBuf; 7 | use crate::psp2::display::SceDisplayFrameBuf; 8 | use crate::psp2::display::SceDisplaySetBufSync::SCE_DISPLAY_SETBUF_NEXTFRAME; 9 | use crate::psp2::kernel::sysmem::sceKernelAllocMemBlock; 10 | use crate::psp2::kernel::sysmem::sceKernelGetMemBlockBase; 11 | use crate::psp2::kernel::sysmem::SceKernelMemBlockType::SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW; 12 | use crate::psp2::kernel::threadmgr::sceKernelCreateMutex; 13 | use crate::psp2::kernel::threadmgr::sceKernelLockMutex; 14 | use crate::psp2::kernel::threadmgr::sceKernelUnlockMutex; 15 | use crate::psp2::types::SceUID; 16 | use crate::psp2::void; 17 | 18 | use super::font::DEBUG_FONT; 19 | 20 | const SCREEN_WIDTH: usize = 960; 21 | const SCREEN_HEIGHT: usize = 544; 22 | const SCREEN_FB_WIDTH: usize = 960; 23 | const SCREEN_FB_SIZE: usize = 2 * 1024 * 1024; 24 | const SCREEN_TAB_SIZE: usize = 8; 25 | const SCREEN_TAB_W: usize = DEBUG_FONT.size_w * SCREEN_TAB_SIZE; 26 | 27 | const DEFAULT_FG: u32 = 0xFFFFFFFF; 28 | const DEFAULT_BG: u32 = 0xFF000000; 29 | 30 | pub struct DebugScreen<'a> { 31 | base: &'a mut [u32], 32 | mutex: SceUID, 33 | coord_x: usize, 34 | coord_y: usize, 35 | saved_x: usize, 36 | saved_y: usize, 37 | color_fg: u32, 38 | color_bg: u32, 39 | } 40 | 41 | impl<'a> Write for DebugScreen<'a> { 42 | fn write_str(&mut self, s: &str) -> Result { 43 | self.puts(s.as_bytes()); 44 | Ok(()) 45 | } 46 | } 47 | 48 | impl<'a> DebugScreen<'a> { 49 | pub fn new() -> Self { 50 | unsafe { 51 | let mut base: *mut void = ::core::ptr::null_mut(); 52 | 53 | // Create the global screen mutex 54 | let mutex: SceUID = 55 | sceKernelCreateMutex(b"_debug_mutex\0".as_ptr(), 0, 0, ::core::ptr::null_mut()); 56 | 57 | // Allocate memory to use as display buffer 58 | let displayblock: SceUID = sceKernelAllocMemBlock( 59 | b"display\0".as_ptr(), 60 | SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW, 61 | SCREEN_FB_SIZE as i32, 62 | ::core::ptr::null_mut(), 63 | ); 64 | sceKernelGetMemBlockBase(displayblock, &mut base); 65 | 66 | // Set the display frame using the allowated memory 67 | let frame = SceDisplayFrameBuf { 68 | size: size_of::() as u32, 69 | base, 70 | pitch: SCREEN_FB_WIDTH as u32, 71 | pixelformat: 0, 72 | width: SCREEN_WIDTH as u32, 73 | height: SCREEN_HEIGHT as u32, 74 | }; 75 | sceDisplaySetFrameBuf(&frame, SCE_DISPLAY_SETBUF_NEXTFRAME); 76 | 77 | Self { 78 | base: from_raw_parts_mut(base as *mut u32, SCREEN_FB_SIZE as usize / 4), 79 | mutex, 80 | coord_x: 0, 81 | coord_y: 0, 82 | saved_x: 0, 83 | saved_y: 0, 84 | color_fg: DEFAULT_FG, 85 | color_bg: DEFAULT_BG, 86 | } 87 | } 88 | } 89 | 90 | unsafe fn clear(&mut self, from_h: usize, to_h: usize, from_w: usize, to_w: usize) { 91 | for h in from_h..to_h { 92 | for w in from_w..to_w { 93 | self.base[h * SCREEN_FB_WIDTH + w] = self.color_bg; 94 | } 95 | } 96 | } 97 | 98 | fn lock(&mut self) { 99 | unsafe { 100 | sceKernelLockMutex(self.mutex, 1, ::core::ptr::null_mut()); 101 | } 102 | } 103 | 104 | fn unlock(&mut self) { 105 | unsafe { 106 | sceKernelUnlockMutex(self.mutex, 1); 107 | } 108 | } 109 | 110 | fn puts(&mut self, text: &[u8]) { 111 | let bytes_per_glyph = DEBUG_FONT.width * DEBUG_FONT.height / 8; 112 | self.lock(); 113 | 114 | for &chr in text.iter() { 115 | if chr == b'\t' { 116 | self.coord_x += SCREEN_TAB_W - (self.coord_x % SCREEN_TAB_W); 117 | continue; 118 | } 119 | 120 | if (self.coord_x + DEBUG_FONT.width > SCREEN_WIDTH) { 121 | self.coord_y += DEBUG_FONT.size_h; 122 | self.coord_x = 0; 123 | } 124 | 125 | if (self.coord_y + DEBUG_FONT.height > SCREEN_HEIGHT) { 126 | self.coord_x = 0; 127 | self.coord_y = 0; 128 | } 129 | 130 | if chr == b'\n' { 131 | self.coord_x = 0; 132 | self.coord_y += DEBUG_FONT.size_h; 133 | continue; 134 | } else if chr == b'\r' { 135 | self.coord_x = 0; 136 | continue; 137 | } 138 | 139 | let vram = &mut self.base[self.coord_x + self.coord_y * SCREEN_FB_WIDTH..]; 140 | let mut font = 141 | &DEBUG_FONT.glyphs[(chr - DEBUG_FONT.first) as usize * bytes_per_glyph..]; 142 | let mut mask = 1 << 7; 143 | 144 | for row in 0..DEBUG_FONT.height { 145 | for col in 0..DEBUG_FONT.width { 146 | if mask == 0 { 147 | font = &font[1..]; 148 | mask = 1 << 7; 149 | } 150 | 151 | vram[row * SCREEN_FB_WIDTH + col] = if (font[0] & mask == 0) { 152 | self.color_bg 153 | } else { 154 | self.color_fg 155 | }; 156 | 157 | mask >>= 1; 158 | } 159 | 160 | for col in DEBUG_FONT.width..DEBUG_FONT.size_w { 161 | vram[row * SCREEN_FB_WIDTH + col] = self.color_bg 162 | } 163 | } 164 | 165 | for row in DEBUG_FONT.height..DEBUG_FONT.size_h { 166 | for col in 0..DEBUG_FONT.size_w { 167 | vram[row * SCREEN_FB_WIDTH + col] = self.color_bg 168 | } 169 | } 170 | 171 | self.coord_x += DEBUG_FONT.size_w; 172 | } 173 | 174 | self.unlock(); 175 | } 176 | } 177 | -------------------------------------------------------------------------------- /src/dialog/message.rs: -------------------------------------------------------------------------------- 1 | use crate::types::SceChar8; 2 | use crate::types::SceInt32; 3 | use crate::types::SceUInt32; 4 | 5 | use super::common::SceCommonDialogParam; 6 | use super::common::SceCommonDialogStatus; 7 | 8 | #[repr(u32)] 9 | pub enum SceMsgDialogErrorCode { 10 | SCE_MSG_DIALOG_ERROR_PARAM = 0x80100A01, // Illegal parameter 11 | } 12 | 13 | /// Max length of a user message 14 | pub const SCE_MSG_DIALOG_USER_MSG_SIZE: usize = 512; 15 | 16 | #[repr(C)] 17 | pub enum SceMsgDialogMode { 18 | SCE_MSG_DIALOG_MODE_INVALID = 0, 19 | SCE_MSG_DIALOG_MODE_USER_MSG = 1, 20 | SCE_MSG_DIALOG_MODE_SYSTEM_MSG = 2, 21 | SCE_MSG_DIALOG_MODE_ERROR_CODE = 3, 22 | SCE_MSG_DIALOG_MODE_PROGRESS_BAR = 4, 23 | } 24 | 25 | #[repr(C)] 26 | pub enum SceMsgDialogSystemMessageType { 27 | SCE_MSG_DIALOG_SYSMSG_TYPE_INVALID = 0, 28 | // Displays "Please wait." 29 | SCE_MSG_DIALOG_SYSMSG_TYPE_WAIT = 1, 30 | // Displays "There is not enough free space on the memory card." 31 | SCE_MSG_DIALOG_SYSMSG_TYPE_NOSPACE = 2, 32 | // Displays "Move away from the source of interference, or adjust the compass by moving your PS Vita system as shown below." 33 | SCE_MSG_DIALOG_SYSMSG_TYPE_MAGNETIC_CALIBRATION = 3, 34 | // Displays "Please wait." in a small message dialog 35 | SCE_MSG_DIALOG_SYSMSG_TYPE_WAIT_SMALL = 5, 36 | // Displays "Please wait..." with a cancel button 37 | SCE_MSG_DIALOG_SYSMSG_TYPE_WAIT_CANCEL = 6, 38 | // Displays "Cannot continue the application. No memory card is inserted." 39 | SCE_MSG_DIALOG_SYSMSG_TYPE_NEED_MC_CONTINUE = 7, 40 | // Displays "Cannot perform this operation. No memory card is inserted." 41 | SCE_MSG_DIALOG_SYSMSG_TYPE_NEED_MC_OPERATION = 8, 42 | // Displays "You must enable the microphone." 43 | SCE_MSG_DIALOG_SYSMSG_TYPE_TRC_MIC_DISABLED = 100, 44 | // Displays "You must use Wi-Fi to do this." 45 | SCE_MSG_DIALOG_SYSMSG_TYPE_TRC_WIFI_REQUIRED_OPERATION = 101, 46 | // Displays "You must use Wi-Fi to use this application." 47 | SCE_MSG_DIALOG_SYSMSG_TYPE_TRC_WIFI_REQUIRED_APPLICATION = 102, 48 | // Displays "No content is available yet." 49 | SCE_MSG_DIALOG_SYSMSG_TYPE_TRC_EMPTY_STORE = 103, 50 | } 51 | 52 | #[repr(C)] 53 | pub enum SceMsgDialogButtonType { 54 | SCE_MSG_DIALOG_BUTTON_TYPE_OK = 0, 55 | SCE_MSG_DIALOG_BUTTON_TYPE_YESNO = 1, 56 | SCE_MSG_DIALOG_BUTTON_TYPE_NONE = 2, 57 | SCE_MSG_DIALOG_BUTTON_TYPE_OK_CANCEL = 3, 58 | SCE_MSG_DIALOG_BUTTON_TYPE_CANCEL = 4, 59 | SCE_MSG_DIALOG_BUTTON_TYPE_3BUTTONS = 5, 60 | } 61 | 62 | #[repr(C)] 63 | pub enum SceMsgDialogButtonId { 64 | SCE_MSG_DIALOG_BUTTON_ID_INVALID = 0, 65 | // SCE_MSG_DIALOG_BUTTON_ID_OK = 1, 66 | SCE_MSG_DIALOG_BUTTON_ID_YES = 1, 67 | SCE_MSG_DIALOG_BUTTON_ID_NO = 2, 68 | SCE_MSG_DIALOG_BUTTON_ID_RETRY = 3, 69 | } 70 | 71 | #[repr(C)] 72 | pub enum SceMsgDialogProgressBarType { 73 | SCE_MSG_DIALOG_PROGRESSBAR_TYPE_PERCENTAGE = 0, 74 | } 75 | 76 | #[repr(C)] 77 | pub enum SceMsgDialogProgressBarTarget { 78 | SCE_MSG_DIALOG_PROGRESSBAR_TARGET_BAR_DEFAULT = 0, 79 | } 80 | 81 | #[repr(C)] 82 | pub enum SceMsgDialogEnvFlag { 83 | SCE_MSG_DIALOG_ENV_FLAG_DEFAULT = 0, 84 | } 85 | 86 | #[repr(C)] 87 | pub enum SceMsgDialogFontSize { 88 | SCE_MSG_DIALOG_FONT_SIZE_DEFAULT = 0, 89 | SCE_MSG_DIALOG_FONT_SIZE_SMALL = 1, 90 | } 91 | 92 | #[repr(C)] 93 | pub struct SceMsgDialogButtonsParam { 94 | pub msg1: *const u8, 95 | pub fontSize1: SceMsgDialogFontSize, 96 | pub msg2: *const u8, 97 | pub fontSize2: SceMsgDialogFontSize, 98 | pub msg3: *const u8, 99 | pub fontSize3: SceMsgDialogFontSize, 100 | pub reserved: [SceChar8; 32], 101 | } 102 | 103 | #[repr(C)] 104 | pub struct SceMsgDialogUserMessageParam { 105 | pub buttonType: SceMsgDialogButtonType, 106 | pub msg: *const SceChar8, 107 | pub buttonParam: *mut SceMsgDialogButtonsParam, 108 | pub reserved: [SceChar8; 28], 109 | } 110 | 111 | #[repr(C)] 112 | pub struct SceMsgDialogSystemMessageParam { 113 | pub sysMsgType: SceMsgDialogSystemMessageType, 114 | pub value: SceInt32, 115 | pub reserved: [SceChar8; 32], 116 | } 117 | 118 | #[repr(C)] 119 | pub struct SceMsgDialogErrorCodeParam { 120 | pub errorCode: SceInt32, 121 | pub reserved: SceChar8, 122 | } 123 | 124 | #[repr(C)] 125 | pub struct SceMsgDialogProgressBarParam { 126 | pub barType: SceMsgDialogProgressBarType, 127 | pub sysMsgParam: SceMsgDialogSystemMessageParam, 128 | pub msg: *const SceChar8, 129 | pub reserved: [SceInt32; 8], 130 | } 131 | 132 | #[repr(C)] 133 | pub struct SceMsgDialogParam { 134 | pub sdkVersion: SceUInt32, 135 | pub commonParam: SceCommonDialogParam, 136 | pub mode: SceMsgDialogMode, 137 | pub userMsgParam: *mut SceMsgDialogUserMessageParam, 138 | pub sysMsgParam: *mut SceMsgDialogSystemMessageParam, 139 | pub errorCodeParam: *mut SceMsgDialogErrorCodeParam, 140 | pub progBarParam: *mut SceMsgDialogProgressBarParam, 141 | pub flag: SceInt32, 142 | pub reserved: [SceChar8; 32], 143 | } 144 | 145 | #[repr(C)] 146 | pub struct SceMsgDialogResult { 147 | pub mode: SceMsgDialogMode, 148 | pub result: SceInt32, 149 | pub buttonId: SceMsgDialogButtonId, 150 | pub reserved: [SceChar8; 32], 151 | } 152 | 153 | // static inline 154 | // void sceMsgDialogParamInit(SceMsgDialogParam *param) 155 | // { 156 | // memset( param, 0x0, sizeof(SceMsgDialogParam) ); 157 | // _sceCommonDialogSetMagicNumber( ¶m->commonParam ); 158 | // param->sdkVersion = 0x03150021; 159 | // } 160 | 161 | #[cfg_attr( 162 | not(feature = "dox"), 163 | link(name = "SceCommonDialog_stub", kind = "static") 164 | )] 165 | extern "C" { 166 | pub fn sceMsgDialogInit(param: *const SceMsgDialogParam) -> i32; 167 | pub fn sceMsgDialogGetStatus() -> SceCommonDialogStatus; 168 | pub fn sceMsgDialogAbort() -> i32; 169 | pub fn sceMsgDialogGetResult(result: *mut SceMsgDialogResult) -> i32; 170 | pub fn sceMsgDialogTerm() -> i32; 171 | pub fn sceMsgDialogClose() -> i32; 172 | pub fn sceMsgDialogProgressBarInc( 173 | target: SceMsgDialogProgressBarTarget, 174 | delta: SceUInt32, 175 | ) -> i32; 176 | pub fn sceMsgDialogProgressBarSetValue( 177 | target: SceMsgDialogProgressBarTarget, 178 | rate: SceUInt32, 179 | ) -> i32; 180 | pub fn sceMsgDialogProgressBarSetMsg( 181 | target: SceMsgDialogProgressBarTarget, 182 | barMsg: *const SceChar8, 183 | ) -> i32; 184 | } 185 | -------------------------------------------------------------------------------- /src/graphics/gxm.rs: -------------------------------------------------------------------------------- 1 | // Error Codes 2 | // typedef enum SceGxmErrorCode { 3 | // SCE_GXM_ERROR_UNINITIALIZED = 0x805B0000, 4 | // SCE_GXM_ERROR_ALREADY_INITIALIZED = 0x805B0001, 5 | // SCE_GXM_ERROR_OUT_OF_MEMORY = 0x805B0002, 6 | // SCE_GXM_ERROR_INVALID_VALUE = 0x805B0003, 7 | // SCE_GXM_ERROR_INVALID_POINTER = 0x805B0004, 8 | // SCE_GXM_ERROR_INVALID_ALIGNMENT = 0x805B0005, 9 | // SCE_GXM_ERROR_NOT_WITHIN_SCENE = 0x805B0006, 10 | // SCE_GXM_ERROR_WITHIN_SCENE = 0x805B0007, 11 | // SCE_GXM_ERROR_NULL_PROGRAM = 0x805B0008, 12 | // SCE_GXM_ERROR_UNSUPPORTED = 0x805B0009, 13 | // SCE_GXM_ERROR_PATCHER_INTERNAL = 0x805B000A, 14 | // SCE_GXM_ERROR_RESERVE_FAILED = 0x805B000B, 15 | // SCE_GXM_ERROR_PROGRAM_IN_USE = 0x805B000C, 16 | // SCE_GXM_ERROR_INVALID_INDEX_COUNT = 0x805B000D, 17 | // SCE_GXM_ERROR_INVALID_POLYGON_MODE = 0x805B000E, 18 | // SCE_GXM_ERROR_INVALID_SAMPLER_RESULT_TYPE_PRECISION = 0x805B000F, 19 | // SCE_GXM_ERROR_INVALID_SAMPLER_RESULT_TYPE_COMPONENT_COUNT = 0x805B0010, 20 | // SCE_GXM_ERROR_UNIFORM_BUFFER_NOT_RESERVED = 0x805B0011, 21 | // SCE_GXM_ERROR_INVALID_AUXILIARY_SURFACE = 0x805B0013, 22 | // SCE_GXM_ERROR_INVALID_PRECOMPUTED_DRAW = 0x805B0014, 23 | // SCE_GXM_ERROR_INVALID_PRECOMPUTED_VERTEX_STATE = 0x805B0015, 24 | // SCE_GXM_ERROR_INVALID_PRECOMPUTED_FRAGMENT_STATE = 0x805B0016, 25 | // SCE_GXM_ERROR_DRIVER = 0x805B0017 26 | // } SceGxmErrorCode; 27 | // 28 | // typedef void (SceGxmDisplayQueueCallback)(const void *callbackData); 29 | // 30 | // typedef struct SceGxmInitializeParams { 31 | // unsigned int flags; 32 | // unsigned int displayQueueMaxPendingCount; 33 | // SceGxmDisplayQueueCallback *displayQueueCallback; 34 | // unsigned int displayQueueCallbackDataSize; 35 | // SceSize parameterBufferSize; 36 | // } SceGxmInitializeParams; 37 | // 38 | 39 | use self::SceGxmColorBaseFormat::*; 40 | // use self::SceGxmColorFormat::*; 41 | // use self::SceGxmColorSwizzle2Mode::*; 42 | use self::SceGxmColorSwizzle4Mode::*; 43 | use self::SceGxmMemoryAttribFlags::*; 44 | 45 | #[repr(u32)] 46 | pub enum SceGxmMemoryAttribFlags { 47 | SCE_GXM_MEMORY_ATTRIB_READ = 1, 48 | SCE_GXM_MEMORY_ATTRIB_WRITE = 2, 49 | SCE_GXM_MEMORY_ATTRIB_RW = 50 | SCE_GXM_MEMORY_ATTRIB_READ as u32 | SCE_GXM_MEMORY_ATTRIB_WRITE as u32, 51 | } 52 | 53 | #[repr(u32)] 54 | pub enum SceGxmAttributeFormat { 55 | SCE_GXM_ATTRIBUTE_FORMAT_U8, 56 | SCE_GXM_ATTRIBUTE_FORMAT_S8, 57 | SCE_GXM_ATTRIBUTE_FORMAT_U16, 58 | SCE_GXM_ATTRIBUTE_FORMAT_S16, 59 | SCE_GXM_ATTRIBUTE_FORMAT_U8N, 60 | SCE_GXM_ATTRIBUTE_FORMAT_S8N, 61 | SCE_GXM_ATTRIBUTE_FORMAT_U16N, 62 | SCE_GXM_ATTRIBUTE_FORMAT_S16N, 63 | SCE_GXM_ATTRIBUTE_FORMAT_F16, 64 | SCE_GXM_ATTRIBUTE_FORMAT_F32, 65 | SCE_GXM_ATTRIBUTE_FORMAT_UNTYPED, 66 | } 67 | 68 | #[repr(u32)] 69 | pub enum SceGxmDepthStencilFormat { 70 | SCE_GXM_DEPTH_STENCIL_FORMAT_DF32 = 0x00044000, 71 | SCE_GXM_DEPTH_STENCIL_FORMAT_S8 = 0x00022000, 72 | SCE_GXM_DEPTH_STENCIL_FORMAT_DF32_S8 = 0x00066000, 73 | SCE_GXM_DEPTH_STENCIL_FORMAT_DF32M = 0x000CC000, 74 | SCE_GXM_DEPTH_STENCIL_FORMAT_DF32M_S8 = 0x000EE000, 75 | SCE_GXM_DEPTH_STENCIL_FORMAT_S8D24 = 0x01266000, 76 | SCE_GXM_DEPTH_STENCIL_FORMAT_D16 = 0x02444000, 77 | } 78 | 79 | #[repr(u32)] 80 | pub enum SceGxmPrimitiveType { 81 | SCE_GXM_PRIMITIVE_TRIANGLES = 0x00000000, 82 | SCE_GXM_PRIMITIVE_LINES = 0x04000000, 83 | SCE_GXM_PRIMITIVE_POINTS = 0x08000000, 84 | SCE_GXM_PRIMITIVE_TRIANGLE_STRIP = 0x0C000000, 85 | SCE_GXM_PRIMITIVE_TRIANGLE_FAN = 0x10000000, 86 | SCE_GXM_PRIMITIVE_TRIANGLE_EDGES = 0x14000000, 87 | } 88 | 89 | #[repr(u32)] 90 | pub enum SceGxmEdgeEnableFlags { 91 | SCE_GXM_EDGE_ENABLE_01 = 0x00000100, 92 | SCE_GXM_EDGE_ENABLE_12 = 0x00000200, 93 | SCE_GXM_EDGE_ENABLE_20 = 0x00000400, 94 | } 95 | 96 | #[repr(u32)] 97 | pub enum SceGxmRegionClipMode { 98 | SCE_GXM_REGION_CLIP_NONE = 0x00000000, 99 | SCE_GXM_REGION_CLIP_ALL = 0x40000000, 100 | SCE_GXM_REGION_CLIP_OUTSIDE = 0x80000000, 101 | SCE_GXM_REGION_CLIP_INSIDE = 0xC0000000, 102 | } 103 | 104 | #[repr(u32)] 105 | pub enum SceGxmDepthFunc { 106 | SCE_GXM_DEPTH_FUNC_NEVER = 0x00000000, 107 | SCE_GXM_DEPTH_FUNC_LESS = 0x00400000, 108 | SCE_GXM_DEPTH_FUNC_EQUAL = 0x00800000, 109 | SCE_GXM_DEPTH_FUNC_LESS_EQUAL = 0x00C00000, 110 | SCE_GXM_DEPTH_FUNC_GREATER = 0x01000000, 111 | SCE_GXM_DEPTH_FUNC_NOT_EQUAL = 0x01400000, 112 | SCE_GXM_DEPTH_FUNC_GREATER_EQUAL = 0x01800000, 113 | SCE_GXM_DEPTH_FUNC_ALWAYS = 0x01C00000, 114 | } 115 | 116 | #[repr(u32)] 117 | pub enum SceGxmStencilFunc { 118 | SCE_GXM_STENCIL_FUNC_NEVER = 0x00000000, 119 | SCE_GXM_STENCIL_FUNC_LESS = 0x02000000, 120 | SCE_GXM_STENCIL_FUNC_EQUAL = 0x04000000, 121 | SCE_GXM_STENCIL_FUNC_LESS_EQUAL = 0x06000000, 122 | SCE_GXM_STENCIL_FUNC_GREATER = 0x08000000, 123 | SCE_GXM_STENCIL_FUNC_NOT_EQUAL = 0x0A000000, 124 | SCE_GXM_STENCIL_FUNC_GREATER_EQUAL = 0x0C000000, 125 | SCE_GXM_STENCIL_FUNC_ALWAYS = 0x0E000000, 126 | } 127 | 128 | #[repr(u32)] 129 | pub enum SceGxmStencilOp { 130 | SCE_GXM_STENCIL_OP_KEEP = 0x00000000, 131 | SCE_GXM_STENCIL_OP_ZERO = 0x00000001, 132 | SCE_GXM_STENCIL_OP_REPLACE = 0x00000002, 133 | SCE_GXM_STENCIL_OP_INCR = 0x00000003, 134 | SCE_GXM_STENCIL_OP_DECR = 0x00000004, 135 | SCE_GXM_STENCIL_OP_INVERT = 0x00000005, 136 | SCE_GXM_STENCIL_OP_INCR_WRAP = 0x00000006, 137 | SCE_GXM_STENCIL_OP_DECR_WRAP = 0x00000007, 138 | } 139 | 140 | #[repr(u32)] 141 | pub enum SceGxmCullMode { 142 | SCE_GXM_CULL_NONE = 0x00000000, 143 | SCE_GXM_CULL_CW = 0x00000001, 144 | SCE_GXM_CULL_CCW = 0x00000002, 145 | } 146 | 147 | #[repr(u32)] 148 | pub enum SceGxmPolygonMode { 149 | SCE_GXM_POLYGON_MODE_TRIANGLE_FILL = 0x00000000, 150 | SCE_GXM_POLYGON_MODE_LINE = 0x00008000, 151 | SCE_GXM_POLYGON_MODE_POINT_10UV = 0x00010000, 152 | SCE_GXM_POLYGON_MODE_POINT = 0x00018000, 153 | SCE_GXM_POLYGON_MODE_POINT_01UV = 0x00020000, 154 | SCE_GXM_POLYGON_MODE_TRIANGLE_LINE = 0x00028000, 155 | SCE_GXM_POLYGON_MODE_TRIANGLE_POINT = 0x00030000, 156 | } 157 | 158 | #[repr(u32)] 159 | pub enum SceGxmColorSwizzle4Mode { 160 | SCE_GXM_COLOR_SWIZZLE4_ABGR = 0x00000000, 161 | SCE_GXM_COLOR_SWIZZLE4_ARGB = 0x00100000, 162 | SCE_GXM_COLOR_SWIZZLE4_RGBA = 0x00200000, 163 | SCE_GXM_COLOR_SWIZZLE4_BGRA = 0x00300000, 164 | } 165 | 166 | #[repr(u32)] 167 | pub enum SceGxmColorSwizzle3Mode { 168 | SCE_GXM_COLOR_SWIZZLE3_BGR = 0x00000000, 169 | SCE_GXM_COLOR_SWIZZLE3_RGB = 0x00100000, 170 | } 171 | 172 | #[repr(u32)] 173 | pub enum SceGxmColorSwizzle2Mode { 174 | SCE_GXM_COLOR_SWIZZLE2_GR = 0x00000000, 175 | SCE_GXM_COLOR_SWIZZLE2_RG = 0x00100000, 176 | SCE_GXM_COLOR_SWIZZLE2_RA = 0x00200000, 177 | SCE_GXM_COLOR_SWIZZLE2_AR = 0x00300000, 178 | } 179 | 180 | #[repr(u32)] 181 | pub enum SceGxmColorSwizzle1Mode { 182 | SCE_GXM_COLOR_SWIZZLE1_R = 0x00000000, 183 | SCE_GXM_COLOR_SWIZZLE1_G = 0x00100000, 184 | // SCE_GXM_COLOR_SWIZZLE1_A = 0x00100000, 185 | } 186 | 187 | #[repr(u32)] 188 | pub enum SceGxmColorBaseFormat { 189 | SCE_GXM_COLOR_BASE_FORMAT_U8U8U8U8 = 0x00000000, 190 | SCE_GXM_COLOR_BASE_FORMAT_U8U8U8 = 0x10000000, 191 | SCE_GXM_COLOR_BASE_FORMAT_U5U6U5 = 0x30000000, 192 | SCE_GXM_COLOR_BASE_FORMAT_U1U5U5U5 = 0x40000000, 193 | SCE_GXM_COLOR_BASE_FORMAT_U4U4U4U4 = 0x50000000, 194 | SCE_GXM_COLOR_BASE_FORMAT_U8U3U3U2 = 0x60000000, 195 | SCE_GXM_COLOR_BASE_FORMAT_F16 = 0xF0000000, 196 | SCE_GXM_COLOR_BASE_FORMAT_F16F16 = 0x00800000, 197 | SCE_GXM_COLOR_BASE_FORMAT_F32 = 0x10800000, 198 | SCE_GXM_COLOR_BASE_FORMAT_S16 = 0x20800000, 199 | SCE_GXM_COLOR_BASE_FORMAT_S16S16 = 0x30800000, 200 | SCE_GXM_COLOR_BASE_FORMAT_U16 = 0x40800000, 201 | SCE_GXM_COLOR_BASE_FORMAT_U16U16 = 0x50800000, 202 | SCE_GXM_COLOR_BASE_FORMAT_U2U10U10U10 = 0x60800000, 203 | SCE_GXM_COLOR_BASE_FORMAT_U8 = 0x80800000, 204 | SCE_GXM_COLOR_BASE_FORMAT_S8 = 0x90800000, 205 | SCE_GXM_COLOR_BASE_FORMAT_S5S5U6 = 0xA0800000, 206 | SCE_GXM_COLOR_BASE_FORMAT_U8U8 = 0xB0800000, 207 | SCE_GXM_COLOR_BASE_FORMAT_S8S8 = 0xC0800000, 208 | SCE_GXM_COLOR_BASE_FORMAT_U8S8S8U8 = 0xD0800000, 209 | SCE_GXM_COLOR_BASE_FORMAT_S8S8S8S8 = 0xE0800000, 210 | SCE_GXM_COLOR_BASE_FORMAT_F16F16F16F16 = 0x01000000, 211 | SCE_GXM_COLOR_BASE_FORMAT_F32F32 = 0x11000000, 212 | SCE_GXM_COLOR_BASE_FORMAT_F11F11F10 = 0x21000000, 213 | SCE_GXM_COLOR_BASE_FORMAT_SE5M9M9M9 = 0x31000000, 214 | SCE_GXM_COLOR_BASE_FORMAT_U2F10F10F10 = 0x41000000, 215 | } 216 | 217 | /// Supported color formats 218 | #[repr(u32)] 219 | pub enum SceGxmColorFormat { 220 | SCE_GXM_COLOR_FORMAT_U8U8U8U8_ABGR = 221 | SCE_GXM_COLOR_BASE_FORMAT_U8U8U8U8 as u32 | SCE_GXM_COLOR_SWIZZLE4_ABGR as u32, 222 | // SCE_GXM_COLOR_FORMAT_U8U8U8U8_ARGB = 223 | // SCE_GXM_COLOR_BASE_FORMAT_U8U8U8U8 | SCE_GXM_COLOR_SWIZZLE4_ARGB, 224 | // SCE_GXM_COLOR_FORMAT_U8U8U8U8_RGBA = 225 | // SCE_GXM_COLOR_BASE_FORMAT_U8U8U8U8 | SCE_GXM_COLOR_SWIZZLE4_RGBA, 226 | // SCE_GXM_COLOR_FORMAT_U8U8U8U8_BGRA = 227 | // SCE_GXM_COLOR_BASE_FORMAT_U8U8U8U8 | SCE_GXM_COLOR_SWIZZLE4_BGRA, 228 | // 229 | // SCE_GXM_COLOR_FORMAT_U8U8U8_BGR = SCE_GXM_COLOR_BASE_FORMAT_U8U8U8 | SCE_GXM_COLOR_SWIZZLE3_BGR, 230 | // SCE_GXM_COLOR_FORMAT_U8U8U8_RGB = SCE_GXM_COLOR_BASE_FORMAT_U8U8U8 | SCE_GXM_COLOR_SWIZZLE3_RGB, 231 | // 232 | // SCE_GXM_COLOR_FORMAT_U5U6U5_BGR = SCE_GXM_COLOR_BASE_FORMAT_U5U6U5 | SCE_GXM_COLOR_SWIZZLE3_BGR, 233 | // SCE_GXM_COLOR_FORMAT_U5U6U5_RGB = SCE_GXM_COLOR_BASE_FORMAT_U5U6U5 | SCE_GXM_COLOR_SWIZZLE3_RGB, 234 | // 235 | // SCE_GXM_COLOR_FORMAT_U1U5U5U5_ABGR = 236 | // SCE_GXM_COLOR_BASE_FORMAT_U1U5U5U5 | SCE_GXM_COLOR_SWIZZLE4_ABGR, 237 | // SCE_GXM_COLOR_FORMAT_U1U5U5U5_ARGB = 238 | // SCE_GXM_COLOR_BASE_FORMAT_U1U5U5U5 | SCE_GXM_COLOR_SWIZZLE4_ARGB, 239 | // SCE_GXM_COLOR_FORMAT_U5U5U5U1_RGBA = 240 | // SCE_GXM_COLOR_BASE_FORMAT_U1U5U5U5 | SCE_GXM_COLOR_SWIZZLE4_RGBA, 241 | // SCE_GXM_COLOR_FORMAT_U5U5U5U1_BGRA = 242 | // SCE_GXM_COLOR_BASE_FORMAT_U1U5U5U5 | SCE_GXM_COLOR_SWIZZLE4_BGRA, 243 | // 244 | // SCE_GXM_COLOR_FORMAT_U4U4U4U4_ABGR = 245 | // SCE_GXM_COLOR_BASE_FORMAT_U4U4U4U4 | SCE_GXM_COLOR_SWIZZLE4_ABGR, 246 | // SCE_GXM_COLOR_FORMAT_U4U4U4U4_ARGB = 247 | // SCE_GXM_COLOR_BASE_FORMAT_U4U4U4U4 | SCE_GXM_COLOR_SWIZZLE4_ARGB, 248 | // SCE_GXM_COLOR_FORMAT_U4U4U4U4_RGBA = 249 | // SCE_GXM_COLOR_BASE_FORMAT_U4U4U4U4 | SCE_GXM_COLOR_SWIZZLE4_RGBA, 250 | // SCE_GXM_COLOR_FORMAT_U4U4U4U4_BGRA = 251 | // SCE_GXM_COLOR_BASE_FORMAT_U4U4U4U4 | SCE_GXM_COLOR_SWIZZLE4_BGRA, 252 | // 253 | // SCE_GXM_COLOR_FORMAT_U8U3U3U2_ARGB = SCE_GXM_COLOR_BASE_FORMAT_U8U3U3U2, 254 | // 255 | // SCE_GXM_COLOR_FORMAT_F16_R = SCE_GXM_COLOR_BASE_FORMAT_F16 | SCE_GXM_COLOR_SWIZZLE1_R, 256 | // SCE_GXM_COLOR_FORMAT_F16_G = SCE_GXM_COLOR_BASE_FORMAT_F16 | SCE_GXM_COLOR_SWIZZLE1_G, 257 | // 258 | // SCE_GXM_COLOR_FORMAT_F16F16_GR = SCE_GXM_COLOR_BASE_FORMAT_F16F16 | SCE_GXM_COLOR_SWIZZLE2_GR, 259 | // SCE_GXM_COLOR_FORMAT_F16F16_RG = SCE_GXM_COLOR_BASE_FORMAT_F16F16 | SCE_GXM_COLOR_SWIZZLE2_RG, 260 | // 261 | // SCE_GXM_COLOR_FORMAT_F32_R = SCE_GXM_COLOR_BASE_FORMAT_F32 | SCE_GXM_COLOR_SWIZZLE1_R, 262 | // 263 | // SCE_GXM_COLOR_FORMAT_S16_R = SCE_GXM_COLOR_BASE_FORMAT_S16 | SCE_GXM_COLOR_SWIZZLE1_R, 264 | // SCE_GXM_COLOR_FORMAT_S16_G = SCE_GXM_COLOR_BASE_FORMAT_S16 | SCE_GXM_COLOR_SWIZZLE1_G, 265 | // 266 | // SCE_GXM_COLOR_FORMAT_S16S16_GR = SCE_GXM_COLOR_BASE_FORMAT_S16S16 | SCE_GXM_COLOR_SWIZZLE2_GR, 267 | // SCE_GXM_COLOR_FORMAT_S16S16_RG = SCE_GXM_COLOR_BASE_FORMAT_S16S16 | SCE_GXM_COLOR_SWIZZLE2_RG, 268 | // 269 | // SCE_GXM_COLOR_FORMAT_U16_R = SCE_GXM_COLOR_BASE_FORMAT_U16 | SCE_GXM_COLOR_SWIZZLE1_R, 270 | // SCE_GXM_COLOR_FORMAT_U16_G = SCE_GXM_COLOR_BASE_FORMAT_U16 | SCE_GXM_COLOR_SWIZZLE1_G, 271 | // 272 | // SCE_GXM_COLOR_FORMAT_U16U16_GR = SCE_GXM_COLOR_BASE_FORMAT_U16U16 | SCE_GXM_COLOR_SWIZZLE2_GR, 273 | // SCE_GXM_COLOR_FORMAT_U16U16_RG = SCE_GXM_COLOR_BASE_FORMAT_U16U16 | SCE_GXM_COLOR_SWIZZLE2_RG, 274 | // 275 | // SCE_GXM_COLOR_FORMAT_U2U10U10U10_ABGR = 276 | // SCE_GXM_COLOR_BASE_FORMAT_U2U10U10U10 | SCE_GXM_COLOR_SWIZZLE4_ABGR, 277 | // SCE_GXM_COLOR_FORMAT_U2U10U10U10_ARGB = 278 | // SCE_GXM_COLOR_BASE_FORMAT_U2U10U10U10 | SCE_GXM_COLOR_SWIZZLE4_ARGB, 279 | // SCE_GXM_COLOR_FORMAT_U10U10U10U2_RGBA = 280 | // SCE_GXM_COLOR_BASE_FORMAT_U2U10U10U10 | SCE_GXM_COLOR_SWIZZLE4_RGBA, 281 | // SCE_GXM_COLOR_FORMAT_U10U10U10U2_BGRA = 282 | // SCE_GXM_COLOR_BASE_FORMAT_U2U10U10U10 | SCE_GXM_COLOR_SWIZZLE4_BGRA, 283 | // 284 | // SCE_GXM_COLOR_FORMAT_U8_R = SCE_GXM_COLOR_BASE_FORMAT_U8 | SCE_GXM_COLOR_SWIZZLE1_R, 285 | // SCE_GXM_COLOR_FORMAT_U8_A = SCE_GXM_COLOR_BASE_FORMAT_U8 | SCE_GXM_COLOR_SWIZZLE1_A, 286 | // 287 | // SCE_GXM_COLOR_FORMAT_S8_R = SCE_GXM_COLOR_BASE_FORMAT_S8 | SCE_GXM_COLOR_SWIZZLE1_R, 288 | // SCE_GXM_COLOR_FORMAT_S8_A = SCE_GXM_COLOR_BASE_FORMAT_S8 | SCE_GXM_COLOR_SWIZZLE1_A, 289 | // 290 | // SCE_GXM_COLOR_FORMAT_U6S5S5_BGR = SCE_GXM_COLOR_BASE_FORMAT_S5S5U6 | SCE_GXM_COLOR_SWIZZLE3_BGR, 291 | // SCE_GXM_COLOR_FORMAT_S5S5U6_RGB = SCE_GXM_COLOR_BASE_FORMAT_S5S5U6 | SCE_GXM_COLOR_SWIZZLE3_RGB, 292 | // 293 | // SCE_GXM_COLOR_FORMAT_U8U8_GR = SCE_GXM_COLOR_BASE_FORMAT_U8U8 | SCE_GXM_COLOR_SWIZZLE2_GR, 294 | // SCE_GXM_COLOR_FORMAT_U8U8_RG = SCE_GXM_COLOR_BASE_FORMAT_U8U8 | SCE_GXM_COLOR_SWIZZLE2_RG, 295 | // SCE_GXM_COLOR_FORMAT_U8U8_RA = SCE_GXM_COLOR_BASE_FORMAT_U8U8 | SCE_GXM_COLOR_SWIZZLE2_RA, 296 | // SCE_GXM_COLOR_FORMAT_U8U8_AR = SCE_GXM_COLOR_BASE_FORMAT_U8U8 | SCE_GXM_COLOR_SWIZZLE2_AR, 297 | // 298 | // SCE_GXM_COLOR_FORMAT_S8S8_GR = SCE_GXM_COLOR_BASE_FORMAT_S8S8 | SCE_GXM_COLOR_SWIZZLE2_GR, 299 | // SCE_GXM_COLOR_FORMAT_S8S8_RG = SCE_GXM_COLOR_BASE_FORMAT_S8S8 | SCE_GXM_COLOR_SWIZZLE2_RG, 300 | // SCE_GXM_COLOR_FORMAT_S8S8_RA = SCE_GXM_COLOR_BASE_FORMAT_S8S8 | SCE_GXM_COLOR_SWIZZLE2_RA, 301 | // SCE_GXM_COLOR_FORMAT_S8S8_AR = SCE_GXM_COLOR_BASE_FORMAT_S8S8 | SCE_GXM_COLOR_SWIZZLE2_AR, 302 | // 303 | // SCE_GXM_COLOR_FORMAT_U8S8S8U8_ABGR = 304 | // SCE_GXM_COLOR_BASE_FORMAT_U8S8S8U8 | SCE_GXM_COLOR_SWIZZLE4_ABGR, 305 | // SCE_GXM_COLOR_FORMAT_U8U8S8S8_ARGB = 306 | // SCE_GXM_COLOR_BASE_FORMAT_U8S8S8U8 | SCE_GXM_COLOR_SWIZZLE4_ARGB, 307 | // SCE_GXM_COLOR_FORMAT_U8S8S8U8_RGBA = 308 | // SCE_GXM_COLOR_BASE_FORMAT_U8S8S8U8 | SCE_GXM_COLOR_SWIZZLE4_RGBA, 309 | // SCE_GXM_COLOR_FORMAT_S8S8U8U8_BGRA = 310 | // SCE_GXM_COLOR_BASE_FORMAT_U8S8S8U8 | SCE_GXM_COLOR_SWIZZLE4_BGRA, 311 | // 312 | // SCE_GXM_COLOR_FORMAT_S8S8S8S8_ABGR = 313 | // SCE_GXM_COLOR_BASE_FORMAT_S8S8S8S8 | SCE_GXM_COLOR_SWIZZLE4_ABGR, 314 | // SCE_GXM_COLOR_FORMAT_S8S8S8S8_ARGB = 315 | // SCE_GXM_COLOR_BASE_FORMAT_S8S8S8S8 | SCE_GXM_COLOR_SWIZZLE4_ARGB, 316 | // SCE_GXM_COLOR_FORMAT_S8S8S8S8_RGBA = 317 | // SCE_GXM_COLOR_BASE_FORMAT_S8S8S8S8 | SCE_GXM_COLOR_SWIZZLE4_RGBA, 318 | // SCE_GXM_COLOR_FORMAT_S8S8S8S8_BGRA = 319 | // SCE_GXM_COLOR_BASE_FORMAT_S8S8S8S8 | SCE_GXM_COLOR_SWIZZLE4_BGRA, 320 | // 321 | // SCE_GXM_COLOR_FORMAT_F16F16F16F16_ABGR = 322 | // SCE_GXM_COLOR_BASE_FORMAT_F16F16F16F16 | SCE_GXM_COLOR_SWIZZLE4_ABGR, 323 | // SCE_GXM_COLOR_FORMAT_F16F16F16F16_ARGB = 324 | // SCE_GXM_COLOR_BASE_FORMAT_F16F16F16F16 | SCE_GXM_COLOR_SWIZZLE4_ARGB, 325 | // SCE_GXM_COLOR_FORMAT_F16F16F16F16_RGBA = 326 | // SCE_GXM_COLOR_BASE_FORMAT_F16F16F16F16 | SCE_GXM_COLOR_SWIZZLE4_RGBA, 327 | // SCE_GXM_COLOR_FORMAT_F16F16F16F16_BGRA = 328 | // SCE_GXM_COLOR_BASE_FORMAT_F16F16F16F16 | SCE_GXM_COLOR_SWIZZLE4_BGRA, 329 | // 330 | // SCE_GXM_COLOR_FORMAT_F32F32_GR = SCE_GXM_COLOR_BASE_FORMAT_F32F32 | SCE_GXM_COLOR_SWIZZLE2_GR, 331 | // SCE_GXM_COLOR_FORMAT_F32F32_RG = SCE_GXM_COLOR_BASE_FORMAT_F32F32 | SCE_GXM_COLOR_SWIZZLE2_RG, 332 | // 333 | // SCE_GXM_COLOR_FORMAT_F10F11F11_BGR = 334 | // SCE_GXM_COLOR_BASE_FORMAT_F11F11F10 | SCE_GXM_COLOR_SWIZZLE3_BGR, 335 | // SCE_GXM_COLOR_FORMAT_F11F11F10_RGB = 336 | // SCE_GXM_COLOR_BASE_FORMAT_F11F11F10 | SCE_GXM_COLOR_SWIZZLE3_RGB, 337 | // 338 | // SCE_GXM_COLOR_FORMAT_SE5M9M9M9_BGR = 339 | // SCE_GXM_COLOR_BASE_FORMAT_SE5M9M9M9 | SCE_GXM_COLOR_SWIZZLE3_BGR, 340 | // SCE_GXM_COLOR_FORMAT_SE5M9M9M9_RGB = 341 | // SCE_GXM_COLOR_BASE_FORMAT_SE5M9M9M9 | SCE_GXM_COLOR_SWIZZLE3_RGB, 342 | // 343 | // SCE_GXM_COLOR_FORMAT_U2F10F10F10_ABGR = 344 | // SCE_GXM_COLOR_BASE_FORMAT_U2F10F10F10 | SCE_GXM_COLOR_SWIZZLE4_ABGR, 345 | // SCE_GXM_COLOR_FORMAT_U2F10F10F10_ARGB = 346 | // SCE_GXM_COLOR_BASE_FORMAT_U2F10F10F10 | SCE_GXM_COLOR_SWIZZLE4_ARGB, 347 | // SCE_GXM_COLOR_FORMAT_F10F10F10U2_RGBA = 348 | // SCE_GXM_COLOR_BASE_FORMAT_U2F10F10F10 | SCE_GXM_COLOR_SWIZZLE4_RGBA, 349 | // SCE_GXM_COLOR_FORMAT_F10F10F10U2_BGRA = 350 | // SCE_GXM_COLOR_BASE_FORMAT_U2F10F10F10 | SCE_GXM_COLOR_SWIZZLE4_BGRA, 351 | 352 | // Legacy formats 353 | // SCE_GXM_COLOR_FORMAT_A8B8G8R8 = SCE_GXM_COLOR_FORMAT_U8U8U8U8_ABGR, 354 | // SCE_GXM_COLOR_FORMAT_A8R8G8B8 = SCE_GXM_COLOR_FORMAT_U8U8U8U8_ARGB, 355 | // SCE_GXM_COLOR_FORMAT_R5G6B5 = SCE_GXM_COLOR_FORMAT_U5U6U5_RGB, 356 | // SCE_GXM_COLOR_FORMAT_A1R5G5B5 = SCE_GXM_COLOR_FORMAT_U1U5U5U5_ARGB, 357 | // SCE_GXM_COLOR_FORMAT_A4R4G4B4 = SCE_GXM_COLOR_FORMAT_U4U4U4U4_ARGB, 358 | // SCE_GXM_COLOR_FORMAT_A8 = SCE_GXM_COLOR_FORMAT_U8_A, 359 | } 360 | 361 | #[repr(u32)] 362 | pub enum SceGxmColorSurfaceType { 363 | SCE_GXM_COLOR_SURFACE_LINEAR = 0x00000000, 364 | SCE_GXM_COLOR_SURFACE_TILED = 0x04000000, 365 | SCE_GXM_COLOR_SURFACE_SWIZZLED = 0x08000000, 366 | } 367 | 368 | // typedef enum SceGxmColorSurfaceGammaMode { 369 | // SCE_GXM_COLOR_SURFACE_GAMMA_NONE = 0x00000000u, 370 | // SCE_GXM_COLOR_SURFACE_GAMMA_R = 0x00001000u, 371 | // SCE_GXM_COLOR_SURFACE_GAMMA_GR = 0x00003000u, 372 | // SCE_GXM_COLOR_SURFACE_GAMMA_BGR = 0x00001000u 373 | // } SceGxmColorSurfaceGammaMode; 374 | // 375 | // typedef enum SceGxmColorSurfaceDitherMode { 376 | // SCE_GXM_COLOR_SURFACE_DITHER_DISABLED = 0x00000000u, 377 | // SCE_GXM_COLOR_SURFACE_DITHER_ENABLED = 0x00000008u 378 | // } SceGxmColorSurfaceDitherMode; 379 | // 380 | // typedef enum SceGxmDepthStencilSurfaceType { 381 | // SCE_GXM_DEPTH_STENCIL_SURFACE_LINEAR = 0x00000000u, 382 | // SCE_GXM_DEPTH_STENCIL_SURFACE_TILED = 0x00011000u 383 | // } SceGxmDepthStencilSurfaceType; 384 | // 385 | // typedef enum SceGxmOutputRegisterFormat { 386 | // SCE_GXM_OUTPUT_REGISTER_FORMAT_DECLARED, 387 | // SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, 388 | // SCE_GXM_OUTPUT_REGISTER_FORMAT_CHAR4, 389 | // SCE_GXM_OUTPUT_REGISTER_FORMAT_USHORT2, 390 | // SCE_GXM_OUTPUT_REGISTER_FORMAT_SHORT2, 391 | // SCE_GXM_OUTPUT_REGISTER_FORMAT_HALF4, 392 | // SCE_GXM_OUTPUT_REGISTER_FORMAT_HALF2, 393 | // SCE_GXM_OUTPUT_REGISTER_FORMAT_FLOAT2, 394 | // SCE_GXM_OUTPUT_REGISTER_FORMAT_FLOAT 395 | // } SceGxmOutputRegisterFormat; 396 | // 397 | // typedef enum SceGxmMultisampleMode { 398 | // SCE_GXM_MULTISAMPLE_NONE, 399 | // SCE_GXM_MULTISAMPLE_2X, 400 | // SCE_GXM_MULTISAMPLE_4X 401 | // } SceGxmMultisampleMode; 402 | // 403 | // typedef enum SceGxmTextureSwizzle4Mode { 404 | // SCE_GXM_TEXTURE_SWIZZLE4_ABGR = 0x00000000u, 405 | // SCE_GXM_TEXTURE_SWIZZLE4_ARGB = 0x00001000u, 406 | // SCE_GXM_TEXTURE_SWIZZLE4_RGBA = 0x00002000u, 407 | // SCE_GXM_TEXTURE_SWIZZLE4_BGRA = 0x00003000u, 408 | // SCE_GXM_TEXTURE_SWIZZLE4_1BGR = 0x00004000u, 409 | // SCE_GXM_TEXTURE_SWIZZLE4_1RGB = 0x00005000u, 410 | // SCE_GXM_TEXTURE_SWIZZLE4_RGB1 = 0x00006000u, 411 | // SCE_GXM_TEXTURE_SWIZZLE4_BGR1 = 0x00007000u 412 | // } SceGxmTextureSwizzle4Mode; 413 | // 414 | // typedef enum SceGxmTextureSwizzle3Mode { 415 | // SCE_GXM_TEXTURE_SWIZZLE3_BGR = 0x00000000u, 416 | // SCE_GXM_TEXTURE_SWIZZLE3_RGB = 0x00001000u 417 | // } SceGxmTextureSwizzle3Mode; 418 | // 419 | // typedef enum SceGxmTextureSwizzle2Mode { 420 | // SCE_GXM_TEXTURE_SWIZZLE2_GR = 0x00000000u, 421 | // SCE_GXM_TEXTURE_SWIZZLE2_00GR = 0x00001000u, 422 | // SCE_GXM_TEXTURE_SWIZZLE2_GRRR = 0x00002000u, 423 | // SCE_GXM_TEXTURE_SWIZZLE2_RGGG = 0x00003000u, 424 | // SCE_GXM_TEXTURE_SWIZZLE2_GRGR = 0x00004000u, 425 | // SCE_GXM_TEXTURE_SWIZZLE2_00RG = 0x00005000u 426 | // } SceGxmTextureSwizzle2Mode; 427 | // 428 | // typedef enum SceGxmTextureSwizzle2ModeAlt { 429 | // SCE_GXM_TEXTURE_SWIZZLE2_SD = 0x00000000u, 430 | // SCE_GXM_TEXTURE_SWIZZLE2_DS = 0x00001000u 431 | // } SceGxmTextureSwizzle2ModeAlt; 432 | // 433 | // typedef enum SceGxmTextureSwizzle1Mode { 434 | // SCE_GXM_TEXTURE_SWIZZLE1_R = 0x00000000u, 435 | // SCE_GXM_TEXTURE_SWIZZLE1_000R = 0x00001000u, 436 | // SCE_GXM_TEXTURE_SWIZZLE1_111R = 0x00002000u, 437 | // SCE_GXM_TEXTURE_SWIZZLE1_RRRR = 0x00003000u, 438 | // SCE_GXM_TEXTURE_SWIZZLE1_0RRR = 0x00004000u, 439 | // SCE_GXM_TEXTURE_SWIZZLE1_1RRR = 0x00005000u, 440 | // SCE_GXM_TEXTURE_SWIZZLE1_R000 = 0x00006000u, 441 | // SCE_GXM_TEXTURE_SWIZZLE1_R111 = 0x00007000u 442 | // } SceGxmTextureSwizzle1Mode; 443 | // 444 | // typedef enum SceGxmTextureSwizzleYUV422Mode { 445 | // SCE_GXM_TEXTURE_SWIZZLE_YUYV_CSC0 = 0x00000000u, 446 | // SCE_GXM_TEXTURE_SWIZZLE_YVYU_CSC0 = 0x00001000u, 447 | // SCE_GXM_TEXTURE_SWIZZLE_UYVY_CSC0 = 0x00002000u, 448 | // SCE_GXM_TEXTURE_SWIZZLE_VYUY_CSC0 = 0x00003000u, 449 | // SCE_GXM_TEXTURE_SWIZZLE_YUYV_CSC1 = 0x00004000u, 450 | // SCE_GXM_TEXTURE_SWIZZLE_YVYU_CSC1 = 0x00005000u, 451 | // SCE_GXM_TEXTURE_SWIZZLE_UYVY_CSC1 = 0x00006000u, 452 | // SCE_GXM_TEXTURE_SWIZZLE_VYUY_CSC1 = 0x00007000u 453 | // } SceGxmTextureSwizzleYUV422Mode; 454 | // 455 | // typedef enum SceGxmTextureSwizzleYUV420Mode { 456 | // SCE_GXM_TEXTURE_SWIZZLE_YUV_CSC0 = 0x00000000u, 457 | // SCE_GXM_TEXTURE_SWIZZLE_YVU_CSC0 = 0x00001000u, 458 | // SCE_GXM_TEXTURE_SWIZZLE_YUV_CSC1 = 0x00002000u, 459 | // SCE_GXM_TEXTURE_SWIZZLE_YVU_CSC1 = 0x00003000u 460 | // } SceGxmTextureSwizzleYUV420Mode; 461 | // 462 | // typedef enum SceGxmTextureBaseFormat { 463 | // SCE_GXM_TEXTURE_BASE_FORMAT_U8 = 0x00000000, 464 | // SCE_GXM_TEXTURE_BASE_FORMAT_S8 = 0x01000000, 465 | // SCE_GXM_TEXTURE_BASE_FORMAT_U4U4U4U4 = 0x02000000, 466 | // SCE_GXM_TEXTURE_BASE_FORMAT_U8U3U3U2 = 0x03000000, 467 | // SCE_GXM_TEXTURE_BASE_FORMAT_U1U5U5U5 = 0x04000000, 468 | // SCE_GXM_TEXTURE_BASE_FORMAT_U5U6U5 = 0x05000000, 469 | // SCE_GXM_TEXTURE_BASE_FORMAT_S5S5U6 = 0x06000000, 470 | // SCE_GXM_TEXTURE_BASE_FORMAT_U8U8 = 0x07000000, 471 | // SCE_GXM_TEXTURE_BASE_FORMAT_S8S8 = 0x08000000, 472 | // SCE_GXM_TEXTURE_BASE_FORMAT_U16 = 0x09000000, 473 | // SCE_GXM_TEXTURE_BASE_FORMAT_S16 = 0x0A000000, 474 | // SCE_GXM_TEXTURE_BASE_FORMAT_F16 = 0x0B000000, 475 | // SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8U8 = 0x0C000000, 476 | // SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8S8 = 0x0D000000, 477 | // SCE_GXM_TEXTURE_BASE_FORMAT_U2U10U10U10 = 0x0E000000, 478 | // SCE_GXM_TEXTURE_BASE_FORMAT_U16U16 = 0x0F000000, 479 | // SCE_GXM_TEXTURE_BASE_FORMAT_S16S16 = 0x10000000, 480 | // SCE_GXM_TEXTURE_BASE_FORMAT_F16F16 = 0x11000000, 481 | // SCE_GXM_TEXTURE_BASE_FORMAT_F32 = 0x12000000, 482 | // SCE_GXM_TEXTURE_BASE_FORMAT_F32M = 0x13000000, 483 | // SCE_GXM_TEXTURE_BASE_FORMAT_X8S8S8U8 = 0x14000000, 484 | // SCE_GXM_TEXTURE_BASE_FORMAT_X8U24 = 0x15000000, 485 | // SCE_GXM_TEXTURE_BASE_FORMAT_U32 = 0x17000000, 486 | // SCE_GXM_TEXTURE_BASE_FORMAT_S32 = 0x18000000, 487 | // SCE_GXM_TEXTURE_BASE_FORMAT_SE5M9M9M9 = 0x19000000, 488 | // SCE_GXM_TEXTURE_BASE_FORMAT_F11F11F10 = 0x1A000000, 489 | // SCE_GXM_TEXTURE_BASE_FORMAT_F16F16F16F16 = 0x1B000000, 490 | // SCE_GXM_TEXTURE_BASE_FORMAT_U16U16U16U16 = 0x1C000000, 491 | // SCE_GXM_TEXTURE_BASE_FORMAT_S16S16S16S16 = 0x1D000000, 492 | // SCE_GXM_TEXTURE_BASE_FORMAT_F32F32 = 0x1E000000, 493 | // SCE_GXM_TEXTURE_BASE_FORMAT_U32U32 = 0x1F000000, 494 | // SCE_GXM_TEXTURE_BASE_FORMAT_PVRT2BPP = 0x80000000, 495 | // SCE_GXM_TEXTURE_BASE_FORMAT_PVRT4BPP = 0x81000000, 496 | // SCE_GXM_TEXTURE_BASE_FORMAT_PVRTII2BPP = 0x82000000, 497 | // SCE_GXM_TEXTURE_BASE_FORMAT_PVRTII4BPP = 0x83000000, 498 | // SCE_GXM_TEXTURE_BASE_FORMAT_UBC1 = 0x85000000, 499 | // SCE_GXM_TEXTURE_BASE_FORMAT_UBC2 = 0x86000000, 500 | // SCE_GXM_TEXTURE_BASE_FORMAT_UBC3 = 0x87000000, 501 | // SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P2 = 0x90000000, 502 | // SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P3 = 0x91000000, 503 | // SCE_GXM_TEXTURE_BASE_FORMAT_YUV422 = 0x92000000, 504 | // SCE_GXM_TEXTURE_BASE_FORMAT_P4 = 0x94000000, 505 | // SCE_GXM_TEXTURE_BASE_FORMAT_P8 = 0x95000000, 506 | // SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8 = 0x98000000, 507 | // SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8 = 0x99000000, 508 | // SCE_GXM_TEXTURE_BASE_FORMAT_U2F10F10F10 = 0x9A000000 509 | // } SceGxmTextureBaseFormat; 510 | // 511 | // typedef enum SceGxmTextureFormat { 512 | // // Supported formats 513 | // 514 | // SCE_GXM_TEXTURE_FORMAT_U8_000R = SCE_GXM_TEXTURE_BASE_FORMAT_U8 | SCE_GXM_TEXTURE_SWIZZLE1_000R, 515 | // SCE_GXM_TEXTURE_FORMAT_U8_111R = SCE_GXM_TEXTURE_BASE_FORMAT_U8 | SCE_GXM_TEXTURE_SWIZZLE1_111R, 516 | // SCE_GXM_TEXTURE_FORMAT_U8_RRRR = SCE_GXM_TEXTURE_BASE_FORMAT_U8 | SCE_GXM_TEXTURE_SWIZZLE1_RRRR, 517 | // SCE_GXM_TEXTURE_FORMAT_U8_0RRR = SCE_GXM_TEXTURE_BASE_FORMAT_U8 | SCE_GXM_TEXTURE_SWIZZLE1_0RRR, 518 | // SCE_GXM_TEXTURE_FORMAT_U8_1RRR = SCE_GXM_TEXTURE_BASE_FORMAT_U8 | SCE_GXM_TEXTURE_SWIZZLE1_1RRR, 519 | // SCE_GXM_TEXTURE_FORMAT_U8_R000 = SCE_GXM_TEXTURE_BASE_FORMAT_U8 | SCE_GXM_TEXTURE_SWIZZLE1_R000, 520 | // SCE_GXM_TEXTURE_FORMAT_U8_R111 = SCE_GXM_TEXTURE_BASE_FORMAT_U8 | SCE_GXM_TEXTURE_SWIZZLE1_R111, 521 | // SCE_GXM_TEXTURE_FORMAT_U8_R = SCE_GXM_TEXTURE_BASE_FORMAT_U8 | SCE_GXM_TEXTURE_SWIZZLE1_R, 522 | // 523 | // SCE_GXM_TEXTURE_FORMAT_S8_000R = SCE_GXM_TEXTURE_BASE_FORMAT_S8 | SCE_GXM_TEXTURE_SWIZZLE1_000R, 524 | // SCE_GXM_TEXTURE_FORMAT_S8_111R = SCE_GXM_TEXTURE_BASE_FORMAT_S8 | SCE_GXM_TEXTURE_SWIZZLE1_111R, 525 | // SCE_GXM_TEXTURE_FORMAT_S8_RRRR = SCE_GXM_TEXTURE_BASE_FORMAT_S8 | SCE_GXM_TEXTURE_SWIZZLE1_RRRR, 526 | // SCE_GXM_TEXTURE_FORMAT_S8_0RRR = SCE_GXM_TEXTURE_BASE_FORMAT_S8 | SCE_GXM_TEXTURE_SWIZZLE1_0RRR, 527 | // SCE_GXM_TEXTURE_FORMAT_S8_1RRR = SCE_GXM_TEXTURE_BASE_FORMAT_S8 | SCE_GXM_TEXTURE_SWIZZLE1_1RRR, 528 | // SCE_GXM_TEXTURE_FORMAT_S8_R000 = SCE_GXM_TEXTURE_BASE_FORMAT_S8 | SCE_GXM_TEXTURE_SWIZZLE1_R000, 529 | // SCE_GXM_TEXTURE_FORMAT_S8_R111 = SCE_GXM_TEXTURE_BASE_FORMAT_S8 | SCE_GXM_TEXTURE_SWIZZLE1_R111, 530 | // SCE_GXM_TEXTURE_FORMAT_S8_R = SCE_GXM_TEXTURE_BASE_FORMAT_S8 | SCE_GXM_TEXTURE_SWIZZLE1_R, 531 | // 532 | // SCE_GXM_TEXTURE_FORMAT_U4U4U4U4_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_U4U4U4U4 | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 533 | // SCE_GXM_TEXTURE_FORMAT_U4U4U4U4_ARGB = SCE_GXM_TEXTURE_BASE_FORMAT_U4U4U4U4 | SCE_GXM_TEXTURE_SWIZZLE4_ARGB, 534 | // SCE_GXM_TEXTURE_FORMAT_U4U4U4U4_RGBA = SCE_GXM_TEXTURE_BASE_FORMAT_U4U4U4U4 | SCE_GXM_TEXTURE_SWIZZLE4_RGBA, 535 | // SCE_GXM_TEXTURE_FORMAT_U4U4U4U4_BGRA = SCE_GXM_TEXTURE_BASE_FORMAT_U4U4U4U4 | SCE_GXM_TEXTURE_SWIZZLE4_BGRA, 536 | // SCE_GXM_TEXTURE_FORMAT_X4U4U4U4_1BGR = SCE_GXM_TEXTURE_BASE_FORMAT_U4U4U4U4 | SCE_GXM_TEXTURE_SWIZZLE4_1BGR, 537 | // SCE_GXM_TEXTURE_FORMAT_X4U4U4U4_1RGB = SCE_GXM_TEXTURE_BASE_FORMAT_U4U4U4U4 | SCE_GXM_TEXTURE_SWIZZLE4_1RGB, 538 | // SCE_GXM_TEXTURE_FORMAT_U4U4U4X4_RGB1 = SCE_GXM_TEXTURE_BASE_FORMAT_U4U4U4U4 | SCE_GXM_TEXTURE_SWIZZLE4_RGB1, 539 | // SCE_GXM_TEXTURE_FORMAT_U4U4U4X4_BGR1 = SCE_GXM_TEXTURE_BASE_FORMAT_U4U4U4U4 | SCE_GXM_TEXTURE_SWIZZLE4_BGR1, 540 | // 541 | // SCE_GXM_TEXTURE_FORMAT_U8U3U3U2_ARGB = SCE_GXM_TEXTURE_BASE_FORMAT_U8U3U3U2, 542 | // 543 | // SCE_GXM_TEXTURE_FORMAT_U1U5U5U5_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_U1U5U5U5 | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 544 | // SCE_GXM_TEXTURE_FORMAT_U1U5U5U5_ARGB = SCE_GXM_TEXTURE_BASE_FORMAT_U1U5U5U5 | SCE_GXM_TEXTURE_SWIZZLE4_ARGB, 545 | // SCE_GXM_TEXTURE_FORMAT_U5U5U5U1_RGBA = SCE_GXM_TEXTURE_BASE_FORMAT_U1U5U5U5 | SCE_GXM_TEXTURE_SWIZZLE4_RGBA, 546 | // SCE_GXM_TEXTURE_FORMAT_U5U5U5U1_BGRA = SCE_GXM_TEXTURE_BASE_FORMAT_U1U5U5U5 | SCE_GXM_TEXTURE_SWIZZLE4_BGRA, 547 | // SCE_GXM_TEXTURE_FORMAT_X1U5U5U5_1BGR = SCE_GXM_TEXTURE_BASE_FORMAT_U1U5U5U5 | SCE_GXM_TEXTURE_SWIZZLE4_1BGR, 548 | // SCE_GXM_TEXTURE_FORMAT_X1U5U5U5_1RGB = SCE_GXM_TEXTURE_BASE_FORMAT_U1U5U5U5 | SCE_GXM_TEXTURE_SWIZZLE4_1RGB, 549 | // SCE_GXM_TEXTURE_FORMAT_U5U5U5X1_RGB1 = SCE_GXM_TEXTURE_BASE_FORMAT_U1U5U5U5 | SCE_GXM_TEXTURE_SWIZZLE4_RGB1, 550 | // SCE_GXM_TEXTURE_FORMAT_U5U5U5X1_BGR1 = SCE_GXM_TEXTURE_BASE_FORMAT_U1U5U5U5 | SCE_GXM_TEXTURE_SWIZZLE4_BGR1, 551 | // 552 | // SCE_GXM_TEXTURE_FORMAT_U5U6U5_BGR = SCE_GXM_TEXTURE_BASE_FORMAT_U5U6U5 | SCE_GXM_TEXTURE_SWIZZLE3_BGR, 553 | // SCE_GXM_TEXTURE_FORMAT_U5U6U5_RGB = SCE_GXM_TEXTURE_BASE_FORMAT_U5U6U5 | SCE_GXM_TEXTURE_SWIZZLE3_RGB, 554 | // 555 | // SCE_GXM_TEXTURE_FORMAT_U6S5S5_BGR = SCE_GXM_TEXTURE_BASE_FORMAT_S5S5U6 | SCE_GXM_TEXTURE_SWIZZLE3_BGR, 556 | // SCE_GXM_TEXTURE_FORMAT_S5S5U6_RGB = SCE_GXM_TEXTURE_BASE_FORMAT_S5S5U6 | SCE_GXM_TEXTURE_SWIZZLE3_RGB, 557 | // 558 | // SCE_GXM_TEXTURE_FORMAT_U8U8_00GR = SCE_GXM_TEXTURE_BASE_FORMAT_U8U8 | SCE_GXM_TEXTURE_SWIZZLE2_00GR, 559 | // SCE_GXM_TEXTURE_FORMAT_U8U8_GRRR = SCE_GXM_TEXTURE_BASE_FORMAT_U8U8 | SCE_GXM_TEXTURE_SWIZZLE2_GRRR, 560 | // SCE_GXM_TEXTURE_FORMAT_U8U8_RGGG = SCE_GXM_TEXTURE_BASE_FORMAT_U8U8 | SCE_GXM_TEXTURE_SWIZZLE2_RGGG, 561 | // SCE_GXM_TEXTURE_FORMAT_U8U8_GRGR = SCE_GXM_TEXTURE_BASE_FORMAT_U8U8 | SCE_GXM_TEXTURE_SWIZZLE2_GRGR, 562 | // SCE_GXM_TEXTURE_FORMAT_U8U8_00RG = SCE_GXM_TEXTURE_BASE_FORMAT_U8U8 | SCE_GXM_TEXTURE_SWIZZLE2_00RG, 563 | // SCE_GXM_TEXTURE_FORMAT_U8U8_GR = SCE_GXM_TEXTURE_BASE_FORMAT_U8U8 | SCE_GXM_TEXTURE_SWIZZLE2_GR, 564 | // 565 | // SCE_GXM_TEXTURE_FORMAT_S8S8_00GR = SCE_GXM_TEXTURE_BASE_FORMAT_S8S8 | SCE_GXM_TEXTURE_SWIZZLE2_00GR, 566 | // SCE_GXM_TEXTURE_FORMAT_S8S8_GRRR = SCE_GXM_TEXTURE_BASE_FORMAT_S8S8 | SCE_GXM_TEXTURE_SWIZZLE2_GRRR, 567 | // SCE_GXM_TEXTURE_FORMAT_S8S8_RGGG = SCE_GXM_TEXTURE_BASE_FORMAT_S8S8 | SCE_GXM_TEXTURE_SWIZZLE2_RGGG, 568 | // SCE_GXM_TEXTURE_FORMAT_S8S8_GRGR = SCE_GXM_TEXTURE_BASE_FORMAT_S8S8 | SCE_GXM_TEXTURE_SWIZZLE2_GRGR, 569 | // SCE_GXM_TEXTURE_FORMAT_S8S8_00RG = SCE_GXM_TEXTURE_BASE_FORMAT_S8S8 | SCE_GXM_TEXTURE_SWIZZLE2_00RG, 570 | // SCE_GXM_TEXTURE_FORMAT_S8S8_GR = SCE_GXM_TEXTURE_BASE_FORMAT_S8S8 | SCE_GXM_TEXTURE_SWIZZLE2_GR, 571 | // 572 | // SCE_GXM_TEXTURE_FORMAT_U16_000R = SCE_GXM_TEXTURE_BASE_FORMAT_U16 | SCE_GXM_TEXTURE_SWIZZLE1_000R, 573 | // SCE_GXM_TEXTURE_FORMAT_U16_111R = SCE_GXM_TEXTURE_BASE_FORMAT_U16 | SCE_GXM_TEXTURE_SWIZZLE1_111R, 574 | // SCE_GXM_TEXTURE_FORMAT_U16_RRRR = SCE_GXM_TEXTURE_BASE_FORMAT_U16 | SCE_GXM_TEXTURE_SWIZZLE1_RRRR, 575 | // SCE_GXM_TEXTURE_FORMAT_U16_0RRR = SCE_GXM_TEXTURE_BASE_FORMAT_U16 | SCE_GXM_TEXTURE_SWIZZLE1_0RRR, 576 | // SCE_GXM_TEXTURE_FORMAT_U16_1RRR = SCE_GXM_TEXTURE_BASE_FORMAT_U16 | SCE_GXM_TEXTURE_SWIZZLE1_1RRR, 577 | // SCE_GXM_TEXTURE_FORMAT_U16_R000 = SCE_GXM_TEXTURE_BASE_FORMAT_U16 | SCE_GXM_TEXTURE_SWIZZLE1_R000, 578 | // SCE_GXM_TEXTURE_FORMAT_U16_R111 = SCE_GXM_TEXTURE_BASE_FORMAT_U16 | SCE_GXM_TEXTURE_SWIZZLE1_R111, 579 | // SCE_GXM_TEXTURE_FORMAT_U16_R = SCE_GXM_TEXTURE_BASE_FORMAT_U16 | SCE_GXM_TEXTURE_SWIZZLE1_R, 580 | // 581 | // SCE_GXM_TEXTURE_FORMAT_S16_000R = SCE_GXM_TEXTURE_BASE_FORMAT_S16 | SCE_GXM_TEXTURE_SWIZZLE1_000R, 582 | // SCE_GXM_TEXTURE_FORMAT_S16_111R = SCE_GXM_TEXTURE_BASE_FORMAT_S16 | SCE_GXM_TEXTURE_SWIZZLE1_111R, 583 | // SCE_GXM_TEXTURE_FORMAT_S16_RRRR = SCE_GXM_TEXTURE_BASE_FORMAT_S16 | SCE_GXM_TEXTURE_SWIZZLE1_RRRR, 584 | // SCE_GXM_TEXTURE_FORMAT_S16_0RRR = SCE_GXM_TEXTURE_BASE_FORMAT_S16 | SCE_GXM_TEXTURE_SWIZZLE1_0RRR, 585 | // SCE_GXM_TEXTURE_FORMAT_S16_1RRR = SCE_GXM_TEXTURE_BASE_FORMAT_S16 | SCE_GXM_TEXTURE_SWIZZLE1_1RRR, 586 | // SCE_GXM_TEXTURE_FORMAT_S16_R000 = SCE_GXM_TEXTURE_BASE_FORMAT_S16 | SCE_GXM_TEXTURE_SWIZZLE1_R000, 587 | // SCE_GXM_TEXTURE_FORMAT_S16_R111 = SCE_GXM_TEXTURE_BASE_FORMAT_S16 | SCE_GXM_TEXTURE_SWIZZLE1_R111, 588 | // SCE_GXM_TEXTURE_FORMAT_S16_R = SCE_GXM_TEXTURE_BASE_FORMAT_S16 | SCE_GXM_TEXTURE_SWIZZLE1_R, 589 | // 590 | // SCE_GXM_TEXTURE_FORMAT_F16_000R = SCE_GXM_TEXTURE_BASE_FORMAT_F16 | SCE_GXM_TEXTURE_SWIZZLE1_000R, 591 | // SCE_GXM_TEXTURE_FORMAT_F16_111R = SCE_GXM_TEXTURE_BASE_FORMAT_F16 | SCE_GXM_TEXTURE_SWIZZLE1_111R, 592 | // SCE_GXM_TEXTURE_FORMAT_F16_RRRR = SCE_GXM_TEXTURE_BASE_FORMAT_F16 | SCE_GXM_TEXTURE_SWIZZLE1_RRRR, 593 | // SCE_GXM_TEXTURE_FORMAT_F16_0RRR = SCE_GXM_TEXTURE_BASE_FORMAT_F16 | SCE_GXM_TEXTURE_SWIZZLE1_0RRR, 594 | // SCE_GXM_TEXTURE_FORMAT_F16_1RRR = SCE_GXM_TEXTURE_BASE_FORMAT_F16 | SCE_GXM_TEXTURE_SWIZZLE1_1RRR, 595 | // SCE_GXM_TEXTURE_FORMAT_F16_R000 = SCE_GXM_TEXTURE_BASE_FORMAT_F16 | SCE_GXM_TEXTURE_SWIZZLE1_R000, 596 | // SCE_GXM_TEXTURE_FORMAT_F16_R111 = SCE_GXM_TEXTURE_BASE_FORMAT_F16 | SCE_GXM_TEXTURE_SWIZZLE1_R111, 597 | // SCE_GXM_TEXTURE_FORMAT_F16_R = SCE_GXM_TEXTURE_BASE_FORMAT_F16 | SCE_GXM_TEXTURE_SWIZZLE1_R, 598 | // 599 | // SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8U8 | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 600 | // SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ARGB = SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8U8 | SCE_GXM_TEXTURE_SWIZZLE4_ARGB, 601 | // SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_RGBA = SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8U8 | SCE_GXM_TEXTURE_SWIZZLE4_RGBA, 602 | // SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_BGRA = SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8U8 | SCE_GXM_TEXTURE_SWIZZLE4_BGRA, 603 | // SCE_GXM_TEXTURE_FORMAT_X8U8U8U8_1BGR = SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8U8 | SCE_GXM_TEXTURE_SWIZZLE4_1BGR, 604 | // SCE_GXM_TEXTURE_FORMAT_X8U8U8U8_1RGB = SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8U8 | SCE_GXM_TEXTURE_SWIZZLE4_1RGB, 605 | // SCE_GXM_TEXTURE_FORMAT_U8U8U8X8_RGB1 = SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8U8 | SCE_GXM_TEXTURE_SWIZZLE4_RGB1, 606 | // SCE_GXM_TEXTURE_FORMAT_U8U8U8X8_BGR1 = SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8U8 | SCE_GXM_TEXTURE_SWIZZLE4_BGR1, 607 | // 608 | // SCE_GXM_TEXTURE_FORMAT_S8S8S8S8_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8S8 | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 609 | // SCE_GXM_TEXTURE_FORMAT_S8S8S8S8_ARGB = SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8S8 | SCE_GXM_TEXTURE_SWIZZLE4_ARGB, 610 | // SCE_GXM_TEXTURE_FORMAT_S8S8S8S8_RGBA = SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8S8 | SCE_GXM_TEXTURE_SWIZZLE4_RGBA, 611 | // SCE_GXM_TEXTURE_FORMAT_S8S8S8S8_BGRA = SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8S8 | SCE_GXM_TEXTURE_SWIZZLE4_BGRA, 612 | // SCE_GXM_TEXTURE_FORMAT_X8S8S8S8_1BGR = SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8S8 | SCE_GXM_TEXTURE_SWIZZLE4_1BGR, 613 | // SCE_GXM_TEXTURE_FORMAT_X8S8S8S8_1RGB = SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8S8 | SCE_GXM_TEXTURE_SWIZZLE4_1RGB, 614 | // SCE_GXM_TEXTURE_FORMAT_S8S8S8X8_RGB1 = SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8S8 | SCE_GXM_TEXTURE_SWIZZLE4_RGB1, 615 | // SCE_GXM_TEXTURE_FORMAT_S8S8S8X8_BGR1 = SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8S8 | SCE_GXM_TEXTURE_SWIZZLE4_BGR1, 616 | // 617 | // SCE_GXM_TEXTURE_FORMAT_U2U10U10U10_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_U2U10U10U10 | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 618 | // SCE_GXM_TEXTURE_FORMAT_U2U10U10U10_ARGB = SCE_GXM_TEXTURE_BASE_FORMAT_U2U10U10U10 | SCE_GXM_TEXTURE_SWIZZLE4_ARGB, 619 | // SCE_GXM_TEXTURE_FORMAT_U10U10U10U2_RGBA = SCE_GXM_TEXTURE_BASE_FORMAT_U2U10U10U10 | SCE_GXM_TEXTURE_SWIZZLE4_RGBA, 620 | // SCE_GXM_TEXTURE_FORMAT_U10U10U10U2_BGRA = SCE_GXM_TEXTURE_BASE_FORMAT_U2U10U10U10 | SCE_GXM_TEXTURE_SWIZZLE4_BGRA, 621 | // SCE_GXM_TEXTURE_FORMAT_X2U10U10U10_1BGR = SCE_GXM_TEXTURE_BASE_FORMAT_U2U10U10U10 | SCE_GXM_TEXTURE_SWIZZLE4_1BGR, 622 | // SCE_GXM_TEXTURE_FORMAT_X2U10U10U10_1RGB = SCE_GXM_TEXTURE_BASE_FORMAT_U2U10U10U10 | SCE_GXM_TEXTURE_SWIZZLE4_1RGB, 623 | // SCE_GXM_TEXTURE_FORMAT_U10U10U10X2_RGB1 = SCE_GXM_TEXTURE_BASE_FORMAT_U2U10U10U10 | SCE_GXM_TEXTURE_SWIZZLE4_RGB1, 624 | // SCE_GXM_TEXTURE_FORMAT_U10U10U10X2_BGR1 = SCE_GXM_TEXTURE_BASE_FORMAT_U2U10U10U10 | SCE_GXM_TEXTURE_SWIZZLE4_BGR1, 625 | // 626 | // SCE_GXM_TEXTURE_FORMAT_U16U16_00GR = SCE_GXM_TEXTURE_BASE_FORMAT_U16U16 | SCE_GXM_TEXTURE_SWIZZLE2_00GR, 627 | // SCE_GXM_TEXTURE_FORMAT_U16U16_GRRR = SCE_GXM_TEXTURE_BASE_FORMAT_U16U16 | SCE_GXM_TEXTURE_SWIZZLE2_GRRR, 628 | // SCE_GXM_TEXTURE_FORMAT_U16U16_RGGG = SCE_GXM_TEXTURE_BASE_FORMAT_U16U16 | SCE_GXM_TEXTURE_SWIZZLE2_RGGG, 629 | // SCE_GXM_TEXTURE_FORMAT_U16U16_GRGR = SCE_GXM_TEXTURE_BASE_FORMAT_U16U16 | SCE_GXM_TEXTURE_SWIZZLE2_GRGR, 630 | // SCE_GXM_TEXTURE_FORMAT_U16U16_00RG = SCE_GXM_TEXTURE_BASE_FORMAT_U16U16 | SCE_GXM_TEXTURE_SWIZZLE2_00RG, 631 | // SCE_GXM_TEXTURE_FORMAT_U16U16_GR = SCE_GXM_TEXTURE_BASE_FORMAT_U16U16 | SCE_GXM_TEXTURE_SWIZZLE2_GR, 632 | // 633 | // SCE_GXM_TEXTURE_FORMAT_S16S16_00GR = SCE_GXM_TEXTURE_BASE_FORMAT_S16S16 | SCE_GXM_TEXTURE_SWIZZLE2_00GR, 634 | // SCE_GXM_TEXTURE_FORMAT_S16S16_GRRR = SCE_GXM_TEXTURE_BASE_FORMAT_S16S16 | SCE_GXM_TEXTURE_SWIZZLE2_GRRR, 635 | // SCE_GXM_TEXTURE_FORMAT_S16S16_RGGG = SCE_GXM_TEXTURE_BASE_FORMAT_S16S16 | SCE_GXM_TEXTURE_SWIZZLE2_RGGG, 636 | // SCE_GXM_TEXTURE_FORMAT_S16S16_GRGR = SCE_GXM_TEXTURE_BASE_FORMAT_S16S16 | SCE_GXM_TEXTURE_SWIZZLE2_GRGR, 637 | // SCE_GXM_TEXTURE_FORMAT_S16S16_00RG = SCE_GXM_TEXTURE_BASE_FORMAT_S16S16 | SCE_GXM_TEXTURE_SWIZZLE2_00RG, 638 | // SCE_GXM_TEXTURE_FORMAT_S16S16_GR = SCE_GXM_TEXTURE_BASE_FORMAT_S16S16 | SCE_GXM_TEXTURE_SWIZZLE2_GR, 639 | // 640 | // SCE_GXM_TEXTURE_FORMAT_F16F16_00GR = SCE_GXM_TEXTURE_BASE_FORMAT_F16F16 | SCE_GXM_TEXTURE_SWIZZLE2_00GR, 641 | // SCE_GXM_TEXTURE_FORMAT_F16F16_GRRR = SCE_GXM_TEXTURE_BASE_FORMAT_F16F16 | SCE_GXM_TEXTURE_SWIZZLE2_GRRR, 642 | // SCE_GXM_TEXTURE_FORMAT_F16F16_RGGG = SCE_GXM_TEXTURE_BASE_FORMAT_F16F16 | SCE_GXM_TEXTURE_SWIZZLE2_RGGG, 643 | // SCE_GXM_TEXTURE_FORMAT_F16F16_GRGR = SCE_GXM_TEXTURE_BASE_FORMAT_F16F16 | SCE_GXM_TEXTURE_SWIZZLE2_GRGR, 644 | // SCE_GXM_TEXTURE_FORMAT_F16F16_00RG = SCE_GXM_TEXTURE_BASE_FORMAT_F16F16 | SCE_GXM_TEXTURE_SWIZZLE2_00RG, 645 | // SCE_GXM_TEXTURE_FORMAT_F16F16_GR = SCE_GXM_TEXTURE_BASE_FORMAT_F16F16 | SCE_GXM_TEXTURE_SWIZZLE2_GR, 646 | // 647 | // SCE_GXM_TEXTURE_FORMAT_F32_000R = SCE_GXM_TEXTURE_BASE_FORMAT_F32 | SCE_GXM_TEXTURE_SWIZZLE1_000R, 648 | // SCE_GXM_TEXTURE_FORMAT_F32_111R = SCE_GXM_TEXTURE_BASE_FORMAT_F32 | SCE_GXM_TEXTURE_SWIZZLE1_111R, 649 | // SCE_GXM_TEXTURE_FORMAT_F32_RRRR = SCE_GXM_TEXTURE_BASE_FORMAT_F32 | SCE_GXM_TEXTURE_SWIZZLE1_RRRR, 650 | // SCE_GXM_TEXTURE_FORMAT_F32_0RRR = SCE_GXM_TEXTURE_BASE_FORMAT_F32 | SCE_GXM_TEXTURE_SWIZZLE1_0RRR, 651 | // SCE_GXM_TEXTURE_FORMAT_F32_1RRR = SCE_GXM_TEXTURE_BASE_FORMAT_F32 | SCE_GXM_TEXTURE_SWIZZLE1_1RRR, 652 | // SCE_GXM_TEXTURE_FORMAT_F32_R000 = SCE_GXM_TEXTURE_BASE_FORMAT_F32 | SCE_GXM_TEXTURE_SWIZZLE1_R000, 653 | // SCE_GXM_TEXTURE_FORMAT_F32_R111 = SCE_GXM_TEXTURE_BASE_FORMAT_F32 | SCE_GXM_TEXTURE_SWIZZLE1_R111, 654 | // SCE_GXM_TEXTURE_FORMAT_F32_R = SCE_GXM_TEXTURE_BASE_FORMAT_F32 | SCE_GXM_TEXTURE_SWIZZLE1_R, 655 | // 656 | // SCE_GXM_TEXTURE_FORMAT_F32M_000R = SCE_GXM_TEXTURE_BASE_FORMAT_F32M | SCE_GXM_TEXTURE_SWIZZLE1_000R, 657 | // SCE_GXM_TEXTURE_FORMAT_F32M_111R = SCE_GXM_TEXTURE_BASE_FORMAT_F32M | SCE_GXM_TEXTURE_SWIZZLE1_111R, 658 | // SCE_GXM_TEXTURE_FORMAT_F32M_RRRR = SCE_GXM_TEXTURE_BASE_FORMAT_F32M | SCE_GXM_TEXTURE_SWIZZLE1_RRRR, 659 | // SCE_GXM_TEXTURE_FORMAT_F32M_0RRR = SCE_GXM_TEXTURE_BASE_FORMAT_F32M | SCE_GXM_TEXTURE_SWIZZLE1_0RRR, 660 | // SCE_GXM_TEXTURE_FORMAT_F32M_1RRR = SCE_GXM_TEXTURE_BASE_FORMAT_F32M | SCE_GXM_TEXTURE_SWIZZLE1_1RRR, 661 | // SCE_GXM_TEXTURE_FORMAT_F32M_R000 = SCE_GXM_TEXTURE_BASE_FORMAT_F32M | SCE_GXM_TEXTURE_SWIZZLE1_R000, 662 | // SCE_GXM_TEXTURE_FORMAT_F32M_R111 = SCE_GXM_TEXTURE_BASE_FORMAT_F32M | SCE_GXM_TEXTURE_SWIZZLE1_R111, 663 | // SCE_GXM_TEXTURE_FORMAT_F32M_R = SCE_GXM_TEXTURE_BASE_FORMAT_F32M | SCE_GXM_TEXTURE_SWIZZLE1_R, 664 | // 665 | // SCE_GXM_TEXTURE_FORMAT_X8S8S8U8_1BGR = SCE_GXM_TEXTURE_BASE_FORMAT_X8S8S8U8 | SCE_GXM_TEXTURE_SWIZZLE3_BGR, 666 | // SCE_GXM_TEXTURE_FORMAT_X8U8S8S8_1RGB = SCE_GXM_TEXTURE_BASE_FORMAT_X8S8S8U8 | SCE_GXM_TEXTURE_SWIZZLE3_RGB, 667 | // 668 | // SCE_GXM_TEXTURE_FORMAT_X8U24_SD = SCE_GXM_TEXTURE_BASE_FORMAT_X8U24 | SCE_GXM_TEXTURE_SWIZZLE2_SD, 669 | // SCE_GXM_TEXTURE_FORMAT_U24X8_DS = SCE_GXM_TEXTURE_BASE_FORMAT_X8U24 | SCE_GXM_TEXTURE_SWIZZLE2_DS, 670 | // 671 | // SCE_GXM_TEXTURE_FORMAT_U32_000R = SCE_GXM_TEXTURE_BASE_FORMAT_U32 | SCE_GXM_TEXTURE_SWIZZLE1_000R, 672 | // SCE_GXM_TEXTURE_FORMAT_U32_111R = SCE_GXM_TEXTURE_BASE_FORMAT_U32 | SCE_GXM_TEXTURE_SWIZZLE1_111R, 673 | // SCE_GXM_TEXTURE_FORMAT_U32_RRRR = SCE_GXM_TEXTURE_BASE_FORMAT_U32 | SCE_GXM_TEXTURE_SWIZZLE1_RRRR, 674 | // SCE_GXM_TEXTURE_FORMAT_U32_0RRR = SCE_GXM_TEXTURE_BASE_FORMAT_U32 | SCE_GXM_TEXTURE_SWIZZLE1_0RRR, 675 | // SCE_GXM_TEXTURE_FORMAT_U32_1RRR = SCE_GXM_TEXTURE_BASE_FORMAT_U32 | SCE_GXM_TEXTURE_SWIZZLE1_1RRR, 676 | // SCE_GXM_TEXTURE_FORMAT_U32_R000 = SCE_GXM_TEXTURE_BASE_FORMAT_U32 | SCE_GXM_TEXTURE_SWIZZLE1_R000, 677 | // SCE_GXM_TEXTURE_FORMAT_U32_R111 = SCE_GXM_TEXTURE_BASE_FORMAT_U32 | SCE_GXM_TEXTURE_SWIZZLE1_R111, 678 | // SCE_GXM_TEXTURE_FORMAT_U32_R = SCE_GXM_TEXTURE_BASE_FORMAT_U32 | SCE_GXM_TEXTURE_SWIZZLE1_R, 679 | // 680 | // SCE_GXM_TEXTURE_FORMAT_S32_000R = SCE_GXM_TEXTURE_BASE_FORMAT_S32 | SCE_GXM_TEXTURE_SWIZZLE1_000R, 681 | // SCE_GXM_TEXTURE_FORMAT_S32_111R = SCE_GXM_TEXTURE_BASE_FORMAT_S32 | SCE_GXM_TEXTURE_SWIZZLE1_111R, 682 | // SCE_GXM_TEXTURE_FORMAT_S32_RRRR = SCE_GXM_TEXTURE_BASE_FORMAT_S32 | SCE_GXM_TEXTURE_SWIZZLE1_RRRR, 683 | // SCE_GXM_TEXTURE_FORMAT_S32_0RRR = SCE_GXM_TEXTURE_BASE_FORMAT_S32 | SCE_GXM_TEXTURE_SWIZZLE1_0RRR, 684 | // SCE_GXM_TEXTURE_FORMAT_S32_1RRR = SCE_GXM_TEXTURE_BASE_FORMAT_S32 | SCE_GXM_TEXTURE_SWIZZLE1_1RRR, 685 | // SCE_GXM_TEXTURE_FORMAT_S32_R000 = SCE_GXM_TEXTURE_BASE_FORMAT_S32 | SCE_GXM_TEXTURE_SWIZZLE1_R000, 686 | // SCE_GXM_TEXTURE_FORMAT_S32_R111 = SCE_GXM_TEXTURE_BASE_FORMAT_S32 | SCE_GXM_TEXTURE_SWIZZLE1_R111, 687 | // SCE_GXM_TEXTURE_FORMAT_S32_R = SCE_GXM_TEXTURE_BASE_FORMAT_S32 | SCE_GXM_TEXTURE_SWIZZLE1_R, 688 | // 689 | // SCE_GXM_TEXTURE_FORMAT_SE5M9M9M9_BGR = SCE_GXM_TEXTURE_BASE_FORMAT_SE5M9M9M9 | SCE_GXM_TEXTURE_SWIZZLE3_BGR, 690 | // SCE_GXM_TEXTURE_FORMAT_SE5M9M9M9_RGB = SCE_GXM_TEXTURE_BASE_FORMAT_SE5M9M9M9 | SCE_GXM_TEXTURE_SWIZZLE3_RGB, 691 | // 692 | // SCE_GXM_TEXTURE_FORMAT_F10F11F11_BGR = SCE_GXM_TEXTURE_BASE_FORMAT_F11F11F10 | SCE_GXM_TEXTURE_SWIZZLE3_BGR, 693 | // SCE_GXM_TEXTURE_FORMAT_F11F11F10_RGB = SCE_GXM_TEXTURE_BASE_FORMAT_F11F11F10 | SCE_GXM_TEXTURE_SWIZZLE3_RGB, 694 | // 695 | // SCE_GXM_TEXTURE_FORMAT_F16F16F16F16_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_F16F16F16F16 | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 696 | // SCE_GXM_TEXTURE_FORMAT_F16F16F16F16_ARGB = SCE_GXM_TEXTURE_BASE_FORMAT_F16F16F16F16 | SCE_GXM_TEXTURE_SWIZZLE4_ARGB, 697 | // SCE_GXM_TEXTURE_FORMAT_F16F16F16F16_RGBA = SCE_GXM_TEXTURE_BASE_FORMAT_F16F16F16F16 | SCE_GXM_TEXTURE_SWIZZLE4_RGBA, 698 | // SCE_GXM_TEXTURE_FORMAT_F16F16F16F16_BGRA = SCE_GXM_TEXTURE_BASE_FORMAT_F16F16F16F16 | SCE_GXM_TEXTURE_SWIZZLE4_BGRA, 699 | // SCE_GXM_TEXTURE_FORMAT_X16F16F16F16_1BGR = SCE_GXM_TEXTURE_BASE_FORMAT_F16F16F16F16 | SCE_GXM_TEXTURE_SWIZZLE4_1BGR, 700 | // SCE_GXM_TEXTURE_FORMAT_X16F16F16F16_1RGB = SCE_GXM_TEXTURE_BASE_FORMAT_F16F16F16F16 | SCE_GXM_TEXTURE_SWIZZLE4_1RGB, 701 | // SCE_GXM_TEXTURE_FORMAT_F16F16F16X16_RGB1 = SCE_GXM_TEXTURE_BASE_FORMAT_F16F16F16F16 | SCE_GXM_TEXTURE_SWIZZLE4_RGB1, 702 | // SCE_GXM_TEXTURE_FORMAT_F16F16F16X16_BGR1 = SCE_GXM_TEXTURE_BASE_FORMAT_F16F16F16F16 | SCE_GXM_TEXTURE_SWIZZLE4_BGR1, 703 | // 704 | // SCE_GXM_TEXTURE_FORMAT_U16U16U16U16_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_U16U16U16U16 | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 705 | // SCE_GXM_TEXTURE_FORMAT_U16U16U16U16_ARGB = SCE_GXM_TEXTURE_BASE_FORMAT_U16U16U16U16 | SCE_GXM_TEXTURE_SWIZZLE4_ARGB, 706 | // SCE_GXM_TEXTURE_FORMAT_U16U16U16U16_RGBA = SCE_GXM_TEXTURE_BASE_FORMAT_U16U16U16U16 | SCE_GXM_TEXTURE_SWIZZLE4_RGBA, 707 | // SCE_GXM_TEXTURE_FORMAT_U16U16U16U16_BGRA = SCE_GXM_TEXTURE_BASE_FORMAT_U16U16U16U16 | SCE_GXM_TEXTURE_SWIZZLE4_BGRA, 708 | // SCE_GXM_TEXTURE_FORMAT_X16U16U16U16_1BGR = SCE_GXM_TEXTURE_BASE_FORMAT_U16U16U16U16 | SCE_GXM_TEXTURE_SWIZZLE4_1BGR, 709 | // SCE_GXM_TEXTURE_FORMAT_X16U16U16U16_1RGB = SCE_GXM_TEXTURE_BASE_FORMAT_U16U16U16U16 | SCE_GXM_TEXTURE_SWIZZLE4_1RGB, 710 | // SCE_GXM_TEXTURE_FORMAT_U16U16U16X16_RGB1 = SCE_GXM_TEXTURE_BASE_FORMAT_U16U16U16U16 | SCE_GXM_TEXTURE_SWIZZLE4_RGB1, 711 | // SCE_GXM_TEXTURE_FORMAT_U16U16U16X16_BGR1 = SCE_GXM_TEXTURE_BASE_FORMAT_U16U16U16U16 | SCE_GXM_TEXTURE_SWIZZLE4_BGR1, 712 | // 713 | // SCE_GXM_TEXTURE_FORMAT_S16S16S16S16_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_S16S16S16S16 | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 714 | // SCE_GXM_TEXTURE_FORMAT_S16S16S16S16_ARGB = SCE_GXM_TEXTURE_BASE_FORMAT_S16S16S16S16 | SCE_GXM_TEXTURE_SWIZZLE4_ARGB, 715 | // SCE_GXM_TEXTURE_FORMAT_S16S16S16S16_RGBA = SCE_GXM_TEXTURE_BASE_FORMAT_S16S16S16S16 | SCE_GXM_TEXTURE_SWIZZLE4_RGBA, 716 | // SCE_GXM_TEXTURE_FORMAT_S16S16S16S16_BGRA = SCE_GXM_TEXTURE_BASE_FORMAT_S16S16S16S16 | SCE_GXM_TEXTURE_SWIZZLE4_BGRA, 717 | // SCE_GXM_TEXTURE_FORMAT_X16S16S16S16_1BGR = SCE_GXM_TEXTURE_BASE_FORMAT_S16S16S16S16 | SCE_GXM_TEXTURE_SWIZZLE4_1BGR, 718 | // SCE_GXM_TEXTURE_FORMAT_X16S16S16S16_1RGB = SCE_GXM_TEXTURE_BASE_FORMAT_S16S16S16S16 | SCE_GXM_TEXTURE_SWIZZLE4_1RGB, 719 | // SCE_GXM_TEXTURE_FORMAT_S16S16S16X16_RGB1 = SCE_GXM_TEXTURE_BASE_FORMAT_S16S16S16S16 | SCE_GXM_TEXTURE_SWIZZLE4_RGB1, 720 | // SCE_GXM_TEXTURE_FORMAT_S16S16S16X16_BGR1 = SCE_GXM_TEXTURE_BASE_FORMAT_S16S16S16S16 | SCE_GXM_TEXTURE_SWIZZLE4_BGR1, 721 | // 722 | // SCE_GXM_TEXTURE_FORMAT_F32F32_00GR = SCE_GXM_TEXTURE_BASE_FORMAT_F32F32 | SCE_GXM_TEXTURE_SWIZZLE2_00GR, 723 | // SCE_GXM_TEXTURE_FORMAT_F32F32_GRRR = SCE_GXM_TEXTURE_BASE_FORMAT_F32F32 | SCE_GXM_TEXTURE_SWIZZLE2_GRRR, 724 | // SCE_GXM_TEXTURE_FORMAT_F32F32_RGGG = SCE_GXM_TEXTURE_BASE_FORMAT_F32F32 | SCE_GXM_TEXTURE_SWIZZLE2_RGGG, 725 | // SCE_GXM_TEXTURE_FORMAT_F32F32_GRGR = SCE_GXM_TEXTURE_BASE_FORMAT_F32F32 | SCE_GXM_TEXTURE_SWIZZLE2_GRGR, 726 | // SCE_GXM_TEXTURE_FORMAT_F32F32_00RG = SCE_GXM_TEXTURE_BASE_FORMAT_F32F32 | SCE_GXM_TEXTURE_SWIZZLE2_00RG, 727 | // SCE_GXM_TEXTURE_FORMAT_F32F32_GR = SCE_GXM_TEXTURE_BASE_FORMAT_F32F32 | SCE_GXM_TEXTURE_SWIZZLE2_GR, 728 | // 729 | // SCE_GXM_TEXTURE_FORMAT_U32U32_00GR = SCE_GXM_TEXTURE_BASE_FORMAT_U32U32 | SCE_GXM_TEXTURE_SWIZZLE2_00GR, 730 | // SCE_GXM_TEXTURE_FORMAT_U32U32_GRRR = SCE_GXM_TEXTURE_BASE_FORMAT_U32U32 | SCE_GXM_TEXTURE_SWIZZLE2_GRRR, 731 | // SCE_GXM_TEXTURE_FORMAT_U32U32_RGGG = SCE_GXM_TEXTURE_BASE_FORMAT_U32U32 | SCE_GXM_TEXTURE_SWIZZLE2_RGGG, 732 | // SCE_GXM_TEXTURE_FORMAT_U32U32_GRGR = SCE_GXM_TEXTURE_BASE_FORMAT_U32U32 | SCE_GXM_TEXTURE_SWIZZLE2_GRGR, 733 | // SCE_GXM_TEXTURE_FORMAT_U32U32_00RG = SCE_GXM_TEXTURE_BASE_FORMAT_U32U32 | SCE_GXM_TEXTURE_SWIZZLE2_00RG, 734 | // SCE_GXM_TEXTURE_FORMAT_U32U32_GR = SCE_GXM_TEXTURE_BASE_FORMAT_U32U32 | SCE_GXM_TEXTURE_SWIZZLE2_GR, 735 | // 736 | // SCE_GXM_TEXTURE_FORMAT_PVRT2BPP_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_PVRT2BPP | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 737 | // SCE_GXM_TEXTURE_FORMAT_PVRT2BPP_1BGR = SCE_GXM_TEXTURE_BASE_FORMAT_PVRT2BPP | SCE_GXM_TEXTURE_SWIZZLE4_1BGR, 738 | // 739 | // SCE_GXM_TEXTURE_FORMAT_PVRT4BPP_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_PVRT4BPP | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 740 | // SCE_GXM_TEXTURE_FORMAT_PVRT4BPP_1BGR = SCE_GXM_TEXTURE_BASE_FORMAT_PVRT4BPP | SCE_GXM_TEXTURE_SWIZZLE4_1BGR, 741 | // 742 | // SCE_GXM_TEXTURE_FORMAT_PVRTII2BPP_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_PVRTII2BPP | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 743 | // SCE_GXM_TEXTURE_FORMAT_PVRTII2BPP_1BGR = SCE_GXM_TEXTURE_BASE_FORMAT_PVRTII2BPP | SCE_GXM_TEXTURE_SWIZZLE4_1BGR, 744 | // 745 | // SCE_GXM_TEXTURE_FORMAT_PVRTII4BPP_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_PVRTII4BPP | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 746 | // SCE_GXM_TEXTURE_FORMAT_PVRTII4BPP_1BGR = SCE_GXM_TEXTURE_BASE_FORMAT_PVRTII4BPP | SCE_GXM_TEXTURE_SWIZZLE4_1BGR, 747 | // 748 | // SCE_GXM_TEXTURE_FORMAT_UBC1_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_UBC1 | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 749 | // 750 | // SCE_GXM_TEXTURE_FORMAT_UBC2_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_UBC2 | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 751 | // 752 | // SCE_GXM_TEXTURE_FORMAT_UBC3_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_UBC3 | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 753 | // 754 | // SCE_GXM_TEXTURE_FORMAT_YUV420P2_CSC0 = SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P2 | SCE_GXM_TEXTURE_SWIZZLE_YUV_CSC0, 755 | // SCE_GXM_TEXTURE_FORMAT_YVU420P2_CSC0 = SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P2 | SCE_GXM_TEXTURE_SWIZZLE_YVU_CSC0, 756 | // SCE_GXM_TEXTURE_FORMAT_YUV420P2_CSC1 = SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P2 | SCE_GXM_TEXTURE_SWIZZLE_YUV_CSC1, 757 | // SCE_GXM_TEXTURE_FORMAT_YVU420P2_CSC1 = SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P2 | SCE_GXM_TEXTURE_SWIZZLE_YVU_CSC1, 758 | // 759 | // SCE_GXM_TEXTURE_FORMAT_YUV420P3_CSC0 = SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P3 | SCE_GXM_TEXTURE_SWIZZLE_YUV_CSC0, 760 | // SCE_GXM_TEXTURE_FORMAT_YVU420P3_CSC0 = SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P3 | SCE_GXM_TEXTURE_SWIZZLE_YVU_CSC0, 761 | // SCE_GXM_TEXTURE_FORMAT_YUV420P3_CSC1 = SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P3 | SCE_GXM_TEXTURE_SWIZZLE_YUV_CSC1, 762 | // SCE_GXM_TEXTURE_FORMAT_YVU420P3_CSC1 = SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P3 | SCE_GXM_TEXTURE_SWIZZLE_YVU_CSC1, 763 | // 764 | // SCE_GXM_TEXTURE_FORMAT_YUYV422_CSC0 = SCE_GXM_TEXTURE_BASE_FORMAT_YUV422 | SCE_GXM_TEXTURE_SWIZZLE_YUYV_CSC0, 765 | // SCE_GXM_TEXTURE_FORMAT_YVYU422_CSC0 = SCE_GXM_TEXTURE_BASE_FORMAT_YUV422 | SCE_GXM_TEXTURE_SWIZZLE_YVYU_CSC0, 766 | // SCE_GXM_TEXTURE_FORMAT_UYVY422_CSC0 = SCE_GXM_TEXTURE_BASE_FORMAT_YUV422 | SCE_GXM_TEXTURE_SWIZZLE_UYVY_CSC0, 767 | // SCE_GXM_TEXTURE_FORMAT_VYUY422_CSC0 = SCE_GXM_TEXTURE_BASE_FORMAT_YUV422 | SCE_GXM_TEXTURE_SWIZZLE_VYUY_CSC0, 768 | // SCE_GXM_TEXTURE_FORMAT_YUYV422_CSC1 = SCE_GXM_TEXTURE_BASE_FORMAT_YUV422 | SCE_GXM_TEXTURE_SWIZZLE_YUYV_CSC1, 769 | // SCE_GXM_TEXTURE_FORMAT_YVYU422_CSC1 = SCE_GXM_TEXTURE_BASE_FORMAT_YUV422 | SCE_GXM_TEXTURE_SWIZZLE_YVYU_CSC1, 770 | // SCE_GXM_TEXTURE_FORMAT_UYVY422_CSC1 = SCE_GXM_TEXTURE_BASE_FORMAT_YUV422 | SCE_GXM_TEXTURE_SWIZZLE_UYVY_CSC1, 771 | // SCE_GXM_TEXTURE_FORMAT_VYUY422_CSC1 = SCE_GXM_TEXTURE_BASE_FORMAT_YUV422 | SCE_GXM_TEXTURE_SWIZZLE_VYUY_CSC1, 772 | // 773 | // SCE_GXM_TEXTURE_FORMAT_P4_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_P4 | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 774 | // SCE_GXM_TEXTURE_FORMAT_P4_ARGB = SCE_GXM_TEXTURE_BASE_FORMAT_P4 | SCE_GXM_TEXTURE_SWIZZLE4_ARGB, 775 | // SCE_GXM_TEXTURE_FORMAT_P4_RGBA = SCE_GXM_TEXTURE_BASE_FORMAT_P4 | SCE_GXM_TEXTURE_SWIZZLE4_RGBA, 776 | // SCE_GXM_TEXTURE_FORMAT_P4_BGRA = SCE_GXM_TEXTURE_BASE_FORMAT_P4 | SCE_GXM_TEXTURE_SWIZZLE4_BGRA, 777 | // SCE_GXM_TEXTURE_FORMAT_P4_1BGR = SCE_GXM_TEXTURE_BASE_FORMAT_P4 | SCE_GXM_TEXTURE_SWIZZLE4_1BGR, 778 | // SCE_GXM_TEXTURE_FORMAT_P4_1RGB = SCE_GXM_TEXTURE_BASE_FORMAT_P4 | SCE_GXM_TEXTURE_SWIZZLE4_1RGB, 779 | // SCE_GXM_TEXTURE_FORMAT_P4_RGB1 = SCE_GXM_TEXTURE_BASE_FORMAT_P4 | SCE_GXM_TEXTURE_SWIZZLE4_RGB1, 780 | // SCE_GXM_TEXTURE_FORMAT_P4_BGR1 = SCE_GXM_TEXTURE_BASE_FORMAT_P4 | SCE_GXM_TEXTURE_SWIZZLE4_BGR1, 781 | // 782 | // SCE_GXM_TEXTURE_FORMAT_P8_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_P8 | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 783 | // SCE_GXM_TEXTURE_FORMAT_P8_ARGB = SCE_GXM_TEXTURE_BASE_FORMAT_P8 | SCE_GXM_TEXTURE_SWIZZLE4_ARGB, 784 | // SCE_GXM_TEXTURE_FORMAT_P8_RGBA = SCE_GXM_TEXTURE_BASE_FORMAT_P8 | SCE_GXM_TEXTURE_SWIZZLE4_RGBA, 785 | // SCE_GXM_TEXTURE_FORMAT_P8_BGRA = SCE_GXM_TEXTURE_BASE_FORMAT_P8 | SCE_GXM_TEXTURE_SWIZZLE4_BGRA, 786 | // SCE_GXM_TEXTURE_FORMAT_P8_1BGR = SCE_GXM_TEXTURE_BASE_FORMAT_P8 | SCE_GXM_TEXTURE_SWIZZLE4_1BGR, 787 | // SCE_GXM_TEXTURE_FORMAT_P8_1RGB = SCE_GXM_TEXTURE_BASE_FORMAT_P8 | SCE_GXM_TEXTURE_SWIZZLE4_1RGB, 788 | // SCE_GXM_TEXTURE_FORMAT_P8_RGB1 = SCE_GXM_TEXTURE_BASE_FORMAT_P8 | SCE_GXM_TEXTURE_SWIZZLE4_RGB1, 789 | // SCE_GXM_TEXTURE_FORMAT_P8_BGR1 = SCE_GXM_TEXTURE_BASE_FORMAT_P8 | SCE_GXM_TEXTURE_SWIZZLE4_BGR1, 790 | // 791 | // SCE_GXM_TEXTURE_FORMAT_U8U8U8_BGR = SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8 | SCE_GXM_TEXTURE_SWIZZLE3_BGR, 792 | // SCE_GXM_TEXTURE_FORMAT_U8U8U8_RGB = SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8 | SCE_GXM_TEXTURE_SWIZZLE3_RGB, 793 | // 794 | // SCE_GXM_TEXTURE_FORMAT_S8S8S8_BGR = SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8 | SCE_GXM_TEXTURE_SWIZZLE3_BGR, 795 | // SCE_GXM_TEXTURE_FORMAT_S8S8S8_RGB = SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8 | SCE_GXM_TEXTURE_SWIZZLE3_RGB, 796 | // 797 | // SCE_GXM_TEXTURE_FORMAT_U2F10F10F10_ABGR = SCE_GXM_TEXTURE_BASE_FORMAT_U2F10F10F10 | SCE_GXM_TEXTURE_SWIZZLE4_ABGR, 798 | // SCE_GXM_TEXTURE_FORMAT_U2F10F10F10_ARGB = SCE_GXM_TEXTURE_BASE_FORMAT_U2F10F10F10 | SCE_GXM_TEXTURE_SWIZZLE4_ARGB, 799 | // SCE_GXM_TEXTURE_FORMAT_F10F10F10U2_RGBA = SCE_GXM_TEXTURE_BASE_FORMAT_U2F10F10F10 | SCE_GXM_TEXTURE_SWIZZLE4_RGBA, 800 | // SCE_GXM_TEXTURE_FORMAT_F10F10F10U2_BGRA = SCE_GXM_TEXTURE_BASE_FORMAT_U2F10F10F10 | SCE_GXM_TEXTURE_SWIZZLE4_BGRA, 801 | // SCE_GXM_TEXTURE_FORMAT_X2F10F10F10_1BGR = SCE_GXM_TEXTURE_BASE_FORMAT_U2F10F10F10 | SCE_GXM_TEXTURE_SWIZZLE4_1BGR, 802 | // SCE_GXM_TEXTURE_FORMAT_X2F10F10F10_1RGB = SCE_GXM_TEXTURE_BASE_FORMAT_U2F10F10F10 | SCE_GXM_TEXTURE_SWIZZLE4_1RGB, 803 | // SCE_GXM_TEXTURE_FORMAT_F10F10F10X2_RGB1 = SCE_GXM_TEXTURE_BASE_FORMAT_U2F10F10F10 | SCE_GXM_TEXTURE_SWIZZLE4_RGB1, 804 | // SCE_GXM_TEXTURE_FORMAT_F10F10F10X2_BGR1 = SCE_GXM_TEXTURE_BASE_FORMAT_U2F10F10F10 | SCE_GXM_TEXTURE_SWIZZLE4_BGR1, 805 | // 806 | // // Legacy formats 807 | // 808 | // SCE_GXM_TEXTURE_FORMAT_L8 = SCE_GXM_TEXTURE_FORMAT_U8_1RRR, 809 | // SCE_GXM_TEXTURE_FORMAT_A8 = SCE_GXM_TEXTURE_FORMAT_U8_R000, 810 | // SCE_GXM_TEXTURE_FORMAT_R8 = SCE_GXM_TEXTURE_FORMAT_U8_000R, 811 | // SCE_GXM_TEXTURE_FORMAT_A4R4G4B4 = SCE_GXM_TEXTURE_FORMAT_U4U4U4U4_ARGB, 812 | // SCE_GXM_TEXTURE_FORMAT_A1R5G5B5 = SCE_GXM_TEXTURE_FORMAT_U1U5U5U5_ARGB, 813 | // SCE_GXM_TEXTURE_FORMAT_R5G6B5 = SCE_GXM_TEXTURE_FORMAT_U5U6U5_RGB, 814 | // SCE_GXM_TEXTURE_FORMAT_A8L8 = SCE_GXM_TEXTURE_FORMAT_U8U8_GRRR, 815 | // SCE_GXM_TEXTURE_FORMAT_L8A8 = SCE_GXM_TEXTURE_FORMAT_U8U8_RGGG, 816 | // SCE_GXM_TEXTURE_FORMAT_G8R8 = SCE_GXM_TEXTURE_FORMAT_U8U8_00GR, 817 | // SCE_GXM_TEXTURE_FORMAT_L16 = SCE_GXM_TEXTURE_FORMAT_U16_1RRR, 818 | // SCE_GXM_TEXTURE_FORMAT_A16 = SCE_GXM_TEXTURE_FORMAT_U16_R000, 819 | // SCE_GXM_TEXTURE_FORMAT_R16 = SCE_GXM_TEXTURE_FORMAT_U16_000R, 820 | // SCE_GXM_TEXTURE_FORMAT_D16 = SCE_GXM_TEXTURE_FORMAT_U16_R, 821 | // SCE_GXM_TEXTURE_FORMAT_LF16 = SCE_GXM_TEXTURE_FORMAT_F16_1RRR, 822 | // SCE_GXM_TEXTURE_FORMAT_AF16 = SCE_GXM_TEXTURE_FORMAT_F16_R000, 823 | // SCE_GXM_TEXTURE_FORMAT_RF16 = SCE_GXM_TEXTURE_FORMAT_F16_000R, 824 | // SCE_GXM_TEXTURE_FORMAT_A8R8G8B8 = SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ARGB, 825 | // SCE_GXM_TEXTURE_FORMAT_A8B8G8R8 = SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR, 826 | // SCE_GXM_TEXTURE_FORMAT_AF16LF16 = SCE_GXM_TEXTURE_FORMAT_F16F16_GRRR, 827 | // SCE_GXM_TEXTURE_FORMAT_LF16AF16 = SCE_GXM_TEXTURE_FORMAT_F16F16_RGGG, 828 | // SCE_GXM_TEXTURE_FORMAT_GF16RF16 = SCE_GXM_TEXTURE_FORMAT_F16F16_00GR, 829 | // SCE_GXM_TEXTURE_FORMAT_LF32M = SCE_GXM_TEXTURE_FORMAT_F32M_1RRR, 830 | // SCE_GXM_TEXTURE_FORMAT_AF32M = SCE_GXM_TEXTURE_FORMAT_F32M_R000, 831 | // SCE_GXM_TEXTURE_FORMAT_RF32M = SCE_GXM_TEXTURE_FORMAT_F32M_000R, 832 | // SCE_GXM_TEXTURE_FORMAT_DF32M = SCE_GXM_TEXTURE_FORMAT_F32M_R, 833 | // SCE_GXM_TEXTURE_FORMAT_VYUY = SCE_GXM_TEXTURE_FORMAT_VYUY422_CSC0, 834 | // SCE_GXM_TEXTURE_FORMAT_YVYU = SCE_GXM_TEXTURE_FORMAT_YVYU422_CSC0, 835 | // SCE_GXM_TEXTURE_FORMAT_UBC1 = SCE_GXM_TEXTURE_FORMAT_UBC1_ABGR, 836 | // SCE_GXM_TEXTURE_FORMAT_UBC2 = SCE_GXM_TEXTURE_FORMAT_UBC2_ABGR, 837 | // SCE_GXM_TEXTURE_FORMAT_UBC3 = SCE_GXM_TEXTURE_FORMAT_UBC3_ABGR, 838 | // SCE_GXM_TEXTURE_FORMAT_PVRT2BPP = SCE_GXM_TEXTURE_FORMAT_PVRT2BPP_ABGR, 839 | // SCE_GXM_TEXTURE_FORMAT_PVRT4BPP = SCE_GXM_TEXTURE_FORMAT_PVRT4BPP_ABGR, 840 | // SCE_GXM_TEXTURE_FORMAT_PVRTII2BPP = SCE_GXM_TEXTURE_FORMAT_PVRTII2BPP_ABGR, 841 | // SCE_GXM_TEXTURE_FORMAT_PVRTII4BPP = SCE_GXM_TEXTURE_FORMAT_PVRTII4BPP_ABGR 842 | // } SceGxmTextureFormat; 843 | // 844 | // typedef enum SceGxmTextureType { 845 | // SCE_GXM_TEXTURE_SWIZZLED = 0x00000000u, 846 | // SCE_GXM_TEXTURE_CUBE = 0x40000000u, 847 | // SCE_GXM_TEXTURE_LINEAR = 0x60000000u, 848 | // SCE_GXM_TEXTURE_TILED = 0x80000000u, 849 | // SCE_GXM_TEXTURE_SWIZZLED_ARBITRARY = 0xA0000000U, 850 | // SCE_GXM_TEXTURE_LINEAR_STRIDED = 0xC0000000u, 851 | // SCE_GXM_TEXTURE_CUBE_ARBITRARY = 0xE0000000U 852 | // } SceGxmTextureType; 853 | // 854 | // typedef enum SceGxmTextureFilter { 855 | // SCE_GXM_TEXTURE_FILTER_POINT = 0x00000000u, 856 | // SCE_GXM_TEXTURE_FILTER_LINEAR = 0x00000001u 857 | // } SceGxmTextureFilter; 858 | // 859 | // typedef enum SceGxmTextureMipFilter { 860 | // SCE_GXM_TEXTURE_MIP_FILTER_DISABLED = 0x00000000u, 861 | // SCE_GXM_TEXTURE_MIP_FILTER_ENABLED = 0x00000200u 862 | // } SceGxmTextureMipFilter; 863 | // 864 | // typedef enum SceGxmTextureAddrMode { 865 | // SCE_GXM_TEXTURE_ADDR_REPEAT = 0x00000000u, 866 | // SCE_GXM_TEXTURE_ADDR_MIRROR = 0x00000001u, 867 | // SCE_GXM_TEXTURE_ADDR_CLAMP = 0x00000002u, 868 | // SCE_GXM_TEXTURE_ADDR_MIRROR_CLAMP = 0x00000003u, 869 | // SCE_GXM_TEXTURE_ADDR_REPEAT_IGNORE_BORDER = 0x00000004u, 870 | // SCE_GXM_TEXTURE_ADDR_CLAMP_FULL_BORDER = 0x00000005u, 871 | // SCE_GXM_TEXTURE_ADDR_CLAMP_IGNORE_BORDER = 0x00000006u, 872 | // SCE_GXM_TEXTURE_ADDR_CLAMP_HALF_BORDER = 0x00000007u 873 | // } SceGxmTextureAddrMode; 874 | // 875 | // typedef enum SceGxmTextureGammaMode { 876 | // SCE_GXM_TEXTURE_GAMMA_NONE = 0x00000000u, 877 | // SCE_GXM_TEXTURE_GAMMA_R = 0x08000000u, 878 | // SCE_GXM_TEXTURE_GAMMA_GR = 0x18000000u, 879 | // SCE_GXM_TEXTURE_GAMMA_BGR = 0x08000000u 880 | // } SceGxmTextureGammaMode; 881 | // 882 | // typedef enum SceGxmIndexFormat { 883 | // SCE_GXM_INDEX_FORMAT_U16 = 0x00000000u, 884 | // SCE_GXM_INDEX_FORMAT_U32 = 0x01000000u 885 | // } SceGxmIndexFormat; 886 | // 887 | // typedef enum SceGxmIndexSource { 888 | // SCE_GXM_INDEX_SOURCE_INDEX_16BIT = 0x00000000u, 889 | // SCE_GXM_INDEX_SOURCE_INDEX_32BIT = 0x00000001u, 890 | // SCE_GXM_INDEX_SOURCE_INSTANCE_16BIT = 0x00000002u, 891 | // SCE_GXM_INDEX_SOURCE_INSTANCE_32BIT = 0x00000003u 892 | // } SceGxmIndexSource; 893 | // 894 | // typedef enum SceGxmFragmentProgramMode { 895 | // SCE_GXM_FRAGMENT_PROGRAM_DISABLED = 0x00200000u, 896 | // SCE_GXM_FRAGMENT_PROGRAM_ENABLED = 0x00000000u 897 | // } SceGxmFragmentProgramMode; 898 | // 899 | // typedef enum SceGxmDepthWriteMode { 900 | // SCE_GXM_DEPTH_WRITE_DISABLED = 0x00100000u, 901 | // SCE_GXM_DEPTH_WRITE_ENABLED = 0x00000000u 902 | // } SceGxmDepthWriteMode; 903 | // 904 | // typedef enum SceGxmLineFillLastPixelMode { 905 | // SCE_GXM_LINE_FILL_LAST_PIXEL_DISABLED = 0x00000000u, 906 | // SCE_GXM_LINE_FILL_LAST_PIXEL_ENABLED = 0x00080000u 907 | // } SceGxmLineFillLastPixelMode; 908 | // 909 | // typedef enum SceGxmTwoSidedMode { 910 | // SCE_GXM_TWO_SIDED_DISABLED = 0x00000000u, 911 | // SCE_GXM_TWO_SIDED_ENABLED = 0x00000800u 912 | // } SceGxmTwoSidedMode; 913 | // 914 | // typedef enum SceGxmWClampMode { 915 | // SCE_GXM_WCLAMP_MODE_DISABLED = 0x00000000u, 916 | // SCE_GXM_WCLAMP_MODE_ENABLED = 0x00008000u 917 | // } SceGxmWClampMode; 918 | // 919 | // typedef enum SceGxmViewportMode { 920 | // SCE_GXM_VIEWPORT_DISABLED = 0x00010000u, 921 | // SCE_GXM_VIEWPORT_ENABLED = 0x00000000u 922 | // } SceGxmViewportMode; 923 | // 924 | // typedef enum SceGxmWBufferMode { 925 | // SCE_GXM_WBUFFER_DISABLED = 0x00000000u, 926 | // SCE_GXM_WBUFFER_ENABLED = 0x00004000u 927 | // } SceGxmWBufferMode; 928 | // 929 | // typedef enum SceGxmDepthStencilForceLoadMode { 930 | // SCE_GXM_DEPTH_STENCIL_FORCE_LOAD_DISABLED = 0x00000000u, 931 | // SCE_GXM_DEPTH_STENCIL_FORCE_LOAD_ENABLED = 0x00000002u 932 | // } SceGxmDepthStencilForceLoadMode; 933 | // 934 | // typedef enum SceGxmDepthStencilForceStoreMode { 935 | // SCE_GXM_DEPTH_STENCIL_FORCE_STORE_DISABLED = 0x00000000u, 936 | // SCE_GXM_DEPTH_STENCIL_FORCE_STORE_ENABLED = 0x00000004u 937 | // } SceGxmDepthStencilForceStoreMode; 938 | // 939 | // typedef enum SceGxmSceneFlags { 940 | // SCE_GXM_SCENE_FRAGMENT_SET_DEPENDENCY = 0x00000001u, 941 | // SCE_GXM_SCENE_VERTEX_WAIT_FOR_DEPENDENCY = 0x00000002u, 942 | // SCE_GXM_SCENE_FRAGMENT_TRANSFER_SYNC = 0x00000004U, 943 | // SCE_GXM_SCENE_VERTEX_TRANSFER_SYNC = 0x00000008U 944 | // } SceGxmSceneFlags; 945 | // 946 | // typedef enum SceGxmMidSceneFlags { 947 | // SCE_GXM_MIDSCENE_PRESERVE_DEFAULT_UNIFORM_BUFFERS = 0x00000001u 948 | // } SceGxmMidSceneFlags; 949 | // 950 | // typedef enum SceGxmColorSurfaceScaleMode { 951 | // SCE_GXM_COLOR_SURFACE_SCALE_NONE = 0x00000000u, 952 | // SCE_GXM_COLOR_SURFACE_SCALE_MSAA_DOWNSCALE = 0x00000001u 953 | // } SceGxmColorSurfaceScaleMode; 954 | // 955 | // typedef enum SceGxmOutputRegisterSize { 956 | // SCE_GXM_OUTPUT_REGISTER_SIZE_32BIT = 0x00000000u, 957 | // SCE_GXM_OUTPUT_REGISTER_SIZE_64BIT = 0x00000001u 958 | // } SceGxmOutputRegisterSize; 959 | // 960 | // typedef enum SceGxmVisibilityTestMode { 961 | // SCE_GXM_VISIBILITY_TEST_DISABLED = 0x00000000u, 962 | // SCE_GXM_VISIBILITY_TEST_ENABLED = 0x00004000u 963 | // } SceGxmVisibilityTestMode; 964 | // 965 | // typedef enum SceGxmVisibilityTestOp { 966 | // SCE_GXM_VISIBILITY_TEST_OP_INCREMENT = 0x00000000u, 967 | // SCE_GXM_VISIBILITY_TEST_OP_SET = 0x00040000u 968 | // } SceGxmVisibilityTestOp; 969 | // 970 | // typedef enum SceGxmBlendFunc { 971 | // SCE_GXM_BLEND_FUNC_NONE, 972 | // SCE_GXM_BLEND_FUNC_ADD, 973 | // SCE_GXM_BLEND_FUNC_SUBTRACT, 974 | // SCE_GXM_BLEND_FUNC_REVERSE_SUBTRACT, 975 | // SCE_GXM_BLEND_FUNC_MIN, 976 | // SCE_GXM_BLEND_FUNC_MAX 977 | // } SceGxmBlendFunc; 978 | // 979 | // typedef enum SceGxmBlendFactor { 980 | // SCE_GXM_BLEND_FACTOR_ZERO, 981 | // SCE_GXM_BLEND_FACTOR_ONE, 982 | // SCE_GXM_BLEND_FACTOR_SRC_COLOR, 983 | // SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_COLOR, 984 | // SCE_GXM_BLEND_FACTOR_SRC_ALPHA, 985 | // SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, 986 | // SCE_GXM_BLEND_FACTOR_DST_COLOR, 987 | // SCE_GXM_BLEND_FACTOR_ONE_MINUS_DST_COLOR, 988 | // SCE_GXM_BLEND_FACTOR_DST_ALPHA, 989 | // SCE_GXM_BLEND_FACTOR_ONE_MINUS_DST_ALPHA, 990 | // SCE_GXM_BLEND_FACTOR_SRC_ALPHA_SATURATE, 991 | // SCE_GXM_BLEND_FACTOR_DST_ALPHA_SATURATE 992 | // } SceGxmBlendFactor; 993 | // 994 | // typedef enum SceGxmColorMask { 995 | // SCE_GXM_COLOR_MASK_NONE = 0, 996 | // SCE_GXM_COLOR_MASK_A = (1 << 0), 997 | // SCE_GXM_COLOR_MASK_R = (1 << 1), 998 | // SCE_GXM_COLOR_MASK_G = (1 << 2), 999 | // SCE_GXM_COLOR_MASK_B = (1 << 3), 1000 | // SCE_GXM_COLOR_MASK_ALL = (SCE_GXM_COLOR_MASK_A | SCE_GXM_COLOR_MASK_B | SCE_GXM_COLOR_MASK_G | SCE_GXM_COLOR_MASK_R) 1001 | // } SceGxmColorMask; 1002 | // 1003 | // typedef enum SceGxmTransferFormat { 1004 | // SCE_GXM_TRANSFER_FORMAT_U8_R = 0x00000000u, 1005 | // SCE_GXM_TRANSFER_FORMAT_U4U4U4U4_ABGR = 0x00010000u, 1006 | // SCE_GXM_TRANSFER_FORMAT_U1U5U5U5_ABGR = 0x00020000u, 1007 | // SCE_GXM_TRANSFER_FORMAT_U5U6U5_BGR = 0x00030000u, 1008 | // SCE_GXM_TRANSFER_FORMAT_U8U8_GR = 0x00040000u, 1009 | // SCE_GXM_TRANSFER_FORMAT_U8U8U8_BGR = 0x00050000u, 1010 | // SCE_GXM_TRANSFER_FORMAT_U8U8U8U8_ABGR = 0x00060000u, 1011 | // SCE_GXM_TRANSFER_FORMAT_VYUY422 = 0x00070000u, 1012 | // SCE_GXM_TRANSFER_FORMAT_YVYU422 = 0x00080000u, 1013 | // SCE_GXM_TRANSFER_FORMAT_UYVY422 = 0x00090000u, 1014 | // SCE_GXM_TRANSFER_FORMAT_YUYV422 = 0x000a0000u, 1015 | // SCE_GXM_TRANSFER_FORMAT_U2U10U10U10_ABGR = 0x000d0000u, 1016 | // SCE_GXM_TRANSFER_FORMAT_RAW16 = 0x000f0000u, 1017 | // SCE_GXM_TRANSFER_FORMAT_RAW32 = 0x00110000u, 1018 | // SCE_GXM_TRANSFER_FORMAT_RAW64 = 0x00120000u, 1019 | // SCE_GXM_TRANSFER_FORMAT_RAW128 = 0x00130000u 1020 | // } SceGxmTransferFormat; 1021 | // 1022 | // typedef enum SceGxmTransferFlags { 1023 | // SCE_GXM_TRANSFER_FRAGMENT_SYNC = 0x00000001u, 1024 | // SCE_GXM_TRANSFER_VERTEX_SYNC = 0x00000002u 1025 | // } SceGxmTransferFlags; 1026 | // 1027 | // typedef enum SceGxmTransferColorKeyMode { 1028 | // SCE_GXM_TRANSFER_COLORKEY_NONE = 0, 1029 | // SCE_GXM_TRANSFER_COLORKEY_PASS = 1, 1030 | // SCE_GXM_TRANSFER_COLORKEY_REJECT = 2 1031 | // } SceGxmTransferColorKeyMode; 1032 | // 1033 | // typedef enum SceGxmTransferType { 1034 | // SCE_GXM_TRANSFER_LINEAR = 0x00000000U, 1035 | // SCE_GXM_TRANSFER_TILED = 0x00400000U, 1036 | // SCE_GXM_TRANSFER_SWIZZLED = 0x00800000U 1037 | // } SceGxmTransferType; 1038 | // 1039 | // typedef struct SceGxmBlendInfo { 1040 | // SceGxmColorMask colorMask; 1041 | // SceGxmBlendFunc colorFunc : 4; 1042 | // SceGxmBlendFunc alphaFunc : 4; 1043 | // SceGxmBlendFactor colorSrc : 4; 1044 | // SceGxmBlendFactor colorDst : 4; 1045 | // SceGxmBlendFactor alphaSrc : 4; 1046 | // SceGxmBlendFactor alphaDst : 4; 1047 | // } SceGxmBlendInfo; 1048 | // 1049 | // typedef struct SceGxmRenderTarget SceGxmRenderTarget; 1050 | // 1051 | pub enum SceGxmSyncObject {} 1052 | // 1053 | // typedef struct SceGxmVertexAttribute { 1054 | // unsigned short streamIndex; 1055 | // unsigned short offset; 1056 | // SceGxmAttributeFormat format; 1057 | // unsigned char componentCount; 1058 | // unsigned short regIndex; 1059 | // } SceGxmVertexAttribute; 1060 | // 1061 | // typedef struct SceGxmVertexStream { 1062 | // unsigned short stride; 1063 | // unsigned short indexSource; 1064 | // } SceGxmVertexStream; 1065 | // 1066 | // typedef struct SceGxmTexture { 1067 | // // Control Word 0 1068 | // uint32_t unk0 : 3; 1069 | // uint32_t vaddr_mode : 3; 1070 | // uint32_t uaddr_mode : 3; 1071 | // uint32_t mip_filter : 1; 1072 | // uint32_t min_filter: 2; 1073 | // uint32_t mag_filter : 2; 1074 | // uint32_t unk1 : 3; 1075 | // uint32_t mip_count : 4; 1076 | // uint32_t lod_bias : 6; 1077 | // uint32_t gamma_mode : 2; 1078 | // uint32_t unk2 : 2; 1079 | // uint32_t format0 : 1; 1080 | // // Control Word 1 1081 | // uint32_t height : 12; 1082 | // uint32_t width : 12; 1083 | // uint32_t base_format : 5; 1084 | // uint32_t type : 3; 1085 | // // Control Word 2 1086 | // uint32_t lod_min0 : 2; 1087 | // uint32_t data_addr : 30; 1088 | // // Control Word 3 1089 | // uint32_t palette_addr : 26; 1090 | // uint32_t lod_min1 : 2; 1091 | // uint32_t swizzle_format : 3; 1092 | // uint32_t normalize_mode : 1; 1093 | // } SceGxmTexture; 1094 | // 1095 | // typedef struct SceGxmColorSurface { 1096 | // unsigned int pbeSidebandWord; 1097 | // unsigned int pbeEmitWords[6]; 1098 | // unsigned int outputRegisterSize; 1099 | // SceGxmTexture backgroundTex; 1100 | // } SceGxmColorSurface; 1101 | // 1102 | // typedef struct SceGxmDepthStencilSurface { 1103 | // unsigned int zlsControl; 1104 | // void *depthData; 1105 | // void *stencilData; 1106 | // float backgroundDepth; 1107 | // unsigned int backgroundControl; 1108 | // } SceGxmDepthStencilSurface; 1109 | // 1110 | // //! Represents an auxiliary surface 1111 | // typedef struct SceGxmAuxiliarySurface { 1112 | // uint32_t colorFormat; //!< Format of auxiliary surface data from SceGxmColorFormat 1113 | // uint32_t type; //!< Memory layout of the surface data from SceGxmColorSurfaceType 1114 | // uint32_t width; //!< Surface width 1115 | // uint32_t height; //!< Surface height 1116 | // uint32_t stride; //!< Surface stride in bytes 1117 | // void *data; //!< A pointer to the surface data 1118 | // } SceGxmAuxiliarySurface; 1119 | // 1120 | // typedef struct SceGxmNotification { 1121 | // volatile unsigned int *address; 1122 | // unsigned int value; 1123 | // } SceGxmNotification; 1124 | // 1125 | // typedef struct SceGxmValidRegion { 1126 | // unsigned int xMin; 1127 | // unsigned int yMin; 1128 | // unsigned int xMax; 1129 | // unsigned int yMax; 1130 | // } SceGxmValidRegion; 1131 | // 1132 | // typedef struct SceGxmContext SceGxmContext; 1133 | // 1134 | // #define SCE_GXM_MINIMUM_CONTEXT_HOST_MEM_SIZE (2 * 1024) 1135 | // #define SCE_GXM_DEFAULT_PARAMETER_BUFFER_SIZE (16 * 1024 * 1024) 1136 | // #define SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE (128 * 1024) 1137 | // #define SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE (2 * 1024 * 1024) 1138 | // #define SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE (512 * 1024) 1139 | // #define SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE (16 * 1024) 1140 | // 1141 | // typedef struct SceGxmContextParams { 1142 | // void *hostMem; 1143 | // SceSize hostMemSize; 1144 | // void *vdmRingBufferMem; 1145 | // SceSize vdmRingBufferMemSize; 1146 | // void *vertexRingBufferMem; 1147 | // SceSize vertexRingBufferMemSize; 1148 | // void *fragmentRingBufferMem; 1149 | // SceSize fragmentRingBufferMemSize; 1150 | // void *fragmentUsseRingBufferMem; 1151 | // SceSize fragmentUsseRingBufferMemSize; 1152 | // unsigned int fragmentUsseRingBufferOffset; 1153 | // } SceGxmContextParams; 1154 | // 1155 | // typedef struct SceGxmVertexProgram SceGxmVertexProgram; 1156 | // 1157 | // typedef struct SceGxmFragmentProgram SceGxmFragmentProgram; 1158 | // 1159 | // typedef enum SceGxmPrecomputedWordCount { 1160 | // SCE_GXM_PRECOMPUTED_VERTEX_STATE_WORD_COUNT = 7, 1161 | // SCE_GXM_PRECOMPUTED_FRAGMENT_STATE_WORD_COUNT = 9, 1162 | // SCE_GXM_PRECOMPUTED_DRAW_WORD_COUNT = 11, 1163 | // } SceGxmPrecomputedWordCount; 1164 | // 1165 | // typedef struct SceGxmPrecomputedVertexState { 1166 | // unsigned int data[SCE_GXM_PRECOMPUTED_VERTEX_STATE_WORD_COUNT]; 1167 | // } SceGxmPrecomputedVertexState; 1168 | // 1169 | // typedef struct SceGxmPrecomputedFragmentState { 1170 | // unsigned int data[SCE_GXM_PRECOMPUTED_FRAGMENT_STATE_WORD_COUNT]; 1171 | // } SceGxmPrecomputedFragmentState; 1172 | // 1173 | // typedef struct SceGxmPrecomputedDraw { 1174 | // unsigned int data[SCE_GXM_PRECOMPUTED_DRAW_WORD_COUNT]; 1175 | // } SceGxmPrecomputedDraw; 1176 | // 1177 | // #define SCE_GXM_MAX_VERTEX_ATTRIBUTES 16 1178 | // #define SCE_GXM_MAX_VERTEX_STREAMS 4 1179 | // #define SCE_GXM_MAX_TEXTURE_UNITS 16 1180 | // #define SCE_GXM_MAX_UNIFORM_BUFFERS 8 1181 | // #define SCE_GXM_MAX_AUXILIARY_SURFACES 3 1182 | // 1183 | // #define SCE_GXM_TILE_SHIFTX 5U 1184 | // #define SCE_GXM_TILE_SHIFTY 5U 1185 | // #define SCE_GXM_TILE_SIZEX (1U << SCE_GXM_TILE_SHIFTX) 1186 | // #define SCE_GXM_TILE_SIZEY (1U << SCE_GXM_TILE_SHIFTY) 1187 | // 1188 | // #define SCE_GXM_COLOR_SURFACE_ALIGNMENT 4U 1189 | // #define SCE_GXM_TEXTURE_ALIGNMENT 16U 1190 | // #define SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT 16U 1191 | // #define SCE_GXM_PALETTE_ALIGNMENT 64U 1192 | // 1193 | // typedef struct SceGxmProgram SceGxmProgram; 1194 | // 1195 | // typedef struct SceGxmProgramParameter SceGxmProgramParameter; 1196 | // 1197 | // typedef enum SceGxmProgramType { 1198 | // SCE_GXM_VERTEX_PROGRAM, 1199 | // SCE_GXM_FRAGMENT_PROGRAM 1200 | // } SceGxmProgramType; 1201 | // 1202 | // typedef enum SceGxmParameterCategory { 1203 | // SCE_GXM_PARAMETER_CATEGORY_ATTRIBUTE, 1204 | // SCE_GXM_PARAMETER_CATEGORY_UNIFORM, 1205 | // SCE_GXM_PARAMETER_CATEGORY_SAMPLER, 1206 | // SCE_GXM_PARAMETER_CATEGORY_AUXILIARY_SURFACE, 1207 | // SCE_GXM_PARAMETER_CATEGORY_UNIFORM_BUFFER 1208 | // } SceGxmParameterCategory; 1209 | // 1210 | // typedef enum SceGxmParameterType { 1211 | // SCE_GXM_PARAMETER_TYPE_F32, 1212 | // SCE_GXM_PARAMETER_TYPE_F16, 1213 | // SCE_GXM_PARAMETER_TYPE_C10, 1214 | // SCE_GXM_PARAMETER_TYPE_U32, 1215 | // SCE_GXM_PARAMETER_TYPE_S32, 1216 | // SCE_GXM_PARAMETER_TYPE_U16, 1217 | // SCE_GXM_PARAMETER_TYPE_S16, 1218 | // SCE_GXM_PARAMETER_TYPE_U8, 1219 | // SCE_GXM_PARAMETER_TYPE_S8, 1220 | // SCE_GXM_PARAMETER_TYPE_AGGREGATE 1221 | // } SceGxmParameterType; 1222 | // 1223 | // typedef enum SceGxmParameterSemantic { 1224 | // SCE_GXM_PARAMETER_SEMANTIC_NONE, 1225 | // SCE_GXM_PARAMETER_SEMANTIC_ATTR, 1226 | // SCE_GXM_PARAMETER_SEMANTIC_BCOL, 1227 | // SCE_GXM_PARAMETER_SEMANTIC_BINORMAL, 1228 | // SCE_GXM_PARAMETER_SEMANTIC_BLENDINDICES, 1229 | // SCE_GXM_PARAMETER_SEMANTIC_BLENDWEIGHT, 1230 | // SCE_GXM_PARAMETER_SEMANTIC_COLOR, 1231 | // SCE_GXM_PARAMETER_SEMANTIC_DIFFUSE, 1232 | // SCE_GXM_PARAMETER_SEMANTIC_FOGCOORD, 1233 | // SCE_GXM_PARAMETER_SEMANTIC_NORMAL, 1234 | // SCE_GXM_PARAMETER_SEMANTIC_POINTSIZE, 1235 | // SCE_GXM_PARAMETER_SEMANTIC_POSITION, 1236 | // SCE_GXM_PARAMETER_SEMANTIC_SPECULAR, 1237 | // SCE_GXM_PARAMETER_SEMANTIC_TANGENT, 1238 | // SCE_GXM_PARAMETER_SEMANTIC_TEXCOORD 1239 | // } SceGxmParameterSemantic; 1240 | // 1241 | // typedef struct SceGxmShaderPatcher SceGxmShaderPatcher; 1242 | // 1243 | // typedef struct SceGxmRegisteredProgram SceGxmRegisteredProgram; 1244 | // 1245 | // typedef SceGxmRegisteredProgram *SceGxmShaderPatcherId; 1246 | // 1247 | // typedef void *(SceGxmShaderPatcherHostAllocCallback)(void *userData, SceSize size); 1248 | // typedef void (SceGxmShaderPatcherHostFreeCallback)(void *userData, void *mem); 1249 | // typedef void *(SceGxmShaderPatcherBufferAllocCallback)(void *userData, SceSize size); 1250 | // typedef void (SceGxmShaderPatcherBufferFreeCallback)(void *userData, void *mem); 1251 | // typedef void *(SceGxmShaderPatcherUsseAllocCallback)(void *userData, SceSize size, unsigned int *usseOffset); 1252 | // typedef void (SceGxmShaderPatcherUsseFreeCallback)(void *userData, void *mem); 1253 | // 1254 | // typedef struct SceGxmShaderPatcherParams { 1255 | // void *userData; 1256 | // SceGxmShaderPatcherHostAllocCallback *hostAllocCallback; 1257 | // SceGxmShaderPatcherHostFreeCallback *hostFreeCallback; 1258 | // SceGxmShaderPatcherBufferAllocCallback *bufferAllocCallback; 1259 | // SceGxmShaderPatcherBufferFreeCallback *bufferFreeCallback; 1260 | // void *bufferMem; 1261 | // SceSize bufferMemSize; 1262 | // SceGxmShaderPatcherUsseAllocCallback *vertexUsseAllocCallback; 1263 | // SceGxmShaderPatcherUsseFreeCallback *vertexUsseFreeCallback; 1264 | // void *vertexUsseMem; 1265 | // SceSize vertexUsseMemSize; 1266 | // unsigned int vertexUsseOffset; 1267 | // SceGxmShaderPatcherUsseAllocCallback *fragmentUsseAllocCallback; 1268 | // SceGxmShaderPatcherUsseFreeCallback *fragmentUsseFreeCallback; 1269 | // void *fragmentUsseMem; 1270 | // SceSize fragmentUsseMemSize; 1271 | // unsigned int fragmentUsseOffset; 1272 | // } SceGxmShaderPatcherParams; 1273 | // 1274 | // typedef enum SceGxmRenderTargetFlags { 1275 | // SCE_GXM_RENDER_TARGET_CUSTOM_MULTISAMPLE_LOCATIONS = (1 << 0) 1276 | // } SceGxmRenderTargetFlags; 1277 | // 1278 | // typedef struct SceGxmRenderTargetParams { 1279 | // uint32_t flags; //!< Bitwise combined flags from ::SceGxmRenderTargetFlags. 1280 | // uint16_t width; //!< The width of the render target in pixels. 1281 | // uint16_t height; //!< The height of the render target in pixels. 1282 | // uint16_t scenesPerFrame; //!< The expected number of scenes per frame, in the range [1,SCE_GXM_MAX_SCENES_PER_RENDERTARGET]. 1283 | // uint16_t multisampleMode; //!< A value from the #SceGxmMultisampleMode enum. 1284 | // uint32_t multisampleLocations; //!< If enabled in the flags, the multisample locations to use. 1285 | // SceUID driverMemBlock; //!< The uncached LPDDR memblock for the render target GPU data structures or SCE_UID_INVALID_UID to specify memory should be allocated in libgxm. 1286 | // } SceGxmRenderTargetParams; 1287 | // 1288 | // /* prototypes */ 1289 | // 1290 | // int sceGxmInitialize(const SceGxmInitializeParams *params); 1291 | // int sceGxmTerminate(); 1292 | // 1293 | // volatile unsigned int *sceGxmGetNotificationRegion(); 1294 | // int sceGxmNotificationWait(const SceGxmNotification *notification); 1295 | // 1296 | // int sceGxmMapMemory(void *base, SceSize size, SceGxmMemoryAttribFlags attr); 1297 | // int sceGxmUnmapMemory(void *base); 1298 | // 1299 | // int sceGxmMapVertexUsseMemory(void *base, SceSize size, unsigned int *offset); 1300 | // int sceGxmUnmapVertexUsseMemory(void *base); 1301 | // 1302 | // int sceGxmMapFragmentUsseMemory(void *base, SceSize size, unsigned int *offset); 1303 | // int sceGxmUnmapFragmentUsseMemory(void *base); 1304 | // 1305 | // int sceGxmDisplayQueueAddEntry(SceGxmSyncObject *oldBuffer, SceGxmSyncObject *newBuffer, const void *callbackData); 1306 | // int sceGxmDisplayQueueFinish(); 1307 | // 1308 | // int sceGxmSyncObjectCreate(SceGxmSyncObject **syncObject); 1309 | // int sceGxmSyncObjectDestroy(SceGxmSyncObject *syncObject); 1310 | // 1311 | // int sceGxmCreateContext(const SceGxmContextParams *params, SceGxmContext **context); 1312 | // int sceGxmDestroyContext(SceGxmContext *context); 1313 | // 1314 | // void sceGxmSetValidationEnable(SceGxmContext *context, SceBool enable); 1315 | // 1316 | // void sceGxmSetVertexProgram(SceGxmContext *context, const SceGxmVertexProgram *vertexProgram); 1317 | // void sceGxmSetFragmentProgram(SceGxmContext *context, const SceGxmFragmentProgram *fragmentProgram); 1318 | // 1319 | // int sceGxmReserveVertexDefaultUniformBuffer(SceGxmContext *context, void **uniformBuffer); 1320 | // int sceGxmReserveFragmentDefaultUniformBuffer(SceGxmContext *context, void **uniformBuffer); 1321 | // 1322 | // int sceGxmSetVertexStream(SceGxmContext *context, unsigned int streamIndex, const void *streamData); 1323 | // int sceGxmSetVertexTexture(SceGxmContext *context, unsigned int textureIndex, const SceGxmTexture *texture); 1324 | // int sceGxmSetFragmentTexture(SceGxmContext *context, unsigned int textureIndex, const SceGxmTexture *texture); 1325 | // int sceGxmSetVertexUniformBuffer(SceGxmContext *context, unsigned int bufferIndex, const void *bufferData); 1326 | // int sceGxmSetFragmentUniformBuffer(SceGxmContext *context, unsigned int bufferIndex, const void *bufferData); 1327 | // int sceGxmSetAuxiliarySurface(SceGxmContext *context, unsigned int surfaceIndex, const SceGxmAuxiliarySurface *surface); 1328 | // 1329 | // void sceGxmSetPrecomputedFragmentState(SceGxmContext *context, const SceGxmPrecomputedFragmentState *precomputedState); 1330 | // void sceGxmSetPrecomputedVertexState(SceGxmContext *context, const SceGxmPrecomputedVertexState *precomputedState); 1331 | // 1332 | // int sceGxmDrawPrecomputed(SceGxmContext *context, const SceGxmPrecomputedDraw *precomputedDraw); 1333 | // int sceGxmDraw(SceGxmContext *context, SceGxmPrimitiveType primType, SceGxmIndexFormat indexType, const void *indexData, unsigned int indexCount); 1334 | // int sceGxmDrawInstanced(SceGxmContext *context, SceGxmPrimitiveType primType, SceGxmIndexFormat indexType, const void *indexData, unsigned int indexCount, unsigned int indexWrap); 1335 | // int sceGxmSetVisibilityBuffer(SceGxmContext *context, void *bufferBase, unsigned int stridePerCore); 1336 | // 1337 | // int sceGxmBeginScene(SceGxmContext *context, unsigned int flags, const SceGxmRenderTarget *renderTarget, const SceGxmValidRegion *validRegion, SceGxmSyncObject *vertexSyncObject, SceGxmSyncObject *fragmentSyncObject, const SceGxmColorSurface *colorSurface, const SceGxmDepthStencilSurface *depthStencil); 1338 | // int sceGxmMidSceneFlush(SceGxmContext *context, unsigned int flags, SceGxmSyncObject *vertexSyncObject, const SceGxmNotification *vertexNotification); 1339 | // int sceGxmEndScene(SceGxmContext *context, const SceGxmNotification *vertexNotification, const SceGxmNotification *fragmentNotification); 1340 | // 1341 | // void sceGxmSetFrontDepthFunc(SceGxmContext *context, SceGxmDepthFunc depthFunc); 1342 | // void sceGxmSetBackDepthFunc(SceGxmContext *context, SceGxmDepthFunc depthFunc); 1343 | // void sceGxmSetFrontFragmentProgramEnable(SceGxmContext *context, SceGxmFragmentProgramMode enable); 1344 | // void sceGxmSetBackFragmentProgramEnable(SceGxmContext *context, SceGxmFragmentProgramMode enable); 1345 | // void sceGxmSetFrontDepthWriteEnable(SceGxmContext *context, SceGxmDepthWriteMode enable); 1346 | // void sceGxmSetBackDepthWriteEnable(SceGxmContext *context, SceGxmDepthWriteMode enable); 1347 | // void sceGxmSetFrontLineFillLastPixelEnable(SceGxmContext *context, SceGxmLineFillLastPixelMode enable); 1348 | // void sceGxmSetBackLineFillLastPixelEnable(SceGxmContext *context, SceGxmLineFillLastPixelMode enable); 1349 | // void sceGxmSetFrontStencilRef(SceGxmContext *context, unsigned int sref); 1350 | // void sceGxmSetBackStencilRef(SceGxmContext *context, unsigned int sref); 1351 | // void sceGxmSetFrontPointLineWidth(SceGxmContext *context, unsigned int width); 1352 | // void sceGxmSetBackPointLineWidth(SceGxmContext *context, unsigned int width); 1353 | // void sceGxmSetFrontPolygonMode(SceGxmContext *context, SceGxmPolygonMode mode); 1354 | // void sceGxmSetBackPolygonMode(SceGxmContext *context, SceGxmPolygonMode mode); 1355 | // void sceGxmSetFrontStencilFunc(SceGxmContext *context, SceGxmStencilFunc func, SceGxmStencilOp stencilFail, SceGxmStencilOp depthFail, SceGxmStencilOp depthPass, unsigned char compareMask, unsigned char writeMask); 1356 | // void sceGxmSetBackStencilFunc(SceGxmContext *context, SceGxmStencilFunc func, SceGxmStencilOp stencilFail, SceGxmStencilOp depthFail, SceGxmStencilOp depthPass, unsigned char compareMask, unsigned char writeMask); 1357 | // void sceGxmSetFrontDepthBias(SceGxmContext *context, int factor, int units); 1358 | // void sceGxmSetBackDepthBias(SceGxmContext *context, int factor, int units); 1359 | // void sceGxmSetTwoSidedEnable(SceGxmContext *context, SceGxmTwoSidedMode enable); 1360 | // void sceGxmSetViewport(SceGxmContext *context, float xOffset, float xScale, float yOffset, float yScale, float zOffset, float zScale); 1361 | // void sceGxmSetWClampValue(SceGxmContext *context, float clampValue); 1362 | // void sceGxmSetWClampEnable(SceGxmContext *context, SceGxmWClampMode enable); 1363 | // void sceGxmSetRegionClip(SceGxmContext *context, SceGxmRegionClipMode mode, unsigned int xMin, unsigned int yMin, unsigned int xMax, unsigned int yMax); 1364 | // void sceGxmSetCullMode(SceGxmContext *context, SceGxmCullMode mode); 1365 | // void sceGxmSetViewportEnable(SceGxmContext *context, SceGxmViewportMode enable); 1366 | // void sceGxmSetWBufferEnable(SceGxmContext *context, SceGxmWBufferMode enable); 1367 | // void sceGxmSetFrontVisibilityTestIndex(SceGxmContext *context, unsigned int index); 1368 | // void sceGxmSetBackVisibilityTestIndex(SceGxmContext *context, unsigned int index); 1369 | // void sceGxmSetFrontVisibilityTestOp(SceGxmContext *context, SceGxmVisibilityTestOp op); 1370 | // void sceGxmSetBackVisibilityTestOp(SceGxmContext *context, SceGxmVisibilityTestOp op); 1371 | // void sceGxmSetFrontVisibilityTestEnable(SceGxmContext *context, SceGxmVisibilityTestMode enable); 1372 | // void sceGxmSetBackVisibilityTestEnable(SceGxmContext *context, SceGxmVisibilityTestMode enable); 1373 | // 1374 | // void sceGxmFinish(SceGxmContext *context); 1375 | // 1376 | // int sceGxmPushUserMarker(SceGxmContext *context, const char *tag); 1377 | // int sceGxmPopUserMarker(SceGxmContext *context); 1378 | // int sceGxmSetUserMarker(SceGxmContext *context, const char *tag); 1379 | // 1380 | // int sceGxmPadHeartbeat(const SceGxmColorSurface *displaySurface, SceGxmSyncObject *displaySyncObject); 1381 | // 1382 | // int sceGxmPadTriggerGpuPaTrace(); 1383 | // 1384 | // int sceGxmColorSurfaceInit(SceGxmColorSurface *surface, SceGxmColorFormat colorFormat, SceGxmColorSurfaceType surfaceType, SceGxmColorSurfaceScaleMode scaleMode, SceGxmOutputRegisterSize outputRegisterSize, unsigned int width, unsigned int height, unsigned int strideInPixels, void *data); 1385 | // int sceGxmColorSurfaceInitDisabled(SceGxmColorSurface *surface); 1386 | // SceBool sceGxmColorSurfaceIsEnabled(const SceGxmColorSurface *surface); 1387 | // void sceGxmColorSurfaceGetClip(const SceGxmColorSurface *surface, unsigned int *xMin, unsigned int *yMin, unsigned int *xMax, unsigned int *yMax); 1388 | // void sceGxmColorSurfaceSetClip(SceGxmColorSurface *surface, unsigned int xMin, unsigned int yMin, unsigned int xMax, unsigned int yMax); 1389 | // 1390 | // SceGxmColorSurfaceScaleMode sceGxmColorSurfaceGetScaleMode(const SceGxmColorSurface *surface); 1391 | // void sceGxmColorSurfaceSetScaleMode(SceGxmColorSurface *surface, SceGxmColorSurfaceScaleMode scaleMode); 1392 | // 1393 | // void *sceGxmColorSurfaceGetData(const SceGxmColorSurface *surface); 1394 | // int sceGxmColorSurfaceSetData(SceGxmColorSurface *surface, void *data); 1395 | // 1396 | // SceGxmColorFormat sceGxmColorSurfaceGetFormat(const SceGxmColorSurface *surface); 1397 | // int sceGxmColorSurfaceSetFormat(SceGxmColorSurface *surface, SceGxmColorFormat format); 1398 | // SceGxmColorSurfaceType sceGxmColorSurfaceGetType(const SceGxmColorSurface *surface); 1399 | // unsigned int sceGxmColorSurfaceGetStrideInPixels(const SceGxmColorSurface *surface); 1400 | // 1401 | // int sceGxmDepthStencilSurfaceInit(SceGxmDepthStencilSurface *surface, SceGxmDepthStencilFormat depthStencilFormat, SceGxmDepthStencilSurfaceType surfaceType, unsigned int strideInSamples, void *depthData, void *stencilData); 1402 | // int sceGxmDepthStencilSurfaceInitDisabled(SceGxmDepthStencilSurface *surface); 1403 | // float sceGxmDepthStencilSurfaceGetBackgroundDepth(const SceGxmDepthStencilSurface *surface); 1404 | // void sceGxmDepthStencilSurfaceSetBackgroundDepth(SceGxmDepthStencilSurface *surface, float backgroundDepth); 1405 | // unsigned char sceGxmDepthStencilSurfaceGetBackgroundStencil(const SceGxmDepthStencilSurface *surface); 1406 | // void sceGxmDepthStencilSurfaceSetBackgroundStencil(SceGxmDepthStencilSurface *surface, unsigned char backgroundStencil); 1407 | // SceBool sceGxmDepthStencilSurfaceIsEnabled(const SceGxmDepthStencilSurface *surface); 1408 | // void sceGxmDepthStencilSurfaceSetForceLoadMode(SceGxmDepthStencilSurface *surface, SceGxmDepthStencilForceLoadMode forceLoad); 1409 | // SceGxmDepthStencilForceLoadMode sceGxmDepthStencilSurfaceGetForceLoadMode(const SceGxmDepthStencilSurface *surface); 1410 | // void sceGxmDepthStencilSurfaceSetForceStoreMode(SceGxmDepthStencilSurface *surface, SceGxmDepthStencilForceStoreMode forceStore); 1411 | // SceGxmDepthStencilForceStoreMode sceGxmDepthStencilSurfaceGetForceStoreMode(const SceGxmDepthStencilSurface *surface); 1412 | // 1413 | // SceGxmColorSurfaceGammaMode sceGxmColorSurfaceGetGammaMode(const SceGxmColorSurface *surface); 1414 | // int sceGxmColorSurfaceSetGammaMode(SceGxmColorSurface *surface, SceGxmColorSurfaceGammaMode gammaMode); 1415 | // SceGxmColorSurfaceDitherMode sceGxmColorSurfaceGetDitherMode(const SceGxmColorSurface *surface); 1416 | // int sceGxmColorSurfaceSetDitherMode(SceGxmColorSurface *surface, SceGxmColorSurfaceDitherMode ditherMode); 1417 | // 1418 | // SceGxmDepthStencilFormat sceGxmDepthStencilSurfaceGetFormat(const SceGxmDepthStencilSurface *surface); 1419 | // unsigned int sceGxmDepthStencilSurfaceGetStrideInSamples(const SceGxmDepthStencilSurface *surface); 1420 | // 1421 | // int sceGxmProgramCheck(const SceGxmProgram *program); 1422 | // unsigned int sceGxmProgramGetSize(const SceGxmProgram *program); 1423 | // SceGxmProgramType sceGxmProgramGetType(const SceGxmProgram *program); 1424 | // SceBool sceGxmProgramIsDiscardUsed(const SceGxmProgram *program); 1425 | // SceBool sceGxmProgramIsDepthReplaceUsed(const SceGxmProgram *program); 1426 | // SceBool sceGxmProgramIsSpriteCoordUsed(const SceGxmProgram *program); 1427 | // unsigned int sceGxmProgramGetDefaultUniformBufferSize(const SceGxmProgram *program); 1428 | // unsigned int sceGxmProgramGetParameterCount(const SceGxmProgram *program); 1429 | // 1430 | // const SceGxmProgramParameter *sceGxmProgramGetParameter(const SceGxmProgram *program, unsigned int index); 1431 | // const SceGxmProgramParameter *sceGxmProgramFindParameterByName(const SceGxmProgram *program, const char *name); 1432 | // const SceGxmProgramParameter *sceGxmProgramFindParameterBySemantic(const SceGxmProgram *program, SceGxmParameterSemantic semantic, unsigned int index); 1433 | // unsigned int sceGxmProgramParameterGetIndex(const SceGxmProgram *program, const SceGxmProgramParameter *parameter); 1434 | // SceGxmParameterCategory sceGxmProgramParameterGetCategory(const SceGxmProgramParameter *parameter); 1435 | // const char *sceGxmProgramParameterGetName(const SceGxmProgramParameter *parameter); 1436 | // SceGxmParameterSemantic sceGxmProgramParameterGetSemantic(const SceGxmProgramParameter *parameter); 1437 | // unsigned int sceGxmProgramParameterGetSemanticIndex(const SceGxmProgramParameter *parameter); 1438 | // SceGxmParameterType sceGxmProgramParameterGetType(const SceGxmProgramParameter *parameter); 1439 | // unsigned int sceGxmProgramParameterGetComponentCount(const SceGxmProgramParameter *parameter); 1440 | // unsigned int sceGxmProgramParameterGetArraySize(const SceGxmProgramParameter *parameter); 1441 | // unsigned int sceGxmProgramParameterGetResourceIndex(const SceGxmProgramParameter *parameter); 1442 | // unsigned int sceGxmProgramParameterGetContainerIndex(const SceGxmProgramParameter *parameter); 1443 | // SceBool sceGxmProgramParameterIsSamplerCube(const SceGxmProgramParameter *parameter); 1444 | // 1445 | // const SceGxmProgram *sceGxmFragmentProgramGetProgram(const SceGxmFragmentProgram *fragmentProgram); 1446 | // const SceGxmProgram *sceGxmVertexProgramGetProgram(const SceGxmVertexProgram *vertexProgram); 1447 | // 1448 | // int sceGxmShaderPatcherCreate(const SceGxmShaderPatcherParams *params, SceGxmShaderPatcher **shaderPatcher); 1449 | // int sceGxmShaderPatcherSetUserData(SceGxmShaderPatcher *shaderPatcher, void *userData); 1450 | // void *sceGxmShaderPatcherGetUserData(SceGxmShaderPatcher *shaderPatcher); 1451 | // int sceGxmShaderPatcherDestroy(SceGxmShaderPatcher *shaderPatcher); 1452 | // int sceGxmShaderPatcherRegisterProgram(SceGxmShaderPatcher *shaderPatcher, const SceGxmProgram *programHeader, SceGxmShaderPatcherId *programId); 1453 | // int sceGxmShaderPatcherUnregisterProgram(SceGxmShaderPatcher *shaderPatcher, SceGxmShaderPatcherId programId); 1454 | // int sceGxmShaderPatcherForceUnregisterProgram(SceGxmShaderPatcher *shaderPatcher, SceGxmShaderPatcherId programId); 1455 | // const SceGxmProgram *sceGxmShaderPatcherGetProgramFromId(SceGxmShaderPatcherId programId); 1456 | // int sceGxmShaderPatcherSetAuxiliarySurface(SceGxmShaderPatcher *shaderPatcher, unsigned int auxSurfaceIndex, const SceGxmAuxiliarySurface *auxSurface); 1457 | // int sceGxmShaderPatcherCreateVertexProgram(SceGxmShaderPatcher *shaderPatcher, SceGxmShaderPatcherId programId, const SceGxmVertexAttribute *attributes, unsigned int attributeCount, const SceGxmVertexStream *streams, unsigned int streamCount, SceGxmVertexProgram **vertexProgram); 1458 | // int sceGxmShaderPatcherCreateFragmentProgram(SceGxmShaderPatcher *shaderPatcher, SceGxmShaderPatcherId programId, SceGxmOutputRegisterFormat outputFormat, SceGxmMultisampleMode multisampleMode, const SceGxmBlendInfo *blendInfo, const SceGxmProgram *vertexProgram, SceGxmFragmentProgram **fragmentProgram); 1459 | // int sceGxmShaderPatcherAddRefVertexProgram(SceGxmShaderPatcher *shaderPatcher, SceGxmVertexProgram *vertexProgram); 1460 | // int sceGxmShaderPatcherAddRefFragmentProgram(SceGxmShaderPatcher *shaderPatcher, SceGxmFragmentProgram *fragmentProgram); 1461 | // int sceGxmShaderPatcherReleaseVertexProgram(SceGxmShaderPatcher *shaderPatcher, SceGxmVertexProgram *vertexProgram); 1462 | // int sceGxmShaderPatcherReleaseFragmentProgram(SceGxmShaderPatcher *shaderPatcher, SceGxmFragmentProgram *fragmentProgram); 1463 | // unsigned int sceGxmShaderPatcherGetHostMemAllocated(const SceGxmShaderPatcher *shaderPatcher); 1464 | // unsigned int sceGxmShaderPatcherGetBufferMemAllocated(const SceGxmShaderPatcher *shaderPatcher); 1465 | // unsigned int sceGxmShaderPatcherGetVertexUsseMemAllocated(const SceGxmShaderPatcher *shaderPatcher); 1466 | // unsigned int sceGxmShaderPatcherGetFragmentUsseMemAllocated(const SceGxmShaderPatcher *shaderPatcher); 1467 | // 1468 | // int sceGxmTextureInitSwizzled(SceGxmTexture *texture, const void *data, SceGxmTextureFormat texFormat, unsigned int width, unsigned int height, unsigned int mipCount); 1469 | // int sceGxmTextureInitLinear(SceGxmTexture *texture, const void *data, SceGxmTextureFormat texFormat, unsigned int width, unsigned int height, unsigned int mipCount); 1470 | // int sceGxmTextureInitLinearStrided(SceGxmTexture *texture, const void *data, SceGxmTextureFormat texFormat, unsigned int width, unsigned int height, unsigned int byteStride); 1471 | // int sceGxmTextureInitTiled(SceGxmTexture *texture, const void *data, SceGxmTextureFormat texFormat, unsigned int width, unsigned int height, unsigned int mipCount); 1472 | // int sceGxmTextureInitCube(SceGxmTexture *texture, const void *data, SceGxmTextureFormat texFormat, unsigned int width, unsigned int height, unsigned int mipCount); 1473 | // 1474 | // SceGxmTextureType sceGxmTextureGetType(const SceGxmTexture *texture); 1475 | // 1476 | // int sceGxmTextureSetMinFilter(SceGxmTexture *texture, SceGxmTextureFilter minFilter); 1477 | // SceGxmTextureFilter sceGxmTextureGetMinFilter(const SceGxmTexture *texture); 1478 | // 1479 | // int sceGxmTextureSetMagFilter(SceGxmTexture *texture, SceGxmTextureFilter magFilter); 1480 | // SceGxmTextureFilter sceGxmTextureGetMagFilter(const SceGxmTexture *texture); 1481 | // 1482 | // int sceGxmTextureSetMipFilter(SceGxmTexture *texture, SceGxmTextureMipFilter mipFilter); 1483 | // SceGxmTextureMipFilter sceGxmTextureGetMipFilter(const SceGxmTexture *texture); 1484 | // 1485 | // int sceGxmTextureSetUAddrMode(SceGxmTexture *texture, SceGxmTextureAddrMode addrMode); 1486 | // SceGxmTextureAddrMode sceGxmTextureGetUAddrMode(const SceGxmTexture *texture); 1487 | // 1488 | // int sceGxmTextureSetVAddrMode(SceGxmTexture *texture, SceGxmTextureAddrMode addrMode); 1489 | // SceGxmTextureAddrMode sceGxmTextureGetVAddrMode(const SceGxmTexture *texture); 1490 | // 1491 | // int sceGxmTextureSetFormat(SceGxmTexture *texture, SceGxmTextureFormat texFormat); 1492 | // SceGxmTextureFormat sceGxmTextureGetFormat(const SceGxmTexture *texture); 1493 | // 1494 | // int sceGxmTextureSetLodBias(SceGxmTexture *texture, unsigned int bias); 1495 | // unsigned int sceGxmTextureGetLodBias(const SceGxmTexture *texture); 1496 | // 1497 | // int sceGxmTextureSetStride(SceGxmTexture *texture, unsigned int byteStride); 1498 | // unsigned int sceGxmTextureGetStride(const SceGxmTexture *texture); 1499 | // 1500 | // int sceGxmTextureSetWidth(SceGxmTexture *texture, unsigned int width); 1501 | // unsigned int sceGxmTextureGetWidth(const SceGxmTexture *texture); 1502 | // 1503 | // int sceGxmTextureSetHeight(SceGxmTexture *texture, unsigned int height); 1504 | // unsigned int sceGxmTextureGetHeight(const SceGxmTexture *texture); 1505 | // 1506 | // int sceGxmTextureSetData(SceGxmTexture *texture, const void *data); 1507 | // void *sceGxmTextureGetData(const SceGxmTexture *texture); 1508 | // 1509 | // int sceGxmTextureSetMipmapCount(SceGxmTexture *texture, unsigned int mipCount); 1510 | // unsigned int sceGxmTextureGetMipmapCount(const SceGxmTexture *texture); 1511 | // 1512 | // int sceGxmTextureSetPalette(SceGxmTexture *texture, const void *paletteData); 1513 | // void *sceGxmTextureGetPalette(const SceGxmTexture *texture); 1514 | // 1515 | // SceGxmTextureGammaMode sceGxmTextureGetGammaMode(const SceGxmTexture *texture); 1516 | // int sceGxmTextureSetGammaMode(SceGxmTexture *texture, SceGxmTextureGammaMode gammaMode); 1517 | // 1518 | // unsigned int sceGxmGetPrecomputedVertexStateSize(const SceGxmVertexProgram *vertexProgram); 1519 | // int sceGxmPrecomputedVertexStateInit(SceGxmPrecomputedVertexState *precomputedState, const SceGxmVertexProgram *vertexProgram, void *memBlock); 1520 | // void sceGxmPrecomputedVertexStateSetDefaultUniformBuffer(SceGxmPrecomputedVertexState *precomputedState, void *defaultBuffer); 1521 | // void *sceGxmPrecomputedVertexStateGetDefaultUniformBuffer(const SceGxmPrecomputedVertexState *precomputedState); 1522 | // int sceGxmPrecomputedVertexStateSetAllTextures(SceGxmPrecomputedVertexState *precomputedState, const SceGxmTexture *textures); 1523 | // int sceGxmPrecomputedVertexStateSetTexture(SceGxmPrecomputedVertexState *precomputedState, unsigned int textureIndex, const SceGxmTexture *texture); 1524 | // int sceGxmPrecomputedVertexStateSetAllUniformBuffers(SceGxmPrecomputedVertexState *precomputedState, const void * const *bufferDataArray); 1525 | // int sceGxmPrecomputedVertexStateSetUniformBuffer(SceGxmPrecomputedVertexState *precomputedState, unsigned int bufferIndex, const void *bufferData); 1526 | // unsigned int sceGxmGetPrecomputedFragmentStateSize(const SceGxmFragmentProgram *fragmentProgram); 1527 | // int sceGxmPrecomputedFragmentStateInit(SceGxmPrecomputedFragmentState *precomputedState, const SceGxmFragmentProgram *fragmentProgram, void *memBlock); 1528 | // void sceGxmPrecomputedFragmentStateSetDefaultUniformBuffer(SceGxmPrecomputedFragmentState *precomputedState, void *defaultBuffer); 1529 | // void *sceGxmPrecomputedFragmentStateGetDefaultUniformBuffer(const SceGxmPrecomputedFragmentState *precomputedState); 1530 | // int sceGxmPrecomputedFragmentStateSetAllTextures(SceGxmPrecomputedFragmentState *precomputedState, const SceGxmTexture *textureArray); 1531 | // int sceGxmPrecomputedFragmentStateSetTexture(SceGxmPrecomputedFragmentState *precomputedState, unsigned int textureIndex, const SceGxmTexture *texture); 1532 | // int sceGxmPrecomputedFragmentStateSetAllUniformBuffers(SceGxmPrecomputedFragmentState *precomputedState, const void * const *bufferDataArray); 1533 | // int sceGxmPrecomputedFragmentStateSetUniformBuffer(SceGxmPrecomputedFragmentState *precomputedState, unsigned int bufferIndex, const void *bufferData); 1534 | // int sceGxmPrecomputedFragmentStateSetAllAuxiliarySurfaces(SceGxmPrecomputedFragmentState *precomputedState, const SceGxmAuxiliarySurface *auxSurfaceArray); 1535 | // unsigned int sceGxmGetPrecomputedDrawSize(const SceGxmVertexProgram *vertexProgram); 1536 | // int sceGxmPrecomputedDrawInit(SceGxmPrecomputedDraw *precomputedDraw, const SceGxmVertexProgram *vertexProgram, void *memBlock); 1537 | // int sceGxmPrecomputedDrawSetAllVertexStreams(SceGxmPrecomputedDraw *precomputedDraw, const void * const *streamDataArray); 1538 | // int sceGxmPrecomputedDrawSetVertexStream(SceGxmPrecomputedDraw *precomputedDraw, unsigned int streamIndex, const void *streamData); 1539 | // void sceGxmPrecomputedDrawSetParams(SceGxmPrecomputedDraw *precomputedDraw, SceGxmPrimitiveType primType, SceGxmIndexFormat indexType, const void *indexData, unsigned int indexCount); 1540 | // void sceGxmPrecomputedDrawSetParamsInstanced(SceGxmPrecomputedDraw *precomputedDraw, SceGxmPrimitiveType primType, SceGxmIndexFormat indexType, const void *indexData, unsigned int indexCount, unsigned int indexWrap); 1541 | // 1542 | // int sceGxmGetRenderTargetMemSizes(const SceGxmRenderTargetParams *params, unsigned int *hostMemSize, unsigned int *driverMemSize); 1543 | // int sceGxmCreateRenderTarget(const SceGxmRenderTargetParams *params, SceGxmRenderTarget **renderTarget); 1544 | // int sceGxmRenderTargetGetHostMem(const SceGxmRenderTarget *renderTarget, void **hostMem); 1545 | // int sceGxmRenderTargetGetDriverMemBlock(const SceGxmRenderTarget *renderTarget, SceUID *driverMemBlock); 1546 | // int sceGxmDestroyRenderTarget(SceGxmRenderTarget *renderTarget); 1547 | // 1548 | // int sceGxmSetUniformDataF(void *uniformBuffer, const SceGxmProgramParameter *parameter, unsigned int componentOffset, unsigned int componentCount, const float *sourceData); 1549 | // 1550 | // int sceGxmTransferCopy(uint32_t width, uint32_t height, uint32_t colorKeyValue, uint32_t colorKeyMask, SceGxmTransferColorKeyMode colorKeyMode, SceGxmTransferFormat srcFormat, SceGxmTransferType srcType, const void *srcAddress, uint32_t srcX, uint32_t srcY, int32_t srcStride, SceGxmTransferFormat destFormat, SceGxmTransferType destType, void *destAddress, uint32_t destX, uint32_t destY, int32_t destStride, SceGxmSyncObject *syncObject, uint32_t syncFlags, const SceGxmNotification *notification); 1551 | // int sceGxmTransferDownscale(SceGxmTransferFormat srcFormat, const void *srcAddress, unsigned int srcX, unsigned int srcY, unsigned int srcWidth, unsigned int srcHeight, int srcStride, SceGxmTransferFormat destFormat, void *destAddress, unsigned int destX, unsigned int destY, int destStride, SceGxmSyncObject *syncObject, unsigned int syncFlags, const SceGxmNotification* notification); 1552 | // int sceGxmTransferFinish(void); 1553 | --------------------------------------------------------------------------------