diff --git a/citro3d/Cargo.toml b/citro3d/Cargo.toml index 8bdaf3f..70eca7f 100644 --- a/citro3d/Cargo.toml +++ b/citro3d/Cargo.toml @@ -7,7 +7,6 @@ edition = "2021" bitflags = "1.3.2" bytemuck = { version = "1.10.0", features = ["extern_crate_std"] } citro3d-sys = { git = "https://github.com/ian-h-chamberlain/citro3d-rs.git" } -ctru-rs = { git = "https://github.com/Meziu/ctru-rs.git" } +ctru-rs = { git = "https://github.com/rust3ds/ctru-rs.git" } +ctru-sys = { git = "https://github.com/rust3ds/ctru-rs.git" } libc = "0.2.125" - -[dev-dependencies] diff --git a/citro3d/src/lib.rs b/citro3d/src/lib.rs index 7d27f4f..0f9501f 100644 --- a/citro3d/src/lib.rs +++ b/citro3d/src/lib.rs @@ -25,7 +25,7 @@ impl Instance { /// /// Fails if `citro3d` cannot be initialized. pub fn new() -> Result { - Self::with_cmdbuf_size(citro3d_sys::C3D_DEFAULT_CMDBUF_SIZE) + Self::with_cmdbuf_size(citro3d_sys::C3D_DEFAULT_CMDBUF_SIZE.try_into().unwrap()) } /// Initialize the instance with a specified command buffer size. @@ -33,7 +33,7 @@ impl Instance { /// # Errors /// /// Fails if `citro3d` cannot be initialized. - pub fn with_cmdbuf_size(size: u32) -> Result { + pub fn with_cmdbuf_size(size: usize) -> Result { if unsafe { citro3d_sys::C3D_Init(size) } { Ok(Self) } else { diff --git a/citro3d/src/render.rs b/citro3d/src/render.rs index dcd7fa3..56d83f5 100644 --- a/citro3d/src/render.rs +++ b/citro3d/src/render.rs @@ -2,11 +2,11 @@ //! of data to the GPU, including the format of color and depth data to be rendered. use citro3d_sys::{ - C3D_RenderTarget, C3D_RenderTargetCreate, C3D_RenderTargetDelete, C3D_DEPTHTYPE, GPU_COLORBUF, - GPU_DEPTHBUF, + C3D_RenderTarget, C3D_RenderTargetCreate, C3D_RenderTargetDelete, C3D_DEPTHTYPE, }; use ctru::gfx; use ctru::services::gspgpu::FramebufferFormat; +use ctru_sys::{GPU_COLORBUF, GPU_DEPTHBUF}; use crate::{Error, Result}; @@ -103,15 +103,15 @@ bitflags::bitflags! { #[derive(Clone, Copy, Debug)] pub enum ColorFormat { /// 8-bit Red + 8-bit Green + 8-bit Blue + 8-bit Alpha. - RGBA8 = citro3d_sys::GPU_RB_RGBA8, + RGBA8 = ctru_sys::GPU_RB_RGBA8, /// 8-bit Red + 8-bit Green + 8-bit Blue. - RGB8 = citro3d_sys::GPU_RB_RGB8, + RGB8 = ctru_sys::GPU_RB_RGB8, /// 5-bit Red + 5-bit Green + 5-bit Blue + 1-bit Alpha. - RGBA5551 = citro3d_sys::GPU_RB_RGBA5551, + RGBA5551 = ctru_sys::GPU_RB_RGBA5551, /// 5-bit Red + 6-bit Green + 5-bit Blue. - RGB565 = citro3d_sys::GPU_RB_RGB565, + RGB565 = ctru_sys::GPU_RB_RGB565, /// 4-bit Red + 4-bit Green + 4-bit Blue + 4-bit Alpha. - RGBA4 = citro3d_sys::GPU_RB_RGBA4, + RGBA4 = ctru_sys::GPU_RB_RGBA4, } impl From for ColorFormat { @@ -132,11 +132,11 @@ impl From for ColorFormat { #[derive(Clone, Copy, Debug)] pub enum DepthFormat { /// 16-bit depth. - Depth16 = citro3d_sys::GPU_RB_DEPTH16, + Depth16 = ctru_sys::GPU_RB_DEPTH16, /// 24-bit depth. - Depth24 = citro3d_sys::GPU_RB_DEPTH24, + Depth24 = ctru_sys::GPU_RB_DEPTH24, /// 24-bit depth + 8-bit Stencil. - Depth24Stencil8 = citro3d_sys::GPU_RB_DEPTH24_STENCIL8, + Depth24Stencil8 = ctru_sys::GPU_RB_DEPTH24_STENCIL8, } impl DepthFormat { diff --git a/citro3d/src/render/transfer.rs b/citro3d/src/render/transfer.rs index 60a5e58..4192547 100644 --- a/citro3d/src/render/transfer.rs +++ b/citro3d/src/render/transfer.rs @@ -1,4 +1,5 @@ -use citro3d_sys::{GX_TRANSFER_FORMAT, GX_TRANSFER_IN_FORMAT, GX_TRANSFER_OUT_FORMAT}; +use citro3d_sys::{GX_TRANSFER_IN_FORMAT, GX_TRANSFER_OUT_FORMAT}; +use ctru_sys::GX_TRANSFER_FORMAT; use super::ColorFormat; @@ -33,15 +34,15 @@ impl Flags { #[repr(u32)] pub enum Format { /// 8-bit Red + 8-bit Green + 8-bit Blue + 8-bit Alpha. - RGBA8 = citro3d_sys::GX_TRANSFER_FMT_RGBA8, + RGBA8 = ctru_sys::GX_TRANSFER_FMT_RGBA8, /// 8-bit Red + 8-bit Green + 8-bit Blue. - RGB8 = citro3d_sys::GX_TRANSFER_FMT_RGB8, + RGB8 = ctru_sys::GX_TRANSFER_FMT_RGB8, /// 5-bit Red + 5-bit Green + 5-bit Blue + 1-bit Alpha. - RGB565 = citro3d_sys::GX_TRANSFER_FMT_RGB565, + RGB565 = ctru_sys::GX_TRANSFER_FMT_RGB565, /// 5-bit Red + 6-bit Green + 5-bit Blue. - RGB5A1 = citro3d_sys::GX_TRANSFER_FMT_RGB5A1, + RGB5A1 = ctru_sys::GX_TRANSFER_FMT_RGB5A1, /// 4-bit Red + 4-bit Green + 4-bit Blue + 4-bit Alpha. - RGBA4 = citro3d_sys::GX_TRANSFER_FMT_RGBA4, + RGBA4 = ctru_sys::GX_TRANSFER_FMT_RGBA4, } impl From for Format { diff --git a/citro3d/src/shader.rs b/citro3d/src/shader.rs index d66a924..91142ee 100644 --- a/citro3d/src/shader.rs +++ b/citro3d/src/shader.rs @@ -16,7 +16,7 @@ pub mod macros; /// /// The PICA200 does not support user-programmable fragment shaders. pub struct Program { - program: citro3d_sys::shaderProgram_s, + program: ctru_sys::shaderProgram_s, } impl Program { @@ -30,14 +30,14 @@ impl Program { pub fn new(vertex_shader: Entrypoint) -> Result { let mut program = unsafe { let mut program = MaybeUninit::uninit(); - let result = citro3d_sys::shaderProgramInit(program.as_mut_ptr()); + let result = ctru_sys::shaderProgramInit(program.as_mut_ptr()); if result != 0 { return Err(ctru::Error::from(result)); } program.assume_init() }; - let ret = unsafe { citro3d_sys::shaderProgramSetVsh(&mut program, vertex_shader.as_raw()) }; + let ret = unsafe { ctru_sys::shaderProgramSetVsh(&mut program, vertex_shader.as_raw()) }; if ret == 0 { Ok(Self { program }) @@ -58,7 +58,7 @@ impl Program { stride: u8, ) -> Result<(), ctru::Error> { let ret = unsafe { - citro3d_sys::shaderProgramSetGsh(&mut self.program, geometry_shader.as_raw(), stride) + ctru_sys::shaderProgramSetGsh(&mut self.program, geometry_shader.as_raw(), stride) }; if ret == 0 { @@ -69,15 +69,15 @@ impl Program { } // TODO: pub(crate) - pub fn as_raw(&mut self) -> *mut citro3d_sys::shaderProgram_s { + pub fn as_raw(&mut self) -> *mut ctru_sys::shaderProgram_s { &mut self.program } } -impl<'vert, 'geom> Drop for Program { +impl Drop for Program { fn drop(&mut self) { unsafe { - let _ = citro3d_sys::shaderProgramFree(self.as_raw()); + let _ = ctru_sys::shaderProgramFree(self.as_raw()); } } } @@ -88,7 +88,7 @@ impl<'vert, 'geom> Drop for Program { /// /// This is the result of parsing a shader binary (shbin), and the resulting /// [`Entrypoint`]s can be used as part of a [`Program`]. -pub struct Library(*mut citro3d_sys::DVLB_s); +pub struct Library(*mut ctru_sys::DVLB_s); impl Library { /// Parse a new shader library from input bytes. @@ -100,7 +100,7 @@ impl Library { pub fn from_bytes(bytes: &[u8]) -> Result> { let aligned: &[u32] = bytemuck::try_cast_slice(bytes)?; Ok(Self(unsafe { - citro3d_sys::DVLB_ParseFile( + ctru_sys::DVLB_ParseFile( // SAFETY: we're trusting the parse implementation doesn't mutate // the contents of the data. From a quick read it looks like that's // correct and it should just take a const arg in the API. @@ -132,7 +132,7 @@ impl Library { self.len() == 0 } - fn as_raw(&mut self) -> *mut citro3d_sys::DVLB_s { + fn as_raw(&mut self) -> *mut ctru_sys::DVLB_s { self.0 } } @@ -140,7 +140,7 @@ impl Library { impl Drop for Library { fn drop(&mut self) { unsafe { - citro3d_sys::DVLB_Free(self.as_raw()); + ctru_sys::DVLB_Free(self.as_raw()); } } } @@ -149,12 +149,12 @@ impl Drop for Library { /// vertex or a geometry shader. #[derive(Clone, Copy)] pub struct Entrypoint<'lib> { - ptr: *mut citro3d_sys::DVLE_s, + ptr: *mut ctru_sys::DVLE_s, _library: &'lib Library, } impl<'lib> Entrypoint<'lib> { - fn as_raw(self) -> *mut citro3d_sys::DVLE_s { + fn as_raw(self) -> *mut ctru_sys::DVLE_s { self.ptr } }