void MainComponent::start() {
if (isRunning) {
return;
}
static const float vertices[] =
{
0.25, -0.25, 0.5, 1.0,
-0.25, -0.25, 0.5, 1.0,
0.25, 0.25, 0.5, 1.0
};
Shader shader = Shader();
glUseProgram(shader._program);
GLuint vbo;
glCreateBuffers(1, &vbo);
glCreateVertexArrays(1, &_vao);
glBindVertexArray(_vao);
glNamedBufferStorage(vbo, sizeof(vertices), vertices, 0);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glVertexArrayVertexBuffer(_vao, 0, vbo, 0, 16);
glVertexArrayAttribFormat(_vao, 0, 4, GL_FLOAT, GL_FALSE, 0);
glVertexArrayAttribBinding(_vao, 0, 0);
glEnableVertexArrayAttrib(_vao, 0);
glEnableVertexAttribArray(0);
run();
}
bool initBuffer()
{
bool Validated(true);
GLint MaxVertexAtomicCounterBuffers(0);
GLint MaxControlAtomicCounterBuffers(0);
GLint MaxEvaluationAtomicCounterBuffers(0);
GLint MaxGeometryAtomicCounterBuffers(0);
GLint MaxFragmentAtomicCounterBuffers(0);
GLint MaxCombinedAtomicCounterBuffers(0);
glGetIntegerv(GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS, &MaxVertexAtomicCounterBuffers);
glGetIntegerv(GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS, &MaxControlAtomicCounterBuffers);
glGetIntegerv(GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS, &MaxEvaluationAtomicCounterBuffers);
glGetIntegerv(GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS, &MaxGeometryAtomicCounterBuffers);
glGetIntegerv(GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS, &MaxFragmentAtomicCounterBuffers);
glGetIntegerv(GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS, &MaxCombinedAtomicCounterBuffers);
glCreateBuffers(buffer::MAX, &BufferName[0]);
glNamedBufferStorage(BufferName[buffer::VERTEX], VertexSize, VertexData, 0);
glNamedBufferStorage(BufferName[buffer::ELEMENT], ElementSize, ElementData, 0);
glNamedBufferStorage(BufferName[buffer::ATOMIC_COUNTER], sizeof(GLuint), nullptr, 0);
glNamedBufferStorage(BufferName[buffer::TRANSFORM], sizeof(glm::mat4), nullptr, GL_MAP_WRITE_BIT);
return Validated;
}
bool initBuffer()
{
GLint UniformBufferOffset(0);
glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &UniformBufferOffset);
GLint UniformBlockSize = glm::max(GLint(sizeof(glm::mat4)), UniformBufferOffset);
glCreateBuffers(buffer::MAX, &BufferName[0]);
glNamedBufferStorage(BufferName[buffer::ELEMENT], ElementSize, ElementData, 0);
glNamedBufferStorage(BufferName[buffer::VERTEX], VertexSize, VertexData, 0);
glNamedBufferStorage(BufferName[buffer::TRANSFORM], UniformBlockSize, nullptr, GL_MAP_WRITE_BIT);
return true;
}
bool initBuffer()
{
GLint UniformBufferOffset(0);
glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &UniformBufferOffset);
this->UniformBlockSize = glm::max(GLint(sizeof(glm::mat4)), UniformBufferOffset);
glCreateBuffers(buffer::MAX, &BufferName[0]);
glNamedBufferStorage(BufferName[buffer::ELEMENT], ElementSize, ElementData, 0);
glNamedBufferStorage(BufferName[buffer::VERTEX], VertexSize, VertexData, 0);
glNamedBufferStorage(BufferName[buffer::TRANSFORM], this->UniformBlockSize * 2, nullptr, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
this->UniformPointer = static_cast<glm::uint8*>(glMapNamedBufferRange(
BufferName[buffer::TRANSFORM], 0, this->UniformBlockSize * 2, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT | GL_MAP_INVALIDATE_BUFFER_BIT));
return true;
}
void startup()
{
rendering_program = compile_shaders();
GLuint buffer[2];
GLuint vao;
static const GLfloat positions[] = { 0.25f, -0.25f, 0.5f, 1.0f,
-0.25f, -0.25f, 0.5f, 1.0f,
0.25f, 0.25f, 0.5f, 1.0f };
static const GLfloat colors[] = { 1.0, 0.0, 0.0, 1.0,
1.0, 0.0, 0.0, 1.0,
1.0, 0.0, 0.0, 1.0 };
// Create the vertex array object.
glCreateVertexArrays(1, &vao);
// Create two buffers.
glCreateBuffers(2, &buffer[0]);
// Initialize the first buffer.
glNamedBufferStorage(buffer[0], sizeof(positions), positions, 0);
// Bind it to the vertex array - offset zero, stride = sizeof(vec4)
glVertexArrayVertexBuffer(vao, 0, buffer[0], 0, sizeof(vmath::vec4));
// Tell OpenGL what the format of the attribute is.
glVertexArrayAttribFormat(vao, 0, 4, GL_FLOAT, GL_FALSE, 0);
// Tell OpenGL which vertex buffer binding to use for this attribute.
glVertexArrayAttribBinding(vao, 0, 0);
// Enable the attribute.
glEnableVertexArrayAttrib(vao, 0);
// Perform similar initialization for the second buffer.
glNamedBufferStorage(buffer[1], sizeof(colors), colors, 0);
glVertexArrayVertexBuffer(vao, 1, buffer[1], 0, sizeof(vmath::vec4));
glVertexArrayAttribFormat(vao, 1, 4, GL_FLOAT, GL_FALSE, 0);
glVertexArrayAttribBinding(vao, 1, 1);
glEnableVertexArrayAttrib(vao, 1);
glEnableVertexAttribArray(1);
glBindVertexArray(vao);
}
bufferPtr allocPersistentBuffer(GLuint bufferId,
GLsizeiptr bufferSize,
BufferStorageMask storageMask,
BufferAccessMask accessMask,
const bufferPtr data) {
glNamedBufferStorage(bufferId, bufferSize, data, storageMask);
bufferPtr ptr = glMapNamedBufferRange(bufferId, 0, bufferSize, accessMask);
assert(ptr != NULL);
return ptr;
}
impl(int size, bool write)
: size_(size)
, write_(write)
, target_(!write ? GL_PIXEL_PACK_BUFFER : GL_PIXEL_UNPACK_BUFFER)
, flags_(GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT | (write ? GL_MAP_WRITE_BIT : GL_MAP_READ_BIT))
{
GL(glCreateBuffers(1, &id_));
GL(glNamedBufferStorage(id_, size_, nullptr, flags_));
data_ = GL2(glMapNamedBufferRange(id_, 0, size_, flags_));
}
bool initBuffer()
{
GLint const Alignement = 256;
GLint BufferPageSize = 0;
glGetIntegerv(GL_SPARSE_BUFFER_PAGE_SIZE_ARB, &BufferPageSize);
bool Validated(true);
GLintptr CopyBufferSize = glm::ceilMultiple<GLint>(VertexSize, Alignement) + glm::ceilMultiple<GLint>(ElementSize, Alignement);
glCreateBuffers(buffer::MAX, &BufferName[0]);
glNamedBufferStorage(BufferName[buffer::COPY], CopyBufferSize, nullptr, GL_MAP_WRITE_BIT);
glm::byte* CopyBufferPointer = reinterpret_cast<glm::byte*>(glMapNamedBufferRange(BufferName[buffer::COPY], 0, CopyBufferSize, GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT));
memcpy(CopyBufferPointer + 0, VertexData, VertexSize);
memcpy(CopyBufferPointer + glm::ceilMultiple<GLint>(VertexSize, Alignement), ElementData, ElementSize);
glUnmapNamedBuffer(BufferName[buffer::COPY]);
glBindBuffer(GL_COPY_READ_BUFFER, BufferName[buffer::COPY]);
glBindBuffer(GL_COPY_WRITE_BUFFER, BufferName[buffer::ELEMENT]);
glBufferStorage(GL_COPY_WRITE_BUFFER, glm::ceilMultiple<GLint>(ElementSize, BufferPageSize), nullptr, GL_SPARSE_STORAGE_BIT_ARB);
glBufferPageCommitmentARB(GL_COPY_WRITE_BUFFER, 0, BufferPageSize, GL_TRUE);
glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, glm::ceilMultiple<GLint>(VertexSize, Alignement), 0, glm::ceilMultiple<GLint>(ElementSize, Alignement));
glBindBuffer(GL_COPY_WRITE_BUFFER, BufferName[buffer::VERTEX]);
glBufferStorage(GL_COPY_WRITE_BUFFER, glm::ceilMultiple<GLint>(VertexSize, BufferPageSize), nullptr, GL_SPARSE_STORAGE_BIT_ARB);
glBufferPageCommitmentARB(GL_COPY_WRITE_BUFFER, 0, BufferPageSize, GL_TRUE);
glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, glm::ceilMultiple<GLint>(VertexSize, Alignement));
GLint UniformBufferOffset(0);
glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &UniformBufferOffset);
GLint UniformBlockSize = glm::max(GLint(sizeof(glm::mat4)), UniformBufferOffset);
glNamedBufferStorage(BufferName[buffer::TRANSFORM], UniformBlockSize, nullptr, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
return Validated;
}
GLuint Mesh_Setup(GLuint shader_prog, struct Vertex *verts, GLuint num_verts)
{
GLuint vao;
glCreateVertexArrays(1, &vao);
GLuint pos_attrib_loc = glGetAttribLocation(shader_prog, "pos");
GLuint col_attrib_loc = glGetAttribLocation(shader_prog, "col");
glVertexArrayAttribFormat(vao, pos_attrib_loc, 3, GL_FLOAT, GL_FALSE, (GLuint)offsetof(struct Vertex, pos));
glVertexArrayAttribFormat(vao, col_attrib_loc, 4, GL_FLOAT, GL_FALSE, (GLuint)offsetof(struct Vertex, col));
glVertexArrayAttribBinding(vao, pos_attrib_loc, 0);
glVertexArrayAttribBinding(vao, col_attrib_loc, 0);
glEnableVertexArrayAttrib(vao, pos_attrib_loc);
glEnableVertexArrayAttrib(vao, col_attrib_loc);
GLuint vbo;
glCreateBuffers(1, &vbo);
glNamedBufferStorage(vbo, sizeof(struct Vertex) * num_verts, verts, 0);
glVertexArrayVertexBuffer(vao, 0, vbo, 0, sizeof(struct Vertex));
return vao;
}
void BufferImplementation_DirectStateAccessARB::setStorage(const Buffer * buffer, GLsizeiptr size, const GLvoid * data, MapBufferUsageMask flags) const
{
glNamedBufferStorage(buffer->id(), static_cast<GLsizei>(size), data, flags);
}
void OGLTexture1D::CreateHWResource(ArrayRef<ElementInitData> init_data, float4 const * clear_value_hint)
{
KFL_UNUSED(clear_value_hint);
GLint glinternalFormat;
GLenum glformat;
GLenum gltype;
OGLMapping::MappingFormat(glinternalFormat, glformat, gltype, format_);
if (sample_count_ <= 1)
{
uint32_t const pbo_size = mipmap_start_offset_.back() * array_size_;
if (glloader_GL_VERSION_4_5() || glloader_GL_ARB_direct_state_access())
{
glTextureParameteri(texture_, GL_TEXTURE_MAX_LEVEL, num_mip_maps_ - 1);
glNamedBufferStorage(pbo_, pbo_size, nullptr, GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_DYNAMIC_STORAGE_BIT);
uint32_t const w0 = this->Width(0);
if (array_size_ > 1)
{
glTextureStorage2D(texture_, num_mip_maps_, glinternalFormat, w0, array_size_);
}
else
{
glTextureStorage1D(texture_, num_mip_maps_, glinternalFormat, w0);
}
if (!init_data.empty())
{
for (uint32_t array_index = 0; array_index < array_size_; ++ array_index)
{
for (uint32_t level = 0; level < num_mip_maps_; ++ level)
{
uint32_t const w = this->Width(level);
GLvoid const * data = init_data[array_index * num_mip_maps_ + level].data;
if (IsCompressedFormat(format_))
{
uint32_t const block_size = NumFormatBytes(format_) * 4;
GLsizei const image_size = ((w + 3) / 4) * block_size;
if (array_size_ > 1)
{
glCompressedTextureSubImage2D(texture_, level, 0, array_index,
w, 1, glformat, image_size, data);
}
else
{
glCompressedTextureSubImage1D(texture_, level, 0,
w, glformat, image_size, data);
}
}
else
{
if (array_size_ > 1)
{
glTextureSubImage2D(texture_, level, 0, array_index, w, 1,
glformat, gltype, data);
}
else
{
glTextureSubImage1D(texture_, level, 0, w, glformat, gltype, data);
}
}
}
}
}
}
else
{
auto& re = *checked_cast<OGLRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
re.BindTexture(0, target_type_, texture_);
glTexParameteri(target_type_, GL_TEXTURE_MAX_LEVEL, num_mip_maps_ - 1);
re.BindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo_);
if (glloader_GL_VERSION_4_4() || glloader_GL_ARB_buffer_storage())
{
glBufferStorage(GL_PIXEL_UNPACK_BUFFER, pbo_size, nullptr, GL_DYNAMIC_STORAGE_BIT);
}
else
{
glBufferData(GL_PIXEL_UNPACK_BUFFER, pbo_size, nullptr, GL_STREAM_COPY);
}
re.BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
if (glloader_GL_VERSION_4_2() || glloader_GL_ARB_texture_storage())
{
uint32_t const w0 = this->Width(0);
if (array_size_ > 1)
{
glTexStorage2D(target_type_, num_mip_maps_, glinternalFormat, w0, array_size_);
}
else
{
glTexStorage1D(target_type_, num_mip_maps_, glinternalFormat, w0);
}
if (!init_data.empty())
{
for (uint32_t array_index = 0; array_index < array_size_; ++ array_index)
{
for (uint32_t level = 0; level < num_mip_maps_; ++ level)
{
uint32_t const w = this->Width(level);
GLvoid const * data = init_data[array_index * num_mip_maps_ + level].data;
if (IsCompressedFormat(format_))
{
uint32_t const block_size = NumFormatBytes(format_) * 4;
GLsizei const image_size = ((w + 3) / 4) * block_size;
if (array_size_ > 1)
{
glCompressedTexSubImage2D(target_type_, level, 0, array_index,
w, 1, glformat, image_size, data);
}
else
{
glCompressedTexSubImage1D(target_type_, level, 0,
w, glformat, image_size, data);
}
}
else
{
if (array_size_ > 1)
{
glTexSubImage2D(target_type_, level, 0, array_index, w, 1,
glformat, gltype, data);
}
else
{
glTexSubImage1D(target_type_, level, 0, w, glformat, gltype, data);
}
}
}
}
}
}
else
{
for (uint32_t array_index = 0; array_index < array_size_; ++ array_index)
{
for (uint32_t level = 0; level < num_mip_maps_; ++ level)
{
uint32_t const w = this->Width(level);
if (IsCompressedFormat(format_))
{
uint32_t const block_size = NumFormatBytes(format_) * 4;
GLsizei const image_size = ((w + 3) / 4) * block_size;
if (array_size_ > 1)
{
if (0 == array_index)
{
glCompressedTexImage2D(target_type_, level, glinternalFormat,
w, array_size_, 0, image_size * array_size_, nullptr);
}
if (!init_data.empty())
{
glCompressedTexSubImage2D(target_type_, level, 0, array_index, w, 1,
glformat, image_size, init_data[array_index * num_mip_maps_ + level].data);
}
}
else
{
glCompressedTexImage1D(target_type_, level, glinternalFormat,
w, 0, image_size,
init_data.empty() ? nullptr : init_data[array_index * num_mip_maps_ + level].data);
}
}
else
{
if (array_size_ > 1)
{
if (0 == array_index)
{
glTexImage2D(target_type_, level, glinternalFormat, w, array_size_, 0, glformat, gltype, nullptr);
}
if (!init_data.empty())
{
glTexSubImage2D(target_type_, level, 0, array_index, w, 1,
glformat, gltype, init_data[array_index * num_mip_maps_ + level].data);
}
}
else
{
glTexImage1D(target_type_, level, glinternalFormat, w, 0, glformat, gltype,
init_data.empty() ? nullptr : init_data[array_index * num_mip_maps_ + level].data);
}
}
}
}
}
}
}
else
{
glBindRenderbuffer(GL_RENDERBUFFER, texture_);
glRenderbufferStorageMultisample(GL_RENDERBUFFER, sample_count_, glinternalFormat, width_, 1);
}
hw_res_ready_ = true;
}