mirror/blah
1
0
Fork 0
mirror of https://github.com/NoelFB/blah.git synced 2025-02-18 12:48:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

more graphics cleanup - removing Shader Attribute Info

Browse Source
This commit is contained in:
Noel Berry 2020-12-24 03:01:05 -08:00
parent 4c4d495fa8
commit 134d26040c
13 changed files with 183 additions and 253 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

149
private/blah/internal/graphics_backend_gl.cpp
View File

@ -1,14 +1,10 @@
#ifdef BLAH_USE_OPENGL
#include <blah/graphics/graphics.h>
#include <blah/internal/graphics_backend.h>
#include <blah/internal/platform_backend.h>
#include <blah/graphics/texture.h>
#include <blah/graphics/framebuffer.h>
#include <blah/graphics/mesh.h>
#include <blah/graphics/shader.h>
#include <blah/graphics/material.h>
#include <blah/containers/stackvector.h>
#include <blah/log.h>
#include <blah/app.h>
#include <stdio.h>
#include <string.h>
#include <stddef.h>
@ -346,25 +342,29 @@ typedef void (APIENTRY* DEBUGPROC)(GLenum source,
namespace Blah
{
// GL function pointers
struct GL
struct State
{
// GL function pointers
#define GL_FUNC(name, ret, ...) typedef ret (*name ## Func) (__VA_ARGS__); name ## Func name;
GL_FUNCTIONS
#undef GL_FUNC
// state
void* context;
// info
int max_color_attachments;
int max_element_indices;
int max_element_vertices;
int max_renderbuffer_size;
int max_samples;
int max_texture_image_units;
int max_texture_size;
GraphicsInfo info;
};
// static state
GL gl;
void* gl_context;
int gl_max_color_attachments;
int gl_max_element_indices;
int gl_max_element_vertices;
int gl_max_renderbuffer_size;
int gl_max_samples;
int gl_max_texture_image_units;
int gl_max_texture_size;
GraphicsInfo gl_info;
State gl;
// debug callback
void APIENTRY gl_message_callback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam)
@ -537,9 +537,9 @@ namespace Blah
m_gl_format = GL_RED;
m_gl_type = GL_UNSIGNED_BYTE;
if (width > gl_max_texture_size || height > gl_max_texture_size)
if (width > gl.max_texture_size || height > gl.max_texture_size)
{
Log::error("Exceeded Max Texture Size of %i", gl_max_texture_size);
Log::error("Exceeded Max Texture Size of %i", gl.max_texture_size);
return;
}
@ -757,11 +757,10 @@ namespace Blah
{
private:
GLuint m_id;
Attributes m_attributes;
Uniforms m_uniforms;
Vector<UniformInfo> m_uniforms;
public:
GLint uniforms_loc[BLAH_UNIFORMS] = { 0 };
Vector<GLint> uniform_locations;
OpenGL_Shader(const ShaderData* data)
{
@ -833,56 +832,25 @@ namespace Blah
// ready to go
m_id = id;
// get attributes
{
GLint active_attributes = 0;
gl.GetProgramiv(id, GL_ACTIVE_ATTRIBUTES, &active_attributes);
if (active_attributes > BLAH_ATTRIBUTES)
{
Log::warn("Exceeding maximum shader attributes (%i / %i)", active_attributes, BLAH_ATTRIBUTES);
active_attributes = BLAH_ATTRIBUTES;
}
for (int i = 0; i < active_attributes; i++)
{
GLsizei length;
GLsizei size;
GLenum type;
GLchar name[BLAH_ATTRIBUTE_NAME];
gl.GetActiveAttrib(id, i, BLAH_ATTRIBUTE_NAME - 1, &length, &size, &type, name);
name[length] = '\0';
ShaderAttribute attr;
attr.name = name;
attr.semantic_name = "";
attr.semantic_location = 0;
m_attributes.push_back(attr);
}
}
// get uniforms
{
const int max_name_length = 256;
GLint active_uniforms = 0;
gl.GetProgramiv(id, GL_ACTIVE_UNIFORMS, &active_uniforms);
if (active_uniforms > BLAH_UNIFORMS)
{
Log::warn("Exceeding maximum shader uniforms (%i / %i)", active_uniforms, BLAH_ATTRIBUTES);
active_uniforms = BLAH_UNIFORMS;
}
for (int i = 0; i < active_uniforms; i++)
{
GLsizei length;
GLsizei size;
GLenum type;
GLchar name[BLAH_UNIFORM_NAME];
GLchar name[max_name_length + 1];
gl.GetActiveUniform(id, i, BLAH_UNIFORM_NAME - 1, &length, &size, &type, name);
gl.GetActiveUniform(id, i, max_name_length, &length, &size, &type, name);
name[length] = '\0';
// array names end with "[0]", and we don't want that
for (int n = 0; n < BLAH_UNIFORM_NAME; n++)
for (int n = 0; n < max_name_length; n++)
if (name[n] == '[')
{
if (name[n + 1] == '0' && name[n + 2] == ']')
@ -892,11 +860,11 @@ namespace Blah
}
}
ShaderUniform uniform;
UniformInfo uniform;
uniform.name = name;
uniform.type = UniformType::None;
uniform.array_length = size;
uniforms_loc[i] = gl.GetUniformLocation(id, name);
uniform_locations.push_back(gl.GetUniformLocation(id, name));
if (type == GL_FLOAT)
uniform.type = UniformType::Float;
@ -935,25 +903,15 @@ namespace Blah
return m_id;
}
virtual Uniforms& uniforms() override
virtual Vector<UniformInfo>& uniforms() override
{
return m_uniforms;
}
virtual const Uniforms& uniforms() const override
virtual const Vector<UniformInfo>& uniforms() const override
{
return m_uniforms;
}
virtual Attributes& attributes() override
{
return m_attributes;
}
virtual const Attributes& attributes() const override
{
return m_attributes;
}
};
class OpenGL_Mesh : public Mesh
@ -970,8 +928,8 @@ namespace Blah
uint16_t m_instance_size;
uint8_t m_vertex_attribs_enabled;
uint8_t m_instance_attribs_enabled;
GLuint m_vertex_attribs[BLAH_ATTRIBUTES];
GLuint m_instance_attribs[BLAH_ATTRIBUTES];
Vector<GLuint> m_vertex_attribs;
Vector<GLuint> m_instance_attribs;
public:
@ -988,8 +946,6 @@ namespace Blah
m_instance_size = 0;
m_vertex_attribs_enabled = 0;
m_instance_attribs_enabled = 0;
m_vertex_attribs[0] = 0;
m_instance_attribs[0] = 0;
gl.GenVertexArrays(1, &m_id);
}
@ -1107,17 +1063,19 @@ namespace Blah
bool GraphicsBackend::init()
{
gl = State();
// create gl context
gl_context = PlatformBackend::gl_context_create();
if (gl_context == nullptr)
gl.context = PlatformBackend::gl_context_create();
if (gl.context == nullptr)
{
Log::error("Failed to create OpenGL Context");
return false;
}
PlatformBackend::gl_context_make_current(gl_context);
PlatformBackend::gl_context_make_current(gl.context);
// bind opengl functions
#define GL_FUNC(name, ...) gl.name = (GL::name ## Func)(PlatformBackend::gl_get_func("gl" #name));
#define GL_FUNC(name, ...) gl.name = (State::name ## Func)(PlatformBackend::gl_get_func("gl" #name));
GL_FUNCTIONS
#undef GL_FUNC
@ -1130,13 +1088,13 @@ namespace Blah
}
// get opengl info
gl.GetIntegerv(0x8CDF, &gl_max_color_attachments);
gl.GetIntegerv(0x80E9, &gl_max_element_indices);
gl.GetIntegerv(0x80E8, &gl_max_element_vertices);
gl.GetIntegerv(0x84E8, &gl_max_renderbuffer_size);
gl.GetIntegerv(0x8D57, &gl_max_samples);
gl.GetIntegerv(0x8872, &gl_max_texture_image_units);
gl.GetIntegerv(0x0D33, &gl_max_texture_size);
gl.GetIntegerv(0x8CDF, &gl.max_color_attachments);
gl.GetIntegerv(0x80E9, &gl.max_element_indices);
gl.GetIntegerv(0x80E8, &gl.max_element_vertices);
gl.GetIntegerv(0x84E8, &gl.max_renderbuffer_size);
gl.GetIntegerv(0x8D57, &gl.max_samples);
gl.GetIntegerv(0x8872, &gl.max_texture_image_units);
gl.GetIntegerv(0x0D33, &gl.max_texture_size);
// log
Log::print("OpenGL %s, %s",
@ -1148,9 +1106,9 @@ namespace Blah
gl.PixelStorei(GL_UNPACK_ALIGNMENT, 1);
// assign info
gl_info.instancing = true;
gl_info.origin_bottom_left = true;
gl_info.max_texture_size = gl_max_texture_size;
gl.info.instancing = true;
gl.info.origin_bottom_left = true;
gl.info.max_texture_size = gl.max_texture_size;
return true;
}
@ -1162,13 +1120,13 @@ namespace Blah
void GraphicsBackend::shutdown()
{
PlatformBackend::gl_context_destroy(gl_context);
gl_context = nullptr;
PlatformBackend::gl_context_destroy(gl.context);
gl.context = nullptr;
}
const GraphicsInfo* GraphicsBackend::info()
{
return &gl_info;
return &gl.info;
}
void GraphicsBackend::frame() {}
@ -1261,7 +1219,7 @@ namespace Blah
auto& uniforms = shader->uniforms();
for (int i = 0; i < uniforms.size(); i++)
{
auto location = shader->uniforms_loc[i];
auto location = shader->uniform_locations[i];
auto& uniform = uniforms[i];
// Sampler 2D
@ -1340,7 +1298,6 @@ namespace Blah
((int)call.blend.mask & (int)BlendMask::Blue),
((int)call.blend.mask & (int)BlendMask::Alpha));
unsigned char r = call.blend.rgba >> 24;
unsigned char g = call.blend.rgba >> 16;
unsigned char b = call.blend.rgba >> 8;

1
private/blah/internal/platform_backend_sdl2.cpp
View File

@ -396,7 +396,6 @@ void PlatformBackend::set_size(int width, int height)
void PlatformBackend::get_draw_size(int* width, int* height)
{
auto config = App::config();
if (GraphicsBackend::renderer() == GraphicsRenderer::OpenGL)
{
SDL_GL_GetDrawableSize(window, width, height);

1
public/blah/drawing/batch.cpp
View File

@ -5,6 +5,7 @@
#include <blah/graphics/shader.h>
#include <blah/graphics/material.h>
#include <blah/math/calc.h>
#include <blah/app.h>
using namespace Blah;

1
public/blah/drawing/spritefont.cpp
View File

@ -1,6 +1,7 @@
#include <blah/drawing/spritefont.h>
#include <blah/images/font.h>
#include <blah/images/packer.h>
#include <blah/graphics/graphics.h>
#include <blah/log.h>
using namespace Blah;

4
public/blah/graphics/framebuffer.h
View File

@ -1,9 +1,11 @@
#pragma once
#include <blah/graphics/graphics.h>
#include <blah/graphics/texture.h>
#include <blah/containers/stackvector.h>
#include <memory>
// 4 color attachments + 1 depth/stencil
#define BLAH_ATTACHMENTS 5
namespace Blah
{
typedef StackVector<TextureRef, BLAH_ATTACHMENTS> Attachments;

1
public/blah/graphics/graphics.cpp
View File

@ -5,6 +5,7 @@
#include <blah/graphics/material.h>
#include <blah/graphics/shader.h>
#include <blah/log.h>
#include <blah/app.h>
#include <blah/internal/graphics_backend.h>
#include <blah/images/image.h>
#include <string.h>

161
public/blah/graphics/graphics.h
View File

@ -1,78 +1,19 @@
#pragma once
#include <inttypes.h>
#include <blah/app.h>
#include <blah/math/point.h>
#include <blah/math/rect.h>
#include <blah/containers/str.h>
#include <blah/graphics/texture.h>
#include <blah/graphics/framebuffer.h>
#include <blah/graphics/mesh.h>
#include <blah/graphics/shader.h>
#include <blah/graphics/material.h>
#include <memory>
#define BLAH_ATTACHMENTS 5 // 4 color attachments + 1 depth/stencil
#define BLAH_UNIFORMS 16 // 16 shader uniforms
#define BLAH_ATTRIBUTES 16 // 16 shader attributes
#define BLAH_ATTRIBUTE_NAME 32 // max shader attribute name length
#define BLAH_UNIFORM_NAME 32 // max shader uniform name length
namespace Blah
{
class Stream;
class Image;
class Texture;
typedef std::shared_ptr<Texture> TextureRef;
class FrameBuffer;
typedef std::shared_ptr<FrameBuffer> FrameBufferRef;
class Material;
typedef std::shared_ptr<Material> MaterialRef;
class Shader;
typedef std::shared_ptr<Shader> ShaderRef;
class Mesh;
typedef std::shared_ptr<Mesh> MeshRef;
enum class GraphicsRenderer
{
None = -1,
OpenGL,
D3D11,
Metal,
Count
};
struct GraphicsInfo
{
bool instancing = false;
bool origin_bottom_left = false;
int max_texture_size = 0;
};
enum class TextureFilter
{
None,
Linear,
Nearest
};
enum class TextureWrap
{
None,
Clamp,
Repeat
};
enum class TextureFormat
{
None,
R,
RG,
RGB,
RGBA,
DepthStencil,
Count
};
enum class Compare
{
None,
@ -129,11 +70,11 @@ namespace Blah
enum class BlendMask
{
None = 0,
Red = 1,
Red = 1,
Green = 2,
Blue = 4,
Alpha = 8,
RGB = Red | Green | Blue,
RGB = Red | Green | Blue,
RGBA = Red | Green | Blue | Alpha,
};
@ -185,78 +126,6 @@ namespace Blah
static const BlendMode Subtract;
};
enum class UniformType
{
None,
Float,
Float2,
Float3,
Float4,
Mat3x2,
Mat4x4,
Texture
};
enum class VertexSemantics
{
None,
Position,
Normal,
Bitangent,
Color0,
Color1,
Color2,
Color3,
Indices,
Weight,
Texcoord0,
Texcoord1,
Texcoord2,
Texcoord3,
Texcoord4,
Texcoord5,
Texcoord6,
Texcoord7
};
enum class VertexAttributeType
{
None,
Byte,
Short,
Int,
Float
};
struct VertexAttribute
{
int index;
VertexSemantics semantics;
VertexAttributeType type;
int components;
bool normalized;
};
struct ShaderData
{
const char* vertex;
const char* fragment;
};
struct ShaderUniform
{
StrOf<BLAH_UNIFORM_NAME> name;
UniformType type;
int array_length;
};
struct ShaderAttribute
{
StrOf<BLAH_ATTRIBUTE_NAME> name;
StrOf<BLAH_ATTRIBUTE_NAME> semantic_name;
int semantic_location;
};
struct RenderCall
{
// Framebuffer to draw to
@ -302,6 +171,22 @@ namespace Blah
RenderCall();
};
enum class GraphicsRenderer
{
None = -1,
OpenGL,
D3D11,
Metal,
Count
};
struct GraphicsInfo
{
bool instancing = false;
bool origin_bottom_left = false;
int max_texture_size = 0;
};
namespace Graphics
{
const FrameBufferRef backbuffer;

6
public/blah/graphics/material.cpp
View File

@ -5,7 +5,7 @@ using namespace Blah;
namespace
{
int calc_uniform_size(const ShaderUniform& uniform)
int calc_uniform_size(const UniformInfo& uniform)
{
int components = 0;
@ -31,8 +31,8 @@ Material::Material(const ShaderRef& shader)
BLAH_ASSERT(shader, "Material is being created with an invalid shader");
m_shader = shader;
Uniforms uniforms = shader->uniforms();
StackVector<size_t, BLAH_UNIFORMS> float_offsets;
auto& uniforms = shader->uniforms();
Vector<size_t> float_offsets;
size_t float_size = 0;
for (auto& uniform : uniforms)

41
public/blah/graphics/mesh.h
View File

@ -1,10 +1,49 @@
#pragma once
#include <inttypes.h>
#include <blah/graphics/graphics.h>
#include <memory>
namespace Blah
{
enum class VertexSemantics
{
None,
Position,
Normal,
Bitangent,
Color0,
Color1,
Color2,
Color3,
Indices,
Weight,
Texcoord0,
Texcoord1,
Texcoord2,
Texcoord3,
Texcoord4,
Texcoord5,
Texcoord6,
Texcoord7
};
enum class VertexAttributeType
{
None,
Byte,
Short,
Int,
Float
};
struct VertexAttribute
{
int index;
VertexSemantics semantics;
VertexAttributeType type;
int components;
bool normalized;
};
class Mesh
{
public:

38
public/blah/graphics/shader.h
View File

@ -1,12 +1,34 @@
#pragma once
#include <blah/graphics/graphics.h>
#include <blah/containers/stackvector.h>
#include <blah/containers/str.h>
#include <memory>
namespace Blah
{
typedef StackVector<ShaderUniform, BLAH_UNIFORMS> Uniforms;
typedef StackVector<ShaderAttribute, BLAH_ATTRIBUTES> Attributes;
enum class UniformType
{
None,
Float,
Float2,
Float3,
Float4,
Mat3x2,
Mat4x4,
Texture
};
struct UniformInfo
{
String name;
UniformType type;
int array_length;
};
struct ShaderData
{
const char* vertex;
const char* fragment;
};
class Shader
{
@ -14,16 +36,10 @@ namespace Blah
virtual ~Shader() = default;
// Gets a list of Shader Uniforms from Shader
virtual Uniforms& uniforms() = 0;
virtual Vector<UniformInfo>& uniforms() = 0;
// Gets a list of Shader Uniforms from Shader
virtual const Uniforms& uniforms() const = 0;
// Gets a list of Shader Attributes from Shader
virtual Attributes& attributes() = 0;
// Gets a list of Shader Attributes from Shader
virtual const Attributes& attributes() const = 0;
virtual const Vector<UniformInfo>& uniforms() const = 0;
};
typedef std::shared_ptr<Shader> ShaderRef;

26
public/blah/graphics/texture.h
View File

@ -1,9 +1,33 @@
#pragma once
#include <blah/graphics/graphics.h>
#include <memory>
namespace Blah
{
enum class TextureFilter
{
None,
Linear,
Nearest
};
enum class TextureWrap
{
None,
Clamp,
Repeat
};
enum class TextureFormat
{
None,
R,
RG,
RGB,
RGBA,
DepthStencil,
Count
};
class Texture
{
public:

5
public/blah/math/rect.cpp
View File

@ -156,6 +156,11 @@ bool Rect::contains(const Vec2& pt) const
return pt.x >= x && pt.x < x + w && pt.y >= y && pt.y < y + h;
}
bool Rect::overlaps(const Rect& rect) const
{
return x + w >= rect.x && y + h >= rect.y && x < rect.x + rect.w && y < rect.y + rect.h;
}
Rect Rect::overlap_rect(const Rect& against) const
{
Rect result(0, 0, 0, 0);

2
public/blah/math/rect.h
View File

@ -50,7 +50,7 @@ namespace Blah
bool contains(const Point& pt) const;
bool contains(const Vec2& pt) const;
bool overlaps(const Rect& rect) const { return x + w >= rect.x && y + h >= rect.y && x < rect.x + rect.w && y < rect.y + rect.h; }
bool overlaps(const Rect& rect) const;
Rect overlap_rect(const Rect& other) const;
bool intersects(const Line& line) const;