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

Started upgrading things to new state

Browse Source
This commit is contained in:
Dominic Masters
2023-02-27 23:36:03 -08:00
parent 099d9a15c3
commit 4dbd9c4521
19 changed files with 456 additions and 495 deletions
Download Patch File Download Diff File Expand all files Collapse all files

117
src/dawn/scene/components/display/Camera.cpp
View File

@ -9,57 +9,54 @@
using namespace Dawn;
Camera::Camera(SceneItem *item) :
SceneItemComponent(item)
SceneItemComponent(item),
renderTarget(nullptr),
fov(0.785398f),// 45 degrees,
type(CAMERA_TYPE_PERSPECTIVE),
orthoLeft(0.0f),
orthoRight(1.0f),
orthoBottom(0.0f),
orthoTop(1.0f),
clipNear(0.001f),
clipFar(50.0f)
{
this->getRenderTarget()->eventRenderTargetResized.addListener(
this, &Camera::onRenderTargetResize
);
}
void Camera::updateProjection() {
switch(this->type) {
case CAMERA_TYPE_ORTHONOGRAPHIC:
this->projection = glm::ortho(
this->orthoLeft,
this->orthoRight,
this->orthoBottom,
this->orthoTop,
this->clipNear,
this->clipFar
);
break;
glm::mat4 Camera::getProjection() {
if(this->projectionNeedsUpdating) {
switch(this->type) {
case CAMERA_TYPE_ORTHONOGRAPHIC:
this->projection = glm::ortho(
(float_t)this->orthoLeft,
(float_t)this->orthoRight,
(float_t)this->orthoBottom,
(float_t)this->orthoTop,
(float_t)this->clipNear,
(float_t)this->clipFar
);
break;
case CAMERA_TYPE_PERSPECTIVE:
this->projection = glm::perspective(
this->fov,
this->getAspect(),
this->clipNear,
this->clipFar
);
break;
case CAMERA_TYPE_PERSPECTIVE:
this->projection = glm::perspective(
(float_t)this->fov,
this->getAspect(),
(float_t)this->clipNear,
(float_t)this->clipFar
);
break;
}
this->projectionNeedsUpdating = false;
}
return this->projection;
}
RenderTarget * Camera::getRenderTarget() {
if(this->target == nullptr) {
auto v = this->renderTarget;
if(this->renderTarget == nullptr) {
return this->getGame()->renderManager.getBackBuffer();
}
return this->target;
}
void Camera::setRenderTarget(RenderTarget *renderTarget) {
if(renderTarget == this->target) return;
this->getRenderTarget()->eventRenderTargetResized.removeListener(
this, &Camera::onRenderTargetResize
);
this->target = renderTarget;
this->getRenderTarget()->eventRenderTargetResized.addListener(
this, &Camera::onRenderTargetResize
);
this->updateProjection();
this->eventRenderTargetResized.invoke(
renderTarget->getWidth(), renderTarget->getHeight()
);
return (RenderTarget*)this->renderTarget;
}
float_t Camera::getAspect() {
@ -80,12 +77,46 @@ glm::vec3 Camera::getRayDirectionFromScreenSpace(glm::vec2 screenSpace) {
}
void Camera::onStart() {
this->updateProjection();
// Render Target
useEffect(renderTarget, [&]{
if(renderTarget.previous != nullptr) {
renderTarget.previous->eventRenderTargetResized.removeListener(
this, &Camera::onRenderTargetResize
);
}
this->projectionNeedsUpdating = true;
auto rt = this->getRenderTarget();
rt->eventRenderTargetResized.addListener(
this, &Camera::onRenderTargetResize
);
this->eventRenderTargetResized.invoke(
rt->getWidth(), rt->getHeight()
);
this->event2RenderTargetResized.invoke(rt->getWidth(), rt->getHeight());
});
// All regular properties.
auto cbUpdateProj = [&]{
this->projectionNeedsUpdating = true;
};
useEffect(fov, cbUpdateProj);
useEffect(type, cbUpdateProj);
useEffect(orthoLeft, cbUpdateProj);
useEffect(orthoRight, cbUpdateProj);
useEffect(orthoBottom, cbUpdateProj);
useEffect(orthoTop, cbUpdateProj);
useEffect(clipNear, cbUpdateProj);
useEffect(clipFar, cbUpdateProj);
getRenderTarget()->eventRenderTargetResized.addListener(this, &Camera::onRenderTargetResize);
}
void Camera::onRenderTargetResize(RenderTarget *target, float_t w, float_t h) {
this->updateProjection();
this->projectionNeedsUpdating = true;
this->eventRenderTargetResized.invoke(w, h);
this->event2RenderTargetResized.invoke(w, h);
}
void Camera::onDispose() {

41
src/dawn/scene/components/display/Camera.hpp
View File

@ -17,34 +17,32 @@ namespace Dawn {
class Camera : public SceneItemComponent {
protected:
RenderTarget *target = nullptr;
bool_t projectionNeedsUpdating = true;
glm::mat4 projection;
void onRenderTargetResize(RenderTarget *target, float_t w, float_t h);
public:
Event<float_t, float_t> eventRenderTargetResized;
static Camera * create(Scene *scene) {
auto item = scene->createSceneItem();
auto cam = item->addComponent<Camera>();
return cam;
}
glm::mat4 projection;
StateProperty<RenderTarget*> renderTarget;
StateProperty<float_t> fov;
StateProperty<enum CameraType> type;
// Perspective
enum CameraType type = CAMERA_TYPE_PERSPECTIVE;
float_t fov = 0.785398f;// 45 degrees
StateProperty<float_t> orthoLeft;
StateProperty<float_t> orthoRight;
StateProperty<float_t> orthoBottom;
StateProperty<float_t> orthoTop;
// Ortho
float_t orthoLeft = 0.0f;
float_t orthoRight = 1.0f;
float_t orthoBottom = 0.0f;
float_t orthoTop = 1.0f;
StateProperty<float_t> clipNear;
StateProperty<float_t> clipFar;
// Shared
float_t clipNear = 0.001f;
float_t clipFar = 50.0f;
Event<float_t, float_t> eventRenderTargetResized;
StateEvent<float_t, float_t> event2RenderTargetResized;
/**
* Create a new Camera Component.
@ -54,9 +52,11 @@ namespace Dawn {
Camera(SceneItem *item);
/**
* Updates the projection matrix.
* Returns the current projection matrix.
*
* @return Projection matrix for this camera.
*/
void updateProjection();
glm::mat4 getProjection();
/**
* Returns the intended render target for this camera to render to, will
@ -66,13 +66,6 @@ namespace Dawn {
*/
RenderTarget * getRenderTarget();
/**
* Updates the render target for the camera to use.
*
* @param renderTarget Render target for this camera to draw to.
*/
void setRenderTarget(RenderTarget *renderTarget);
/**
* Returs the aspect ratio of the camera.
*

131
src/dawn/scene/components/display/PixelPerfectCamera.cpp
View File

@ -1,68 +1,65 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "PixelPerfectCamera.hpp"
#include "game/DawnGame.hpp"
using namespace Dawn;
PixelPerfectCamera::PixelPerfectCamera(SceneItem *i) : SceneItemComponent(i) {
}
std::vector<SceneItemComponent*> PixelPerfectCamera::getDependencies() {
return std::vector<SceneItemComponent*>{
(this->camera = this->item->getComponent<Camera>())
};
}
void PixelPerfectCamera::onRenderTargetResized(float_t w, float_t h) {
this->updateDimensions();
}
void PixelPerfectCamera::updateDimensions() {
float_t w, h;
assertNotNull(this->camera);
auto target = this->camera->getRenderTarget();
switch(this->camera->type) {
case CAMERA_TYPE_ORTHONOGRAPHIC:
w = target->getWidth() / 2.0f / this->scale;
h = target->getHeight() / 2.0f / this->scale;
camera->orthoLeft = -w;
camera->orthoRight = w;
camera->orthoTop = h;
camera->orthoBottom = -h;
camera->updateProjection();
break;
case CAMERA_TYPE_PERSPECTIVE:
this->transform->lookAtPixelPerfect(
glm::vec3(0, 0, 0),
glm::vec3(0, 0, 0),
target->getHeight() / this->scale,
this->camera->fov
);
// this->transform->lookAt(glm::vec3(360, 360, 360), glm::vec3(0, 0, 0));
break;
default:
assertUnreachable();
}
}
void PixelPerfectCamera::onStart() {
assertNotNull(this->camera);
this->updateDimensions();
camera->eventRenderTargetResized.addListener(
this, &PixelPerfectCamera::onRenderTargetResized
);
}
void PixelPerfectCamera::onDispose() {
camera->eventRenderTargetResized.removeListener(
this, &PixelPerfectCamera::onRenderTargetResized
);
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "PixelPerfectCamera.hpp"
#include "game/DawnGame.hpp"
using namespace Dawn;
PixelPerfectCamera::PixelPerfectCamera(SceneItem *i) :
SceneItemComponent(i),
scale(1.0f)
{
}
std::vector<SceneItemComponent*> PixelPerfectCamera::getDependencies() {
return std::vector<SceneItemComponent*>{
(this->camera = this->item->getComponent<Camera>())
};
}
void PixelPerfectCamera::updateDimensions() {
float_t w, h;
assertNotNull(this->camera);
auto target = this->camera->getRenderTarget();
switch(this->camera->type) {
case CAMERA_TYPE_ORTHONOGRAPHIC:
w = target->getWidth() / 2.0f / (float_t)this->scale;
h = target->getHeight() / 2.0f / (float_t)this->scale;
camera->orthoLeft = -w;
camera->orthoRight = w;
camera->orthoTop = h;
camera->orthoBottom = -h;
break;
case CAMERA_TYPE_PERSPECTIVE:
this->transform->lookAtPixelPerfect(
glm::vec3(0, 0, 0),
glm::vec3(0, 0, 0),
target->getHeight() / this->scale,
this->camera->fov
);
// this->transform->lookAt(glm::vec3(360, 360, 360), glm::vec3(0, 0, 0));
break;
default:
assertUnreachable();
}
}
void PixelPerfectCamera::onStart() {
assertNotNull(this->camera);
this->updateDimensions();
useEvent(this->camera->event2RenderTargetResized, [&](float_t w, float_t h){
this->updateDimensions();
});
useEffect(scale, [&]{
this->updateDimensions();
});
}

65
src/dawn/scene/components/display/PixelPerfectCamera.hpp
View File

@ -1,35 +1,32 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "Camera.hpp"
namespace Dawn {
class PixelPerfectCamera : public SceneItemComponent {
protected:
Camera *camera = nullptr;
/** Event for when the render target is resized. */
void onRenderTargetResized(float_t w, float_t h);
/**
* Updates the underlying camera's projection information.
*/
void updateDimensions();
public:
float_t scale = 1.0f;
/**
* Create a new PixelPerfectCamera Component.
*
* @param item Item that this component belongs to.
*/
PixelPerfectCamera(SceneItem *item);
std::vector<SceneItemComponent*> getDependencies() override;
void onStart() override;
void onDispose() override;
};
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "Camera.hpp"
namespace Dawn {
class PixelPerfectCamera : public SceneItemComponent {
protected:
Camera *camera = nullptr;
/**
* Updates the underlying camera's projection information.
*/
void updateDimensions();
public:
StateProperty<float_t> scale;
/**
* Create a new PixelPerfectCamera Component.
*
* @param item Item that this component belongs to.
*/
PixelPerfectCamera(SceneItem *item);
std::vector<SceneItemComponent*> getDependencies() override;
void onStart() override;
};
}

70
src/dawn/scene/components/display/SimpleRenderTargetQuad.cpp
View File

@ -8,7 +8,8 @@
using namespace Dawn;
SimpleRenderTargetQuad::SimpleRenderTargetQuad(SceneItem *i) :
SceneItemComponent(i)
SceneItemComponent(i),
renderTarget(nullptr)
{
}
@ -16,36 +17,19 @@ void SimpleRenderTargetQuad::onRenderTargetResized(
RenderTarget *target, float_t w, float_t h
) {
assertTrue(target == this->renderTarget);
// Update mesh
QuadMesh::bufferQuadMesh(
&this->meshHost->mesh,
glm::vec2(0, 0), glm::vec2(0, 0),
glm::vec2(w, h), glm::vec2(1, 1),
glm::vec2(
((RenderTarget*)this->renderTarget)->getWidth(),
((RenderTarget*)this->renderTarget)->getHeight()
),
glm::vec2(1, 1),
0, 0
);
}
void SimpleRenderTargetQuad::setRenderTarget(RenderTarget *rt) {
assertTrue(rt != this->renderTarget);
// Remove old event listener
if(this->renderTarget != nullptr) {
this->renderTarget->eventRenderTargetResized.removeListener(
this, &SimpleRenderTargetQuad::onRenderTargetResized
);
}
this->renderTarget = rt;
// Add new event listener.
if(rt != nullptr) {
rt->eventRenderTargetResized.addListener(
this, &SimpleRenderTargetQuad::onRenderTargetResized
);
}
}
std::vector<SceneItemComponent*> SimpleRenderTargetQuad::getDependencies() {
return std::vector<SceneItemComponent*>{
(this->meshHost = this->item->getComponent<MeshHost>())
@ -57,15 +41,43 @@ void SimpleRenderTargetQuad::onStart() {
// Create quad mesh
this->meshHost->mesh.createBuffers(QUAD_VERTICE_COUNT, QUAD_INDICE_COUNT);
useEffect(this->renderTarget, [&]{
if(this->renderTarget.previous != nullptr) {
this->renderTarget.previous->eventRenderTargetResized.addListener(
this, &SimpleRenderTargetQuad::onRenderTargetResized
);
}
if(this->renderTarget == nullptr) return;
// Update mesh
QuadMesh::bufferQuadMesh(
&this->meshHost->mesh,
glm::vec2(0, 0), glm::vec2(0, 0),
glm::vec2(
((RenderTarget*)this->renderTarget)->getWidth(),
((RenderTarget*)this->renderTarget)->getHeight()
),
glm::vec2(1, 1),
0, 0
);
((RenderTarget*)this->renderTarget)->eventRenderTargetResized.addListener(
this, &SimpleRenderTargetQuad::onRenderTargetResized
);
});
// Perform first resize.
if(this->renderTarget != nullptr) {
QuadMesh::bufferQuadMesh(
&this->meshHost->mesh,
glm::vec2(0, 0),
glm::vec2(0, 0),
glm::vec2(this->renderTarget->getWidth(), this->renderTarget->getHeight()),
glm::vec2(1,1),
glm::vec2(0, 0), glm::vec2(0, 0),
glm::vec2(
((RenderTarget*)this->renderTarget)->getWidth(),
((RenderTarget*)this->renderTarget)->getHeight()
),
glm::vec2(1, 1),
0, 0
);
}
@ -73,7 +85,7 @@ void SimpleRenderTargetQuad::onStart() {
void SimpleRenderTargetQuad::onDispose() {
if(this->renderTarget != nullptr) {
this->renderTarget->eventRenderTargetResized.removeListener(
((RenderTarget*)this->renderTarget)->eventRenderTargetResized.removeListener(
this, &SimpleRenderTargetQuad::onRenderTargetResized
);
}

73
src/dawn/scene/components/display/SimpleRenderTargetQuad.hpp
View File

@ -1,41 +1,34 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "scene/components/display/MeshHost.hpp"
#include "display/RenderTarget.hpp"
#include "display/mesh/QuadMesh.hpp"
namespace Dawn {
class SimpleRenderTargetQuad : public SceneItemComponent {
protected:
MeshHost *meshHost = nullptr;
RenderTarget *renderTarget = nullptr;
void onRenderTargetResized(RenderTarget *target, float_t w, float_t h);
public:
/**
* Creates a SimpleRenderTargetQuad scene item component. This component
* will update the attached MeshHost any time the render target provided
* is updated / resized.
*
* @param item Item that this component is attached to.
*/
SimpleRenderTargetQuad(SceneItem *item);
/**
* Sets the render target to use for this quad. Can be set to nullptr when
* you no longer wish to listen for resize events.
*
* @param rt Render target to attach to.
*/
void setRenderTarget(RenderTarget *rt);
std::vector<SceneItemComponent*> getDependencies() override;
void onStart() override;
void onDispose() override;
};
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "scene/components/display/MeshHost.hpp"
#include "display/RenderTarget.hpp"
#include "display/mesh/QuadMesh.hpp"
namespace Dawn {
class SimpleRenderTargetQuad : public SceneItemComponent {
protected:
MeshHost *meshHost = nullptr;
void onRenderTargetResized(RenderTarget *target, float_t w, float_t h);
public:
StateProperty<RenderTarget*> renderTarget;
/**
* Creates a SimpleRenderTargetQuad scene item component. This component
* will update the attached MeshHost any time the render target provided
* is updated / resized.
*
* @param item Item that this component is attached to.
*/
SimpleRenderTargetQuad(SceneItem *item);
std::vector<SceneItemComponent*> getDependencies() override;
void onStart() override;
void onDispose() override;
};
}

174
src/dawn/scene/components/display/TiledSprite.hpp
View File

@ -1,88 +1,88 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "scene/SceneItemComponent.hpp"
#include "scene/components/display/MeshRenderer.hpp"
#include "scene/components/display/MeshHost.hpp"
#include "display/mesh/QuadMesh.hpp"
#include "display/Tileset.hpp"
#define TILED_SPRITE_FLIP_Y FLAG_DEFINE(0)
#define TILED_SPRITE_FLIP_X FLAG_DEFINE(1)
namespace Dawn {
class TiledSprite : public SceneItemComponent {
protected:
MeshHost *host = nullptr;
Tileset *tileset = nullptr;
flag_t flipState = TILED_SPRITE_FLIP_Y;
int32_t tileIndex = -1;
glm::vec2 xy0 = glm::vec2(0, 0);
glm::vec2 xy1 = glm::vec2(1, 1);
glm::vec2 getUV0();
glm::vec2 getUV1();
public:
TiledSprite(SceneItem *item);
std::vector<SceneItemComponent*> getDependencies() override;
void onStart() override;
/**
* Sets which tileset to use for this sprite.
*
* @param tileset Tileset to use.
*/
void setTileset(Tileset *tileset);
/**
* Sets the tileset for the sprite, and autosizes the sprite based on
* this tileset.
*
* @param gridTileset Tileset to use.
* @param center The center offset of the sprite.
*/
void setTilesetAndSize(TilesetGrid *gridTileset, glm::vec2 center);
/**
* Sets the tileset for the sprite, and autosizes the sprite based on
* this tileset. This will put the sprite centered on its origin.
*
* @param gridTileset Tileset to use.
*/
void setTilesetAndSize(TilesetGrid *gridTileset);
/**
* Updates the selected tile.
*
* @param tile Tile to use.
*/
void setTile(int32_t tile);
/**
* Adjust how the sprite is flippxed.
*
* @param flippedState Flipped axis flags.
*/
void setFlippedState(flag_t flippedState);
/**
* Sets the dimensions of this tiled sprite.
*
* @param size Size of the sprite.
* @param center Negative center offset.
*/
void setSize(glm::vec2 size, glm::vec2 center);
/**
* Sets the size of this sprite. This will center the sprite on its origin
*
* @param size Size of the sprite.
*/
void setSize(glm::vec2 size);
};
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "scene/SceneItemComponent.hpp"
#include "scene/components/display/MeshRenderer.hpp"
#include "scene/components/display/MeshHost.hpp"
#include "display/mesh/QuadMesh.hpp"
#include "display/Tileset.hpp"
#define TILED_SPRITE_FLIP_Y FLAG_DEFINE(0)
#define TILED_SPRITE_FLIP_X FLAG_DEFINE(1)
namespace Dawn {
class TiledSprite : public SceneItemComponent {
protected:
MeshHost *host = nullptr;
Tileset *tileset = nullptr;
flag_t flipState = TILED_SPRITE_FLIP_Y;
int32_t tileIndex = -1;
glm::vec2 xy0 = glm::vec2(0, 0);
glm::vec2 xy1 = glm::vec2(1, 1);
glm::vec2 getUV0();
glm::vec2 getUV1();
public:
TiledSprite(SceneItem *item);
std::vector<SceneItemComponent*> getDependencies() override;
void onStart() override;
/**
* Sets which tileset to use for this sprite.
*
* @param tileset Tileset to use.
*/
void setTileset(Tileset *tileset);
/**
* Sets the tileset for the sprite, and autosizes the sprite based on
* this tileset.
*
* @param gridTileset Tileset to use.
* @param center The center offset of the sprite.
*/
void setTilesetAndSize(TilesetGrid *gridTileset, glm::vec2 center);
/**
* Sets the tileset for the sprite, and autosizes the sprite based on
* this tileset. This will put the sprite centered on its origin.
*
* @param gridTileset Tileset to use.
*/
void setTilesetAndSize(TilesetGrid *gridTileset);
/**
* Updates the selected tile.
*
* @param tile Tile to use.
*/
void setTile(int32_t tile);
/**
* Adjust how the sprite is flippxed.
*
* @param flippedState Flipped axis flags.
*/
void setFlippedState(flag_t flippedState);
/**
* Sets the dimensions of this tiled sprite.
*
* @param size Size of the sprite.
* @param center Negative center offset.
*/
void setSize(glm::vec2 size, glm::vec2 center);
/**
* Sets the size of this sprite. This will center the sprite on its origin
*
* @param size Size of the sprite.
*/
void setSize(glm::vec2 size);
};
}

2
src/dawn/scene/debug/SceneDebugLine.cpp
View File

@ -25,7 +25,7 @@ struct ShaderPassItem SceneDebugLine::createShaderItem(
item.colorValues[shader->program.paramColor] = this->color;
item.matrixValues[shader->program.paramModel] = this->transform;
item.matrixValues[shader->program.paramView] = camera->transform->getWorldTransform();
item.matrixValues[shader->program.paramProjection] = camera->projection;
item.matrixValues[shader->program.paramProjection] = camera->getProjection();
item.boolValues[shader->program.paramHasTexture] = false;
auto i = *lineIndex;