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

Bit of cleanup.

Browse Source
This commit is contained in:
Dominic Masters
2023-11-01 23:08:20 -05:00
parent 0356f8fc6e
commit e88ca80265
32 changed files with 212 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/dawn/asset/AssetManager.cpp
View File

@ -16,7 +16,11 @@ void AssetManager::update() {
}
void AssetManager::queueLoad(std::vector<Asset*> assets) {
vectorAppend(&this->assetsToLoad, &assets);
std::merge(
this->assetsToLoad.begin(), this->assetsToLoad.end(),
assets.begin(), assets.end(),
this->assetsToLoad.begin()
);
}
void AssetManager::queueLoad(Asset *asset) {
@ -24,12 +28,20 @@ void AssetManager::queueLoad(Asset *asset) {
}
void AssetManager::queueUnload(std::vector<Asset*> assets) {
std::cout << "Asset list was queued to unload, but is not yet implemented" << std::endl;
vectorAppend(&this->assetsToUnload, &assets);
std::cout <<
"Asset list was queued to unload, but is not yet implemented" <<
std::endl;
std::merge(
this->assetsToUnload.begin(), this->assetsToUnload.end(),
assets.begin(), assets.end(),
this->assetsToUnload.begin()
);
}
void AssetManager::queueUnload(Asset *asset) {
std::cout << "Asset was queued to unload, but is not yet implemented" << std::endl;
std::cout <<
"Asset was queued to unload, but is not yet implemented" <<
std::endl;
this->assetsToUnload.push_back(asset);
}

5
src/dawn/asset/AssetManager.hpp
View File

@ -5,7 +5,6 @@
#pragma once
#include "Asset.hpp"
#include "util/array.hpp"
namespace Dawn {
class AssetManager {
@ -73,7 +72,9 @@ namespace Dawn {
*/
template<class T>
T * get(std::string name) {
assertTrue(name.size() > 0, "AssetManager::get: name must be greater than 0");
assertTrue(
name.size() > 0, "AssetManager::get: name must be greater than 0"
);
auto existing = this->assets.find(name);
if(existing != this->assets.end()) {

10
src/dawn/asset/IAssetLoader.cpp
View File

@ -8,12 +8,18 @@
using namespace Dawn;
IAssetLoader::IAssetLoader(std::string fileName) {
assertTrue(fileName.size() > 0, "IAssetLoader::IAssetLoader: fileName must be greater than 0");
assertTrue(
fileName.size() > 0,
"IAssetLoader::IAssetLoader: fileName must be greater than 0"
);
this->fileName = fileName;
}
size_t IAssetLoader::setPosition(size_t position) {
assertTrue(position >= 0, "IAssetLoader::setPosition: position must be greater than or equal to 0");
assertTrue(
position >= 0,
"IAssetLoader::setPosition: position must be greater than or equal to 0"
);
this->rewind();
return this->skip(position);
}

1
src/dawn/asset/assets/TextureAsset.cpp
View File

@ -4,6 +4,7 @@
// https://opensource.org/licenses/MIT
#include "TextureAsset.hpp"
#include "util/memory.hpp"
using namespace Dawn;

22
src/dawn/asset/assets/TrueTypeAsset.cpp
View File

@ -24,24 +24,24 @@ TrueTypeAsset::TrueTypeAsset(AssetManager *assMan, std::string name) :
lbt.erase(it0);
auto it1 = this->textureByLock.find(id);
assertTrue(it1 != this->textureByLock.end(), "Could not remove textureByLock");
assertTrue(
it1 != this->textureByLock.end(), "Could not remove textureByLock"
);
this->textureByLock.erase(it1);
if(lbt.empty()) {
auto it2 = locksByTexture.find(texture);
assertTrue(it2 != locksByTexture.end(), "Could not remove locksByTexture");
assertTrue(
it2 != locksByTexture.end(), "Could not remove locksByTexture"
);
locksByTexture.erase(it2);
auto it3 = textureByStyle.begin();
while(it3 != textureByStyle.end()) {
if(it3->second == texture) it3 = textureByStyle.erase(it3);
++it3;
}
auto it4 = std::find(textures.begin(), textures.end(), texture);
assertTrue(it4 != textures.end(), "Could not remove textureByStyle");
textures.erase(it4);
std::erase_if(textureByStyle, [&](const auto &item){
auto const& [key, value] = item;
return value == texture;
});
std::erase(textures, texture);
delete texture;
}
};

4
src/dawn/asset/assets/TrueTypeAsset.hpp
View File

@ -38,7 +38,9 @@ namespace Dawn {
std::vector<struct TrueTypeAssetStyle> assetStyles;
std::vector<TrueTypeFaceTexture*> textures;
std::map<usagelockid_t, TrueTypeFaceTexture*> textureByLock;
std::map<struct TrueTypeFaceTextureStyle, TrueTypeFaceTexture*> textureByStyle;
std::map<struct TrueTypeFaceTextureStyle, TrueTypeFaceTexture*>
textureByStyle
;
std::map<TrueTypeFaceTexture*, std::vector<usagelockid_t>> locksByTexture;
public:

0
src/dawn/display/_RenderManager.hpp → src/dawn/display/IRenderManager.hpp
View File

0
src/dawn/display/_Texture.hpp → src/dawn/display/ITexture.hpp
View File

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

@ -4,7 +4,7 @@
// https://opensource.org/licenses/MIT
#pragma once
#include "display/_RenderManager.hpp"
#include "display/IRenderManager.hpp"
#include "display/shader/ShaderPass.hpp"
#include "scene/components/display/IRenderable.hpp"
#include "display/shader/buffers/RenderPipelineShaderBuffer.hpp"

1
src/dawn/display/font/truetype/TrueTypeFaceTexture.cpp
View File

@ -4,6 +4,7 @@
// https://opensource.org/licenses/MIT
#include "TrueTypeFaceTexture.hpp"
#include "util/memory.hpp"
using namespace Dawn;

3
src/dawn/display/shader/_Shader.hpp → src/dawn/display/shader/IShader.hpp
View File

@ -5,7 +5,7 @@
#pragma once
#include "display/mesh/Mesh.hpp"
#include "display/_RenderManager.hpp"
#include "display/IRenderManager.hpp"
#include "display/Texture.hpp"
#include "display/shader/ShaderParameterBuffer.hpp"
@ -82,6 +82,5 @@ namespace Dawn {
* @param Float to bind.
*/
virtual void setFloat(T parameter, float_t value) = 0;
};
}

0
src/dawn/display/shader/_ShaderParameterBuffer.hpp → src/dawn/display/shader/IShaderParameterBuffer.hpp
View File

1
src/dawn/save/SaveManager.cpp
View File

@ -5,6 +5,7 @@
#include "SaveManager.hpp"
#include "game/DawnGame.hpp"
#include "util/memory.hpp"
using namespace Dawn;

4
src/dawn/scene/components/display/Material.cpp
View File

@ -9,4 +9,8 @@
using namespace Dawn;
Material::Material(SceneItem *item) : SceneItemComponent(item) {
}
ShaderManager & Material::getShaderManager() {
return *this->getGame()->renderManager.getShaderManager();
}

6
src/dawn/scene/components/display/Material.hpp
View File

@ -17,5 +17,11 @@ namespace Dawn {
* @param item Scene Item this component belongs to.
*/
Material(SceneItem *item);
/**
* Returns the shader manager for the game.
* @return The shader manager for the game.
*/
ShaderManager & getShaderManager();
};
}

1
src/dawn/scene/components/physics/2d/TriggerController2D.cpp
View File

@ -45,6 +45,7 @@ bool_t TriggerController2D::getCollidingResult(Collider2D* movingObject) {
default: {
assertUnreachable("TriggerController2D::getCollidingResult: Moving object type not implemented");
return false;
}
}
}

14
src/dawnglfw/debug/debug.hpp
View File

@ -1,14 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "dawnlibs.hpp"
// Draws an error message on screen and force closes the app after user input
template<typename... A>
void debugMessage(const char *fmt, A... args) {
printf(fmt, args...);
printf("\n");
}

2
src/dawnliminal/scenes/LoadingScene.hpp
View File

@ -19,7 +19,7 @@ namespace Dawn {
void stage() override {
useEvent([&](float_t delta) {
assertNull(this->instanceOfT, "LoadingScene::stage: Scene already loaded!");
assertNull(this->instanceOfT, "Scene already loaded!");
this->instanceOfT = new T(this->game);
auto assets = this->instanceOfT->getRequiredAssets();
this->game->assetManager.queueLoad(assets);

1
src/dawnlinux64/host/DawnHostTux32.cpp
View File

@ -4,6 +4,7 @@
// https://opensource.org/licenses/MIT
#include "DawnHostTux32.hpp"
#include "util/memory.hpp"
using namespace Dawn;

37
src/dawnopengl/display/RenderManager.cpp
View File

@ -18,21 +18,28 @@ RenderManager::RenderManager(DawnGame *game) :
void RenderManager::init() {
// Lock the common shaders
this->lockSimpleTextured = this->shaderManager.lockShader<SimpleTexturedShader>();
this->simpleTexturedShader = this->shaderManager.getShader<SimpleTexturedShader>(this->lockSimpleTextured);
lockSimpleTextured = shaderManager.lockShader<SimpleTexturedShader>();
simpleTexturedShader = shaderManager.getShader<SimpleTexturedShader>(
lockSimpleTextured
);
this->lockUIShaderProgram = this->shaderManager.lockShader<UIShader>();
this->uiShader = this->shaderManager.getShader<UIShader>(this->lockUIShaderProgram);
lockUIShaderProgram = shaderManager.lockShader<UIShader>();
uiShader = shaderManager.getShader<UIShader>(lockUIShaderProgram);
this->lockFontShader = this->shaderManager.lockShader<FontShader>();
this->fontShader = this->shaderManager.getShader<FontShader>(this->lockFontShader);
this->renderPipeline.init();
lockFontShader = shaderManager.lockShader<FontShader>();
fontShader = shaderManager.getShader<FontShader>(lockFontShader);
renderPipeline.init();
assertNoGLError();
// Prepare the initial values
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
assertNoGLError();
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glBlendFuncSeparate(
GL_SRC_ALPHA,
GL_ONE_MINUS_SRC_ALPHA,
GL_ONE,
GL_ONE_MINUS_SRC_ALPHA
);
assertNoGLError();
glDepthMask(GL_TRUE);
assertNoGLError();
@ -41,19 +48,19 @@ void RenderManager::init() {
}
RenderTarget * RenderManager::getBackBuffer() {
return &this->backBuffer;
return &backBuffer;
}
RenderPipeline * RenderManager::getRenderPipeline() {
return &this->renderPipeline;
return &renderPipeline;
}
ShaderManager * RenderManager::getShaderManager() {
return &this->shaderManager;
return &shaderManager;
}
void RenderManager::setRenderFlags(renderflag_t flags) {
this->renderFlags = flags;
renderFlags = flags;
if((flags & RENDER_MANAGER_RENDER_FLAG_DEPTH_TEST) == 0) {
glDisable(GL_DEPTH_TEST);
@ -75,7 +82,7 @@ void RenderManager::update() {
}
RenderManager::~RenderManager() {
this->shaderManager.releaseShader<SimpleTexturedShader>(this->lockSimpleTextured);
this->shaderManager.releaseShader<UIShader>(this->lockUIShaderProgram);
this->shaderManager.releaseShader<FontShader>(this->lockFontShader);
shaderManager.releaseShader<SimpleTexturedShader>(lockSimpleTextured);
shaderManager.releaseShader<UIShader>(lockUIShaderProgram);
shaderManager.releaseShader<FontShader>(lockFontShader);
}

80
src/dawnopengl/display/Texture.cpp
View File

@ -4,6 +4,8 @@
// https://opensource.org/licenses/MIT
#include "Texture.hpp"
#include "assert/assertgl.hpp"
#include "util/memory.hpp"
using namespace Dawn;
@ -18,7 +20,7 @@ Texture::Texture() : ITexture() {
}
void Texture::bind(textureslot_t slot) {
assertTrue(this->id != -1, "Texture::bind: Texture is not ready!");
assertTrue(this->id != -1, "Texture is not ready!");
glActiveTexture(GL_TEXTURE0 + slot);
assertNoGLError();
glBindTexture(GL_TEXTURE_2D, this->id);
@ -50,12 +52,10 @@ void Texture::setSize(
this->id = -1;
}
#if DAWN_DEBUG_BUILD
int32_t maxSize;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxSize);
assertTrue(width > 0 && width <= maxSize, "Texture::setSize: Width is out of bounds!");
assertTrue(height > 0 && height <= maxSize, "Texture::setSize: Height is out of bounds!");
#endif
int32_t maxSize;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxSize);
assertTrue(width > 0 && width <= maxSize, "Width is out of bounds!");
assertTrue(height > 0 && height <= maxSize, "Height is out of bounds!");
this->width = width;
this->height = height;
@ -64,8 +64,8 @@ void Texture::setSize(
glGenTextures(1, &this->id);
assertNoGLError();
if(this->id <= 0) throw "Texture generation failed!";
if(this->id <= 0) assertUnreachable("Texture generation failed!");
// Initialize the texture to blank
glActiveTexture(GL_TEXTURE0);
assertNoGLError();
@ -112,7 +112,7 @@ void Texture::updateTextureProperties() {
break;
default:
assertUnreachable("Texture::updateTextureProperties: Unknown wrap mode!");
assertUnreachable("Unknown wrap mode!");
}
assertNoGLError();
};
@ -128,51 +128,31 @@ void Texture::updateTextureProperties() {
switch(filter) {
case TEXTURE_FILTER_MODE_NEAREST: {
glTexParameteri(GL_TEXTURE_2D, minMag, GL_NEAREST);
// switch(mapFilterMode) {
// case TEXTURE_FILTER_MODE_NEAREST:
// glTexParameteri(GL_TEXTURE_2D, minMag, GL_NEAREST_MIPMAP_NEAREST);
// break;
// case TEXTURE_FILTER_MODE_LINEAR:
// glTexParameteri(GL_TEXTURE_2D, minMag, GL_LINEAR_MIPMAP_NEAREST);
// break;
// default:
// assertUnreachable();
// }
break;
}
case TEXTURE_FILTER_MODE_LINEAR: {
glTexParameteri(GL_TEXTURE_2D, minMag, GL_LINEAR);
// switch(mapFilterMode) {
// case TEXTURE_FILTER_MODE_NEAREST:
// glTexParameteri(GL_TEXTURE_2D, minMag, GL_NEAREST_MIPMAP_LINEAR);
// break;
// case TEXTURE_FILTER_MODE_LINEAR:
// glTexParameteri(GL_TEXTURE_2D, minMag, GL_LINEAR_MIPMAP_LINEAR);
// break;
// default:
// assertUnreachable();
// }
break;
}
default: {
assertUnreachable("Texture::updateTextureProperties: Unknown filter mode!");
assertUnreachable("Unknown filter mode!");
}
}
assertNoGLError();
};
setFilterMode(GL_TEXTURE_MIN_FILTER, this->filterModeMin, this->mipmapFilterModeMin);
setFilterMode(GL_TEXTURE_MAG_FILTER, this->filterModeMag, this->mipmapFilterModeMag);
setFilterMode(
GL_TEXTURE_MIN_FILTER, this->filterModeMin, this->mipmapFilterModeMin
);
setFilterMode(
GL_TEXTURE_MAG_FILTER, this->filterModeMag, this->mipmapFilterModeMag
);
}
void Texture::bufferRaw(void *data) {
assertTrue(this->isReady(), "Texture::bufferRaw: Texture is not ready!");
assertTrue(this->isReady(), "Texture is not ready!");
GLenum format;
switch(this->format) {
@ -193,7 +173,7 @@ void Texture::bufferRaw(void *data) {
break;
default:
assertUnreachable("Texture::bufferRaw: Unknown texture format!");
assertUnreachable("Unknown texture format!");
}
GLenum dataFormat;
@ -207,7 +187,7 @@ void Texture::bufferRaw(void *data) {
break;
default:
assertUnreachable("Texture::bufferRaw: Unknown texture data format!");
assertUnreachable("Unknown texture data format!");
}
glBindTexture(GL_TEXTURE_2D, this->id);
@ -224,18 +204,30 @@ void Texture::bufferRaw(void *data) {
}
void Texture::buffer(struct ColorU8 pixels[]) {
assertTrue(this->dataFormat == TEXTURE_DATA_FORMAT_UNSIGNED_BYTE, "Texture::buffer: Texture data format must be unsigned byte!");
assertTrue(
this->dataFormat == TEXTURE_DATA_FORMAT_UNSIGNED_BYTE,
"Texture data format must be unsigned byte!"
);
this->bufferRaw((void*)pixels);
}
void Texture::buffer(struct Color pixels[]) {
assertTrue(this->dataFormat == TEXTURE_DATA_FORMAT_FLOAT, "Texture::buffer: Texture data format must be float!");
assertTrue(this->format == TEXTURE_FORMAT_RGBA, "Texture::buffer: Texture format must be RGBA!");
assertTrue(
this->dataFormat == TEXTURE_DATA_FORMAT_FLOAT,
"Texture data format must be float!"
);
assertTrue(
this->format == TEXTURE_FORMAT_RGBA,
"Texture format must be RGBA!"
);
this->bufferRaw((void*)pixels);
}
void Texture::buffer(uint8_t pixels[]) {
assertTrue(this->dataFormat == TEXTURE_DATA_FORMAT_UNSIGNED_BYTE, "Texture::buffer: Texture data format must be unsigned byte!");
assertTrue(
this->dataFormat == TEXTURE_DATA_FORMAT_UNSIGNED_BYTE,
"Texture data format must be unsigned byte!"
);
this->bufferRaw((void*)pixels);
}

4
src/dawnopengl/display/Texture.hpp
View File

@ -5,9 +5,7 @@
#pragma once
#include "dawnopengl.hpp"
#include "assert/assertgl.hpp"
#include "display/_Texture.hpp"
#include "util/memory.hpp"
#include "display/ITexture.hpp"
namespace Dawn {
class TextureRenderTarget;

1
src/dawnopengl/display/TextureRenderTarget.cpp
View File

@ -4,6 +4,7 @@
// https://opensource.org/licenses/MIT
#include "TextureRenderTarget.hpp"
#include "assert/assertgl.hpp"
using namespace Dawn;

28
src/dawnopengl/display/mesh/Mesh.cpp
View File

@ -98,12 +98,12 @@ void Mesh::disposeBuffers() {
}
void Mesh::bufferPositions(int32_t pos, glm::vec3 *positions, int32_t len) {
assertNotNull(positions, "Mesh::bufferPositions: Positions cannot be null");
assertTrue(pos >= 0 && pos < this->verticeCount, "Mesh::bufferPositions: Position must be within range");
assertTrue(pos+len <= this->verticeCount, "Mesh::bufferPositions: Position + Length must be within range");
assertTrue(len > 0, "Mesh::bufferPositions: Length must be greater than zero");
assertNotNull(positions, "Positions cannot be null");
assertTrue(pos >= 0 && pos < verticeCount, "Position must be within range");
assertTrue(pos+len <= verticeCount, "Position + Length must be within range");
assertTrue(len > 0, "Length must be greater than zero");
glBindBuffer(GL_ARRAY_BUFFER, this->vertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
assertNoGLError();
glBufferSubData(
GL_ARRAY_BUFFER,
@ -115,10 +115,10 @@ void Mesh::bufferPositions(int32_t pos, glm::vec3 *positions, int32_t len) {
}
void Mesh::bufferCoordinates(int32_t pos, glm::vec2 *coordinates, int32_t len) {
assertNotNull(coordinates, "Mesh::bufferCoordinates: Coordinates cannot be null");
assertTrue(pos >= 0 && pos < this->verticeCount, "Mesh::bufferCoordinates: Position must be within range");
assertTrue(pos+len <= this->verticeCount, "Mesh::bufferCoordinates: Position + Length must be within range");
assertTrue(len > 0, "Mesh::bufferCoordinates: Length must be greater than zero");
assertNotNull(coordinates, "Coordinates cannot be null");
assertTrue(pos >= 0 && pos < verticeCount, "Position must be within range");
assertTrue(pos+len <= verticeCount, "Position + Length must be within range");
assertTrue(len > 0, "Length must be greater than zero");
auto offsetCoordinates = (
(sizeof(glm::vec3) * this->verticeCount) +
@ -137,12 +137,12 @@ void Mesh::bufferCoordinates(int32_t pos, glm::vec2 *coordinates, int32_t len) {
}
void Mesh::bufferIndices(int32_t pos, meshindice_t *indices, int32_t len) {
assertNotNull(indices, "Mesh::bufferIndices: Indices cannot be null");
assertTrue(pos >= 0 && pos < this->indiceCount, "Mesh::bufferIndices: Position must be within range");
assertTrue(pos+len <= this->indiceCount, "Mesh::bufferIndices: Position + Length must be within range");
assertTrue(len > 0, "Mesh::bufferIndices: Length must be greater than zero");
assertNotNull(indices, "Indices cannot be null");
assertTrue(pos >= 0 && pos < indiceCount, "Position must be within range");
assertTrue(pos+len <= indiceCount, "Position + Length must be within range");
assertTrue(len > 0, "Length must be greater than zero");
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->indexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
assertNoGLError();
glBufferSubData(
GL_ELEMENT_ARRAY_BUFFER,

30
src/dawnopengl/display/shader/Shader.cpp
View File

@ -30,8 +30,7 @@ void Shader::compileShader(
if(!isSuccess) {
glGetShaderiv(this->shaderVertex, GL_INFO_LOG_LENGTH, &maxLength);
glGetShaderInfoLog(this->shaderVertex, maxLength, &maxLength, error);
debugMessage("Error compiling vert shader");
debugMessage(error);
assertUnreachable("Error compiling vert shader %s", error);
throw error;
}
assertNoGLError();
@ -46,16 +45,15 @@ void Shader::compileShader(
glGetShaderiv(this->shaderFrag, GL_INFO_LOG_LENGTH, &maxLength);
glGetShaderInfoLog(this->shaderFrag, maxLength, &maxLength, error);
glDeleteShader(this->shaderVertex);
debugMessage("Error compiling frag shader");
debugMessage(error);
assertUnreachable("Error compiling frag shader %s", error);
throw error;
}
assertNoGLError();
// Now create the shader program.
this->shaderProgram = glCreateProgram();
glAttachShader(this->shaderProgram, this->shaderVertex);
glAttachShader(this->shaderProgram, this->shaderFrag);
shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, shaderVertex);
glAttachShader(shaderProgram, shaderFrag);
assertNoGLError();
// Now parse out the variables.
@ -75,8 +73,7 @@ void Shader::compileShader(
glGetProgramInfoLog(this->shaderProgram, maxLength, &maxLength, error);
glDeleteShader(this->shaderVertex);
glDeleteShader(this->shaderFrag);
debugMessage("Error compiling shader program");
debugMessage(error);
assertUnreachable("Error compiling shader program %s", error);
throw error;
}
assertNoGLError();
@ -101,7 +98,10 @@ shaderbufferlocation_t Shader::getBufferLocationByName(std::string name) {
return glGetUniformBlockIndex(this->shaderProgram, name.c_str());
}
void Shader::setParameterBuffer(shaderbufferlocation_t location, shaderbufferslot_t slot) {
void Shader::setParameterBuffer(
shaderbufferlocation_t location,
shaderbufferslot_t slot
) {
glUniformBlockBinding(this->shaderProgram, location, slot);
assertNoGLError();
}
@ -132,13 +132,13 @@ void Shader::setFloat(shaderparameter_t param, float_t value) {
}
void Shader::bind() {
assertTrue(this->shaderProgram != -1, "Shader::bind: Cannot bind a program that is not ready");
glUseProgram(this->shaderProgram);
assertTrue(shaderProgram != -1, "Cannot bind a program that is not ready");
glUseProgram(shaderProgram);
assertNoGLError();
}
Shader::~Shader() {
if(this->shaderProgram != -1) glDeleteProgram(this->shaderProgram);
if(this->shaderVertex != -1) glDeleteShader(this->shaderVertex);
if(this->shaderFrag != -1) glDeleteShader(this->shaderFrag);
if(shaderProgram != -1) glDeleteProgram(shaderProgram);
if(shaderVertex != -1) glDeleteShader(shaderVertex);
if(shaderFrag != -1) glDeleteShader(shaderFrag);
}

14
src/dawnopengl/display/shader/Shader.hpp
View File

@ -4,10 +4,8 @@
// https://opensource.org/licenses/MIT
#pragma once
#include "display/shader/_Shader.hpp"
#include "display/shader/IShader.hpp"
#include "dawnopengl.hpp"
#include "display/Color.hpp"
#include "debug/debug.hpp"
typedef GLuint shaderparameter_t;
@ -66,12 +64,18 @@ namespace Dawn {
virtual void compile() override = 0;
void bind() override;
void setParameterBuffer(shaderbufferlocation_t location, shaderbufferslot_t slot);
void setParameterBuffer(
shaderbufferlocation_t location,
shaderbufferslot_t slot
);
void setMatrix(shaderparameter_t parameter, glm::mat4 matrix) override;
void setBoolean(shaderparameter_t parameter, bool_t value) override;
void setColor(shaderparameter_t parameter, struct Color color) override;
void setVector3(shaderparameter_t parameter, glm::vec3 vector) override;
void setTexture(shaderparameter_t parameter, textureslot_t texture) override;
void setTexture(
shaderparameter_t parameter,
textureslot_t texture
) override;
void setFloat(shaderparameter_t parameter, float_t value) override;
/**

19
src/dawnopengl/display/shader/ShaderParameterBuffer.hpp
View File

@ -5,7 +5,7 @@
#pragma once
#include "dawnopengl.hpp"
#include "display/shader/_ShaderParameterBuffer.hpp"
#include "display/shader/IShaderParameterBuffer.hpp"
#include "ShaderParameterBufferTypes.hpp"
namespace Dawn {
@ -13,14 +13,19 @@ namespace Dawn {
typedef GLuint shaderbufferlocation_t;
template<typename T>
class ShaderParameterBuffer : public IShaderParameterBuffer<shaderbufferslot_t> {
class ShaderParameterBuffer :
public IShaderParameterBuffer<shaderbufferslot_t>
{
protected:
shaderbufferlocation_t id = -1;
size_t size;
public:
void init() {
assertTrue(this->id == -1, "ShaderParameterBuffer::init: ShaderParameterBuffer is already initialized!");
assertTrue(
this->id == -1,
"ShaderParameterBuffer is already initialized!"
);
this->size = sizeof(T);
glGenBuffers(1, &this->id);
assertNoGLError();
@ -46,7 +51,7 @@ namespace Dawn {
}
void bind(shaderbufferslot_t location) override {
assertTrue(this->isReady(), "ShaderParameterBuffer::bind: ShaderParameterBuffer is not ready!");
assertTrue(this->isReady(), "ShaderParameterBuffer is not ready!");
glBindBuffer(GL_UNIFORM_BUFFER, this->id);
assertNoGLError();
glBindBufferBase(GL_UNIFORM_BUFFER, location, this->id);
@ -71,10 +76,12 @@ namespace Dawn {
* @param length Length of the data to buffer.
*/
void bufferRaw(void *data, size_t start, size_t length) {
assertTrue(this->isReady(), "ShaderParameterBuffer::bufferRaw: ShaderParameterBuffer is not ready!");
assertTrue(this->isReady(), "ShaderParameterBuffer is not ready!");
glBindBuffer(GL_UNIFORM_BUFFER, this->id);
assertNoGLError();
glBufferSubData(GL_UNIFORM_BUFFER, start, length, (void*)((size_t)data + start));
glBufferSubData(
GL_UNIFORM_BUFFER, start, length, (void*)((size_t)data + start)
);
assertNoGLError();
}

8
src/dawnopengl/display/shader/shaders/SimpleTexturedShader.cpp
View File

@ -63,7 +63,9 @@ void SimpleTexturedShader::compile() {
"float4 out gl_Position : POSITION\n"
") {\n"
"o_TextCoord = aTexCoord;\n"
"gl_Position = mul(mul(mul(float4(aPos, 1.0), u_Model), u_View), u_Proj);\n"
"gl_Position = mul(\n"
"mul(mul(float4(aPos, 1.0), u_Model), u_View), u_Proj\n"
");\n"
"}",
// Fragment Shader
@ -91,5 +93,7 @@ void SimpleTexturedShader::compile() {
this->paramColor = this->getParameterByName("u_Color");
this->paramTexture = this->getParameterByName("u_Text");
this->paramHasTexture = this->getParameterByName("u_HasTexture");
this->bufferRenderPipeline = this->getBufferLocationByName(RenderPipelineShaderBuffer::getShaderUniformName());
this->bufferRenderPipeline = this->getBufferLocationByName(
RenderPipelineShaderBuffer::getShaderUniformName()
);
}

22
src/dawnopengl/scene/components/display/material/SimpleBillboardedMaterial.cpp
View File

@ -15,27 +15,31 @@ SimpleBillboardedMaterial::SimpleBillboardedMaterial(SceneItem *i) :
}
void SimpleBillboardedMaterial::onStart() {
this->shaderLock = this->getGame()->renderManager.getShaderManager()->lockShader<SimpleBillboardedShader>();
this->shaderLock = getShaderManager().lockShader<SimpleBillboardedShader>();
}
void SimpleBillboardedMaterial::onDispose() {
this->getGame()->renderManager.getShaderManager()->releaseShader<SimpleBillboardedShader>(this->shaderLock);
getShaderManager().releaseShader<SimpleBillboardedShader>(this->shaderLock);
}
std::vector<struct ShaderPassItem> SimpleBillboardedMaterial::getRenderPasses(IRenderableContext &context) {
auto mesh = this->item->getComponent<MeshRenderer>();
auto shader = this->getGame()->renderManager.getShaderManager()->getShader<SimpleBillboardedShader>(this->shaderLock);
std::vector<struct ShaderPassItem>
SimpleBillboardedMaterial::getRenderPasses(IRenderableContext &context)
{
auto mesh = item->getComponent<MeshRenderer>();
auto shader = getShaderManager().getShader<SimpleBillboardedShader>(this->shaderLock);
assertNotNull(mesh, "SimpleBillboardedMaterial::getRenderPasses: Mesh cannot be null");
assertNotNull(mesh->mesh, "SimpleBillboardedMaterial::getRenderPasses: Mesh cannot be null");
assertNotNull(shader, "SimpleBillboardedMaterial::getRenderPasses: Shader cannot be null");
assertNotNull(mesh, "Mesh cannot be null");
assertNotNull(mesh->mesh, "Mesh cannot be null");
assertNotNull(shader, "Shader cannot be null");
struct ShaderPassItem onlyPass;
onlyPass.mesh = mesh->mesh;
onlyPass.shader = shader;
onlyPass.colorValues[shader->paramColor] = this->color;
onlyPass.matrixValues[shader->paramModel] = this->transform->getWorldTransform();
onlyPass.parameterBuffers[shader->bufferRenderPipeline] = &context.renderPipeline->shaderBuffer;
onlyPass.parameterBuffers[shader->bufferRenderPipeline] =
&context.renderPipeline->shaderBuffer
;
onlyPass.renderFlags = (
RENDER_MANAGER_RENDER_FLAG_BLEND

4
src/dawnopengl/scene/components/display/material/SimpleBillboardedMaterial.hpp
View File

@ -27,6 +27,8 @@ namespace Dawn {
void onStart() override;
void onDispose() override;
std::vector<struct ShaderPassItem> getRenderPasses(IRenderableContext &context) override;
std::vector<struct ShaderPassItem>
getRenderPasses(IRenderableContext &context) override
;
};
}

26
src/dawnopengl/scene/components/display/material/SimpleTexturedMaterial.cpp
View File

@ -14,27 +14,35 @@ SimpleTexturedMaterial::SimpleTexturedMaterial(SceneItem *i) :
}
void SimpleTexturedMaterial::onStart() {
this->shaderLock = this->getGame()->renderManager.getShaderManager()->lockShader<SimpleTexturedShader>();
this->shaderLock = getShaderManager().lockShader<SimpleTexturedShader>();
}
void SimpleTexturedMaterial::onDispose() {
this->getGame()->renderManager.getShaderManager()->releaseShader<SimpleTexturedShader>(this->shaderLock);
getShaderManager().releaseShader<SimpleTexturedShader>(this->shaderLock);
}
std::vector<struct ShaderPassItem> SimpleTexturedMaterial::getRenderPasses(IRenderableContext &context) {
std::vector<struct ShaderPassItem>
SimpleTexturedMaterial::getRenderPasses(IRenderableContext &context)
{
auto mesh = this->item->getComponent<MeshRenderer>();
auto shader = this->getGame()->renderManager.getShaderManager()->getShader<SimpleTexturedShader>(this->shaderLock);
auto shader = getShaderManager()
.getShader<SimpleTexturedShader>(this->shaderLock)
;
assertNotNull(mesh, "SimpleTexturedMaterial::getRenderPasses: Mesh cannot be null");
assertNotNull(mesh->mesh, "SimpleTexturedMaterial::getRenderPasses: Mesh cannot be null");
assertNotNull(shader, "SimpleTexturedMaterial::getRenderPasses: Shader cannot be null");
assertNotNull(mesh, "Mesh cannot be null");
assertNotNull(mesh->mesh, "Mesh cannot be null");
assertNotNull(shader, "Shader cannot be null");
struct ShaderPassItem onlyPass;
onlyPass.mesh = mesh->mesh;
onlyPass.shader = shader;
onlyPass.colorValues[shader->paramColor] = this->color;
onlyPass.matrixValues[shader->paramModel] = this->transform->getWorldTransform();
onlyPass.parameterBuffers[shader->bufferRenderPipeline] = &context.renderPipeline->shaderBuffer;
onlyPass.matrixValues[shader->paramModel] =
this->transform->getWorldTransform()
;
onlyPass.parameterBuffers[
shader->bufferRenderPipeline
] = &context.renderPipeline->shaderBuffer;
if(this->opaque) {
onlyPass.renderFlags = (

4
src/dawnopengl/scene/components/display/material/SimpleTexturedMaterial.hpp
View File

@ -29,6 +29,8 @@ namespace Dawn {
void onStart() override;
void onDispose() override;
std::vector<struct ShaderPassItem> getRenderPasses(IRenderableContext &context) override;
std::vector<struct ShaderPassItem>
getRenderPasses(IRenderableContext &context) override
;
};
}