YourWishes/Dawn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

UI menu now accepts mouse input from absolutes.

Browse Source
This commit is contained in:
Dominic Masters
2023-03-08 16:39:24 -08:00
parent 95e5aa1eeb
commit 186ac8bc3f
20 changed files with 864 additions and 549 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/SDL

Submodule lib/SDL updated: c9aec268fa...87a83787a3

2
lib/openal-soft

Submodule lib/openal-soft updated: fde74453a6...d66107e9f0

366
src/dawn/physics/3d/Ray3D.cpp
View File

@ -1,165 +1,203 @@
// Copyright (c) 2023 Dominic Masters // Copyright (c) 2023 Dominic Masters
// //
// This software is released under the MIT License. // This software is released under the MIT License.
// https://opensource.org/licenses/MIT // https://opensource.org/licenses/MIT
#include "Ray3D.hpp" #include "Ray3D.hpp"
using namespace Dawn; using namespace Dawn;
bool_t Dawn::raytestSphere( bool_t Dawn::raytestSphere(
struct Ray3D ray, struct Ray3D ray,
struct PhysicsSphere sphere, struct PhysicsSphere sphere,
glm::vec3 *hit, glm::vec3 *hit,
glm::vec3 *normal glm::vec3 *normal
) { ) {
assertNotNull(hit); assertNotNull(hit);
assertNotNull(normal); assertNotNull(normal);
glm::vec3 h, n; glm::vec3 h, n;
auto result = glm::intersectRaySphere( auto result = glm::intersectRaySphere(
ray.origin, ray.direction, ray.origin, ray.direction,
sphere.center, sphere.radius, sphere.center, sphere.radius,
h, n h, n
); );
*hit = h; *hit = h;
*normal = n; *normal = n;
return result; return result;
} }
bool_t Dawn::raytestTriangle( bool_t Dawn::raytestTriangle(
struct Ray3D ray, struct Ray3D ray,
struct PhysicsTriangle triangle, struct PhysicsTriangle triangle,
glm::vec3 *hitPoint, glm::vec3 *hitPoint,
glm::vec3 *hitNormal, glm::vec3 *hitNormal,
float_t *hitDistance float_t *hitDistance
) { ) {
assertNotNull(hitPoint); assertNotNull(hitPoint);
assertNotNull(hitNormal); assertNotNull(hitNormal);
assertNotNull(hitDistance); assertNotNull(hitDistance);
// Calculate the normal of the triangle // Calculate the normal of the triangle
glm::vec3 e0 = triangle.v1 - triangle.v0; glm::vec3 e0 = triangle.v1 - triangle.v0;
glm::vec3 e1 = triangle.v2 - triangle.v0; glm::vec3 e1 = triangle.v2 - triangle.v0;
glm::vec3 normal = glm::normalize(glm::cross(e0, e1)); glm::vec3 normal = glm::normalize(glm::cross(e0, e1));
// Calculate the denominator of the ray-triangle intersection formula // Calculate the denominator of the ray-triangle intersection formula
float_t denominator = glm::dot(normal, ray.direction); 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 the denominator is zero, the ray and triangle are parallel and there is no intersection
if(denominator == 0) return -1; if(denominator == 0) return -1;
// Calculate the distance from the ray origin to the plane of the triangle // Calculate the distance from the ray origin to the plane of the triangle
float_t d = glm::dot(triangle.v0 - ray.origin, normal) / denominator; 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 the distance is negative, the intersection point is behind the ray origin and there is no intersection
if(d < 0) return -1; if(d < 0) return -1;
// Calculate the intersection point // Calculate the intersection point
glm::vec3 intersectionPoint = ray.origin + d * ray.direction; glm::vec3 intersectionPoint = ray.origin + d * ray.direction;
// Check if the intersection point is inside the triangle // Check if the intersection point is inside the triangle
glm::vec3 edge0 = triangle.v1 - triangle.v0; glm::vec3 edge0 = triangle.v1 - triangle.v0;
glm::vec3 edge1 = triangle.v2 - triangle.v1; glm::vec3 edge1 = triangle.v2 - triangle.v1;
glm::vec3 edge2 = triangle.v0 - triangle.v2; glm::vec3 edge2 = triangle.v0 - triangle.v2;
glm::vec3 c0 = intersectionPoint - triangle.v0; glm::vec3 c0 = intersectionPoint - triangle.v0;
glm::vec3 c1 = intersectionPoint - triangle.v1; glm::vec3 c1 = intersectionPoint - triangle.v1;
glm::vec3 c2 = intersectionPoint - triangle.v2; glm::vec3 c2 = intersectionPoint - triangle.v2;
glm::vec3 n0 = glm::cross(edge0, c0); glm::vec3 n0 = glm::cross(edge0, c0);
glm::vec3 n1 = glm::cross(edge1, c1); glm::vec3 n1 = glm::cross(edge1, c1);
glm::vec3 n2 = glm::cross(edge2, c2); glm::vec3 n2 = glm::cross(edge2, c2);
if(glm::dot(n0, normal) >= 0 && glm::dot(n1, normal) >= 0 && glm::dot(n2, normal) >= 0) { 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 // If the intersection point is inside the triangle, set the hit point, normal and distance
*hitPoint = intersectionPoint; *hitPoint = intersectionPoint;
*hitNormal = normal; *hitNormal = normal;
*hitDistance = d; *hitDistance = d;
return true; return true;
} }
// If the intersection point is outside the triangle, there is no intersection // If the intersection point is outside the triangle, there is no intersection
return false; return false;
} }
bool_t Dawn::raytestAABB( bool_t Dawn::raytestAABB(
struct Ray3D ray, struct Ray3D ray,
struct AABB3D box, struct AABB3D box,
glm::vec3 *point, glm::vec3 *point,
glm::vec3 *normal, glm::vec3 *normal,
float_t *distance float_t *distance
) { ) {
assertNotNull(point); assertNotNull(point);
assertNotNull(normal); assertNotNull(normal);
assertNotNull(distance); assertNotNull(distance);
// Compute the inverse direction of the ray, for numerical stability // 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); 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 // Compute the t-values for the two intersection candidates
glm::vec3 tMin = (box.min - ray.origin) * invDir; glm::vec3 tMin = (box.min - ray.origin) * invDir;
glm::vec3 tMax = (box.max - ray.origin) * invDir; glm::vec3 tMax = (box.max - ray.origin) * invDir;
// Make sure tMin is less than or equal to tMax for all components // Make sure tMin is less than or equal to tMax for all components
glm::vec3 t1 = glm::min(tMin, tMax); glm::vec3 t1 = glm::min(tMin, tMax);
glm::vec3 t2 = glm::max(tMin, tMax); glm::vec3 t2 = glm::max(tMin, tMax);
float tNear = glm::compMax(t1); float tNear = glm::compMax(t1);
float tFar = glm::compMin(t2); float tFar = glm::compMin(t2);
// If tNear is greater than or equal to tFar, there is no intersection // If tNear is greater than or equal to tFar, there is no intersection
if(tNear >= tFar) return false; if(tNear >= tFar) return false;
// If tFar is negative, the ray is pointing away from the box // If tFar is negative, the ray is pointing away from the box
if(tFar < 0.0f) return false; if(tFar < 0.0f) return false;
// Compute the hit point and normal // Compute the hit point and normal
glm::vec3 hitPoint = ray.origin + tNear * ray.direction; glm::vec3 hitPoint = ray.origin + tNear * ray.direction;
*point = hitPoint; *point = hitPoint;
*distance = tNear; *distance = tNear;
// Small value to account for floating point imprecision // Small value to account for floating point imprecision
const float epsilon = 0.001f; const float epsilon = 0.001f;
if(std::abs(hitPoint.x - box.min.x) < epsilon) { if(std::abs(hitPoint.x - box.min.x) < epsilon) {
*normal = glm::vec3(-1, 0, 0); *normal = glm::vec3(-1, 0, 0);
} else if(std::abs(hitPoint.x - box.max.x) < epsilon) { } else if(std::abs(hitPoint.x - box.max.x) < epsilon) {
*normal = glm::vec3(1, 0, 0); *normal = glm::vec3(1, 0, 0);
} else if(std::abs(hitPoint.y - box.min.y) < epsilon) { } else if(std::abs(hitPoint.y - box.min.y) < epsilon) {
*normal = glm::vec3(0, -1, 0); *normal = glm::vec3(0, -1, 0);
} else if(std::abs(hitPoint.y - box.max.y) < epsilon) { } else if(std::abs(hitPoint.y - box.max.y) < epsilon) {
*normal = glm::vec3(0, 1, 0); *normal = glm::vec3(0, 1, 0);
} else if(std::abs(hitPoint.z - box.min.z) < epsilon) { } else if(std::abs(hitPoint.z - box.min.z) < epsilon) {
*normal = glm::vec3(0, 0, -1); *normal = glm::vec3(0, 0, -1);
} else if(std::abs(hitPoint.z - box.max.z) < epsilon) { } else if(std::abs(hitPoint.z - box.max.z) < epsilon) {
*normal = glm::vec3(0, 0, 1); *normal = glm::vec3(0, 0, 1);
} }
return true; return true;
} }
bool_t Dawn::raytestCube( bool_t Dawn::raytestCube(
struct Ray3D ray, struct Ray3D ray,
struct AABB3D box, struct AABB3D box,
glm::mat4 transform, glm::mat4 transform,
glm::vec3 *point, glm::vec3 *point,
glm::vec3 *normal, glm::vec3 *normal,
float_t *distance float_t *distance
) { ) {
// Compute the inverse transformation matrix // Compute the inverse transformation matrix
glm::mat4 inverseTransform = glm::inverse(transform); glm::mat4 inverseTransform = glm::inverse(transform);
// Transform the ray into model space // Transform the ray into model space
struct Ray3D localRay; struct Ray3D localRay;
localRay.origin = glm::vec3(inverseTransform * glm::vec4(ray.origin, 1.0f)); localRay.origin = glm::vec3(inverseTransform * glm::vec4(ray.origin, 1.0f));
localRay.direction = glm::normalize(glm::vec3(inverseTransform * glm::vec4(ray.direction, 0.0f))); localRay.direction = glm::normalize(glm::vec3(inverseTransform * glm::vec4(ray.direction, 0.0f)));
// Call raytestAABB with the transformed ray and cube // Call raytestAABB with the transformed ray and cube
bool_t hit = raytestAABB(localRay, box, point, normal, distance); bool_t hit = raytestAABB(localRay, box, point, normal, distance);
if(!hit) return false; if(!hit) return false;
// Transform the hit point and normal back into world space // Transform the hit point and normal back into world space
*point = glm::vec3(transform * glm::vec4(*point, 1.0f)); *point = glm::vec3(transform * glm::vec4(*point, 1.0f));
*normal = glm::normalize(glm::vec3(glm::transpose(inverseTransform) * glm::vec4(*normal, 0.0f))); *normal = glm::normalize(glm::vec3(glm::transpose(inverseTransform) * glm::vec4(*normal, 0.0f)));
return true; 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
} }

110
src/dawn/physics/3d/Ray3D.hpp
View File

@ -1,50 +1,60 @@
// Copyright (c) 2023 Dominic Masters // Copyright (c) 2023 Dominic Masters
// //
// This software is released under the MIT License. // This software is released under the MIT License.
// https://opensource.org/licenses/MIT // https://opensource.org/licenses/MIT
#pragma once #pragma once
#include "dawnlibs.hpp" #include "dawnlibs.hpp"
#include "assert/assert.hpp" #include "assert/assert.hpp"
#include "PhysicsTriangle.hpp" #include "PhysicsTriangle.hpp"
#include "PhysicsSphere.hpp" #include "PhysicsSphere.hpp"
#include "AABB3D.hpp" #include "AABB3D.hpp"
namespace Dawn { namespace Dawn {
struct Ray3D { struct Ray3D {
glm::vec3 origin; glm::vec3 origin;
glm::vec3 direction; glm::vec3 direction;
}; };
bool_t raytestSphere( bool_t raytestSphere(
struct Ray3D ray, struct Ray3D ray,
struct PhysicsSphere sphere, struct PhysicsSphere sphere,
glm::vec3 *hit, glm::vec3 *hit,
glm::vec3 *normal glm::vec3 *normal
); );
bool_t raytestTriangle( bool_t raytestTriangle(
struct Ray3D ray, struct Ray3D ray,
struct PhysicsTriangle triangle, struct PhysicsTriangle triangle,
glm::vec3 *hitPoint, glm::vec3 *hitPoint,
glm::vec3 *hitNormal, glm::vec3 *hitNormal,
float_t *hitDistance float_t *hitDistance
); );
bool_t raytestAABB( bool_t raytestAABB(
struct Ray3D ray, struct Ray3D ray,
struct AABB3D box, struct AABB3D box,
glm::vec3 *point, glm::vec3 *point,
glm::vec3 *normal, glm::vec3 *normal,
float_t *distance float_t *distance
); );
bool_t raytestCube( bool_t raytestCube(
struct Ray3D ray, struct Ray3D ray,
struct AABB3D box, struct AABB3D box,
glm::mat4 transform, glm::mat4 transform,
glm::vec3 *point, glm::vec3 *point,
glm::vec3 *normal, glm::vec3 *normal,
float_t *distance 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
);
}

66
src/dawn/physics/ScenePhysicsManager.hpp
View File

@ -1,34 +1,34 @@
// Copyright (c) 2023 Dominic Masters // Copyright (c) 2023 Dominic Masters
// //
// This software is released under the MIT License. // This software is released under the MIT License.
// https://opensource.org/licenses/MIT // https://opensource.org/licenses/MIT
#pragma once #pragma once
#include "dawnlibs.hpp" #include "dawnlibs.hpp"
#include "physics/3d/Ray3D.hpp" #include "physics/3d/Ray3D.hpp"
typedef int64_t scenechunk_t; typedef int64_t scenechunk_t;
#define SCENE_CHUNK_SIZE_2D 512 #define SCENE_CHUNK_SIZE_2D 512
namespace Dawn { namespace Dawn {
class Scene; class Scene;
class Collider3D; class Collider3D;
struct Collider3DRayResult; struct Collider3DRayResult;
class ScenePhysicsManager { class ScenePhysicsManager {
protected: protected:
Scene *scene; Scene *scene;
// std::map<scenechunk_t, std::vector<SceneItem*>> chunkItems; // std::map<scenechunk_t, std::vector<SceneItem*>> chunkItems;
// std::map<SceneItem*, std::vector<scenechunk_t>> itemChunks; // std::map<SceneItem*, std::vector<scenechunk_t>> itemChunks;
public: public:
ScenePhysicsManager(Scene *scene); ScenePhysicsManager(Scene *scene);
void update(); void update();
std::vector<struct Collider3DRayResult> raycast3DAll(struct Ray3D ray); std::vector<struct Collider3DRayResult> raycast3DAll(struct Ray3D ray);
friend class Scene; friend class Scene;
}; };
} }

3
src/dawn/scene/components/ui/CMakeLists.txt
View File

@ -9,7 +9,6 @@ target_sources(${DAWN_TARGET_NAME}
UICanvas.cpp UICanvas.cpp
UIComponent.cpp UIComponent.cpp
UILabel.cpp UILabel.cpp
UIMenuController.cpp
) )
tool_scenecomponent(UICanvas scene/components/ui/UICanvas.hpp) add_subdirectory(menu)

2
src/dawn/scene/components/ui/UICanvas.hpp
View File

@ -64,7 +64,7 @@ namespace Dawn {
//======================================================================// //======================================================================//
StateProperty<Camera*> camera; 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. * Constructs the UI Canvas Scene Item Component.

30
src/dawn/scene/components/ui/UIMenuController.cpp
View File

@ -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
View 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
View 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)();
}

3
src/dawn/scene/components/ui/UIMenuController.hpp → src/dawn/scene/components/ui/menu/UIMenuController.hpp
View File

@ -20,6 +20,9 @@ namespace Dawn {
StateEvent<int32_t, int32_t> eventItemChange; StateEvent<int32_t, int32_t> eventItemChange;
StateEvent<int32_t, int32_t> eventItemSelected; StateEvent<int32_t, int32_t> eventItemSelected;
StateEvent<> eventMenuCancel;
void moveRelative(int32_t x, int32_t y);
UIMenuController(SceneItem *item); UIMenuController(SceneItem *item);

110
src/dawn/scene/components/ui/menu/UISimpleMenu.cpp Normal file
View 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
View 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
View 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
View 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();
};
}

486
src/dawn/state/State.hpp
View File

@ -1,243 +1,245 @@
// Copyright (c) 2023 Dominic Masters // Copyright (c) 2023 Dominic Masters
// //
// This software is released under the MIT License. // This software is released under the MIT License.
// https://opensource.org/licenses/MIT // https://opensource.org/licenses/MIT
#pragma once #pragma once
#include "StateEvent.hpp" #include "StateEvent.hpp"
#include "StateProperty.hpp" #include "StateProperty.hpp"
namespace Dawn { namespace Dawn {
template<typename ...A> template<typename ...A>
class StateOwnerEventLegacy : public IStateOwnerEventLegacy { class StateOwnerEventLegacy : public IStateOwnerEventLegacy {
public: public:
IStateOwner *owner; IStateOwner *owner;
Event<A...> *event; Event<A...> *event;
std::function<void(A...)> fn; std::function<void(A...)> fn;
/** /**
* Function used to simply remove the event listener from the legacy * Function used to simply remove the event listener from the legacy
* event, does not deal with the state owner. * event, does not deal with the state owner.
*/ */
void removeListener() override { void removeListener() override {
event->removeListener(this, &StateOwnerEventLegacy::callback); event->removeListener(this, &StateOwnerEventLegacy::callback);
} }
/** /**
* Function that can be used to tear down this legacy event. * Function that can be used to tear down this legacy event.
*/ */
void teardown() override { void teardown() override {
this->removeListener(); this->removeListener();
owner->_stateLegacyEventDisposed(this); owner->_stateLegacyEventDisposed(this);
} }
/** /**
* Callbaack method that is invoked by the legacy event. * Callbaack method that is invoked by the legacy event.
* @param args Arguments received by legacy event. * @param args Arguments received by legacy event.
*/ */
void callback(A... args) { void callback(A... args) {
this->fn(args...); this->fn(args...);
} }
}; };
class StateOwner : public IStateOwner { class StateOwner : public IStateOwner {
private: private:
std::vector<IStateEvent*> eventsSubscribed; std::vector<IStateEvent*> eventsSubscribed;
std::vector<IStateOwnerEventLegacy*> eventLegacyBridge; std::vector<IStateOwnerEventLegacy*> eventLegacyBridge;
public: public:
/** /**
* Called by the state event when it is disposing (before the StateOwner * Called by the state event when it is disposing (before the StateOwner
* itself is). * itself is).
* *
* @param evt Event that is being disposed. * @param evt Event that is being disposed.
*/ */
void _stateEventDisposed(IStateEvent *evt) override { void _stateEventDisposed(IStateEvent *evt) override {
auto it = eventsSubscribed.begin(); auto it = eventsSubscribed.begin();
while(it != eventsSubscribed.end()) { while(it != eventsSubscribed.end()) {
if(*it == evt) { if(*it == evt) {
it = eventsSubscribed.erase(it); it = eventsSubscribed.erase(it);
} else { } else {
++it; ++it;
} }
} }
} }
/** /**
* Called by legacy events when they are being disposed in a way that was * Called by legacy events when they are being disposed in a way that was
* not called by this state owner disposing. * not called by this state owner disposing.
* *
* @param evt Event that is being disposed. * @param evt Event that is being disposed.
*/ */
void _stateLegacyEventDisposed(IStateOwnerEventLegacy *evt) override { void _stateLegacyEventDisposed(IStateOwnerEventLegacy *evt) override {
auto it = this->eventLegacyBridge.begin(); auto it = this->eventLegacyBridge.begin();
while(it != this->eventLegacyBridge.end()) { while(it != this->eventLegacyBridge.end()) {
if(*it == evt) { if(*it == evt) {
this->eventLegacyBridge.erase(it); this->eventLegacyBridge.erase(it);
break; break;
} else { } else {
++it; ++it;
} }
} }
} }
/** /**
* Listen for changes to a state property and invoke the provided func * Listen for changes to a state property and invoke the provided func
* when the value is changed. * when the value is changed.
* *
* @param fn The callback to be invoked when the state value changes. * @param fn The callback to be invoked when the state value changes.
* @param property Property to listen for affect changees to. * @param property Property to listen for affect changees to.
* @return Returns callback that invokes the provided FN immediately. * @return Returns callback that invokes the provided FN immediately.
*/ */
std::function<void()> useEffect( std::function<void()> useEffect(
const std::function<void()> &fn, const std::function<void()> &fn,
IStateProperty &property IStateProperty &property
) { ) {
if(property.owner == nullptr) { if(property.owner == nullptr) {
property.owner = this; property.owner = this;
} else { } else {
// TODO: This actually isn't needed, but because I need to teardown // TODO: This actually isn't needed, but because I need to teardown
// all the listeners on StateProperty<> that belong to this StateOwner // all the listeners on StateProperty<> that belong to this StateOwner
// I need to keep track of what events I've subbed to, consuming more // 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. // memory, and I don't know if I actually need to do this or not.
assertTrue(property.owner == this); assertTrue(property.owner == this);
} }
property._effectListners.push_back(fn); property._effectListners.push_back(fn);
return fn; return fn;
} }
/** /**
* Listen for changes to a set of state properties and invoke the provided * Listen for changes to a set of state properties and invoke the provided
* func when any of their values are changed. * func when any of their values are changed.
* *
* @param fn The callback to be invoked when the state value changes. * @param fn The callback to be invoked when the state value changes.
* @param property Vector list of properties to listen for changes to. * @param property Vector list of properties to listen for changes to.
* @return Returns callback that invokes the provided FN immediately. * @return Returns callback that invokes the provided FN immediately.
*/ */
std::function<void()> useEffect( std::function<void()> useEffect(
const std::function<void()> &fn, const std::function<void()> &fn,
std::vector<IStateProperty*> props std::vector<IStateProperty*> props
) { ) {
auto itProp = props.begin(); auto itProp = props.begin();
while(itProp != props.end()) { while(itProp != props.end()) {
auto property = *itProp; auto property = *itProp;
if(property->owner == nullptr) { property->owner = this; } else { assertTrue(property->owner == this); } if(property->owner == nullptr) { property->owner = this; } else { assertTrue(property->owner == this); }
property->_effectListners.push_back(fn); property->_effectListners.push_back(fn);
++itProp; ++itProp;
} }
return fn; return fn;
} }
/** /**
* Listen for changes to a state property and invoke the provided callback * Listen for changes to a state property and invoke the provided callback
* also, when state is changed this will run the returned teardown * also, when state is changed this will run the returned teardown
* callback. * callback.
* *
* @param fn The callback to be invoked when the state value changes. * @param fn The callback to be invoked when the state value changes.
* @param property Vector list of properties to listen for changes to. * @param property Vector list of properties to listen for changes to.
* @return Returns callback that invokes the provided FN immediately. * @return Returns callback that invokes the provided FN immediately.
*/ */
std::function<void()> useEffectWithTeardown( std::function<void()> useEffectWithTeardown(
const std::function<std::function<void()>()> &fn, const std::function<std::function<void()>()> &fn,
IStateProperty &property IStateProperty &property
) { ) {
if(property.owner == nullptr) { property.owner = this; } else { assertTrue(property.owner == this); } if(property.owner == nullptr) { property.owner = this; } else { assertTrue(property.owner == this); }
property._effectListnersWithTeardown.push_back(fn); property._effectListnersWithTeardown.push_back(fn);
return std::bind([&]( return std::bind([&](
std::function<std::function<void()>()> &callback, std::function<std::function<void()>()> &callback,
IStateProperty *prop IStateProperty *prop
) { ) {
auto teardown = callback(); auto teardown = callback();
prop->_effectTeardowns.push_back(teardown); prop->_effectTeardowns.push_back(teardown);
}, fn, &property); }, fn, &property);
} }
/** /**
* Listen for when an event is invoked by a state event. This is intended * 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 * to allow for cross-state-owner communication in a simple and effective
* way. * way.
* *
* @tparam F The type of the callback function. * @tparam F The type of the callback function.
* @tparam A The arguments from the state event that are calledback. * @tparam A The arguments from the state event that are calledback.
* @param fn The function to be inokved on event trigger. * @param fn The function to be inokved on event trigger.
* @param event The event that is being subscribed to. * @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) { template<typename F, typename... A>
// Create a listener structure std::function<void()> useEvent(F fn, StateEvent<A...> &event) {
struct StateEventListener<A...> listener; // Create a listener structure
listener.listener = fn; struct StateEventListener<A...> listener;
listener.owner = this; listener.listener = fn;
listener.event = &event; listener.owner = this;
listener.unsubWithParams = [&](struct StateEventListener<A...> listener) { listener.event = &event;
auto itFound = listener.event->_eventListeners.begin(); listener.unsubWithParams = [&](struct StateEventListener<A...> listener) {
while(itFound != listener.event->_eventListeners.end()) { auto itFound = listener.event->_eventListeners.begin();
if(itFound->id == listener.id) { while(itFound != listener.event->_eventListeners.end()) {
listener.event->_eventListeners.erase(itFound); if(itFound->id == listener.id) {
break; listener.event->_eventListeners.erase(itFound);
} break;
++itFound++; }
} ++itFound++;
}; }
listener.id = event.stateEventId++; };
listener.unsub = std::bind(listener.unsubWithParams, listener); 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); // Put that listener structure on to the event stack
this->eventsSubscribed.push_back(&event); event._eventListeners.push_back(listener);
this->eventsSubscribed.push_back(&event);
return listener.unsub;
} 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 * Listen for callback of a legacy styled event. This will be removed in
* more memory than the new state event listener. * 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. * @deprecated In favour of StateEvent<>
* @tparam A Argument types for the event. * @tparam F The type of the callback function.
* @param fn Callback function to be invoked when the event is triggered. * @tparam A Argument types for the event.
* @param event Event that will be listened to. * @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> * @return A method that, when invoked, will unsubscribe from the event.
std::function<void()> useEventLegacy( */
F fn, template<typename F, typename... A>
Event<A...> &event std::function<void()> useEventLegacy(
) { F fn,
// This is a legacy feature to make upgrading to the new useEffect a bit Event<A...> &event
// easier for me. For the time being I am just bodging this together to ) {
// do what I need here. // This is a legacy feature to make upgrading to the new useEffect a bit
auto bridge = new StateOwnerEventLegacy<A...>(); // easier for me. For the time being I am just bodging this together to
bridge->owner = this; // do what I need here.
bridge->event = &event; auto bridge = new StateOwnerEventLegacy<A...>();
bridge->fn = fn; bridge->owner = this;
event.addListener(bridge, &StateOwnerEventLegacy<A...>::callback); bridge->event = &event;
eventLegacyBridge.push_back(bridge); bridge->fn = fn;
event.addListener(bridge, &StateOwnerEventLegacy<A...>::callback);
return std::bind([&](IStateOwnerEventLegacy *evt){ eventLegacyBridge.push_back(bridge);
evt->teardown();
}, bridge); return std::bind([&](IStateOwnerEventLegacy *evt){
} evt->teardown();
}, bridge);
/** }
* State Owner teardown function. Mostly just used to remove any lingering
* useEffects or useEvents. /**
*/ * State Owner teardown function. Mostly just used to remove any lingering
virtual ~StateOwner() { * useEffects or useEvents.
auto it = this->eventsSubscribed.begin(); */
while(it != this->eventsSubscribed.end()) { virtual ~StateOwner() {
(*it)->_stateOwnerDestroyed(this); auto it = this->eventsSubscribed.begin();
++it; while(it != this->eventsSubscribed.end()) {
} (*it)->_stateOwnerDestroyed(this);
++it;
auto itBridge = this->eventLegacyBridge.begin(); }
while(itBridge != this->eventLegacyBridge.end()) {
(*itBridge)->removeListener(); auto itBridge = this->eventLegacyBridge.begin();
delete *itBridge; while(itBridge != this->eventLegacyBridge.end()) {
++itBridge; (*itBridge)->removeListener();
} delete *itBridge;
} ++itBridge;
}; }
}
};
} }

22
src/dawn/state/StateProperty.hpp
View File

@ -80,6 +80,28 @@ namespace Dawn {
return *this; 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 { const V operator->() const {
return this->_realValue; return this->_realValue;
} }

8
src/dawnglfw/host/DawnGLFWHost.cpp
View File

@ -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_ENTER);
game->inputManager.bind(INPUT_BIND_ACCEPT, GLFW_KEY_E); game->inputManager.bind(INPUT_BIND_ACCEPT, GLFW_KEY_E);
game->inputManager.bind(INPUT_BIND_ACCEPT, GLFW_KEY_SPACE); 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_POSITIVE_X, GLFW_KEY_D);
game->inputManager.bind(INPUT_BIND_NEGATIVE_Y, GLFW_KEY_S); game->inputManager.bind(INPUT_BIND_NEGATIVE_X, GLFW_KEY_A);
game->inputManager.bind(INPUT_BIND_POSITIVE_Y, GLFW_KEY_W); 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_CLICK, INPUT_MANAGER_AXIS_MOUSE_0);
game->inputManager.bind(INPUT_BIND_MOUSE_X, INPUT_MANAGER_AXIS_MOUSE_X); game->inputManager.bind(INPUT_BIND_MOUSE_X, INPUT_MANAGER_AXIS_MOUSE_X);

3
src/dawntictactoe/input/InputBinds.hpp
View File

@ -15,4 +15,5 @@
#define INPUT_BIND_POSITIVE_Y INPUT_BIND(5) #define INPUT_BIND_POSITIVE_Y INPUT_BIND(5)
#define INPUT_BIND_MOUSE_X INPUT_BIND(6) #define INPUT_BIND_MOUSE_X INPUT_BIND(6)
#define INPUT_BIND_MOUSE_Y INPUT_BIND(7) #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)

55
src/dawntictactoe/scenes/TicTacToeScene.hpp
View File

@ -10,6 +10,7 @@
#include "display/mesh/TriangleMesh.hpp" #include "display/mesh/TriangleMesh.hpp"
#include "components/TicTacToeGame.hpp" #include "components/TicTacToeGame.hpp"
#include "scene/components/ui/UILabel.hpp" #include "scene/components/ui/UILabel.hpp"
#include "scene/components/ui/menu/UISimpleMenu.hpp"
#include "state/State.hpp" #include "state/State.hpp"
@ -20,13 +21,10 @@ namespace Dawn {
Camera *camera; Camera *camera;
std::function<void()> evtUnsub; std::function<void()> evtUnsub;
UILabel *label;
StateProperty<int32_t> test;
void stage() override { void stage() override {
camera = Camera::create(this); camera = Camera::create(this);
// camera->transform->lookAt(glm::vec3(0, 0, 8), glm::vec3(0, 0, 0)); // 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; float_t s = 2.0f;
camera->orthoTop = s; camera->orthoTop = s;
@ -50,26 +48,41 @@ namespace Dawn {
auto canvasItem = this->createSceneItem(); auto canvasItem = this->createSceneItem();
auto canvas = canvasItem->addComponent<UICanvas>(); auto canvas = canvasItem->addComponent<UICanvas>();
auto menu = canvasItem->addComponent<UIMenuController>();
auto simpleMenu = canvasItem->addComponent<UISimpleMenu>();
auto labelItem = this->createSceneItem(); for(int32_t x = 0; x < 2; x++) {
label = labelItem->addComponent<UILabel>(); for(int32_t y = 0; y < 2; y++) {
label->font = &this->game->assetManager.get<TrueTypeAsset>("truetype_bizudp")->font; auto labelItem = this->createSceneItem();
label->text = "Hello World"; auto label = labelItem->addComponent<UILabel>();
label->fontSize = 36.0f; auto labelMenuItem = labelItem->addComponent<UISimpleMenuItem>();
labelItem->transform.setParent(canvas->transform);
label->alignX = UI_COMPONENT_ALIGN_MIDDLE; label->font = &this->game->assetManager.get<TrueTypeAsset>("truetype_bizudp")->font;
label->alignY = UI_COMPONENT_ALIGN_MIDDLE; label->text = "Item " + std::to_string(x) + ", " + std::to_string(y);
label->alignment = glm::vec4(0, 0, 350, 100); // label->fontSize = 36.0f;
label->maxWidth = 0; label->fontSize = 1.0f;
labelItem->transform.setParent(canvas->transform);
useEffect([&]{ label->alignment = glm::vec4(label->fontSize * 8 * x, label->fontSize * 1.5f * y, 350, 100);
label->text = "Hello " + std::to_string(test) + " world"; label->maxWidth = 0;
}, test);
labelMenuItem->menuX = x;
labelMenuItem->menuY = y;
useEvent([&](float_t delta){
test = test + 1; useEvent(std::bind([&](UISimpleMenuItem *itm){
}, this->eventSceneUpdate); 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 { std::vector<Asset*> getRequiredAssets() override {
@ -82,6 +95,6 @@ namespace Dawn {
} }
public: public:
TicTacToeScene(DawnGame *game) : Scene(game), test(0) {} TicTacToeScene(DawnGame *game) : Scene(game) {}
}; };
} }