From d354644ea6dac5028a02870b8ee026fe1f786a3e Mon Sep 17 00:00:00 2001
From: Shon Ferguson <shonferg@users.sourceforge.net>
Date: Wed, 21 Jun 2006 06:31:11 +0000
Subject: [PATCH] Fixed Python wrapper. Had to revert changes to Ref.h.  They
 changed some Python syntax and would not compile.

---
 Ref.h      |  266 +++++-----
 pyniflib.i | 1379 ++++++++++++++++++++++++++--------------------------
 2 files changed, 826 insertions(+), 819 deletions(-)

diff --git a/Ref.h b/Ref.h
index 20a8b1b8..3c64d134 100644
--- a/Ref.h
+++ b/Ref.h
@@ -3,6 +3,7 @@ All rights reserved.  Please see niflib.h for licence. */
 
 #ifndef _REF_H_
 #define _REF_H_
+
 #include <ostream>
 #include "dll_export.h"
 namespace Niflib {
@@ -12,162 +13,179 @@ namespace Niflib {
  */
 
 template<class T> class Ref;
-template<class T> std::ostream & operator<<(std::ostream &, const Ref<T> &);
-
+template<class T> ostream & operator<<(ostream &, const Ref<T> &);
 
-/**
-* Ref Traits:  Class overridable behavior methods
-*/
-template<typename T>
-class RefTraits
-{
-public:	
-   static void AddRef( T* p )   { if (p) p->AddRef(); }
-   static void Release( T* p )  { if (p) p->SubtractRef(); }
-   static bool Less( T*l, T*r ) { return ( l < r ); }
-   static ::std::ostream & ToStream(::std::ostream &os, T* p) { 
-      if (p) os << p->GetIDString();
-      else   os << "NULL";
-      return os; 
-   }
-#ifdef USE_NIFLIB_TEMPLATE_HELPERS
-   template<typename U> static T* StaticCast(U* p) { return static_cast<T*>(p); }
-   template<typename U> static T* DynamicCast(U* p) {
-      if ( (NULL != p) && p->IsDerivedType(T::TypeConst()) ) {
-         return static_cast<T*>(p);
-      } else {
-         return NULL;
-      }
-   }
+template <class T> class Ref {
+public:
+	Ref( T * object = NULL );
+	Ref(const Ref & ref_to_copy );
+	~Ref();
+
+	T& operator*() const;
+	
+	T* Ptr() const;
+
+	bool operator<(const Ref & ref) const;
+
+	bool operator==(T * object) const;
+	bool operator!=(T * object) const;
+	bool operator==(const Ref & ref) const;
+	bool operator!=(const Ref & ref) const;
+
+	//These operators generate problems in SWIG
+#ifndef SWIG
+	friend ostream & operator<< <T>(ostream & os, const Ref & ref);
+	Ref & operator=( T * object );
+	Ref & operator=( const Ref & ref );
+	operator T*() const;
+	T* operator->() const;
 #endif
-};
 
+protected:
+	//The shared object
+	T* _object;
+};
 
-/**
-* Smart reference
-*/
-template<class T>
-class Ref
-{
-public:
-   Ref( T* p = 0 ) 
-      : p_( ShallowCopy( p ) )
-   {
-   }	
-
-   ~Ref() { Release( ); }
-
-   Ref& Attach( T* p = 0 )
-   {
-      Reset();
-      p_ = p;
-      return (*this);
+template <class T>
+Ref<T>::Ref( T * object ) : _object(object) {
+   //If object isn't null, increment reference count
+   if ( _object != NULL ) {
+      _object->AddRef();
    }
+}
 
-   // Normally I'd disable this and force you to use safe/explicit conversions
-   operator T*() const { return p_; }
-
-   T& operator*() const { return *p_; }
-
-   T* operator->() const { return p_; }
-
-   T* ToPointer() const { return p_; }
+template <class T>
+Ref<T>::Ref(const Ref & ref_to_copy ) {
+	_object = ref_to_copy._object;
+	//If object isn't null, increment reference count
+	if ( _object != NULL ) {
+		_object->AddRef();
+	}
+}
 
-   void Swap( Ref& other ) { std::swap( p_, other.p_); }
+template <class T>
+Ref<T>::~Ref() {
+	//if object insn't null, decrement reference count
+	if ( _object != NULL ) {
+		_object->SubtractRef();
+	}
+}
 
-   bool isEmpty() const
-   { return (p_ == 0); }
+template <class T>
+Ref<T>::operator T*() const {
+	return _object;
+}
 
-   bool isSet() const
-   { return (p_ != 0); }
 
-   /**
-   * overload all potential null test comparison operators
-   */
-   operator bool() const // Enables "if (sp) ..."
-   { return (p_ != 0); }
 
-   bool operator!() const // Enables "if (!sp) ..."
-   { return (p_ == 0); }
+template <class T>
+T* Ref<T>::operator->() const {
+	return _object;
+}
 
-   inline friend bool operator==(const Ref& lhs, const Ref& rhs)
-   { return (lhs.p_ == rhs.p_); }
+template <class T>
+T* Ref<T>::Ptr() const {
+	return _object;
+}
 
-   inline friend bool operator!=(const Ref& lhs, const Ref& rhs)
-   { return (lhs.p_ != rhs.p_); }
+//These operators generate warnings in SWIG
+#ifndef SWIG
 
-   inline friend bool operator==(const Ref& lhs, const T* rhs)
-   { return (lhs.p_ == rhs); }
+template <class T>
+T& Ref<T>::operator*() const {
+	return *_object;
+}
 
-   inline friend bool operator==(const T* lhs, const Ref& rhs)
-   { return (lhs == rhs.p_); }
+template <class T>
+Ref<T> & Ref<T>::operator=( T * object ) {
+	//Check if referenced objects are already the same
+	if ( _object == object ) {
+		return *this; //Do nothing
+	}
 
-   inline friend bool operator==(const Ref& lhs, intptr_t rhs)
-   { return (lhs.p_ == reinterpret_cast<T*>(rhs)); }
+	//Decriment reference count on previously referenced object, if any
+	if ( _object != NULL ) {
+		_object->SubtractRef();
+	}
 
-   inline friend bool operator==(intptr_t rhs, const Ref& lhs)
-   { return (reinterpret_cast<T*>(lhs) == rhs.p_); }
+	//Change reference to new object
+	_object = object;
 
-   inline friend bool operator!=(const Ref& lhs, const T* rhs)
-   { return (lhs.p_ != rhs); }
+	//Increment reference count on new object if it is not NULL
+	if ( _object != NULL ) {
+		_object->AddRef();
+	}
 
-   inline friend bool operator!=(const T* lhs, const Ref& rhs)
-   { return (lhs != rhs.p_); }
+	return *this;
+}
 
-   inline friend bool operator!=(const Ref& lhs, intptr_t rhs)
-   { return (lhs.p_ != reinterpret_cast<T*>(rhs)); }
 
-   inline friend bool operator!=(intptr_t rhs, const Ref& lhs)
-   { return (reinterpret_cast<T*>(lhs) != rhs.p_); }
+template <class T>
+Ref<T> & Ref<T>::operator=( const Ref & ref ) {
+	//Check if referenced objects are already the same
+	if ( _object == ref._object ) {
+		return *this; //Do nothing
+	}
 
-   inline friend bool operator<(const Ref& lhs, const Ref& rhs)
-   { return RefTraits<T>::Less(lhs.p_, rhs.p_); }
+	//Decriment reference count on previously referenced object, if any
+	if ( _object != NULL ) {
+		_object->SubtractRef();
+	}
 
-   inline friend std::ostream & operator<<(std::ostream &os, const Ref& rhs)
-   { return RefTraits<T>::ToStream(os, rhs.p_); }
+	//Change reference to new object
+	_object = ref._object;
 
-   Ref( const Ref& other )
-      : p_( ShallowCopy( other.p_ ) )
-   { }
+	//Increment reference count on new object if it is not NULL
+	if ( _object != NULL ) {
+		_object->AddRef();
+	}
 
-#ifdef USE_NIFLIB_TEMPLATE_HELPERS
-   template<typename U>
-   Ref( const Ref<U>& other ) 
-      : p_( ShallowCopy(RefTraits<T>::DynamicCast(other.p_)) )
-   { }
+	return *this;
+}
 #endif
 
-   Ref& operator=( T * other )
-   {
-      Ref temp(other);
-      Swap(temp);
-      return *this;
-   }
+//Template functions must be in the header file
 
-   Ref& operator=( const Ref& other )
-   {
-      Ref temp(other);
-      Swap(temp);
-      return *this;
-   }
+template <class T>
+bool Ref<T>::operator<(const Ref & ref) const {
+	return (_object < ref._object);
+}
 
-private:
-   template<typename U> friend class Ref;
+template <class T>
+bool Ref<T>::operator==(T * object) const {
+	//Compare pointer values of referenced objects
+	return ( _object == object );
+}
 
-   T* ShallowCopy( T* p ) 
-   {
-      RefTraits<T>::AddRef( p );
-      return p;
-   }
+template <class T>
+bool Ref<T>::operator!=(T * object) const {
+	//Compare pointer values of referenced objects
+	return ( _object != object );
+}
 
-   void Release( )
-   {
-      RefTraits<T>::Release( p_ );
-      p_ = 0;
-   }
+template <class T>
+bool Ref<T>::operator==(const Ref & ref) const {
+	//Compare pointer values of referenced objects
+	return ( _object == ref._object );
+}
 
-   T* p_;
-};
+template <class T>
+bool Ref<T>::operator!=(const Ref & ref) const {
+	//Compare pointer values of referenced objects
+	return ( _object != ref._object );
+}
 
+#ifndef SWIG
+template <class T>
+ostream & operator<<(ostream & os, const Ref<T> & ref) {
+	if (ref._object)
+		os << ref->GetIDString();
+	else
+		os << "NULL";
+	return os;
 }
 #endif
+
+}
+
+#endif
diff --git a/pyniflib.i b/pyniflib.i
index e6d77727..07d34a93 100644
--- a/pyniflib.i
+++ b/pyniflib.i
@@ -34,7 +34,7 @@ LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE. */
 
-%module niflib
+%module new_niflib
 %include "stl.i"
 %include "std_map.i"
 %include "exception.i"
@@ -43,41 +43,39 @@ POSSIBILITY OF SUCH DAMAGE. */
 
 // enable string assignment in structure member functions
 %typemap(in) std::string* ($*1_ltype tempstr) {
-	char * temps; int templ;
- 	if (PyString_AsStringAndSize($input, &temps, &templ)) return NULL;
- 	tempstr = $*1_ltype(temps, templ);
- 	$1 = &tempstr;
+  char * temps; int templ;
+   if (PyString_AsStringAndSize($input, &temps, &templ)) return NULL;
+   tempstr = $*1_ltype(temps, templ);
+   $1 = &tempstr;
 }
 %typemap(out) std::string* "$result = PyString_FromStringAndSize($1->data(), $1->length());";
 
 // we need a version of SWIG that has SWIG_CATCH_STDEXCEPT support
 #if SWIG_VERSION >= 0x010322
 %exception {
-	try {
-		$action
-	}
-	SWIG_CATCH_STDEXCEPT // catch std::exception
-	catch (...) {
-		SWIG_exception(SWIG_UnknownError, "Unknown exception");
-	}
+  try {
+    $action
+  }
+  SWIG_CATCH_STDEXCEPT // catch std::exception
+  catch (...) {
+    SWIG_exception(SWIG_UnknownError, "Unknown exception");
+  }
 }
 #endif
 
-// we need to define this because the wrapper gets confused about NIFLIB_API'd functions otherwise
-#define NIFLIB_API
-#define NIFLIB_HIDDEN
-
 //Ignore the const versions of these functions
 %ignore DynamicCast( const NiObject * object );
-%ignore StaticCast (const NiObject * object);
+%ignore StaticCast ( const NiObject * object );
 
 //Do not use smart pointer support as it doubles the size of the library
 //and makes it take twice as long to be imported
-%ignore Ref::operator->;
-%ignore Ref::operator=;
+%ignore Niflib::Ref::operator->;
+%ignore Niflib::Ref::operator=;
 
-// we need this to get all the defines in there
-%include "gen/obj_defines.h"
+//Import the symbols from these but do not include them in the wrapper
+%import "gen/obj_defines.h"
+%import "NIF_IO.h"
+%import "dll_export.h"
 %{
 		#include "niflib.h"
 		#include "Ref.h"
@@ -326,44 +324,35 @@ POSSIBILITY OF SUCH DAMAGE. */
 		#include "gen/SkinData.h"
 		#include "gen/RagDollDescriptor.h"
 		#include "gen/LimitedHingeDescriptor.h"
+	using namespace Niflib;
 %}
 
-
-// we need the definition of the template classes before we define the template Python names below
-template <class T> 
-struct Key {
-	float time;
-	T data, forward_tangent, backward_tangent;
-	float tension, bias, continuity;
-};
-
-%ignore Key;
-%template(vector_byte) std::vector<byte>;
-%template(vector_ushort) std::vector<ushort>;
-%template(vector_SkinShape) std::vector<SkinShape>;
+%template(vector_byte) std::vector<Niflib::byte>;
+%template(vector_ushort) std::vector<Niflib::ushort>;
+%template(vector_SkinShape) std::vector<Niflib::SkinShape>;
 %template(vector_string) std::vector<std::string>;
-%template(vector_Triangle) std::vector<Triangle>;
-%template(vector_Vector3) std::vector<Vector3>;
+%template(vector_Triangle) std::vector<Niflib::Triangle>;
+%template(vector_Vector3) std::vector<Niflib::Vector3>;
 %template(vector_float) std::vector<float>;
-%template(vector_SkinWeight) std::vector<SkinWeight>;
-%template(vector_NodeGroup) std::vector<NodeGroup>;
-%template(vector_Color4) std::vector<Color4>;
-%template(vector_Float4) std::vector<Float4>;
-%template(vector_uint) std::vector<uint>;
-%template(vector_FurniturePosition) std::vector<FurniturePosition>;
-%template(vector_hkTriangle) std::vector<hkTriangle>;
-%template(vector_SkinShapeGroup) std::vector<SkinShapeGroup>;
-%template(vector_ControllerLink) std::vector<ControllerLink>;
-%template(vector_AVObject) std::vector<AVObject>;
-%template(vector_Morph) std::vector<Morph>;
-%template(vector_LODRange) std::vector<LODRange>;
-%template(vector_Quaternion) std::vector<Quaternion>;
-%template(vector_Particle) std::vector<Particle>;
-%template(vector_MipMap) std::vector<MipMap>;
-%template(vector_SkinData) std::vector<SkinData>;
-%template(vector_SkinPartition) std::vector<SkinPartition>;
-%template(vector_ShaderTexDesc) std::vector<ShaderTexDesc>;
-%template(vector_MatchGroup) std::vector<MatchGroup>;
+%template(vector_SkinWeight) std::vector<Niflib::SkinWeight>;
+%template(vector_NodeGroup) std::vector<Niflib::NodeGroup>;
+%template(vector_Color4) std::vector<Niflib::Color4>;
+%template(vector_Float4) std::vector<Niflib::Float4>;
+%template(vector_uint) std::vector<Niflib::uint>;
+%template(vector_FurniturePosition) std::vector<Niflib::FurniturePosition>;
+%template(vector_hkTriangle) std::vector<Niflib::hkTriangle>;
+%template(vector_SkinShapeGroup) std::vector<Niflib::SkinShapeGroup>;
+%template(vector_ControllerLink) std::vector<Niflib::ControllerLink>;
+%template(vector_AVObject) std::vector<Niflib::AVObject>;
+%template(vector_Morph) std::vector<Niflib::Morph>;
+%template(vector_LODRange) std::vector<Niflib::LODRange>;
+%template(vector_Quaternion) std::vector<Niflib::Quaternion>;
+%template(vector_Particle) std::vector<Niflib::Particle>;
+%template(vector_MipMap) std::vector<Niflib::MipMap>;
+%template(vector_SkinData) std::vector<Niflib::SkinData>;
+%template(vector_SkinPartition) std::vector<Niflib::SkinPartition>;
+%template(vector_ShaderTexDesc) std::vector<Niflib::ShaderTexDesc>;
+%template(vector_MatchGroup) std::vector<Niflib::MatchGroup>;
 %template(pair_int_float) std::pair<int, float>;
 %template(map_int_float) std::map<int, float>;
 
@@ -372,857 +361,857 @@ struct Key {
 %include "Type.h"
 %include "nif_math.h"
 %include "obj/NiObject.h"
-%template(NiObjectRef) Ref<NiObject>;
-%template(DynamicCastToNiObject) DynamicCast<NiObject>;
-%template(StaticCastToNiObject) StaticCast<NiObject>;
+%template(NiObjectRef) Niflib::Ref<Niflib::NiObject>;
+%template(DynamicCastToNiObject) Niflib::DynamicCast<Niflib::NiObject>;
+%template(StaticCastToNiObject) Niflib::StaticCast<Niflib::NiObject>;
 %include "obj/AKeyedData.h"
-%template(AKeyedDataRef) Ref<AKeyedData>;
-%template(DynamicCastToAKeyedData) DynamicCast<AKeyedData>;
-%template(StaticCastToAKeyedData) StaticCast<AKeyedData>;
+%template(AKeyedDataRef) Niflib::Ref<Niflib::AKeyedData>;
+%template(DynamicCastToAKeyedData) Niflib::DynamicCast<Niflib::AKeyedData>;
+%template(StaticCastToAKeyedData) Niflib::StaticCast<Niflib::AKeyedData>;
 %include "obj/AParticleModifier.h"
-%template(AParticleModifierRef) Ref<AParticleModifier>;
-%template(DynamicCastToAParticleModifier) DynamicCast<AParticleModifier>;
-%template(StaticCastToAParticleModifier) StaticCast<AParticleModifier>;
+%template(AParticleModifierRef) Niflib::Ref<Niflib::AParticleModifier>;
+%template(DynamicCastToAParticleModifier) Niflib::DynamicCast<Niflib::AParticleModifier>;
+%template(StaticCastToAParticleModifier) Niflib::StaticCast<Niflib::AParticleModifier>;
 %include "obj/bhkRefObject.h"
-%template(bhkRefObjectRef) Ref<bhkRefObject>;
-%template(DynamicCastTobhkRefObject) DynamicCast<bhkRefObject>;
-%template(StaticCastTobhkRefObject) StaticCast<bhkRefObject>;
+%template(bhkRefObjectRef) Niflib::Ref<Niflib::bhkRefObject>;
+%template(DynamicCastTobhkRefObject) Niflib::DynamicCast<Niflib::bhkRefObject>;
+%template(StaticCastTobhkRefObject) Niflib::StaticCast<Niflib::bhkRefObject>;
 %include "obj/bhkSerializable.h"
-%template(bhkSerializableRef) Ref<bhkSerializable>;
-%template(DynamicCastTobhkSerializable) DynamicCast<bhkSerializable>;
-%template(StaticCastTobhkSerializable) StaticCast<bhkSerializable>;
+%template(bhkSerializableRef) Niflib::Ref<Niflib::bhkSerializable>;
+%template(DynamicCastTobhkSerializable) Niflib::DynamicCast<Niflib::bhkSerializable>;
+%template(StaticCastTobhkSerializable) Niflib::StaticCast<Niflib::bhkSerializable>;
 %include "obj/AbhkConstraint.h"
-%template(AbhkConstraintRef) Ref<AbhkConstraint>;
-%template(DynamicCastToAbhkConstraint) DynamicCast<AbhkConstraint>;
-%template(StaticCastToAbhkConstraint) StaticCast<AbhkConstraint>;
+%template(AbhkConstraintRef) Niflib::Ref<Niflib::AbhkConstraint>;
+%template(DynamicCastToAbhkConstraint) Niflib::DynamicCast<Niflib::AbhkConstraint>;
+%template(StaticCastToAbhkConstraint) Niflib::StaticCast<Niflib::AbhkConstraint>;
 %include "obj/AbhkRagdollConstraint.h"
-%template(AbhkRagdollConstraintRef) Ref<AbhkRagdollConstraint>;
-%template(DynamicCastToAbhkRagdollConstraint) DynamicCast<AbhkRagdollConstraint>;
-%template(StaticCastToAbhkRagdollConstraint) StaticCast<AbhkRagdollConstraint>;
+%template(AbhkRagdollConstraintRef) Niflib::Ref<Niflib::AbhkRagdollConstraint>;
+%template(DynamicCastToAbhkRagdollConstraint) Niflib::DynamicCast<Niflib::AbhkRagdollConstraint>;
+%template(StaticCastToAbhkRagdollConstraint) Niflib::StaticCast<Niflib::AbhkRagdollConstraint>;
 %include "obj/bhkShape.h"
-%template(bhkShapeRef) Ref<bhkShape>;
-%template(DynamicCastTobhkShape) DynamicCast<bhkShape>;
-%template(StaticCastTobhkShape) StaticCast<bhkShape>;
+%template(bhkShapeRef) Niflib::Ref<Niflib::bhkShape>;
+%template(DynamicCastTobhkShape) Niflib::DynamicCast<Niflib::bhkShape>;
+%template(StaticCastTobhkShape) Niflib::StaticCast<Niflib::bhkShape>;
 %include "obj/AbhkShapeCollection.h"
-%template(AbhkShapeCollectionRef) Ref<AbhkShapeCollection>;
-%template(DynamicCastToAbhkShapeCollection) DynamicCast<AbhkShapeCollection>;
-%template(StaticCastToAbhkShapeCollection) StaticCast<AbhkShapeCollection>;
+%template(AbhkShapeCollectionRef) Niflib::Ref<Niflib::AbhkShapeCollection>;
+%template(DynamicCastToAbhkShapeCollection) Niflib::DynamicCast<Niflib::AbhkShapeCollection>;
+%template(StaticCastToAbhkShapeCollection) Niflib::StaticCast<Niflib::AbhkShapeCollection>;
 %include "obj/bhkSphereRepShape.h"
-%template(bhkSphereRepShapeRef) Ref<bhkSphereRepShape>;
-%template(DynamicCastTobhkSphereRepShape) DynamicCast<bhkSphereRepShape>;
-%template(StaticCastTobhkSphereRepShape) StaticCast<bhkSphereRepShape>;
+%template(bhkSphereRepShapeRef) Niflib::Ref<Niflib::bhkSphereRepShape>;
+%template(DynamicCastTobhkSphereRepShape) Niflib::DynamicCast<Niflib::bhkSphereRepShape>;
+%template(StaticCastTobhkSphereRepShape) Niflib::StaticCast<Niflib::bhkSphereRepShape>;
 %include "obj/bhkConvexShape.h"
-%template(bhkConvexShapeRef) Ref<bhkConvexShape>;
-%template(DynamicCastTobhkConvexShape) DynamicCast<bhkConvexShape>;
-%template(StaticCastTobhkConvexShape) StaticCast<bhkConvexShape>;
+%template(bhkConvexShapeRef) Niflib::Ref<Niflib::bhkConvexShape>;
+%template(DynamicCastTobhkConvexShape) Niflib::DynamicCast<Niflib::bhkConvexShape>;
+%template(StaticCastTobhkConvexShape) Niflib::StaticCast<Niflib::bhkConvexShape>;
 %include "obj/bhkWorldObject.h"
-%template(bhkWorldObjectRef) Ref<bhkWorldObject>;
-%template(DynamicCastTobhkWorldObject) DynamicCast<bhkWorldObject>;
-%template(StaticCastTobhkWorldObject) StaticCast<bhkWorldObject>;
+%template(bhkWorldObjectRef) Niflib::Ref<Niflib::bhkWorldObject>;
+%template(DynamicCastTobhkWorldObject) Niflib::DynamicCast<Niflib::bhkWorldObject>;
+%template(StaticCastTobhkWorldObject) Niflib::StaticCast<Niflib::bhkWorldObject>;
 %include "obj/bhkEntity.h"
-%template(bhkEntityRef) Ref<bhkEntity>;
-%template(DynamicCastTobhkEntity) DynamicCast<bhkEntity>;
-%template(StaticCastTobhkEntity) StaticCast<bhkEntity>;
+%template(bhkEntityRef) Niflib::Ref<Niflib::bhkEntity>;
+%template(DynamicCastTobhkEntity) Niflib::DynamicCast<Niflib::bhkEntity>;
+%template(StaticCastTobhkEntity) Niflib::StaticCast<Niflib::bhkEntity>;
 %include "obj/NiCollisionObject.h"
-%template(NiCollisionObjectRef) Ref<NiCollisionObject>;
-%template(DynamicCastToNiCollisionObject) DynamicCast<NiCollisionObject>;
-%template(StaticCastToNiCollisionObject) StaticCast<NiCollisionObject>;
+%template(NiCollisionObjectRef) Niflib::Ref<Niflib::NiCollisionObject>;
+%template(DynamicCastToNiCollisionObject) Niflib::DynamicCast<Niflib::NiCollisionObject>;
+%template(StaticCastToNiCollisionObject) Niflib::StaticCast<Niflib::NiCollisionObject>;
 %include "obj/NiExtraData.h"
-%template(NiExtraDataRef) Ref<NiExtraData>;
-%template(DynamicCastToNiExtraData) DynamicCast<NiExtraData>;
-%template(StaticCastToNiExtraData) StaticCast<NiExtraData>;
+%template(NiExtraDataRef) Niflib::Ref<Niflib::NiExtraData>;
+%template(DynamicCastToNiExtraData) Niflib::DynamicCast<Niflib::NiExtraData>;
+%template(StaticCastToNiExtraData) Niflib::StaticCast<Niflib::NiExtraData>;
 %include "obj/NiInterpolator.h"
-%template(NiInterpolatorRef) Ref<NiInterpolator>;
-%template(DynamicCastToNiInterpolator) DynamicCast<NiInterpolator>;
-%template(StaticCastToNiInterpolator) StaticCast<NiInterpolator>;
+%template(NiInterpolatorRef) Niflib::Ref<Niflib::NiInterpolator>;
+%template(DynamicCastToNiInterpolator) Niflib::DynamicCast<Niflib::NiInterpolator>;
+%template(StaticCastToNiInterpolator) Niflib::StaticCast<Niflib::NiInterpolator>;
 %include "obj/NiBlendInterpolator.h"
-%template(NiBlendInterpolatorRef) Ref<NiBlendInterpolator>;
-%template(DynamicCastToNiBlendInterpolator) DynamicCast<NiBlendInterpolator>;
-%template(StaticCastToNiBlendInterpolator) StaticCast<NiBlendInterpolator>;
+%template(NiBlendInterpolatorRef) Niflib::Ref<Niflib::NiBlendInterpolator>;
+%template(DynamicCastToNiBlendInterpolator) Niflib::DynamicCast<Niflib::NiBlendInterpolator>;
+%template(StaticCastToNiBlendInterpolator) Niflib::StaticCast<Niflib::NiBlendInterpolator>;
 %include "obj/NiBSplineInterpolator.h"
-%template(NiBSplineInterpolatorRef) Ref<NiBSplineInterpolator>;
-%template(DynamicCastToNiBSplineInterpolator) DynamicCast<NiBSplineInterpolator>;
-%template(StaticCastToNiBSplineInterpolator) StaticCast<NiBSplineInterpolator>;
+%template(NiBSplineInterpolatorRef) Niflib::Ref<Niflib::NiBSplineInterpolator>;
+%template(DynamicCastToNiBSplineInterpolator) Niflib::DynamicCast<Niflib::NiBSplineInterpolator>;
+%template(StaticCastToNiBSplineInterpolator) Niflib::StaticCast<Niflib::NiBSplineInterpolator>;
 %include "obj/NiObjectNET.h"
-%template(NiObjectNETRef) Ref<NiObjectNET>;
-%template(DynamicCastToNiObjectNET) DynamicCast<NiObjectNET>;
-%template(StaticCastToNiObjectNET) StaticCast<NiObjectNET>;
+%template(NiObjectNETRef) Niflib::Ref<Niflib::NiObjectNET>;
+%template(DynamicCastToNiObjectNET) Niflib::DynamicCast<Niflib::NiObjectNET>;
+%template(StaticCastToNiObjectNET) Niflib::StaticCast<Niflib::NiObjectNET>;
 %include "obj/NiAVObject.h"
-%template(NiAVObjectRef) Ref<NiAVObject>;
-%template(DynamicCastToNiAVObject) DynamicCast<NiAVObject>;
-%template(StaticCastToNiAVObject) StaticCast<NiAVObject>;
+%template(NiAVObjectRef) Niflib::Ref<Niflib::NiAVObject>;
+%template(DynamicCastToNiAVObject) Niflib::DynamicCast<Niflib::NiAVObject>;
+%template(StaticCastToNiAVObject) Niflib::StaticCast<Niflib::NiAVObject>;
 %include "obj/NiDynamicEffect.h"
-%template(NiDynamicEffectRef) Ref<NiDynamicEffect>;
-%template(DynamicCastToNiDynamicEffect) DynamicCast<NiDynamicEffect>;
-%template(StaticCastToNiDynamicEffect) StaticCast<NiDynamicEffect>;
+%template(NiDynamicEffectRef) Niflib::Ref<Niflib::NiDynamicEffect>;
+%template(DynamicCastToNiDynamicEffect) Niflib::DynamicCast<Niflib::NiDynamicEffect>;
+%template(StaticCastToNiDynamicEffect) Niflib::StaticCast<Niflib::NiDynamicEffect>;
 %include "obj/NiLight.h"
-%template(NiLightRef) Ref<NiLight>;
-%template(DynamicCastToNiLight) DynamicCast<NiLight>;
-%template(StaticCastToNiLight) StaticCast<NiLight>;
+%template(NiLightRef) Niflib::Ref<Niflib::NiLight>;
+%template(DynamicCastToNiLight) Niflib::DynamicCast<Niflib::NiLight>;
+%template(StaticCastToNiLight) Niflib::StaticCast<Niflib::NiLight>;
 %include "obj/NiProperty.h"
-%template(NiPropertyRef) Ref<NiProperty>;
-%template(DynamicCastToNiProperty) DynamicCast<NiProperty>;
-%template(StaticCastToNiProperty) StaticCast<NiProperty>;
+%template(NiPropertyRef) Niflib::Ref<Niflib::NiProperty>;
+%template(DynamicCastToNiProperty) Niflib::DynamicCast<Niflib::NiProperty>;
+%template(StaticCastToNiProperty) Niflib::StaticCast<Niflib::NiProperty>;
 %include "obj/NiPSysModifier.h"
-%template(NiPSysModifierRef) Ref<NiPSysModifier>;
-%template(DynamicCastToNiPSysModifier) DynamicCast<NiPSysModifier>;
-%template(StaticCastToNiPSysModifier) StaticCast<NiPSysModifier>;
+%template(NiPSysModifierRef) Niflib::Ref<Niflib::NiPSysModifier>;
+%template(DynamicCastToNiPSysModifier) Niflib::DynamicCast<Niflib::NiPSysModifier>;
+%template(StaticCastToNiPSysModifier) Niflib::StaticCast<Niflib::NiPSysModifier>;
 %include "obj/NiPSysEmitter.h"
-%template(NiPSysEmitterRef) Ref<NiPSysEmitter>;
-%template(DynamicCastToNiPSysEmitter) DynamicCast<NiPSysEmitter>;
-%template(StaticCastToNiPSysEmitter) StaticCast<NiPSysEmitter>;
+%template(NiPSysEmitterRef) Niflib::Ref<Niflib::NiPSysEmitter>;
+%template(DynamicCastToNiPSysEmitter) Niflib::DynamicCast<Niflib::NiPSysEmitter>;
+%template(StaticCastToNiPSysEmitter) Niflib::StaticCast<Niflib::NiPSysEmitter>;
 %include "obj/NiPSysVolumeEmitter.h"
-%template(NiPSysVolumeEmitterRef) Ref<NiPSysVolumeEmitter>;
-%template(DynamicCastToNiPSysVolumeEmitter) DynamicCast<NiPSysVolumeEmitter>;
-%template(StaticCastToNiPSysVolumeEmitter) StaticCast<NiPSysVolumeEmitter>;
+%template(NiPSysVolumeEmitterRef) Niflib::Ref<Niflib::NiPSysVolumeEmitter>;
+%template(DynamicCastToNiPSysVolumeEmitter) Niflib::DynamicCast<Niflib::NiPSysVolumeEmitter>;
+%template(StaticCastToNiPSysVolumeEmitter) Niflib::StaticCast<Niflib::NiPSysVolumeEmitter>;
 %include "obj/NiTimeController.h"
-%template(NiTimeControllerRef) Ref<NiTimeController>;
-%template(DynamicCastToNiTimeController) DynamicCast<NiTimeController>;
-%template(StaticCastToNiTimeController) StaticCast<NiTimeController>;
+%template(NiTimeControllerRef) Niflib::Ref<Niflib::NiTimeController>;
+%template(DynamicCastToNiTimeController) Niflib::DynamicCast<Niflib::NiTimeController>;
+%template(StaticCastToNiTimeController) Niflib::StaticCast<Niflib::NiTimeController>;
 %include "obj/ABoneLODController.h"
-%template(ABoneLODControllerRef) Ref<ABoneLODController>;
-%template(DynamicCastToABoneLODController) DynamicCast<ABoneLODController>;
-%template(StaticCastToABoneLODController) StaticCast<ABoneLODController>;
+%template(ABoneLODControllerRef) Niflib::Ref<Niflib::ABoneLODController>;
+%template(DynamicCastToABoneLODController) Niflib::DynamicCast<Niflib::ABoneLODController>;
+%template(StaticCastToABoneLODController) Niflib::StaticCast<Niflib::ABoneLODController>;
 %include "obj/NiSingleInterpolatorController.h"
-%template(NiSingleInterpolatorControllerRef) Ref<NiSingleInterpolatorController>;
-%template(DynamicCastToNiSingleInterpolatorController) DynamicCast<NiSingleInterpolatorController>;
-%template(StaticCastToNiSingleInterpolatorController) StaticCast<NiSingleInterpolatorController>;
+%template(NiSingleInterpolatorControllerRef) Niflib::Ref<Niflib::NiSingleInterpolatorController>;
+%template(DynamicCastToNiSingleInterpolatorController) Niflib::DynamicCast<Niflib::NiSingleInterpolatorController>;
+%template(StaticCastToNiSingleInterpolatorController) Niflib::StaticCast<Niflib::NiSingleInterpolatorController>;
 %include "obj/APSysCtlr.h"
-%template(APSysCtlrRef) Ref<APSysCtlr>;
-%template(DynamicCastToAPSysCtlr) DynamicCast<APSysCtlr>;
-%template(StaticCastToAPSysCtlr) StaticCast<APSysCtlr>;
+%template(APSysCtlrRef) Niflib::Ref<Niflib::APSysCtlr>;
+%template(DynamicCastToAPSysCtlr) Niflib::DynamicCast<Niflib::APSysCtlr>;
+%template(StaticCastToAPSysCtlr) Niflib::StaticCast<Niflib::APSysCtlr>;
 %include "obj/NiTriBasedGeom.h"
-%template(NiTriBasedGeomRef) Ref<NiTriBasedGeom>;
-%template(DynamicCastToNiTriBasedGeom) DynamicCast<NiTriBasedGeom>;
-%template(StaticCastToNiTriBasedGeom) StaticCast<NiTriBasedGeom>;
+%template(NiTriBasedGeomRef) Niflib::Ref<Niflib::NiTriBasedGeom>;
+%template(DynamicCastToNiTriBasedGeom) Niflib::DynamicCast<Niflib::NiTriBasedGeom>;
+%template(StaticCastToNiTriBasedGeom) Niflib::StaticCast<Niflib::NiTriBasedGeom>;
 %include "obj/NiTriBasedGeomData.h"
-%template(NiTriBasedGeomDataRef) Ref<NiTriBasedGeomData>;
-%template(DynamicCastToNiTriBasedGeomData) DynamicCast<NiTriBasedGeomData>;
-%template(StaticCastToNiTriBasedGeomData) StaticCast<NiTriBasedGeomData>;
+%template(NiTriBasedGeomDataRef) Niflib::Ref<Niflib::NiTriBasedGeomData>;
+%template(DynamicCastToNiTriBasedGeomData) Niflib::DynamicCast<Niflib::NiTriBasedGeomData>;
+%template(StaticCastToNiTriBasedGeomData) Niflib::StaticCast<Niflib::NiTriBasedGeomData>;
 %include "obj/APSysData.h"
-%template(APSysDataRef) Ref<APSysData>;
-%template(DynamicCastToAPSysData) DynamicCast<APSysData>;
-%template(StaticCastToAPSysData) StaticCast<APSysData>;
+%template(APSysDataRef) Niflib::Ref<Niflib::APSysData>;
+%template(DynamicCastToAPSysData) Niflib::DynamicCast<Niflib::APSysData>;
+%template(StaticCastToAPSysData) Niflib::StaticCast<Niflib::APSysData>;
 %include "obj/bhkBlendCollisionObject.h"
-%template(bhkBlendCollisionObjectRef) Ref<bhkBlendCollisionObject>;
-%template(DynamicCastTobhkBlendCollisionObject) DynamicCast<bhkBlendCollisionObject>;
-%template(StaticCastTobhkBlendCollisionObject) StaticCast<bhkBlendCollisionObject>;
+%template(bhkBlendCollisionObjectRef) Niflib::Ref<Niflib::bhkBlendCollisionObject>;
+%template(DynamicCastTobhkBlendCollisionObject) Niflib::DynamicCast<Niflib::bhkBlendCollisionObject>;
+%template(StaticCastTobhkBlendCollisionObject) Niflib::StaticCast<Niflib::bhkBlendCollisionObject>;
 %include "obj/bhkBlendController.h"
-%template(bhkBlendControllerRef) Ref<bhkBlendController>;
-%template(DynamicCastTobhkBlendController) DynamicCast<bhkBlendController>;
-%template(StaticCastTobhkBlendController) StaticCast<bhkBlendController>;
+%template(bhkBlendControllerRef) Niflib::Ref<Niflib::bhkBlendController>;
+%template(DynamicCastTobhkBlendController) Niflib::DynamicCast<Niflib::bhkBlendController>;
+%template(StaticCastTobhkBlendController) Niflib::StaticCast<Niflib::bhkBlendController>;
 %include "obj/bhkBoxShape.h"
-%template(bhkBoxShapeRef) Ref<bhkBoxShape>;
-%template(DynamicCastTobhkBoxShape) DynamicCast<bhkBoxShape>;
-%template(StaticCastTobhkBoxShape) StaticCast<bhkBoxShape>;
+%template(bhkBoxShapeRef) Niflib::Ref<Niflib::bhkBoxShape>;
+%template(DynamicCastTobhkBoxShape) Niflib::DynamicCast<Niflib::bhkBoxShape>;
+%template(StaticCastTobhkBoxShape) Niflib::StaticCast<Niflib::bhkBoxShape>;
 %include "obj/bhkCapsuleShape.h"
-%template(bhkCapsuleShapeRef) Ref<bhkCapsuleShape>;
-%template(DynamicCastTobhkCapsuleShape) DynamicCast<bhkCapsuleShape>;
-%template(StaticCastTobhkCapsuleShape) StaticCast<bhkCapsuleShape>;
+%template(bhkCapsuleShapeRef) Niflib::Ref<Niflib::bhkCapsuleShape>;
+%template(DynamicCastTobhkCapsuleShape) Niflib::DynamicCast<Niflib::bhkCapsuleShape>;
+%template(StaticCastTobhkCapsuleShape) Niflib::StaticCast<Niflib::bhkCapsuleShape>;
 %include "obj/bhkCollisionObject.h"
-%template(bhkCollisionObjectRef) Ref<bhkCollisionObject>;
-%template(DynamicCastTobhkCollisionObject) DynamicCast<bhkCollisionObject>;
-%template(StaticCastTobhkCollisionObject) StaticCast<bhkCollisionObject>;
+%template(bhkCollisionObjectRef) Niflib::Ref<Niflib::bhkCollisionObject>;
+%template(DynamicCastTobhkCollisionObject) Niflib::DynamicCast<Niflib::bhkCollisionObject>;
+%template(StaticCastTobhkCollisionObject) Niflib::StaticCast<Niflib::bhkCollisionObject>;
 %include "obj/bhkConvexVerticesShape.h"
-%template(bhkConvexVerticesShapeRef) Ref<bhkConvexVerticesShape>;
-%template(DynamicCastTobhkConvexVerticesShape) DynamicCast<bhkConvexVerticesShape>;
-%template(StaticCastTobhkConvexVerticesShape) StaticCast<bhkConvexVerticesShape>;
+%template(bhkConvexVerticesShapeRef) Niflib::Ref<Niflib::bhkConvexVerticesShape>;
+%template(DynamicCastTobhkConvexVerticesShape) Niflib::DynamicCast<Niflib::bhkConvexVerticesShape>;
+%template(StaticCastTobhkConvexVerticesShape) Niflib::StaticCast<Niflib::bhkConvexVerticesShape>;
 %include "obj/bhkHingeConstraint.h"
-%template(bhkHingeConstraintRef) Ref<bhkHingeConstraint>;
-%template(DynamicCastTobhkHingeConstraint) DynamicCast<bhkHingeConstraint>;
-%template(StaticCastTobhkHingeConstraint) StaticCast<bhkHingeConstraint>;
+%template(bhkHingeConstraintRef) Niflib::Ref<Niflib::bhkHingeConstraint>;
+%template(DynamicCastTobhkHingeConstraint) Niflib::DynamicCast<Niflib::bhkHingeConstraint>;
+%template(StaticCastTobhkHingeConstraint) Niflib::StaticCast<Niflib::bhkHingeConstraint>;
 %include "obj/bhkLimitedHingeConstraint.h"
-%template(bhkLimitedHingeConstraintRef) Ref<bhkLimitedHingeConstraint>;
-%template(DynamicCastTobhkLimitedHingeConstraint) DynamicCast<bhkLimitedHingeConstraint>;
-%template(StaticCastTobhkLimitedHingeConstraint) StaticCast<bhkLimitedHingeConstraint>;
+%template(bhkLimitedHingeConstraintRef) Niflib::Ref<Niflib::bhkLimitedHingeConstraint>;
+%template(DynamicCastTobhkLimitedHingeConstraint) Niflib::DynamicCast<Niflib::bhkLimitedHingeConstraint>;
+%template(StaticCastTobhkLimitedHingeConstraint) Niflib::StaticCast<Niflib::bhkLimitedHingeConstraint>;
 %include "obj/bhkListShape.h"
-%template(bhkListShapeRef) Ref<bhkListShape>;
-%template(DynamicCastTobhkListShape) DynamicCast<bhkListShape>;
-%template(StaticCastTobhkListShape) StaticCast<bhkListShape>;
+%template(bhkListShapeRef) Niflib::Ref<Niflib::bhkListShape>;
+%template(DynamicCastTobhkListShape) Niflib::DynamicCast<Niflib::bhkListShape>;
+%template(StaticCastTobhkListShape) Niflib::StaticCast<Niflib::bhkListShape>;
 %include "obj/bhkMalleableConstraint.h"
-%template(bhkMalleableConstraintRef) Ref<bhkMalleableConstraint>;
-%template(DynamicCastTobhkMalleableConstraint) DynamicCast<bhkMalleableConstraint>;
-%template(StaticCastTobhkMalleableConstraint) StaticCast<bhkMalleableConstraint>;
+%template(bhkMalleableConstraintRef) Niflib::Ref<Niflib::bhkMalleableConstraint>;
+%template(DynamicCastTobhkMalleableConstraint) Niflib::DynamicCast<Niflib::bhkMalleableConstraint>;
+%template(StaticCastTobhkMalleableConstraint) Niflib::StaticCast<Niflib::bhkMalleableConstraint>;
 %include "obj/bhkMoppBvTreeShape.h"
-%template(bhkMoppBvTreeShapeRef) Ref<bhkMoppBvTreeShape>;
-%template(DynamicCastTobhkMoppBvTreeShape) DynamicCast<bhkMoppBvTreeShape>;
-%template(StaticCastTobhkMoppBvTreeShape) StaticCast<bhkMoppBvTreeShape>;
+%template(bhkMoppBvTreeShapeRef) Niflib::Ref<Niflib::bhkMoppBvTreeShape>;
+%template(DynamicCastTobhkMoppBvTreeShape) Niflib::DynamicCast<Niflib::bhkMoppBvTreeShape>;
+%template(StaticCastTobhkMoppBvTreeShape) Niflib::StaticCast<Niflib::bhkMoppBvTreeShape>;
 %include "obj/bhkMultiSphereShape.h"
-%template(bhkMultiSphereShapeRef) Ref<bhkMultiSphereShape>;
-%template(DynamicCastTobhkMultiSphereShape) DynamicCast<bhkMultiSphereShape>;
-%template(StaticCastTobhkMultiSphereShape) StaticCast<bhkMultiSphereShape>;
+%template(bhkMultiSphereShapeRef) Niflib::Ref<Niflib::bhkMultiSphereShape>;
+%template(DynamicCastTobhkMultiSphereShape) Niflib::DynamicCast<Niflib::bhkMultiSphereShape>;
+%template(StaticCastTobhkMultiSphereShape) Niflib::StaticCast<Niflib::bhkMultiSphereShape>;
 %include "obj/bhkNiTriStripsShape.h"
-%template(bhkNiTriStripsShapeRef) Ref<bhkNiTriStripsShape>;
-%template(DynamicCastTobhkNiTriStripsShape) DynamicCast<bhkNiTriStripsShape>;
-%template(StaticCastTobhkNiTriStripsShape) StaticCast<bhkNiTriStripsShape>;
+%template(bhkNiTriStripsShapeRef) Niflib::Ref<Niflib::bhkNiTriStripsShape>;
+%template(DynamicCastTobhkNiTriStripsShape) Niflib::DynamicCast<Niflib::bhkNiTriStripsShape>;
+%template(StaticCastTobhkNiTriStripsShape) Niflib::StaticCast<Niflib::bhkNiTriStripsShape>;
 %include "obj/bhkPackedNiTriStripsShape.h"
-%template(bhkPackedNiTriStripsShapeRef) Ref<bhkPackedNiTriStripsShape>;
-%template(DynamicCastTobhkPackedNiTriStripsShape) DynamicCast<bhkPackedNiTriStripsShape>;
-%template(StaticCastTobhkPackedNiTriStripsShape) StaticCast<bhkPackedNiTriStripsShape>;
+%template(bhkPackedNiTriStripsShapeRef) Niflib::Ref<Niflib::bhkPackedNiTriStripsShape>;
+%template(DynamicCastTobhkPackedNiTriStripsShape) Niflib::DynamicCast<Niflib::bhkPackedNiTriStripsShape>;
+%template(StaticCastTobhkPackedNiTriStripsShape) Niflib::StaticCast<Niflib::bhkPackedNiTriStripsShape>;
 %include "obj/bhkPrismaticConstraint.h"
-%template(bhkPrismaticConstraintRef) Ref<bhkPrismaticConstraint>;
-%template(DynamicCastTobhkPrismaticConstraint) DynamicCast<bhkPrismaticConstraint>;
-%template(StaticCastTobhkPrismaticConstraint) StaticCast<bhkPrismaticConstraint>;
+%template(bhkPrismaticConstraintRef) Niflib::Ref<Niflib::bhkPrismaticConstraint>;
+%template(DynamicCastTobhkPrismaticConstraint) Niflib::DynamicCast<Niflib::bhkPrismaticConstraint>;
+%template(StaticCastTobhkPrismaticConstraint) Niflib::StaticCast<Niflib::bhkPrismaticConstraint>;
 %include "obj/bhkRagdollConstraint.h"
-%template(bhkRagdollConstraintRef) Ref<bhkRagdollConstraint>;
-%template(DynamicCastTobhkRagdollConstraint) DynamicCast<bhkRagdollConstraint>;
-%template(StaticCastTobhkRagdollConstraint) StaticCast<bhkRagdollConstraint>;
+%template(bhkRagdollConstraintRef) Niflib::Ref<Niflib::bhkRagdollConstraint>;
+%template(DynamicCastTobhkRagdollConstraint) Niflib::DynamicCast<Niflib::bhkRagdollConstraint>;
+%template(StaticCastTobhkRagdollConstraint) Niflib::StaticCast<Niflib::bhkRagdollConstraint>;
 %include "obj/bhkRigidBody.h"
-%template(bhkRigidBodyRef) Ref<bhkRigidBody>;
-%template(DynamicCastTobhkRigidBody) DynamicCast<bhkRigidBody>;
-%template(StaticCastTobhkRigidBody) StaticCast<bhkRigidBody>;
+%template(bhkRigidBodyRef) Niflib::Ref<Niflib::bhkRigidBody>;
+%template(DynamicCastTobhkRigidBody) Niflib::DynamicCast<Niflib::bhkRigidBody>;
+%template(StaticCastTobhkRigidBody) Niflib::StaticCast<Niflib::bhkRigidBody>;
 %include "obj/bhkRigidBodyT.h"
-%template(bhkRigidBodyTRef) Ref<bhkRigidBodyT>;
-%template(DynamicCastTobhkRigidBodyT) DynamicCast<bhkRigidBodyT>;
-%template(StaticCastTobhkRigidBodyT) StaticCast<bhkRigidBodyT>;
+%template(bhkRigidBodyTRef) Niflib::Ref<Niflib::bhkRigidBodyT>;
+%template(DynamicCastTobhkRigidBodyT) Niflib::DynamicCast<Niflib::bhkRigidBodyT>;
+%template(StaticCastTobhkRigidBodyT) Niflib::StaticCast<Niflib::bhkRigidBodyT>;
 %include "obj/bhkSimpleShapePhantom.h"
-%template(bhkSimpleShapePhantomRef) Ref<bhkSimpleShapePhantom>;
-%template(DynamicCastTobhkSimpleShapePhantom) DynamicCast<bhkSimpleShapePhantom>;
-%template(StaticCastTobhkSimpleShapePhantom) StaticCast<bhkSimpleShapePhantom>;
+%template(bhkSimpleShapePhantomRef) Niflib::Ref<Niflib::bhkSimpleShapePhantom>;
+%template(DynamicCastTobhkSimpleShapePhantom) Niflib::DynamicCast<Niflib::bhkSimpleShapePhantom>;
+%template(StaticCastTobhkSimpleShapePhantom) Niflib::StaticCast<Niflib::bhkSimpleShapePhantom>;
 %include "obj/bhkSPCollisionObject.h"
-%template(bhkSPCollisionObjectRef) Ref<bhkSPCollisionObject>;
-%template(DynamicCastTobhkSPCollisionObject) DynamicCast<bhkSPCollisionObject>;
-%template(StaticCastTobhkSPCollisionObject) StaticCast<bhkSPCollisionObject>;
+%template(bhkSPCollisionObjectRef) Niflib::Ref<Niflib::bhkSPCollisionObject>;
+%template(DynamicCastTobhkSPCollisionObject) Niflib::DynamicCast<Niflib::bhkSPCollisionObject>;
+%template(StaticCastTobhkSPCollisionObject) Niflib::StaticCast<Niflib::bhkSPCollisionObject>;
 %include "obj/bhkSphereShape.h"
-%template(bhkSphereShapeRef) Ref<bhkSphereShape>;
-%template(DynamicCastTobhkSphereShape) DynamicCast<bhkSphereShape>;
-%template(StaticCastTobhkSphereShape) StaticCast<bhkSphereShape>;
+%template(bhkSphereShapeRef) Niflib::Ref<Niflib::bhkSphereShape>;
+%template(DynamicCastTobhkSphereShape) Niflib::DynamicCast<Niflib::bhkSphereShape>;
+%template(StaticCastTobhkSphereShape) Niflib::StaticCast<Niflib::bhkSphereShape>;
 %include "obj/bhkStiffSpringConstraint.h"
-%template(bhkStiffSpringConstraintRef) Ref<bhkStiffSpringConstraint>;
-%template(DynamicCastTobhkStiffSpringConstraint) DynamicCast<bhkStiffSpringConstraint>;
-%template(StaticCastTobhkStiffSpringConstraint) StaticCast<bhkStiffSpringConstraint>;
+%template(bhkStiffSpringConstraintRef) Niflib::Ref<Niflib::bhkStiffSpringConstraint>;
+%template(DynamicCastTobhkStiffSpringConstraint) Niflib::DynamicCast<Niflib::bhkStiffSpringConstraint>;
+%template(StaticCastTobhkStiffSpringConstraint) Niflib::StaticCast<Niflib::bhkStiffSpringConstraint>;
 %include "obj/bhkTransformShape.h"
-%template(bhkTransformShapeRef) Ref<bhkTransformShape>;
-%template(DynamicCastTobhkTransformShape) DynamicCast<bhkTransformShape>;
-%template(StaticCastTobhkTransformShape) StaticCast<bhkTransformShape>;
+%template(bhkTransformShapeRef) Niflib::Ref<Niflib::bhkTransformShape>;
+%template(DynamicCastTobhkTransformShape) Niflib::DynamicCast<Niflib::bhkTransformShape>;
+%template(StaticCastTobhkTransformShape) Niflib::StaticCast<Niflib::bhkTransformShape>;
 %include "obj/bhkConvexTransformShape.h"
-%template(bhkConvexTransformShapeRef) Ref<bhkConvexTransformShape>;
-%template(DynamicCastTobhkConvexTransformShape) DynamicCast<bhkConvexTransformShape>;
-%template(StaticCastTobhkConvexTransformShape) StaticCast<bhkConvexTransformShape>;
+%template(bhkConvexTransformShapeRef) Niflib::Ref<Niflib::bhkConvexTransformShape>;
+%template(DynamicCastTobhkConvexTransformShape) Niflib::DynamicCast<Niflib::bhkConvexTransformShape>;
+%template(StaticCastTobhkConvexTransformShape) Niflib::StaticCast<Niflib::bhkConvexTransformShape>;
 %include "obj/BSBound.h"
-%template(BSBoundRef) Ref<BSBound>;
-%template(DynamicCastToBSBound) DynamicCast<BSBound>;
-%template(StaticCastToBSBound) StaticCast<BSBound>;
+%template(BSBoundRef) Niflib::Ref<Niflib::BSBound>;
+%template(DynamicCastToBSBound) Niflib::DynamicCast<Niflib::BSBound>;
+%template(StaticCastToBSBound) Niflib::StaticCast<Niflib::BSBound>;
 %include "obj/BSFurnitureMarker.h"
-%template(BSFurnitureMarkerRef) Ref<BSFurnitureMarker>;
-%template(DynamicCastToBSFurnitureMarker) DynamicCast<BSFurnitureMarker>;
-%template(StaticCastToBSFurnitureMarker) StaticCast<BSFurnitureMarker>;
+%template(BSFurnitureMarkerRef) Niflib::Ref<Niflib::BSFurnitureMarker>;
+%template(DynamicCastToBSFurnitureMarker) Niflib::DynamicCast<Niflib::BSFurnitureMarker>;
+%template(StaticCastToBSFurnitureMarker) Niflib::StaticCast<Niflib::BSFurnitureMarker>;
 %include "obj/BSParentVelocityModifier.h"
-%template(BSParentVelocityModifierRef) Ref<BSParentVelocityModifier>;
-%template(DynamicCastToBSParentVelocityModifier) DynamicCast<BSParentVelocityModifier>;
-%template(StaticCastToBSParentVelocityModifier) StaticCast<BSParentVelocityModifier>;
+%template(BSParentVelocityModifierRef) Niflib::Ref<Niflib::BSParentVelocityModifier>;
+%template(DynamicCastToBSParentVelocityModifier) Niflib::DynamicCast<Niflib::BSParentVelocityModifier>;
+%template(StaticCastToBSParentVelocityModifier) Niflib::StaticCast<Niflib::BSParentVelocityModifier>;
 %include "obj/BSPSysArrayEmitter.h"
-%template(BSPSysArrayEmitterRef) Ref<BSPSysArrayEmitter>;
-%template(DynamicCastToBSPSysArrayEmitter) DynamicCast<BSPSysArrayEmitter>;
-%template(StaticCastToBSPSysArrayEmitter) StaticCast<BSPSysArrayEmitter>;
+%template(BSPSysArrayEmitterRef) Niflib::Ref<Niflib::BSPSysArrayEmitter>;
+%template(DynamicCastToBSPSysArrayEmitter) Niflib::DynamicCast<Niflib::BSPSysArrayEmitter>;
+%template(StaticCastToBSPSysArrayEmitter) Niflib::StaticCast<Niflib::BSPSysArrayEmitter>;
 %include "obj/BSXFlags.h"
-%template(BSXFlagsRef) Ref<BSXFlags>;
-%template(DynamicCastToBSXFlags) DynamicCast<BSXFlags>;
-%template(StaticCastToBSXFlags) StaticCast<BSXFlags>;
+%template(BSXFlagsRef) Niflib::Ref<Niflib::BSXFlags>;
+%template(DynamicCastToBSXFlags) Niflib::DynamicCast<Niflib::BSXFlags>;
+%template(StaticCastToBSXFlags) Niflib::StaticCast<Niflib::BSXFlags>;
 %include "obj/hkPackedNiTriStripsData.h"
-%template(hkPackedNiTriStripsDataRef) Ref<hkPackedNiTriStripsData>;
-%template(DynamicCastTohkPackedNiTriStripsData) DynamicCast<hkPackedNiTriStripsData>;
-%template(StaticCastTohkPackedNiTriStripsData) StaticCast<hkPackedNiTriStripsData>;
+%template(hkPackedNiTriStripsDataRef) Niflib::Ref<Niflib::hkPackedNiTriStripsData>;
+%template(DynamicCastTohkPackedNiTriStripsData) Niflib::DynamicCast<Niflib::hkPackedNiTriStripsData>;
+%template(StaticCastTohkPackedNiTriStripsData) Niflib::StaticCast<Niflib::hkPackedNiTriStripsData>;
 %include "obj/NiAlphaController.h"
-%template(NiAlphaControllerRef) Ref<NiAlphaController>;
-%template(DynamicCastToNiAlphaController) DynamicCast<NiAlphaController>;
-%template(StaticCastToNiAlphaController) StaticCast<NiAlphaController>;
+%template(NiAlphaControllerRef) Niflib::Ref<Niflib::NiAlphaController>;
+%template(DynamicCastToNiAlphaController) Niflib::DynamicCast<Niflib::NiAlphaController>;
+%template(StaticCastToNiAlphaController) Niflib::StaticCast<Niflib::NiAlphaController>;
 %include "obj/NiAlphaProperty.h"
-%template(NiAlphaPropertyRef) Ref<NiAlphaProperty>;
-%template(DynamicCastToNiAlphaProperty) DynamicCast<NiAlphaProperty>;
-%template(StaticCastToNiAlphaProperty) StaticCast<NiAlphaProperty>;
+%template(NiAlphaPropertyRef) Niflib::Ref<Niflib::NiAlphaProperty>;
+%template(DynamicCastToNiAlphaProperty) Niflib::DynamicCast<Niflib::NiAlphaProperty>;
+%template(StaticCastToNiAlphaProperty) Niflib::StaticCast<Niflib::NiAlphaProperty>;
 %include "obj/NiAmbientLight.h"
-%template(NiAmbientLightRef) Ref<NiAmbientLight>;
-%template(DynamicCastToNiAmbientLight) DynamicCast<NiAmbientLight>;
-%template(StaticCastToNiAmbientLight) StaticCast<NiAmbientLight>;
+%template(NiAmbientLightRef) Niflib::Ref<Niflib::NiAmbientLight>;
+%template(DynamicCastToNiAmbientLight) Niflib::DynamicCast<Niflib::NiAmbientLight>;
+%template(StaticCastToNiAmbientLight) Niflib::StaticCast<Niflib::NiAmbientLight>;
 %include "obj/NiAutoNormalParticlesData.h"
-%template(NiAutoNormalParticlesDataRef) Ref<NiAutoNormalParticlesData>;
-%template(DynamicCastToNiAutoNormalParticlesData) DynamicCast<NiAutoNormalParticlesData>;
-%template(StaticCastToNiAutoNormalParticlesData) StaticCast<NiAutoNormalParticlesData>;
+%template(NiAutoNormalParticlesDataRef) Niflib::Ref<Niflib::NiAutoNormalParticlesData>;
+%template(DynamicCastToNiAutoNormalParticlesData) Niflib::DynamicCast<Niflib::NiAutoNormalParticlesData>;
+%template(StaticCastToNiAutoNormalParticlesData) Niflib::StaticCast<Niflib::NiAutoNormalParticlesData>;
 %include "obj/NiBinaryExtraData.h"
-%template(NiBinaryExtraDataRef) Ref<NiBinaryExtraData>;
-%template(DynamicCastToNiBinaryExtraData) DynamicCast<NiBinaryExtraData>;
-%template(StaticCastToNiBinaryExtraData) StaticCast<NiBinaryExtraData>;
+%template(NiBinaryExtraDataRef) Niflib::Ref<Niflib::NiBinaryExtraData>;
+%template(DynamicCastToNiBinaryExtraData) Niflib::DynamicCast<Niflib::NiBinaryExtraData>;
+%template(StaticCastToNiBinaryExtraData) Niflib::StaticCast<Niflib::NiBinaryExtraData>;
 %include "obj/NiBlendBoolInterpolator.h"
-%template(NiBlendBoolInterpolatorRef) Ref<NiBlendBoolInterpolator>;
-%template(DynamicCastToNiBlendBoolInterpolator) DynamicCast<NiBlendBoolInterpolator>;
-%template(StaticCastToNiBlendBoolInterpolator) StaticCast<NiBlendBoolInterpolator>;
+%template(NiBlendBoolInterpolatorRef) Niflib::Ref<Niflib::NiBlendBoolInterpolator>;
+%template(DynamicCastToNiBlendBoolInterpolator) Niflib::DynamicCast<Niflib::NiBlendBoolInterpolator>;
+%template(StaticCastToNiBlendBoolInterpolator) Niflib::StaticCast<Niflib::NiBlendBoolInterpolator>;
 %include "obj/NiBlendFloatInterpolator.h"
-%template(NiBlendFloatInterpolatorRef) Ref<NiBlendFloatInterpolator>;
-%template(DynamicCastToNiBlendFloatInterpolator) DynamicCast<NiBlendFloatInterpolator>;
-%template(StaticCastToNiBlendFloatInterpolator) StaticCast<NiBlendFloatInterpolator>;
+%template(NiBlendFloatInterpolatorRef) Niflib::Ref<Niflib::NiBlendFloatInterpolator>;
+%template(DynamicCastToNiBlendFloatInterpolator) Niflib::DynamicCast<Niflib::NiBlendFloatInterpolator>;
+%template(StaticCastToNiBlendFloatInterpolator) Niflib::StaticCast<Niflib::NiBlendFloatInterpolator>;
 %include "obj/NiBlendPoint3Interpolator.h"
-%template(NiBlendPoint3InterpolatorRef) Ref<NiBlendPoint3Interpolator>;
-%template(DynamicCastToNiBlendPoint3Interpolator) DynamicCast<NiBlendPoint3Interpolator>;
-%template(StaticCastToNiBlendPoint3Interpolator) StaticCast<NiBlendPoint3Interpolator>;
+%template(NiBlendPoint3InterpolatorRef) Niflib::Ref<Niflib::NiBlendPoint3Interpolator>;
+%template(DynamicCastToNiBlendPoint3Interpolator) Niflib::DynamicCast<Niflib::NiBlendPoint3Interpolator>;
+%template(StaticCastToNiBlendPoint3Interpolator) Niflib::StaticCast<Niflib::NiBlendPoint3Interpolator>;
 %include "obj/NiBlendTransformInterpolator.h"
-%template(NiBlendTransformInterpolatorRef) Ref<NiBlendTransformInterpolator>;
-%template(DynamicCastToNiBlendTransformInterpolator) DynamicCast<NiBlendTransformInterpolator>;
-%template(StaticCastToNiBlendTransformInterpolator) StaticCast<NiBlendTransformInterpolator>;
+%template(NiBlendTransformInterpolatorRef) Niflib::Ref<Niflib::NiBlendTransformInterpolator>;
+%template(DynamicCastToNiBlendTransformInterpolator) Niflib::DynamicCast<Niflib::NiBlendTransformInterpolator>;
+%template(StaticCastToNiBlendTransformInterpolator) Niflib::StaticCast<Niflib::NiBlendTransformInterpolator>;
 %include "obj/NiBoneLODController.h"
-%template(NiBoneLODControllerRef) Ref<NiBoneLODController>;
-%template(DynamicCastToNiBoneLODController) DynamicCast<NiBoneLODController>;
-%template(StaticCastToNiBoneLODController) StaticCast<NiBoneLODController>;
+%template(NiBoneLODControllerRef) Niflib::Ref<Niflib::NiBoneLODController>;
+%template(DynamicCastToNiBoneLODController) Niflib::DynamicCast<Niflib::NiBoneLODController>;
+%template(StaticCastToNiBoneLODController) Niflib::StaticCast<Niflib::NiBoneLODController>;
 %include "obj/NiBoolData.h"
-%template(NiBoolDataRef) Ref<NiBoolData>;
-%template(DynamicCastToNiBoolData) DynamicCast<NiBoolData>;
-%template(StaticCastToNiBoolData) StaticCast<NiBoolData>;
+%template(NiBoolDataRef) Niflib::Ref<Niflib::NiBoolData>;
+%template(DynamicCastToNiBoolData) Niflib::DynamicCast<Niflib::NiBoolData>;
+%template(StaticCastToNiBoolData) Niflib::StaticCast<Niflib::NiBoolData>;
 %include "obj/NiBooleanExtraData.h"
-%template(NiBooleanExtraDataRef) Ref<NiBooleanExtraData>;
-%template(DynamicCastToNiBooleanExtraData) DynamicCast<NiBooleanExtraData>;
-%template(StaticCastToNiBooleanExtraData) StaticCast<NiBooleanExtraData>;
+%template(NiBooleanExtraDataRef) Niflib::Ref<Niflib::NiBooleanExtraData>;
+%template(DynamicCastToNiBooleanExtraData) Niflib::DynamicCast<Niflib::NiBooleanExtraData>;
+%template(StaticCastToNiBooleanExtraData) Niflib::StaticCast<Niflib::NiBooleanExtraData>;
 %include "obj/NiBoolInterpolator.h"
-%template(NiBoolInterpolatorRef) Ref<NiBoolInterpolator>;
-%template(DynamicCastToNiBoolInterpolator) DynamicCast<NiBoolInterpolator>;
-%template(StaticCastToNiBoolInterpolator) StaticCast<NiBoolInterpolator>;
+%template(NiBoolInterpolatorRef) Niflib::Ref<Niflib::NiBoolInterpolator>;
+%template(DynamicCastToNiBoolInterpolator) Niflib::DynamicCast<Niflib::NiBoolInterpolator>;
+%template(StaticCastToNiBoolInterpolator) Niflib::StaticCast<Niflib::NiBoolInterpolator>;
 %include "obj/NiBoolTimelineInterpolator.h"
-%template(NiBoolTimelineInterpolatorRef) Ref<NiBoolTimelineInterpolator>;
-%template(DynamicCastToNiBoolTimelineInterpolator) DynamicCast<NiBoolTimelineInterpolator>;
-%template(StaticCastToNiBoolTimelineInterpolator) StaticCast<NiBoolTimelineInterpolator>;
+%template(NiBoolTimelineInterpolatorRef) Niflib::Ref<Niflib::NiBoolTimelineInterpolator>;
+%template(DynamicCastToNiBoolTimelineInterpolator) Niflib::DynamicCast<Niflib::NiBoolTimelineInterpolator>;
+%template(StaticCastToNiBoolTimelineInterpolator) Niflib::StaticCast<Niflib::NiBoolTimelineInterpolator>;
 %include "obj/NiBSBoneLODController.h"
-%template(NiBSBoneLODControllerRef) Ref<NiBSBoneLODController>;
-%template(DynamicCastToNiBSBoneLODController) DynamicCast<NiBSBoneLODController>;
-%template(StaticCastToNiBSBoneLODController) StaticCast<NiBSBoneLODController>;
+%template(NiBSBoneLODControllerRef) Niflib::Ref<Niflib::NiBSBoneLODController>;
+%template(DynamicCastToNiBSBoneLODController) Niflib::DynamicCast<Niflib::NiBSBoneLODController>;
+%template(StaticCastToNiBSBoneLODController) Niflib::StaticCast<Niflib::NiBSBoneLODController>;
 %include "obj/NiBSplineBasisData.h"
-%template(NiBSplineBasisDataRef) Ref<NiBSplineBasisData>;
-%template(DynamicCastToNiBSplineBasisData) DynamicCast<NiBSplineBasisData>;
-%template(StaticCastToNiBSplineBasisData) StaticCast<NiBSplineBasisData>;
+%template(NiBSplineBasisDataRef) Niflib::Ref<Niflib::NiBSplineBasisData>;
+%template(DynamicCastToNiBSplineBasisData) Niflib::DynamicCast<Niflib::NiBSplineBasisData>;
+%template(StaticCastToNiBSplineBasisData) Niflib::StaticCast<Niflib::NiBSplineBasisData>;
 %include "obj/NiBSplineCompFloatInterpolator.h"
-%template(NiBSplineCompFloatInterpolatorRef) Ref<NiBSplineCompFloatInterpolator>;
-%template(DynamicCastToNiBSplineCompFloatInterpolator) DynamicCast<NiBSplineCompFloatInterpolator>;
-%template(StaticCastToNiBSplineCompFloatInterpolator) StaticCast<NiBSplineCompFloatInterpolator>;
+%template(NiBSplineCompFloatInterpolatorRef) Niflib::Ref<Niflib::NiBSplineCompFloatInterpolator>;
+%template(DynamicCastToNiBSplineCompFloatInterpolator) Niflib::DynamicCast<Niflib::NiBSplineCompFloatInterpolator>;
+%template(StaticCastToNiBSplineCompFloatInterpolator) Niflib::StaticCast<Niflib::NiBSplineCompFloatInterpolator>;
 %include "obj/NiBSplineCompPoint3Interpolator.h"
-%template(NiBSplineCompPoint3InterpolatorRef) Ref<NiBSplineCompPoint3Interpolator>;
-%template(DynamicCastToNiBSplineCompPoint3Interpolator) DynamicCast<NiBSplineCompPoint3Interpolator>;
-%template(StaticCastToNiBSplineCompPoint3Interpolator) StaticCast<NiBSplineCompPoint3Interpolator>;
+%template(NiBSplineCompPoint3InterpolatorRef) Niflib::Ref<Niflib::NiBSplineCompPoint3Interpolator>;
+%template(DynamicCastToNiBSplineCompPoint3Interpolator) Niflib::DynamicCast<Niflib::NiBSplineCompPoint3Interpolator>;
+%template(StaticCastToNiBSplineCompPoint3Interpolator) Niflib::StaticCast<Niflib::NiBSplineCompPoint3Interpolator>;
 %include "obj/NiBSplineCompTransformInterpolator.h"
-%template(NiBSplineCompTransformInterpolatorRef) Ref<NiBSplineCompTransformInterpolator>;
-%template(DynamicCastToNiBSplineCompTransformInterpolator) DynamicCast<NiBSplineCompTransformInterpolator>;
-%template(StaticCastToNiBSplineCompTransformInterpolator) StaticCast<NiBSplineCompTransformInterpolator>;
+%template(NiBSplineCompTransformInterpolatorRef) Niflib::Ref<Niflib::NiBSplineCompTransformInterpolator>;
+%template(DynamicCastToNiBSplineCompTransformInterpolator) Niflib::DynamicCast<Niflib::NiBSplineCompTransformInterpolator>;
+%template(StaticCastToNiBSplineCompTransformInterpolator) Niflib::StaticCast<Niflib::NiBSplineCompTransformInterpolator>;
 %include "obj/NiBSplineData.h"
-%template(NiBSplineDataRef) Ref<NiBSplineData>;
-%template(DynamicCastToNiBSplineData) DynamicCast<NiBSplineData>;
-%template(StaticCastToNiBSplineData) StaticCast<NiBSplineData>;
+%template(NiBSplineDataRef) Niflib::Ref<Niflib::NiBSplineData>;
+%template(DynamicCastToNiBSplineData) Niflib::DynamicCast<Niflib::NiBSplineData>;
+%template(StaticCastToNiBSplineData) Niflib::StaticCast<Niflib::NiBSplineData>;
 %include "obj/NiCamera.h"
-%template(NiCameraRef) Ref<NiCamera>;
-%template(DynamicCastToNiCamera) DynamicCast<NiCamera>;
-%template(StaticCastToNiCamera) StaticCast<NiCamera>;
+%template(NiCameraRef) Niflib::Ref<Niflib::NiCamera>;
+%template(DynamicCastToNiCamera) Niflib::DynamicCast<Niflib::NiCamera>;
+%template(StaticCastToNiCamera) Niflib::StaticCast<Niflib::NiCamera>;
 %include "obj/NiCollisionData.h"
-%template(NiCollisionDataRef) Ref<NiCollisionData>;
-%template(DynamicCastToNiCollisionData) DynamicCast<NiCollisionData>;
-%template(StaticCastToNiCollisionData) StaticCast<NiCollisionData>;
+%template(NiCollisionDataRef) Niflib::Ref<Niflib::NiCollisionData>;
+%template(DynamicCastToNiCollisionData) Niflib::DynamicCast<Niflib::NiCollisionData>;
+%template(StaticCastToNiCollisionData) Niflib::StaticCast<Niflib::NiCollisionData>;
 %include "obj/NiColorData.h"
-%template(NiColorDataRef) Ref<NiColorData>;
-%template(DynamicCastToNiColorData) DynamicCast<NiColorData>;
-%template(StaticCastToNiColorData) StaticCast<NiColorData>;
+%template(NiColorDataRef) Niflib::Ref<Niflib::NiColorData>;
+%template(DynamicCastToNiColorData) Niflib::DynamicCast<Niflib::NiColorData>;
+%template(StaticCastToNiColorData) Niflib::StaticCast<Niflib::NiColorData>;
 %include "obj/NiColorExtraData.h"
-%template(NiColorExtraDataRef) Ref<NiColorExtraData>;
-%template(DynamicCastToNiColorExtraData) DynamicCast<NiColorExtraData>;
-%template(StaticCastToNiColorExtraData) StaticCast<NiColorExtraData>;
+%template(NiColorExtraDataRef) Niflib::Ref<Niflib::NiColorExtraData>;
+%template(DynamicCastToNiColorExtraData) Niflib::DynamicCast<Niflib::NiColorExtraData>;
+%template(StaticCastToNiColorExtraData) Niflib::StaticCast<Niflib::NiColorExtraData>;
 %include "obj/NiControllerManager.h"
-%template(NiControllerManagerRef) Ref<NiControllerManager>;
-%template(DynamicCastToNiControllerManager) DynamicCast<NiControllerManager>;
-%template(StaticCastToNiControllerManager) StaticCast<NiControllerManager>;
+%template(NiControllerManagerRef) Niflib::Ref<Niflib::NiControllerManager>;
+%template(DynamicCastToNiControllerManager) Niflib::DynamicCast<Niflib::NiControllerManager>;
+%template(StaticCastToNiControllerManager) Niflib::StaticCast<Niflib::NiControllerManager>;
 %include "obj/NiControllerSequence.h"
-%template(NiControllerSequenceRef) Ref<NiControllerSequence>;
-%template(DynamicCastToNiControllerSequence) DynamicCast<NiControllerSequence>;
-%template(StaticCastToNiControllerSequence) StaticCast<NiControllerSequence>;
+%template(NiControllerSequenceRef) Niflib::Ref<Niflib::NiControllerSequence>;
+%template(DynamicCastToNiControllerSequence) Niflib::DynamicCast<Niflib::NiControllerSequence>;
+%template(StaticCastToNiControllerSequence) Niflib::StaticCast<Niflib::NiControllerSequence>;
 %include "obj/NiDefaultAVObjectPalette.h"
-%template(NiDefaultAVObjectPaletteRef) Ref<NiDefaultAVObjectPalette>;
-%template(DynamicCastToNiDefaultAVObjectPalette) DynamicCast<NiDefaultAVObjectPalette>;
-%template(StaticCastToNiDefaultAVObjectPalette) StaticCast<NiDefaultAVObjectPalette>;
+%template(NiDefaultAVObjectPaletteRef) Niflib::Ref<Niflib::NiDefaultAVObjectPalette>;
+%template(DynamicCastToNiDefaultAVObjectPalette) Niflib::DynamicCast<Niflib::NiDefaultAVObjectPalette>;
+%template(StaticCastToNiDefaultAVObjectPalette) Niflib::StaticCast<Niflib::NiDefaultAVObjectPalette>;
 %include "obj/NiDirectionalLight.h"
-%template(NiDirectionalLightRef) Ref<NiDirectionalLight>;
-%template(DynamicCastToNiDirectionalLight) DynamicCast<NiDirectionalLight>;
-%template(StaticCastToNiDirectionalLight) StaticCast<NiDirectionalLight>;
+%template(NiDirectionalLightRef) Niflib::Ref<Niflib::NiDirectionalLight>;
+%template(DynamicCastToNiDirectionalLight) Niflib::DynamicCast<Niflib::NiDirectionalLight>;
+%template(StaticCastToNiDirectionalLight) Niflib::StaticCast<Niflib::NiDirectionalLight>;
 %include "obj/NiDitherProperty.h"
-%template(NiDitherPropertyRef) Ref<NiDitherProperty>;
-%template(DynamicCastToNiDitherProperty) DynamicCast<NiDitherProperty>;
-%template(StaticCastToNiDitherProperty) StaticCast<NiDitherProperty>;
+%template(NiDitherPropertyRef) Niflib::Ref<Niflib::NiDitherProperty>;
+%template(DynamicCastToNiDitherProperty) Niflib::DynamicCast<Niflib::NiDitherProperty>;
+%template(StaticCastToNiDitherProperty) Niflib::StaticCast<Niflib::NiDitherProperty>;
 %include "obj/NiFlipController.h"
-%template(NiFlipControllerRef) Ref<NiFlipController>;
-%template(DynamicCastToNiFlipController) DynamicCast<NiFlipController>;
-%template(StaticCastToNiFlipController) StaticCast<NiFlipController>;
+%template(NiFlipControllerRef) Niflib::Ref<Niflib::NiFlipController>;
+%template(DynamicCastToNiFlipController) Niflib::DynamicCast<Niflib::NiFlipController>;
+%template(StaticCastToNiFlipController) Niflib::StaticCast<Niflib::NiFlipController>;
 %include "obj/NiFloatData.h"
-%template(NiFloatDataRef) Ref<NiFloatData>;
-%template(DynamicCastToNiFloatData) DynamicCast<NiFloatData>;
-%template(StaticCastToNiFloatData) StaticCast<NiFloatData>;
+%template(NiFloatDataRef) Niflib::Ref<Niflib::NiFloatData>;
+%template(DynamicCastToNiFloatData) Niflib::DynamicCast<Niflib::NiFloatData>;
+%template(StaticCastToNiFloatData) Niflib::StaticCast<Niflib::NiFloatData>;
 %include "obj/NiFloatExtraData.h"
-%template(NiFloatExtraDataRef) Ref<NiFloatExtraData>;
-%template(DynamicCastToNiFloatExtraData) DynamicCast<NiFloatExtraData>;
-%template(StaticCastToNiFloatExtraData) StaticCast<NiFloatExtraData>;
+%template(NiFloatExtraDataRef) Niflib::Ref<Niflib::NiFloatExtraData>;
+%template(DynamicCastToNiFloatExtraData) Niflib::DynamicCast<Niflib::NiFloatExtraData>;
+%template(StaticCastToNiFloatExtraData) Niflib::StaticCast<Niflib::NiFloatExtraData>;
 %include "obj/NiFloatExtraDataController.h"
-%template(NiFloatExtraDataControllerRef) Ref<NiFloatExtraDataController>;
-%template(DynamicCastToNiFloatExtraDataController) DynamicCast<NiFloatExtraDataController>;
-%template(StaticCastToNiFloatExtraDataController) StaticCast<NiFloatExtraDataController>;
+%template(NiFloatExtraDataControllerRef) Niflib::Ref<Niflib::NiFloatExtraDataController>;
+%template(DynamicCastToNiFloatExtraDataController) Niflib::DynamicCast<Niflib::NiFloatExtraDataController>;
+%template(StaticCastToNiFloatExtraDataController) Niflib::StaticCast<Niflib::NiFloatExtraDataController>;
 %include "obj/NiFloatInterpolator.h"
-%template(NiFloatInterpolatorRef) Ref<NiFloatInterpolator>;
-%template(DynamicCastToNiFloatInterpolator) DynamicCast<NiFloatInterpolator>;
-%template(StaticCastToNiFloatInterpolator) StaticCast<NiFloatInterpolator>;
+%template(NiFloatInterpolatorRef) Niflib::Ref<Niflib::NiFloatInterpolator>;
+%template(DynamicCastToNiFloatInterpolator) Niflib::DynamicCast<Niflib::NiFloatInterpolator>;
+%template(StaticCastToNiFloatInterpolator) Niflib::StaticCast<Niflib::NiFloatInterpolator>;
 %include "obj/NiFloatsExtraData.h"
-%template(NiFloatsExtraDataRef) Ref<NiFloatsExtraData>;
-%template(DynamicCastToNiFloatsExtraData) DynamicCast<NiFloatsExtraData>;
-%template(StaticCastToNiFloatsExtraData) StaticCast<NiFloatsExtraData>;
+%template(NiFloatsExtraDataRef) Niflib::Ref<Niflib::NiFloatsExtraData>;
+%template(DynamicCastToNiFloatsExtraData) Niflib::DynamicCast<Niflib::NiFloatsExtraData>;
+%template(StaticCastToNiFloatsExtraData) Niflib::StaticCast<Niflib::NiFloatsExtraData>;
 %include "obj/NiFogProperty.h"
-%template(NiFogPropertyRef) Ref<NiFogProperty>;
-%template(DynamicCastToNiFogProperty) DynamicCast<NiFogProperty>;
-%template(StaticCastToNiFogProperty) StaticCast<NiFogProperty>;
+%template(NiFogPropertyRef) Niflib::Ref<Niflib::NiFogProperty>;
+%template(DynamicCastToNiFogProperty) Niflib::DynamicCast<Niflib::NiFogProperty>;
+%template(StaticCastToNiFogProperty) Niflib::StaticCast<Niflib::NiFogProperty>;
 %include "obj/NiGeomMorpherController.h"
-%template(NiGeomMorpherControllerRef) Ref<NiGeomMorpherController>;
-%template(DynamicCastToNiGeomMorpherController) DynamicCast<NiGeomMorpherController>;
-%template(StaticCastToNiGeomMorpherController) StaticCast<NiGeomMorpherController>;
+%template(NiGeomMorpherControllerRef) Niflib::Ref<Niflib::NiGeomMorpherController>;
+%template(DynamicCastToNiGeomMorpherController) Niflib::DynamicCast<Niflib::NiGeomMorpherController>;
+%template(StaticCastToNiGeomMorpherController) Niflib::StaticCast<Niflib::NiGeomMorpherController>;
 %include "obj/NiGravity.h"
-%template(NiGravityRef) Ref<NiGravity>;
-%template(DynamicCastToNiGravity) DynamicCast<NiGravity>;
-%template(StaticCastToNiGravity) StaticCast<NiGravity>;
+%template(NiGravityRef) Niflib::Ref<Niflib::NiGravity>;
+%template(DynamicCastToNiGravity) Niflib::DynamicCast<Niflib::NiGravity>;
+%template(StaticCastToNiGravity) Niflib::StaticCast<Niflib::NiGravity>;
 %include "obj/NiIntegerExtraData.h"
-%template(NiIntegerExtraDataRef) Ref<NiIntegerExtraData>;
-%template(DynamicCastToNiIntegerExtraData) DynamicCast<NiIntegerExtraData>;
-%template(StaticCastToNiIntegerExtraData) StaticCast<NiIntegerExtraData>;
+%template(NiIntegerExtraDataRef) Niflib::Ref<Niflib::NiIntegerExtraData>;
+%template(DynamicCastToNiIntegerExtraData) Niflib::DynamicCast<Niflib::NiIntegerExtraData>;
+%template(StaticCastToNiIntegerExtraData) Niflib::StaticCast<Niflib::NiIntegerExtraData>;
 %include "obj/NiIntegersExtraData.h"
-%template(NiIntegersExtraDataRef) Ref<NiIntegersExtraData>;
-%template(DynamicCastToNiIntegersExtraData) DynamicCast<NiIntegersExtraData>;
-%template(StaticCastToNiIntegersExtraData) StaticCast<NiIntegersExtraData>;
+%template(NiIntegersExtraDataRef) Niflib::Ref<Niflib::NiIntegersExtraData>;
+%template(DynamicCastToNiIntegersExtraData) Niflib::DynamicCast<Niflib::NiIntegersExtraData>;
+%template(StaticCastToNiIntegersExtraData) Niflib::StaticCast<Niflib::NiIntegersExtraData>;
 %include "obj/NiKeyframeController.h"
-%template(NiKeyframeControllerRef) Ref<NiKeyframeController>;
-%template(DynamicCastToNiKeyframeController) DynamicCast<NiKeyframeController>;
-%template(StaticCastToNiKeyframeController) StaticCast<NiKeyframeController>;
+%template(NiKeyframeControllerRef) Niflib::Ref<Niflib::NiKeyframeController>;
+%template(DynamicCastToNiKeyframeController) Niflib::DynamicCast<Niflib::NiKeyframeController>;
+%template(StaticCastToNiKeyframeController) Niflib::StaticCast<Niflib::NiKeyframeController>;
 %include "obj/BSKeyframeController.h"
-%template(BSKeyframeControllerRef) Ref<BSKeyframeController>;
-%template(DynamicCastToBSKeyframeController) DynamicCast<BSKeyframeController>;
-%template(StaticCastToBSKeyframeController) StaticCast<BSKeyframeController>;
+%template(BSKeyframeControllerRef) Niflib::Ref<Niflib::BSKeyframeController>;
+%template(DynamicCastToBSKeyframeController) Niflib::DynamicCast<Niflib::BSKeyframeController>;
+%template(StaticCastToBSKeyframeController) Niflib::StaticCast<Niflib::BSKeyframeController>;
 %include "obj/NiKeyframeData.h"
-%template(NiKeyframeDataRef) Ref<NiKeyframeData>;
-%template(DynamicCastToNiKeyframeData) DynamicCast<NiKeyframeData>;
-%template(StaticCastToNiKeyframeData) StaticCast<NiKeyframeData>;
+%template(NiKeyframeDataRef) Niflib::Ref<Niflib::NiKeyframeData>;
+%template(DynamicCastToNiKeyframeData) Niflib::DynamicCast<Niflib::NiKeyframeData>;
+%template(StaticCastToNiKeyframeData) Niflib::StaticCast<Niflib::NiKeyframeData>;
 %include "obj/NiLightColorController.h"
-%template(NiLightColorControllerRef) Ref<NiLightColorController>;
-%template(DynamicCastToNiLightColorController) DynamicCast<NiLightColorController>;
-%template(StaticCastToNiLightColorController) StaticCast<NiLightColorController>;
+%template(NiLightColorControllerRef) Niflib::Ref<Niflib::NiLightColorController>;
+%template(DynamicCastToNiLightColorController) Niflib::DynamicCast<Niflib::NiLightColorController>;
+%template(StaticCastToNiLightColorController) Niflib::StaticCast<Niflib::NiLightColorController>;
 %include "obj/NiLightDimmerController.h"
-%template(NiLightDimmerControllerRef) Ref<NiLightDimmerController>;
-%template(DynamicCastToNiLightDimmerController) DynamicCast<NiLightDimmerController>;
-%template(StaticCastToNiLightDimmerController) StaticCast<NiLightDimmerController>;
+%template(NiLightDimmerControllerRef) Niflib::Ref<Niflib::NiLightDimmerController>;
+%template(DynamicCastToNiLightDimmerController) Niflib::DynamicCast<Niflib::NiLightDimmerController>;
+%template(StaticCastToNiLightDimmerController) Niflib::StaticCast<Niflib::NiLightDimmerController>;
 %include "obj/NiLookAtController.h"
-%template(NiLookAtControllerRef) Ref<NiLookAtController>;
-%template(DynamicCastToNiLookAtController) DynamicCast<NiLookAtController>;
-%template(StaticCastToNiLookAtController) StaticCast<NiLookAtController>;
+%template(NiLookAtControllerRef) Niflib::Ref<Niflib::NiLookAtController>;
+%template(DynamicCastToNiLookAtController) Niflib::DynamicCast<Niflib::NiLookAtController>;
+%template(StaticCastToNiLookAtController) Niflib::StaticCast<Niflib::NiLookAtController>;
 %include "obj/NiLookAtInterpolator.h"
-%template(NiLookAtInterpolatorRef) Ref<NiLookAtInterpolator>;
-%template(DynamicCastToNiLookAtInterpolator) DynamicCast<NiLookAtInterpolator>;
-%template(StaticCastToNiLookAtInterpolator) StaticCast<NiLookAtInterpolator>;
+%template(NiLookAtInterpolatorRef) Niflib::Ref<Niflib::NiLookAtInterpolator>;
+%template(DynamicCastToNiLookAtInterpolator) Niflib::DynamicCast<Niflib::NiLookAtInterpolator>;
+%template(StaticCastToNiLookAtInterpolator) Niflib::StaticCast<Niflib::NiLookAtInterpolator>;
 %include "obj/NiMaterialColorController.h"
-%template(NiMaterialColorControllerRef) Ref<NiMaterialColorController>;
-%template(DynamicCastToNiMaterialColorController) DynamicCast<NiMaterialColorController>;
-%template(StaticCastToNiMaterialColorController) StaticCast<NiMaterialColorController>;
+%template(NiMaterialColorControllerRef) Niflib::Ref<Niflib::NiMaterialColorController>;
+%template(DynamicCastToNiMaterialColorController) Niflib::DynamicCast<Niflib::NiMaterialColorController>;
+%template(StaticCastToNiMaterialColorController) Niflib::StaticCast<Niflib::NiMaterialColorController>;
 %include "obj/NiMaterialProperty.h"
-%template(NiMaterialPropertyRef) Ref<NiMaterialProperty>;
-%template(DynamicCastToNiMaterialProperty) DynamicCast<NiMaterialProperty>;
-%template(StaticCastToNiMaterialProperty) StaticCast<NiMaterialProperty>;
+%template(NiMaterialPropertyRef) Niflib::Ref<Niflib::NiMaterialProperty>;
+%template(DynamicCastToNiMaterialProperty) Niflib::DynamicCast<Niflib::NiMaterialProperty>;
+%template(StaticCastToNiMaterialProperty) Niflib::StaticCast<Niflib::NiMaterialProperty>;
 %include "obj/NiMeshPSysData.h"
-%template(NiMeshPSysDataRef) Ref<NiMeshPSysData>;
-%template(DynamicCastToNiMeshPSysData) DynamicCast<NiMeshPSysData>;
-%template(StaticCastToNiMeshPSysData) StaticCast<NiMeshPSysData>;
+%template(NiMeshPSysDataRef) Niflib::Ref<Niflib::NiMeshPSysData>;
+%template(DynamicCastToNiMeshPSysData) Niflib::DynamicCast<Niflib::NiMeshPSysData>;
+%template(StaticCastToNiMeshPSysData) Niflib::StaticCast<Niflib::NiMeshPSysData>;
 %include "obj/NiMorphData.h"
-%template(NiMorphDataRef) Ref<NiMorphData>;
-%template(DynamicCastToNiMorphData) DynamicCast<NiMorphData>;
-%template(StaticCastToNiMorphData) StaticCast<NiMorphData>;
+%template(NiMorphDataRef) Niflib::Ref<Niflib::NiMorphData>;
+%template(DynamicCastToNiMorphData) Niflib::DynamicCast<Niflib::NiMorphData>;
+%template(StaticCastToNiMorphData) Niflib::StaticCast<Niflib::NiMorphData>;
 %include "obj/NiMultiTargetTransformController.h"
-%template(NiMultiTargetTransformControllerRef) Ref<NiMultiTargetTransformController>;
-%template(DynamicCastToNiMultiTargetTransformController) DynamicCast<NiMultiTargetTransformController>;
-%template(StaticCastToNiMultiTargetTransformController) StaticCast<NiMultiTargetTransformController>;
+%template(NiMultiTargetTransformControllerRef) Niflib::Ref<Niflib::NiMultiTargetTransformController>;
+%template(DynamicCastToNiMultiTargetTransformController) Niflib::DynamicCast<Niflib::NiMultiTargetTransformController>;
+%template(StaticCastToNiMultiTargetTransformController) Niflib::StaticCast<Niflib::NiMultiTargetTransformController>;
 %include "obj/NiNode.h"
-%template(NiNodeRef) Ref<NiNode>;
-%template(DynamicCastToNiNode) DynamicCast<NiNode>;
-%template(StaticCastToNiNode) StaticCast<NiNode>;
+%template(NiNodeRef) Niflib::Ref<Niflib::NiNode>;
+%template(DynamicCastToNiNode) Niflib::DynamicCast<Niflib::NiNode>;
+%template(StaticCastToNiNode) Niflib::StaticCast<Niflib::NiNode>;
 %include "obj/AvoidNode.h"
-%template(AvoidNodeRef) Ref<AvoidNode>;
-%template(DynamicCastToAvoidNode) DynamicCast<AvoidNode>;
-%template(StaticCastToAvoidNode) StaticCast<AvoidNode>;
+%template(AvoidNodeRef) Niflib::Ref<Niflib::AvoidNode>;
+%template(DynamicCastToAvoidNode) Niflib::DynamicCast<Niflib::AvoidNode>;
+%template(StaticCastToAvoidNode) Niflib::StaticCast<Niflib::AvoidNode>;
 %include "obj/FxWidget.h"
-%template(FxWidgetRef) Ref<FxWidget>;
-%template(DynamicCastToFxWidget) DynamicCast<FxWidget>;
-%template(StaticCastToFxWidget) StaticCast<FxWidget>;
+%template(FxWidgetRef) Niflib::Ref<Niflib::FxWidget>;
+%template(DynamicCastToFxWidget) Niflib::DynamicCast<Niflib::FxWidget>;
+%template(StaticCastToFxWidget) Niflib::StaticCast<Niflib::FxWidget>;
 %include "obj/FxButton.h"
-%template(FxButtonRef) Ref<FxButton>;
-%template(DynamicCastToFxButton) DynamicCast<FxButton>;
-%template(StaticCastToFxButton) StaticCast<FxButton>;
+%template(FxButtonRef) Niflib::Ref<Niflib::FxButton>;
+%template(DynamicCastToFxButton) Niflib::DynamicCast<Niflib::FxButton>;
+%template(StaticCastToFxButton) Niflib::StaticCast<Niflib::FxButton>;
 %include "obj/FxRadioButton.h"
-%template(FxRadioButtonRef) Ref<FxRadioButton>;
-%template(DynamicCastToFxRadioButton) DynamicCast<FxRadioButton>;
-%template(StaticCastToFxRadioButton) StaticCast<FxRadioButton>;
+%template(FxRadioButtonRef) Niflib::Ref<Niflib::FxRadioButton>;
+%template(DynamicCastToFxRadioButton) Niflib::DynamicCast<Niflib::FxRadioButton>;
+%template(StaticCastToFxRadioButton) Niflib::StaticCast<Niflib::FxRadioButton>;
 %include "obj/NiBillboardNode.h"
-%template(NiBillboardNodeRef) Ref<NiBillboardNode>;
-%template(DynamicCastToNiBillboardNode) DynamicCast<NiBillboardNode>;
-%template(StaticCastToNiBillboardNode) StaticCast<NiBillboardNode>;
+%template(NiBillboardNodeRef) Niflib::Ref<Niflib::NiBillboardNode>;
+%template(DynamicCastToNiBillboardNode) Niflib::DynamicCast<Niflib::NiBillboardNode>;
+%template(StaticCastToNiBillboardNode) Niflib::StaticCast<Niflib::NiBillboardNode>;
 %include "obj/NiBSAnimationNode.h"
-%template(NiBSAnimationNodeRef) Ref<NiBSAnimationNode>;
-%template(DynamicCastToNiBSAnimationNode) DynamicCast<NiBSAnimationNode>;
-%template(StaticCastToNiBSAnimationNode) StaticCast<NiBSAnimationNode>;
+%template(NiBSAnimationNodeRef) Niflib::Ref<Niflib::NiBSAnimationNode>;
+%template(DynamicCastToNiBSAnimationNode) Niflib::DynamicCast<Niflib::NiBSAnimationNode>;
+%template(StaticCastToNiBSAnimationNode) Niflib::StaticCast<Niflib::NiBSAnimationNode>;
 %include "obj/NiBSParticleNode.h"
-%template(NiBSParticleNodeRef) Ref<NiBSParticleNode>;
-%template(DynamicCastToNiBSParticleNode) DynamicCast<NiBSParticleNode>;
-%template(StaticCastToNiBSParticleNode) StaticCast<NiBSParticleNode>;
+%template(NiBSParticleNodeRef) Niflib::Ref<Niflib::NiBSParticleNode>;
+%template(DynamicCastToNiBSParticleNode) Niflib::DynamicCast<Niflib::NiBSParticleNode>;
+%template(StaticCastToNiBSParticleNode) Niflib::StaticCast<Niflib::NiBSParticleNode>;
 %include "obj/NiLODNode.h"
-%template(NiLODNodeRef) Ref<NiLODNode>;
-%template(DynamicCastToNiLODNode) DynamicCast<NiLODNode>;
-%template(StaticCastToNiLODNode) StaticCast<NiLODNode>;
+%template(NiLODNodeRef) Niflib::Ref<Niflib::NiLODNode>;
+%template(DynamicCastToNiLODNode) Niflib::DynamicCast<Niflib::NiLODNode>;
+%template(StaticCastToNiLODNode) Niflib::StaticCast<Niflib::NiLODNode>;
 %include "obj/NiPalette.h"
-%template(NiPaletteRef) Ref<NiPalette>;
-%template(DynamicCastToNiPalette) DynamicCast<NiPalette>;
-%template(StaticCastToNiPalette) StaticCast<NiPalette>;
+%template(NiPaletteRef) Niflib::Ref<Niflib::NiPalette>;
+%template(DynamicCastToNiPalette) Niflib::DynamicCast<Niflib::NiPalette>;
+%template(StaticCastToNiPalette) Niflib::StaticCast<Niflib::NiPalette>;
 %include "obj/NiParticleBomb.h"
-%template(NiParticleBombRef) Ref<NiParticleBomb>;
-%template(DynamicCastToNiParticleBomb) DynamicCast<NiParticleBomb>;
-%template(StaticCastToNiParticleBomb) StaticCast<NiParticleBomb>;
+%template(NiParticleBombRef) Niflib::Ref<Niflib::NiParticleBomb>;
+%template(DynamicCastToNiParticleBomb) Niflib::DynamicCast<Niflib::NiParticleBomb>;
+%template(StaticCastToNiParticleBomb) Niflib::StaticCast<Niflib::NiParticleBomb>;
 %include "obj/NiParticleColorModifier.h"
-%template(NiParticleColorModifierRef) Ref<NiParticleColorModifier>;
-%template(DynamicCastToNiParticleColorModifier) DynamicCast<NiParticleColorModifier>;
-%template(StaticCastToNiParticleColorModifier) StaticCast<NiParticleColorModifier>;
+%template(NiParticleColorModifierRef) Niflib::Ref<Niflib::NiParticleColorModifier>;
+%template(DynamicCastToNiParticleColorModifier) Niflib::DynamicCast<Niflib::NiParticleColorModifier>;
+%template(StaticCastToNiParticleColorModifier) Niflib::StaticCast<Niflib::NiParticleColorModifier>;
 %include "obj/NiParticleGrowFade.h"
-%template(NiParticleGrowFadeRef) Ref<NiParticleGrowFade>;
-%template(DynamicCastToNiParticleGrowFade) DynamicCast<NiParticleGrowFade>;
-%template(StaticCastToNiParticleGrowFade) StaticCast<NiParticleGrowFade>;
+%template(NiParticleGrowFadeRef) Niflib::Ref<Niflib::NiParticleGrowFade>;
+%template(DynamicCastToNiParticleGrowFade) Niflib::DynamicCast<Niflib::NiParticleGrowFade>;
+%template(StaticCastToNiParticleGrowFade) Niflib::StaticCast<Niflib::NiParticleGrowFade>;
 %include "obj/NiParticleMeshModifier.h"
-%template(NiParticleMeshModifierRef) Ref<NiParticleMeshModifier>;
-%template(DynamicCastToNiParticleMeshModifier) DynamicCast<NiParticleMeshModifier>;
-%template(StaticCastToNiParticleMeshModifier) StaticCast<NiParticleMeshModifier>;
+%template(NiParticleMeshModifierRef) Niflib::Ref<Niflib::NiParticleMeshModifier>;
+%template(DynamicCastToNiParticleMeshModifier) Niflib::DynamicCast<Niflib::NiParticleMeshModifier>;
+%template(StaticCastToNiParticleMeshModifier) Niflib::StaticCast<Niflib::NiParticleMeshModifier>;
 %include "obj/NiParticleRotation.h"
-%template(NiParticleRotationRef) Ref<NiParticleRotation>;
-%template(DynamicCastToNiParticleRotation) DynamicCast<NiParticleRotation>;
-%template(StaticCastToNiParticleRotation) StaticCast<NiParticleRotation>;
+%template(NiParticleRotationRef) Niflib::Ref<Niflib::NiParticleRotation>;
+%template(DynamicCastToNiParticleRotation) Niflib::DynamicCast<Niflib::NiParticleRotation>;
+%template(StaticCastToNiParticleRotation) Niflib::StaticCast<Niflib::NiParticleRotation>;
 %include "obj/NiParticles.h"
-%template(NiParticlesRef) Ref<NiParticles>;
-%template(DynamicCastToNiParticles) DynamicCast<NiParticles>;
-%template(StaticCastToNiParticles) StaticCast<NiParticles>;
+%template(NiParticlesRef) Niflib::Ref<Niflib::NiParticles>;
+%template(DynamicCastToNiParticles) Niflib::DynamicCast<Niflib::NiParticles>;
+%template(StaticCastToNiParticles) Niflib::StaticCast<Niflib::NiParticles>;
 %include "obj/NiAutoNormalParticles.h"
-%template(NiAutoNormalParticlesRef) Ref<NiAutoNormalParticles>;
-%template(DynamicCastToNiAutoNormalParticles) DynamicCast<NiAutoNormalParticles>;
-%template(StaticCastToNiAutoNormalParticles) StaticCast<NiAutoNormalParticles>;
+%template(NiAutoNormalParticlesRef) Niflib::Ref<Niflib::NiAutoNormalParticles>;
+%template(DynamicCastToNiAutoNormalParticles) Niflib::DynamicCast<Niflib::NiAutoNormalParticles>;
+%template(StaticCastToNiAutoNormalParticles) Niflib::StaticCast<Niflib::NiAutoNormalParticles>;
 %include "obj/NiParticleMeshes.h"
-%template(NiParticleMeshesRef) Ref<NiParticleMeshes>;
-%template(DynamicCastToNiParticleMeshes) DynamicCast<NiParticleMeshes>;
-%template(StaticCastToNiParticleMeshes) StaticCast<NiParticleMeshes>;
+%template(NiParticleMeshesRef) Niflib::Ref<Niflib::NiParticleMeshes>;
+%template(DynamicCastToNiParticleMeshes) Niflib::DynamicCast<Niflib::NiParticleMeshes>;
+%template(StaticCastToNiParticleMeshes) Niflib::StaticCast<Niflib::NiParticleMeshes>;
 %include "obj/NiParticlesData.h"
-%template(NiParticlesDataRef) Ref<NiParticlesData>;
-%template(DynamicCastToNiParticlesData) DynamicCast<NiParticlesData>;
-%template(StaticCastToNiParticlesData) StaticCast<NiParticlesData>;
+%template(NiParticlesDataRef) Niflib::Ref<Niflib::NiParticlesData>;
+%template(DynamicCastToNiParticlesData) Niflib::DynamicCast<Niflib::NiParticlesData>;
+%template(StaticCastToNiParticlesData) Niflib::StaticCast<Niflib::NiParticlesData>;
 %include "obj/NiParticleMeshesData.h"
-%template(NiParticleMeshesDataRef) Ref<NiParticleMeshesData>;
-%template(DynamicCastToNiParticleMeshesData) DynamicCast<NiParticleMeshesData>;
-%template(StaticCastToNiParticleMeshesData) StaticCast<NiParticleMeshesData>;
+%template(NiParticleMeshesDataRef) Niflib::Ref<Niflib::NiParticleMeshesData>;
+%template(DynamicCastToNiParticleMeshesData) Niflib::DynamicCast<Niflib::NiParticleMeshesData>;
+%template(StaticCastToNiParticleMeshesData) Niflib::StaticCast<Niflib::NiParticleMeshesData>;
 %include "obj/NiParticleSystem.h"
-%template(NiParticleSystemRef) Ref<NiParticleSystem>;
-%template(DynamicCastToNiParticleSystem) DynamicCast<NiParticleSystem>;
-%template(StaticCastToNiParticleSystem) StaticCast<NiParticleSystem>;
+%template(NiParticleSystemRef) Niflib::Ref<Niflib::NiParticleSystem>;
+%template(DynamicCastToNiParticleSystem) Niflib::DynamicCast<Niflib::NiParticleSystem>;
+%template(StaticCastToNiParticleSystem) Niflib::StaticCast<Niflib::NiParticleSystem>;
 %include "obj/NiMeshParticleSystem.h"
-%template(NiMeshParticleSystemRef) Ref<NiMeshParticleSystem>;
-%template(DynamicCastToNiMeshParticleSystem) DynamicCast<NiMeshParticleSystem>;
-%template(StaticCastToNiMeshParticleSystem) StaticCast<NiMeshParticleSystem>;
+%template(NiMeshParticleSystemRef) Niflib::Ref<Niflib::NiMeshParticleSystem>;
+%template(DynamicCastToNiMeshParticleSystem) Niflib::DynamicCast<Niflib::NiMeshParticleSystem>;
+%template(StaticCastToNiMeshParticleSystem) Niflib::StaticCast<Niflib::NiMeshParticleSystem>;
 %include "obj/NiParticleSystemController.h"
-%template(NiParticleSystemControllerRef) Ref<NiParticleSystemController>;
-%template(DynamicCastToNiParticleSystemController) DynamicCast<NiParticleSystemController>;
-%template(StaticCastToNiParticleSystemController) StaticCast<NiParticleSystemController>;
+%template(NiParticleSystemControllerRef) Niflib::Ref<Niflib::NiParticleSystemController>;
+%template(DynamicCastToNiParticleSystemController) Niflib::DynamicCast<Niflib::NiParticleSystemController>;
+%template(StaticCastToNiParticleSystemController) Niflib::StaticCast<Niflib::NiParticleSystemController>;
 %include "obj/NiBSPArrayController.h"
-%template(NiBSPArrayControllerRef) Ref<NiBSPArrayController>;
-%template(DynamicCastToNiBSPArrayController) DynamicCast<NiBSPArrayController>;
-%template(StaticCastToNiBSPArrayController) StaticCast<NiBSPArrayController>;
+%template(NiBSPArrayControllerRef) Niflib::Ref<Niflib::NiBSPArrayController>;
+%template(DynamicCastToNiBSPArrayController) Niflib::DynamicCast<Niflib::NiBSPArrayController>;
+%template(StaticCastToNiBSPArrayController) Niflib::StaticCast<Niflib::NiBSPArrayController>;
 %include "obj/NiPathController.h"
-%template(NiPathControllerRef) Ref<NiPathController>;
-%template(DynamicCastToNiPathController) DynamicCast<NiPathController>;
-%template(StaticCastToNiPathController) StaticCast<NiPathController>;
+%template(NiPathControllerRef) Niflib::Ref<Niflib::NiPathController>;
+%template(DynamicCastToNiPathController) Niflib::DynamicCast<Niflib::NiPathController>;
+%template(StaticCastToNiPathController) Niflib::StaticCast<Niflib::NiPathController>;
 %include "obj/NiPathInterpolator.h"
-%template(NiPathInterpolatorRef) Ref<NiPathInterpolator>;
-%template(DynamicCastToNiPathInterpolator) DynamicCast<NiPathInterpolator>;
-%template(StaticCastToNiPathInterpolator) StaticCast<NiPathInterpolator>;
+%template(NiPathInterpolatorRef) Niflib::Ref<Niflib::NiPathInterpolator>;
+%template(DynamicCastToNiPathInterpolator) Niflib::DynamicCast<Niflib::NiPathInterpolator>;
+%template(StaticCastToNiPathInterpolator) Niflib::StaticCast<Niflib::NiPathInterpolator>;
 %include "obj/NiPixelData.h"
-%template(NiPixelDataRef) Ref<NiPixelData>;
-%template(DynamicCastToNiPixelData) DynamicCast<NiPixelData>;
-%template(StaticCastToNiPixelData) StaticCast<NiPixelData>;
+%template(NiPixelDataRef) Niflib::Ref<Niflib::NiPixelData>;
+%template(DynamicCastToNiPixelData) Niflib::DynamicCast<Niflib::NiPixelData>;
+%template(StaticCastToNiPixelData) Niflib::StaticCast<Niflib::NiPixelData>;
 %include "obj/NiPlanarCollider.h"
-%template(NiPlanarColliderRef) Ref<NiPlanarCollider>;
-%template(DynamicCastToNiPlanarCollider) DynamicCast<NiPlanarCollider>;
-%template(StaticCastToNiPlanarCollider) StaticCast<NiPlanarCollider>;
+%template(NiPlanarColliderRef) Niflib::Ref<Niflib::NiPlanarCollider>;
+%template(DynamicCastToNiPlanarCollider) Niflib::DynamicCast<Niflib::NiPlanarCollider>;
+%template(StaticCastToNiPlanarCollider) Niflib::StaticCast<Niflib::NiPlanarCollider>;
 %include "obj/NiPoint3Interpolator.h"
-%template(NiPoint3InterpolatorRef) Ref<NiPoint3Interpolator>;
-%template(DynamicCastToNiPoint3Interpolator) DynamicCast<NiPoint3Interpolator>;
-%template(StaticCastToNiPoint3Interpolator) StaticCast<NiPoint3Interpolator>;
+%template(NiPoint3InterpolatorRef) Niflib::Ref<Niflib::NiPoint3Interpolator>;
+%template(DynamicCastToNiPoint3Interpolator) Niflib::DynamicCast<Niflib::NiPoint3Interpolator>;
+%template(StaticCastToNiPoint3Interpolator) Niflib::StaticCast<Niflib::NiPoint3Interpolator>;
 %include "obj/NiPointLight.h"
-%template(NiPointLightRef) Ref<NiPointLight>;
-%template(DynamicCastToNiPointLight) DynamicCast<NiPointLight>;
-%template(StaticCastToNiPointLight) StaticCast<NiPointLight>;
+%template(NiPointLightRef) Niflib::Ref<Niflib::NiPointLight>;
+%template(DynamicCastToNiPointLight) Niflib::DynamicCast<Niflib::NiPointLight>;
+%template(StaticCastToNiPointLight) Niflib::StaticCast<Niflib::NiPointLight>;
 %include "obj/NiPosData.h"
-%template(NiPosDataRef) Ref<NiPosData>;
-%template(DynamicCastToNiPosData) DynamicCast<NiPosData>;
-%template(StaticCastToNiPosData) StaticCast<NiPosData>;
+%template(NiPosDataRef) Niflib::Ref<Niflib::NiPosData>;
+%template(DynamicCastToNiPosData) Niflib::DynamicCast<Niflib::NiPosData>;
+%template(StaticCastToNiPosData) Niflib::StaticCast<Niflib::NiPosData>;
 %include "obj/NiPSysAgeDeathModifier.h"
-%template(NiPSysAgeDeathModifierRef) Ref<NiPSysAgeDeathModifier>;
-%template(DynamicCastToNiPSysAgeDeathModifier) DynamicCast<NiPSysAgeDeathModifier>;
-%template(StaticCastToNiPSysAgeDeathModifier) StaticCast<NiPSysAgeDeathModifier>;
+%template(NiPSysAgeDeathModifierRef) Niflib::Ref<Niflib::NiPSysAgeDeathModifier>;
+%template(DynamicCastToNiPSysAgeDeathModifier) Niflib::DynamicCast<Niflib::NiPSysAgeDeathModifier>;
+%template(StaticCastToNiPSysAgeDeathModifier) Niflib::StaticCast<Niflib::NiPSysAgeDeathModifier>;
 %include "obj/NiPSysBombModifier.h"
-%template(NiPSysBombModifierRef) Ref<NiPSysBombModifier>;
-%template(DynamicCastToNiPSysBombModifier) DynamicCast<NiPSysBombModifier>;
-%template(StaticCastToNiPSysBombModifier) StaticCast<NiPSysBombModifier>;
+%template(NiPSysBombModifierRef) Niflib::Ref<Niflib::NiPSysBombModifier>;
+%template(DynamicCastToNiPSysBombModifier) Niflib::DynamicCast<Niflib::NiPSysBombModifier>;
+%template(StaticCastToNiPSysBombModifier) Niflib::StaticCast<Niflib::NiPSysBombModifier>;
 %include "obj/NiPSysBoundUpdateModifier.h"
-%template(NiPSysBoundUpdateModifierRef) Ref<NiPSysBoundUpdateModifier>;
-%template(DynamicCastToNiPSysBoundUpdateModifier) DynamicCast<NiPSysBoundUpdateModifier>;
-%template(StaticCastToNiPSysBoundUpdateModifier) StaticCast<NiPSysBoundUpdateModifier>;
+%template(NiPSysBoundUpdateModifierRef) Niflib::Ref<Niflib::NiPSysBoundUpdateModifier>;
+%template(DynamicCastToNiPSysBoundUpdateModifier) Niflib::DynamicCast<Niflib::NiPSysBoundUpdateModifier>;
+%template(StaticCastToNiPSysBoundUpdateModifier) Niflib::StaticCast<Niflib::NiPSysBoundUpdateModifier>;
 %include "obj/NiPSysBoxEmitter.h"
-%template(NiPSysBoxEmitterRef) Ref<NiPSysBoxEmitter>;
-%template(DynamicCastToNiPSysBoxEmitter) DynamicCast<NiPSysBoxEmitter>;
-%template(StaticCastToNiPSysBoxEmitter) StaticCast<NiPSysBoxEmitter>;
+%template(NiPSysBoxEmitterRef) Niflib::Ref<Niflib::NiPSysBoxEmitter>;
+%template(DynamicCastToNiPSysBoxEmitter) Niflib::DynamicCast<Niflib::NiPSysBoxEmitter>;
+%template(StaticCastToNiPSysBoxEmitter) Niflib::StaticCast<Niflib::NiPSysBoxEmitter>;
 %include "obj/NiPSysColliderManager.h"
-%template(NiPSysColliderManagerRef) Ref<NiPSysColliderManager>;
-%template(DynamicCastToNiPSysColliderManager) DynamicCast<NiPSysColliderManager>;
-%template(StaticCastToNiPSysColliderManager) StaticCast<NiPSysColliderManager>;
+%template(NiPSysColliderManagerRef) Niflib::Ref<Niflib::NiPSysColliderManager>;
+%template(DynamicCastToNiPSysColliderManager) Niflib::DynamicCast<Niflib::NiPSysColliderManager>;
+%template(StaticCastToNiPSysColliderManager) Niflib::StaticCast<Niflib::NiPSysColliderManager>;
 %include "obj/NiPSysColorModifier.h"
-%template(NiPSysColorModifierRef) Ref<NiPSysColorModifier>;
-%template(DynamicCastToNiPSysColorModifier) DynamicCast<NiPSysColorModifier>;
-%template(StaticCastToNiPSysColorModifier) StaticCast<NiPSysColorModifier>;
+%template(NiPSysColorModifierRef) Niflib::Ref<Niflib::NiPSysColorModifier>;
+%template(DynamicCastToNiPSysColorModifier) Niflib::DynamicCast<Niflib::NiPSysColorModifier>;
+%template(StaticCastToNiPSysColorModifier) Niflib::StaticCast<Niflib::NiPSysColorModifier>;
 %include "obj/NiPSysCylinderEmitter.h"
-%template(NiPSysCylinderEmitterRef) Ref<NiPSysCylinderEmitter>;
-%template(DynamicCastToNiPSysCylinderEmitter) DynamicCast<NiPSysCylinderEmitter>;
-%template(StaticCastToNiPSysCylinderEmitter) StaticCast<NiPSysCylinderEmitter>;
+%template(NiPSysCylinderEmitterRef) Niflib::Ref<Niflib::NiPSysCylinderEmitter>;
+%template(DynamicCastToNiPSysCylinderEmitter) Niflib::DynamicCast<Niflib::NiPSysCylinderEmitter>;
+%template(StaticCastToNiPSysCylinderEmitter) Niflib::StaticCast<Niflib::NiPSysCylinderEmitter>;
 %include "obj/NiPSysData.h"
-%template(NiPSysDataRef) Ref<NiPSysData>;
-%template(DynamicCastToNiPSysData) DynamicCast<NiPSysData>;
-%template(StaticCastToNiPSysData) StaticCast<NiPSysData>;
+%template(NiPSysDataRef) Niflib::Ref<Niflib::NiPSysData>;
+%template(DynamicCastToNiPSysData) Niflib::DynamicCast<Niflib::NiPSysData>;
+%template(StaticCastToNiPSysData) Niflib::StaticCast<Niflib::NiPSysData>;
 %include "obj/NiPSysDragModifier.h"
-%template(NiPSysDragModifierRef) Ref<NiPSysDragModifier>;
-%template(DynamicCastToNiPSysDragModifier) DynamicCast<NiPSysDragModifier>;
-%template(StaticCastToNiPSysDragModifier) StaticCast<NiPSysDragModifier>;
+%template(NiPSysDragModifierRef) Niflib::Ref<Niflib::NiPSysDragModifier>;
+%template(DynamicCastToNiPSysDragModifier) Niflib::DynamicCast<Niflib::NiPSysDragModifier>;
+%template(StaticCastToNiPSysDragModifier) Niflib::StaticCast<Niflib::NiPSysDragModifier>;
 %include "obj/NiPSysEmitterCtlr.h"
-%template(NiPSysEmitterCtlrRef) Ref<NiPSysEmitterCtlr>;
-%template(DynamicCastToNiPSysEmitterCtlr) DynamicCast<NiPSysEmitterCtlr>;
-%template(StaticCastToNiPSysEmitterCtlr) StaticCast<NiPSysEmitterCtlr>;
+%template(NiPSysEmitterCtlrRef) Niflib::Ref<Niflib::NiPSysEmitterCtlr>;
+%template(DynamicCastToNiPSysEmitterCtlr) Niflib::DynamicCast<Niflib::NiPSysEmitterCtlr>;
+%template(StaticCastToNiPSysEmitterCtlr) Niflib::StaticCast<Niflib::NiPSysEmitterCtlr>;
 %include "obj/NiPSysEmitterCtlrData.h"
-%template(NiPSysEmitterCtlrDataRef) Ref<NiPSysEmitterCtlrData>;
-%template(DynamicCastToNiPSysEmitterCtlrData) DynamicCast<NiPSysEmitterCtlrData>;
-%template(StaticCastToNiPSysEmitterCtlrData) StaticCast<NiPSysEmitterCtlrData>;
+%template(NiPSysEmitterCtlrDataRef) Niflib::Ref<Niflib::NiPSysEmitterCtlrData>;
+%template(DynamicCastToNiPSysEmitterCtlrData) Niflib::DynamicCast<Niflib::NiPSysEmitterCtlrData>;
+%template(StaticCastToNiPSysEmitterCtlrData) Niflib::StaticCast<Niflib::NiPSysEmitterCtlrData>;
 %include "obj/NiPSysEmitterDeclinationCtlr.h"
-%template(NiPSysEmitterDeclinationCtlrRef) Ref<NiPSysEmitterDeclinationCtlr>;
-%template(DynamicCastToNiPSysEmitterDeclinationCtlr) DynamicCast<NiPSysEmitterDeclinationCtlr>;
-%template(StaticCastToNiPSysEmitterDeclinationCtlr) StaticCast<NiPSysEmitterDeclinationCtlr>;
+%template(NiPSysEmitterDeclinationCtlrRef) Niflib::Ref<Niflib::NiPSysEmitterDeclinationCtlr>;
+%template(DynamicCastToNiPSysEmitterDeclinationCtlr) Niflib::DynamicCast<Niflib::NiPSysEmitterDeclinationCtlr>;
+%template(StaticCastToNiPSysEmitterDeclinationCtlr) Niflib::StaticCast<Niflib::NiPSysEmitterDeclinationCtlr>;
 %include "obj/NiPSysEmitterDeclinationVarCtlr.h"
-%template(NiPSysEmitterDeclinationVarCtlrRef) Ref<NiPSysEmitterDeclinationVarCtlr>;
-%template(DynamicCastToNiPSysEmitterDeclinationVarCtlr) DynamicCast<NiPSysEmitterDeclinationVarCtlr>;
-%template(StaticCastToNiPSysEmitterDeclinationVarCtlr) StaticCast<NiPSysEmitterDeclinationVarCtlr>;
+%template(NiPSysEmitterDeclinationVarCtlrRef) Niflib::Ref<Niflib::NiPSysEmitterDeclinationVarCtlr>;
+%template(DynamicCastToNiPSysEmitterDeclinationVarCtlr) Niflib::DynamicCast<Niflib::NiPSysEmitterDeclinationVarCtlr>;
+%template(StaticCastToNiPSysEmitterDeclinationVarCtlr) Niflib::StaticCast<Niflib::NiPSysEmitterDeclinationVarCtlr>;
 %include "obj/NiPSysEmitterInitialRadiusCtlr.h"
-%template(NiPSysEmitterInitialRadiusCtlrRef) Ref<NiPSysEmitterInitialRadiusCtlr>;
-%template(DynamicCastToNiPSysEmitterInitialRadiusCtlr) DynamicCast<NiPSysEmitterInitialRadiusCtlr>;
-%template(StaticCastToNiPSysEmitterInitialRadiusCtlr) StaticCast<NiPSysEmitterInitialRadiusCtlr>;
+%template(NiPSysEmitterInitialRadiusCtlrRef) Niflib::Ref<Niflib::NiPSysEmitterInitialRadiusCtlr>;
+%template(DynamicCastToNiPSysEmitterInitialRadiusCtlr) Niflib::DynamicCast<Niflib::NiPSysEmitterInitialRadiusCtlr>;
+%template(StaticCastToNiPSysEmitterInitialRadiusCtlr) Niflib::StaticCast<Niflib::NiPSysEmitterInitialRadiusCtlr>;
 %include "obj/NiPSysEmitterLifeSpanCtlr.h"
-%template(NiPSysEmitterLifeSpanCtlrRef) Ref<NiPSysEmitterLifeSpanCtlr>;
-%template(DynamicCastToNiPSysEmitterLifeSpanCtlr) DynamicCast<NiPSysEmitterLifeSpanCtlr>;
-%template(StaticCastToNiPSysEmitterLifeSpanCtlr) StaticCast<NiPSysEmitterLifeSpanCtlr>;
+%template(NiPSysEmitterLifeSpanCtlrRef) Niflib::Ref<Niflib::NiPSysEmitterLifeSpanCtlr>;
+%template(DynamicCastToNiPSysEmitterLifeSpanCtlr) Niflib::DynamicCast<Niflib::NiPSysEmitterLifeSpanCtlr>;
+%template(StaticCastToNiPSysEmitterLifeSpanCtlr) Niflib::StaticCast<Niflib::NiPSysEmitterLifeSpanCtlr>;
 %include "obj/NiPSysEmitterSpeedCtlr.h"
-%template(NiPSysEmitterSpeedCtlrRef) Ref<NiPSysEmitterSpeedCtlr>;
-%template(DynamicCastToNiPSysEmitterSpeedCtlr) DynamicCast<NiPSysEmitterSpeedCtlr>;
-%template(StaticCastToNiPSysEmitterSpeedCtlr) StaticCast<NiPSysEmitterSpeedCtlr>;
+%template(NiPSysEmitterSpeedCtlrRef) Niflib::Ref<Niflib::NiPSysEmitterSpeedCtlr>;
+%template(DynamicCastToNiPSysEmitterSpeedCtlr) Niflib::DynamicCast<Niflib::NiPSysEmitterSpeedCtlr>;
+%template(StaticCastToNiPSysEmitterSpeedCtlr) Niflib::StaticCast<Niflib::NiPSysEmitterSpeedCtlr>;
 %include "obj/NiPSysGravityModifier.h"
-%template(NiPSysGravityModifierRef) Ref<NiPSysGravityModifier>;
-%template(DynamicCastToNiPSysGravityModifier) DynamicCast<NiPSysGravityModifier>;
-%template(StaticCastToNiPSysGravityModifier) StaticCast<NiPSysGravityModifier>;
+%template(NiPSysGravityModifierRef) Niflib::Ref<Niflib::NiPSysGravityModifier>;
+%template(DynamicCastToNiPSysGravityModifier) Niflib::DynamicCast<Niflib::NiPSysGravityModifier>;
+%template(StaticCastToNiPSysGravityModifier) Niflib::StaticCast<Niflib::NiPSysGravityModifier>;
 %include "obj/NiPSysGravityStrengthCtlr.h"
-%template(NiPSysGravityStrengthCtlrRef) Ref<NiPSysGravityStrengthCtlr>;
-%template(DynamicCastToNiPSysGravityStrengthCtlr) DynamicCast<NiPSysGravityStrengthCtlr>;
-%template(StaticCastToNiPSysGravityStrengthCtlr) StaticCast<NiPSysGravityStrengthCtlr>;
+%template(NiPSysGravityStrengthCtlrRef) Niflib::Ref<Niflib::NiPSysGravityStrengthCtlr>;
+%template(DynamicCastToNiPSysGravityStrengthCtlr) Niflib::DynamicCast<Niflib::NiPSysGravityStrengthCtlr>;
+%template(StaticCastToNiPSysGravityStrengthCtlr) Niflib::StaticCast<Niflib::NiPSysGravityStrengthCtlr>;
 %include "obj/NiPSysGrowFadeModifier.h"
-%template(NiPSysGrowFadeModifierRef) Ref<NiPSysGrowFadeModifier>;
-%template(DynamicCastToNiPSysGrowFadeModifier) DynamicCast<NiPSysGrowFadeModifier>;
-%template(StaticCastToNiPSysGrowFadeModifier) StaticCast<NiPSysGrowFadeModifier>;
+%template(NiPSysGrowFadeModifierRef) Niflib::Ref<Niflib::NiPSysGrowFadeModifier>;
+%template(DynamicCastToNiPSysGrowFadeModifier) Niflib::DynamicCast<Niflib::NiPSysGrowFadeModifier>;
+%template(StaticCastToNiPSysGrowFadeModifier) Niflib::StaticCast<Niflib::NiPSysGrowFadeModifier>;
 %include "obj/NiPSysMeshEmitter.h"
-%template(NiPSysMeshEmitterRef) Ref<NiPSysMeshEmitter>;
-%template(DynamicCastToNiPSysMeshEmitter) DynamicCast<NiPSysMeshEmitter>;
-%template(StaticCastToNiPSysMeshEmitter) StaticCast<NiPSysMeshEmitter>;
+%template(NiPSysMeshEmitterRef) Niflib::Ref<Niflib::NiPSysMeshEmitter>;
+%template(DynamicCastToNiPSysMeshEmitter) Niflib::DynamicCast<Niflib::NiPSysMeshEmitter>;
+%template(StaticCastToNiPSysMeshEmitter) Niflib::StaticCast<Niflib::NiPSysMeshEmitter>;
 %include "obj/NiPSysMeshUpdateModifier.h"
-%template(NiPSysMeshUpdateModifierRef) Ref<NiPSysMeshUpdateModifier>;
-%template(DynamicCastToNiPSysMeshUpdateModifier) DynamicCast<NiPSysMeshUpdateModifier>;
-%template(StaticCastToNiPSysMeshUpdateModifier) StaticCast<NiPSysMeshUpdateModifier>;
+%template(NiPSysMeshUpdateModifierRef) Niflib::Ref<Niflib::NiPSysMeshUpdateModifier>;
+%template(DynamicCastToNiPSysMeshUpdateModifier) Niflib::DynamicCast<Niflib::NiPSysMeshUpdateModifier>;
+%template(StaticCastToNiPSysMeshUpdateModifier) Niflib::StaticCast<Niflib::NiPSysMeshUpdateModifier>;
 %include "obj/NiPSysModifierActiveCtlr.h"
-%template(NiPSysModifierActiveCtlrRef) Ref<NiPSysModifierActiveCtlr>;
-%template(DynamicCastToNiPSysModifierActiveCtlr) DynamicCast<NiPSysModifierActiveCtlr>;
-%template(StaticCastToNiPSysModifierActiveCtlr) StaticCast<NiPSysModifierActiveCtlr>;
+%template(NiPSysModifierActiveCtlrRef) Niflib::Ref<Niflib::NiPSysModifierActiveCtlr>;
+%template(DynamicCastToNiPSysModifierActiveCtlr) Niflib::DynamicCast<Niflib::NiPSysModifierActiveCtlr>;
+%template(StaticCastToNiPSysModifierActiveCtlr) Niflib::StaticCast<Niflib::NiPSysModifierActiveCtlr>;
 %include "obj/NiPSysPlanarCollider.h"
-%template(NiPSysPlanarColliderRef) Ref<NiPSysPlanarCollider>;
-%template(DynamicCastToNiPSysPlanarCollider) DynamicCast<NiPSysPlanarCollider>;
-%template(StaticCastToNiPSysPlanarCollider) StaticCast<NiPSysPlanarCollider>;
+%template(NiPSysPlanarColliderRef) Niflib::Ref<Niflib::NiPSysPlanarCollider>;
+%template(DynamicCastToNiPSysPlanarCollider) Niflib::DynamicCast<Niflib::NiPSysPlanarCollider>;
+%template(StaticCastToNiPSysPlanarCollider) Niflib::StaticCast<Niflib::NiPSysPlanarCollider>;
 %include "obj/NiPSysPositionModifier.h"
-%template(NiPSysPositionModifierRef) Ref<NiPSysPositionModifier>;
-%template(DynamicCastToNiPSysPositionModifier) DynamicCast<NiPSysPositionModifier>;
-%template(StaticCastToNiPSysPositionModifier) StaticCast<NiPSysPositionModifier>;
+%template(NiPSysPositionModifierRef) Niflib::Ref<Niflib::NiPSysPositionModifier>;
+%template(DynamicCastToNiPSysPositionModifier) Niflib::DynamicCast<Niflib::NiPSysPositionModifier>;
+%template(StaticCastToNiPSysPositionModifier) Niflib::StaticCast<Niflib::NiPSysPositionModifier>;
 %include "obj/NiPSysResetOnLoopCtlr.h"
-%template(NiPSysResetOnLoopCtlrRef) Ref<NiPSysResetOnLoopCtlr>;
-%template(DynamicCastToNiPSysResetOnLoopCtlr) DynamicCast<NiPSysResetOnLoopCtlr>;
-%template(StaticCastToNiPSysResetOnLoopCtlr) StaticCast<NiPSysResetOnLoopCtlr>;
+%template(NiPSysResetOnLoopCtlrRef) Niflib::Ref<Niflib::NiPSysResetOnLoopCtlr>;
+%template(DynamicCastToNiPSysResetOnLoopCtlr) Niflib::DynamicCast<Niflib::NiPSysResetOnLoopCtlr>;
+%template(StaticCastToNiPSysResetOnLoopCtlr) Niflib::StaticCast<Niflib::NiPSysResetOnLoopCtlr>;
 %include "obj/NiPSysRotationModifier.h"
-%template(NiPSysRotationModifierRef) Ref<NiPSysRotationModifier>;
-%template(DynamicCastToNiPSysRotationModifier) DynamicCast<NiPSysRotationModifier>;
-%template(StaticCastToNiPSysRotationModifier) StaticCast<NiPSysRotationModifier>;
+%template(NiPSysRotationModifierRef) Niflib::Ref<Niflib::NiPSysRotationModifier>;
+%template(DynamicCastToNiPSysRotationModifier) Niflib::DynamicCast<Niflib::NiPSysRotationModifier>;
+%template(StaticCastToNiPSysRotationModifier) Niflib::StaticCast<Niflib::NiPSysRotationModifier>;
 %include "obj/NiPSysSpawnModifier.h"
-%template(NiPSysSpawnModifierRef) Ref<NiPSysSpawnModifier>;
-%template(DynamicCastToNiPSysSpawnModifier) DynamicCast<NiPSysSpawnModifier>;
-%template(StaticCastToNiPSysSpawnModifier) StaticCast<NiPSysSpawnModifier>;
+%template(NiPSysSpawnModifierRef) Niflib::Ref<Niflib::NiPSysSpawnModifier>;
+%template(DynamicCastToNiPSysSpawnModifier) Niflib::DynamicCast<Niflib::NiPSysSpawnModifier>;
+%template(StaticCastToNiPSysSpawnModifier) Niflib::StaticCast<Niflib::NiPSysSpawnModifier>;
 %include "obj/NiPSysSphereEmitter.h"
-%template(NiPSysSphereEmitterRef) Ref<NiPSysSphereEmitter>;
-%template(DynamicCastToNiPSysSphereEmitter) DynamicCast<NiPSysSphereEmitter>;
-%template(StaticCastToNiPSysSphereEmitter) StaticCast<NiPSysSphereEmitter>;
+%template(NiPSysSphereEmitterRef) Niflib::Ref<Niflib::NiPSysSphereEmitter>;
+%template(DynamicCastToNiPSysSphereEmitter) Niflib::DynamicCast<Niflib::NiPSysSphereEmitter>;
+%template(StaticCastToNiPSysSphereEmitter) Niflib::StaticCast<Niflib::NiPSysSphereEmitter>;
 %include "obj/NiPSysUpdateCtlr.h"
-%template(NiPSysUpdateCtlrRef) Ref<NiPSysUpdateCtlr>;
-%template(DynamicCastToNiPSysUpdateCtlr) DynamicCast<NiPSysUpdateCtlr>;
-%template(StaticCastToNiPSysUpdateCtlr) StaticCast<NiPSysUpdateCtlr>;
+%template(NiPSysUpdateCtlrRef) Niflib::Ref<Niflib::NiPSysUpdateCtlr>;
+%template(DynamicCastToNiPSysUpdateCtlr) Niflib::DynamicCast<Niflib::NiPSysUpdateCtlr>;
+%template(StaticCastToNiPSysUpdateCtlr) Niflib::StaticCast<Niflib::NiPSysUpdateCtlr>;
 %include "obj/NiRangeLODData.h"
-%template(NiRangeLODDataRef) Ref<NiRangeLODData>;
-%template(DynamicCastToNiRangeLODData) DynamicCast<NiRangeLODData>;
-%template(StaticCastToNiRangeLODData) StaticCast<NiRangeLODData>;
+%template(NiRangeLODDataRef) Niflib::Ref<Niflib::NiRangeLODData>;
+%template(DynamicCastToNiRangeLODData) Niflib::DynamicCast<Niflib::NiRangeLODData>;
+%template(StaticCastToNiRangeLODData) Niflib::StaticCast<Niflib::NiRangeLODData>;
 %include "obj/NiRotatingParticles.h"
-%template(NiRotatingParticlesRef) Ref<NiRotatingParticles>;
-%template(DynamicCastToNiRotatingParticles) DynamicCast<NiRotatingParticles>;
-%template(StaticCastToNiRotatingParticles) StaticCast<NiRotatingParticles>;
+%template(NiRotatingParticlesRef) Niflib::Ref<Niflib::NiRotatingParticles>;
+%template(DynamicCastToNiRotatingParticles) Niflib::DynamicCast<Niflib::NiRotatingParticles>;
+%template(StaticCastToNiRotatingParticles) Niflib::StaticCast<Niflib::NiRotatingParticles>;
 %include "obj/NiRotatingParticlesData.h"
-%template(NiRotatingParticlesDataRef) Ref<NiRotatingParticlesData>;
-%template(DynamicCastToNiRotatingParticlesData) DynamicCast<NiRotatingParticlesData>;
-%template(StaticCastToNiRotatingParticlesData) StaticCast<NiRotatingParticlesData>;
+%template(NiRotatingParticlesDataRef) Niflib::Ref<Niflib::NiRotatingParticlesData>;
+%template(DynamicCastToNiRotatingParticlesData) Niflib::DynamicCast<Niflib::NiRotatingParticlesData>;
+%template(StaticCastToNiRotatingParticlesData) Niflib::StaticCast<Niflib::NiRotatingParticlesData>;
 %include "obj/NiScreenLODData.h"
-%template(NiScreenLODDataRef) Ref<NiScreenLODData>;
-%template(DynamicCastToNiScreenLODData) DynamicCast<NiScreenLODData>;
-%template(StaticCastToNiScreenLODData) StaticCast<NiScreenLODData>;
+%template(NiScreenLODDataRef) Niflib::Ref<Niflib::NiScreenLODData>;
+%template(DynamicCastToNiScreenLODData) Niflib::DynamicCast<Niflib::NiScreenLODData>;
+%template(StaticCastToNiScreenLODData) Niflib::StaticCast<Niflib::NiScreenLODData>;
 %include "obj/NiSequenceStreamHelper.h"
-%template(NiSequenceStreamHelperRef) Ref<NiSequenceStreamHelper>;
-%template(DynamicCastToNiSequenceStreamHelper) DynamicCast<NiSequenceStreamHelper>;
-%template(StaticCastToNiSequenceStreamHelper) StaticCast<NiSequenceStreamHelper>;
+%template(NiSequenceStreamHelperRef) Niflib::Ref<Niflib::NiSequenceStreamHelper>;
+%template(DynamicCastToNiSequenceStreamHelper) Niflib::DynamicCast<Niflib::NiSequenceStreamHelper>;
+%template(StaticCastToNiSequenceStreamHelper) Niflib::StaticCast<Niflib::NiSequenceStreamHelper>;
 %include "obj/NiShadeProperty.h"
-%template(NiShadePropertyRef) Ref<NiShadeProperty>;
-%template(DynamicCastToNiShadeProperty) DynamicCast<NiShadeProperty>;
-%template(StaticCastToNiShadeProperty) StaticCast<NiShadeProperty>;
+%template(NiShadePropertyRef) Niflib::Ref<Niflib::NiShadeProperty>;
+%template(DynamicCastToNiShadeProperty) Niflib::DynamicCast<Niflib::NiShadeProperty>;
+%template(StaticCastToNiShadeProperty) Niflib::StaticCast<Niflib::NiShadeProperty>;
 %include "obj/NiSkinData.h"
-%template(NiSkinDataRef) Ref<NiSkinData>;
-%template(DynamicCastToNiSkinData) DynamicCast<NiSkinData>;
-%template(StaticCastToNiSkinData) StaticCast<NiSkinData>;
+%template(NiSkinDataRef) Niflib::Ref<Niflib::NiSkinData>;
+%template(DynamicCastToNiSkinData) Niflib::DynamicCast<Niflib::NiSkinData>;
+%template(StaticCastToNiSkinData) Niflib::StaticCast<Niflib::NiSkinData>;
 %include "obj/NiSkinInstance.h"
-%template(NiSkinInstanceRef) Ref<NiSkinInstance>;
-%template(DynamicCastToNiSkinInstance) DynamicCast<NiSkinInstance>;
-%template(StaticCastToNiSkinInstance) StaticCast<NiSkinInstance>;
+%template(NiSkinInstanceRef) Niflib::Ref<Niflib::NiSkinInstance>;
+%template(DynamicCastToNiSkinInstance) Niflib::DynamicCast<Niflib::NiSkinInstance>;
+%template(StaticCastToNiSkinInstance) Niflib::StaticCast<Niflib::NiSkinInstance>;
 %include "obj/NiSkinPartition.h"
-%template(NiSkinPartitionRef) Ref<NiSkinPartition>;
-%template(DynamicCastToNiSkinPartition) DynamicCast<NiSkinPartition>;
-%template(StaticCastToNiSkinPartition) StaticCast<NiSkinPartition>;
+%template(NiSkinPartitionRef) Niflib::Ref<Niflib::NiSkinPartition>;
+%template(DynamicCastToNiSkinPartition) Niflib::DynamicCast<Niflib::NiSkinPartition>;
+%template(StaticCastToNiSkinPartition) Niflib::StaticCast<Niflib::NiSkinPartition>;
 %include "obj/NiSourceTexture.h"
-%template(NiSourceTextureRef) Ref<NiSourceTexture>;
-%template(DynamicCastToNiSourceTexture) DynamicCast<NiSourceTexture>;
-%template(StaticCastToNiSourceTexture) StaticCast<NiSourceTexture>;
+%template(NiSourceTextureRef) Niflib::Ref<Niflib::NiSourceTexture>;
+%template(DynamicCastToNiSourceTexture) Niflib::DynamicCast<Niflib::NiSourceTexture>;
+%template(StaticCastToNiSourceTexture) Niflib::StaticCast<Niflib::NiSourceTexture>;
 %include "obj/NiSpecularProperty.h"
-%template(NiSpecularPropertyRef) Ref<NiSpecularProperty>;
-%template(DynamicCastToNiSpecularProperty) DynamicCast<NiSpecularProperty>;
-%template(StaticCastToNiSpecularProperty) StaticCast<NiSpecularProperty>;
+%template(NiSpecularPropertyRef) Niflib::Ref<Niflib::NiSpecularProperty>;
+%template(DynamicCastToNiSpecularProperty) Niflib::DynamicCast<Niflib::NiSpecularProperty>;
+%template(StaticCastToNiSpecularProperty) Niflib::StaticCast<Niflib::NiSpecularProperty>;
 %include "obj/NiSphericalCollider.h"
-%template(NiSphericalColliderRef) Ref<NiSphericalCollider>;
-%template(DynamicCastToNiSphericalCollider) DynamicCast<NiSphericalCollider>;
-%template(StaticCastToNiSphericalCollider) StaticCast<NiSphericalCollider>;
+%template(NiSphericalColliderRef) Niflib::Ref<Niflib::NiSphericalCollider>;
+%template(DynamicCastToNiSphericalCollider) Niflib::DynamicCast<Niflib::NiSphericalCollider>;
+%template(StaticCastToNiSphericalCollider) Niflib::StaticCast<Niflib::NiSphericalCollider>;
 %include "obj/NiSpotLight.h"
-%template(NiSpotLightRef) Ref<NiSpotLight>;
-%template(DynamicCastToNiSpotLight) DynamicCast<NiSpotLight>;
-%template(StaticCastToNiSpotLight) StaticCast<NiSpotLight>;
+%template(NiSpotLightRef) Niflib::Ref<Niflib::NiSpotLight>;
+%template(DynamicCastToNiSpotLight) Niflib::DynamicCast<Niflib::NiSpotLight>;
+%template(StaticCastToNiSpotLight) Niflib::StaticCast<Niflib::NiSpotLight>;
 %include "obj/NiStencilProperty.h"
-%template(NiStencilPropertyRef) Ref<NiStencilProperty>;
-%template(DynamicCastToNiStencilProperty) DynamicCast<NiStencilProperty>;
-%template(StaticCastToNiStencilProperty) StaticCast<NiStencilProperty>;
+%template(NiStencilPropertyRef) Niflib::Ref<Niflib::NiStencilProperty>;
+%template(DynamicCastToNiStencilProperty) Niflib::DynamicCast<Niflib::NiStencilProperty>;
+%template(StaticCastToNiStencilProperty) Niflib::StaticCast<Niflib::NiStencilProperty>;
 %include "obj/NiStringExtraData.h"
-%template(NiStringExtraDataRef) Ref<NiStringExtraData>;
-%template(DynamicCastToNiStringExtraData) DynamicCast<NiStringExtraData>;
-%template(StaticCastToNiStringExtraData) StaticCast<NiStringExtraData>;
+%template(NiStringExtraDataRef) Niflib::Ref<Niflib::NiStringExtraData>;
+%template(DynamicCastToNiStringExtraData) Niflib::DynamicCast<Niflib::NiStringExtraData>;
+%template(StaticCastToNiStringExtraData) Niflib::StaticCast<Niflib::NiStringExtraData>;
 %include "obj/NiStringPalette.h"
-%template(NiStringPaletteRef) Ref<NiStringPalette>;
-%template(DynamicCastToNiStringPalette) DynamicCast<NiStringPalette>;
-%template(StaticCastToNiStringPalette) StaticCast<NiStringPalette>;
+%template(NiStringPaletteRef) Niflib::Ref<Niflib::NiStringPalette>;
+%template(DynamicCastToNiStringPalette) Niflib::DynamicCast<Niflib::NiStringPalette>;
+%template(StaticCastToNiStringPalette) Niflib::StaticCast<Niflib::NiStringPalette>;
 %include "obj/NiStringsExtraData.h"
-%template(NiStringsExtraDataRef) Ref<NiStringsExtraData>;
-%template(DynamicCastToNiStringsExtraData) DynamicCast<NiStringsExtraData>;
-%template(StaticCastToNiStringsExtraData) StaticCast<NiStringsExtraData>;
+%template(NiStringsExtraDataRef) Niflib::Ref<Niflib::NiStringsExtraData>;
+%template(DynamicCastToNiStringsExtraData) Niflib::DynamicCast<Niflib::NiStringsExtraData>;
+%template(StaticCastToNiStringsExtraData) Niflib::StaticCast<Niflib::NiStringsExtraData>;
 %include "obj/NiTextKeyExtraData.h"
-%template(NiTextKeyExtraDataRef) Ref<NiTextKeyExtraData>;
-%template(DynamicCastToNiTextKeyExtraData) DynamicCast<NiTextKeyExtraData>;
-%template(StaticCastToNiTextKeyExtraData) StaticCast<NiTextKeyExtraData>;
+%template(NiTextKeyExtraDataRef) Niflib::Ref<Niflib::NiTextKeyExtraData>;
+%template(DynamicCastToNiTextKeyExtraData) Niflib::DynamicCast<Niflib::NiTextKeyExtraData>;
+%template(StaticCastToNiTextKeyExtraData) Niflib::StaticCast<Niflib::NiTextKeyExtraData>;
 %include "obj/NiTextureEffect.h"
-%template(NiTextureEffectRef) Ref<NiTextureEffect>;
-%template(DynamicCastToNiTextureEffect) DynamicCast<NiTextureEffect>;
-%template(StaticCastToNiTextureEffect) StaticCast<NiTextureEffect>;
+%template(NiTextureEffectRef) Niflib::Ref<Niflib::NiTextureEffect>;
+%template(DynamicCastToNiTextureEffect) Niflib::DynamicCast<Niflib::NiTextureEffect>;
+%template(StaticCastToNiTextureEffect) Niflib::StaticCast<Niflib::NiTextureEffect>;
 %include "obj/NiTextureTransformController.h"
-%template(NiTextureTransformControllerRef) Ref<NiTextureTransformController>;
-%template(DynamicCastToNiTextureTransformController) DynamicCast<NiTextureTransformController>;
-%template(StaticCastToNiTextureTransformController) StaticCast<NiTextureTransformController>;
+%template(NiTextureTransformControllerRef) Niflib::Ref<Niflib::NiTextureTransformController>;
+%template(DynamicCastToNiTextureTransformController) Niflib::DynamicCast<Niflib::NiTextureTransformController>;
+%template(StaticCastToNiTextureTransformController) Niflib::StaticCast<Niflib::NiTextureTransformController>;
 %include "obj/NiTexturingProperty.h"
-%template(NiTexturingPropertyRef) Ref<NiTexturingProperty>;
-%template(DynamicCastToNiTexturingProperty) DynamicCast<NiTexturingProperty>;
-%template(StaticCastToNiTexturingProperty) StaticCast<NiTexturingProperty>;
+%template(NiTexturingPropertyRef) Niflib::Ref<Niflib::NiTexturingProperty>;
+%template(DynamicCastToNiTexturingProperty) Niflib::DynamicCast<Niflib::NiTexturingProperty>;
+%template(StaticCastToNiTexturingProperty) Niflib::StaticCast<Niflib::NiTexturingProperty>;
 %include "obj/NiTransformController.h"
-%template(NiTransformControllerRef) Ref<NiTransformController>;
-%template(DynamicCastToNiTransformController) DynamicCast<NiTransformController>;
-%template(StaticCastToNiTransformController) StaticCast<NiTransformController>;
+%template(NiTransformControllerRef) Niflib::Ref<Niflib::NiTransformController>;
+%template(DynamicCastToNiTransformController) Niflib::DynamicCast<Niflib::NiTransformController>;
+%template(StaticCastToNiTransformController) Niflib::StaticCast<Niflib::NiTransformController>;
 %include "obj/NiTransformData.h"
-%template(NiTransformDataRef) Ref<NiTransformData>;
-%template(DynamicCastToNiTransformData) DynamicCast<NiTransformData>;
-%template(StaticCastToNiTransformData) StaticCast<NiTransformData>;
+%template(NiTransformDataRef) Niflib::Ref<Niflib::NiTransformData>;
+%template(DynamicCastToNiTransformData) Niflib::DynamicCast<Niflib::NiTransformData>;
+%template(StaticCastToNiTransformData) Niflib::StaticCast<Niflib::NiTransformData>;
 %include "obj/NiTransformInterpolator.h"
-%template(NiTransformInterpolatorRef) Ref<NiTransformInterpolator>;
-%template(DynamicCastToNiTransformInterpolator) DynamicCast<NiTransformInterpolator>;
-%template(StaticCastToNiTransformInterpolator) StaticCast<NiTransformInterpolator>;
+%template(NiTransformInterpolatorRef) Niflib::Ref<Niflib::NiTransformInterpolator>;
+%template(DynamicCastToNiTransformInterpolator) Niflib::DynamicCast<Niflib::NiTransformInterpolator>;
+%template(StaticCastToNiTransformInterpolator) Niflib::StaticCast<Niflib::NiTransformInterpolator>;
 %include "obj/NiTriShape.h"
-%template(NiTriShapeRef) Ref<NiTriShape>;
-%template(DynamicCastToNiTriShape) DynamicCast<NiTriShape>;
-%template(StaticCastToNiTriShape) StaticCast<NiTriShape>;
+%template(NiTriShapeRef) Niflib::Ref<Niflib::NiTriShape>;
+%template(DynamicCastToNiTriShape) Niflib::DynamicCast<Niflib::NiTriShape>;
+%template(StaticCastToNiTriShape) Niflib::StaticCast<Niflib::NiTriShape>;
 %include "obj/NiTriShapeData.h"
-%template(NiTriShapeDataRef) Ref<NiTriShapeData>;
-%template(DynamicCastToNiTriShapeData) DynamicCast<NiTriShapeData>;
-%template(StaticCastToNiTriShapeData) StaticCast<NiTriShapeData>;
+%template(NiTriShapeDataRef) Niflib::Ref<Niflib::NiTriShapeData>;
+%template(DynamicCastToNiTriShapeData) Niflib::DynamicCast<Niflib::NiTriShapeData>;
+%template(StaticCastToNiTriShapeData) Niflib::StaticCast<Niflib::NiTriShapeData>;
 %include "obj/NiTriStrips.h"
-%template(NiTriStripsRef) Ref<NiTriStrips>;
-%template(DynamicCastToNiTriStrips) DynamicCast<NiTriStrips>;
-%template(StaticCastToNiTriStrips) StaticCast<NiTriStrips>;
+%template(NiTriStripsRef) Niflib::Ref<Niflib::NiTriStrips>;
+%template(DynamicCastToNiTriStrips) Niflib::DynamicCast<Niflib::NiTriStrips>;
+%template(StaticCastToNiTriStrips) Niflib::StaticCast<Niflib::NiTriStrips>;
 %include "obj/NiTriStripsData.h"
-%template(NiTriStripsDataRef) Ref<NiTriStripsData>;
-%template(DynamicCastToNiTriStripsData) DynamicCast<NiTriStripsData>;
-%template(StaticCastToNiTriStripsData) StaticCast<NiTriStripsData>;
+%template(NiTriStripsDataRef) Niflib::Ref<Niflib::NiTriStripsData>;
+%template(DynamicCastToNiTriStripsData) Niflib::DynamicCast<Niflib::NiTriStripsData>;
+%template(StaticCastToNiTriStripsData) Niflib::StaticCast<Niflib::NiTriStripsData>;
 %include "obj/NiUVController.h"
-%template(NiUVControllerRef) Ref<NiUVController>;
-%template(DynamicCastToNiUVController) DynamicCast<NiUVController>;
-%template(StaticCastToNiUVController) StaticCast<NiUVController>;
+%template(NiUVControllerRef) Niflib::Ref<Niflib::NiUVController>;
+%template(DynamicCastToNiUVController) Niflib::DynamicCast<Niflib::NiUVController>;
+%template(StaticCastToNiUVController) Niflib::StaticCast<Niflib::NiUVController>;
 %include "obj/NiUVData.h"
-%template(NiUVDataRef) Ref<NiUVData>;
-%template(DynamicCastToNiUVData) DynamicCast<NiUVData>;
-%template(StaticCastToNiUVData) StaticCast<NiUVData>;
+%template(NiUVDataRef) Niflib::Ref<Niflib::NiUVData>;
+%template(DynamicCastToNiUVData) Niflib::DynamicCast<Niflib::NiUVData>;
+%template(StaticCastToNiUVData) Niflib::StaticCast<Niflib::NiUVData>;
 %include "obj/NiVectorExtraData.h"
-%template(NiVectorExtraDataRef) Ref<NiVectorExtraData>;
-%template(DynamicCastToNiVectorExtraData) DynamicCast<NiVectorExtraData>;
-%template(StaticCastToNiVectorExtraData) StaticCast<NiVectorExtraData>;
+%template(NiVectorExtraDataRef) Niflib::Ref<Niflib::NiVectorExtraData>;
+%template(DynamicCastToNiVectorExtraData) Niflib::DynamicCast<Niflib::NiVectorExtraData>;
+%template(StaticCastToNiVectorExtraData) Niflib::StaticCast<Niflib::NiVectorExtraData>;
 %include "obj/NiVertexColorProperty.h"
-%template(NiVertexColorPropertyRef) Ref<NiVertexColorProperty>;
-%template(DynamicCastToNiVertexColorProperty) DynamicCast<NiVertexColorProperty>;
-%template(StaticCastToNiVertexColorProperty) StaticCast<NiVertexColorProperty>;
+%template(NiVertexColorPropertyRef) Niflib::Ref<Niflib::NiVertexColorProperty>;
+%template(DynamicCastToNiVertexColorProperty) Niflib::DynamicCast<Niflib::NiVertexColorProperty>;
+%template(StaticCastToNiVertexColorProperty) Niflib::StaticCast<Niflib::NiVertexColorProperty>;
 %include "obj/NiVertWeightsExtraData.h"
-%template(NiVertWeightsExtraDataRef) Ref<NiVertWeightsExtraData>;
-%template(DynamicCastToNiVertWeightsExtraData) DynamicCast<NiVertWeightsExtraData>;
-%template(StaticCastToNiVertWeightsExtraData) StaticCast<NiVertWeightsExtraData>;
+%template(NiVertWeightsExtraDataRef) Niflib::Ref<Niflib::NiVertWeightsExtraData>;
+%template(DynamicCastToNiVertWeightsExtraData) Niflib::DynamicCast<Niflib::NiVertWeightsExtraData>;
+%template(StaticCastToNiVertWeightsExtraData) Niflib::StaticCast<Niflib::NiVertWeightsExtraData>;
 %include "obj/NiVisController.h"
-%template(NiVisControllerRef) Ref<NiVisController>;
-%template(DynamicCastToNiVisController) DynamicCast<NiVisController>;
-%template(StaticCastToNiVisController) StaticCast<NiVisController>;
+%template(NiVisControllerRef) Niflib::Ref<Niflib::NiVisController>;
+%template(DynamicCastToNiVisController) Niflib::DynamicCast<Niflib::NiVisController>;
+%template(StaticCastToNiVisController) Niflib::StaticCast<Niflib::NiVisController>;
 %include "obj/NiVisData.h"
-%template(NiVisDataRef) Ref<NiVisData>;
-%template(DynamicCastToNiVisData) DynamicCast<NiVisData>;
-%template(StaticCastToNiVisData) StaticCast<NiVisData>;
+%template(NiVisDataRef) Niflib::Ref<Niflib::NiVisData>;
+%template(DynamicCastToNiVisData) Niflib::DynamicCast<Niflib::NiVisData>;
+%template(StaticCastToNiVisData) Niflib::StaticCast<Niflib::NiVisData>;
 %include "obj/NiWireframeProperty.h"
-%template(NiWireframePropertyRef) Ref<NiWireframeProperty>;
-%template(DynamicCastToNiWireframeProperty) DynamicCast<NiWireframeProperty>;
-%template(StaticCastToNiWireframeProperty) StaticCast<NiWireframeProperty>;
+%template(NiWireframePropertyRef) Niflib::Ref<Niflib::NiWireframeProperty>;
+%template(DynamicCastToNiWireframeProperty) Niflib::DynamicCast<Niflib::NiWireframeProperty>;
+%template(StaticCastToNiWireframeProperty) Niflib::StaticCast<Niflib::NiWireframeProperty>;
 %include "obj/NiZBufferProperty.h"
-%template(NiZBufferPropertyRef) Ref<NiZBufferProperty>;
-%template(DynamicCastToNiZBufferProperty) DynamicCast<NiZBufferProperty>;
-%template(StaticCastToNiZBufferProperty) StaticCast<NiZBufferProperty>;
+%template(NiZBufferPropertyRef) Niflib::Ref<Niflib::NiZBufferProperty>;
+%template(DynamicCastToNiZBufferProperty) Niflib::DynamicCast<Niflib::NiZBufferProperty>;
+%template(StaticCastToNiZBufferProperty) Niflib::StaticCast<Niflib::NiZBufferProperty>;
 %include "obj/RootCollisionNode.h"
-%template(RootCollisionNodeRef) Ref<RootCollisionNode>;
-%template(DynamicCastToRootCollisionNode) DynamicCast<RootCollisionNode>;
-%template(StaticCastToRootCollisionNode) StaticCast<RootCollisionNode>;
+%template(RootCollisionNodeRef) Niflib::Ref<Niflib::RootCollisionNode>;
+%template(DynamicCastToRootCollisionNode) Niflib::DynamicCast<Niflib::RootCollisionNode>;
+%template(StaticCastToRootCollisionNode) Niflib::StaticCast<Niflib::RootCollisionNode>;
 %include "gen/ByteArray.h"
 %include "gen/Footer.h"
 %include "gen/LODRange.h"
@@ -1254,4 +1243,4 @@ struct Key {
 %include "gen/RagDollDescriptor.h"
 %include "gen/LimitedHingeDescriptor.h"
 
-%template(vector_NiAVObjectRef) std::vector<NiAVObjectRef>;
+%template(vector_NiAVObjectRef) std::vector<Niflib::NiAVObjectRef>;
-- 
GitLab