No longer export intermediate modules in core_types

Author: Bromeon

bindings_generator/src/api.rs

@@ -422,7 +422,7 @@ impl Ty {
             Ty::Bool => syn::parse_quote! { bool },
             Ty::Vector2 => syn::parse_quote! { Vector2 },
             Ty::Vector3 => syn::parse_quote! { Vector3 },
-            Ty::Vector3Axis => syn::parse_quote! { vector3::Axis },
+            Ty::Vector3Axis => syn::parse_quote! { Axis },
             Ty::Quat => syn::parse_quote! { Quat },
             Ty::Transform => syn::parse_quote! { Transform },
             Ty::Transform2D => syn::parse_quote! { Transform2D },

gdnative-core/src/core_types/access.rs

@@ -5,21 +5,21 @@ use std::ops::{Deref, DerefMut};
 use std::ptr;
 use std::slice;
 
+/// A pool array access that may be unaligned.
 #[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
-/// An pool array access that may be unaligned.
 pub struct MaybeUnaligned<G> {
     guard: G,
 }
 
+/// A pool array access that is (assumed to be) aligned.
 #[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
-/// An pool array access that is (assumed to be) aligned.
 pub struct Aligned<G> {
     guard: G,
 }
 
-#[derive(Debug)]
-/// An pool array write access with an owned aligned copy. The data is written back when this is
+/// A pool array write access with an owned aligned copy. The data is written back when this is
 /// dropped.
+#[derive(Debug)]
 pub struct Owned<G>
 where
     G: Guard + WritePtr,

gdnative-core/src/core_types/byte_array.rs

@@ -1,4 +1,4 @@
-use crate::core_types::typed_array::TypedArray;
+use crate::core_types::TypedArray;
 
 /// A reference-counted vector of `u8` that uses Godot's pool allocator.
 pub type ByteArray = TypedArray<u8>;

gdnative-core/src/core_types/color_array.rs

@@ -1,5 +1,5 @@
-use crate::core_types::typed_array::TypedArray;
 use crate::core_types::Color;
+use crate::core_types::TypedArray;
 
 /// A reference-counted vector of `Color` that uses Godot's pool allocator.
 pub type ColorArray = TypedArray<Color>;

gdnative-core/src/core_types/error.rs

@@ -82,3 +82,6 @@ impl std::fmt::Display for GodotError {
 }
 
 impl std::error::Error for GodotError {}
+
+/// Result type with [GodotError]
+pub type GodotResult = Result<(), GodotError>;

gdnative-core/src/core_types/float32_array.rs

@@ -1,4 +1,4 @@
-use crate::core_types::typed_array::TypedArray;
+use crate::core_types::TypedArray;
 
 /// A reference-counted vector of `f32` that uses Godot's pool allocator.
 pub type Float32Array = TypedArray<f32>;

gdnative-core/src/core_types/int32_array.rs

@@ -1,4 +1,4 @@
-use crate::core_types::typed_array::TypedArray;
+use crate::core_types::TypedArray;
 
 /// A reference-counted vector of `i32` that uses Godot's pool allocator.
 pub type Int32Array = TypedArray<i32>;

gdnative-core/src/core_types/mod.rs

@@ -1,11 +1,18 @@
-//! Types that represent core-datatypes of Godot.
+//! Types that represent core data types of Godot.
+//!
+//! In contrast to generated Godot class types from the `api` module, the types in here are hand-written in idiomatic Rust and
+//! are the counterparts to built-in types in GDScript.
+//!
+//! godot-rust provides optional serialization support for many core types.  Enable the feature `serde` to make use of it.
 
 mod geom;
 
 mod access;
 mod byte_array;
 mod color;
 mod color_array;
+mod dictionary;
+mod error;
 mod float32_array;
 mod int32_array;
 mod node_path;
@@ -20,21 +27,17 @@ mod variant;
 mod variant_array;
 mod vector2;
 mod vector2_array;
+mod vector3;
 mod vector3_array;
 
-pub mod dictionary;
-pub mod error;
-pub mod vector3;
-
-pub use geom::*;
-
 pub use access::*;
 pub use byte_array::*;
 pub use color::*;
 pub use color_array::*;
-pub use dictionary::Dictionary;
-pub use error::GodotError;
+pub use dictionary::*;
+pub use error::{GodotError, GodotResult};
 pub use float32_array::*;
+pub use geom::*;
 pub use int32_array::*;
 pub use node_path::*;
 pub use quat::*;

gdnative-core/src/core_types/string_array.rs

@@ -1,5 +1,5 @@
-use crate::core_types::typed_array::TypedArray;
 use crate::core_types::GodotString;
+use crate::core_types::TypedArray;
 
 /// A reference-counted vector of `GodotString` that uses Godot's pool allocator.
 pub type StringArray = TypedArray<GodotString>;

gdnative-core/src/core_types/vector2_array.rs

@@ -1,4 +1,4 @@
-use crate::core_types::typed_array::TypedArray;
+use crate::core_types::TypedArray;
 use crate::core_types::Vector2;
 
 /// A reference-counted vector of `Vector2` that uses Godot's pool allocator.