mirror of
https://github.com/love2d/love.git
synced 2026-08-16 08:11:02 +02:00
Rename some internal buffer enums to better match what they do
This commit is contained in:
Alex Szpakowski
@@ -72,22 +72,22 @@ Buffer::Buffer(love::graphics::Graphics *gfx, const Settings &settings, const st
|
||||
size = getSize();
|
||||
arraylength = getArrayLength();
|
||||
|
||||
if (typeFlags & TYPEFLAG_TEXEL)
|
||||
mapType = BUFFERTYPE_TEXEL;
|
||||
else if (typeFlags & TYPEFLAG_VERTEX)
|
||||
mapType = BUFFERTYPE_VERTEX;
|
||||
else if (typeFlags & TYPEFLAG_INDEX)
|
||||
mapType = BUFFERTYPE_INDEX;
|
||||
else if (typeFlags & TYPEFLAG_SHADER_STORAGE)
|
||||
mapType = BUFFERTYPE_SHADER_STORAGE;
|
||||
else if (typeFlags & TYPEFLAG_COPY_SOURCE)
|
||||
mapType = BUFFERTYPE_COPY_SOURCE;
|
||||
else if (typeFlags & TYPEFLAG_COPY_DEST)
|
||||
mapType = BUFFERTYPE_COPY_DEST;
|
||||
if (usageFlags & BUFFERUSAGEFLAG_TEXEL)
|
||||
mapUsage = BUFFERUSAGE_TEXEL;
|
||||
else if (usageFlags & BUFFERUSAGEFLAG_VERTEX)
|
||||
mapUsage = BUFFERUSAGE_VERTEX;
|
||||
else if (usageFlags & BUFFERUSAGEFLAG_INDEX)
|
||||
mapUsage = BUFFERUSAGE_INDEX;
|
||||
else if (usageFlags & BUFFERUSAGEFLAG_SHADER_STORAGE)
|
||||
mapUsage = BUFFERUSAGE_SHADER_STORAGE;
|
||||
else if (usageFlags & BUFFERUSAGEFLAG_COPY_SOURCE)
|
||||
mapUsage = BUFFERUSAGE_COPY_SOURCE;
|
||||
else if (usageFlags & BUFFERUSAGEFLAG_COPY_DEST)
|
||||
mapUsage = BUFFERUSAGE_COPY_DEST;
|
||||
|
||||
target = OpenGL::getGLBufferType(mapType);
|
||||
target = OpenGL::getGLBufferType(mapUsage);
|
||||
|
||||
if (usage == BUFFERUSAGE_STREAM)
|
||||
if (dataUsage == BUFFERDATAUSAGE_STREAM)
|
||||
ownsMemoryMap = true;
|
||||
|
||||
std::vector<uint8> emptydata;
|
||||
@@ -143,12 +143,14 @@ bool Buffer::load(const void *initialdata)
|
||||
/* Clear the error buffer. */;
|
||||
|
||||
glGenBuffers(1, &buffer);
|
||||
gl.bindBuffer(mapType, buffer);
|
||||
gl.bindBuffer(mapUsage, buffer);
|
||||
|
||||
GLenum gldatausage = OpenGL::getGLBufferDataUsage(getDataUsage());
|
||||
|
||||
// initialdata can be null.
|
||||
glBufferData(target, (GLsizeiptr) getSize(), initialdata, OpenGL::getGLBufferUsage(getUsage()));
|
||||
glBufferData(target, (GLsizeiptr) getSize(), initialdata, gldatausage);
|
||||
|
||||
if (getTypeFlags() & TYPEFLAG_TEXEL)
|
||||
if (getUsageFlags() & BUFFERUSAGEFLAG_TEXEL)
|
||||
{
|
||||
glGenTextures(1, &texture);
|
||||
gl.bindBufferTextureToUnit(texture, 0, false, true);
|
||||
@@ -204,7 +206,7 @@ void Buffer::unmap(size_t usedoffset, size_t usedsize)
|
||||
mapped = false;
|
||||
|
||||
// Orphan optimization - see fill().
|
||||
if (usage != BUFFERUSAGE_STATIC && mappedRange.first == 0 && mappedRange.getSize() == getSize())
|
||||
if (dataUsage != BUFFERDATAUSAGE_STATIC && mappedRange.first == 0 && mappedRange.getSize() == getSize())
|
||||
{
|
||||
usedoffset = 0;
|
||||
usedsize = getSize();
|
||||
@@ -232,21 +234,21 @@ void Buffer::fill(size_t offset, size_t size, const void *data)
|
||||
if (!Range(0, buffersize).contains(Range(offset, size)))
|
||||
return;
|
||||
|
||||
GLenum glusage = OpenGL::getGLBufferUsage(usage);
|
||||
GLenum gldatausage = OpenGL::getGLBufferDataUsage(dataUsage);
|
||||
|
||||
gl.bindBuffer(mapType, buffer);
|
||||
gl.bindBuffer(mapUsage, buffer);
|
||||
|
||||
if (usage != BUFFERUSAGE_STATIC && size == buffersize)
|
||||
if (dataUsage != BUFFERDATAUSAGE_STATIC && size == buffersize)
|
||||
{
|
||||
// "orphan" current buffer to avoid implicit synchronisation on the GPU:
|
||||
// http://www.seas.upenn.edu/~pcozzi/OpenGLInsights/OpenGLInsights-AsynchronousBufferTransfers.pdf
|
||||
gl.bindBuffer(mapType, buffer);
|
||||
glBufferData(target, (GLsizeiptr) buffersize, nullptr, glusage);
|
||||
gl.bindBuffer(mapUsage, buffer);
|
||||
glBufferData(target, (GLsizeiptr) buffersize, nullptr, gldatausage);
|
||||
|
||||
#if LOVE_WINDOWS
|
||||
// TODO: Verify that this codepath is a useful optimization.
|
||||
if (gl.getVendor() == OpenGL::VENDOR_INTEL)
|
||||
glBufferData(target, (GLsizeiptr) buffersize, data, glusage);
|
||||
glBufferData(target, (GLsizeiptr) buffersize, data, gldatausage);
|
||||
else
|
||||
#endif
|
||||
glBufferSubData(target, 0, (GLsizeiptr) buffersize, data);
|
||||
@@ -259,8 +261,8 @@ void Buffer::fill(size_t offset, size_t size, const void *data)
|
||||
|
||||
void Buffer::copyTo(love::graphics::Buffer *dest, size_t sourceoffset, size_t destoffset, size_t size)
|
||||
{
|
||||
gl.bindBuffer(BUFFERTYPE_COPY_SOURCE, buffer);
|
||||
gl.bindBuffer(BUFFERTYPE_COPY_DEST, ((Buffer *) dest)->buffer);
|
||||
gl.bindBuffer(BUFFERUSAGE_COPY_SOURCE, buffer);
|
||||
gl.bindBuffer(BUFFERUSAGE_COPY_DEST, ((Buffer *) dest)->buffer);
|
||||
|
||||
glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, sourceoffset, destoffset, size);
|
||||
}
|
||||
|
||||
@@ -65,7 +65,7 @@ private:
|
||||
void unmapStatic(size_t offset, size_t size);
|
||||
void unmapStream();
|
||||
|
||||
BufferType mapType = BUFFERTYPE_VERTEX;
|
||||
BufferUsage mapUsage = BUFFERUSAGE_VERTEX;
|
||||
GLenum target = 0;
|
||||
|
||||
// The buffer object identifier. Assigned by OpenGL.
|
||||
|
||||
@@ -140,7 +140,7 @@ const char *Graphics::getName() const
|
||||
return "love.graphics.opengl";
|
||||
}
|
||||
|
||||
love::graphics::StreamBuffer *Graphics::newStreamBuffer(BufferType type, size_t size)
|
||||
love::graphics::StreamBuffer *Graphics::newStreamBuffer(BufferUsage type, size_t size)
|
||||
{
|
||||
return CreateStreamBuffer(type, size);
|
||||
}
|
||||
@@ -333,46 +333,46 @@ bool Graphics::setMode(int width, int height, int pixelwidth, int pixelheight, b
|
||||
{
|
||||
// Initial sizes that should be good enough for most cases. It will
|
||||
// resize to fit if needed, later.
|
||||
batchedDrawState.vb[0] = CreateStreamBuffer(BUFFERTYPE_VERTEX, 1024 * 1024 * 1);
|
||||
batchedDrawState.vb[1] = CreateStreamBuffer(BUFFERTYPE_VERTEX, 256 * 1024 * 1);
|
||||
batchedDrawState.indexBuffer = CreateStreamBuffer(BUFFERTYPE_INDEX, sizeof(uint16) * LOVE_UINT16_MAX);
|
||||
batchedDrawState.vb[0] = CreateStreamBuffer(BUFFERUSAGE_VERTEX, 1024 * 1024 * 1);
|
||||
batchedDrawState.vb[1] = CreateStreamBuffer(BUFFERUSAGE_VERTEX, 256 * 1024 * 1);
|
||||
batchedDrawState.indexBuffer = CreateStreamBuffer(BUFFERUSAGE_INDEX, sizeof(uint16) * LOVE_UINT16_MAX);
|
||||
}
|
||||
|
||||
if (capabilities.features[FEATURE_TEXEL_BUFFER] && defaultBuffers[BUFFERTYPE_TEXEL].get() == nullptr)
|
||||
if (capabilities.features[FEATURE_TEXEL_BUFFER] && defaultBuffers[BUFFERUSAGE_TEXEL].get() == nullptr)
|
||||
{
|
||||
Buffer::Settings settings(Buffer::TYPEFLAG_TEXEL, BUFFERUSAGE_STATIC);
|
||||
Buffer::Settings settings(BUFFERUSAGEFLAG_TEXEL, BUFFERDATAUSAGE_STATIC);
|
||||
std::vector<Buffer::DataDeclaration> format = {{"", DATAFORMAT_FLOAT_VEC4, 0}};
|
||||
|
||||
const float texel[] = {0.0f, 0.0f, 0.0f, 1.0f};
|
||||
|
||||
auto buffer = newBuffer(settings, format, texel, sizeof(texel), 1);
|
||||
defaultBuffers[BUFFERTYPE_TEXEL].set(buffer, Acquire::NORETAIN);
|
||||
defaultBuffers[BUFFERUSAGE_TEXEL].set(buffer, Acquire::NORETAIN);
|
||||
}
|
||||
|
||||
if (capabilities.features[FEATURE_GLSL4] && defaultBuffers[BUFFERTYPE_SHADER_STORAGE].get() == nullptr)
|
||||
if (capabilities.features[FEATURE_GLSL4] && defaultBuffers[BUFFERUSAGE_SHADER_STORAGE].get() == nullptr)
|
||||
{
|
||||
Buffer::Settings settings(Buffer::TYPEFLAG_SHADER_STORAGE, BUFFERUSAGE_STATIC);
|
||||
Buffer::Settings settings(BUFFERUSAGEFLAG_SHADER_STORAGE, BUFFERDATAUSAGE_STATIC);
|
||||
std::vector<Buffer::DataDeclaration> format = {{"", DATAFORMAT_FLOAT, 0}};
|
||||
|
||||
std::vector<float> data;
|
||||
data.resize(Buffer::SHADER_STORAGE_BUFFER_MAX_STRIDE / 4);
|
||||
|
||||
auto buffer = newBuffer(settings, format, data.data(), data.size() * sizeof(float), data.size());
|
||||
defaultBuffers[BUFFERTYPE_TEXEL].set(buffer, Acquire::NORETAIN);
|
||||
defaultBuffers[BUFFERUSAGE_TEXEL].set(buffer, Acquire::NORETAIN);
|
||||
}
|
||||
|
||||
// Load default resources before other Volatile.
|
||||
for (int i = 0; i < BUFFERTYPE_MAX_ENUM; i++)
|
||||
for (int i = 0; i < BUFFERUSAGE_MAX_ENUM; i++)
|
||||
{
|
||||
if (defaultBuffers[i].get())
|
||||
((Buffer *) defaultBuffers[i].get())->loadVolatile();
|
||||
}
|
||||
|
||||
if (defaultBuffers[BUFFERTYPE_TEXEL].get())
|
||||
gl.setDefaultTexelBuffer((GLuint) defaultBuffers[BUFFERTYPE_TEXEL]->getTexelBufferHandle());
|
||||
if (defaultBuffers[BUFFERUSAGE_TEXEL].get())
|
||||
gl.setDefaultTexelBuffer((GLuint) defaultBuffers[BUFFERUSAGE_TEXEL]->getTexelBufferHandle());
|
||||
|
||||
if (defaultBuffers[BUFFERTYPE_SHADER_STORAGE].get())
|
||||
gl.setDefaultStorageBuffer((GLuint) defaultBuffers[BUFFERTYPE_SHADER_STORAGE]->getHandle());
|
||||
if (defaultBuffers[BUFFERUSAGE_SHADER_STORAGE].get())
|
||||
gl.setDefaultStorageBuffer((GLuint) defaultBuffers[BUFFERUSAGE_SHADER_STORAGE]->getHandle());
|
||||
|
||||
// Reload all volatile objects.
|
||||
if (!Volatile::loadAll())
|
||||
@@ -494,7 +494,7 @@ void Graphics::draw(const DrawIndexedCommand &cmd)
|
||||
GLenum glprimitivetype = OpenGL::getGLPrimitiveType(cmd.primitiveType);
|
||||
GLenum gldatatype = OpenGL::getGLIndexDataType(cmd.indexType);
|
||||
|
||||
gl.bindBuffer(BUFFERTYPE_INDEX, cmd.indexBuffer->getHandle());
|
||||
gl.bindBuffer(BUFFERUSAGE_INDEX, cmd.indexBuffer->getHandle());
|
||||
|
||||
if (cmd.instanceCount > 1)
|
||||
glDrawElementsInstanced(glprimitivetype, cmd.indexCount, gldatatype, gloffset, cmd.instanceCount);
|
||||
@@ -536,7 +536,7 @@ void Graphics::drawQuads(int start, int count, const VertexAttributes &attribute
|
||||
gl.bindTextureToUnit(texture, 0, false);
|
||||
gl.setCullMode(CULL_NONE);
|
||||
|
||||
gl.bindBuffer(BUFFERTYPE_INDEX, quadIndexBuffer->getHandle());
|
||||
gl.bindBuffer(BUFFERUSAGE_INDEX, quadIndexBuffer->getHandle());
|
||||
|
||||
if (gl.isBaseVertexSupported())
|
||||
{
|
||||
@@ -1530,8 +1530,8 @@ void Graphics::initCapabilities()
|
||||
capabilities.features[FEATURE_GLSL3] = GLAD_ES_VERSION_3_0 || gl.isCoreProfile();
|
||||
capabilities.features[FEATURE_GLSL4] = GLAD_ES_VERSION_3_1 || (gl.isCoreProfile() && GLAD_VERSION_4_3);
|
||||
capabilities.features[FEATURE_INSTANCING] = gl.isInstancingSupported();
|
||||
capabilities.features[FEATURE_TEXEL_BUFFER] = gl.isBufferTypeSupported(BUFFERTYPE_TEXEL);
|
||||
capabilities.features[FEATURE_COPY_BUFFER] = gl.isBufferTypeSupported(BUFFERTYPE_COPY_SOURCE);
|
||||
capabilities.features[FEATURE_TEXEL_BUFFER] = gl.isBufferUsageSupported(BUFFERUSAGE_TEXEL);
|
||||
capabilities.features[FEATURE_COPY_BUFFER] = gl.isBufferUsageSupported(BUFFERUSAGE_COPY_SOURCE);
|
||||
static_assert(FEATURE_MAX_ENUM == 12, "Graphics::initCapabilities must be updated when adding a new graphics feature!");
|
||||
|
||||
capabilities.limits[LIMIT_POINT_SIZE] = gl.getMaxPointSize();
|
||||
|
||||
@@ -138,7 +138,7 @@ private:
|
||||
|
||||
love::graphics::ShaderStage *newShaderStageInternal(ShaderStage::StageType stage, const std::string &cachekey, const std::string &source, bool gles) override;
|
||||
love::graphics::Shader *newShaderInternal(love::graphics::ShaderStage *vertex, love::graphics::ShaderStage *pixel) override;
|
||||
love::graphics::StreamBuffer *newStreamBuffer(BufferType type, size_t size) override;
|
||||
love::graphics::StreamBuffer *newStreamBuffer(BufferUsage type, size_t size) override;
|
||||
void setRenderTargetsInternal(const RenderTargets &rts, int w, int h, int pixelw, int pixelh, bool hasSRGBtexture) override;
|
||||
void initCapabilities() override;
|
||||
void getAPIStats(int &shaderswitches) const override;
|
||||
@@ -166,7 +166,7 @@ private:
|
||||
size_t bufferMapMemorySize;
|
||||
|
||||
// Only needed for buffer types that can be bound to shaders.
|
||||
StrongRef<love::graphics::Buffer> defaultBuffers[BUFFERTYPE_MAX_ENUM];
|
||||
StrongRef<love::graphics::Buffer> defaultBuffers[BUFFERUSAGE_MAX_ENUM];
|
||||
|
||||
// [rendertarget][readable][srgb]
|
||||
OptionalBool supportedFormats[PIXELFORMAT_MAX_ENUM][2][2][2];
|
||||
|
||||
@@ -235,15 +235,15 @@ void OpenGL::setupContext()
|
||||
glGetIntegerv(GL_CULL_FACE_MODE, &faceCull);
|
||||
state.faceCullMode = faceCull;
|
||||
|
||||
for (int i = 0; i < (int) BUFFERTYPE_MAX_ENUM; i++)
|
||||
for (int i = 0; i < (int) BUFFERUSAGE_MAX_ENUM; i++)
|
||||
{
|
||||
state.boundBuffers[i] = 0;
|
||||
if (isBufferTypeSupported((BufferType) i))
|
||||
glBindBuffer(getGLBufferType((BufferType) i), 0);
|
||||
if (isBufferUsageSupported((BufferUsage) i))
|
||||
glBindBuffer(getGLBufferType((BufferUsage) i), 0);
|
||||
}
|
||||
|
||||
if (isBufferTypeSupported(BUFFERTYPE_SHADER_STORAGE))
|
||||
state.boundIndexedBuffers[BUFFERTYPE_SHADER_STORAGE].resize(maxShaderStorageBufferBindings, 0);
|
||||
if (isBufferUsageSupported(BUFFERUSAGE_SHADER_STORAGE))
|
||||
state.boundIndexedBuffers[BUFFERUSAGE_SHADER_STORAGE].resize(maxShaderStorageBufferBindings, 0);
|
||||
|
||||
// Initialize multiple texture unit support for shaders.
|
||||
for (int i = 0; i < TEXTURE_MAX_ENUM + 1; i++)
|
||||
@@ -484,12 +484,12 @@ void OpenGL::initMaxValues()
|
||||
else
|
||||
maxTextureArrayLayers = 0;
|
||||
|
||||
if (isBufferTypeSupported(BUFFERTYPE_TEXEL))
|
||||
if (isBufferUsageSupported(BUFFERUSAGE_TEXEL))
|
||||
glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE, &maxTexelBufferSize);
|
||||
else
|
||||
maxTexelBufferSize = 0;
|
||||
|
||||
if (isBufferTypeSupported(BUFFERTYPE_SHADER_STORAGE))
|
||||
if (isBufferUsageSupported(BUFFERUSAGE_SHADER_STORAGE))
|
||||
{
|
||||
glGetIntegerv(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &maxShaderStorageBufferSize);
|
||||
glGetIntegerv(GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, &maxShaderStorageBufferBindings);
|
||||
@@ -613,17 +613,17 @@ GLenum OpenGL::getGLPrimitiveType(PrimitiveType type)
|
||||
return GL_ZERO;
|
||||
}
|
||||
|
||||
GLenum OpenGL::getGLBufferType(BufferType type)
|
||||
GLenum OpenGL::getGLBufferType(BufferUsage usage)
|
||||
{
|
||||
switch (type)
|
||||
switch (usage)
|
||||
{
|
||||
case BUFFERTYPE_VERTEX: return GL_ARRAY_BUFFER;
|
||||
case BUFFERTYPE_INDEX: return GL_ELEMENT_ARRAY_BUFFER;
|
||||
case BUFFERTYPE_TEXEL: return GL_TEXTURE_BUFFER;
|
||||
case BUFFERTYPE_SHADER_STORAGE: return GL_SHADER_STORAGE_BUFFER;
|
||||
case BUFFERTYPE_COPY_SOURCE: return GL_COPY_READ_BUFFER;
|
||||
case BUFFERTYPE_COPY_DEST: return GL_COPY_WRITE_BUFFER;
|
||||
case BUFFERTYPE_MAX_ENUM: return GL_ZERO;
|
||||
case BUFFERUSAGE_VERTEX: return GL_ARRAY_BUFFER;
|
||||
case BUFFERUSAGE_INDEX: return GL_ELEMENT_ARRAY_BUFFER;
|
||||
case BUFFERUSAGE_TEXEL: return GL_TEXTURE_BUFFER;
|
||||
case BUFFERUSAGE_SHADER_STORAGE: return GL_SHADER_STORAGE_BUFFER;
|
||||
case BUFFERUSAGE_COPY_SOURCE: return GL_COPY_READ_BUFFER;
|
||||
case BUFFERUSAGE_COPY_DEST: return GL_COPY_WRITE_BUFFER;
|
||||
case BUFFERUSAGE_MAX_ENUM: return GL_ZERO;
|
||||
}
|
||||
|
||||
return GL_ZERO;
|
||||
@@ -792,18 +792,18 @@ GLenum OpenGL::getGLVertexDataType(DataFormat format, int &components, GLboolean
|
||||
return GL_ZERO;
|
||||
}
|
||||
|
||||
GLenum OpenGL::getGLBufferUsage(BufferUsage usage)
|
||||
GLenum OpenGL::getGLBufferDataUsage(BufferDataUsage usage)
|
||||
{
|
||||
switch (usage)
|
||||
{
|
||||
case BUFFERUSAGE_STREAM: return GL_STREAM_DRAW;
|
||||
case BUFFERUSAGE_DYNAMIC: return GL_DYNAMIC_DRAW;
|
||||
case BUFFERUSAGE_STATIC: return GL_STATIC_DRAW;
|
||||
case BUFFERDATAUSAGE_STREAM: return GL_STREAM_DRAW;
|
||||
case BUFFERDATAUSAGE_DYNAMIC: return GL_DYNAMIC_DRAW;
|
||||
case BUFFERDATAUSAGE_STATIC: return GL_STATIC_DRAW;
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
void OpenGL::bindBuffer(BufferType type, GLuint buffer)
|
||||
void OpenGL::bindBuffer(BufferUsage type, GLuint buffer)
|
||||
{
|
||||
if (state.boundBuffers[type] != buffer)
|
||||
{
|
||||
@@ -816,7 +816,7 @@ void OpenGL::deleteBuffer(GLuint buffer)
|
||||
{
|
||||
glDeleteBuffers(1, &buffer);
|
||||
|
||||
for (int i = 0; i < (int) BUFFERTYPE_MAX_ENUM; i++)
|
||||
for (int i = 0; i < (int) BUFFERUSAGE_MAX_ENUM; i++)
|
||||
{
|
||||
if (state.boundBuffers[i] == buffer)
|
||||
state.boundBuffers[i] = 0;
|
||||
@@ -869,7 +869,7 @@ void OpenGL::setVertexAttributes(const VertexAttributes &attributes, const Buffe
|
||||
|
||||
const void *offsetpointer = reinterpret_cast<void*>(bufferinfo.offset + attrib.offsetFromVertex);
|
||||
|
||||
bindBuffer(BUFFERTYPE_VERTEX, (GLuint) bufferinfo.buffer->getHandle());
|
||||
bindBuffer(BUFFERUSAGE_VERTEX, (GLuint) bufferinfo.buffer->getHandle());
|
||||
|
||||
if (intformat)
|
||||
glVertexAttribIPointer(i, components, gltype, layout.stride, offsetpointer);
|
||||
@@ -1165,7 +1165,7 @@ void OpenGL::bindTextureToUnit(Texture *texture, int textureunit, bool restorepr
|
||||
bindTextureToUnit(textype, handle, textureunit, restoreprev, bindforedit);
|
||||
}
|
||||
|
||||
void OpenGL::bindIndexedBuffer(GLuint buffer, BufferType type, int index)
|
||||
void OpenGL::bindIndexedBuffer(GLuint buffer, BufferUsage type, int index)
|
||||
{
|
||||
auto &bindings = state.boundIndexedBuffers[type];
|
||||
if (bindings.size() > (size_t) index && buffer != bindings[index])
|
||||
@@ -1434,22 +1434,22 @@ bool OpenGL::isTextureTypeSupported(TextureType type) const
|
||||
return false;
|
||||
}
|
||||
|
||||
bool OpenGL::isBufferTypeSupported(BufferType type) const
|
||||
bool OpenGL::isBufferUsageSupported(BufferUsage usage) const
|
||||
{
|
||||
switch (type)
|
||||
switch (usage)
|
||||
{
|
||||
case BUFFERTYPE_VERTEX:
|
||||
case BUFFERTYPE_INDEX:
|
||||
case BUFFERUSAGE_VERTEX:
|
||||
case BUFFERUSAGE_INDEX:
|
||||
return true;
|
||||
case BUFFERTYPE_TEXEL:
|
||||
case BUFFERUSAGE_TEXEL:
|
||||
// Not supported in ES until 3.2, which we don't support shaders for...
|
||||
return GLAD_VERSION_3_1;
|
||||
case BUFFERTYPE_SHADER_STORAGE:
|
||||
case BUFFERUSAGE_SHADER_STORAGE:
|
||||
return (GLAD_VERSION_4_3 && isCoreProfile()) || GLAD_ES_VERSION_3_1;
|
||||
case BUFFERTYPE_COPY_SOURCE:
|
||||
case BUFFERTYPE_COPY_DEST:
|
||||
case BUFFERUSAGE_COPY_SOURCE:
|
||||
case BUFFERUSAGE_COPY_DEST:
|
||||
return GLAD_VERSION_3_1 || GLAD_ES_VERSION_3_0;
|
||||
case BUFFERTYPE_MAX_ENUM:
|
||||
case BUFFERUSAGE_MAX_ENUM:
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
|
||||
@@ -235,7 +235,7 @@ public:
|
||||
* NOTE: This does not account for multiple VAOs being used! Index buffer
|
||||
* bindings are per-VAO in OpenGL, but this doesn't know about that.
|
||||
**/
|
||||
void bindBuffer(BufferType type, GLuint buffer);
|
||||
void bindBuffer(BufferUsage type, GLuint buffer);
|
||||
|
||||
/**
|
||||
* glDeleteBuffers which updates our shadowed state.
|
||||
@@ -341,7 +341,7 @@ public:
|
||||
|
||||
void bindBufferTextureToUnit(GLuint texture, int textureunit, bool restoreprev, bool bindforedit);
|
||||
|
||||
void bindIndexedBuffer(GLuint buffer, BufferType type, int index);
|
||||
void bindIndexedBuffer(GLuint buffer, BufferUsage type, int index);
|
||||
|
||||
/**
|
||||
* Helper for deleting an OpenGL texture.
|
||||
@@ -362,7 +362,7 @@ public:
|
||||
bool rawTexStorage(TextureType target, int levels, PixelFormat pixelformat, bool &isSRGB, int width, int height, int depth = 1);
|
||||
|
||||
bool isTextureTypeSupported(TextureType type) const;
|
||||
bool isBufferTypeSupported(BufferType type) const;
|
||||
bool isBufferUsageSupported(BufferUsage usage) const;
|
||||
bool isClampZeroOneTextureWrapSupported() const;
|
||||
bool isPixelShaderHighpSupported() const;
|
||||
bool isInstancingSupported() const;
|
||||
@@ -433,10 +433,10 @@ public:
|
||||
Vendor getVendor() const;
|
||||
|
||||
static GLenum getGLPrimitiveType(PrimitiveType type);
|
||||
static GLenum getGLBufferType(BufferType type);
|
||||
static GLenum getGLBufferType(BufferUsage usage);
|
||||
static GLenum getGLIndexDataType(IndexDataType type);
|
||||
static GLenum getGLVertexDataType(DataFormat format, int &components, GLboolean &normalized, bool &intformat);
|
||||
static GLenum getGLBufferUsage(BufferUsage usage);
|
||||
static GLenum getGLBufferDataUsage(BufferDataUsage usage);
|
||||
static GLenum getGLTextureType(TextureType type);
|
||||
static GLint getGLWrapMode(SamplerState::WrapMode wmode);
|
||||
static GLint getGLCompareMode(CompareMode mode);
|
||||
@@ -486,12 +486,12 @@ private:
|
||||
// Tracked OpenGL state.
|
||||
struct
|
||||
{
|
||||
GLuint boundBuffers[BUFFERTYPE_MAX_ENUM];
|
||||
GLuint boundBuffers[BUFFERUSAGE_MAX_ENUM];
|
||||
|
||||
// Texture unit state (currently bound texture for each texture unit.)
|
||||
std::vector<GLuint> boundTextures[TEXTURE_MAX_ENUM + 1];
|
||||
|
||||
std::vector<GLuint> boundIndexedBuffers[BUFFERTYPE_MAX_ENUM];
|
||||
std::vector<GLuint> boundIndexedBuffers[BUFFERUSAGE_MAX_ENUM];
|
||||
|
||||
bool enableState[ENABLE_MAX_ENUM];
|
||||
|
||||
|
||||
@@ -315,7 +315,7 @@ void Shader::mapActiveUniforms()
|
||||
}
|
||||
}
|
||||
|
||||
if (gl.isBufferTypeSupported(BUFFERTYPE_SHADER_STORAGE))
|
||||
if (gl.isBufferUsageSupported(BUFFERUSAGE_SHADER_STORAGE))
|
||||
{
|
||||
GLint numstoragebuffers = 0;
|
||||
glGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_ACTIVE_RESOURCES, &numstoragebuffers);
|
||||
@@ -586,7 +586,7 @@ void Shader::attach()
|
||||
}
|
||||
|
||||
for (auto bufferbinding : activeStorageBufferBindings)
|
||||
gl.bindIndexedBuffer(bufferbinding.buffer, BUFFERTYPE_SHADER_STORAGE, bufferbinding.bindingindex);
|
||||
gl.bindIndexedBuffer(bufferbinding.buffer, BUFFERUSAGE_SHADER_STORAGE, bufferbinding.bindingindex);
|
||||
|
||||
// send any pending uniforms to the shader program.
|
||||
for (const auto &p : pendingUniformUpdates)
|
||||
@@ -816,9 +816,9 @@ void Shader::sendBuffers(const UniformInfo *info, love::graphics::Buffer **buffe
|
||||
bool storagebinding = info->baseType == UNIFORM_STORAGEBUFFER;
|
||||
|
||||
if (texelbinding)
|
||||
requiredtypeflags = Buffer::TYPEFLAG_TEXEL;
|
||||
requiredtypeflags = BUFFERUSAGEFLAG_TEXEL;
|
||||
else if (storagebinding)
|
||||
requiredtypeflags = Buffer::TYPEFLAG_SHADER_STORAGE;
|
||||
requiredtypeflags = BUFFERUSAGEFLAG_SHADER_STORAGE;
|
||||
|
||||
if (requiredtypeflags == 0)
|
||||
return;
|
||||
@@ -837,7 +837,7 @@ void Shader::sendBuffers(const UniformInfo *info, love::graphics::Buffer **buffe
|
||||
|
||||
if (buffer != nullptr)
|
||||
{
|
||||
if ((buffer->getTypeFlags() & requiredtypeflags) == 0)
|
||||
if ((buffer->getUsageFlags() & requiredtypeflags) == 0)
|
||||
{
|
||||
if (internalUpdate)
|
||||
continue;
|
||||
@@ -915,7 +915,7 @@ void Shader::sendBuffers(const UniformInfo *info, love::graphics::Buffer **buffe
|
||||
glbuffer = gl.getDefaultStorageBuffer();
|
||||
|
||||
if (shaderactive)
|
||||
gl.bindIndexedBuffer(glbuffer, BUFFERTYPE_SHADER_STORAGE, bindingindex);
|
||||
gl.bindIndexedBuffer(glbuffer, BUFFERUSAGE_SHADER_STORAGE, bindingindex);
|
||||
|
||||
int activeindex = storageBufferBindingIndexToActiveBinding[bindingindex];
|
||||
if (activeindex >= 0)
|
||||
|
||||
@@ -44,7 +44,7 @@ class StreamBufferClientMemory final : public love::graphics::StreamBuffer
|
||||
{
|
||||
public:
|
||||
|
||||
StreamBufferClientMemory(BufferType mode, size_t size)
|
||||
StreamBufferClientMemory(BufferUsage mode, size_t size)
|
||||
: love::graphics::StreamBuffer(mode, size)
|
||||
, data(nullptr)
|
||||
{
|
||||
@@ -86,7 +86,7 @@ class StreamBufferSubDataOrphan final : public love::graphics::StreamBuffer, pub
|
||||
{
|
||||
public:
|
||||
|
||||
StreamBufferSubDataOrphan(BufferType mode, size_t size)
|
||||
StreamBufferSubDataOrphan(BufferUsage mode, size_t size)
|
||||
: love::graphics::StreamBuffer(mode, size)
|
||||
, vbo(0)
|
||||
, glMode(OpenGL::getGLBufferType(mode))
|
||||
@@ -184,7 +184,7 @@ class StreamBufferSync : public love::graphics::StreamBuffer
|
||||
{
|
||||
public:
|
||||
|
||||
StreamBufferSync(BufferType type, size_t size)
|
||||
StreamBufferSync(BufferUsage type, size_t size)
|
||||
: love::graphics::StreamBuffer(type, size)
|
||||
, frameIndex(0)
|
||||
, syncs()
|
||||
@@ -220,7 +220,7 @@ class StreamBufferMapSync final : public StreamBufferSync, public Volatile
|
||||
{
|
||||
public:
|
||||
|
||||
StreamBufferMapSync(BufferType type, size_t size)
|
||||
StreamBufferMapSync(BufferUsage type, size_t size)
|
||||
: StreamBufferSync(type, size)
|
||||
, vbo(0)
|
||||
, glMode(OpenGL::getGLBufferType(mode))
|
||||
@@ -302,7 +302,7 @@ public:
|
||||
|
||||
// Coherent mapping is supposedly faster on intel/nvidia aside from a couple
|
||||
// old nvidia GPUs.
|
||||
StreamBufferPersistentMapSync(BufferType type, size_t size, bool coherent = true)
|
||||
StreamBufferPersistentMapSync(BufferUsage type, size_t size, bool coherent = true)
|
||||
: StreamBufferSync(type, size)
|
||||
, vbo(0)
|
||||
, glMode(OpenGL::getGLBufferType(mode))
|
||||
@@ -393,7 +393,7 @@ class StreamBufferPinnedMemory final : public StreamBufferSync, public Volatile
|
||||
{
|
||||
public:
|
||||
|
||||
StreamBufferPinnedMemory(BufferType type, size_t size)
|
||||
StreamBufferPinnedMemory(BufferUsage type, size_t size)
|
||||
: StreamBufferSync(type, size)
|
||||
, vbo(0)
|
||||
, glMode(OpenGL::getGLBufferType(mode))
|
||||
@@ -491,7 +491,7 @@ private:
|
||||
|
||||
}; // StreamBufferPinnedMemory
|
||||
|
||||
love::graphics::StreamBuffer *CreateStreamBuffer(BufferType mode, size_t size)
|
||||
love::graphics::StreamBuffer *CreateStreamBuffer(BufferUsage mode, size_t size)
|
||||
{
|
||||
if (gl.isCoreProfile())
|
||||
{
|
||||
|
||||
@@ -29,7 +29,7 @@ namespace graphics
|
||||
namespace opengl
|
||||
{
|
||||
|
||||
love::graphics::StreamBuffer *CreateStreamBuffer(BufferType mode, size_t size);
|
||||
love::graphics::StreamBuffer *CreateStreamBuffer(BufferUsage mode, size_t size);
|
||||
|
||||
} // opengl
|
||||
} // graphics
|
||||
|
||||
Reference in New Issue
Block a user