bufferPtr glPixelBuffer::begin() const {
GL_API::getStateTracker().setPixelPackUnpackAlignment();
glNamedBufferSubData(_pixelBufferHandle, 0, _bufferSize, NULL);
GL_API::getStateTracker().setActiveBuffer(GL_PIXEL_UNPACK_BUFFER, _pixelBufferHandle);
switch (_pbtype) {
case PBType::PB_TEXTURE_1D:
glTextureSubImage1D(_textureID,
0,
0,
_width,
_format,
_dataType,
NULL);
break;
case PBType::PB_TEXTURE_2D:
glTextureSubImage2D(_textureID,
0,
0,
0,
_width,
_height,
_format,
_dataType,
NULL);
break;
case PBType::PB_TEXTURE_3D:
glTextureSubImage3D(_textureID,
0,
0,
0,
0,
_width,
_height,
_depth,
_format,
_dataType,
NULL);
break;
};
return glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY);
}
PIGLIT_GL_TEST_CONFIG_END
/** Test texture size errors and subtexture position errors */
static bool
test_pos_and_sizes(void)
{
bool pass = true;
GLuint name;
/* all of these should generate GL_INVALID_VALUE */
glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, -16, 0, GL_RGBA, GL_FLOAT, NULL);
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, -6, -5, 0, GL_RGBA, GL_FLOAT, NULL);
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
glTexImage2D(GL_TEXTURE_2D, -2, GL_RGBA, 16, 16, 0, GL_RGBA, GL_FLOAT, NULL);
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
glTexImage2D(GL_TEXTURE_2D, 2000, GL_RGBA, 16, 16, 0, GL_RGBA, GL_FLOAT, NULL);
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
/* Setup dsa. */
glCreateTextures(GL_TEXTURE_2D, 1, &name);
glBindTextureUnit(0, name); /* Since next command isn't bindless. */
/* setup valid 2D texture for subsequent TexSubImage calls */
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_FLOAT, NULL);
glTextureSubImage2D(name, 0, 6, 6, 100, 100, GL_RGBA, GL_FLOAT, NULL);
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
glTextureSubImage2D(name, 0, -6, -6, 10, 10, GL_RGBA, GL_FLOAT, NULL);
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
glCopyTextureSubImage2D(name, 0, -6, -6, 2, 2, 10, 10);
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
glCopyTextureSubImage2D(name, 0, 6, 6, 2, 2, 200, 200);
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
/* mipmap level 1 doesn't exist */
glTextureSubImage2D(name, 1, 0, 0, 8, 8, GL_RGBA, GL_FLOAT, NULL);
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
/* mipmap level 2 doesn't exist */
glCopyTextureSubImage2D(name, 2, 0, 0, 0, 0, 4, 4);
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
/* To test 1D and 3D entry points, let's try using the wrong functions. */
glTextureSubImage1D(name, 0, 0, 4, GL_RGBA, GL_FLOAT, NULL);
pass = piglit_check_gl_error(GL_INVALID_ENUM) && pass;
glTextureSubImage3D(name, 0, 0, 0, 0, 4, 4, 4, GL_RGBA, GL_FLOAT, NULL);
pass = piglit_check_gl_error(GL_INVALID_ENUM) && pass;
glCopyTextureSubImage1D(name, 0, 0, 0, 0, 4);
pass = piglit_check_gl_error(GL_INVALID_ENUM) && pass;
glCopyTextureSubImage3D(name, 0, 0, 0, 0, 0, 0, 4, 4);
pass = piglit_check_gl_error(GL_INVALID_ENUM) && pass;
return pass;
}
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;
}
