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

Added basic debug lines

Browse Source
This commit is contained in:
Dominic Masters
2023-02-22 13:41:52 -08:00
parent c065ab08b3
commit 389a290362
15 changed files with 357 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
cmake/CMakeLists.txt
View File

@ -1,7 +1,15 @@
# Copyright (c) 2022 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
add_subdirectory(hosts)
# Copyright (c) 2022 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Defines
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
set(DAWN_DEBUG_BUILD true CACHE INTERNAL ${DAWN_CACHE_TARGET})
else()
set(DAWN_DEBUG_BUILD false CACHE INTERNAL ${DAWN_CACHE_TARGET})
endif()
# Includes
add_subdirectory(hosts)
add_subdirectory(targets)

9
src/dawn/CMakeLists.txt
View File

@ -38,4 +38,11 @@ add_subdirectory(ui)
if(DAWN_VISUAL_NOVEL)
add_subdirectory(visualnovel)
endif()
endif()
# Definitions
target_compile_definitions(${DAWN_TARGET_NAME}
PUBLIC
${DAWN_SHARED_DEFINITIONS}
DAWN_DEBUG_BUILD=${DAWN_DEBUG_BUILD}
)

31
src/dawn/display/RenderPipeline.cpp
View File

@ -6,6 +6,10 @@
#include "RenderPipeline.hpp"
#include "game/DawnGame.hpp"
#if DAWN_DEBUG_BUILD
#include "scene/debug/SceneDebugLine.hpp"
#endif
using namespace Dawn;
RenderPipeline::RenderPipeline(RenderManager *renderManager) {
@ -159,6 +163,27 @@ void RenderPipeline::renderSceneCamera(Scene *scene, Camera *camera) {
++itCanvas;
}
// Debug Lines
#if DAWN_DEBUG_BUILD
Mesh lineMesh;
int32_t lineIndex = 0;
lineMesh.createBuffers(
scene->debugLines.size() * SCENE_DEBUG_LINE_VERTICE_COUNT,
scene->debugLines.size() * SCENE_DEBUG_LINE_INDICE_COUNT
);
auto itDebugLine = scene->debugLines.begin();
while(itDebugLine != scene->debugLines.end()) {
auto item = itDebugLine->createShaderItem(
&lineMesh,
&lineIndex,
camera,
&this->renderManager->simpleShader
);
shaderPassItems.push_back(item);
++itDebugLine;
}
#endif
// Now we've queued everything, let's sort the rendering queue by the priority
std::sort(
shaderPassItems.begin(),
@ -246,11 +271,7 @@ void RenderPipeline::renderSceneCamera(Scene *scene, Camera *camera) {
this->renderManager->setRenderFlags(item.renderFlags);
// Thank god that's done, now just draw the damn mesh.
item.mesh->draw(
MESH_DRAW_MODE_TRIANGLES,
item.start,
item.count
);
item.mesh->draw(item.drawMode, item.start, item.count);
++itPassItem;
}
}

1
src/dawn/display/RenderPipeline.hpp
View File

@ -11,6 +11,7 @@
#include "scene/components/scene/SubSceneController.hpp"
#include "ui/UIComponent.hpp"
namespace Dawn {
class RenderManager;

124
src/dawn/display/shader/Shader.hpp
View File

@ -1,62 +1,64 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "display/shader/ShaderProgram.hpp"
#include "scene/components/display/MeshRenderer.hpp"
#include "scene/components/display/Camera.hpp"
#include "display/_RenderManager.hpp"
namespace Dawn {
class Material;
struct ShaderPassItem {
ShaderProgram *shaderProgram = nullptr;
int32_t priority = 0;
Mesh *mesh;
int32_t start = 0;
int32_t count = -1;
float_t w = 0;
renderflag_t renderFlags = RENDER_MANAGER_RENDER_FLAG_DEPTH_TEST;
// Parameters
std::map<shaderparameter_t, struct Color> colorValues;
std::map<shaderparameter_t, bool_t> boolValues;
std::map<shaderparameter_t, glm::mat4> matrixValues;
std::map<shaderparameter_t, glm::vec3> vec3Values;
std::map<shaderparameter_t, textureslot_t> textureValues;
std::map<shaderparameter_t, float_t> floatValues;
// Textures
std::map<textureslot_t, Texture*> textureSlots;
};
class Shader {
public:
int_fast16_t renderId = 0;
/**
* Compile all programs for this shader. This amy not remain forever as I
* may decide to allow shaders to share programs somehow. For now though
* this is clean enough.
*/
virtual void compile() = 0;
/**
* Returns the list of pass items to render for the given scene item.
*
* @param mesh Mesh Renderer for the scene item.
* @param material Material for the scene item.
* @param camera Camera for the scene.
* @return List of passes to render.
*/
virtual std::vector<struct ShaderPassItem> getPassItems(
Mesh *mesh,
Material *material,
Camera *camera
) = 0;
};
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "display/shader/ShaderProgram.hpp"
#include "display/mesh/Mesh.hpp"
#include "display/_RenderManager.hpp"
namespace Dawn {
class Material;
class MeshRenderer;
class Camera;
struct ShaderPassItem {
ShaderProgram *shaderProgram = nullptr;
int32_t priority = 0;
Mesh *mesh;
int32_t start = 0;
int32_t count = -1;
float_t w = 0;
renderflag_t renderFlags = RENDER_MANAGER_RENDER_FLAG_DEPTH_TEST;
enum MeshDrawMode drawMode = MESH_DRAW_MODE_TRIANGLES;
// Parameters
std::map<shaderparameter_t, struct Color> colorValues;
std::map<shaderparameter_t, bool_t> boolValues;
std::map<shaderparameter_t, glm::mat4> matrixValues;
std::map<shaderparameter_t, glm::vec3> vec3Values;
std::map<shaderparameter_t, textureslot_t> textureValues;
std::map<shaderparameter_t, float_t> floatValues;
// Textures
std::map<textureslot_t, Texture*> textureSlots;
};
class Shader {
public:
int_fast16_t renderId = 0;
/**
* Compile all programs for this shader. This amy not remain forever as I
* may decide to allow shaders to share programs somehow. For now though
* this is clean enough.
*/
virtual void compile() = 0;
/**
* Returns the list of pass items to render for the given scene item.
*
* @param mesh Mesh Renderer for the scene item.
* @param material Material for the scene item.
* @param camera Camera for the scene.
* @return List of passes to render.
*/
virtual std::vector<struct ShaderPassItem> getPassItems(
Mesh *mesh,
Material *material,
Camera *camera
) = 0;
};
}

2
src/dawn/prefabs/SimpleSpinningCubePrefab.hpp
View File

@ -31,7 +31,7 @@ namespace Dawn {
void prefabInit(AssetManager *man) override {
auto meshRenderer = this->addComponent<MeshRenderer>();
meshHost = this->addComponent<MeshHost>();
// auto spinning = this->addComponent<ExampleSpin>();
auto spinning = this->addComponent<ExampleSpin>();
material = this->addComponent<SimpleTexturedMaterial>();
meshHost->mesh.createBuffers(CUBE_VERTICE_COUNT, CUBE_INDICE_COUNT);

34
src/dawn/scene/CMakeLists.txt
View File

@ -1,15 +1,19 @@
# 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
Scene.cpp
SceneItem.cpp
SceneItemComponent.cpp
)
# Subdirs
add_subdirectory(components)
# 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
Scene.cpp
SceneItem.cpp
SceneItemComponent.cpp
)
# Subdirs
add_subdirectory(components)
if(DAWN_DEBUG_BUILD)
add_subdirectory(debug)
endif()

10
src/dawn/scene/Scene.hpp
View File

@ -6,6 +6,7 @@
#pragma once
#include "event/Event.hpp"
#include "asset/Asset.hpp"
#include "scene/debug/SceneDebugLine.hpp"
namespace Dawn {
class DawnGame;
@ -23,7 +24,7 @@ namespace Dawn {
sceneitemid_t nextId;
std::map<sceneitemid_t, SceneItem*> items;
std::map<sceneitemid_t, SceneItem*> itemsNotInitialized;
public:
DawnGame *game;
Event<> eventSceneUpdate;
@ -130,6 +131,13 @@ namespace Dawn {
return components;
}
// Scene debugging functions
#if DAWN_DEBUG_BUILD
std::vector<struct SceneDebugLine> debugLines;
void debugLine(struct SceneDebugLine line);
void debugCube(struct SceneDebugCube cube);
#endif
/**
* Destroys a previously initialized Scene.
*/

10
src/dawn/scene/debug/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Sources
target_sources(${DAWN_TARGET_NAME}
PRIVATE
SceneDebugLine.cpp
)

100
src/dawn/scene/debug/SceneDebugLine.cpp Normal file
View File

@ -0,0 +1,100 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "SceneDebugLine.hpp"
#include "display/shader/SimpleTexturedShader.hpp"
#include "scene/components/display/Camera.hpp"
#include "scene/Scene.hpp"
using namespace Dawn;
struct ShaderPassItem SceneDebugLine::createShaderItem(
Mesh *mesh,
int32_t *lineIndex,
Camera *camera,
SimpleTexturedShader *shader
) {
struct ShaderPassItem item;
item.priority = SCENE_DEBUG_LINE_PRIORITY;
item.shaderProgram = &shader->program;
item.colorValues[shader->program.paramColor] = this->color;
item.matrixValues[shader->program.paramModel] = this->translation;
item.matrixValues[shader->program.paramView] = camera->transform->getWorldTransform();
item.matrixValues[shader->program.paramProjection] = camera->projection;
item.boolValues[shader->program.paramHasTexture] = false;
item.renderFlags = 0x00;
auto i = *lineIndex;
item.mesh = mesh;
item.drawMode = MESH_DRAW_MODE_LINES;
item.start = i * SCENE_DEBUG_LINE_INDICE_COUNT;
item.count = SCENE_DEBUG_LINE_INDICE_COUNT;
glm::vec3 positions[SCENE_DEBUG_LINE_VERTICE_COUNT] = { this->v0, this->v1 };
mesh->bufferPositions(
i * SCENE_DEBUG_LINE_VERTICE_COUNT,
positions,
SCENE_DEBUG_LINE_VERTICE_COUNT
);
meshindice_t indices[SCENE_DEBUG_LINE_INDICE_COUNT] = {
i * SCENE_DEBUG_LINE_VERTICE_COUNT,
(i*SCENE_DEBUG_LINE_VERTICE_COUNT) + 1
};
mesh->bufferIndices(
i * SCENE_DEBUG_LINE_INDICE_COUNT,
indices,
SCENE_DEBUG_LINE_INDICE_COUNT
);
(*lineIndex)++;
return item;
}
// Scene Implementations (done here to keep things cleaner in scene)
void Scene::debugLine(struct SceneDebugLine line) {
this->debugLines.push_back(line);
}
void Scene::debugCube(struct SceneDebugCube cube) {
auto min = cube.min;
auto max = cube.max;
struct SceneDebugLine line;
line.color = cube.color;
line.translation = cube.translation;
// Bottom Face
line.v0 = glm::vec3(min.x, min.y, min.z), line.v1 = glm::vec3(max.x, min.y, min.z);
this->debugLine(line);
line.v0 = glm::vec3(min.x, min.y, min.z), line.v1 = glm::vec3(min.x, min.y, max.z);
this->debugLine(line);
line.v0 = glm::vec3(max.x, min.y, min.z), line.v1 = glm::vec3(max.x, min.y, max.z);
this->debugLine(line);
line.v0 = glm::vec3(min.x, min.y, max.z), line.v1 = glm::vec3(max.x, min.y, max.z);
this->debugLine(line);
// Top Face
line.v0 = glm::vec3(min.x, max.y, min.z), line.v1 = glm::vec3(max.x, max.y, min.z);
this->debugLine(line);
line.v0 = glm::vec3(min.x, max.y, min.z), line.v1 = glm::vec3(min.x, max.y, max.z);
this->debugLine(line);
line.v0 = glm::vec3(max.x, max.y, min.z), line.v1 = glm::vec3(max.x, max.y, max.z);
this->debugLine(line);
line.v0 = glm::vec3(min.x, max.y, max.z), line.v1 = glm::vec3(max.x, max.y, max.z);
this->debugLine(line);
// Rails
line.v0 = glm::vec3(min.x, min.y, min.z), line.v1 = glm::vec3(min.x, max.y, min.z);
this->debugLine(line);
line.v0 = glm::vec3(max.x, min.y, min.z), line.v1 = glm::vec3(max.x, max.y, min.z);
this->debugLine(line);
line.v0 = glm::vec3(min.x, min.y, max.z), line.v1 = glm::vec3(min.x, max.y, max.z);
this->debugLine(line);
line.v0 = glm::vec3(max.x, min.y, max.z), line.v1 = glm::vec3(max.x, max.y, max.z);
this->debugLine(line);
}

48
src/dawn/scene/debug/SceneDebugLine.hpp Normal file
View File

@ -0,0 +1,48 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "display/Color.hpp"
#include "display/mesh/Mesh.hpp"
#include "display/shader/Shader.hpp"
#define SCENE_DEBUG_LINE_VERTICE_COUNT 2
#define SCENE_DEBUG_LINE_INDICE_COUNT 2
#define SCENE_DEBUG_LINE_PRIORITY 100
namespace Dawn {
class SimpleTexturedShader;
class Camera;
struct SceneDebugCube {
glm::vec3 min;
glm::vec3 max;
struct Color color = COLOR_RED;
glm::mat4 translation = glm::mat4(1.0f);
};
struct SceneDebugLine {
glm::vec3 v0 = glm::vec3(0, 0, 0);
glm::vec3 v1 = glm::vec3(1, 1, 1);
struct Color color = COLOR_RED;
glm::mat4 translation = glm::mat4(1.0f);
/**
* Creates a renderable shader item for this debug line.
*
* @param mesh Mesh that this debug line will buffer its indices in to
* @param lineIndex Currently iterated line index.
* @param camera Camera for this line index to set the shader params for.
* @param shader Shader that the params will be set for.
* @return The queueable shader pass item.
*/
struct ShaderPassItem createShaderItem(
Mesh *mesh,
int32_t *lineIndex,
Camera *camera,
SimpleTexturedShader *shader
);
};
}

3
src/dawnopengl/display/mesh/Mesh.hpp
View File

@ -13,7 +13,8 @@ typedef int32_t meshindice_t;
namespace Dawn {
enum MeshDrawMode {
MESH_DRAW_MODE_TRIANGLES = GL_TRIANGLES
MESH_DRAW_MODE_TRIANGLES = GL_TRIANGLES,
MESH_DRAW_MODE_LINES = GL_LINES
};
class Mesh {

90
src/dawnopengl/display/shader/SimpleTexturedShader.cpp
View File

@ -1,45 +1,47 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "SimpleTexturedShader.hpp"
using namespace Dawn;
void SimpleTexturedShader::compile() {
this->program.compile();
}
std::vector<struct ShaderPassItem> SimpleTexturedShader::getPassItems(
Mesh *mesh,
Material *material,
Camera *camera
) {
SimpleTexturedMaterial *simpleMaterial = dynamic_cast<SimpleTexturedMaterial*>(material);
assertNotNull(simpleMaterial);
struct ShaderPassItem onlyPass;
onlyPass.mesh = mesh;
onlyPass.shaderProgram = &program;
onlyPass.colorValues[program.paramColor] = simpleMaterial->color;
onlyPass.matrixValues[program.paramModel] = material->transform->getWorldTransform();
onlyPass.matrixValues[program.paramView] = camera->transform->getWorldTransform();
onlyPass.matrixValues[program.paramProjection] = camera->projection;
onlyPass.renderFlags = (
RENDER_MANAGER_RENDER_FLAG_BLEND |
RENDER_MANAGER_RENDER_FLAG_DEPTH_TEST
);
if(simpleMaterial->texture != nullptr) {
onlyPass.boolValues[program.paramHasTexture] = true;
onlyPass.textureSlots[0] = simpleMaterial->texture;
onlyPass.textureValues[program.paramTexture] = 0;
} else {
onlyPass.boolValues[program.paramHasTexture] = false;
}
std::vector<struct ShaderPassItem> passes;
passes.push_back(onlyPass);
return passes;
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "SimpleTexturedShader.hpp"
#include "scene/components/display/MeshRenderer.hpp"
#include "scene/components/display/Camera.hpp"
using namespace Dawn;
void SimpleTexturedShader::compile() {
this->program.compile();
}
std::vector<struct ShaderPassItem> SimpleTexturedShader::getPassItems(
Mesh *mesh,
Material *material,
Camera *camera
) {
SimpleTexturedMaterial *simpleMaterial = dynamic_cast<SimpleTexturedMaterial*>(material);
assertNotNull(simpleMaterial);
struct ShaderPassItem onlyPass;
onlyPass.mesh = mesh;
onlyPass.shaderProgram = &program;
onlyPass.colorValues[program.paramColor] = simpleMaterial->color;
onlyPass.matrixValues[program.paramModel] = material->transform->getWorldTransform();
onlyPass.matrixValues[program.paramView] = camera->transform->getWorldTransform();
onlyPass.matrixValues[program.paramProjection] = camera->projection;
onlyPass.renderFlags = (
RENDER_MANAGER_RENDER_FLAG_BLEND |
RENDER_MANAGER_RENDER_FLAG_DEPTH_TEST
);
if(simpleMaterial->texture != nullptr) {
onlyPass.boolValues[program.paramHasTexture] = true;
onlyPass.textureSlots[0] = simpleMaterial->texture;
onlyPass.textureValues[program.paramTexture] = 0;
} else {
onlyPass.boolValues[program.paramHasTexture] = false;
}
std::vector<struct ShaderPassItem> passes;
passes.push_back(onlyPass);
return passes;
}

3
src/dawnopengl/display/shader/SimpleTexturedShader.hpp
View File

@ -10,10 +10,9 @@
namespace Dawn {
class SimpleTexturedShader : public Shader {
protected:
public:
SimpleTexturedShaderProgram program;
public:
void compile() override;
std::vector<struct ShaderPassItem> getPassItems(

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

@ -17,8 +17,9 @@ namespace Dawn {
void stage() override {
camera = Camera::create(this);
camera->transform->lookAt(glm::vec3(0, 0, 5), glm::vec3(0, 0, 0));
camera->type = CAMERA_TYPE_ORTHONOGRAPHIC;
// camera->transform->lookAt(glm::vec3(0, 0, 5), glm::vec3(0, 0, 0));
// camera->type = CAMERA_TYPE_ORTHONOGRAPHIC;
camera->transform->lookAt(glm::vec3(1, 2, 3), glm::vec3(0, 0, 0));
float_t s = 2.0f;
camera->orthoTop = -s;
@ -43,6 +44,12 @@ namespace Dawn {
// tile->ticTacToe->setState(i % 2 == 0 ? TIC_TAC_TOE_CROSS : TIC_TAC_TOE_NOUGHT);
}
}
this->debugCube((struct SceneDebugCube){
.min = glm::vec3(-0.5f, -0.5f, -0.5f),
.max = glm::vec3(0.5f, 0.5f, 0.5f),
COLOR_BLUE
});
}
std::vector<Asset*> getRequiredAssets() override {