Update citro3d to use upstream ctru_sys types

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]

citro3d/src/lib.rs

@@ -25,7 +25,7 @@ impl Instance {
     ///
     /// Fails if `citro3d` cannot be initialized.
     pub fn new() -> Result<Self> {
-        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<Self> {
+    pub fn with_cmdbuf_size(size: usize) -> Result<Self> {
         if unsafe { citro3d_sys::C3D_Init(size) } {
             Ok(Self)
         } else {

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<FramebufferFormat> for ColorFormat {
@@ -132,11 +132,11 @@ impl From<FramebufferFormat> 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 {

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<ColorFormat> for Format {

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<Self, ctru::Error> {
         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<Self, Box<dyn Error>> {
         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
     }
 }