// --------------------------------------------------------------------------------------------------------------------
bool DynamicStreamingGLMapUnsynchronized::Init(size_t _maxVertexCount)
{
// Uniform Buffer
glGenBuffers(1, &mUniformBuffer);
// Program
const char* kUniformNames[] = { "CB0", nullptr };
mProgram = CreateProgramT("streaming_vb_gl_vs.glsl",
"streaming_vb_gl_fs.glsl",
kUniformNames, &mUniformLocation);
if (mProgram == 0) {
console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str());
return false;
}
// Dynamic vertex buffer
mParticleBufferSize = kTripleBuffer * sizeof(Vec2) * _maxVertexCount;
glGenBuffers(1, &mVertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
glBufferData(GL_ARRAY_BUFFER, mParticleBufferSize, nullptr, GL_DYNAMIC_DRAW);
return GLRenderer::GetApiError() == GL_NO_ERROR;
}
// --------------------------------------------------------------------------------------------------------------------
bool UntexturedObjectsGLTexCoord::Init(const std::vector<UntexturedObjectsProblem::Vertex>& _vertices,
const std::vector<UntexturedObjectsProblem::Index>& _indices,
size_t _objectCount)
{
if (!UntexturedObjectsSolution::Init(_vertices, _indices, _objectCount)) {
return false;
}
// Program
const char* kUniformNames[] = { "ViewProjection", nullptr };
m_prog = CreateProgramT("cubes_gl_tex_coord_vs.glsl",
"cubes_gl_tex_coord_fs.glsl",
kUniformNames, &mUniformLocation);
if (m_prog == 0) {
console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str());
return false;
}
// Buffers
glGenBuffers(1, &m_vb);
glBindBuffer(GL_ARRAY_BUFFER, m_vb);
glBufferData(GL_ARRAY_BUFFER, sizeof(UntexturedObjectsProblem::Vertex) * _vertices.size(), &*_vertices.begin(), GL_STATIC_DRAW);
glGenBuffers(1, &m_ib);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ib);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(UntexturedObjectsProblem::Index) * _indices.size(), &*_indices.begin(), GL_STATIC_DRAW);
return glGetError() == GL_NO_ERROR;
}
// --------------------------------------------------------------------------------------------------------------------
bool DynamicStreamingGLMapPersistent::Init(size_t _maxVertexCount)
{
if (glBufferStorage == nullptr) {
console::warn("Unable to initialize solution '%s', glBufferStorage() unavailable.", GetName().c_str());
return false;
}
// Uniform Buffer
glGenBuffers(1, &mUniformBuffer);
// Program
const char* kUniformNames[] = { "CB0", nullptr };
mProgram = CreateProgramT("streaming_vb_gl_vs.glsl",
"streaming_vb_gl_fs.glsl",
kUniformNames, &mUniformLocation);
if (mProgram == 0) {
console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str());
return false;
}
// Dynamic vertex buffer
glGenBuffers(1, &mVertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
mParticleBufferSize = kTripleBuffer * sizeof(Vec2) * _maxVertexCount;
const GLbitfield flags = GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT;
glBufferStorage(GL_ARRAY_BUFFER, mParticleBufferSize, NULL, flags);
mVertexDataPtr = glMapBufferRange(GL_ARRAY_BUFFER, 0, mParticleBufferSize, flags);
return GLRenderer::GetApiError() == GL_NO_ERROR;
}
// --------------------------------------------------------------------------------------------------------------------
bool TexturedQuadsGLBindless::Init(const std::vector<TexturedQuadsProblem::Vertex>& _vertices,
const std::vector<TexturedQuadsProblem::Index>& _indices,
const std::vector<TextureDetails*>& _textures,
size_t _objectCount)
{
if (!TexturedQuadsSolution::Init(_vertices, _indices, _textures, _objectCount)) {
return false;
}
// Prerequisites
if (glGetTextureHandleARB == nullptr) {
console::warn("Unable to initialize solution '%s', requires support for bindless textures (not present).", GetName().c_str());
return false;
}
// Program
const char* kUniformNames[] = { "ViewProjection", "DrawID", "gTex", nullptr };
mProgram = CreateProgramT("textures_gl_bindless_vs.glsl",
"textures_gl_bindless_fs.glsl",
kUniformNames, &mUniformLocation);
if (mProgram == 0) {
console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str());
return false;
}
// Textures
for (auto it = _textures.begin(); it != _textures.end(); ++it) {
GLuint tex = NewTex2DFromDetails(*(*it));
if (!tex) {
console::warn("Unable to initialize solution '%s', texture creation failed.", GetName().c_str());
return false;
}
// Needs to be freed later.
mTextures.push_back(tex);
GLuint64 texHandle = glGetTextureHandleARB(tex);
if (texHandle == 0) {
console::warn("Unable to initialize solution '%s', couldn't get texture handle.", GetName().c_str());
}
mTexHandles.push_back(texHandle);
}
// Buffers
glGenVertexArrays(1, &mVertexArray);
glBindVertexArray(mVertexArray);
mVertexBuffer = NewBufferFromVector(GL_ARRAY_BUFFER, _vertices, GL_STATIC_DRAW);
mIndexBuffer = NewBufferFromVector(GL_ELEMENT_ARRAY_BUFFER, _indices, GL_STATIC_DRAW);
glGenBuffers(1, &mTransformBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, mTransformBuffer);
glGenVertexArrays(1, &mVAO);
glBindVertexArray(mVAO);
return glGetError() == GL_NO_ERROR;
}
// --------------------------------------------------------------------------------------------------------------------
bool TexturedQuadsGLSparseBindlessTextureArray::Init(const std::vector<TexturedQuadsProblem::Vertex>& _vertices,
const std::vector<TexturedQuadsProblem::Index>& _indices,
const std::vector<TextureDetails*>& _textures,
size_t _objectCount)
{
if (!TexturedQuadsSolution::Init(_vertices, _indices, _textures, _objectCount)) {
return false;
}
// Prerequisites
if (!mTexManager.Init()) {
return false;
}
if (glGetTextureHandleARB == nullptr) {
console::warn("Unable to initialize solution '%s', requires support for bindless textures (not present).", GetName().c_str());
return false;
}
// Program
const char* kUniformNames[] = { "ViewProjection", "DrawID", nullptr };
mProgram = CreateProgramT("textures_gl_sparse_bindless_texture_array_vs.glsl",
"textures_gl_sparse_bindless_texture_array_fs.glsl",
kUniformNames, &mUniformLocation);
if (mProgram == 0) {
console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str());
return false;
}
// Textures
for (auto it = _textures.begin(); it != _textures.end(); ++it) {
mTextures.push_back(mTexManager.newTexture2DFromDetails(*it));
}
// Buffers
mVertexBuffer = NewBufferFromVector(GL_ARRAY_BUFFER, _vertices, GL_STATIC_DRAW);
mIndexBuffer = NewBufferFromVector(GL_ELEMENT_ARRAY_BUFFER, _indices, GL_STATIC_DRAW);
glGenBuffers(1, &mTransformBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, mTransformBuffer);
auto srcIt = mTextures.cbegin();
std::vector<TexAddress> texAddressContents(_objectCount);
for (auto dstIt = texAddressContents.begin(); dstIt != texAddressContents.end(); ++dstIt) {
if (srcIt == mTextures.cend()) {
srcIt = mTextures.cbegin();
}
(*dstIt) = (*srcIt)->GetAddress();
++srcIt;
}
mTexAddressBuffer = NewBufferFromVector(GL_SHADER_STORAGE_BUFFER, texAddressContents, GL_DYNAMIC_DRAW);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, mTexAddressBuffer);
return glGetError() == GL_NO_ERROR;
}
// --------------------------------------------------------------------------------------------------------------------
bool UntexturedObjectsGLBindless::Init(const std::vector<UntexturedObjectsProblem::Vertex>& _vertices,
const std::vector<UntexturedObjectsProblem::Index>& _indices,
size_t _objectCount)
{
if (glBufferStorage == nullptr) {
console::warn("Unable to initialize solution '%s', glBufferStorage() unavailable.", GetName().c_str());
return false;
}
if (glGetBufferParameterui64vNV == nullptr ||
glMakeBufferResidentNV == nullptr) {
console::warn("Unable to initialize solution '%s', GL_NV_shader_buffer_load unavailable.", GetName().c_str());
return false;
}
if (!UntexturedObjectsSolution::Init(_vertices, _indices, _objectCount)) {
return false;
}
// Program
const char* kUniformNames[] = { "ViewProjection", "World", nullptr };
m_prog = CreateProgramT("cubes_gl_bindless_vs.glsl",
"cubes_gl_bindless_fs.glsl",
kUniformNames, &mUniformLocation);
if (m_prog == 0) {
console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str());
return false;
}
m_ibs.resize(_objectCount);
m_ib_addrs.resize(_objectCount);
m_ib_sizes.resize(_objectCount);
m_vbs.resize(_objectCount);
m_vbo_addrs.resize(_objectCount);
m_vbo_sizes.resize(_objectCount);
glGenBuffers(_objectCount, &*m_ibs.begin());
glGenBuffers(_objectCount, &*m_vbs.begin());
for (size_t u = 0; u < _objectCount; ++u)
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibs[u]);
glBufferStorage(GL_ELEMENT_ARRAY_BUFFER, _indices.size() * sizeof(UntexturedObjectsProblem::Index), &*_indices.begin(), 0);
glGetBufferParameterui64vNV(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_GPU_ADDRESS_NV, &m_ib_addrs[u]);
glMakeBufferResidentNV(GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY);
m_ib_sizes[u] = _indices.size() * sizeof(UntexturedObjectsProblem::Index);
glBindBuffer(GL_ARRAY_BUFFER, m_vbs[u]);
glBufferStorage(GL_ARRAY_BUFFER, _vertices.size() * sizeof(UntexturedObjectsProblem::Vertex), &*_vertices.begin(), 0);
glGetBufferParameterui64vNV(GL_ARRAY_BUFFER, GL_BUFFER_GPU_ADDRESS_NV, &m_vbo_addrs[u]);
glMakeBufferResidentNV(GL_ARRAY_BUFFER, GL_READ_ONLY);
m_vbo_sizes[u] = _vertices.size() * sizeof(UntexturedObjectsProblem::Vertex);
}
return glGetError() == GL_NO_ERROR;
}
// --------------------------------------------------------------------------------------------------------------------
bool UntexturedObjectsGLDrawLoop::Init(const std::vector<UntexturedObjectsProblem::Vertex>& _vertices,
const std::vector<UntexturedObjectsProblem::Index>& _indices,
size_t _objectCount)
{
if (!UntexturedObjectsSolution::Init(_vertices, _indices, _objectCount)) {
return false;
}
// Program
const char* kUniformNames[] = { "ViewProjection", nullptr };
m_prog = CreateProgramT("cubes_gl_multi_draw_vs.glsl",
"cubes_gl_multi_draw_fs.glsl",
kUniformNames, &mUniformLocation);
if (m_prog == 0) {
console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str());
return false;
}
glGenVertexArrays(1, &m_varray);
glBindVertexArray(m_varray);
// Buffers
glGenBuffers(1, &m_vb);
glBindBuffer(GL_ARRAY_BUFFER, m_vb);
glBufferData(GL_ARRAY_BUFFER, _vertices.size() * sizeof(UntexturedObjectsProblem::Vertex), &*_vertices.begin(), GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(UntexturedObjectsProblem::Vertex), (void*) offsetof(UntexturedObjectsProblem::Vertex, pos));
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(UntexturedObjectsProblem::Vertex), (void*) offsetof(UntexturedObjectsProblem::Vertex, color));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
std::vector<uint32_t> drawids(_objectCount);
for (uint32_t i = 0; i < _objectCount; ++i) {
drawids[i] = i;
}
glGenBuffers(1, &m_drawid);
glBindBuffer(GL_ARRAY_BUFFER, m_drawid);
glBufferData(GL_ARRAY_BUFFER, drawids.size() * sizeof(uint32_t), drawids.data(), GL_STATIC_DRAW);
glVertexAttribIPointer(2, 1, GL_UNSIGNED_INT, sizeof(uint32_t), 0);
glVertexAttribDivisor(2, 1);
glEnableVertexAttribArray(2);
glGenBuffers(1, &m_ib);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ib);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, _indices.size() * sizeof(UntexturedObjectsProblem::Index), &*_indices.begin(), GL_STATIC_DRAW);
glGenBuffers(1, &m_transform_buffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_transform_buffer);
return glGetError() == GL_NO_ERROR;
}
// --------------------------------------------------------------------------------------------------------------------
bool SimpleSolution::Init(const std::vector<RotationCubeProblem::Vertex>& _vertices,
const std::vector<RotationCubeProblem::Index>& _indices,
size_t _objectCount)
{
mObjectCount = _objectCount;
mIndexCount = _indices.size();
// Program
const char* kUniformNames[] = { "gTex", nullptr };
mProgram = CreateProgramT("cubes_gl_simple_vs.glsl",
"cubes_gl_simple_fs.glsl",
kUniformNames, &mUniformLocation);
if (mProgram == 0) {
console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str());
return false;
}
glGenVertexArrays(1, &mVertexArrayObject);
glBindVertexArray(mVertexArrayObject);
GLuint UB0 = glGetUniformBlockIndex(mProgram, "UB0");
glUniformBlockBinding(mProgram, UB0, 0);
GLuint UB1 = glGetUniformBlockIndex(mProgram, "UB1");
glUniformBlockBinding(mProgram, UB1, 1);
GLint uniformBufferOffsetAlignment = 0;
glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &uniformBufferOffsetAlignment);
mMatrixStride = iceil(sizeof(Matrix), uniformBufferOffsetAlignment);
glGenBuffers(1, &mVertexBuffer);
glGenBuffers(1, &mIndexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
BufferData(GL_ARRAY_BUFFER, _vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer);
BufferData(GL_ELEMENT_ARRAY_BUFFER, _indices, GL_STATIC_DRAW);
glGenBuffers(1, &mUniformBuffer0);
glGenBuffers(1, &mUniformBuffer1);
glGenVertexArrays(1, &mVAO);
glBindVertexArray(mVAO);
mStorage.resize(mMatrixStride);
return glGetError() == GL_NO_ERROR;
}
// --------------------------------------------------------------------------------------------------------------------
bool TexturedQuadsGLNaive::Init(const std::vector<TexturedQuadsProblem::Vertex>& _vertices,
const std::vector<TexturedQuadsProblem::Index>& _indices,
const std::vector<TextureDetails*>& _textures,
size_t _objectCount)
{
if (!TexturedQuadsSolution::Init(_vertices, _indices, _textures, _objectCount)) {
return false;
}
// Program
const char* kUniformNames[] = { "ViewProjection", "World", "gTex", nullptr };
mProgram = CreateProgramT("textures_gl_naive_vs.glsl",
"textures_gl_naive_fs.glsl",
kUniformNames, &mUniformLocation);
if (mProgram == 0) {
console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str());
return false;
}
// Textures
for (auto it = _textures.begin(); it != _textures.end(); ++it) {
GLuint tex = NewTex2DFromDetails(*(*it));
if (!tex) {
console::warn("Unable to initialize solution '%s', texture creation failed.", GetName().c_str());
return false;
}
// Needs to be freed later.
mTextures.push_back(tex);
}
// Buffers
glGenVertexArrays(1, &mVertexArray);
glBindVertexArray(mVertexArray);
mVertexBuffer = NewBufferFromVector(GL_ARRAY_BUFFER, _vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(TexturedQuadsProblem::Vertex), (void*)offsetof(TexturedQuadsProblem::Vertex, pos));
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedQuadsProblem::Vertex), (void*)offsetof(TexturedQuadsProblem::Vertex, tex));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
mIndexBuffer = NewBufferFromVector(GL_ELEMENT_ARRAY_BUFFER, _indices, GL_STATIC_DRAW);
return GLRenderer::GetApiError() == GL_NO_ERROR;
}
// --------------------------------------------------------------------------------------------------------------------
bool TexturedQuadsGLNaiveUniform::Init(const std::vector<TexturedQuadsProblem::Vertex>& _vertices,
const std::vector<TexturedQuadsProblem::Index>& _indices,
const std::vector<TextureDetails*>& _textures,
size_t _objectCount)
{
if (!TexturedQuadsSolution::Init(_vertices, _indices, _textures, _objectCount)) {
return false;
}
// Program
const char* kUniformNames[] = { "ViewProjection", "DrawID", "gTex", nullptr };
mProgram = CreateProgramT("textures_gl_naive_uniform_vs.glsl",
"textures_gl_naive_uniform_fs.glsl",
kUniformNames, &mUniformLocation);
if (mProgram == 0) {
console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str());
return false;
}
glGenVertexArrays(1, &mVertexArrayObject);
glBindVertexArray(mVertexArrayObject);
// Textures
for (auto it = _textures.begin(); it != _textures.end(); ++it) {
GLuint tex = NewTex2DFromDetails(*(*it));
if (!tex) {
console::warn("Unable to initialize solution '%s', texture creation failed.", GetName().c_str());
return false;
}
// Needs to be freed later.
mTextures.push_back(tex);
}
// Buffers
mVertexBuffer = NewBufferFromVector(GL_ARRAY_BUFFER, _vertices, GL_STATIC_DRAW);
mIndexBuffer = NewBufferFromVector(GL_ELEMENT_ARRAY_BUFFER, _indices, GL_STATIC_DRAW);
glGenBuffers(1, &mTransformBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, mTransformBuffer);
return GLRenderer::GetApiError() == GL_NO_ERROR;
}
// --------------------------------------------------------------------------------------------------------------------
bool TexturedQuadsGLNoTexUniform::Init(const std::vector<TexturedQuadsProblem::Vertex>& _vertices,
const std::vector<TexturedQuadsProblem::Index>& _indices,
const std::vector<TextureDetails*>& _textures,
size_t _objectCount)
{
if (!TexturedQuadsSolution::Init(_vertices, _indices, _textures, _objectCount)) {
return false;
}
// Program
const char* kUniformNames[] = { "ViewProjection", "DrawID", nullptr };
mProgram = CreateProgramT("textures_gl_notex_uniform_vs.glsl",
"textures_gl_notex_uniform_fs.glsl",
kUniformNames, &mUniformLocation);
if (mProgram == 0) {
console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str());
return false;
}
glGenVertexArrays(1, &mVertexArrayObject);
glBindVertexArray(mVertexArrayObject);
// Buffers
mVertexBuffer = NewBufferFromVector(GL_ARRAY_BUFFER, _vertices, GL_STATIC_DRAW);
mIndexBuffer = NewBufferFromVector(GL_ELEMENT_ARRAY_BUFFER, _indices, GL_STATIC_DRAW);
glGenBuffers(1, &mTransformBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, mTransformBuffer);
glGenVertexArrays(1, &mVAO);
glBindVertexArray(mVAO);
return glGetError() == GL_NO_ERROR;
}
// --------------------------------------------------------------------------------------------------------------------
bool UntexturedObjectsGLBufferStorage::Init(const std::vector<UntexturedObjectsProblem::Vertex>& _vertices,
const std::vector<UntexturedObjectsProblem::Index>& _indices,
size_t _objectCount)
{
if (glBufferStorage == nullptr) {
console::warn("Unable to initialize solution '%s', glBufferStorage() unavailable.", GetName().c_str());
return false;
}
if (!UntexturedObjectsSolution::Init(_vertices, _indices, _objectCount)) {
return false;
}
if (mUseShaderDrawParameters && !HasExtension("GL_ARB_shader_draw_parameters")) {
console::warn("Unable to initialize solution, ARB_shader_draw_parameters is required but not available.");
return false;
}
// Program
const char* kUniformNames[] = { "ViewProjection", nullptr };
m_prog = CreateProgramT("cubes_gl_buffer_storage_vs.glsl",
"cubes_gl_buffer_storage_fs.glsl",
mUseShaderDrawParameters ? std::string("#define USE_SHADER_DRAW_PARAMETERS 1\n") : std::string(""),
kUniformNames, &mUniformLocation);
if (m_prog == 0) {
console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str());
return false;
}
glGenVertexArrays(1, &m_varray);
glBindVertexArray(m_varray);
// Buffers
glGenBuffers(1, &m_vb);
glBindBuffer(GL_ARRAY_BUFFER, m_vb);
glBufferData(GL_ARRAY_BUFFER, _vertices.size() * sizeof(UntexturedObjectsProblem::Vertex), &*_vertices.begin(), GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(UntexturedObjectsProblem::Vertex), (void*) offsetof(UntexturedObjectsProblem::Vertex, pos));
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(UntexturedObjectsProblem::Vertex), (void*) offsetof(UntexturedObjectsProblem::Vertex, color));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
// If we aren't using shader draw parameters, use the workaround instead.
if (!mUseShaderDrawParameters) {
std::vector<uint32_t> drawids(_objectCount);
for (uint32_t i = 0; i < _objectCount; ++i) {
drawids[i] = i;
}
glGenBuffers(1, &m_drawid);
glBindBuffer(GL_ARRAY_BUFFER, m_drawid);
glBufferData(GL_ARRAY_BUFFER, drawids.size() * sizeof(uint32_t), drawids.data(), GL_STATIC_DRAW);
glVertexAttribIPointer(2, 1, GL_UNSIGNED_INT, sizeof(uint32_t), 0);
glVertexAttribDivisor(2, 1);
glEnableVertexAttribArray(2);
}
glGenBuffers(1, &m_ib);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ib);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, _indices.size() * sizeof(UntexturedObjectsProblem::Index), &*_indices.begin(), GL_STATIC_DRAW);
glGenBuffers(1, &m_transform_buffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_transform_buffer);
glBufferStorage(GL_SHADER_STORAGE_BUFFER, _objectCount * 64, nullptr, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_DYNAMIC_STORAGE_BIT);
m_transform_ptr = glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, _objectCount * 64, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT);
glGenBuffers(1, &m_cmd_buffer);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, m_cmd_buffer);
glBufferStorage(GL_DRAW_INDIRECT_BUFFER, _objectCount * sizeof(DrawElementsIndirectCommand), nullptr, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_DYNAMIC_STORAGE_BIT);
m_cmd_ptr = glMapBufferRange(GL_DRAW_INDIRECT_BUFFER, 0, _objectCount * sizeof(DrawElementsIndirectCommand), GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT);
// Set the command buffer size.
m_commands.resize(_objectCount);
return glGetError() == GL_NO_ERROR;
}
// --------------------------------------------------------------------------------------------------------------------
bool TexturedQuadsGLTextureArrayUniform::Init(const std::vector<TexturedQuadsProblem::Vertex>& _vertices,
const std::vector<TexturedQuadsProblem::Index>& _indices,
const std::vector<TextureDetails*>& _textures,
size_t _objectCount)
{
if (!TexturedQuadsSolution::Init(_vertices, _indices, _textures, _objectCount)) {
return false;
}
// Prerequisites
auto numTextures = _textures.size();
if (!mTexManager.Init(false, numTextures)) {
return false;
}
// Program
const char* kUniformNames[] = { "ViewProjection", "DrawID", "TexContainer", nullptr };
mProgram = CreateProgramT("textures_gl_texture_array_uniform_vs.glsl",
"textures_gl_texture_array_uniform_fs.glsl",
kUniformNames, &mUniformLocation);
if (mProgram == 0) {
console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str());
return false;
}
// Textures
for (auto it = _textures.begin(); it != _textures.end(); ++it) {
mTextures.push_back(mTexManager.newTexture2DFromDetails(*it));
}
GLint lastTexId = -1;
GLint lastTexUnit = -1;
std::vector<DenseTexAddress> texAddress(numTextures);
for (size_t i = 0; i < numTextures; ++i) {
auto texture = mTextures[i];
auto texId = texture->GetTexId();
if (lastTexId != texId) {
lastTexId = texId;
lastTexUnit = (GLint) mTexUnits.size();
glActiveTexture(GL_TEXTURE0 + lastTexUnit);
glBindTexture(GL_TEXTURE_2D_ARRAY, texId);
mTexUnits.push_back(lastTexUnit);
}
texAddress[i].m_container_index = lastTexUnit;
texAddress[i].m_layer = ((float) texture->getSliceNum() + 0.5f) / numTextures;
}
std::vector<DenseTexAddress> texAddressContents(_objectCount);
for (uint32_t i = 0; i < _objectCount; ++i) {
texAddressContents[i] = texAddress[i % numTextures];
}
mTexAddressBuffer = NewBufferFromVector(GL_SHADER_STORAGE_BUFFER, texAddressContents, GL_DYNAMIC_DRAW);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, mTexAddressBuffer);
// Buffers
mVertexBuffer = NewBufferFromVector(GL_ARRAY_BUFFER, _vertices, GL_STATIC_DRAW);
mIndexBuffer = NewBufferFromVector(GL_ELEMENT_ARRAY_BUFFER, _indices, GL_STATIC_DRAW);
glGenBuffers(1, &mTransformBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, mTransformBuffer);
return glGetError() == GL_NO_ERROR;
}
// --------------------------------------------------------------------------------------------------------------------
bool TexturedQuadsGLTextureArrayMultiDraw::Init(const std::vector<TexturedQuadsProblem::Vertex>& _vertices,
const std::vector<TexturedQuadsProblem::Index>& _indices,
const std::vector<TextureDetails*>& _textures,
size_t _objectCount)
{
if (!TexturedQuadsSolution::Init(_vertices, _indices, _textures, _objectCount)) {
return false;
}
// Prerequisites
auto numTextures = _textures.size();
if (!mTexManager.Init(false, numTextures)) {
return false;
}
if (mUseShaderDrawParameters && !HasExtension("GL_ARB_shader_draw_parameters")) {
console::warn("Unable to initialize solution, ARB_shader_draw_parameters is required but not available.");
return false;
}
// Program
const char* kUniformNames[] = { "ViewProjection", "TexContainer", nullptr };
mProgram = CreateProgramT("textures_gl_texture_array_multidraw_vs.glsl",
"textures_gl_texture_array_multidraw_fs.glsl",
mUseShaderDrawParameters ? std::string("#define USE_SHADER_DRAW_PARAMETERS 1\n") : std::string(""),
kUniformNames, &mUniformLocation);
if (mProgram == 0) {
console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str());
return false;
}
// Textures
for (auto it = _textures.begin(); it != _textures.end(); ++it) {
mTextures.push_back(mTexManager.newTexture2DFromDetails(*it));
}
GLint lastTexId = -1;
GLint lastTexUnit = -1;
std::vector<DenseTexAddress> texAddress(numTextures);
for (size_t i = 0; i < numTextures; ++i) {
auto texture = mTextures[i];
auto texId = texture->GetTexId();
if (lastTexId != texId) {
lastTexId = texId;
lastTexUnit = (GLint) mTexUnits.size();
glActiveTexture(GL_TEXTURE0 + lastTexUnit);
glBindTexture(GL_TEXTURE_2D_ARRAY, texId);
mTexUnits.push_back(lastTexUnit);
}
texAddress[i].m_container_index = lastTexUnit;
texAddress[i].m_layer = ((float) texture->getSliceNum() + 0.5f) / numTextures;
}
std::vector<DenseTexAddress> texAddressContents(_objectCount);
for (uint32_t i = 0; i < _objectCount; ++i) {
texAddressContents[i] = texAddress[i % numTextures];
}
mTexAddressBuffer = NewBufferFromVector(GL_SHADER_STORAGE_BUFFER, texAddressContents, GL_DYNAMIC_DRAW);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, mTexAddressBuffer);
// Buffers
glGenVertexArrays(1, &mVertexArray);
glBindVertexArray(mVertexArray);
mVertexBuffer = NewBufferFromVector(GL_ARRAY_BUFFER, _vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(TexturedQuadsProblem::Vertex), (void*)offsetof(TexturedQuadsProblem::Vertex, pos));
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedQuadsProblem::Vertex), (void*)offsetof(TexturedQuadsProblem::Vertex, tex));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
// If we aren't using shader draw parameters, use the workaround instead.
if (!mUseShaderDrawParameters) {
std::vector<uint32_t> drawids(_objectCount);
for (uint32_t i = 0; i < _objectCount; ++i) {
drawids[i] = i;
}
mDrawIDBuffer = NewBufferFromVector(GL_ARRAY_BUFFER, drawids, GL_STATIC_DRAW);
glVertexAttribIPointer(2, 1, GL_UNSIGNED_INT, sizeof(uint32_t), 0);
glVertexAttribDivisor(2, 1);
glEnableVertexAttribArray(2);
}
mIndexBuffer = NewBufferFromVector(GL_ELEMENT_ARRAY_BUFFER, _indices, GL_STATIC_DRAW);
glGenBuffers(1, &mTransformBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, mTransformBuffer);
// Set the command buffer size.
m_commands.resize(_objectCount);
return glGetError() == GL_NO_ERROR;
}
// --------------------------------------------------------------------------------------------------------------------
bool UntexturedObjectsGLBindlessIndirect::Init(const std::vector<UntexturedObjectsProblem::Vertex>& _vertices,
const std::vector<UntexturedObjectsProblem::Index>& _indices,
size_t _objectCount)
{
if (glBufferStorage == nullptr) {
console::warn("Unable to initialize solution '%s', glBufferStorage() unavailable.", GetName().c_str());
return false;
}
if (glGetBufferParameterui64vNV == nullptr ||
glMakeBufferResidentNV == nullptr) {
console::warn("Unable to initialize solution '%s', GL_NV_shader_buffer_load unavailable.", GetName().c_str());
return false;
}
if (!UntexturedObjectsSolution::Init(_vertices, _indices, _objectCount)) {
return false;
}
// Program
const char* kUniformNames[] = { "ViewProjection", "World", nullptr };
m_prog = CreateProgramT("cubes_gl_bindless_indirect_vs.glsl",
"cubes_gl_bindless_indirect_fs.glsl",
kUniformNames, &mUniformLocation);
if (m_prog == 0) {
console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str());
return false;
}
m_ibs.resize(_objectCount);
m_ib_addrs.resize(_objectCount);
m_ib_sizes.resize(_objectCount);
m_vbs.resize(_objectCount);
m_vbo_addrs.resize(_objectCount);
m_vbo_sizes.resize(_objectCount);
m_commands.resize(_objectCount);
glGenBuffers(_objectCount, &*m_ibs.begin());
glGenBuffers(_objectCount, &*m_vbs.begin());
for (size_t u = 0; u < _objectCount; ++u)
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibs[u]);
glBufferStorage(GL_ELEMENT_ARRAY_BUFFER, _indices.size() * sizeof(UntexturedObjectsProblem::Index), &*_indices.begin(), 0);
glGetBufferParameterui64vNV(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_GPU_ADDRESS_NV, &m_ib_addrs[u]);
glMakeBufferResidentNV(GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY);
m_ib_sizes[u] = _indices.size() * sizeof(UntexturedObjectsProblem::Index);
glBindBuffer(GL_ARRAY_BUFFER, m_vbs[u]);
glBufferStorage(GL_ARRAY_BUFFER, _vertices.size() * sizeof(UntexturedObjectsProblem::Vertex), &*_vertices.begin(), 0);
glGetBufferParameterui64vNV(GL_ARRAY_BUFFER, GL_BUFFER_GPU_ADDRESS_NV, &m_vbo_addrs[u]);
glMakeBufferResidentNV(GL_ARRAY_BUFFER, GL_READ_ONLY);
m_vbo_sizes[u] = _vertices.size() * sizeof(UntexturedObjectsProblem::Vertex);
}
glGenBuffers(1, &m_transform_buffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_transform_buffer);
glBufferStorage(GL_SHADER_STORAGE_BUFFER, _objectCount * 64, nullptr, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_DYNAMIC_STORAGE_BIT);
m_transform_ptr = glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, _objectCount * 64, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT);
glGenBuffers(1, &m_cmd_buffer);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, m_cmd_buffer);
glBufferStorage(GL_DRAW_INDIRECT_BUFFER, _objectCount * sizeof(Command), nullptr, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_DYNAMIC_STORAGE_BIT);
m_cmd_ptr = glMapBufferRange(GL_DRAW_INDIRECT_BUFFER, 0, _objectCount * sizeof(Command), GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT);
m_queries.resize(4);
glGenQueries(kQueryCount, &*m_queries.begin());
return glGetError() == GL_NO_ERROR;
}