UI menu now accepts mouse input from absolutes.
This commit is contained in:
2
lib/SDL
2
lib/SDL
Submodule lib/SDL updated: c9aec268fa...87a83787a3
Submodule lib/openal-soft updated: fde74453a6...d66107e9f0
@ -1,165 +1,203 @@
|
||||
// Copyright (c) 2023 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
|
||||
#include "Ray3D.hpp"
|
||||
|
||||
using namespace Dawn;
|
||||
|
||||
bool_t Dawn::raytestSphere(
|
||||
struct Ray3D ray,
|
||||
struct PhysicsSphere sphere,
|
||||
glm::vec3 *hit,
|
||||
glm::vec3 *normal
|
||||
) {
|
||||
assertNotNull(hit);
|
||||
assertNotNull(normal);
|
||||
|
||||
glm::vec3 h, n;
|
||||
auto result = glm::intersectRaySphere(
|
||||
ray.origin, ray.direction,
|
||||
sphere.center, sphere.radius,
|
||||
h, n
|
||||
);
|
||||
|
||||
*hit = h;
|
||||
*normal = n;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
bool_t Dawn::raytestTriangle(
|
||||
struct Ray3D ray,
|
||||
struct PhysicsTriangle triangle,
|
||||
glm::vec3 *hitPoint,
|
||||
glm::vec3 *hitNormal,
|
||||
float_t *hitDistance
|
||||
) {
|
||||
assertNotNull(hitPoint);
|
||||
assertNotNull(hitNormal);
|
||||
assertNotNull(hitDistance);
|
||||
|
||||
// Calculate the normal of the triangle
|
||||
glm::vec3 e0 = triangle.v1 - triangle.v0;
|
||||
glm::vec3 e1 = triangle.v2 - triangle.v0;
|
||||
glm::vec3 normal = glm::normalize(glm::cross(e0, e1));
|
||||
|
||||
// Calculate the denominator of the ray-triangle intersection formula
|
||||
float_t denominator = glm::dot(normal, ray.direction);
|
||||
|
||||
// If the denominator is zero, the ray and triangle are parallel and there is no intersection
|
||||
if(denominator == 0) return -1;
|
||||
|
||||
// Calculate the distance from the ray origin to the plane of the triangle
|
||||
float_t d = glm::dot(triangle.v0 - ray.origin, normal) / denominator;
|
||||
|
||||
// If the distance is negative, the intersection point is behind the ray origin and there is no intersection
|
||||
if(d < 0) return -1;
|
||||
|
||||
// Calculate the intersection point
|
||||
glm::vec3 intersectionPoint = ray.origin + d * ray.direction;
|
||||
|
||||
// Check if the intersection point is inside the triangle
|
||||
glm::vec3 edge0 = triangle.v1 - triangle.v0;
|
||||
glm::vec3 edge1 = triangle.v2 - triangle.v1;
|
||||
glm::vec3 edge2 = triangle.v0 - triangle.v2;
|
||||
glm::vec3 c0 = intersectionPoint - triangle.v0;
|
||||
glm::vec3 c1 = intersectionPoint - triangle.v1;
|
||||
glm::vec3 c2 = intersectionPoint - triangle.v2;
|
||||
glm::vec3 n0 = glm::cross(edge0, c0);
|
||||
glm::vec3 n1 = glm::cross(edge1, c1);
|
||||
glm::vec3 n2 = glm::cross(edge2, c2);
|
||||
if(glm::dot(n0, normal) >= 0 && glm::dot(n1, normal) >= 0 && glm::dot(n2, normal) >= 0) {
|
||||
// If the intersection point is inside the triangle, set the hit point, normal and distance
|
||||
*hitPoint = intersectionPoint;
|
||||
*hitNormal = normal;
|
||||
*hitDistance = d;
|
||||
return true;
|
||||
}
|
||||
|
||||
// If the intersection point is outside the triangle, there is no intersection
|
||||
return false;
|
||||
}
|
||||
|
||||
bool_t Dawn::raytestAABB(
|
||||
struct Ray3D ray,
|
||||
struct AABB3D box,
|
||||
glm::vec3 *point,
|
||||
glm::vec3 *normal,
|
||||
float_t *distance
|
||||
) {
|
||||
assertNotNull(point);
|
||||
assertNotNull(normal);
|
||||
assertNotNull(distance);
|
||||
|
||||
// Compute the inverse direction of the ray, for numerical stability
|
||||
glm::vec3 invDir(1.0f / ray.direction.x, 1.0f / ray.direction.y, 1.0f / ray.direction.z);
|
||||
|
||||
// Compute the t-values for the two intersection candidates
|
||||
glm::vec3 tMin = (box.min - ray.origin) * invDir;
|
||||
glm::vec3 tMax = (box.max - ray.origin) * invDir;
|
||||
|
||||
// Make sure tMin is less than or equal to tMax for all components
|
||||
glm::vec3 t1 = glm::min(tMin, tMax);
|
||||
glm::vec3 t2 = glm::max(tMin, tMax);
|
||||
float tNear = glm::compMax(t1);
|
||||
float tFar = glm::compMin(t2);
|
||||
|
||||
// If tNear is greater than or equal to tFar, there is no intersection
|
||||
if(tNear >= tFar) return false;
|
||||
|
||||
// If tFar is negative, the ray is pointing away from the box
|
||||
if(tFar < 0.0f) return false;
|
||||
|
||||
// Compute the hit point and normal
|
||||
glm::vec3 hitPoint = ray.origin + tNear * ray.direction;
|
||||
|
||||
*point = hitPoint;
|
||||
*distance = tNear;
|
||||
|
||||
// Small value to account for floating point imprecision
|
||||
const float epsilon = 0.001f;
|
||||
if(std::abs(hitPoint.x - box.min.x) < epsilon) {
|
||||
*normal = glm::vec3(-1, 0, 0);
|
||||
} else if(std::abs(hitPoint.x - box.max.x) < epsilon) {
|
||||
*normal = glm::vec3(1, 0, 0);
|
||||
} else if(std::abs(hitPoint.y - box.min.y) < epsilon) {
|
||||
*normal = glm::vec3(0, -1, 0);
|
||||
} else if(std::abs(hitPoint.y - box.max.y) < epsilon) {
|
||||
*normal = glm::vec3(0, 1, 0);
|
||||
} else if(std::abs(hitPoint.z - box.min.z) < epsilon) {
|
||||
*normal = glm::vec3(0, 0, -1);
|
||||
} else if(std::abs(hitPoint.z - box.max.z) < epsilon) {
|
||||
*normal = glm::vec3(0, 0, 1);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool_t Dawn::raytestCube(
|
||||
struct Ray3D ray,
|
||||
struct AABB3D box,
|
||||
glm::mat4 transform,
|
||||
glm::vec3 *point,
|
||||
glm::vec3 *normal,
|
||||
float_t *distance
|
||||
) {
|
||||
// Compute the inverse transformation matrix
|
||||
glm::mat4 inverseTransform = glm::inverse(transform);
|
||||
|
||||
// Transform the ray into model space
|
||||
struct Ray3D localRay;
|
||||
localRay.origin = glm::vec3(inverseTransform * glm::vec4(ray.origin, 1.0f));
|
||||
localRay.direction = glm::normalize(glm::vec3(inverseTransform * glm::vec4(ray.direction, 0.0f)));
|
||||
|
||||
// Call raytestAABB with the transformed ray and cube
|
||||
bool_t hit = raytestAABB(localRay, box, point, normal, distance);
|
||||
if(!hit) return false;
|
||||
|
||||
// Transform the hit point and normal back into world space
|
||||
*point = glm::vec3(transform * glm::vec4(*point, 1.0f));
|
||||
*normal = glm::normalize(glm::vec3(glm::transpose(inverseTransform) * glm::vec4(*normal, 0.0f)));
|
||||
|
||||
return true;
|
||||
// Copyright (c) 2023 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
|
||||
#include "Ray3D.hpp"
|
||||
|
||||
using namespace Dawn;
|
||||
|
||||
bool_t Dawn::raytestSphere(
|
||||
struct Ray3D ray,
|
||||
struct PhysicsSphere sphere,
|
||||
glm::vec3 *hit,
|
||||
glm::vec3 *normal
|
||||
) {
|
||||
assertNotNull(hit);
|
||||
assertNotNull(normal);
|
||||
|
||||
glm::vec3 h, n;
|
||||
auto result = glm::intersectRaySphere(
|
||||
ray.origin, ray.direction,
|
||||
sphere.center, sphere.radius,
|
||||
h, n
|
||||
);
|
||||
|
||||
*hit = h;
|
||||
*normal = n;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
bool_t Dawn::raytestTriangle(
|
||||
struct Ray3D ray,
|
||||
struct PhysicsTriangle triangle,
|
||||
glm::vec3 *hitPoint,
|
||||
glm::vec3 *hitNormal,
|
||||
float_t *hitDistance
|
||||
) {
|
||||
assertNotNull(hitPoint);
|
||||
assertNotNull(hitNormal);
|
||||
assertNotNull(hitDistance);
|
||||
|
||||
// Calculate the normal of the triangle
|
||||
glm::vec3 e0 = triangle.v1 - triangle.v0;
|
||||
glm::vec3 e1 = triangle.v2 - triangle.v0;
|
||||
glm::vec3 normal = glm::normalize(glm::cross(e0, e1));
|
||||
|
||||
// Calculate the denominator of the ray-triangle intersection formula
|
||||
float_t denominator = glm::dot(normal, ray.direction);
|
||||
|
||||
// If the denominator is zero, the ray and triangle are parallel and there is no intersection
|
||||
if(denominator == 0) return -1;
|
||||
|
||||
// Calculate the distance from the ray origin to the plane of the triangle
|
||||
float_t d = glm::dot(triangle.v0 - ray.origin, normal) / denominator;
|
||||
|
||||
// If the distance is negative, the intersection point is behind the ray origin and there is no intersection
|
||||
if(d < 0) return -1;
|
||||
|
||||
// Calculate the intersection point
|
||||
glm::vec3 intersectionPoint = ray.origin + d * ray.direction;
|
||||
|
||||
// Check if the intersection point is inside the triangle
|
||||
glm::vec3 edge0 = triangle.v1 - triangle.v0;
|
||||
glm::vec3 edge1 = triangle.v2 - triangle.v1;
|
||||
glm::vec3 edge2 = triangle.v0 - triangle.v2;
|
||||
glm::vec3 c0 = intersectionPoint - triangle.v0;
|
||||
glm::vec3 c1 = intersectionPoint - triangle.v1;
|
||||
glm::vec3 c2 = intersectionPoint - triangle.v2;
|
||||
glm::vec3 n0 = glm::cross(edge0, c0);
|
||||
glm::vec3 n1 = glm::cross(edge1, c1);
|
||||
glm::vec3 n2 = glm::cross(edge2, c2);
|
||||
if(glm::dot(n0, normal) >= 0 && glm::dot(n1, normal) >= 0 && glm::dot(n2, normal) >= 0) {
|
||||
// If the intersection point is inside the triangle, set the hit point, normal and distance
|
||||
*hitPoint = intersectionPoint;
|
||||
*hitNormal = normal;
|
||||
*hitDistance = d;
|
||||
return true;
|
||||
}
|
||||
|
||||
// If the intersection point is outside the triangle, there is no intersection
|
||||
return false;
|
||||
}
|
||||
|
||||
bool_t Dawn::raytestAABB(
|
||||
struct Ray3D ray,
|
||||
struct AABB3D box,
|
||||
glm::vec3 *point,
|
||||
glm::vec3 *normal,
|
||||
float_t *distance
|
||||
) {
|
||||
assertNotNull(point);
|
||||
assertNotNull(normal);
|
||||
assertNotNull(distance);
|
||||
|
||||
// Compute the inverse direction of the ray, for numerical stability
|
||||
glm::vec3 invDir(1.0f / ray.direction.x, 1.0f / ray.direction.y, 1.0f / ray.direction.z);
|
||||
|
||||
// Compute the t-values for the two intersection candidates
|
||||
glm::vec3 tMin = (box.min - ray.origin) * invDir;
|
||||
glm::vec3 tMax = (box.max - ray.origin) * invDir;
|
||||
|
||||
// Make sure tMin is less than or equal to tMax for all components
|
||||
glm::vec3 t1 = glm::min(tMin, tMax);
|
||||
glm::vec3 t2 = glm::max(tMin, tMax);
|
||||
float tNear = glm::compMax(t1);
|
||||
float tFar = glm::compMin(t2);
|
||||
|
||||
// If tNear is greater than or equal to tFar, there is no intersection
|
||||
if(tNear >= tFar) return false;
|
||||
|
||||
// If tFar is negative, the ray is pointing away from the box
|
||||
if(tFar < 0.0f) return false;
|
||||
|
||||
// Compute the hit point and normal
|
||||
glm::vec3 hitPoint = ray.origin + tNear * ray.direction;
|
||||
|
||||
*point = hitPoint;
|
||||
*distance = tNear;
|
||||
|
||||
// Small value to account for floating point imprecision
|
||||
const float epsilon = 0.001f;
|
||||
if(std::abs(hitPoint.x - box.min.x) < epsilon) {
|
||||
*normal = glm::vec3(-1, 0, 0);
|
||||
} else if(std::abs(hitPoint.x - box.max.x) < epsilon) {
|
||||
*normal = glm::vec3(1, 0, 0);
|
||||
} else if(std::abs(hitPoint.y - box.min.y) < epsilon) {
|
||||
*normal = glm::vec3(0, -1, 0);
|
||||
} else if(std::abs(hitPoint.y - box.max.y) < epsilon) {
|
||||
*normal = glm::vec3(0, 1, 0);
|
||||
} else if(std::abs(hitPoint.z - box.min.z) < epsilon) {
|
||||
*normal = glm::vec3(0, 0, -1);
|
||||
} else if(std::abs(hitPoint.z - box.max.z) < epsilon) {
|
||||
*normal = glm::vec3(0, 0, 1);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool_t Dawn::raytestCube(
|
||||
struct Ray3D ray,
|
||||
struct AABB3D box,
|
||||
glm::mat4 transform,
|
||||
glm::vec3 *point,
|
||||
glm::vec3 *normal,
|
||||
float_t *distance
|
||||
) {
|
||||
// Compute the inverse transformation matrix
|
||||
glm::mat4 inverseTransform = glm::inverse(transform);
|
||||
|
||||
// Transform the ray into model space
|
||||
struct Ray3D localRay;
|
||||
localRay.origin = glm::vec3(inverseTransform * glm::vec4(ray.origin, 1.0f));
|
||||
localRay.direction = glm::normalize(glm::vec3(inverseTransform * glm::vec4(ray.direction, 0.0f)));
|
||||
|
||||
// Call raytestAABB with the transformed ray and cube
|
||||
bool_t hit = raytestAABB(localRay, box, point, normal, distance);
|
||||
if(!hit) return false;
|
||||
|
||||
// Transform the hit point and normal back into world space
|
||||
*point = glm::vec3(transform * glm::vec4(*point, 1.0f));
|
||||
*normal = glm::normalize(glm::vec3(glm::transpose(inverseTransform) * glm::vec4(*normal, 0.0f)));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool_t Dawn::raytestQuad(
|
||||
struct Ray3D ray,
|
||||
glm::vec2 min,
|
||||
glm::vec2 max,
|
||||
glm::mat4 transform,
|
||||
glm::vec3 *point,
|
||||
glm::vec3 *normal,
|
||||
float_t *distance
|
||||
) {
|
||||
assertNotNull(point);
|
||||
assertNotNull(normal);
|
||||
assertNotNull(distance);
|
||||
|
||||
// transform ray into local space of the quad
|
||||
glm::mat4 inverseTransform = glm::inverse(transform);
|
||||
glm::vec3 localRayOrigin = glm::vec3(inverseTransform * glm::vec4(ray.origin, 1.0f));
|
||||
glm::vec3 localRayDirection = glm::vec3(inverseTransform * glm::vec4(ray.direction, 0.0f));
|
||||
|
||||
// perform ray-quad intersection test
|
||||
float_t t = -localRayOrigin.z / localRayDirection.z; // intersection distance along ray
|
||||
if (t < 0) return false; // intersection is behind the ray origin
|
||||
glm::vec2 intersectionPoint = glm::vec2(localRayOrigin) + t * glm::vec2(localRayDirection);
|
||||
if (
|
||||
glm::any(glm::lessThan(intersectionPoint, min)) ||
|
||||
glm::any(glm::greaterThan(intersectionPoint, max))
|
||||
) {
|
||||
return false; // intersection is outside the quad
|
||||
}
|
||||
*distance = t;
|
||||
|
||||
// compute point and normal of intersection in world space
|
||||
glm::vec3 localIntersectionPoint = glm::vec3(intersectionPoint, 0.0f);
|
||||
*point = glm::vec3(transform * glm::vec4(localIntersectionPoint, 1.0f));
|
||||
*normal = glm::normalize(glm::vec3(transform * glm::vec4(0.0f, 0.0f, 1.0f, 0.0f)));
|
||||
|
||||
return true; // intersection found
|
||||
}
|
||||
@ -1,50 +1,60 @@
|
||||
// Copyright (c) 2023 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
|
||||
#pragma once
|
||||
#include "dawnlibs.hpp"
|
||||
#include "assert/assert.hpp"
|
||||
#include "PhysicsTriangle.hpp"
|
||||
#include "PhysicsSphere.hpp"
|
||||
#include "AABB3D.hpp"
|
||||
|
||||
namespace Dawn {
|
||||
struct Ray3D {
|
||||
glm::vec3 origin;
|
||||
glm::vec3 direction;
|
||||
};
|
||||
|
||||
bool_t raytestSphere(
|
||||
struct Ray3D ray,
|
||||
struct PhysicsSphere sphere,
|
||||
glm::vec3 *hit,
|
||||
glm::vec3 *normal
|
||||
);
|
||||
|
||||
bool_t raytestTriangle(
|
||||
struct Ray3D ray,
|
||||
struct PhysicsTriangle triangle,
|
||||
glm::vec3 *hitPoint,
|
||||
glm::vec3 *hitNormal,
|
||||
float_t *hitDistance
|
||||
);
|
||||
|
||||
bool_t raytestAABB(
|
||||
struct Ray3D ray,
|
||||
struct AABB3D box,
|
||||
glm::vec3 *point,
|
||||
glm::vec3 *normal,
|
||||
float_t *distance
|
||||
);
|
||||
|
||||
bool_t raytestCube(
|
||||
struct Ray3D ray,
|
||||
struct AABB3D box,
|
||||
glm::mat4 transform,
|
||||
glm::vec3 *point,
|
||||
glm::vec3 *normal,
|
||||
float_t *distance
|
||||
);
|
||||
}
|
||||
// Copyright (c) 2023 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
|
||||
#pragma once
|
||||
#include "dawnlibs.hpp"
|
||||
#include "assert/assert.hpp"
|
||||
#include "PhysicsTriangle.hpp"
|
||||
#include "PhysicsSphere.hpp"
|
||||
#include "AABB3D.hpp"
|
||||
|
||||
namespace Dawn {
|
||||
struct Ray3D {
|
||||
glm::vec3 origin;
|
||||
glm::vec3 direction;
|
||||
};
|
||||
|
||||
bool_t raytestSphere(
|
||||
struct Ray3D ray,
|
||||
struct PhysicsSphere sphere,
|
||||
glm::vec3 *hit,
|
||||
glm::vec3 *normal
|
||||
);
|
||||
|
||||
bool_t raytestTriangle(
|
||||
struct Ray3D ray,
|
||||
struct PhysicsTriangle triangle,
|
||||
glm::vec3 *hitPoint,
|
||||
glm::vec3 *hitNormal,
|
||||
float_t *hitDistance
|
||||
);
|
||||
|
||||
bool_t raytestAABB(
|
||||
struct Ray3D ray,
|
||||
struct AABB3D box,
|
||||
glm::vec3 *point,
|
||||
glm::vec3 *normal,
|
||||
float_t *distance
|
||||
);
|
||||
|
||||
bool_t raytestCube(
|
||||
struct Ray3D ray,
|
||||
struct AABB3D box,
|
||||
glm::mat4 transform,
|
||||
glm::vec3 *point,
|
||||
glm::vec3 *normal,
|
||||
float_t *distance
|
||||
);
|
||||
|
||||
bool_t raytestQuad(
|
||||
struct Ray3D ray,
|
||||
glm::vec2 min,
|
||||
glm::vec2 max,
|
||||
glm::mat4 transform,
|
||||
glm::vec3 *point,
|
||||
glm::vec3 *normal,
|
||||
float_t *distance
|
||||
);
|
||||
}
|
||||
|
||||
@ -1,34 +1,34 @@
|
||||
// Copyright (c) 2023 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
|
||||
#pragma once
|
||||
#include "dawnlibs.hpp"
|
||||
#include "physics/3d/Ray3D.hpp"
|
||||
|
||||
typedef int64_t scenechunk_t;
|
||||
|
||||
#define SCENE_CHUNK_SIZE_2D 512
|
||||
|
||||
namespace Dawn {
|
||||
class Scene;
|
||||
class Collider3D;
|
||||
struct Collider3DRayResult;
|
||||
|
||||
class ScenePhysicsManager {
|
||||
protected:
|
||||
Scene *scene;
|
||||
// std::map<scenechunk_t, std::vector<SceneItem*>> chunkItems;
|
||||
// std::map<SceneItem*, std::vector<scenechunk_t>> itemChunks;
|
||||
|
||||
public:
|
||||
ScenePhysicsManager(Scene *scene);
|
||||
|
||||
void update();
|
||||
|
||||
std::vector<struct Collider3DRayResult> raycast3DAll(struct Ray3D ray);
|
||||
|
||||
friend class Scene;
|
||||
};
|
||||
// Copyright (c) 2023 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
|
||||
#pragma once
|
||||
#include "dawnlibs.hpp"
|
||||
#include "physics/3d/Ray3D.hpp"
|
||||
|
||||
typedef int64_t scenechunk_t;
|
||||
|
||||
#define SCENE_CHUNK_SIZE_2D 512
|
||||
|
||||
namespace Dawn {
|
||||
class Scene;
|
||||
class Collider3D;
|
||||
struct Collider3DRayResult;
|
||||
|
||||
class ScenePhysicsManager {
|
||||
protected:
|
||||
Scene *scene;
|
||||
// std::map<scenechunk_t, std::vector<SceneItem*>> chunkItems;
|
||||
// std::map<SceneItem*, std::vector<scenechunk_t>> itemChunks;
|
||||
|
||||
public:
|
||||
ScenePhysicsManager(Scene *scene);
|
||||
|
||||
void update();
|
||||
|
||||
std::vector<struct Collider3DRayResult> raycast3DAll(struct Ray3D ray);
|
||||
|
||||
friend class Scene;
|
||||
};
|
||||
}
|
||||
@ -9,7 +9,6 @@ target_sources(${DAWN_TARGET_NAME}
|
||||
UICanvas.cpp
|
||||
UIComponent.cpp
|
||||
UILabel.cpp
|
||||
UIMenuController.cpp
|
||||
)
|
||||
|
||||
tool_scenecomponent(UICanvas scene/components/ui/UICanvas.hpp)
|
||||
add_subdirectory(menu)
|
||||
@ -64,7 +64,7 @@ namespace Dawn {
|
||||
|
||||
//======================================================================//
|
||||
StateProperty<Camera*> camera;
|
||||
enum UIDrawType drawType = UI_DRAW_TYPE_WORLD_CAMERA_RELATIVE;
|
||||
enum UIDrawType drawType = UI_DRAW_TYPE_WORLD_ABSOLUTE;
|
||||
|
||||
/**
|
||||
* Constructs the UI Canvas Scene Item Component.
|
||||
|
||||
@ -1,30 +0,0 @@
|
||||
// Copyright (c) 2023 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
|
||||
#pragma once
|
||||
#include "UIMenuController.hpp"
|
||||
|
||||
using namespace Dawn;
|
||||
|
||||
UIMenuController::UIMenuController(SceneItem *item) :
|
||||
SceneItemComponent(item),
|
||||
active(false),
|
||||
menuX(0),
|
||||
menuY(0),
|
||||
columns(4),
|
||||
rows(4)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void UIMenuController::onStart() {
|
||||
useEffectWithTeardown([&]{
|
||||
if(!active) return activeTeardown = [&]{ };
|
||||
|
||||
return activeTeardown = [&]{
|
||||
|
||||
};
|
||||
}, active)();
|
||||
}
|
||||
12
src/dawn/scene/components/ui/menu/CMakeLists.txt
Normal file
12
src/dawn/scene/components/ui/menu/CMakeLists.txt
Normal file
@ -0,0 +1,12 @@
|
||||
# Copyright (c) 2022 Dominic Masters
|
||||
#
|
||||
# This software is released under the MIT License.
|
||||
# https://opensource.org/licenses/MIT
|
||||
|
||||
# Sources
|
||||
target_sources(${DAWN_TARGET_NAME}
|
||||
PRIVATE
|
||||
UIMenuController.cpp
|
||||
UISimpleMenu.cpp
|
||||
UISimpleMenuItem.cpp
|
||||
)
|
||||
67
src/dawn/scene/components/ui/menu/UIMenuController.cpp
Normal file
67
src/dawn/scene/components/ui/menu/UIMenuController.cpp
Normal file
@ -0,0 +1,67 @@
|
||||
// Copyright (c) 2023 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
|
||||
#include "UIMenuController.hpp"
|
||||
#include "game/DawnGame.hpp"
|
||||
|
||||
using namespace Dawn;
|
||||
|
||||
UIMenuController::UIMenuController(SceneItem *item) :
|
||||
SceneItemComponent(item),
|
||||
active(true),
|
||||
menuX(0),
|
||||
menuY(0),
|
||||
columns(4),
|
||||
rows(4)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void UIMenuController::onStart() {
|
||||
useEffectWithTeardown([&]{
|
||||
if(!active) return activeTeardown = [&]{ };
|
||||
|
||||
useEffect([&]{
|
||||
eventItemChange.invoke(menuX, menuY);
|
||||
}, menuX);
|
||||
|
||||
useEffect([&]{
|
||||
eventItemChange.invoke(menuX, menuY);
|
||||
}, menuY);
|
||||
|
||||
useEffect([&]{
|
||||
menuX = mathClamp<int32_t>(menuX, 0, rows);
|
||||
}, columns);
|
||||
|
||||
useEffect([&]{
|
||||
menuY = mathClamp<int32_t>(menuY, 0, rows);
|
||||
}, rows);
|
||||
|
||||
return activeTeardown = useEvent([&](inputbind_t bind) {
|
||||
switch(bind) {
|
||||
case INPUT_BIND_POSITIVE_X:
|
||||
menuX = mathClamp<int32_t>(menuX+1, 0, columns);
|
||||
break;
|
||||
case INPUT_BIND_POSITIVE_Y:
|
||||
menuY = mathClamp<int32_t>(menuY+1, 0, rows);
|
||||
break;
|
||||
case INPUT_BIND_NEGATIVE_X:
|
||||
menuX = mathClamp<int32_t>(menuX-1, 0, columns);
|
||||
break;
|
||||
case INPUT_BIND_NEGATIVE_Y:
|
||||
menuY = mathClamp<int32_t>(menuY-1, 0, rows);
|
||||
break;
|
||||
case INPUT_BIND_ACCEPT:
|
||||
eventItemSelected.invoke(menuX, menuY);
|
||||
break;
|
||||
case INPUT_BIND_CANCEL:
|
||||
eventMenuCancel.invoke();
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
}, this->getGame()->inputManager.eventBindPressed);
|
||||
}, active)();
|
||||
}
|
||||
@ -20,6 +20,9 @@ namespace Dawn {
|
||||
|
||||
StateEvent<int32_t, int32_t> eventItemChange;
|
||||
StateEvent<int32_t, int32_t> eventItemSelected;
|
||||
StateEvent<> eventMenuCancel;
|
||||
|
||||
void moveRelative(int32_t x, int32_t y);
|
||||
|
||||
UIMenuController(SceneItem *item);
|
||||
|
||||
110
src/dawn/scene/components/ui/menu/UISimpleMenu.cpp
Normal file
110
src/dawn/scene/components/ui/menu/UISimpleMenu.cpp
Normal file
@ -0,0 +1,110 @@
|
||||
// Copyright (c) 2023 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
|
||||
#include "UISimpleMenu.hpp"
|
||||
#include "game/DawnGame.hpp"
|
||||
|
||||
using namespace Dawn;
|
||||
|
||||
UISimpleMenu::UISimpleMenu(SceneItem *item) :
|
||||
SceneItemComponent(item)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
std::vector<SceneItemComponent*> UISimpleMenu::getDependencies() {
|
||||
return {
|
||||
(this->menu = this->item->getComponent<UIMenuController>()),
|
||||
(this->canvas == nullptr ? (this->canvas = this->item->getComponent<UICanvas>()) : nullptr)
|
||||
};
|
||||
}
|
||||
|
||||
void UISimpleMenu::onStart() {
|
||||
if(canvas == nullptr) canvas = getScene()->findComponent<UICanvas>();
|
||||
|
||||
assertNotNull(this->menu);
|
||||
assertNotNull(this->canvas);
|
||||
menuItems = this->item->findChildren<UISimpleMenuItem>();
|
||||
|
||||
auto updateSimpleMenuPos = [&](int32_t x, int32_t y) {
|
||||
if(currentlySelected != nullptr) {
|
||||
currentlySelected->eventHoveredOff.invoke();
|
||||
currentlySelected = nullptr;
|
||||
}
|
||||
|
||||
// Find item
|
||||
auto itItem = menuItems.begin();
|
||||
while(itItem != menuItems.end()) {
|
||||
auto itm = *itItem;
|
||||
if(itm->menuX == x && itm->menuY == y) {
|
||||
currentlySelected = itm;
|
||||
break;
|
||||
}
|
||||
++itItem;
|
||||
}
|
||||
|
||||
// Was anything found?
|
||||
if(currentlySelected == nullptr) return;
|
||||
currentlySelected->eventHoveredOn.invoke();
|
||||
};
|
||||
|
||||
useEvent(updateSimpleMenuPos, menu->eventItemChange);
|
||||
updateSimpleMenuPos(menu->menuX, menu->menuY);
|
||||
|
||||
useEvent([&](int32_t x, int32_t y){
|
||||
if(currentlySelected == nullptr) return;
|
||||
currentlySelected->eventSelected.invoke();
|
||||
}, menu->eventItemSelected);
|
||||
|
||||
useEvent([&](float_t d){
|
||||
assertNotNull(canvas->camera);
|
||||
if(!this->menu->active) return;
|
||||
|
||||
auto mouse = getGame()->inputManager.getAxis2D(INPUT_BIND_MOUSE_X, INPUT_BIND_MOUSE_Y);
|
||||
mouse *= 2.0f;
|
||||
mouse -= glm::vec2(1, 1);
|
||||
|
||||
struct Ray3D ray;
|
||||
ray.origin = canvas->camera->transform->getWorldPosition();
|
||||
ray.direction = canvas->camera->getRayDirectionFromScreenSpace(mouse);
|
||||
|
||||
switch(canvas->drawType) {
|
||||
case UI_DRAW_TYPE_WORLD_CAMERA_RELATIVE:
|
||||
break;
|
||||
|
||||
case UI_DRAW_TYPE_WORLD_ABSOLUTE:
|
||||
auto itItems = menuItems.begin();
|
||||
while(itItems != menuItems.end()) {
|
||||
auto item = *itItems;
|
||||
++itItems;
|
||||
auto highlight = item->getComponentForHighlighting();
|
||||
if(highlight == nullptr) continue;
|
||||
|
||||
glm::vec2 size(
|
||||
highlight->getContentWidth(),
|
||||
highlight->getContentHeight()
|
||||
);
|
||||
glm::vec3 point;
|
||||
glm::vec3 normal;
|
||||
float_t distance;
|
||||
|
||||
// TODO: Include Z axis.
|
||||
if(!raytestQuad(
|
||||
ray,
|
||||
glm::vec2(0, 0), size,
|
||||
highlight->transform->getWorldTransform(),
|
||||
&point,
|
||||
&normal,
|
||||
&distance
|
||||
)) continue;
|
||||
|
||||
this->menu->menuX = item->menuX;
|
||||
this->menu->menuY = item->menuY;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}, getScene()->eventSceneUnpausedUpdate);
|
||||
}
|
||||
24
src/dawn/scene/components/ui/menu/UISimpleMenu.hpp
Normal file
24
src/dawn/scene/components/ui/menu/UISimpleMenu.hpp
Normal file
@ -0,0 +1,24 @@
|
||||
// Copyright (c) 2023 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
|
||||
#pragma once
|
||||
#include "UIMenuController.hpp"
|
||||
#include "UISimpleMenuItem.hpp"
|
||||
|
||||
namespace Dawn {
|
||||
class UISimpleMenu : public SceneItemComponent {
|
||||
protected:
|
||||
UIMenuController *menu = nullptr;
|
||||
UICanvas *canvas = nullptr;
|
||||
UISimpleMenuItem *currentlySelected = nullptr;
|
||||
std::vector<UISimpleMenuItem*> menuItems;
|
||||
|
||||
public:
|
||||
UISimpleMenu(SceneItem *item);
|
||||
|
||||
std::vector<SceneItemComponent*> getDependencies() override;
|
||||
void onStart() override;
|
||||
};
|
||||
}
|
||||
17
src/dawn/scene/components/ui/menu/UISimpleMenuItem.cpp
Normal file
17
src/dawn/scene/components/ui/menu/UISimpleMenuItem.cpp
Normal file
@ -0,0 +1,17 @@
|
||||
// Copyright (c) 2023 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
|
||||
#include "UISimpleMenuItem.hpp"
|
||||
|
||||
using namespace Dawn;
|
||||
|
||||
UISimpleMenuItem::UISimpleMenuItem(SceneItem *item) : SceneItemComponent(item) {
|
||||
|
||||
}
|
||||
|
||||
UIComponent * UISimpleMenuItem::getComponentForHighlighting() {
|
||||
if(uiComponent == nullptr) uiComponent = item->getComponent<UIComponent>();
|
||||
return uiComponent;
|
||||
}
|
||||
25
src/dawn/scene/components/ui/menu/UISimpleMenuItem.hpp
Normal file
25
src/dawn/scene/components/ui/menu/UISimpleMenuItem.hpp
Normal file
@ -0,0 +1,25 @@
|
||||
// Copyright (c) 2023 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
|
||||
#pragma once
|
||||
#include "scene/components/ui/UIComponent.hpp"
|
||||
|
||||
namespace Dawn {
|
||||
class UISimpleMenuItem : public SceneItemComponent {
|
||||
public:
|
||||
StateEvent<> eventHoveredOn;
|
||||
StateEvent<> eventHoveredOff;
|
||||
StateEvent<> eventSelected;
|
||||
|
||||
// May make these into either state events or make a new event.
|
||||
int32_t menuX;
|
||||
int32_t menuY;
|
||||
|
||||
UIComponent *uiComponent = nullptr;
|
||||
|
||||
UISimpleMenuItem(SceneItem *item);
|
||||
virtual UIComponent * getComponentForHighlighting();
|
||||
};
|
||||
}
|
||||
@ -1,243 +1,245 @@
|
||||
// Copyright (c) 2023 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
|
||||
#pragma once
|
||||
#include "StateEvent.hpp"
|
||||
#include "StateProperty.hpp"
|
||||
|
||||
namespace Dawn {
|
||||
template<typename ...A>
|
||||
class StateOwnerEventLegacy : public IStateOwnerEventLegacy {
|
||||
public:
|
||||
IStateOwner *owner;
|
||||
Event<A...> *event;
|
||||
std::function<void(A...)> fn;
|
||||
|
||||
/**
|
||||
* Function used to simply remove the event listener from the legacy
|
||||
* event, does not deal with the state owner.
|
||||
*/
|
||||
void removeListener() override {
|
||||
event->removeListener(this, &StateOwnerEventLegacy::callback);
|
||||
}
|
||||
|
||||
/**
|
||||
* Function that can be used to tear down this legacy event.
|
||||
*/
|
||||
void teardown() override {
|
||||
this->removeListener();
|
||||
owner->_stateLegacyEventDisposed(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Callbaack method that is invoked by the legacy event.
|
||||
* @param args Arguments received by legacy event.
|
||||
*/
|
||||
void callback(A... args) {
|
||||
this->fn(args...);
|
||||
}
|
||||
};
|
||||
|
||||
class StateOwner : public IStateOwner {
|
||||
private:
|
||||
std::vector<IStateEvent*> eventsSubscribed;
|
||||
std::vector<IStateOwnerEventLegacy*> eventLegacyBridge;
|
||||
|
||||
public:
|
||||
/**
|
||||
* Called by the state event when it is disposing (before the StateOwner
|
||||
* itself is).
|
||||
*
|
||||
* @param evt Event that is being disposed.
|
||||
*/
|
||||
void _stateEventDisposed(IStateEvent *evt) override {
|
||||
auto it = eventsSubscribed.begin();
|
||||
while(it != eventsSubscribed.end()) {
|
||||
if(*it == evt) {
|
||||
it = eventsSubscribed.erase(it);
|
||||
} else {
|
||||
++it;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Called by legacy events when they are being disposed in a way that was
|
||||
* not called by this state owner disposing.
|
||||
*
|
||||
* @param evt Event that is being disposed.
|
||||
*/
|
||||
void _stateLegacyEventDisposed(IStateOwnerEventLegacy *evt) override {
|
||||
auto it = this->eventLegacyBridge.begin();
|
||||
while(it != this->eventLegacyBridge.end()) {
|
||||
if(*it == evt) {
|
||||
this->eventLegacyBridge.erase(it);
|
||||
break;
|
||||
} else {
|
||||
++it;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Listen for changes to a state property and invoke the provided func
|
||||
* when the value is changed.
|
||||
*
|
||||
* @param fn The callback to be invoked when the state value changes.
|
||||
* @param property Property to listen for affect changees to.
|
||||
* @return Returns callback that invokes the provided FN immediately.
|
||||
*/
|
||||
std::function<void()> useEffect(
|
||||
const std::function<void()> &fn,
|
||||
IStateProperty &property
|
||||
) {
|
||||
if(property.owner == nullptr) {
|
||||
property.owner = this;
|
||||
} else {
|
||||
// TODO: This actually isn't needed, but because I need to teardown
|
||||
// all the listeners on StateProperty<> that belong to this StateOwner
|
||||
// I need to keep track of what events I've subbed to, consuming more
|
||||
// memory, and I don't know if I actually need to do this or not.
|
||||
assertTrue(property.owner == this);
|
||||
}
|
||||
property._effectListners.push_back(fn);
|
||||
return fn;
|
||||
}
|
||||
|
||||
/**
|
||||
* Listen for changes to a set of state properties and invoke the provided
|
||||
* func when any of their values are changed.
|
||||
*
|
||||
* @param fn The callback to be invoked when the state value changes.
|
||||
* @param property Vector list of properties to listen for changes to.
|
||||
* @return Returns callback that invokes the provided FN immediately.
|
||||
*/
|
||||
std::function<void()> useEffect(
|
||||
const std::function<void()> &fn,
|
||||
std::vector<IStateProperty*> props
|
||||
) {
|
||||
auto itProp = props.begin();
|
||||
while(itProp != props.end()) {
|
||||
auto property = *itProp;
|
||||
if(property->owner == nullptr) { property->owner = this; } else { assertTrue(property->owner == this); }
|
||||
property->_effectListners.push_back(fn);
|
||||
++itProp;
|
||||
}
|
||||
return fn;
|
||||
}
|
||||
|
||||
/**
|
||||
* Listen for changes to a state property and invoke the provided callback
|
||||
* also, when state is changed this will run the returned teardown
|
||||
* callback.
|
||||
*
|
||||
* @param fn The callback to be invoked when the state value changes.
|
||||
* @param property Vector list of properties to listen for changes to.
|
||||
* @return Returns callback that invokes the provided FN immediately.
|
||||
*/
|
||||
std::function<void()> useEffectWithTeardown(
|
||||
const std::function<std::function<void()>()> &fn,
|
||||
IStateProperty &property
|
||||
) {
|
||||
if(property.owner == nullptr) { property.owner = this; } else { assertTrue(property.owner == this); }
|
||||
property._effectListnersWithTeardown.push_back(fn);
|
||||
|
||||
return std::bind([&](
|
||||
std::function<std::function<void()>()> &callback,
|
||||
IStateProperty *prop
|
||||
) {
|
||||
auto teardown = callback();
|
||||
prop->_effectTeardowns.push_back(teardown);
|
||||
}, fn, &property);
|
||||
}
|
||||
|
||||
/**
|
||||
* Listen for when an event is invoked by a state event. This is intended
|
||||
* to allow for cross-state-owner communication in a simple and effective
|
||||
* way.
|
||||
*
|
||||
* @tparam F The type of the callback function.
|
||||
* @tparam A The arguments from the state event that are calledback.
|
||||
* @param fn The function to be inokved on event trigger.
|
||||
* @param event The event that is being subscribed to.
|
||||
*/
|
||||
template<typename F, typename... A>
|
||||
std::function<void()> useEvent(F fn, StateEvent<A...> &event) {
|
||||
// Create a listener structure
|
||||
struct StateEventListener<A...> listener;
|
||||
listener.listener = fn;
|
||||
listener.owner = this;
|
||||
listener.event = &event;
|
||||
listener.unsubWithParams = [&](struct StateEventListener<A...> listener) {
|
||||
auto itFound = listener.event->_eventListeners.begin();
|
||||
while(itFound != listener.event->_eventListeners.end()) {
|
||||
if(itFound->id == listener.id) {
|
||||
listener.event->_eventListeners.erase(itFound);
|
||||
break;
|
||||
}
|
||||
++itFound++;
|
||||
}
|
||||
};
|
||||
listener.id = event.stateEventId++;
|
||||
listener.unsub = std::bind(listener.unsubWithParams, listener);
|
||||
|
||||
// Put that listener structure on to the event stack
|
||||
event._eventListeners.push_back(listener);
|
||||
this->eventsSubscribed.push_back(&event);
|
||||
|
||||
return listener.unsub;
|
||||
}
|
||||
|
||||
/**
|
||||
* Listen for callback of a legacy styled event. This will be removed in
|
||||
* the future in favour of everything using State Events. This uses a lot
|
||||
* more memory than the new state event listener.
|
||||
*
|
||||
* @deprecated In favour of StateEvent<>
|
||||
* @tparam F The type of the callback function.
|
||||
* @tparam A Argument types for the event.
|
||||
* @param fn Callback function to be invoked when the event is triggered.
|
||||
* @param event Event that will be listened to.
|
||||
*/
|
||||
template<typename F, typename... A>
|
||||
std::function<void()> useEventLegacy(
|
||||
F fn,
|
||||
Event<A...> &event
|
||||
) {
|
||||
// This is a legacy feature to make upgrading to the new useEffect a bit
|
||||
// easier for me. For the time being I am just bodging this together to
|
||||
// do what I need here.
|
||||
auto bridge = new StateOwnerEventLegacy<A...>();
|
||||
bridge->owner = this;
|
||||
bridge->event = &event;
|
||||
bridge->fn = fn;
|
||||
event.addListener(bridge, &StateOwnerEventLegacy<A...>::callback);
|
||||
eventLegacyBridge.push_back(bridge);
|
||||
|
||||
return std::bind([&](IStateOwnerEventLegacy *evt){
|
||||
evt->teardown();
|
||||
}, bridge);
|
||||
}
|
||||
|
||||
/**
|
||||
* State Owner teardown function. Mostly just used to remove any lingering
|
||||
* useEffects or useEvents.
|
||||
*/
|
||||
virtual ~StateOwner() {
|
||||
auto it = this->eventsSubscribed.begin();
|
||||
while(it != this->eventsSubscribed.end()) {
|
||||
(*it)->_stateOwnerDestroyed(this);
|
||||
++it;
|
||||
}
|
||||
|
||||
auto itBridge = this->eventLegacyBridge.begin();
|
||||
while(itBridge != this->eventLegacyBridge.end()) {
|
||||
(*itBridge)->removeListener();
|
||||
delete *itBridge;
|
||||
++itBridge;
|
||||
}
|
||||
}
|
||||
};
|
||||
// Copyright (c) 2023 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
|
||||
#pragma once
|
||||
#include "StateEvent.hpp"
|
||||
#include "StateProperty.hpp"
|
||||
|
||||
namespace Dawn {
|
||||
template<typename ...A>
|
||||
class StateOwnerEventLegacy : public IStateOwnerEventLegacy {
|
||||
public:
|
||||
IStateOwner *owner;
|
||||
Event<A...> *event;
|
||||
std::function<void(A...)> fn;
|
||||
|
||||
/**
|
||||
* Function used to simply remove the event listener from the legacy
|
||||
* event, does not deal with the state owner.
|
||||
*/
|
||||
void removeListener() override {
|
||||
event->removeListener(this, &StateOwnerEventLegacy::callback);
|
||||
}
|
||||
|
||||
/**
|
||||
* Function that can be used to tear down this legacy event.
|
||||
*/
|
||||
void teardown() override {
|
||||
this->removeListener();
|
||||
owner->_stateLegacyEventDisposed(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Callbaack method that is invoked by the legacy event.
|
||||
* @param args Arguments received by legacy event.
|
||||
*/
|
||||
void callback(A... args) {
|
||||
this->fn(args...);
|
||||
}
|
||||
};
|
||||
|
||||
class StateOwner : public IStateOwner {
|
||||
private:
|
||||
std::vector<IStateEvent*> eventsSubscribed;
|
||||
std::vector<IStateOwnerEventLegacy*> eventLegacyBridge;
|
||||
|
||||
public:
|
||||
/**
|
||||
* Called by the state event when it is disposing (before the StateOwner
|
||||
* itself is).
|
||||
*
|
||||
* @param evt Event that is being disposed.
|
||||
*/
|
||||
void _stateEventDisposed(IStateEvent *evt) override {
|
||||
auto it = eventsSubscribed.begin();
|
||||
while(it != eventsSubscribed.end()) {
|
||||
if(*it == evt) {
|
||||
it = eventsSubscribed.erase(it);
|
||||
} else {
|
||||
++it;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Called by legacy events when they are being disposed in a way that was
|
||||
* not called by this state owner disposing.
|
||||
*
|
||||
* @param evt Event that is being disposed.
|
||||
*/
|
||||
void _stateLegacyEventDisposed(IStateOwnerEventLegacy *evt) override {
|
||||
auto it = this->eventLegacyBridge.begin();
|
||||
while(it != this->eventLegacyBridge.end()) {
|
||||
if(*it == evt) {
|
||||
this->eventLegacyBridge.erase(it);
|
||||
break;
|
||||
} else {
|
||||
++it;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Listen for changes to a state property and invoke the provided func
|
||||
* when the value is changed.
|
||||
*
|
||||
* @param fn The callback to be invoked when the state value changes.
|
||||
* @param property Property to listen for affect changees to.
|
||||
* @return Returns callback that invokes the provided FN immediately.
|
||||
*/
|
||||
std::function<void()> useEffect(
|
||||
const std::function<void()> &fn,
|
||||
IStateProperty &property
|
||||
) {
|
||||
if(property.owner == nullptr) {
|
||||
property.owner = this;
|
||||
} else {
|
||||
// TODO: This actually isn't needed, but because I need to teardown
|
||||
// all the listeners on StateProperty<> that belong to this StateOwner
|
||||
// I need to keep track of what events I've subbed to, consuming more
|
||||
// memory, and I don't know if I actually need to do this or not.
|
||||
assertTrue(property.owner == this);
|
||||
}
|
||||
property._effectListners.push_back(fn);
|
||||
return fn;
|
||||
}
|
||||
|
||||
/**
|
||||
* Listen for changes to a set of state properties and invoke the provided
|
||||
* func when any of their values are changed.
|
||||
*
|
||||
* @param fn The callback to be invoked when the state value changes.
|
||||
* @param property Vector list of properties to listen for changes to.
|
||||
* @return Returns callback that invokes the provided FN immediately.
|
||||
*/
|
||||
std::function<void()> useEffect(
|
||||
const std::function<void()> &fn,
|
||||
std::vector<IStateProperty*> props
|
||||
) {
|
||||
auto itProp = props.begin();
|
||||
while(itProp != props.end()) {
|
||||
auto property = *itProp;
|
||||
if(property->owner == nullptr) { property->owner = this; } else { assertTrue(property->owner == this); }
|
||||
property->_effectListners.push_back(fn);
|
||||
++itProp;
|
||||
}
|
||||
return fn;
|
||||
}
|
||||
|
||||
/**
|
||||
* Listen for changes to a state property and invoke the provided callback
|
||||
* also, when state is changed this will run the returned teardown
|
||||
* callback.
|
||||
*
|
||||
* @param fn The callback to be invoked when the state value changes.
|
||||
* @param property Vector list of properties to listen for changes to.
|
||||
* @return Returns callback that invokes the provided FN immediately.
|
||||
*/
|
||||
std::function<void()> useEffectWithTeardown(
|
||||
const std::function<std::function<void()>()> &fn,
|
||||
IStateProperty &property
|
||||
) {
|
||||
if(property.owner == nullptr) { property.owner = this; } else { assertTrue(property.owner == this); }
|
||||
property._effectListnersWithTeardown.push_back(fn);
|
||||
|
||||
return std::bind([&](
|
||||
std::function<std::function<void()>()> &callback,
|
||||
IStateProperty *prop
|
||||
) {
|
||||
auto teardown = callback();
|
||||
prop->_effectTeardowns.push_back(teardown);
|
||||
}, fn, &property);
|
||||
}
|
||||
|
||||
/**
|
||||
* Listen for when an event is invoked by a state event. This is intended
|
||||
* to allow for cross-state-owner communication in a simple and effective
|
||||
* way.
|
||||
*
|
||||
* @tparam F The type of the callback function.
|
||||
* @tparam A The arguments from the state event that are calledback.
|
||||
* @param fn The function to be inokved on event trigger.
|
||||
* @param event The event that is being subscribed to.
|
||||
* @return A method that, when invoked, will unsubscribe from the event.
|
||||
*/
|
||||
template<typename F, typename... A>
|
||||
std::function<void()> useEvent(F fn, StateEvent<A...> &event) {
|
||||
// Create a listener structure
|
||||
struct StateEventListener<A...> listener;
|
||||
listener.listener = fn;
|
||||
listener.owner = this;
|
||||
listener.event = &event;
|
||||
listener.unsubWithParams = [&](struct StateEventListener<A...> listener) {
|
||||
auto itFound = listener.event->_eventListeners.begin();
|
||||
while(itFound != listener.event->_eventListeners.end()) {
|
||||
if(itFound->id == listener.id) {
|
||||
listener.event->_eventListeners.erase(itFound);
|
||||
break;
|
||||
}
|
||||
++itFound++;
|
||||
}
|
||||
};
|
||||
listener.id = event.stateEventId++;
|
||||
listener.unsub = std::bind(listener.unsubWithParams, listener);
|
||||
|
||||
// Put that listener structure on to the event stack
|
||||
event._eventListeners.push_back(listener);
|
||||
this->eventsSubscribed.push_back(&event);
|
||||
|
||||
return listener.unsub;
|
||||
}
|
||||
|
||||
/**
|
||||
* Listen for callback of a legacy styled event. This will be removed in
|
||||
* the future in favour of everything using State Events. This uses a lot
|
||||
* more memory than the new state event listener.
|
||||
*
|
||||
* @deprecated In favour of StateEvent<>
|
||||
* @tparam F The type of the callback function.
|
||||
* @tparam A Argument types for the event.
|
||||
* @param fn Callback function to be invoked when the event is triggered.
|
||||
* @param event Event that will be listened to.
|
||||
* @return A method that, when invoked, will unsubscribe from the event.
|
||||
*/
|
||||
template<typename F, typename... A>
|
||||
std::function<void()> useEventLegacy(
|
||||
F fn,
|
||||
Event<A...> &event
|
||||
) {
|
||||
// This is a legacy feature to make upgrading to the new useEffect a bit
|
||||
// easier for me. For the time being I am just bodging this together to
|
||||
// do what I need here.
|
||||
auto bridge = new StateOwnerEventLegacy<A...>();
|
||||
bridge->owner = this;
|
||||
bridge->event = &event;
|
||||
bridge->fn = fn;
|
||||
event.addListener(bridge, &StateOwnerEventLegacy<A...>::callback);
|
||||
eventLegacyBridge.push_back(bridge);
|
||||
|
||||
return std::bind([&](IStateOwnerEventLegacy *evt){
|
||||
evt->teardown();
|
||||
}, bridge);
|
||||
}
|
||||
|
||||
/**
|
||||
* State Owner teardown function. Mostly just used to remove any lingering
|
||||
* useEffects or useEvents.
|
||||
*/
|
||||
virtual ~StateOwner() {
|
||||
auto it = this->eventsSubscribed.begin();
|
||||
while(it != this->eventsSubscribed.end()) {
|
||||
(*it)->_stateOwnerDestroyed(this);
|
||||
++it;
|
||||
}
|
||||
|
||||
auto itBridge = this->eventLegacyBridge.begin();
|
||||
while(itBridge != this->eventLegacyBridge.end()) {
|
||||
(*itBridge)->removeListener();
|
||||
delete *itBridge;
|
||||
++itBridge;
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
@ -80,6 +80,28 @@ namespace Dawn {
|
||||
return *this;
|
||||
}
|
||||
|
||||
StateProperty& operator++() {
|
||||
this->setInternal(_realValue + 1);
|
||||
return *this;
|
||||
}
|
||||
|
||||
V operator++(int) {
|
||||
V temp = _realValue;
|
||||
this->setInternal(_realValue + 1);
|
||||
return temp;
|
||||
}
|
||||
|
||||
StateProperty& operator--() {
|
||||
this->setInternal(_realValue - 1);
|
||||
return *this;
|
||||
}
|
||||
|
||||
V operator--(int) {
|
||||
V temp = _realValue;
|
||||
this->setInternal(_realValue - 1);
|
||||
return temp;
|
||||
}
|
||||
|
||||
const V operator->() const {
|
||||
return this->_realValue;
|
||||
}
|
||||
|
||||
@ -61,10 +61,12 @@ int32_t DawnHost::init(DawnGame *game) {
|
||||
game->inputManager.bind(INPUT_BIND_ACCEPT, GLFW_KEY_ENTER);
|
||||
game->inputManager.bind(INPUT_BIND_ACCEPT, GLFW_KEY_E);
|
||||
game->inputManager.bind(INPUT_BIND_ACCEPT, GLFW_KEY_SPACE);
|
||||
game->inputManager.bind(INPUT_BIND_NEGATIVE_X, GLFW_KEY_A);
|
||||
game->inputManager.bind(INPUT_BIND_POSITIVE_X, GLFW_KEY_D);
|
||||
game->inputManager.bind(INPUT_BIND_NEGATIVE_Y, GLFW_KEY_S);
|
||||
game->inputManager.bind(INPUT_BIND_POSITIVE_Y, GLFW_KEY_W);
|
||||
game->inputManager.bind(INPUT_BIND_NEGATIVE_X, GLFW_KEY_A);
|
||||
game->inputManager.bind(INPUT_BIND_POSITIVE_Y, GLFW_KEY_S);
|
||||
game->inputManager.bind(INPUT_BIND_NEGATIVE_Y, GLFW_KEY_W);
|
||||
game->inputManager.bind(INPUT_BIND_CANCEL, GLFW_KEY_ESCAPE);
|
||||
game->inputManager.bind(INPUT_BIND_CANCEL, GLFW_KEY_Q);
|
||||
|
||||
game->inputManager.bind(INPUT_BIND_MOUSE_CLICK, INPUT_MANAGER_AXIS_MOUSE_0);
|
||||
game->inputManager.bind(INPUT_BIND_MOUSE_X, INPUT_MANAGER_AXIS_MOUSE_X);
|
||||
|
||||
@ -15,4 +15,5 @@
|
||||
#define INPUT_BIND_POSITIVE_Y INPUT_BIND(5)
|
||||
#define INPUT_BIND_MOUSE_X INPUT_BIND(6)
|
||||
#define INPUT_BIND_MOUSE_Y INPUT_BIND(7)
|
||||
#define INPUT_BIND_MOUSE_CLICK INPUT_BIND(8)
|
||||
#define INPUT_BIND_MOUSE_CLICK INPUT_BIND(8)
|
||||
#define INPUT_BIND_CANCEL INPUT_BIND(9)
|
||||
@ -10,6 +10,7 @@
|
||||
#include "display/mesh/TriangleMesh.hpp"
|
||||
#include "components/TicTacToeGame.hpp"
|
||||
#include "scene/components/ui/UILabel.hpp"
|
||||
#include "scene/components/ui/menu/UISimpleMenu.hpp"
|
||||
|
||||
#include "state/State.hpp"
|
||||
|
||||
@ -20,13 +21,10 @@ namespace Dawn {
|
||||
Camera *camera;
|
||||
std::function<void()> evtUnsub;
|
||||
|
||||
UILabel *label;
|
||||
StateProperty<int32_t> test;
|
||||
|
||||
void stage() override {
|
||||
camera = Camera::create(this);
|
||||
// camera->transform->lookAt(glm::vec3(0, 0, 8), glm::vec3(0, 0, 0));
|
||||
camera->transform->lookAt(glm::vec3(32, 32, 32), glm::vec3(0, 0, 0));
|
||||
camera->transform->lookAt(glm::vec3(3, 3, 3), glm::vec3(0, 0, 0));
|
||||
|
||||
float_t s = 2.0f;
|
||||
camera->orthoTop = s;
|
||||
@ -50,26 +48,41 @@ namespace Dawn {
|
||||
|
||||
auto canvasItem = this->createSceneItem();
|
||||
auto canvas = canvasItem->addComponent<UICanvas>();
|
||||
auto menu = canvasItem->addComponent<UIMenuController>();
|
||||
auto simpleMenu = canvasItem->addComponent<UISimpleMenu>();
|
||||
|
||||
auto labelItem = this->createSceneItem();
|
||||
label = labelItem->addComponent<UILabel>();
|
||||
label->font = &this->game->assetManager.get<TrueTypeAsset>("truetype_bizudp")->font;
|
||||
label->text = "Hello World";
|
||||
label->fontSize = 36.0f;
|
||||
labelItem->transform.setParent(canvas->transform);
|
||||
for(int32_t x = 0; x < 2; x++) {
|
||||
for(int32_t y = 0; y < 2; y++) {
|
||||
auto labelItem = this->createSceneItem();
|
||||
auto label = labelItem->addComponent<UILabel>();
|
||||
auto labelMenuItem = labelItem->addComponent<UISimpleMenuItem>();
|
||||
|
||||
label->alignX = UI_COMPONENT_ALIGN_MIDDLE;
|
||||
label->alignY = UI_COMPONENT_ALIGN_MIDDLE;
|
||||
label->alignment = glm::vec4(0, 0, 350, 100);
|
||||
label->maxWidth = 0;
|
||||
label->font = &this->game->assetManager.get<TrueTypeAsset>("truetype_bizudp")->font;
|
||||
label->text = "Item " + std::to_string(x) + ", " + std::to_string(y);
|
||||
// label->fontSize = 36.0f;
|
||||
label->fontSize = 1.0f;
|
||||
labelItem->transform.setParent(canvas->transform);
|
||||
|
||||
useEffect([&]{
|
||||
label->text = "Hello " + std::to_string(test) + " world";
|
||||
}, test);
|
||||
label->alignment = glm::vec4(label->fontSize * 8 * x, label->fontSize * 1.5f * y, 350, 100);
|
||||
label->maxWidth = 0;
|
||||
|
||||
labelMenuItem->menuX = x;
|
||||
labelMenuItem->menuY = y;
|
||||
|
||||
useEvent([&](float_t delta){
|
||||
test = test + 1;
|
||||
}, this->eventSceneUpdate);
|
||||
|
||||
useEvent(std::bind([&](UISimpleMenuItem *itm){
|
||||
std::cout << "Hover on " << std::to_string(itm->menuX) << ", " << std::to_string(itm->menuY) << std::endl;
|
||||
}, labelMenuItem), labelMenuItem->eventHoveredOn);
|
||||
|
||||
useEvent(std::bind([&](UISimpleMenuItem *itm){
|
||||
std::cout << "Hover off " << std::to_string(itm->menuX) << ", " << std::to_string(itm->menuY) << std::endl;
|
||||
}, labelMenuItem), labelMenuItem->eventHoveredOff);
|
||||
|
||||
useEvent([&]{
|
||||
std::cout << "Selected" << std::endl;
|
||||
}, labelMenuItem->eventSelected);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<Asset*> getRequiredAssets() override {
|
||||
@ -82,6 +95,6 @@ namespace Dawn {
|
||||
}
|
||||
|
||||
public:
|
||||
TicTacToeScene(DawnGame *game) : Scene(game), test(0) {}
|
||||
TicTacToeScene(DawnGame *game) : Scene(game) {}
|
||||
};
|
||||
}
|
||||
Reference in New Issue
Block a user