diff --git a/engine/asset/include/asset_types.hpp b/engine/asset/include/asset_types.hpp index c031491..9a0f24d 100644 --- a/engine/asset/include/asset_types.hpp +++ b/engine/asset/include/asset_types.hpp @@ -63,9 +63,9 @@ struct Bone { Bone* parent = nullptr; - Vector3 position; + prism::float3 position; Quaternion rotation; - Vector3 scale; + prism::float3 scale; }; class Mesh : public Asset { @@ -74,7 +74,7 @@ public: // with multiple materials with different textures, etc struct Part { std::string name; - AABB aabb; + prism::aabb bounding_box; GFXBuffer* bone_batrix_buffer = nullptr; std::vector offset_matrices; diff --git a/engine/asset/include/material_nodes.hpp b/engine/asset/include/material_nodes.hpp index 308a5b8..c1d824f 100644 --- a/engine/asset/include/material_nodes.hpp +++ b/engine/asset/include/material_nodes.hpp @@ -46,8 +46,8 @@ struct MaterialProperty { DataType type; MaterialProperty(std::string n, DataType t) : name(n), type(t) {} - - Vector3 value; + + prism::float3 value; AssetPtr value_tex; float float_value; }; diff --git a/engine/asset/src/asset.cpp b/engine/asset/src/asset.cpp index 77d6af6..8e5b094 100644 --- a/engine/asset/src/asset.cpp +++ b/engine/asset/src/asset.cpp @@ -61,11 +61,11 @@ std::unique_ptr load_mesh(const prism::path path) { }; // read positions - mesh->position_buffer = read_buffer(sizeof(Vector3)); - mesh->normal_buffer = read_buffer(sizeof(Vector3)); - mesh->texture_coord_buffer = read_buffer(sizeof(Vector2)); - mesh->tangent_buffer = read_buffer(sizeof(Vector3)); - mesh->bitangent_buffer = read_buffer(sizeof(Vector3)); + mesh->position_buffer = read_buffer(sizeof(prism::float3)); + mesh->normal_buffer = read_buffer(sizeof(prism::float3)); + mesh->texture_coord_buffer = read_buffer(sizeof(prism::float2)); + mesh->tangent_buffer = read_buffer(sizeof(prism::float3)); + mesh->bitangent_buffer = read_buffer(sizeof(prism::float3)); if(mesh_type == MeshType::Skinned) mesh->bone_buffer = read_buffer(sizeof(BoneVertexData)); @@ -98,14 +98,14 @@ std::unique_ptr load_mesh(const prism::path path) { file->read_string(bone); file->read_string(parent); - - Vector3 pos; + + prism::float3 pos; file->read(&pos); Quaternion rot; file->read(&rot); - - Vector3 scl; + + prism::float3 scl; file->read(&scl); if(!boneMapping.count(bone)) { @@ -155,7 +155,7 @@ std::unique_ptr load_mesh(const prism::path path) { file->read_string(p.name); if(version == 6) { - file->read(&p.aabb); + file->read(&p.bounding_box); } int numVerts = 0; diff --git a/engine/core/include/components.hpp b/engine/core/include/components.hpp index 385f870..8da2a60 100755 --- a/engine/core/include/components.hpp +++ b/engine/core/include/components.hpp @@ -19,7 +19,7 @@ struct Collision { Capsule } type = Type::Cube; - Vector3 size; + prism::float3 size; bool is_trigger = false; std::string trigger_id; @@ -41,12 +41,12 @@ struct Rigidbody { bool enable_deactivation = true; bool enable_rotation = true; - void add_force(const Vector3 force) { + void add_force(const prism::float3 force) { stored_force += force; } btRigidBody* body = nullptr; - Vector3 stored_force; + prism::float3 stored_force; }; struct Data { @@ -57,12 +57,12 @@ struct Data { }; struct Transform { - Vector3 position, scale = Vector3(1); + prism::float3 position, scale = prism::float3(1); Quaternion rotation; Matrix4x4 model; - Vector3 get_world_position() const { + prism::float3 get_world_position() const { return { model[3][0], model[3][1], @@ -85,7 +85,7 @@ struct Light { Sun = 2 } type = Type::Point; - Vector3 color = Vector3(1); + prism::float3 color = prism::float3(1); float power = 10.0f; float size = 1.0f; @@ -116,7 +116,7 @@ struct UI { struct EnvironmentProbe { bool is_sized = true; - Vector3 size = Vector3(10); + prism::float3 size = prism::float3(10); float intensity = 1.0; }; diff --git a/engine/core/include/cutscene.hpp b/engine/core/include/cutscene.hpp index 0825004..1cda410 100755 --- a/engine/core/include/cutscene.hpp +++ b/engine/core/include/cutscene.hpp @@ -9,7 +9,7 @@ struct PositionKeyFrame { float time; - Vector3 value; + prism::float3 value; }; inline bool operator==(const PositionKeyFrame& lhs, const PositionKeyFrame& rhs) { @@ -23,7 +23,7 @@ struct RotationKeyFrame { struct ScaleKeyFrame { float time; - Vector3 value; + prism::float3 value; }; struct Bone; diff --git a/engine/core/include/imgui_utility.hpp b/engine/core/include/imgui_utility.hpp index 2a8d20a..c31b92f 100755 --- a/engine/core/include/imgui_utility.hpp +++ b/engine/core/include/imgui_utility.hpp @@ -42,8 +42,8 @@ namespace ImGui { inline bool DragQuat(const char* label, Quaternion* quat) { bool result = false; - - Vector3 euler = quat_to_euler(*quat); + + prism::float3 euler = quat_to_euler(*quat); euler.x = degrees(euler.x); euler.y = degrees(euler.y); diff --git a/engine/core/include/physics.hpp b/engine/core/include/physics.hpp index 74f0052..247c36e 100755 --- a/engine/core/include/physics.hpp +++ b/engine/core/include/physics.hpp @@ -23,10 +23,10 @@ public: struct RayResult { bool hasHit; - Vector3 location; + prism::float3 location; }; - RayResult raycast(Vector3 from, Vector3 to); + RayResult raycast(prism::float3 from, prism::float3 to); private: std::unique_ptr broadphase; diff --git a/engine/core/include/scene.hpp b/engine/core/include/scene.hpp index 55090ba..bc7f820 100755 --- a/engine/core/include/scene.hpp +++ b/engine/core/include/scene.hpp @@ -252,7 +252,7 @@ public: @param target The position to be centered in the camera's view. @note Although this is a look at function, it applies no special attribute to the camera and simply changes it's position and rotation. */ -void camera_look_at(Scene& scene, Object cam, Vector3 pos, Vector3 target); +void camera_look_at(Scene& scene, Object cam, prism::float3 pos, prism::float3 target); Object load_object(Scene& scene, const nlohmann::json obj); nlohmann::json save_object(Object obj); diff --git a/engine/core/src/engine.cpp b/engine/core/src/engine.cpp index 283d70c..0d4709a 100755 --- a/engine/core/src/engine.cpp +++ b/engine/core/src/engine.cpp @@ -510,9 +510,9 @@ void engine::calculate_bone(Mesh& mesh, const Mesh::Part& part, Bone& bone, cons if(parent_bone != nullptr) parent_matrix = parent_bone->local_transform; - Matrix4x4 local = transform::translate(Matrix4x4(), bone.position); + Matrix4x4 local = prism::translate(Matrix4x4(), bone.position); local *= matrix_from_quat(bone.rotation); - local = transform::scale(local, bone.scale); + local = prism::scale(local, bone.scale); bone.local_transform = parent_matrix * local; @@ -531,9 +531,9 @@ void engine::calculate_object(Scene& scene, Object object, const Object parent_o auto& transform = scene.get(object); - Matrix4x4 local = transform::translate(Matrix4x4(), transform.position); + Matrix4x4 local = prism::translate(Matrix4x4(), transform.position); local *= matrix_from_quat(transform.rotation); - local = transform::scale(local, transform.scale); + local = prism::scale(local, transform.scale); transform.model = parent_matrix * local; @@ -589,7 +589,7 @@ void engine::update_animation_channel(Scene& scene, const AnimationChannel& chan } if(keyframeIndex != -1) { - Vector3* targetVec = nullptr; + prism::float3* targetVec = nullptr; if(channel.bone != nullptr) targetVec = &channel.bone->position; diff --git a/engine/core/src/physics.cpp b/engine/core/src/physics.cpp index 6c8581d..a4fe8c7 100755 --- a/engine/core/src/physics.cpp +++ b/engine/core/src/physics.cpp @@ -18,9 +18,9 @@ void Physics::update(float deltaTime) { for(auto [obj, rigidbody] : engine->get_scene()->get_all()) { if(rigidbody.body != nullptr) { if(rigidbody.type == Rigidbody::Type::Dynamic) { - if(rigidbody.stored_force != Vector3(0.0f)) { + if(rigidbody.stored_force != prism::float3(0.0f)) { rigidbody.body->setLinearVelocity(btVector3(rigidbody.stored_force.x, rigidbody.stored_force.y, rigidbody.stored_force.z)); - rigidbody.stored_force = Vector3(0.0f); + rigidbody.stored_force = prism::float3(0.0f); } } } @@ -78,7 +78,7 @@ void Physics::update(float deltaTime) { if(rigidbody.type == Rigidbody::Type::Dynamic) { btTransform trans = rigidbody.body->getWorldTransform(); - transform.position = Vector3(trans.getOrigin().x(), trans.getOrigin().y(), trans.getOrigin().z()); + transform.position = prism::float3(trans.getOrigin().x(), trans.getOrigin().y(), trans.getOrigin().z()); } else { btTransform t; t.setIdentity(); @@ -104,7 +104,7 @@ void Physics::remove_object(Object object) { } } -Physics::RayResult Physics::raycast(Vector3 from, Vector3 to) { +Physics::RayResult Physics::raycast(prism::float3 from, prism::float3 to) { Physics::RayResult result; btVector3 btFrom(from.x, from.y, from.z); @@ -131,7 +131,7 @@ Physics::RayResult Physics::raycast(Vector3 from, Vector3 to) { auto vec = res.m_hitPointWorld[closestCollisionObject];; - result.location = Vector3(vec.x(), vec.y(), vec.z()); + result.location = prism::float3(vec.x(), vec.y(), vec.z()); } return result; diff --git a/engine/core/src/scene.cpp b/engine/core/src/scene.cpp index 748ff56..05c55d3 100755 --- a/engine/core/src/scene.cpp +++ b/engine/core/src/scene.cpp @@ -6,9 +6,9 @@ #include "transform.hpp" #include "asset.hpp" -void camera_look_at(Scene& scene, Object cam, Vector3 pos, Vector3 target) { +void camera_look_at(Scene& scene, Object cam, prism::float3 pos, prism::float3 target) { scene.get(cam).position = pos; - scene.get(cam).rotation = transform::quat_look_at(pos, target, Vector3(0, 1, 0)); + scene.get(cam).rotation = prism::quat_look_at(pos, target, prism::float3(0, 1, 0)); } void load_transform_component(nlohmann::json j, Transform& t) { diff --git a/engine/math/CMakeLists.txt b/engine/math/CMakeLists.txt index 1c71d5c..447d62b 100755 --- a/engine/math/CMakeLists.txt +++ b/engine/math/CMakeLists.txt @@ -5,6 +5,7 @@ set(SRC include/vector.hpp include/quaternion.hpp include/plane.hpp + include/aabb.hpp src/transform.cpp src/math.cpp include/ray.hpp) diff --git a/engine/math/include/aabb.hpp b/engine/math/include/aabb.hpp new file mode 100644 index 0000000..2538380 --- /dev/null +++ b/engine/math/include/aabb.hpp @@ -0,0 +1,25 @@ +#pragma once + +#include + +#include "vector.hpp" + +namespace prism { + /// A 3D axis aligned bounding box. + struct aabb { + float3 min, max; + }; + + /// Creates an array of 8 points, each of these being one extreme of the bounding box.. + inline std::array get_points(const aabb& aabb) { + return { + float3(aabb.min.x, aabb.min.y, aabb.min.z), + float3(aabb.max.x, aabb.min.y, aabb.min.z), + float3(aabb.min.x, aabb.max.y, aabb.min.z), + float3(aabb.max.x, aabb.max.y, aabb.min.z), + float3(aabb.min.x, aabb.min.y, aabb.max.z), + float3(aabb.max.x, aabb.min.y, aabb.max.z), + float3(aabb.min.x, aabb.max.y, aabb.max.z), + float3(aabb.max.x, aabb.max.y, aabb.max.z)}; + } +} \ No newline at end of file diff --git a/engine/math/include/math.hpp b/engine/math/include/math.hpp index 28c5810..6e797c2 100755 --- a/engine/math/include/math.hpp +++ b/engine/math/include/math.hpp @@ -25,7 +25,7 @@ constexpr inline bool nearly_equal(const T a, const T b) { Matrix4x4 matrix_from_quat(Quaternion quat); Quaternion quat_from_matrix(Matrix3x3 matrix); -Quaternion euler_to_quat(Vector3 angle); -Vector3 quat_to_euler(Quaternion quat); +Quaternion euler_to_quat(prism::float3 angle); +prism::float3 quat_to_euler(Quaternion quat); Matrix4x4 inverse(Matrix4x4 m); -Quaternion angle_axis(float angle, Vector3 axis); +Quaternion angle_axis(float angle, prism::float3 axis); diff --git a/engine/math/include/matrix.hpp b/engine/math/include/matrix.hpp index bc9ba3b..a775c84 100755 --- a/engine/math/include/matrix.hpp +++ b/engine/math/include/matrix.hpp @@ -13,7 +13,7 @@ public: unordered_data[i] = ((i / M) == (i % N) ? diagonal : T(0)); } - constexpr Matrix(const Vector4 m1_, const Vector4 m2_, const Vector4 m3_, const Vector4 m4_) { + constexpr Matrix(const prism::float4 m1_, const prism::float4 m2_, const prism::float4 m3_, const prism::float4 m4_) { columns[0] = m1_; columns[1] = m2_; columns[2] = m3_; @@ -22,7 +22,7 @@ public: constexpr inline void operator*=(const Matrix rhs); - using VectorType = Vector; + using VectorType = prism::Vector; constexpr VectorType& operator[](const size_t index) { return columns[index]; } constexpr VectorType operator[](const size_t index) const { return columns[index]; } @@ -49,8 +49,8 @@ constexpr inline Matrix4x4 operator*(const Matrix4x4 lhs, const Matrix4x4 rhs) { return tmp; } -constexpr inline Vector4 operator*(const Matrix4x4 lhs, const Vector4 rhs) { - Vector4 tmp; +constexpr inline prism::float4 operator*(const Matrix4x4 lhs, const prism::float4 rhs) { + prism::float4 tmp; for(int r = 0; r < 4; r++) { for(int c = 0; c < 4; c++) tmp[r] += lhs.data[c][r] * rhs.data[c]; diff --git a/engine/math/include/plane.hpp b/engine/math/include/plane.hpp index d59dade..2c0aa3b 100755 --- a/engine/math/include/plane.hpp +++ b/engine/math/include/plane.hpp @@ -22,7 +22,7 @@ inline Plane normalize(const Plane& plane) { return normalized_plane; } -inline float distance_to_point(const Plane& plane, const Vector3& point) { +inline float distance_to_point(const Plane& plane, const prism::float3& point) { return plane.a * point.x + plane.b * point.y + plane.c * point.z + diff --git a/engine/math/include/quaternion.hpp b/engine/math/include/quaternion.hpp index 96f8274..e314bb3 100755 --- a/engine/math/include/quaternion.hpp +++ b/engine/math/include/quaternion.hpp @@ -21,15 +21,15 @@ constexpr inline Quaternion operator*(const Quaternion lhs, const float rhs) { return tmp; } -constexpr inline Vector3 operator*(const Quaternion& lhs, const Vector3& rhs) { - const Vector3 quatVector = Vector3(lhs.x, lhs.y, lhs.z); - const Vector3 uv = cross(quatVector, rhs); - const Vector3 uuv = cross(quatVector, uv); +constexpr inline prism::float3 operator*(const Quaternion& lhs, const prism::float3& rhs) { + const prism::float3 quatVector = prism::float3(lhs.x, lhs.y, lhs.z); + const prism::float3 uv = cross(quatVector, rhs); + const prism::float3 uuv = cross(quatVector, uv); return rhs + ((uv * lhs.w) + uuv) * 2.0f; } -constexpr inline Vector3 operator*(const Vector3& rhs, const Quaternion& lhs) { +constexpr inline prism::float3 operator*(const prism::float3& rhs, const Quaternion& lhs) { return lhs * rhs; } diff --git a/engine/math/include/ray.hpp b/engine/math/include/ray.hpp index 099d6af..e9ae9e2 100644 --- a/engine/math/include/ray.hpp +++ b/engine/math/include/ray.hpp @@ -1,8 +1,12 @@ #pragma once -struct ray { - Vector3 origin, direction; - float t = 0.0f; -}; +#include "vector.hpp" -float closest_distance_between_lines(ray& l1, ray& l2); \ No newline at end of file +namespace prism { + struct ray { + float3 origin, direction; + float t = 0.0f; + }; + + float closest_distance_between_lines(ray& l1, ray& l2); +} \ No newline at end of file diff --git a/engine/math/include/transform.hpp b/engine/math/include/transform.hpp index 4177c2e..4ffab2c 100755 --- a/engine/math/include/transform.hpp +++ b/engine/math/include/transform.hpp @@ -4,16 +4,16 @@ #include "vector.hpp" #include "quaternion.hpp" -namespace transform { - Matrix4x4 perspective(const float field_of_view, const float aspect, const float z_near, const float z_far); - Matrix4x4 infinite_perspective(const float field_of_view, const float aspect, const float z_near); +namespace prism { + Matrix4x4 perspective(float field_of_view, float aspect, float z_near, float z_far); + Matrix4x4 infinite_perspective(float field_of_view, float aspect, float z_near); Matrix4x4 orthographic(float left, float right, float bottom, float top, float zNear, float zFar); - Matrix4x4 look_at(const Vector3 eye, const Vector3 center, const Vector3 up); - Quaternion quat_look_at(const Vector3 eye, const Vector3 center, const Vector3 up); + Matrix4x4 look_at(float3 eye, float3 center, float3 up); + Quaternion quat_look_at(float3 eye, float3 center, float3 up); - Matrix4x4 translate(const Matrix4x4 matrix, const Vector3 translation); - Matrix4x4 rotate(const Matrix4x4 matrix, const float angle, const Vector3 axis); - Matrix4x4 scale(const Matrix4x4 matrix, const Vector3 scale); + Matrix4x4 translate(Matrix4x4 matrix, float3 translation); + Matrix4x4 rotate(Matrix4x4 matrix, float angle, float3 axis); + Matrix4x4 scale(Matrix4x4 matrix, float3 scale); } diff --git a/engine/math/include/vector.hpp b/engine/math/include/vector.hpp index 31e5b62..7dfadb4 100755 --- a/engine/math/include/vector.hpp +++ b/engine/math/include/vector.hpp @@ -5,254 +5,256 @@ #include #include -#define DEFINE_OPERATORS(Size) \ -constexpr Vector(const T scalar = T(0)) { \ - for(std::size_t i = 0; i < Size; i++) \ - data[i] = scalar; \ -} \ -constexpr T& operator[](const size_t index) { \ - return data[index]; \ -} \ -constexpr T operator[](const size_t index) const { \ - return data[index]; \ -} \ -constexpr Vector& operator+=(const Vector rhs) { \ - for(std::size_t i = 0; i < Size; i++)\ - data[i] += rhs[i]; \ - return *this; \ -} \ -constexpr Vector& operator-=(const Vector rhs) { \ - for(std::size_t i = 0; i < Size; i++)\ - data[i] -= rhs[i]; \ - return *this; \ -} \ -constexpr Vector& operator*=(const Vector rhs) { \ - for(std::size_t i = 0; i < Size; i++) \ - data[i] *= rhs[i]; \ - return *this; \ -} \ -constexpr Vector& operator/=(const T scalar) { \ - for(std::size_t i = 0; i < Size; i++) \ - data[i] /= scalar; \ - return *this; \ -} \ -constexpr T* ptr() const { \ - return data.data(); \ -} \ -constexpr T* ptr() { \ - return data.data(); \ -} \ -constexpr Vector operator- () const { \ - Vector vec; \ - for(std::size_t i = 0; i < Size; i++) \ - vec[i] = -data[i]; \ - return vec; \ +namespace prism { + #define DEFINE_OPERATORS(Size) \ + constexpr Vector(const T scalar = T(0)) { \ + for(std::size_t i = 0; i < (Size); i++) \ + data[i] = scalar; \ + } \ + constexpr T& operator[](const size_t index) { \ + return data[index]; \ + } \ + constexpr T operator[](const size_t index) const { \ + return data[index]; \ + } \ + constexpr Vector& operator+=(const Vector rhs) { \ + for(std::size_t i = 0; i < (Size); i++)\ + data[i] += rhs[i]; \ + return *this; \ + } \ + constexpr Vector& operator-=(const Vector rhs) { \ + for(std::size_t i = 0; i < (Size); i++)\ + data[i] -= rhs[i]; \ + return *this; \ + } \ + constexpr Vector& operator*=(const Vector rhs) { \ + for(std::size_t i = 0; i < (Size); i++) \ + data[i] *= rhs[i]; \ + return *this; \ + } \ + constexpr Vector& operator/=(const T scalar) { \ + for(std::size_t i = 0; i < (Size); i++) \ + data[i] /= scalar; \ + return *this; \ + } \ + constexpr T* ptr() const { \ + return data.data(); \ + } \ + constexpr T* ptr() { \ + return data.data(); \ + } \ + constexpr Vector operator- () const { \ + Vector vec; \ + for(std::size_t i = 0; i < (Size); i++) \ + vec[i] = -data[i]; \ + return vec; \ + } + + template + struct Vector { + std::array data; + }; + + template + struct Vector<2, T> { + constexpr Vector(const T x_, const T y_) { + x = x_; + y = y_; + } + + DEFINE_OPERATORS(2) + + union { + std::array data; + + struct { + T x, y; + }; + }; + }; + + template + struct Vector<3, T> { + constexpr Vector(const T x_, const T y_, const T z_) { + x = x_; + y = y_; + z = z_; + } + + DEFINE_OPERATORS(3) + + union { + std::array data; + + struct { + T x, y, z; + }; + }; + }; + + template + struct alignas(16) Vector<4, T> { + constexpr Vector(const T x_, const T y_, const T z_, const T w_) { + x = x_; + y = y_; + z = z_; + w = w_; + } + + constexpr Vector(const Vector<3, T> &v, const float w = 0.0f) : x(v.x), y(v.y), z(v.z), w(w) {} + + DEFINE_OPERATORS(4) + + union { + std::array data; + + struct { + T x, y, z, w; + }; + + struct { + Vector<3, T> xyz; + T padding_xyz; + }; + }; + }; + + using float2 = Vector<2, float>; + using float3 = Vector<3, float>; + using float4 = Vector<4, float>; + + template + constexpr inline T dot(const Vector lhs, const Vector rhs) { + T product = T(0.0); + + for (std::size_t i = 0; i < N; i++) + product += lhs[i] * rhs[i]; + + return product; + } + + template + constexpr inline T length(const Vector vec) { + return sqrtf(dot(vec, vec)); + } + + template + constexpr inline Vector lerp(const Vector a, const Vector b, const T t) { + Vector vec; + for (std::size_t i = 0; i < N; i++) + vec[i] = (T(1) - t) * a[i] + t * b[i]; + + return vec; + } + + template + constexpr inline Vector normalize(const Vector vec) { + Vector result; + + const float len = length(vec); + for (std::size_t i = 0; i < N; i++) + result[i] = vec[i] / len; + + return result; + } + + constexpr inline float3 cross(const float3 u, const float3 v) { + return float3(u.y * v.z - u.z * v.y, u.z * v.x - u.x * v.z, u.x * v.y - u.y * v.x); + } + + inline float distance(const float3 lhs, const float3 rhs) { + const float diffX = lhs.x - rhs.x; + const float diffY = lhs.y - rhs.y; + const float diffZ = lhs.z - rhs.z; + + return std::sqrt((diffX * diffX) + (diffY * diffY) + (diffZ * diffZ)); + } + + template + constexpr inline T norm(const Vector vec) { + T val = T(0); + for (std::size_t i = 0; i < N; i++) + val += abs(vec[i]); + + return sqrtf(dot(vec, vec)); + } } template -struct Vector { - std::array data; -}; - -template -struct Vector<2, T> { - constexpr Vector(const T x_, const T y_) { - x = x_; - y = y_; - } - - DEFINE_OPERATORS(2) - - union { - std::array data; - - struct { - T x, y; - }; - }; -}; - -template -struct Vector<3, T> { - constexpr Vector(const T x_, const T y_, const T z_) { - x = x_; - y = y_; - z = z_; - } - - DEFINE_OPERATORS(3) - - union { - std::array data; - - struct { - T x, y, z; - }; - }; -}; - -template -struct alignas(16) Vector<4, T> { - constexpr Vector(const T x_, const T y_, const T z_, const T w_) { - x = x_; - y = y_; - z = z_; - w = w_; - } - - constexpr Vector(const Vector<3, T>& v, const float w = 0.0f) : x(v.x), y(v.y), z(v.z), w(w) {} - - DEFINE_OPERATORS(4) - - union { - std::array data; - - struct { - T x, y, z, w; - }; - - struct { - Vector<3, T> xyz; - T padding_xyz; - }; - }; -}; - -using Vector2 = Vector<2, float>; -using Vector3 = Vector<3, float>; -using Vector4 = Vector<4, float>; - -template -constexpr inline bool operator==(const Vector lhs, const Vector rhs) { +constexpr inline bool operator==(const prism::Vector lhs, const prism::Vector rhs) { bool is_equal = true; - for(std::size_t i = 0; i < N; i++) { - if(lhs[i] != rhs[i]) + for (std::size_t i = 0; i < N; i++) { + if (lhs[i] != rhs[i]) is_equal = false; } - + return is_equal; } template -constexpr inline bool operator!=(const Vector lhs, const Vector rhs) { +constexpr inline bool operator!=(const prism::Vector lhs, const prism::Vector rhs) { return !(lhs == rhs); } template -constexpr inline Vector operator-(const Vector lhs, const Vector rhs) { - Vector vec; - for(std::size_t i = 0; i < N; i++) +constexpr inline prism::Vector operator-(const prism::Vector lhs, const prism::Vector rhs) { + prism::Vector vec; + for (std::size_t i = 0; i < N; i++) vec[i] = lhs[i] - rhs[i]; - + return vec; } template -constexpr inline Vector operator+(const Vector lhs, const Vector rhs) { - Vector vec; - for(std::size_t i = 0; i < N; i++) +constexpr inline prism::Vector operator+(const prism::Vector lhs, const prism::Vector rhs) { + prism::Vector vec; + for (std::size_t i = 0; i < N; i++) vec[i] = lhs[i] + rhs[i]; - + return vec; } template -constexpr inline Vector operator*(const Vector lhs, const Vector rhs) { - Vector vec; - for(std::size_t i = 0; i < N; i++) +constexpr inline prism::Vector operator*(const prism::Vector lhs, const prism::Vector rhs) { + prism::Vector vec; + for (std::size_t i = 0; i < N; i++) vec[i] = lhs[i] * rhs[i]; - + return vec; } template -constexpr inline Vector operator+(const Vector lhs, const T scalar) { - Vector vec; - for(std::size_t i = 0; i < N; i++) +constexpr inline prism::Vector operator+(const prism::Vector lhs, const T scalar) { + prism::Vector vec; + for (std::size_t i = 0; i < N; i++) vec[i] = lhs[i] + scalar; - + return vec; } template -constexpr inline Vector operator*(const Vector lhs, const T scalar) { - Vector vec; - for(std::size_t i = 0; i < N; i++) +constexpr inline prism::Vector operator*(const prism::Vector lhs, const T scalar) { + prism::Vector vec; + for (std::size_t i = 0; i < N; i++) vec[i] = lhs[i] * scalar; - + return vec; } template -constexpr inline Vector operator/(const Vector lhs, const Vector rhs) { - Vector vec; - for(std::size_t i = 0; i < N; i++) +constexpr inline prism::Vector operator/(const prism::Vector lhs, const prism::Vector rhs) { + prism::Vector vec; + for (std::size_t i = 0; i < N; i++) vec[i] = lhs[i] / rhs[i]; - + return vec; } template -constexpr inline Vector operator/(const Vector lhs, const T scalar) { - Vector vec; - for(std::size_t i = 0; i < N; i++) +constexpr inline prism::Vector operator/(const prism::Vector lhs, const T scalar) { + prism::Vector vec; + for (std::size_t i = 0; i < N; i++) vec[i] = lhs[i] / scalar; - + return vec; -} - -template -constexpr inline T dot(const Vector lhs, const Vector rhs) { - T product = T(0.0); - - for(std::size_t i = 0; i < N; i++) - product += lhs[i] * rhs[i]; - - return product; -} - -template -constexpr inline T length(const Vector vec) { - return sqrtf(dot(vec, vec)); -} - -template -constexpr inline Vector lerp(const Vector a, const Vector b, const T t) { - Vector vec; - for(std::size_t i = 0; i < N; i++) - vec[i] = (T(1) - t) * a[i] + t * b[i]; - - return vec; -} - -template -constexpr inline Vector normalize(const Vector vec) { - Vector result; - - const float len = length(vec); - for(std::size_t i = 0; i < N; i++) - result[i] = vec[i] / len; - - return result; -} - -constexpr inline Vector3 cross(const Vector3 u, const Vector3 v) { - return Vector3(u.y * v.z - u.z * v.y, u.z * v.x - u.x * v.z, u.x * v.y - u.y * v.x); -} - -inline float distance(const Vector3 lhs, const Vector3 rhs) { - const float diffX = lhs.x - rhs.x; - const float diffY = lhs.y - rhs.y; - const float diffZ = lhs.z - rhs.z; - - return std::sqrt((diffX * diffX) + (diffY * diffY) + (diffZ * diffZ)); -} - -template -constexpr inline T norm(const Vector vec) { - T val = T(0); - for(std::size_t i = 0; i < N; i++) - val += abs(vec[i]); - - return sqrtf(dot(vec, vec)); -} +} \ No newline at end of file diff --git a/engine/math/src/math.cpp b/engine/math/src/math.cpp index 0dfa24e..531609e 100755 --- a/engine/math/src/math.cpp +++ b/engine/math/src/math.cpp @@ -65,7 +65,7 @@ Quaternion quat_from_matrix(const Matrix3x3 m) { } } -Quaternion euler_to_quat(const Vector3 angle) { +Quaternion euler_to_quat(const prism::float3 angle) { const float cy = cosf(angle.z * 0.5f); const float sy = sinf(angle.z * 0.5f); const float cr = cosf(angle.x * 0.5f); @@ -87,7 +87,7 @@ Quaternion euler_to_quat(const Vector3 angle) { return normalize(result); } -Vector3 quat_to_euler(const Quaternion q) { +prism::float3 quat_to_euler(const Quaternion q) { const float roll = atan2(2.0f * (q.x * q.y + q.w * q.z), q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z); const float y = 2.0f * (q.y * q.z + q.w * q.x); @@ -97,7 +97,7 @@ Vector3 quat_to_euler(const Quaternion q) { const float yaw = asinf(-2.0f * (q.x * q.z - q.w * q.y)); - return Vector3(pitch, yaw, roll); + return prism::float3(pitch, yaw, roll); } Matrix4x4 inverse(const Matrix4x4 m) { @@ -125,30 +125,30 @@ Matrix4x4 inverse(const Matrix4x4 m) { const float Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1]; const float Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1]; - const Vector4 Fac0(Coef00, Coef00, Coef02, Coef03); - const Vector4 Fac1(Coef04, Coef04, Coef06, Coef07); - const Vector4 Fac2(Coef08, Coef08, Coef10, Coef11); - const Vector4 Fac3(Coef12, Coef12, Coef14, Coef15); - const Vector4 Fac4(Coef16, Coef16, Coef18, Coef19); - const Vector4 Fac5(Coef20, Coef20, Coef22, Coef23); + const prism::float4 Fac0(Coef00, Coef00, Coef02, Coef03); + const prism::float4 Fac1(Coef04, Coef04, Coef06, Coef07); + const prism::float4 Fac2(Coef08, Coef08, Coef10, Coef11); + const prism::float4 Fac3(Coef12, Coef12, Coef14, Coef15); + const prism::float4 Fac4(Coef16, Coef16, Coef18, Coef19); + const prism::float4 Fac5(Coef20, Coef20, Coef22, Coef23); - const Vector4 Vec0(m[1][0], m[0][0], m[0][0], m[0][0]); - const Vector4 Vec1(m[1][1], m[0][1], m[0][1], m[0][1]); - const Vector4 Vec2(m[1][2], m[0][2], m[0][2], m[0][2]); - const Vector4 Vec3(m[1][3], m[0][3], m[0][3], m[0][3]); + const prism::float4 Vec0(m[1][0], m[0][0], m[0][0], m[0][0]); + const prism::float4 Vec1(m[1][1], m[0][1], m[0][1], m[0][1]); + const prism::float4 Vec2(m[1][2], m[0][2], m[0][2], m[0][2]); + const prism::float4 Vec3(m[1][3], m[0][3], m[0][3], m[0][3]); - const Vector4 Inv0(Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2); - const Vector4 Inv1(Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4); - const Vector4 Inv2(Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5); - const Vector4 Inv3(Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5); + const prism::float4 Inv0(Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2); + const prism::float4 Inv1(Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4); + const prism::float4 Inv2(Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5); + const prism::float4 Inv3(Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5); - const Vector4 SignA(+1, -1, +1, -1); - const Vector4 SignB(-1, +1, -1, +1); + const prism::float4 SignA(+1, -1, +1, -1); + const prism::float4 SignB(-1, +1, -1, +1); const Matrix4x4 Inverse(Inv0 * SignA, Inv1 * SignB, Inv2 * SignA, Inv3 * SignB); - const Vector4 Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]); + const prism::float4 Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]); - const Vector4 Dot0(m[0] * Row0); + const prism::float4 Dot0(m[0] * Row0); const float Dot1 = (Dot0.x + Dot0.y) + (Dot0.z + Dot0.w); const float OneOverDeterminant = 1.0f / Dot1; @@ -156,7 +156,7 @@ Matrix4x4 inverse(const Matrix4x4 m) { return Inverse * OneOverDeterminant; } -Quaternion angle_axis(const float angle, const Vector3 axis) { +Quaternion angle_axis(const float angle, const prism::float3 axis) { const float s = sinf(angle * 0.5f); Quaternion result; @@ -169,8 +169,8 @@ Quaternion angle_axis(const float angle, const Vector3 axis) { } // from https://nelari.us/post/gizmos/ -float closest_distance_between_lines(ray& l1, ray& l2) { - const Vector3 dp = l2.origin - l1.origin; +float prism::closest_distance_between_lines(prism::ray& l1, prism::ray& l2) { + const float3 dp = l2.origin - l1.origin; const float v12 = dot(l1.direction, l1.direction); const float v22 = dot(l2.direction, l2.direction); const float v1v2 = dot(l1.direction, l2.direction); diff --git a/engine/math/src/transform.cpp b/engine/math/src/transform.cpp index 2b939e5..4418ab8 100755 --- a/engine/math/src/transform.cpp +++ b/engine/math/src/transform.cpp @@ -9,7 +9,7 @@ These produce left-handed matrices. Metal/DX12 are both NDC +y down. */ -Matrix4x4 transform::perspective(const float field_of_view, const float aspect, const float z_near, const float z_far) { +Matrix4x4 prism::perspective(const float field_of_view, const float aspect, const float z_near, const float z_far) { const float tan_half_fov = tanf(field_of_view / 2.0f); Matrix4x4 result(0.0f); @@ -22,7 +22,7 @@ Matrix4x4 transform::perspective(const float field_of_view, const float aspect, return result; } -Matrix4x4 transform::infinite_perspective(const float field_of_view, const float aspect, const float z_near) { +Matrix4x4 prism::infinite_perspective(const float field_of_view, const float aspect, const float z_near) { const float range = tanf(field_of_view / 2.0f) * z_near; const float left = -range * aspect; const float right = range * aspect; @@ -39,7 +39,7 @@ Matrix4x4 transform::infinite_perspective(const float field_of_view, const float return result; } -Matrix4x4 transform::orthographic(float left, float right, float bottom, float top, float zNear, float zFar) { +Matrix4x4 prism::orthographic(float left, float right, float bottom, float top, float zNear, float zFar) { Matrix4x4 result(1.0f); result[0][0] = 2.0f / (right - left); result[1][1] = 2.0f / (top - bottom); @@ -51,10 +51,10 @@ Matrix4x4 transform::orthographic(float left, float right, float bottom, float t return result; } -Matrix4x4 transform::look_at(const Vector3 eye, const Vector3 center, const Vector3 up) { - const Vector3 f = normalize(center - eye); - const Vector3 s = normalize(cross(up, f)); - const Vector3 u = cross(f, s); +Matrix4x4 prism::look_at(const float3 eye, const float3 center, const float3 up) { + const float3 f = normalize(center - eye); + const float3 s = normalize(cross(up, f)); + const float3 u = cross(f, s); Matrix4x4 result(1.0f); result[0][0] = s.x; @@ -73,20 +73,20 @@ Matrix4x4 transform::look_at(const Vector3 eye, const Vector3 center, const Vect return result; } -Matrix4x4 transform::translate(const Matrix4x4 matrix, const Vector3 translation) { +Matrix4x4 prism::translate(const Matrix4x4 matrix, const float3 translation) { Matrix4x4 result(1.0f); - result[3] = Vector4(translation, 1.0); + result[3] = float4(translation, 1.0); return matrix * result; } -Matrix4x4 transform::rotate(const Matrix4x4 matrix, const float angle, const Vector3 v) { +Matrix4x4 prism::rotate(const Matrix4x4 matrix, const float angle, const float3 v) { const float a = angle; const float c = cosf(a); const float s = sinf(a); - const Vector3 axis = normalize(v); - const Vector3 temp = Vector3((1.0f - c) * axis); + const float3 axis = normalize(v); + const float3 temp = float3((1.0f - c) * axis); Matrix4x4 Rotate(1.0f); Rotate[0][0] = c + temp[0] * axis[0]; @@ -110,7 +110,7 @@ Matrix4x4 transform::rotate(const Matrix4x4 matrix, const float angle, const Vec return result; } -Matrix4x4 transform::scale(const Matrix4x4 matrix, const Vector3 scale) { +Matrix4x4 prism::scale(const Matrix4x4 matrix, const float3 scale) { Matrix4x4 result(1.0f); result[0][0] = scale.x; result[1][1] = scale.y; @@ -119,8 +119,8 @@ Matrix4x4 transform::scale(const Matrix4x4 matrix, const Vector3 scale) { return matrix * result; } -Quaternion transform::quat_look_at(const Vector3 eye, const Vector3 center, const Vector3 up) { - const Vector3 direction = normalize(center - eye); +Quaternion prism::quat_look_at(const float3 eye, const float3 center, const float3 up) { + const float3 direction = normalize(center - eye); Matrix3x3 result(1.0f); result[2] = direction; diff --git a/engine/renderer/include/frustum.hpp b/engine/renderer/include/frustum.hpp index e11de64..d29af05 100755 --- a/engine/renderer/include/frustum.hpp +++ b/engine/renderer/include/frustum.hpp @@ -16,12 +16,12 @@ struct CameraFrustum { std::array planes; }; -CameraFrustum extract_frustum(const Matrix4x4 combined); +CameraFrustum extract_frustum(Matrix4x4 combined); CameraFrustum camera_extract_frustum(Scene& scene, Object cam); CameraFrustum normalize_frustum(const CameraFrustum& frustum); -bool test_point_plane(const Plane& plane, const Vector3& point); -bool test_point_frustum(const CameraFrustum& frustum, const Vector3& point); -bool test_aabb_frustum(const CameraFrustum& frustum, const AABB& aabb); +bool test_point_plane(const Plane& plane, const prism::float3& point); +bool test_point_frustum(const CameraFrustum& frustum, const prism::float3& point); +bool test_aabb_frustum(const CameraFrustum& frustum, const prism::aabb& aabb); -AABB get_aabb_for_part(const Transform& transform, const Mesh::Part& part); +prism::aabb get_aabb_for_part(const Transform& transform, const Mesh::Part& part); diff --git a/engine/renderer/include/shadowpass.hpp b/engine/renderer/include/shadowpass.hpp index c226024..74cd87a 100755 --- a/engine/renderer/include/shadowpass.hpp +++ b/engine/renderer/include/shadowpass.hpp @@ -24,7 +24,7 @@ public: void render(GFXCommandBuffer* command_buffer, Scene& scene); private: - void render_meshes(GFXCommandBuffer* command_buffer, Scene& scene, const Matrix4x4 light_matrix, const Matrix4x4 model, const Vector3 light_position, const Light::Type type, const CameraFrustum& frustum, const int base_instance); + void render_meshes(GFXCommandBuffer* command_buffer, Scene& scene, const Matrix4x4 light_matrix, const Matrix4x4 model, const prism::float3 light_position, const Light::Type type, const CameraFrustum& frustum, const int base_instance); void render_sun(GFXCommandBuffer* command_buffer, Scene& scene, Object light_object, Light& light); void render_spot(GFXCommandBuffer* command_buffer, Scene& scene, Object light_object, Light& light); @@ -45,7 +45,7 @@ private: GFXFramebuffer* offscreen_framebuffer = nullptr; GFXBuffer* point_location_buffer = nullptr; - Vector3* point_location_map = nullptr; + prism::float3* point_location_map = nullptr; // sun GFXPipeline* static_sun_pipeline = nullptr; diff --git a/engine/renderer/src/dofpass.cpp b/engine/renderer/src/dofpass.cpp index de5a9b4..e865c86 100755 --- a/engine/renderer/src/dofpass.cpp +++ b/engine/renderer/src/dofpass.cpp @@ -40,7 +40,7 @@ DoFPass::DoFPass(GFX* gfx, prism::renderer* renderer) : renderer(renderer) { }; create_info.shader_input.push_constants = { - {sizeof(Vector4), 0} + {sizeof(prism::float4), 0} }; create_info.render_pass = renderpass; @@ -102,10 +102,10 @@ void DoFPass::render(GFXCommandBuffer* command_buffer, Scene&) { command_buffer->bind_texture(aperture_texture->handle, 3); //const auto extent = renderer->get_render_extent(); + + prism::float4 params(render_options.depth_of_field_strength, 0.0, 0.0, 0.0); - Vector4 params(render_options.depth_of_field_strength, 0.0, 0.0, 0.0); - - command_buffer->set_push_constant(¶ms, sizeof(Vector4)); + command_buffer->set_push_constant(¶ms, sizeof(prism::float4)); command_buffer->draw(0, 4, 0, extent.width * extent.height); @@ -122,7 +122,7 @@ void DoFPass::render(GFXCommandBuffer* command_buffer, Scene&) { params.y = 1; - command_buffer->set_push_constant(¶ms, sizeof(Vector4)); + command_buffer->set_push_constant(¶ms, sizeof(prism::float4)); command_buffer->draw(0, 4, 0, extent.width * extent.height); } diff --git a/engine/renderer/src/frustum.cpp b/engine/renderer/src/frustum.cpp index b70f272..62d7341 100644 --- a/engine/renderer/src/frustum.cpp +++ b/engine/renderer/src/frustum.cpp @@ -59,11 +59,11 @@ CameraFrustum normalize_frustum(const CameraFrustum& frustum) { return normalized_frustum; } -bool test_point_plane(const Plane& plane, const Vector3& point) { +bool test_point_plane(const Plane& plane, const prism::float3& point) { return distance_to_point(plane, point) > 0.0; } -bool test_point_frustum(const CameraFrustum& frustum, const Vector3& point) { +bool test_point_frustum(const CameraFrustum& frustum, const prism::float3& point) { bool inside_frustum = false; for(int i = 0; i < 6; i++) @@ -72,7 +72,7 @@ bool test_point_frustum(const CameraFrustum& frustum, const Vector3& point) { return !inside_frustum; } -bool test_aabb_frustum(const CameraFrustum& frustum, const AABB& aabb) { +bool test_aabb_frustum(const CameraFrustum& frustum, const prism::aabb& aabb) { for(int i = 0; i < 6; i++) { int out = 0; @@ -86,10 +86,10 @@ bool test_aabb_frustum(const CameraFrustum& frustum, const AABB& aabb) { return true; } -AABB get_aabb_for_part(const Transform& transform, const Mesh::Part& part) { - AABB aabb = {}; - aabb.min = part.aabb.min - transform.get_world_position(); - aabb.max = transform.get_world_position() + part.aabb.max; +prism::aabb get_aabb_for_part(const Transform& transform, const Mesh::Part& part) { + prism::aabb aabb = {}; + aabb.min = part.bounding_box.min - transform.get_world_position(); + aabb.max = transform.get_world_position() + part.bounding_box.max; aabb.min *= transform.scale; aabb.max *= transform.scale; diff --git a/engine/renderer/src/imguipass.cpp b/engine/renderer/src/imguipass.cpp index 65cf367..0888905 100755 --- a/engine/renderer/src/imguipass.cpp +++ b/engine/renderer/src/imguipass.cpp @@ -103,12 +103,12 @@ void ImGuiPass::render_post(GFXCommandBuffer* command_buffer, RenderTarget& targ command_buffer->set_index_buffer(target.index_buffer[target.current_frame], IndexType::UINT16); } - const Matrix4x4 projection = transform::orthographic(draw_data->DisplayPos.x, + const Matrix4x4 projection = prism::orthographic(draw_data->DisplayPos.x, draw_data->DisplayPos.x + draw_data->DisplaySize.x, draw_data->DisplayPos.y + draw_data->DisplaySize.y, - draw_data->DisplayPos.y, - 0.0f, - 1.0f); + draw_data->DisplayPos.y, + 0.0f, + 1.0f); command_buffer->set_push_constant(&projection, sizeof(Matrix4x4)); diff --git a/engine/renderer/src/materialcompiler.cpp b/engine/renderer/src/materialcompiler.cpp index ee19a87..ac3aa83 100755 --- a/engine/renderer/src/materialcompiler.cpp +++ b/engine/renderer/src/materialcompiler.cpp @@ -49,7 +49,7 @@ GFXPipeline* MaterialCompiler::create_static_pipeline(GFXGraphicsPipelineCreateI if(positions_only) { createInfo.vertex_input.inputs = { - {position_buffer_index, sizeof(Vector3)} + {position_buffer_index, sizeof(prism::float3)} }; createInfo.vertex_input.attributes = { @@ -57,11 +57,11 @@ GFXPipeline* MaterialCompiler::create_static_pipeline(GFXGraphicsPipelineCreateI }; } else { createInfo.vertex_input.inputs = { - {position_buffer_index, sizeof(Vector3)}, - {normal_buffer_index, sizeof(Vector3)}, - {texcoord_buffer_index, sizeof(Vector2)}, - {tangent_buffer_index, sizeof(Vector3)}, - {bitangent_buffer_index, sizeof(Vector3)} + {position_buffer_index, sizeof(prism::float3)}, + {normal_buffer_index, sizeof(prism::float3)}, + {texcoord_buffer_index, sizeof(prism::float2)}, + {tangent_buffer_index, sizeof(prism::float3)}, + {bitangent_buffer_index, sizeof(prism::float3)} }; createInfo.vertex_input.attributes = { @@ -89,7 +89,7 @@ GFXPipeline* MaterialCompiler::create_skinned_pipeline(GFXGraphicsPipelineCreate if(positions_only) { createInfo.vertex_input.inputs = { - {position_buffer_index, sizeof(Vector3)}, + {position_buffer_index, sizeof(prism::float3)}, {bone_buffer_index, sizeof(BoneVertexData)} }; @@ -100,11 +100,11 @@ GFXPipeline* MaterialCompiler::create_skinned_pipeline(GFXGraphicsPipelineCreate }; } else { createInfo.vertex_input.inputs = { - {position_buffer_index, sizeof(Vector3)}, - {normal_buffer_index, sizeof(Vector3)}, - {texcoord_buffer_index, sizeof(Vector2)}, - {tangent_buffer_index, sizeof(Vector3)}, - {bitangent_buffer_index, sizeof(Vector3)}, + {position_buffer_index, sizeof(prism::float3)}, + {normal_buffer_index, sizeof(prism::float3)}, + {texcoord_buffer_index, sizeof(prism::float2)}, + {tangent_buffer_index, sizeof(prism::float3)}, + {bitangent_buffer_index, sizeof(prism::float3)}, {bone_buffer_index, sizeof(BoneVertexData)} }; diff --git a/engine/renderer/src/renderer.cpp b/engine/renderer/src/renderer.cpp index 5318afc..be8dcee 100755 --- a/engine/renderer/src/renderer.cpp +++ b/engine/renderer/src/renderer.cpp @@ -27,7 +27,7 @@ using prism::renderer; struct ElementInstance { - Vector4 color; + prism::float4 color; uint32_t position = 0, size = 0; uint32_t padding[2]; }; @@ -47,23 +47,23 @@ struct StringInstance { }; struct SceneMaterial { - Vector4 color, info; + prism::float4 color, info; }; struct SceneLight { - Vector4 positionType; - Vector4 directionPower; - Vector4 colorSize; - Vector4 shadowsEnable; + prism::float4 positionType; + prism::float4 directionPower; + prism::float4 colorSize; + prism::float4 shadowsEnable; }; struct SceneProbe { - Vector4 position, size; + prism::float4 position, size; }; struct SceneInformation { - Vector4 options; - Vector4 camPos; + prism::float4 options; + prism::float4 camPos; Matrix4x4 vp, lightspace; Matrix4x4 spotLightSpaces[max_spot_shadows]; SceneMaterial materials[max_scene_materials]; @@ -74,17 +74,17 @@ struct SceneInformation { }; struct PostPushConstants { - Vector4 viewport, options, transform_ops; + prism::float4 viewport, options, transform_ops; }; struct UIPushConstant { - Vector2 screenSize; + prism::float2 screenSize; Matrix4x4 mvp; }; struct SkyPushConstant { Matrix4x4 view; - Vector4 sun_position_fov; + prism::float4 sun_position_fov; float aspect; }; @@ -277,14 +277,14 @@ void renderer::render(GFXCommandBuffer* commandbuffer, Scene* scene, RenderTarge for(auto& [obj, camera] : cameras) { const bool requires_limited_perspective = render_options.enable_depth_of_field; if(requires_limited_perspective) { - camera.perspective = transform::perspective(radians(camera.fov), + camera.perspective = prism::perspective(radians(camera.fov), static_cast(render_extent.width) / static_cast(render_extent.height), - camera.near, - 100.0f); + camera.near, + 100.0f); } else { - camera.perspective = transform::infinite_perspective(radians(camera.fov), + camera.perspective = prism::infinite_perspective(radians(camera.fov), static_cast(render_extent.width) / static_cast(render_extent.height), - camera.near); + camera.near); } camera.view = inverse(scene->get(obj).model); @@ -326,25 +326,25 @@ void renderer::render(GFXCommandBuffer* commandbuffer, Scene* scene, RenderTarge commandbuffer->bind_shader_buffer(histogram_buffer, 0, 1, sizeof(uint32_t) * 256); const float lum_range = render_options.max_luminance - render_options.min_luminance; - - Vector4 params = Vector4(render_options.min_luminance, + + prism::float4 params = prism::float4(render_options.min_luminance, 1.0f / lum_range, static_cast(render_extent.width), static_cast(render_extent.height)); - commandbuffer->set_push_constant(¶ms, sizeof(Vector4)); + commandbuffer->set_push_constant(¶ms, sizeof(prism::float4)); commandbuffer->dispatch(static_cast(std::ceil(static_cast(render_extent.width) / 16.0f)), static_cast(std::ceil(static_cast(render_extent.height) / 16.0f)), 1); commandbuffer->set_compute_pipeline(histogram_average_pipeline); - params = Vector4(render_options.min_luminance, + params = prism::float4(render_options.min_luminance, lum_range, std::clamp(1.0f - std::exp(-(1.0f / 60.0f) * 1.1f), 0.0f, 1.0f), static_cast(render_extent.width * render_extent.height)); - commandbuffer->set_push_constant(¶ms, sizeof(Vector4)); + commandbuffer->set_push_constant(¶ms, sizeof(prism::float4)); commandbuffer->bind_texture(average_luminance_texture, 0); @@ -394,7 +394,7 @@ void renderer::render(GFXCommandBuffer* commandbuffer, Scene* scene, RenderTarge pc.transform_ops.y = static_cast(render_options.tonemapping); const auto [width, height] = render_extent; - pc.viewport = Vector4(1.0f / static_cast(width), 1.0f / static_cast(height), static_cast(width), static_cast(height)); + pc.viewport = prism::float4(1.0f / static_cast(width), 1.0f / static_cast(height), static_cast(width), static_cast(height)); commandbuffer->set_push_constant(&pc, sizeof(PostPushConstants)); @@ -421,20 +421,20 @@ void renderer::render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Obj SceneInformation sceneInfo = {}; sceneInfo.lightspace = scene.lightSpace; - sceneInfo.options = Vector4(1, 0, 0, 0); + sceneInfo.options = prism::float4(1, 0, 0, 0); sceneInfo.camPos = scene.get(camera_object).get_world_position(); sceneInfo.camPos.w = 2.0f * camera.near * std::tan(camera.fov * 0.5f) * (static_cast(extent.width) / static_cast(extent.height)); sceneInfo.vp = camera.perspective * camera.view; for(const auto& [obj, light] : scene.get_all()) { SceneLight sl; - sl.positionType = Vector4(scene.get(obj).get_world_position(), static_cast(light.type)); + sl.positionType = prism::float4(scene.get(obj).get_world_position(), static_cast(light.type)); + + prism::float3 front = prism::float3(0.0f, 0.0f, 1.0f) * scene.get(obj).rotation; - Vector3 front = Vector3(0.0f, 0.0f, 1.0f) * scene.get(obj).rotation; - - sl.directionPower = Vector4(-front, light.power); - sl.colorSize = Vector4(utility::from_srgb_to_linear(light.color), radians(light.spot_size)); - sl.shadowsEnable = Vector4(light.enable_shadows, radians(light.size), 0, 0); + sl.directionPower = prism::float4(-front, light.power); + sl.colorSize = prism::float4(utility::from_srgb_to_linear(light.color), radians(light.spot_size)); + sl.shadowsEnable = prism::float4(light.enable_shadows, radians(light.size), 0, 0); sceneInfo.lights[sceneInfo.numLights++] = sl; } @@ -445,8 +445,8 @@ void renderer::render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Obj int last_probe = 0; for(const auto& [obj, probe] : scene.get_all()) { SceneProbe p; - p.position = Vector4(scene.get(obj).position, probe.is_sized ? 1.0f : 2.0f); - p.size = Vector4(probe.size, probe.intensity); + p.position = prism::float4(scene.get(obj).position, probe.is_sized ? 1.0f : 2.0f); + p.size = prism::float4(probe.size, probe.intensity); sceneInfo.probes[last_probe++] = p; } @@ -549,7 +549,7 @@ void renderer::render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Obj for(const auto& [obj, light] : scene.get_all()) { if(light.type == Light::Type::Sun) - pc.sun_position_fov = Vector4(scene.get(obj).get_world_position(), radians(camera.fov)); + pc.sun_position_fov = prism::float4(scene.get(obj).get_world_position(), radians(camera.fov)); } command_buffer->set_graphics_pipeline(sky_pipeline); @@ -644,7 +644,7 @@ void renderer::render_screen(GFXCommandBuffer *commandbuffer, ui::Screen* screen gfx->copy_buffer(screen->instance_buffer, stringInstances.data(), 0, sizeof(StringInstance) * 50); gfx->copy_buffer(screen->elements_buffer, elementInstances.data(), sizeof(ElementInstance) * continuity.elementOffset, sizeof(ElementInstance) * elementInstances.size()); - const Vector2 windowSize = {static_cast(extent.width), static_cast(extent.height)}; + const prism::float2 windowSize = {static_cast(extent.width), static_cast(extent.height)}; for(auto [i, element] : utility::enumerate(screen->elements)) { if(!element.visible) @@ -1017,7 +1017,7 @@ void renderer::create_histogram_resources() { }; create_info.shader_input.push_constants = { - {sizeof(Vector4), 0} + {sizeof(prism::float4), 0} }; histogram_pipeline = gfx->create_compute_pipeline(create_info); diff --git a/engine/renderer/src/scenecapture.cpp b/engine/renderer/src/scenecapture.cpp index d4b4c46..dee99a8 100755 --- a/engine/renderer/src/scenecapture.cpp +++ b/engine/renderer/src/scenecapture.cpp @@ -16,23 +16,23 @@ struct PushConstant { }; struct SceneMaterial { - Vector4 color, info; + prism::float4 color, info; }; struct SceneLight { - Vector4 positionType; - Vector4 directionPower; - Vector4 colorSize; - Vector4 shadowsEnable; + prism::float4 positionType; + prism::float4 directionPower; + prism::float4 colorSize; + prism::float4 shadowsEnable; }; struct SceneProbe { - Vector4 position, size; + prism::float4 position, size; }; struct SceneInformation { - Vector4 options; - Vector4 camPos; + prism::float4 options; + prism::float4 camPos; Matrix4x4 vp, lightspace; Matrix4x4 spotLightSpaces[max_spot_shadows]; SceneMaterial materials[max_scene_materials]; @@ -44,7 +44,7 @@ struct SceneInformation { struct SkyPushConstant { Matrix4x4 view; - Vector4 sun_position_fov; + prism::float4 sun_position_fov; float aspect; }; @@ -57,12 +57,12 @@ struct FilterPushConstant { const int mipLevels = 5; const std::array sceneTransforms = { - transform::look_at(Vector3(0), Vector3(-1.0, 0.0, 0.0), Vector3(0.0, -1.0, 0.0)), // right - transform::look_at(Vector3(0), Vector3(1.0, 0.0, 0.0), Vector3(0.0, -1.0, 0.0)), // left - transform::look_at(Vector3(0), Vector3( 0.0, -1.0, 0.0), Vector3(0.0, 0.0, -1.0)), // top - transform::look_at(Vector3(0), Vector3( 0.0, 1.0, 0.0), Vector3(0.0, 0.0, 1.0)), // bottom - transform::look_at(Vector3(0), Vector3( 0.0, 0.0, 1.0), Vector3(0.0, -1.0, 0.0)), // back - transform::look_at(Vector3(0), Vector3( 0.0, 0.0, -1.0), Vector3(0.0, -1.0, 0.0)) // front + prism::look_at(prism::float3(0), prism::float3(-1.0, 0.0, 0.0), prism::float3(0.0, -1.0, 0.0)), // right + prism::look_at(prism::float3(0), prism::float3(1.0, 0.0, 0.0), prism::float3(0.0, -1.0, 0.0)), // left + prism::look_at(prism::float3(0), prism::float3(0.0, -1.0, 0.0), prism::float3(0.0, 0.0, -1.0)), // top + prism::look_at(prism::float3(0), prism::float3(0.0, 1.0, 0.0), prism::float3(0.0, 0.0, 1.0)), // bottom + prism::look_at(prism::float3(0), prism::float3(0.0, 0.0, 1.0), prism::float3(0.0, -1.0, 0.0)), // back + prism::look_at(prism::float3(0), prism::float3(0.0, 0.0, -1.0), prism::float3(0.0, -1.0, 0.0)) // front }; inline AssetPtr cubeMesh; @@ -166,10 +166,10 @@ void SceneCapture::render(GFXCommandBuffer* command_buffer, Scene* scene) { std::map material_indices; int numMaterialsInBuffer = 0; - const Vector3 lightPos = scene->get(obj).get_world_position(); + const prism::float3 lightPos = scene->get(obj).get_world_position(); - const Matrix4x4 projection = transform::infinite_perspective(radians(90.0f), 1.0f, 0.1f); - const Matrix4x4 model = transform::translate(Matrix4x4(), Vector3(-lightPos.x, -lightPos.y, -lightPos.z)); + const Matrix4x4 projection = prism::infinite_perspective(radians(90.0f), 1.0f, 0.1f); + const Matrix4x4 model = prism::translate(Matrix4x4(), prism::float3(-lightPos.x, -lightPos.y, -lightPos.z)); SceneInformation sceneInfo = {}; sceneInfo.lightspace = scene->lightSpace; @@ -179,13 +179,13 @@ void SceneCapture::render(GFXCommandBuffer* command_buffer, Scene* scene) { for(const auto [obj, light] : scene->get_all()) { SceneLight sl; - sl.positionType = Vector4(scene->get(obj).get_world_position(), (int)light.type); + sl.positionType = prism::float4(scene->get(obj).get_world_position(), (int)light.type); + + prism::float3 front = prism::float3(0.0f, 0.0f, 1.0f) * scene->get(obj).rotation; - Vector3 front = Vector3(0.0f, 0.0f, 1.0f) * scene->get(obj).rotation; - - sl.directionPower = Vector4(-front, light.power); - sl.colorSize = Vector4(utility::from_srgb_to_linear(light.color), radians(light.spot_size)); - sl.shadowsEnable = Vector4(light.enable_shadows, radians(light.size), 0, 0); + sl.directionPower = prism::float4(-front, light.power); + sl.colorSize = prism::float4(utility::from_srgb_to_linear(light.color), radians(light.spot_size)); + sl.shadowsEnable = prism::float4(light.enable_shadows, radians(light.size), 0, 0); sceneInfo.lights[sceneInfo.numLights++] = sl; } @@ -295,7 +295,7 @@ void SceneCapture::render(GFXCommandBuffer* command_buffer, Scene* scene) { for(auto& [obj, light] : scene->get_all()) { if(light.type == Light::Type::Sun) - pc.sun_position_fov = Vector4(scene->get(obj).get_world_position(), radians(90.0f)); + pc.sun_position_fov = prism::float4(scene->get(obj).get_world_position(), radians(90.0f)); } command_buffer->set_graphics_pipeline(skyPipeline); @@ -455,7 +455,7 @@ void SceneCapture::createIrradianceResources() { pipelineInfo.shaders.fragment_src = ShaderSource(prism::path("irradiance.frag")); GFXVertexInput input; - input.stride = sizeof(Vector3); + input.stride = sizeof(prism::float3); pipelineInfo.vertex_input.inputs.push_back(input); @@ -509,7 +509,7 @@ void SceneCapture::createPrefilterResources() { pipelineInfo.shaders.fragment_constants = {size_constant}; GFXVertexInput input; - input.stride = sizeof(Vector3); + input.stride = sizeof(prism::float3); pipelineInfo.vertex_input.inputs.push_back(input); diff --git a/engine/renderer/src/shadowpass.cpp b/engine/renderer/src/shadowpass.cpp index 7909b2e..732d279 100755 --- a/engine/renderer/src/shadowpass.cpp +++ b/engine/renderer/src/shadowpass.cpp @@ -15,12 +15,12 @@ struct PushConstant { }; const std::array shadowTransforms = { - transform::look_at(Vector3(0), Vector3(1.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0)), // right - transform::look_at(Vector3(0), Vector3(-1.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0)), // left - transform::look_at(Vector3(0), Vector3( 0.0, 1.0, 0.0), Vector3(0.0, 0.0, -1.0)), // top - transform::look_at(Vector3(0), Vector3( 0.0, -1.0, 0.0), Vector3(0.0, 0.0, 1.0)), // bottom - transform::look_at(Vector3(0), Vector3( 0.0, 0.0, 1.0), Vector3(0.0, 1.0, 0.0)), // back - transform::look_at(Vector3(0), Vector3( 0.0, 0.0, -1.0), Vector3(0.0, 1.0, 0.0)) // front + prism::look_at(prism::float3(0), prism::float3(1.0, 0.0, 0.0), prism::float3(0.0, 1.0, 0.0)), // right + prism::look_at(prism::float3(0), prism::float3(-1.0, 0.0, 0.0), prism::float3(0.0, 1.0, 0.0)), // left + prism::look_at(prism::float3(0), prism::float3(0.0, 1.0, 0.0), prism::float3(0.0, 0.0, -1.0)), // top + prism::look_at(prism::float3(0), prism::float3(0.0, -1.0, 0.0), prism::float3(0.0, 0.0, 1.0)), // bottom + prism::look_at(prism::float3(0), prism::float3(0.0, 0.0, 1.0), prism::float3(0.0, 1.0, 0.0)), // back + prism::look_at(prism::float3(0), prism::float3(0.0, 0.0, -1.0), prism::float3(0.0, 1.0, 0.0)) // front }; ShadowPass::ShadowPass(GFX* gfx) { @@ -109,7 +109,7 @@ void ShadowPass::render(GFXCommandBuffer* command_buffer, Scene& scene) { } } -void ShadowPass::render_meshes(GFXCommandBuffer* command_buffer, Scene& scene, const Matrix4x4 light_matrix, const Matrix4x4 model, const Vector3 light_position, const Light::Type type, const CameraFrustum& frustum, const int base_instance) { +void ShadowPass::render_meshes(GFXCommandBuffer* command_buffer, Scene& scene, const Matrix4x4 light_matrix, const Matrix4x4 model, const prism::float3 light_position, const Light::Type type, const CameraFrustum& frustum, const int base_instance) { for(auto [obj, mesh] : scene.get_all()) { if(!mesh.mesh) continue; @@ -135,7 +135,7 @@ void ShadowPass::render_meshes(GFXCommandBuffer* command_buffer, Scene& scene, c break; } - command_buffer->bind_shader_buffer(point_location_buffer, 0, 2, sizeof(Vector3) * max_point_shadows); + command_buffer->bind_shader_buffer(point_location_buffer, 0, 2, sizeof(prism::float3) * max_point_shadows); command_buffer->set_push_constant(&pc, sizeof(PushConstant)); command_buffer->set_depth_bias(1.25f, 0.00f, 1.75f); @@ -159,7 +159,7 @@ void ShadowPass::render_meshes(GFXCommandBuffer* command_buffer, Scene& scene, c break; } - command_buffer->bind_shader_buffer(point_location_buffer, 0, 2, sizeof(Vector3) * max_point_shadows); + command_buffer->bind_shader_buffer(point_location_buffer, 0, 2, sizeof(prism::float3) * max_point_shadows); command_buffer->set_push_constant(&pc, sizeof(PushConstant)); @@ -192,10 +192,10 @@ void ShadowPass::render_sun(GFXCommandBuffer* command_buffer, Scene& scene, Obje command_buffer->set_viewport(viewport); - const Vector3 lightPos = scene.get(light_object).position; + const prism::float3 lightPos = scene.get(light_object).position; - const Matrix4x4 projection = transform::orthographic(-25.0f, 25.0f, -25.0f, 25.0f, 0.1f, 100.0f); - const Matrix4x4 view = transform::look_at(lightPos, Vector3(0), Vector3(0, 1, 0)); + const Matrix4x4 projection = prism::orthographic(-25.0f, 25.0f, -25.0f, 25.0f, 0.1f, 100.0f); + const Matrix4x4 view = prism::look_at(lightPos, prism::float3(0), prism::float3(0, 1, 0)); const Matrix4x4 realMVP = projection * view; @@ -230,7 +230,7 @@ void ShadowPass::render_spot(GFXCommandBuffer* command_buffer, Scene& scene, Obj command_buffer->set_viewport(viewport); - const Matrix4x4 perspective = transform::perspective(radians(90.0f), 1.0f, 0.1f, 100.0f); + const Matrix4x4 perspective = prism::perspective(radians(90.0f), 1.0f, 0.1f, 100.0f); const Matrix4x4 realMVP = perspective * inverse(scene.get(light_object).model); @@ -276,9 +276,9 @@ void ShadowPass::render_point(GFXCommandBuffer* command_buffer, Scene& scene, Ob command_buffer->set_viewport(viewport); - const Vector3 lightPos = scene.get(light_object).get_world_position(); + const prism::float3 lightPos = scene.get(light_object).get_world_position(); - const Matrix4x4 projection = transform::perspective(radians(90.0f), 1.0f, 0.1f, 100.0f); + const Matrix4x4 projection = prism::perspective(radians(90.0f), 1.0f, 0.1f, 100.0f); const Matrix4x4 model = inverse(scene.get(light_object).model); const auto frustum = normalize_frustum(extract_frustum(projection * shadowTransforms[face] * model)); @@ -402,6 +402,6 @@ void ShadowPass::create_offscreen_resources() { offscreen_framebuffer = gfx->create_framebuffer(info); - point_location_buffer = gfx->create_buffer(nullptr, sizeof(Vector3) * max_point_shadows, false, GFXBufferUsage::Storage); - point_location_map = reinterpret_cast(gfx->get_buffer_contents(point_location_buffer)); + point_location_buffer = gfx->create_buffer(nullptr, sizeof(prism::float3) * max_point_shadows, false, GFXBufferUsage::Storage); + point_location_map = reinterpret_cast(gfx->get_buffer_contents(point_location_buffer)); } diff --git a/engine/renderer/src/smaapass.cpp b/engine/renderer/src/smaapass.cpp index 5038aca..26488fb 100755 --- a/engine/renderer/src/smaapass.cpp +++ b/engine/renderer/src/smaapass.cpp @@ -51,11 +51,11 @@ void SMAAPass::render(GFXCommandBuffer* command_buffer, RenderTarget& target) { beginInfo.render_pass = render_pass; struct PushConstant { - Vector4 viewport; + prism::float4 viewport; Matrix4x4 correction_matrix; } pc; - pc.viewport = Vector4(1.0f / static_cast(target.extent.width), 1.0f / static_cast(target.extent.height), target.extent.width, target.extent.height); + pc.viewport = prism::float4(1.0f / static_cast(target.extent.width), 1.0f / static_cast(target.extent.height), target.extent.width, target.extent.height); // edge { @@ -143,7 +143,7 @@ void SMAAPass::create_pipelines() { createInfo.render_pass = render_pass; createInfo.shader_input.push_constants = { - {sizeof(Vector4) + sizeof(Matrix4x4), 0} + {sizeof(prism::float4) + sizeof(Matrix4x4), 0} }; createInfo.shader_input.bindings = { diff --git a/engine/utility/CMakeLists.txt b/engine/utility/CMakeLists.txt index 75323b9..64efa70 100755 --- a/engine/utility/CMakeLists.txt +++ b/engine/utility/CMakeLists.txt @@ -4,7 +4,6 @@ set(SRC include/string_utils.hpp include/timer.hpp include/common.hpp - include/aabb.hpp include/file_utils.hpp include/assertions.hpp include/path.hpp diff --git a/engine/utility/include/aabb.hpp b/engine/utility/include/aabb.hpp deleted file mode 100755 index e1c14a7..0000000 --- a/engine/utility/include/aabb.hpp +++ /dev/null @@ -1,23 +0,0 @@ -#pragma once - -#include - -#include "vector.hpp" - -/// A 3D axis aligned bounding box. -struct AABB { - Vector3 min, max; -}; - -/// Creates an array of 8 points, each of these being one extreme of the bounding box.. -inline std::array get_points(const AABB& aabb) { - return { - Vector3(aabb.min.x, aabb.min.y, aabb.min.z), - Vector3(aabb.max.x, aabb.min.y, aabb.min.z), - Vector3(aabb.min.x, aabb.max.y, aabb.min.z), - Vector3(aabb.max.x, aabb.max.y, aabb.min.z), - Vector3(aabb.min.x, aabb.min.y, aabb.max.z), - Vector3(aabb.max.x, aabb.min.y, aabb.max.z), - Vector3(aabb.min.x, aabb.max.y, aabb.max.z), - Vector3(aabb.max.x, aabb.max.y, aabb.max.z)}; -} diff --git a/engine/utility/include/json_conversions.hpp b/engine/utility/include/json_conversions.hpp index 128f3d1..03f9d67 100755 --- a/engine/utility/include/json_conversions.hpp +++ b/engine/utility/include/json_conversions.hpp @@ -5,16 +5,18 @@ #include "vector.hpp" #include "quaternion.hpp" -inline void to_json(nlohmann::json& j, const Vector3& p) { - j["x"] = p.x; - j["y"] = p.y; - j["z"] = p.z; -} +namespace prism { + inline void to_json(nlohmann::json &j, const float3 &p) { + j["x"] = p.x; + j["y"] = p.y; + j["z"] = p.z; + } -inline void from_json(const nlohmann::json& j, Vector3& p) { - p.x = j["x"]; - p.y = j["y"]; - p.z = j["z"]; + inline void from_json(const nlohmann::json &j, float3 &p) { + p.x = j["x"]; + p.y = j["y"]; + p.z = j["z"]; + } } inline void to_json(nlohmann::json& j, const Quaternion& p) { diff --git a/engine/utility/include/utility.hpp b/engine/utility/include/utility.hpp index c3f512e..24df21a 100755 --- a/engine/utility/include/utility.hpp +++ b/engine/utility/include/utility.hpp @@ -99,8 +99,8 @@ namespace utility { return static_cast(32.0f * f + 0.5f); } - inline Vector3 from_srgb_to_linear(const Vector3 sRGB) { - Vector3 linear = sRGB; + inline prism::float3 from_srgb_to_linear(const prism::float3 sRGB) { + prism::float3 linear = sRGB; for(auto& component : linear.data) { if(component > 0.04045f) { component = std::pow((component + 0.055) / (1.055), 2.4f); diff --git a/tools/common/include/commoneditor.hpp b/tools/common/include/commoneditor.hpp index 907c8b8..7b980b7 100755 --- a/tools/common/include/commoneditor.hpp +++ b/tools/common/include/commoneditor.hpp @@ -155,7 +155,7 @@ public: GFXTexture* get_material_preview(Material& material); GFXTexture* get_mesh_preview(Mesh& mesh); GFXTexture* get_texture_preview(Texture& texture); - GFXTexture* generate_common_preview(Scene& scene, const Vector3 camera_position); + GFXTexture* generate_common_preview(Scene& scene, const prism::float3 camera_position); template GFXTexture* get_asset_thumbnail(AssetPtr& asset) { @@ -326,7 +326,7 @@ private: bool transforming_axis = false; SelectableObject::Axis axis; - Vector3 last_object_position; + prism::float3 last_object_position; bool open_asset_popup = false; AssetType current_asset_type; diff --git a/tools/common/include/debugpass.hpp b/tools/common/include/debugpass.hpp index 9a3b53a..43d917f 100755 --- a/tools/common/include/debugpass.hpp +++ b/tools/common/include/debugpass.hpp @@ -52,7 +52,7 @@ public: void render_scene(Scene& scene, GFXCommandBuffer* commandBuffer) override; void get_selected_object(int x, int y, std::function callback); - void draw_arrow(GFXCommandBuffer* commandBuffer, Vector3 color, Matrix4x4 model); + void draw_arrow(GFXCommandBuffer* commandBuffer, prism::float3 color, Matrix4x4 model); GFXTexture* get_requested_texture(PassTextureType type) override { if(type == PassTextureType::SelectionSobel) diff --git a/tools/common/src/commoneditor.cpp b/tools/common/src/commoneditor.cpp index 7558e6f..c59b0a4 100755 --- a/tools/common/src/commoneditor.cpp +++ b/tools/common/src/commoneditor.cpp @@ -100,7 +100,7 @@ static float previous_intersect = 0.0; void CommonEditor::update(float deltaTime) { if(engine->get_scene() != nullptr) { - Vector3 offset; + prism::float3 offset; willCaptureMouse = engine->get_input()->is_repeating("cameraLook") && accepting_viewport_input; @@ -111,10 +111,10 @@ void CommonEditor::update(float deltaTime) { pitch += engine->get_input()->get_value("lookY") * 50.0f * deltaTime; const float speed = 7.00f; - - Vector3 forward, right; - forward = normalize(angle_axis(yaw, Vector3(0, 1, 0)) * angle_axis(pitch, Vector3(1, 0, 0)) * Vector3(0, 0, 1)); - right = normalize(angle_axis(yaw, Vector3(0, 1, 0)) * Vector3(1, 0, 0)); + + prism::float3 forward, right; + forward = normalize(angle_axis(yaw, prism::float3(0, 1, 0)) * angle_axis(pitch, prism::float3(1, 0, 0)) * prism::float3(0, 0, 1)); + right = normalize(angle_axis(yaw, prism::float3(0, 1, 0)) * prism::float3(1, 0, 0)); float movX = engine->get_input()->get_value("movementX"); float movY = engine->get_input()->get_value("movementY"); @@ -124,7 +124,7 @@ void CommonEditor::update(float deltaTime) { engine->get_scene()->get(obj).position += right * movX * speed * deltaTime; engine->get_scene()->get(obj).position += forward * -movY * speed * deltaTime; - engine->get_scene()->get(obj).rotation = angle_axis(yaw, Vector3(0, 1, 0)) * angle_axis(pitch, Vector3(1, 0, 0)); + engine->get_scene()->get(obj).rotation = angle_axis(yaw, prism::float3(0, 1, 0)) * angle_axis(pitch, prism::float3(1, 0, 0)); } doing_viewport_input = willCaptureMouse; @@ -156,8 +156,8 @@ void CommonEditor::update(float deltaTime) { const auto width = viewport_width; const auto height = viewport_height; - - Vector2 n = Vector2(((viewport_x / (float)width) * 2) - 1, + + prism::float2 n = prism::float2(((viewport_x / (float)width) * 2) - 1, ((viewport_y / (float)height) * 2) - 1); // [-1, 1] mouse coordinates n.y = -n.y; @@ -165,37 +165,37 @@ void CommonEditor::update(float deltaTime) { n.y = std::clamp(n.y, -1.0f, 1.0f); const Matrix4x4 view_proj_inverse = inverse(cam.perspective * cam.view); - - Vector4 ray_start = view_proj_inverse * Vector4(n.x, n.y, 0.0f, 1.0f); + + prism::float4 ray_start = view_proj_inverse * prism::float4(n.x, n.y, 0.0f, 1.0f); ray_start *= 1.0f / ray_start.w; - - Vector4 ray_end = view_proj_inverse * Vector4(n.x, n.y, 1.0f, 1.0f); + + prism::float4 ray_end = view_proj_inverse * prism::float4(n.x, n.y, 1.0f, 1.0f); ray_end *= 1.0f / ray_end.w; - ray camera_ray; + prism::ray camera_ray; camera_ray.origin = ray_start.xyz; camera_ray.direction = normalize(ray_end.xyz - ray_start.xyz); camera_ray.t = std::numeric_limits::max(); auto& transform = engine->get_scene()->get(selected_object); - ray transform_ray; + prism::ray transform_ray; transform_ray.origin = last_object_position; transform_ray.t = std::numeric_limits::max(); switch(axis) { case SelectableObject::Axis::X: - transform_ray.direction = Vector3(1, 0, 0); + transform_ray.direction = prism::float3(1, 0, 0); break; case SelectableObject::Axis::Y: - transform_ray.direction = Vector3(0, 1, 0); + transform_ray.direction = prism::float3(0, 1, 0); break; case SelectableObject::Axis::Z: - transform_ray.direction = Vector3(0, 0, 1); + transform_ray.direction = prism::float3(0, 0, 1); break; } - closest_distance_between_lines(camera_ray, transform_ray); + prism::closest_distance_between_lines(camera_ray, transform_ray); const float current_intersect = transform_ray.t; if(previous_intersect == 0.0) @@ -817,9 +817,9 @@ GFXTexture* CommonEditor::get_material_preview(Material& material) { scene.add(sphere).mesh = assetm->get(prism::app_domain / "models" / "sphere.model"); scene.get(sphere).materials.push_back(assetm->get(prism::app_domain / material.path)); // we throw away our material handle here :-( - scene.get(sphere).rotation = euler_to_quat(Vector3(radians(90.0f), 0, 0)); + scene.get(sphere).rotation = euler_to_quat(prism::float3(radians(90.0f), 0, 0)); - return generate_common_preview(scene, Vector3(0, 0, 3)); + return generate_common_preview(scene, prism::float3(0, 0, 3)); } GFXTexture* CommonEditor::get_mesh_preview(Mesh& mesh) { @@ -830,20 +830,20 @@ GFXTexture* CommonEditor::get_mesh_preview(Mesh& mesh) { float biggest_component = 0.0f; for(const auto& part : scene.get(mesh_obj).mesh->parts) { - const auto find_biggest_component = [&biggest_component](const Vector3 vec) { + const auto find_biggest_component = [&biggest_component](const prism::float3 vec) { for(auto& component : vec.data) { if(std::fabs(component) > biggest_component) biggest_component = component; } }; - find_biggest_component(part.aabb.min); - find_biggest_component(part.aabb.max); + find_biggest_component(part.bounding_box.min); + find_biggest_component(part.bounding_box.max); scene.get(mesh_obj).materials.push_back(assetm->get(prism::app_domain / "materials" / "Material.material")); } - return generate_common_preview(scene, Vector3(biggest_component * 2.0f)); + return generate_common_preview(scene, prism::float3(biggest_component * 2.0f)); } GFXTexture* CommonEditor::get_texture_preview(Texture& texture) { @@ -889,11 +889,11 @@ GFXTexture* CommonEditor::get_texture_preview(Texture& texture) { command_buffer->bind_texture(renderer->dummy_texture, 4); struct PostPushConstants { - Vector4 viewport; - Vector4 options; + prism::float4 viewport; + prism::float4 options; } pc; pc.options.w = 1.0; - pc.viewport = Vector4(1.0 / (float)thumbnail_resolution, 1.0 / (float)thumbnail_resolution, thumbnail_resolution, thumbnail_resolution); + pc.viewport = prism::float4(1.0 / (float)thumbnail_resolution, 1.0 / (float)thumbnail_resolution, thumbnail_resolution, thumbnail_resolution); command_buffer->set_push_constant(&pc, sizeof(PostPushConstants)); @@ -904,7 +904,7 @@ GFXTexture* CommonEditor::get_texture_preview(Texture& texture) { return final_texture; } -GFXTexture* CommonEditor::generate_common_preview(Scene& scene, const Vector3 camera_position) { +GFXTexture* CommonEditor::generate_common_preview(Scene& scene, const prism::float3 camera_position) { auto gfx = engine->get_gfx(); // setup scene @@ -914,19 +914,19 @@ GFXTexture* CommonEditor::generate_common_preview(Scene& scene, const Vector3 ca auto camera = scene.add_object(); scene.add(camera); - camera_look_at(scene, camera, camera_position, Vector3(0)); + camera_look_at(scene, camera, camera_position, prism::float3(0)); auto light = scene.add_object(); - scene.get(light).position = Vector3(5); + scene.get(light).position = prism::float3(5); scene.add(light).type = Light::Type::Sun; auto probe = scene.add_object(); scene.add(probe).is_sized = false; - scene.get(probe).position = Vector3(3); + scene.get(probe).position = prism::float3(3); engine->update_scene(scene); - scene.get(camera).perspective = transform::infinite_perspective(radians(45.0f), 1.0f, 0.1f); + scene.get(camera).perspective = prism::infinite_perspective(radians(45.0f), 1.0f, 0.1f); scene.get(camera).view = inverse(scene.get(camera).model); auto renderer = engine->get_renderer(); @@ -1010,12 +1010,12 @@ GFXTexture* CommonEditor::generate_common_preview(Scene& scene, const Vector3 ca command_buffer->bind_texture(renderer->dummy_texture, 4); struct PostPushConstants { - Vector4 viewport; - Vector4 options; + prism::float4 viewport; + prism::float4 options; } pc; pc.options.w = 1.0; - pc.viewport = Vector4(1.0 / (float)thumbnail_resolution, 1.0 / (float)thumbnail_resolution, thumbnail_resolution, thumbnail_resolution); - + pc.viewport = prism::float4(1.0 / (float)thumbnail_resolution, 1.0 / (float)thumbnail_resolution, thumbnail_resolution, thumbnail_resolution); + command_buffer->set_push_constant(&pc, sizeof(PostPushConstants)); command_buffer->draw(0, 4, 0, 1); diff --git a/tools/common/src/debugpass.cpp b/tools/common/src/debugpass.cpp index a995070..f82cbc2 100755 --- a/tools/common/src/debugpass.cpp +++ b/tools/common/src/debugpass.cpp @@ -13,7 +13,7 @@ struct BillPushConstant { Matrix4x4 mvp; - Vector4 color; + prism::float4 color; }; void DebugPass::initialize() { @@ -25,7 +25,7 @@ void DebugPass::initialize() { createInfo.shaders.fragment_src = ShaderSource(prism::path("debug.frag")); GFXVertexInput vertexInput = {}; - vertexInput.stride = sizeof(Vector3); + vertexInput.stride = sizeof(prism::float3); createInfo.vertex_input.inputs.push_back(vertexInput); @@ -35,7 +35,7 @@ void DebugPass::initialize() { createInfo.vertex_input.attributes.push_back(positionAttribute); createInfo.shader_input.push_constants = { - {sizeof(Matrix4x4) + sizeof(Vector4), 0} + {sizeof(Matrix4x4) + sizeof(prism::float4), 0} }; createInfo.shader_input.bindings = { @@ -73,7 +73,7 @@ void DebugPass::initialize() { pipelineInfo.shaders.fragment_src = ShaderSource(prism::path("color.frag")); GFXVertexInput input; - input.stride = sizeof(Vector3); + input.stride = sizeof(prism::float3); pipelineInfo.vertex_input.inputs.push_back(input); @@ -87,7 +87,7 @@ void DebugPass::initialize() { }; pipelineInfo.shader_input.push_constants = { - {sizeof(Matrix4x4) + sizeof(Vector4), 0} + {sizeof(Matrix4x4) + sizeof(prism::float4), 0} }; pipelineInfo.render_pass = selectRenderPass; @@ -114,7 +114,7 @@ void DebugPass::initialize() { pipelineInfo.shaders.fragment_src = ShaderSource(prism::path("color.frag")); GFXVertexInput input; - input.stride = sizeof(Vector3); + input.stride = sizeof(prism::float3); pipelineInfo.vertex_input.inputs.push_back(input); @@ -128,7 +128,7 @@ void DebugPass::initialize() { }; pipelineInfo.shader_input.push_constants = { - {sizeof(Matrix4x4) + sizeof(Vector4), 0} + {sizeof(Matrix4x4) + sizeof(prism::float4), 0} }; pipelineInfo.render_pass = sobelRenderPass; @@ -223,10 +223,10 @@ void DebugPass::createOffscreenResources() { } } -void DebugPass::draw_arrow(GFXCommandBuffer* commandBuffer, Vector3 color, Matrix4x4 model) { +void DebugPass::draw_arrow(GFXCommandBuffer* commandBuffer, prism::float3 color, Matrix4x4 model) { struct PushConstant { Matrix4x4 mvp; - Vector4 color; + prism::float4 color; } pc; pc.mvp = model; pc.color = color; @@ -244,7 +244,7 @@ void DebugPass::render_scene(Scene& scene, GFXCommandBuffer* commandBuffer) { struct PushConstant { Matrix4x4 mvp; - Vector4 color; + prism::float4 color; }; Matrix4x4 vp = camera.perspective * camera.view; @@ -252,17 +252,17 @@ void DebugPass::render_scene(Scene& scene, GFXCommandBuffer* commandBuffer) { commandBuffer->set_graphics_pipeline(primitive_pipeline); struct DebugPrimitive { - Vector3 position, size; + prism::float3 position, size; Quaternion rotation; - Vector4 color; + prism::float4 color; }; std::vector primitives; struct DebugBillboard { - Vector3 position; + prism::float3 position; GFXTexture* texture; - Vector4 color; + prism::float4 color; }; std::vector billboards; @@ -281,7 +281,7 @@ void DebugPass::render_scene(Scene& scene, GFXCommandBuffer* commandBuffer) { prim.position = transform.get_world_position(); prim.rotation = transform.rotation; prim.size = collision.size / 2.0f; - prim.color = collision.is_trigger ? Vector4(0, 0, 1, 1) : Vector4(0, 1, 0, 1); + prim.color = collision.is_trigger ? prism::float4(0, 0, 1, 1) : prism::float4(0, 1, 0, 1); primitives.push_back(prim); } @@ -290,7 +290,7 @@ void DebugPass::render_scene(Scene& scene, GFXCommandBuffer* commandBuffer) { if(scene.has(obj)) { DebugBillboard bill; bill.position = transform.get_world_position(); - bill.color = Vector4(scene.get(obj).color, 1.0f); + bill.color = prism::float4(scene.get(obj).color, 1.0f); switch(scene.get(obj).type) { case Light::Type::Point: @@ -315,14 +315,14 @@ void DebugPass::render_scene(Scene& scene, GFXCommandBuffer* commandBuffer) { prim.position = transform.get_world_position(); prim.rotation = transform.rotation; prim.size = probe.size / 2.0f; - prim.color = Vector4(0, 1, 1, 1); + prim.color = prism::float4(0, 1, 1, 1); primitives.push_back(prim); } DebugBillboard bill; bill.position = transform.get_world_position(); - bill.color = Vector4(1.0f); + bill.color = prism::float4(1.0f); bill.texture = probeTexture->handle; billboards.push_back(bill); @@ -333,9 +333,9 @@ void DebugPass::render_scene(Scene& scene, GFXCommandBuffer* commandBuffer) { for(auto& prim : primitives) { PushConstant pc; - Matrix4x4 m = transform::translate(Matrix4x4(), prim.position); + Matrix4x4 m = prism::translate(Matrix4x4(), prim.position); m *= matrix_from_quat(prim.rotation); - m = transform::scale(m, prim.size); + m = prism::scale(m, prim.size); pc.mvp = vp * m; pc.color = prim.color; @@ -354,7 +354,7 @@ void DebugPass::render_scene(Scene& scene, GFXCommandBuffer* commandBuffer) { // draw primitives for(auto& bill : billboards) { - Matrix4x4 m = transform::translate(Matrix4x4(), bill.position); + Matrix4x4 m = prism::translate(Matrix4x4(), bill.position); BillPushConstant pc; pc.mvp = vp * m; @@ -376,17 +376,17 @@ void DebugPass::render_scene(Scene& scene, GFXCommandBuffer* commandBuffer) { const float base_scale = 0.05f; const float scale_factor = length(position - scene.get(camObj).get_world_position()); - Matrix4x4 base_model = transform::translate(Matrix4x4(), position); - base_model = transform::scale(base_model, base_scale * scale_factor); + Matrix4x4 base_model = prism::translate(Matrix4x4(), position); + base_model = prism::scale(base_model, base_scale * scale_factor); // draw y axis - draw_arrow(commandBuffer, Vector3(0, 1, 0), vp * base_model); + draw_arrow(commandBuffer, prism::float3(0, 1, 0), vp * base_model); // draw x axis - draw_arrow(commandBuffer, Vector3(1, 0, 0), vp * base_model * matrix_from_quat(angle_axis(radians(-90.0f), Vector3(0, 0, 1)))); + draw_arrow(commandBuffer, prism::float3(1, 0, 0), vp * base_model * matrix_from_quat(angle_axis(radians(-90.0f), prism::float3(0, 0, 1)))); // draw z axis - draw_arrow(commandBuffer, Vector3(0, 0, 1), vp * base_model * matrix_from_quat(angle_axis(radians(90.0f), Vector3(1, 0, 0)))); + draw_arrow(commandBuffer, prism::float3(0, 0, 1), vp * base_model * matrix_from_quat(angle_axis(radians(90.0f), prism::float3(1, 0, 0)))); } // draw sobel @@ -407,11 +407,11 @@ void DebugPass::render_scene(Scene& scene, GFXCommandBuffer* commandBuffer) { struct PC { Matrix4x4 mvp; - Vector4 color; + prism::float4 color; } pc; pc.mvp = vp * engine->get_scene()->get(selected_object).model; - pc.color = Vector4(1); + pc.color = prism::float4(1); commandBuffer->set_push_constant(&pc, sizeof(PC)); @@ -482,14 +482,14 @@ void DebugPass::get_selected_object(int x, int y, std::functionget_scene()->get(camObj).position); - const Matrix4x4 translate_model = transform::translate(Matrix4x4(), position); - const Matrix4x4 scale_model = transform::scale(Matrix4x4(), base_scale * scale_factor); + const Matrix4x4 translate_model = prism::translate(Matrix4x4(), position); + const Matrix4x4 scale_model = prism::scale(Matrix4x4(), base_scale * scale_factor); add_arrow(SelectableObject::Axis::Y, translate_model * scale_model); - add_arrow(SelectableObject::Axis::X, translate_model * matrix_from_quat(angle_axis(radians(-90.0f), Vector3(0, 0, 1))) * scale_model); + add_arrow(SelectableObject::Axis::X, translate_model * matrix_from_quat(angle_axis(radians(-90.0f), prism::float3(0, 0, 1))) * scale_model); - add_arrow(SelectableObject::Axis::Z, translate_model * matrix_from_quat(angle_axis(radians(90.0f), Vector3(1, 0, 0))) * scale_model); + add_arrow(SelectableObject::Axis::Z, translate_model * matrix_from_quat(angle_axis(radians(90.0f), prism::float3(1, 0, 0))) * scale_model); } GFXCommandBuffer* commandBuffer = engine->get_gfx()->acquire_command_buffer(); @@ -536,13 +536,13 @@ void DebugPass::get_selected_object(int x, int y, std::function> 0) / 255.0f, diff --git a/tools/editor/src/prismeditor.cpp b/tools/editor/src/prismeditor.cpp index 3631dde..d646dcd 100755 --- a/tools/editor/src/prismeditor.cpp +++ b/tools/editor/src/prismeditor.cpp @@ -50,7 +50,7 @@ void prepScene() { scene->add(camera); - camera_look_at(*scene, camera, Vector3(0, 2, 3), Vector3(0)); + camera_look_at(*scene, camera, prism::float3(0, 2, 3), prism::float3(0)); } void prepThreePointLighting() { @@ -63,7 +63,7 @@ void prepThreePointLighting() { scene->get(sun_light).name = "sun light"; scene->get(sun_light).editor_object = true; - scene->get(sun_light).position = Vector3(15); + scene->get(sun_light).position = prism::float3(15); scene->add(sun_light).type = Light::Type::Sun; scene->get(sun_light).power = 5.0f; @@ -78,8 +78,8 @@ void prepPrefabScene() { scene->get(plane).name = "plane"; scene->get(plane).editor_object = true; - scene->get(plane).position = Vector3(0, -1, 0); - scene->get(plane).scale = Vector3(50); + scene->get(plane).position = prism::float3(0, -1, 0); + scene->get(plane).scale = prism::float3(50); scene->add(plane).mesh = assetm->get(prism::app_domain / "models/plane.model"); @@ -93,8 +93,8 @@ Renderable* prepMaterialScene() { scene->get(plane).name = "plane"; scene->get(plane).editor_object = true; - scene->get(plane).position = Vector3(0, -1, 0); - scene->get(plane).scale = Vector3(50); + scene->get(plane).position = prism::float3(0, -1, 0); + scene->get(plane).scale = prism::float3(50); scene->add(plane).mesh = assetm->get(prism::app_domain / "models/plane.model"); scene->get(plane).materials.push_back(assetm->get(prism::app_domain / "materials/Material.material")); @@ -103,7 +103,7 @@ Renderable* prepMaterialScene() { scene->get(sphere).name = "sphere"; scene->get(sphere).editor_object = true; - scene->get(sphere).rotation = euler_to_quat(Vector3(radians(90.0f), 0, 0)); + scene->get(sphere).rotation = euler_to_quat(prism::float3(radians(90.0f), 0, 0)); scene->add(sphere).mesh = assetm->get(prism::app_domain / "models/sphere.model");