void OGLRenderLayout::UnbindVertexStreams(ShaderObjectPtr const & so, GLuint vao) const
{
OGLShaderObjectPtr const & ogl_so = checked_pointer_cast<OGLShaderObject>(so);
for (uint32_t i = 0; i < this->NumVertexStreams(); ++ i)
{
auto const & vertex_stream_fmt = this->VertexStreamFormat(i);
for (auto const & vs_elem : vertex_stream_fmt)
{
GLint attr = ogl_so->GetAttribLocation(vs_elem.usage, vs_elem.usage_index);
if (attr != -1)
{
if (glloader_GL_VERSION_4_5() || glloader_GL_ARB_direct_state_access())
{
glDisableVertexArrayAttrib(vao, attr);
}
else if (glloader_GL_EXT_direct_state_access())
{
glDisableVertexArrayAttribEXT(vao, attr);
}
else
{
glDisableVertexAttribArray(attr);
}
}
}
}
if (this->InstanceStream())
{
if (glloader_GL_VERSION_4_5() || glloader_GL_ARB_direct_state_access())
{
glVertexArrayBindingDivisor(vao, this->NumVertexStreams(), 0);
}
size_t const inst_format_size = this->InstanceStreamFormat().size();
for (size_t i = 0; i < inst_format_size; ++ i)
{
VertexElement const & vs_elem = this->InstanceStreamFormat()[i];
GLint attr = ogl_so->GetAttribLocation(vs_elem.usage, vs_elem.usage_index);
if (attr != -1)
{
if (glloader_GL_VERSION_4_5() || glloader_GL_ARB_direct_state_access())
{
glDisableVertexArrayAttrib(vao, attr);
}
else if (glloader_GL_EXT_direct_state_access())
{
glDisableVertexArrayAttribEXT(vao, attr);
glVertexAttribDivisor(attr, 0);
}
else
{
glDisableVertexAttribArray(attr);
glVertexAttribDivisor(attr, 0);
}
}
}
}
}
OGLTexture1D::OGLTexture1D(uint32_t width, uint32_t numMipMaps, uint32_t array_size, ElementFormat format,
uint32_t sample_count, uint32_t sample_quality, uint32_t access_hint)
: OGLTexture(TT_1D, array_size, sample_count, sample_quality, access_hint)
{
format_ = format;
if (0 == numMipMaps)
{
num_mip_maps_ = 1;
uint32_t w = width;
while (w != 1)
{
++ num_mip_maps_;
w = std::max<uint32_t>(1U, w / 2);
}
}
else
{
num_mip_maps_ = numMipMaps;
}
width_ = width;
if (glloader_GL_VERSION_4_5() || glloader_GL_ARB_direct_state_access())
{
glCreateBuffers(1, &pbo_);
}
else
{
glGenBuffers(1, &pbo_);
}
mipmap_start_offset_.resize(num_mip_maps_ + 1);
mipmap_start_offset_[0] = 0;
for (uint32_t level = 0; level < num_mip_maps_; ++ level)
{
uint32_t const w = this->Width(level);
GLsizei image_size;
if (IsCompressedFormat(format_))
{
uint32_t const block_size = NumFormatBytes(format_) * 4;
image_size = ((w + 3) / 4) * block_size;
}
else
{
uint32_t const texel_size = NumFormatBytes(format_);
image_size = w * texel_size;
}
mipmap_start_offset_[level + 1] = mipmap_start_offset_[level] + image_size;
}
}
void OGLRenderLayout::Active(ShaderObjectPtr const & so) const
{
GLuint vao;
auto iter = vaos_.find(so);
if (iter == vaos_.end())
{
if (glloader_GL_VERSION_4_5() || glloader_GL_ARB_direct_state_access())
{
glCreateVertexArrays(1, &vao);
}
else
{
glGenVertexArrays(1, &vao);
}
glBindVertexArray(vao);
vaos_.emplace(so, vao);
this->BindVertexStreams(so, vao);
}
else
{
vao = iter->second;
glBindVertexArray(vao);
if (streams_dirty_)
{
this->BindVertexStreams(so, vao);
streams_dirty_ = false;
}
}
OGLRenderEngine& re = *checked_cast<OGLRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
if (this->NumVertexStreams() > 0)
{
OGLGraphicsBuffer& stream(*checked_pointer_cast<OGLGraphicsBuffer>(this->GetVertexStream(this->NumVertexStreams() - 1)));
re.OverrideBindBufferCache(stream.GLType(), stream.GLvbo());
}
if (this->InstanceStream())
{
OGLGraphicsBuffer& stream(*checked_pointer_cast<OGLGraphicsBuffer>(this->InstanceStream()));
re.OverrideBindBufferCache(stream.GLType(), stream.GLvbo());
}
if (this->UseIndices())
{
OGLGraphicsBuffer& stream(*checked_pointer_cast<OGLGraphicsBuffer>(this->GetIndexStream()));
BOOST_ASSERT(GL_ELEMENT_ARRAY_BUFFER == stream.GLType());
stream.Active(true);
}
else
{
re.OverrideBindBufferCache(GL_ELEMENT_ARRAY_BUFFER, 0);
}
}
void OGLTexture::TexParameterf(GLenum pname, GLfloat param)
{
auto iter = tex_param_f_.find(pname);
if ((iter == tex_param_f_.end()) || (iter->second != param))
{
if (glloader_GL_VERSION_4_5() || glloader_GL_ARB_direct_state_access())
{
glTextureParameterf(texture_, pname, param);
}
else if (glloader_GL_EXT_direct_state_access())
{
glTextureParameterfEXT(texture_, target_type_, pname, param);
}
else
{
OGLRenderEngine& re = *checked_cast<OGLRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
re.BindTexture(0, target_type_, texture_);
glTexParameterf(target_type_, pname, param);
}
tex_param_f_[pname] = param;
}
}
void OGLRenderLayout::BindVertexStreams(ShaderObjectPtr const & so, GLuint vao) const
{
OGLShaderObjectPtr const & ogl_so = checked_pointer_cast<OGLShaderObject>(so);
RenderEngine& re = Context::Instance().RenderFactoryInstance().RenderEngineInstance();
uint32_t max_vertex_streams = re.DeviceCaps().max_vertex_streams;
std::vector<char> used_streams(max_vertex_streams, 0);
for (uint32_t i = 0; i < this->NumVertexStreams(); ++ i)
{
OGLGraphicsBuffer& stream(*checked_pointer_cast<OGLGraphicsBuffer>(this->GetVertexStream(i)));
uint32_t const size = this->VertexSize(i);
auto const & vertex_stream_fmt = this->VertexStreamFormat(i);
if (glloader_GL_VERSION_4_5() || glloader_GL_ARB_direct_state_access())
{
glVertexArrayVertexBuffer(vao, i, stream.GLvbo(), this->StartVertexLocation() * size, size);
}
uint32_t elem_offset = 0;
for (auto const & vs_elem : vertex_stream_fmt)
{
GLint attr = ogl_so->GetAttribLocation(vs_elem.usage, vs_elem.usage_index);
if (attr != -1)
{
GLintptr offset = elem_offset + this->StartVertexLocation() * size;
GLint const num_components = static_cast<GLint>(NumComponents(vs_elem.format));
GLenum type;
GLboolean normalized;
OGLMapping::MappingVertexFormat(type, normalized, vs_elem.format);
normalized = (((VEU_Diffuse == vs_elem.usage) || (VEU_Specular == vs_elem.usage)) && !IsFloatFormat(vs_elem.format)) ? GL_TRUE : normalized;
BOOST_ASSERT(GL_ARRAY_BUFFER == stream.GLType());
stream.Active(true);
if (glloader_GL_VERSION_4_5() || glloader_GL_ARB_direct_state_access())
{
glVertexArrayAttribFormat(vao, attr, num_components, type, normalized, elem_offset);
glVertexArrayAttribBinding(vao, attr, i);
glEnableVertexArrayAttrib(vao, attr);
}
else if (glloader_GL_EXT_direct_state_access())
{
glVertexArrayVertexAttribOffsetEXT(vao, stream.GLvbo(), attr, num_components, type,
normalized, size, offset);
glEnableVertexArrayAttribEXT(vao, attr);
}
else
{
glVertexAttribPointer(attr, num_components, type, normalized, size, reinterpret_cast<GLvoid*>(offset));
glEnableVertexAttribArray(attr);
}
used_streams[attr] = 1;
}
elem_offset += vs_elem.element_size();
}
}
if (this->InstanceStream())
{
OGLGraphicsBuffer& stream(*checked_pointer_cast<OGLGraphicsBuffer>(this->InstanceStream()));
uint32_t const instance_size = this->InstanceSize();
BOOST_ASSERT(this->NumInstances() * instance_size <= stream.Size());
if (glloader_GL_VERSION_4_5() || glloader_GL_ARB_direct_state_access())
{
glVertexArrayVertexBuffer(vao, this->NumVertexStreams(), stream.GLvbo(),
this->StartInstanceLocation() * instance_size, instance_size);
glVertexArrayBindingDivisor(vao, this->NumVertexStreams(), 1);
}
size_t const inst_format_size = this->InstanceStreamFormat().size();
uint32_t elem_offset = 0;
for (size_t i = 0; i < inst_format_size; ++ i)
{
VertexElement const & vs_elem = this->InstanceStreamFormat()[i];
GLint attr = ogl_so->GetAttribLocation(vs_elem.usage, vs_elem.usage_index);
if (attr != -1)
{
GLint const num_components = static_cast<GLint>(NumComponents(vs_elem.format));
GLenum type;
GLboolean normalized;
OGLMapping::MappingVertexFormat(type, normalized, vs_elem.format);
normalized = (((VEU_Diffuse == vs_elem.usage) || (VEU_Specular == vs_elem.usage)) && !IsFloatFormat(vs_elem.format)) ? GL_TRUE : normalized;
GLintptr offset = elem_offset + this->StartInstanceLocation() * instance_size;
BOOST_ASSERT(GL_ARRAY_BUFFER == stream.GLType());
stream.Active(true);
if (glloader_GL_VERSION_4_5() || glloader_GL_ARB_direct_state_access())
{
glVertexArrayAttribFormat(vao, attr, num_components, type, normalized, elem_offset);
glVertexArrayAttribBinding(vao, attr, this->NumVertexStreams());
glEnableVertexArrayAttrib(vao, attr);
}
else if (glloader_GL_EXT_direct_state_access())
{
glVertexArrayVertexAttribOffsetEXT(vao, stream.GLvbo(), attr, num_components, type,
normalized, instance_size, offset);
glEnableVertexArrayAttribEXT(vao, attr);
glVertexAttribDivisor(attr, 1);
}
else
{
glVertexAttribPointer(attr, num_components, type, normalized, instance_size,
reinterpret_cast<GLvoid*>(offset));
glEnableVertexAttribArray(attr);
glVertexAttribDivisor(attr, 1);
}
used_streams[attr] = 1;
}
elem_offset += vs_elem.element_size();
}
}
for (GLuint i = 0; i < max_vertex_streams; ++ i)
{
if (!used_streams[i])
{
if (glloader_GL_VERSION_4_5() || glloader_GL_ARB_direct_state_access())
{
glDisableVertexArrayAttrib(vao, i);
}
else if (glloader_GL_EXT_direct_state_access())
{
glDisableVertexArrayAttribEXT(vao, i);
}
else
{
glDisableVertexAttribArray(i);
}
}
}
}
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;
}
