fixed warning related with clang

Create Export for DLL (shared MSVC build)

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.26)
 
 project(omath VERSION 1.0.0)
 
-
+include(CMakePackageConfigHelpers)
 
 set(CMAKE_CXX_STANDARD 26)
 
@@ -19,10 +19,16 @@ else()
     add_library(omath STATIC source/Vector3.cpp)
 endif()
 
+target_compile_definitions(omath PUBLIC OMATH_EXPORT)
+
+if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+    target_compile_options(omath PRIVATE /Zc:static_assert-)
+endif()
+
 add_subdirectory(source)
-add_subdirectory(extlibs)
 
 if(OMATH_BUILD_TESTS)
+    add_subdirectory(extlibs)
     add_subdirectory(tests)
 endif()
 
@@ -79,4 +85,4 @@ install(FILES
         "${CMAKE_CURRENT_BINARY_DIR}/omathConfig.cmake"
         "${CMAKE_CURRENT_BINARY_DIR}/omathConfigVersion.cmake"
         DESTINATION lib/cmake/omath
-)
+)

include/omath/Angle.hpp

@@ -6,7 +6,7 @@
 #include "omath/Angles.hpp"
 
 #include <algorithm>
-
+#include "omath/omath_export.hpp"
 
 namespace omath
 {
@@ -18,7 +18,7 @@ namespace omath
 
     template<class Type = float, Type min = Type(0), Type max = Type(360), AngleFlags flags = AngleFlags::Normalized>
     requires std::is_arithmetic_v<Type>
-    class Angle
+    class OMATH_API Angle
     {
         Type m_angle;
         constexpr Angle(const Type& degrees)

include/omath/Angles.hpp

@@ -6,7 +6,6 @@
 #include <numbers>
 #include <cmath>
 
-
 namespace omath::angles
 {
     template<class Type>

include/omath/Color.hpp

@@ -7,11 +7,11 @@
 #include "omath/Vector3.hpp"
 #include <cstdint>
 #include "omath/Vector4.hpp"
-
+#include "omath/omath_export.hpp"
 
 namespace omath
 {
-    struct HSV
+    struct OMATH_API HSV
     {
         float m_hue{};
         float m_saturation{};
@@ -19,7 +19,7 @@ namespace omath
     };
 
 
-    class Color final : public Vector4
+    class OMATH_API Color final : public Vector4
     {
         public:
             constexpr Color(float r, float g, float b, float a) : Vector4(r,g,b,a)

include/omath/Mat.hpp

@@ -8,11 +8,11 @@
 #include <stdexcept>
 #include <utility>
 #include "Vector3.hpp"
-
+#include "omath/omath_export.hpp"
 
 namespace omath
 {
-    struct MatSize
+    struct OMATH_API MatSize
     {
         size_t rows, columns;
     };
@@ -28,15 +28,15 @@ namespace omath
     class Mat final
     {
     public:
-        constexpr Mat()
+        OMATH_API constexpr Mat()
         {
             Clear();
         }
-        constexpr static MatStoreType GetStoreOrdering()
+        OMATH_API constexpr static MatStoreType GetStoreOrdering()
         {
             return StoreType;
         }
-        constexpr Mat(const std::initializer_list<std::initializer_list<Type>>& rows)
+        OMATH_API constexpr Mat(const std::initializer_list<std::initializer_list<Type>>& rows)
         {
             if (rows.size() != Rows)
                 throw std::invalid_argument("Initializer list rows size does not match template parameter Rows");
@@ -56,40 +56,40 @@ namespace omath
             }
         }
 
-        constexpr explicit Mat(const Type* rawData)
+        OMATH_API constexpr explicit Mat(const Type* rawData)
         {
             std::copy_n(rawData, Rows * Columns, m_data.begin());
         }
 
-        constexpr Mat(const Mat& other) noexcept
+        OMATH_API constexpr Mat(const Mat& other) noexcept
         {
             m_data = other.m_data;
         }
 
-        constexpr Mat(Mat&& other) noexcept
+        OMATH_API constexpr Mat(Mat&& other) noexcept
         {
             m_data = std::move(other.m_data);
         }
 
         [[nodiscard]]
-        static constexpr size_t RowCount() noexcept
+        OMATH_API static constexpr size_t RowCount() noexcept
         {
             return Rows;
         }
 
         [[nodiscard]]
-        static constexpr size_t ColumnsCount() noexcept
+        OMATH_API static constexpr size_t ColumnsCount() noexcept
         {
             return Columns;
         }
 
         [[nodiscard]]
-        static consteval MatSize Size() noexcept
+        OMATH_API static consteval MatSize Size() noexcept
         {
             return {Rows, Columns};
         }
 
-        [[nodiscard]] constexpr const Type& At(const size_t rowIndex, const size_t columnIndex) const
+        [[nodiscard]] OMATH_API constexpr const Type& At(const size_t rowIndex, const size_t columnIndex) const
         {
             if (rowIndex >= Rows || columnIndex >= Columns)
                 throw std::out_of_range("Index out of range");
@@ -107,13 +107,13 @@ namespace omath
             }
         }
 
-        [[nodiscard]] constexpr Type& At(const size_t rowIndex, const size_t columnIndex)
+        [[nodiscard]] OMATH_API constexpr Type& At(const size_t rowIndex, const size_t columnIndex)
         {
             return const_cast<Type&>(std::as_const(*this).At(rowIndex, columnIndex));
         }
 
         [[nodiscard]]
-        constexpr Type Sum() const noexcept
+        OMATH_API constexpr Type Sum() const noexcept
         {
             Type sum = 0;
             for (size_t i = 0; i < Rows; ++i)
@@ -123,12 +123,12 @@ namespace omath
             return sum;
         }
 
-        constexpr void Clear() noexcept
+        OMATH_API constexpr void Clear() noexcept
         {
             Set(0);
         }
 
-        constexpr void Set(const Type& value) noexcept
+        OMATH_API constexpr void Set(const Type& value) noexcept
         {
             std::ranges::fill(m_data, value);
         }
@@ -136,7 +136,7 @@ namespace omath
         // Operator overloading for multiplication with another Mat
         template<size_t OtherColumns>
         constexpr Mat<Rows, OtherColumns, Type, StoreType>
-        operator*(const Mat<Columns, OtherColumns, Type, StoreType>& other) const
+        OMATH_API operator*(const Mat<Columns, OtherColumns, Type, StoreType>& other) const
         {
             Mat<Rows, OtherColumns, Type, StoreType> result;
 
@@ -151,7 +151,7 @@ namespace omath
             return result;
         }
 
-        constexpr Mat& operator*=(const Type& f) noexcept
+        OMATH_API constexpr Mat& operator*=(const Type& f) noexcept
         {
             for (size_t i = 0; i < Rows; ++i)
                 for (size_t j = 0; j < Columns; ++j)
@@ -161,19 +161,19 @@ namespace omath
 
         template<size_t OtherColumns>
         constexpr Mat<Rows, OtherColumns, Type, StoreType>
-        operator*=(const Mat<Columns, OtherColumns, Type, StoreType>& other)
+        OMATH_API operator*=(const Mat<Columns, OtherColumns, Type, StoreType>& other)
         {
             return *this = *this * other;
         }
 
-        constexpr Mat operator*(const Type& f) const noexcept
+        OMATH_API constexpr Mat operator*(const Type& f) const noexcept
         {
             Mat result(*this);
             result *= f;
             return result;
         }
 
-        constexpr Mat& operator/=(const Type& f) noexcept
+        OMATH_API constexpr Mat& operator/=(const Type& f) noexcept
         {
             for (size_t i = 0; i < Rows; ++i)
                 for (size_t j = 0; j < Columns; ++j)
@@ -181,14 +181,14 @@ namespace omath
             return *this;
         }
 
-        constexpr Mat operator/(const Type& f) const noexcept
+        OMATH_API constexpr Mat operator/(const Type& f) const noexcept
         {
             Mat result(*this);
             result /= f;
             return result;
         }
 
-        constexpr Mat& operator=(const Mat& other) noexcept
+        OMATH_API constexpr Mat& operator=(const Mat& other) noexcept
         {
             if (this == &other)
                 return *this;
@@ -198,7 +198,7 @@ namespace omath
             return *this;
         }
 
-        constexpr Mat& operator=(Mat&& other) noexcept
+        OMATH_API constexpr Mat& operator=(Mat&& other) noexcept
         {
             if (this == &other)
                 return *this;
@@ -211,7 +211,7 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Mat<Columns, Rows, Type, StoreType> Transposed() const noexcept
+        OMATH_API constexpr Mat<Columns, Rows, Type, StoreType> Transposed() const noexcept
         {
             Mat<Columns, Rows, Type, StoreType> transposed;
             for (size_t i = 0; i < Rows; ++i)
@@ -222,7 +222,7 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Type Determinant() const
+        OMATH_API constexpr Type Determinant() const
         {
             static_assert(Rows == Columns, "Determinant is only defined for square matrices.");
 
@@ -244,7 +244,7 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Mat<Rows - 1, Columns - 1, Type, StoreType> Minor(const size_t row, const size_t column) const
+        OMATH_API constexpr Mat<Rows - 1, Columns - 1, Type, StoreType> Minor(const size_t row, const size_t column) const
         {
             Mat<Rows - 1, Columns - 1, Type, StoreType> result;
             for (size_t i = 0, m = 0; i < Rows; ++i)
@@ -264,19 +264,19 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr const std::array<Type, Rows * Columns>& RawArray() const
+        OMATH_API constexpr const std::array<Type, Rows * Columns>& RawArray() const
         {
             return m_data;
         }
 
         [[nodiscard]]
-        constexpr std::array<Type, Rows * Columns>& RawArray()
+        OMATH_API constexpr std::array<Type, Rows * Columns>& RawArray()
         {
             return const_cast<std::array<Type, Rows * Columns>>(std::as_const(*this).RawArray());
         }
 
         [[nodiscard]]
-        std::string ToString() const noexcept
+        OMATH_API std::string ToString() const noexcept
         {
             std::ostringstream oss;
             for (size_t i = 0; i < Rows; ++i)
@@ -293,20 +293,20 @@ namespace omath
         }
 
         [[nodiscard]]
-        bool operator==(const Mat& mat) const
+        OMATH_API bool operator==(const Mat& mat) const
         {
             return m_data == mat.m_data;
         }
 
         [[nodiscard]]
-        bool operator!=(const Mat& mat) const
+        OMATH_API bool operator!=(const Mat& mat) const
         {
             return !operator==(mat);
         }
 
         // Static methods that return fixed-size matrices
         [[nodiscard]]
-        constexpr static Mat<4, 4> ToScreenMat(const Type& screenWidth, const Type& screenHeight) noexcept
+        OMATH_API constexpr static Mat<4, 4> ToScreenMat(const Type& screenWidth, const Type& screenHeight) noexcept
         {
             return {
                     {screenWidth / 2, 0, 0, 0},
@@ -336,7 +336,7 @@ namespace omath
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     [[nodiscard]]
-    constexpr Mat<4, 4, Type, St> MatTranslation(const Vector3& diff) noexcept
+    OMATH_API constexpr Mat<4, 4, Type, St> MatTranslation(const Vector3& diff) noexcept
     {
         return
         {
@@ -349,7 +349,7 @@ namespace omath
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
     [[nodiscard]]
-    Mat<4, 4, Type, St> MatRotationAxisX(const Angle& angle) noexcept
+    OMATH_API Mat<4, 4, Type, St> MatRotationAxisX(const Angle& angle) noexcept
     {
         return
         {
@@ -362,7 +362,7 @@ namespace omath
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
     [[nodiscard]]
-    Mat<4, 4, Type, St> MatRotationAxisY(const Angle& angle) noexcept
+    OMATH_API Mat<4, 4, Type, St> MatRotationAxisY(const Angle& angle) noexcept
     {
         return
         {
@@ -375,7 +375,7 @@ namespace omath
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
     [[nodiscard]]
-    Mat<4, 4, Type, St> MatRotationAxisZ(const Angle& angle) noexcept
+    OMATH_API Mat<4, 4, Type, St> MatRotationAxisZ(const Angle& angle) noexcept
     {
         return
         {
@@ -403,7 +403,7 @@ namespace omath
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class ViewAngles>
     [[nodiscard]]
-    Mat<4, 4, Type, St> MatRotation(const ViewAngles& angles) noexcept
+    OMATH_API Mat<4, 4, Type, St> MatRotation(const ViewAngles& angles) noexcept
     {
         return MatRotationAxisZ(angles.yaw) * MatRotationAxisY(angles.pitch) * MatRotationAxisX(angles.roll);
     }

include/omath/Matrix.hpp

@@ -2,6 +2,7 @@
 #include <initializer_list>
 #include <memory>
 #include <string>
+#include "omath/omath_export.hpp"
 
 namespace omath
 {
@@ -10,91 +11,91 @@ namespace omath
     class Matrix final
     {
     public:
-        Matrix();
+        OMATH_API Matrix();
-        Matrix(size_t rows, size_t columns);
+        OMATH_API Matrix(size_t rows, size_t columns);
 
-        Matrix(const std::initializer_list<std::initializer_list<float>>& rows);
+        OMATH_API Matrix(const std::initializer_list<std::initializer_list<float>>& rows);
 
         [[nodiscard]]
-        static Matrix ToScreenMatrix(float screenWidth, float screenHeight);
+        OMATH_API static Matrix ToScreenMatrix(float screenWidth, float screenHeight);
 
         [[nodiscard]]
-        static Matrix TranslationMatrix(const Vector3& diff);
+        OMATH_API static Matrix TranslationMatrix(const Vector3& diff);
 
         [[nodiscard]]
-        static Matrix OrientationMatrix(const Vector3& forward, const Vector3& right, const Vector3& up);
+        OMATH_API static Matrix OrientationMatrix(const Vector3& forward, const Vector3& right, const Vector3& up);
 
         [[nodiscard]]
-        static Matrix ProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
+        OMATH_API static Matrix ProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
 
-        Matrix(const Matrix& other);
+        OMATH_API Matrix(const Matrix& other);
 
-        Matrix(size_t rows, size_t columns, const float* pRaw);
+        OMATH_API Matrix(size_t rows, size_t columns, const float* pRaw);
 
-        Matrix(Matrix&& other) noexcept;
+        OMATH_API Matrix(Matrix&& other) noexcept;
 
         [[nodiscard]]
-        size_t RowCount() const noexcept;
+        OMATH_API size_t RowCount() const noexcept;
 
         [[nodiscard]]
-        size_t ColumnsCount() const noexcept;
+        OMATH_API size_t ColumnsCount() const noexcept;
 
         [[nodiscard]]
-        std::pair<size_t, size_t> Size() const noexcept;
+        OMATH_API std::pair<size_t, size_t> Size() const noexcept;
 
         [[nodiscard]]
-        float& At(size_t iRow, size_t iCol);
+        OMATH_API float& At(size_t iRow, size_t iCol);
 
         [[nodiscard]]
-        float Sum();
+        OMATH_API float Sum();
 
-        void SetDataFromRaw(const float* pRawMatrix);
+        OMATH_API void SetDataFromRaw(const float* pRawMatrix);
 
         [[nodiscard]]
-        Matrix Transpose() const;
+        OMATH_API Matrix Transpose() const;
 
-        void Set(float val);
+        OMATH_API void Set(float val);
 
         [[nodiscard]]
-        const float& At(size_t iRow, size_t iCol) const;
+        OMATH_API const float& At(size_t iRow, size_t iCol) const;
 
-        Matrix operator*(const Matrix& other) const;
+        OMATH_API Matrix operator*(const Matrix& other) const;
 
-        Matrix& operator*=(const Matrix& other);
+        OMATH_API Matrix& operator*=(const Matrix& other);
 
-        Matrix operator*(float f) const;
+        OMATH_API Matrix operator*(float f) const;
 
-        Matrix& operator*=(float f);
+        OMATH_API Matrix& operator*=(float f);
 
-        Matrix& operator/=(float f);
+        OMATH_API Matrix& operator/=(float f);
 
-        void Clear();
+        OMATH_API void Clear();
 
         [[nodiscard]]
-        Matrix Strip(size_t row, size_t column) const;
+        OMATH_API Matrix Strip(size_t row, size_t column) const;
 
         [[nodiscard]]
-        float Minor(size_t i, size_t j) const;
+        OMATH_API float Minor(size_t i, size_t j) const;
 
         [[nodiscard]]
-        float AlgComplement(size_t i, size_t j) const;
+        OMATH_API float AlgComplement(size_t i, size_t j) const;
 
         [[nodiscard]]
-        float Determinant() const;
+        OMATH_API float Determinant() const;
 
         [[nodiscard]]
-        const float* Raw() const;
+        OMATH_API const float* Raw() const;
 
-        Matrix& operator=(const Matrix& other);
+        OMATH_API Matrix& operator=(const Matrix& other);
 
-        Matrix& operator=(Matrix&& other) noexcept;
+        OMATH_API Matrix& operator=(Matrix&& other) noexcept;
 
-        Matrix operator/(float f) const;
+        OMATH_API Matrix operator/(float f) const;
 
         [[nodiscard]]
-        std::string ToString() const;
+        OMATH_API std::string ToString() const;
 
-        ~Matrix();
+        OMATH_API ~Matrix();
 
     private:
         size_t m_rows;

include/omath/Triangle3d.hpp

@@ -3,10 +3,11 @@
 //
 #pragma once
 #include "omath/Vector3.hpp"
+#include "omath/omath_export.hpp"
 
 namespace omath
 {
-    class Triangle3d final
+    class OMATH_API Triangle3d final
     {
     public:
         Triangle3d(const Vector3& vertex1, const Vector3& vertex2, const Vector3& vertex3);

include/omath/Vector2.hpp

@@ -5,11 +5,11 @@
 #pragma once
 #include <tuple>
 #include <cmath>
-
+#include "omath/omath_export.hpp"
 
 namespace omath
 {
-    class Vector2
+    class OMATH_API Vector2
     {
     public:
         float x = 0.f;

include/omath/Vector3.hpp

@@ -7,11 +7,11 @@
 #include <cstdint>
 #include <functional>
 #include "omath/Vector2.hpp"
-
+#include "omath/omath_export.hpp"
 
 namespace omath
 {
-    class Vector3 : public Vector2
+    class OMATH_API Vector3 : public Vector2
     {
     public:
         float z = 0.f;

include/omath/Vector4.hpp

@@ -5,11 +5,11 @@
 
 #include <omath/Vector3.hpp>
 #include <algorithm>
-
+#include "omath/omath_export.hpp"
 
 namespace omath
 {
-    class Vector4 : public Vector3
+    class OMATH_API Vector4 : public Vector3
     {
     public:
         float w;

include/omath/ViewAngles.hpp

@@ -3,10 +3,12 @@
 //
 #pragma once
 
+#include "omath/omath_export.hpp"
+
 namespace omath
 {
     template<class PitchType, class YawType, class RollType>
-    struct ViewAngles
+    struct OMATH_API ViewAngles
     {
         PitchType pitch;
         YawType yaw;

include/omath/collision/LineTracer.hpp

@@ -5,11 +5,11 @@
 
 #include "omath/Vector3.hpp"
 #include "omath/Triangle3d.hpp"
-
+#include "omath/omath_export.hpp"
 
 namespace omath::collision
 {
-    class Ray
+    class OMATH_API Ray
     {
     public:
         Vector3 start;
@@ -21,7 +21,7 @@ namespace omath::collision
         [[nodiscard]]
         Vector3 DirectionVectorNormalized() const;
     };
-    class LineTracer
+    class OMATH_API LineTracer
     {
     public:
         LineTracer() = delete;

include/omath/engines/Source/Camera.hpp

@@ -4,14 +4,15 @@
 #pragma once
 #include "Constants.h"
 #include "omath/projection/Camera.hpp"
+#include "omath/omath_export.hpp"
 
 namespace omath::source
 {
-    class Camera final : public projection::Camera<Mat4x4, ViewAngles>
+    class OMATH_API Camera final : public projection::Camera<Mat4x4, ViewAngles>
     {
     public:
         Camera(const Vector3& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
-               const Angle<float, 0, 180, AngleFlags::Clamped>& fov, float near, float far);
+               const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
         void LookAt(const Vector3& target) override;
         [[nodiscard]] Mat4x4 GetViewMatrix() const override;
         [[nodiscard]] Mat4x4 GetProjectionMatrix() const override;

include/omath/omath_export.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+/* Export prefix for functions */
+#ifdef _MSC_VER
+	/* MSVC */
+#	define OMATH_API_EXPORT __declspec(dllexport)
+#else
+	/* GCC/Clang */
+#	define OMATH_API_EXPORT __attribute__((visibility("default")))
+#endif
+
+/* Import prefix for functions */
+#ifdef _MSC_VER
+#	define OMATH_API_IMPORT __declspec(dllimport)
+#else
+#	define OMATH_API_IMPORT extern
+#endif
+
+/* Resolve import/export */
+#ifdef OMATH_EXPORT
+#	define OMATH_API OMATH_API_EXPORT
+#else
+#	define OMATH_API OMATH_API_IMPORT
+#endif

include/omath/pathfinding/Astar.hpp

@@ -6,11 +6,11 @@
 #include <vector>
 #include "NavigationMesh.hpp"
 #include "omath/Vector3.hpp"
-
+#include "omath/omath_export.hpp"
 
 namespace omath::pathfinding
 {
-    class Astar final
+    class OMATH_API Astar final
     {
     public:
         [[nodiscard]]

include/omath/pathfinding/NavigationMesh.hpp

@@ -8,7 +8,7 @@
 #include <expected>
 #include <vector>
 #include <string>
-
+#include "omath/omath_export.hpp"
 
 namespace omath::pathfinding
 {
@@ -23,16 +23,16 @@ namespace omath::pathfinding
     public:
 
         [[nodiscard]]
-        std::expected<Vector3, std::string> GetClosestVertex(const Vector3& point) const;
+        OMATH_API std::expected<Vector3, std::string> GetClosestVertex(const Vector3& point) const;
 
 
         [[nodiscard]]
-        const std::vector<Vector3>& GetNeighbors(const Vector3& vertex) const;
+        OMATH_API const std::vector<Vector3>& GetNeighbors(const Vector3& vertex) const;
 
         [[nodiscard]]
-        bool Empty() const;
+        OMATH_API bool Empty() const;
         [[nodiscard]] std::vector<uint8_t> Serialize() const;
-        void Deserialize(const std::vector<uint8_t>& raw);
+        OMATH_API void Deserialize(const std::vector<uint8_t>& raw);
 
         std::unordered_map<Vector3, std::vector<Vector3>> m_verTextMap;
     };

include/omath/prediction/Engine.hpp

@@ -8,11 +8,11 @@
 #include "omath/Vector3.hpp"
 #include "omath/prediction/Projectile.hpp"
 #include "omath/prediction/Target.hpp"
-
+#include "omath/omath_export.hpp"
 
 namespace omath::prediction
 {
-    class Engine final
+    class OMATH_API Engine final
     {
     public:
         explicit Engine(float gravityConstant, float simulationTimeStep,

include/omath/prediction/Projectile.hpp

@@ -4,11 +4,11 @@
 
 #pragma once
 #include "omath/Vector3.hpp"
-
+#include "omath/omath_export.hpp"
 
 namespace omath::prediction
 {
-    class Projectile final
+    class OMATH_API Projectile final
     {
     public:
 

include/omath/prediction/Target.hpp

@@ -4,11 +4,11 @@
 
 #pragma once
 #include "omath/Vector3.hpp"
-
+#include "omath/omath_export.hpp"
 
 namespace omath::prediction
 {
-    class Target final
+    class OMATH_API Target final
     {
     public:
 

include/omath/projection/Camera.hpp

@@ -10,11 +10,11 @@
 #include "ErrorCodes.hpp"
 #include <omath/Angle.hpp>
 #include <type_traits>
-
+#include "omath/omath_export.hpp"
 
 namespace omath::projection
 {
-    class ViewPort final
+    class OMATH_API ViewPort final
     {
     public:
         float m_width;
@@ -28,7 +28,7 @@ namespace omath::projection
     using FieldOfView = const Angle<float, 0.f, 180.f, AngleFlags::Clamped>;
 
     template<class Mat4x4Type, class ViewAnglesType>
-    class Camera
+    class OMATH_API Camera
     {
 
     public: