atdunbg/Prism
1
1
Fork 0
Code Issues Pull Requests Actions Projects Releases Wiki Activity

merge vertexbuffer and indexbuffer to buffer.cpp/h file

Browse Source
This commit is contained in:
Atdunbg
2025-11-22 15:19:48 +08:00
parent d24ca28e74
commit 104b08ef24
23 changed files with 337 additions and 230 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitmodules vendored
View File

@ -8,3 +8,6 @@
path = Prism/vendor/ImGui
url = https://github.com/ocornut/imgui.git
branch = docking
[submodule "Prism/vendor/glm"]
path = Prism/vendor/glm
url = https://github.com/g-truc/glm.git

25
Prism/CMakeLists.txt
View File

@ -8,6 +8,7 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON)
add_subdirectory(vendor/spdlog EXCLUDE_FROM_ALL)
add_subdirectory(vendor/glfw EXCLUDE_FROM_ALL)
add_subdirectory(vendor/glad EXCLUDE_FROM_ALL)
add_subdirectory(vendor/glm EXCLUDE_FROM_ALL)
# ------------- imgui -------------
@ -22,18 +23,22 @@ file(GLOB IMGUI_SOURCE
list(APPEND SRC_SOURCE ${IMGUI_SOURCE})
# ------------- link libraries -------------
set(LINK_LIBRARIES
set(LINK_LIBRARIES_PRIVATE
spdlog
glfw
glad
)
set(LINK_LIBRARIES_PUBLIC
glm
)
# link library opengl
if(WIN32)
list(APPEND LINK_LIBRARIES opengl32)
list(APPEND LINK_LIBRARIES_PRIVATE opengl32)
elseif(UNIX AND NOT APPLE)
find_package(X11 REQUIRED)
list(APPEND LINK_LIBRARIES GL ${X11_LIBRARIES})
list(APPEND LINK_LIBRARIES_PRIVATE GL ${X11_LIBRARIES})
endif()
@ -62,8 +67,11 @@ target_compile_definitions(${STATIC_LIBRARY} PRIVATE
target_include_directories(${STATIC_LIBRARY} PUBLIC
${TARGET_INCLUDE_DIR}
)
target_link_libraries(${STATIC_LIBRARY} PRIVATE
${LINK_LIBRARIES}
target_link_libraries(${STATIC_LIBRARY}
PRIVATE
${LINK_LIBRARIES_PRIVATE}
PUBLIC
${LINK_LIBRARIES_PUBLIC}
)
target_precompile_headers(${STATIC_LIBRARY} PRIVATE
src/pmpch.h
@ -87,8 +95,11 @@ target_compile_definitions(${SHARED_LIBRARY} PRIVATE
target_include_directories(${SHARED_LIBRARY} PUBLIC
${TARGET_INCLUDE_DIR}
)
target_link_libraries(${SHARED_LIBRARY} PRIVATE
${LINK_LIBRARIES}
target_link_libraries(${SHARED_LIBRARY}
PRIVATE
${LINK_LIBRARIES_PRIVATE}
PUBLIC
${LINK_LIBRARIES_PUBLIC}
)
target_precompile_headers(${SHARED_LIBRARY} PRIVATE
src/pmpch.h

3
Prism/src/Prism.h
View File

@ -11,10 +11,9 @@
#include "Prism/Core/Events/Event.h"
#include "Prism/Core/Events/KeyEvent.h"
#include "Prism/Core/Events/MouseEvent.h"
#include "Prism/Renderer/IndexBuffer.h"
#include "Prism/Renderer/Buffer.h"
#include "Prism/Renderer/Renderer.h"
#include "Prism/Renderer/Shader.h"
#include "Prism/Renderer/Texture.h"
#include "Prism/Renderer/VertexBuffer.h"
#endif //PRISM_H

81
Prism/src/Prism/Platform/OpenGL/OpenGLBuffer.cpp Normal file
View File

@ -0,0 +1,81 @@
//
// Created by sfd on 25-11-22.
//
#include "OpenGLBuffer.h"
#include "Prism/Renderer/Renderer.h"
namespace Prism
{
// ******************************************
// Vertex
// ******************************************
OpenGLVertexBuffer::OpenGLVertexBuffer(unsigned int size)
: m_RendererID(0), m_Size(size)
{
PM_RENDER_S({
glGenBuffers(1, &self->m_RendererID);
});
}
OpenGLVertexBuffer::~OpenGLVertexBuffer()
{
PM_RENDER_S({
glDeleteBuffers(1, &self->m_RendererID);
});
}
void OpenGLVertexBuffer::SetData(void* buffer, unsigned int size, unsigned int offset)
{
PM_RENDER_S3(buffer, size, offset, {
glBindBuffer(GL_ARRAY_BUFFER, self->m_RendererID);
glBufferData(GL_ARRAY_BUFFER, size, buffer, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 3, 0);
});
}
void OpenGLVertexBuffer::Bind() const
{
PM_RENDER_S({
glBindBuffer(GL_ARRAY_BUFFER, self->m_RendererID);
});
}
// ******************************************
// IndexBuffer
// ******************************************
OpenGLIndexBuffer::OpenGLIndexBuffer(unsigned int size)
: m_RendererID(0), m_Size(size)
{
PM_RENDER_S({
glGenBuffers(1, &self->m_RendererID);
});
}
OpenGLIndexBuffer::~OpenGLIndexBuffer()
{
PM_RENDER_S({
glDeleteBuffers(1, &self->m_RendererID);
});
}
void OpenGLIndexBuffer::SetData(void* buffer, unsigned int size, unsigned int offset)
{
PM_RENDER_S3(buffer, size, offset, {
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self->m_RendererID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, buffer, GL_STATIC_DRAW);
});
}
void OpenGLIndexBuffer::Bind() const
{
PM_RENDER_S({
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self->m_RendererID);
});
}
}

55
Prism/src/Prism/Platform/OpenGL/OpenGLBuffer.h Normal file
View File

@ -0,0 +1,55 @@
//
// Created by sfd on 25-11-22.
//
#ifndef OPENGLBUFFER_H
#define OPENGLBUFFER_H
#include "glad/glad.h"
#include "Prism/Renderer/Buffer.h"
namespace Prism
{
// ******************************************
// Vertex
// ******************************************
class OpenGLVertexBuffer : public VertexBuffer
{
public:
OpenGLVertexBuffer(unsigned int size);
virtual ~OpenGLVertexBuffer();
virtual void SetData(void* buffer, unsigned int size, unsigned int offset = 0);
virtual void Bind() const;
virtual unsigned int GetSize() const { return m_Size; }
virtual RendererID GetRendererID() const { return m_RendererID; }
private:
RendererID m_RendererID;
unsigned int m_Size;
};
// ******************************************
// IndexBuffer
// ******************************************
class OpenGLIndexBuffer : public IndexBuffer
{
public:
OpenGLIndexBuffer(unsigned int size);
virtual ~OpenGLIndexBuffer();
virtual void SetData(void* buffer, unsigned int size, unsigned int offset = 0);
virtual void Bind() const;
virtual unsigned int GetSize() const { return m_Size; }
virtual RendererID GetRendererID() const { return m_RendererID; }
private:
RendererID m_RendererID;
unsigned int m_Size;
};
}
#endif //OPENGLBUFFER_H

41
Prism/src/Prism/Platform/OpenGL/OpenGLIndexBuffer.cpp
View File

@ -1,41 +0,0 @@
//
// Created by sfd on 25-11-22.
//
#include "OpenGLIndexBuffer.h"
#include "glad/glad.h"
#include "Prism/Renderer/Renderer.h"
namespace Prism
{
OpenGLIndexBuffer::OpenGLIndexBuffer(unsigned int size)
: m_RendererID(0), m_Size(size)
{
PM_RENDER_S({
glGenBuffers(1, &self->m_RendererID);
});
}
OpenGLIndexBuffer::~OpenGLIndexBuffer()
{
PM_RENDER_S({
glDeleteBuffers(1, &self->m_RendererID);
});
}
void OpenGLIndexBuffer::SetData(void* buffer, unsigned int size, unsigned int offset)
{
PM_RENDER_S3(buffer, size, offset, {
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self->m_RendererID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, buffer, GL_STATIC_DRAW);
});
}
void OpenGLIndexBuffer::Bind() const
{
PM_RENDER_S({
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self->m_RendererID);
});
}
}

30
Prism/src/Prism/Platform/OpenGL/OpenGLIndexBuffer.h
View File

@ -1,30 +0,0 @@
//
// Created by sfd on 25-11-22.
//
#ifndef OPENGLINDEXBUFFER_H
#define OPENGLINDEXBUFFER_H
#include "Prism/Renderer/IndexBuffer.h"
namespace Prism
{
class OpenGLIndexBuffer : public IndexBuffer
{
public:
OpenGLIndexBuffer(unsigned int size);
virtual ~OpenGLIndexBuffer();
virtual void SetData(void* buffer, unsigned int size, unsigned int offset = 0);
virtual void Bind() const;
virtual unsigned int GetSize() const { return m_Size; }
virtual RendererID GetRendererID() const { return m_RendererID; }
private:
RendererID m_RendererID;
unsigned int m_Size;
};
}
#endif //OPENGLINDEXBUFFER_H

41
Prism/src/Prism/Platform/OpenGL/OpenGLShader.cpp
View File

@ -22,6 +22,33 @@ namespace Prism
});
}
void OpenGLShader::UploadUniformBuffer(const UniformBufferBase& uniformBuffer)
{
for (unsigned int i = 0; i < uniformBuffer.GetUniformCount(); i++)
{
const UniformDecl& decl = uniformBuffer.GetUniforms()[i];
switch (decl.Type)
{
case UniformType::Float:
{
const std::string& name = decl.Name;
float value = *(float*)(uniformBuffer.GetBuffer() + decl.Offset);
PM_RENDER_S2(name, value, {
self->UploadUniformFloat(name, value);
});
}
case UniformType::Float4:
{
const std::string& name = decl.Name;
glm::vec4& values = *(glm::vec4*)(uniformBuffer.GetBuffer() + decl.Offset);
PM_RENDER_S2(name, values, {
self->UploadUniformFloat4(name, values);
});
}
}
}
}
void OpenGLShader::ReadShaderFromFile(const std::string& filepath)
{
std::ifstream file(filepath, std::ios::in | std::ios::binary);
@ -53,7 +80,7 @@ namespace Prism
PM_CORE_TRACE("Type={0}", type);
}
printf("%s \n", token.c_str());
PM_CORE_TRACE("{}", token.c_str());
}
std::unordered_map<GLenum, std::string> shaderSources;
@ -144,4 +171,16 @@ namespace Prism
return GL_NONE;
}
void OpenGLShader::UploadUniformFloat(const std::string& name, float value)
{
glUseProgram(m_RendererID);
glUniform1f(glGetUniformLocation(m_RendererID, name.c_str()), value);
}
void OpenGLShader::UploadUniformFloat4(const std::string& name, const glm::vec4& values)
{
glUseProgram(m_RendererID);
glUniform4f(glGetUniformLocation(m_RendererID, name.c_str()), values.x, values.y, values.z, values.w);
}
}

7
Prism/src/Prism/Platform/OpenGL/OpenGLShader.h
View File

@ -17,11 +17,18 @@ namespace Prism
OpenGLShader(const std::string& filepath);
virtual void Bind() override;
virtual void UploadUniformBuffer(const UniformBufferBase& uniformBuffer) override;
private:
void ReadShaderFromFile(const std::string& filepath);
void CompileAndUploadShader();
static GLenum ShaderTypeFromString(const std::string& type);
void UploadUniformFloat(const std::string& name, float value);
void UploadUniformFloat2(const std::string& name, float* values);
void UploadUniformFloat3(const std::string& name, float* values);
void UploadUniformFloat4(const std::string& name, const glm::vec4& values);
private:
RendererID m_RendererID;

44
Prism/src/Prism/Platform/OpenGL/OpenGLVertexBuffer.cpp
View File

@ -1,44 +0,0 @@
//
// Created by sfd on 25-11-22.
//
#include "OpenGLVertexBuffer.h"
#include "glad/glad.h"
#include "Prism/Renderer/Renderer.h"
namespace Prism
{
OpenGLVertexBuffer::OpenGLVertexBuffer(unsigned int size)
: m_RendererID(0), m_Size(size)
{
PM_RENDER_S({
glGenBuffers(1, &self->m_RendererID);
});
}
OpenGLVertexBuffer::~OpenGLVertexBuffer()
{
PM_RENDER_S({
glDeleteBuffers(1, &self->m_RendererID);
});
}
void OpenGLVertexBuffer::SetData(void* buffer, unsigned int size, unsigned int offset)
{
PM_RENDER_S3(buffer, size, offset, {
glBindBuffer(GL_ARRAY_BUFFER, self->m_RendererID);
glBufferData(GL_ARRAY_BUFFER, size, buffer, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 3, 0);
});
}
void OpenGLVertexBuffer::Bind() const
{
PM_RENDER_S({
glBindBuffer(GL_ARRAY_BUFFER, self->m_RendererID);
});
}
}

30
Prism/src/Prism/Platform/OpenGL/OpenGLVertexBuffer.h
View File

@ -1,30 +0,0 @@
//
// Created by sfd on 25-11-22.
//
#ifndef OPENGLVERTEXBUFFER_H
#define OPENGLVERTEXBUFFER_H
#include "Prism/Renderer/VertexBuffer.h"
namespace Prism
{
class OpenGLVertexBuffer : public VertexBuffer
{
public:
OpenGLVertexBuffer(unsigned int size);
virtual ~OpenGLVertexBuffer();
virtual void SetData(void* buffer, unsigned int size, unsigned int offset = 0);
virtual void Bind() const;
virtual unsigned int GetSize() const { return m_Size; }
virtual RendererID GetRendererID() const { return m_RendererID; }
private:
RendererID m_RendererID;
unsigned int m_Size;
};
}
#endif //OPENGLVERTEXBUFFER_H

31
Prism/src/Prism/Renderer/Buffer.cpp Normal file
View File

@ -0,0 +1,31 @@
//
// Created by sfd on 25-11-22.
//
#include "Buffer.h"
#include "Prism/Platform/OpenGL/OpenGLBuffer.h"
namespace Prism
{
VertexBuffer* VertexBuffer::Create(unsigned int size)
{
switch (RendererAPI::Current())
{
case RendererAPIType::None: return nullptr;
case RendererAPIType::OpenGL: return new OpenGLVertexBuffer(size);
}
return nullptr;
}
IndexBuffer* IndexBuffer::Create(const unsigned int size)
{
switch (RendererAPI::Current())
{
case RendererAPIType::None: return nullptr;
case RendererAPIType::OpenGL: return new OpenGLIndexBuffer(size);
}
return nullptr;
}
}

21
Prism/src/Prism/Renderer/VertexBuffer.h → Prism/src/Prism/Renderer/Buffer.h
View File

@ -2,8 +2,8 @@
// Created by sfd on 25-11-22.
//
#ifndef VERTEXBUFFER_H
#define VERTEXBUFFER_H
#ifndef RENDERER_BUFFER_H
#define RENDERER_BUFFER_H
#include "RendererAPI.h"
@ -21,9 +21,24 @@ namespace Prism
virtual RendererID GetRendererID() const = 0;
static VertexBuffer* Create(unsigned int size = 0);
};
class PRISM_API IndexBuffer
{
public:
virtual ~IndexBuffer() {}
virtual void SetData(void* buffer, unsigned int size, unsigned int offset = 0) = 0;
virtual void Bind() const = 0;
virtual unsigned int GetSize() const = 0;
virtual RendererID GetRendererID() const = 0;
static IndexBuffer* Create(unsigned int size = 0);
};
}
#endif //VERTEXBUFFER_H
#endif //RENDERER_BUFFER_H

20
Prism/src/Prism/Renderer/IndexBuffer.cpp
View File

@ -1,20 +0,0 @@
//
// Created by sfd on 25-11-22.
//
#include "IndexBuffer.h"
#include "Prism/Platform/OpenGL/OpenGLIndexBuffer.h"
namespace Prism
{
IndexBuffer* IndexBuffer::Create(const unsigned int size)
{
switch (RendererAPI::Current())
{
case RendererAPIType::None: return nullptr;
case RendererAPIType::OpenGL: return new OpenGLIndexBuffer(size);
}
return nullptr;
}
}

28
Prism/src/Prism/Renderer/IndexBuffer.h
View File

@ -1,28 +0,0 @@
//
// Created by sfd on 25-11-22.
//
#ifndef INDEXBUFFER_H
#define INDEXBUFFER_H
#include "RendererAPI.h"
namespace Prism
{
class PRISM_API IndexBuffer
{
public:
virtual ~IndexBuffer() {}
virtual void SetData(void* buffer, unsigned int size, unsigned int offset = 0) = 0;
virtual void Bind() const = 0;
virtual unsigned int GetSize() const = 0;
virtual RendererID GetRendererID() const = 0;
static IndexBuffer* Create(unsigned int size = 0);
};
}
#endif //INDEXBUFFER_H

2
Prism/src/Prism/Renderer/RendererAPI.h
View File

@ -10,7 +10,7 @@ namespace Prism
using RendererID = unsigned int;
enum class PRISM_API RendererAPIType
enum class RendererAPIType
{
None,
OpenGL

70
Prism/src/Prism/Renderer/Shader.h
View File

@ -5,13 +5,83 @@
#ifndef SHADER_H
#define SHADER_H
#include <glm/glm.hpp>
#include "glm/gtc/type_ptr.hpp"
namespace Prism
{
enum class UniformType
{
None = 0,
Float, Float2, Float3, Float4,
Mat3, Mat4,
Int32, Uint32
};
struct UniformDecl
{
UniformType Type;
std::ptrdiff_t Offset;
std::string Name;
};
struct UniformBuffer
{
// TODO: This currently represents a byte buffer that has been
// packed with uniforms. This was primarily created for OpenGL,
// and needs to be revisted for other rendering APIs. Furthermore,
// this currently does not assume any alignment. This also has
// nothing to do with GL uniform buffers, this is simply a CPU-side
// buffer abstraction.
byte* Buffer;
std::vector<UniformDecl> Uniforms;
};
struct UniformBufferBase
{
virtual const byte* GetBuffer() const = 0;
virtual const UniformDecl* GetUniforms() const = 0;
virtual unsigned int GetUniformCount() const = 0;
};
template<unsigned int N, unsigned int U>
struct UniformBufferDeclaration : public UniformBufferBase
{
byte Buffer[N];
UniformDecl Uniforms[U];
std::ptrdiff_t Cursor = 0;
virtual const byte* GetBuffer() const override { return Buffer; }
virtual const UniformDecl* GetUniforms() const override { return Uniforms; }
virtual unsigned int GetUniformCount() const { return U; }
template<typename T>
void Push(const std::string& name, const T& data) {}
void Push(const std::string& name, const float& data)
{
Uniforms[0] = { UniformType::Float, Cursor, name };
memcpy(Buffer + Cursor, &data, sizeof(float));
Cursor += sizeof(float);
}
void Push(const std::string& name, const glm::vec4& data)
{
Uniforms[0] = { UniformType::Float4, Cursor, name };
memcpy(Buffer + Cursor, glm::value_ptr(data), sizeof(glm::vec4));
Cursor += sizeof(glm::vec4);
}
};
class PRISM_API Shader
{
public:
virtual void Bind() = 0;
virtual void UploadUniformBuffer(const UniformBufferBase& uniformBuffer) = 0;
static Shader* Create(const std::string& filepath);
};

21
Prism/src/Prism/Renderer/VertexBuffer.cpp
View File

@ -1,21 +0,0 @@
//
// Created by sfd on 25-11-22.
//
#include "VertexBuffer.h"
#include "Prism/Platform/OpenGL/OpenGLVertexBuffer.h"
namespace Prism
{
VertexBuffer* VertexBuffer::Create(unsigned int size)
{
switch (RendererAPI::Current())
{
case RendererAPIType::None: return nullptr;
case RendererAPIType::OpenGL: return new OpenGLVertexBuffer(size);
}
return nullptr;
}
}

1
Prism/vendor/glm vendored Submodule

Submodule Prism/vendor/glm added at a583c59e16

2
Sandbox/CMakeLists.txt
View File

@ -9,4 +9,4 @@ file(COPY ${ASSETS} DESTINATION ${CMAKE_BINARY_DIR}/bin)
add_executable(${PROJECT_NAME} ${SRC_SOURCE})
target_link_libraries(${PROJECT_NAME} PRIVATE Prism)
target_compile_definitions(${PROJECT_NAME} PRIVATE ENABLE_DOCKSPACE)
#target_compile_definitions(${PROJECT_NAME} PRIVATE ENABLE_DOCKSPACE)

6
Sandbox/Sandbox/Layer/DemoLayer.cpp
View File

@ -57,6 +57,11 @@ void DemoLayer::OnDetach()
void DemoLayer::OnUpdate()
{
Prism::Renderer::Clear(m_ClearColor[0], m_ClearColor[1], m_ClearColor[2], m_ClearColor[3]);
Prism::UniformBufferDeclaration<sizeof(glm::vec4), 1> buffer;
buffer.Push("u_Color", m_TriangleColor);
m_Shader->UploadUniformBuffer(buffer);
m_Shader->Bind();
m_VertexBuffer->Bind();
m_IndexBuffer->Bind();
@ -71,6 +76,7 @@ void DemoLayer::OnImGuiRender()
ImGui::Begin("GameLayer");
ImGui::ColorEdit4("Clear Color", m_ClearColor);
ImGui::ColorEdit4("Triangle Color", glm::value_ptr(m_TriangleColor));
ImGui::End();
#if ENABLE_DOCKSPACE

1
Sandbox/Sandbox/Layer/DemoLayer.h
View File

@ -21,6 +21,7 @@ public:
private:
float m_ClearColor[4] = { 0.2f, 0.2f, 0.2f, 1.0f };
glm::vec4 m_TriangleColor = { 0.4f, 0.5f, 0.6f, 1.0f };
std::unique_ptr<Prism::VertexBuffer> m_VertexBuffer;
std::unique_ptr<Prism::IndexBuffer> m_IndexBuffer;

4
Sandbox/assets/shaders/shader.glsl
View File

@ -13,7 +13,9 @@ void main()
layout(location = 0) out vec4 o_Color;
uniform vec4 u_Color;
void main()
{
o_Color = vec4(1.0, 0.0, 1.0, 1.0);
o_Color = u_Color;
}