static void GLTexSubImage1DBase(
GLenum target,
std::uint32_t mipLevel,
std::int32_t x,
std::uint32_t width,
const SrcImageDescriptor& imageDesc)
{
if (IsCompressedFormat(imageDesc.format))
{
glCompressedTexSubImage1D(
target,
static_cast<GLint>(mipLevel),
x,
static_cast<GLsizei>(width),
GLTypes::Map(imageDesc.format),
static_cast<GLsizei>(imageDesc.dataSize),
imageDesc.data
);
}
else
{
glTexSubImage1D(
target,
static_cast<GLint>(mipLevel),
x,
static_cast<GLsizei>(width),
GLTypes::Map(imageDesc.format),
GLTypes::Map(imageDesc.dataType),
imageDesc.data
);
}
}
void QOpenGLTextureHelper::qt_CompressedTextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *bits)
{
GLint oldTexture;
glGetIntegerv(bindingTarget, &oldTexture);
glBindTexture(target, texture);
glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, bits);
glBindTexture(target, oldTexture);
}
void Texture1D::setCompressedSubImage(int level, int x, int w, int s, const Buffer &pixels)
{
bindToTextureUnit();
pixels.bind(GL_PIXEL_UNPACK_BUFFER);
glCompressedTexSubImage1D(GL_TEXTURE_1D, level, x, w, getTextureInternalFormat(internalFormat), s, pixels.data(0));
pixels.unbind(GL_PIXEL_UNPACK_BUFFER);
assert(FrameBuffer::getError() == GL_NO_ERROR);
}
void OGLTexture1D::UpdateSubresource1D(uint32_t array_index, uint32_t level,
uint32_t x_offset, uint32_t width,
void const * data)
{
OGLRenderEngine& re = *checked_cast<OGLRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
GLint gl_internalFormat;
GLenum gl_format;
GLenum gl_type;
OGLMapping::MappingFormat(gl_internalFormat, gl_format, gl_type, format_);
re.BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
re.BindTexture(0, target_type_, texture_);
if (IsCompressedFormat(format_))
{
uint32_t const block_size = NumFormatBytes(format_) * 4;
GLsizei const image_size = ((width + 3) / 4) * block_size;
if (array_size_ > 1)
{
glCompressedTexSubImage2D(target_type_, level, x_offset, array_index,
width, 1, gl_format, image_size, data);
}
else
{
glCompressedTexSubImage1D(target_type_, level, x_offset,
width, gl_format, image_size, data);
}
}
else
{
if (array_size_ > 1)
{
glTexSubImage2D(target_type_, level, x_offset, array_index, width, 1,
gl_format, gl_type, data);
}
else
{
glTexSubImage1D(target_type_, level, x_offset, width,
gl_format, gl_type, data);
}
}
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage1DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint width, jint format, jint imageSize, jlong data_buffer_offset, jlong function_pointer) {
const GLvoid *data_address = (const GLvoid *)(intptr_t)offsetToPointer(data_buffer_offset);
glCompressedTexSubImage1DPROC glCompressedTexSubImage1D = (glCompressedTexSubImage1DPROC)((intptr_t)function_pointer);
glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data_address);
}
void GLTextureBuffer::upload(const PixelData &data, const PixelVolume &dest)
{
if((mUsage & TU_RENDERTARGET) != 0)
BS_EXCEPT(NotImplementedException, "Writing to render texture from CPU not supported.");
if ((mUsage & TU_DEPTHSTENCIL) != 0)
BS_EXCEPT(NotImplementedException, "Writing to depth stencil texture from CPU not supported.");
glBindTexture( mTarget, mTextureID );
if(PixelUtil::isCompressed(data.getFormat()))
{
if(data.getFormat() != mFormat || !data.isConsecutive())
BS_EXCEPT(InvalidParametersException,
"Compressed images must be consecutive, in the source format");
GLenum format = GLPixelUtil::getClosestGLInternalFormat(mFormat);
switch(mTarget) {
case GL_TEXTURE_1D:
if (dest.left == 0)
{
glCompressedTexImage1D(GL_TEXTURE_1D, mLevel,
format,
dest.getWidth(),
0,
data.getConsecutiveSize(),
data.getData());
}
else
{
glCompressedTexSubImage1D(GL_TEXTURE_1D, mLevel,
dest.left,
dest.getWidth(),
format, data.getConsecutiveSize(),
data.getData());
}
break;
case GL_TEXTURE_2D:
case GL_TEXTURE_CUBE_MAP:
if (dest.left == 0 && dest.top == 0)
{
glCompressedTexImage2D(mFaceTarget, mLevel,
format,
dest.getWidth(),
dest.getHeight(),
0,
data.getConsecutiveSize(),
data.getData());
}
else
{
glCompressedTexSubImage2D(mFaceTarget, mLevel,
dest.left, dest.top,
dest.getWidth(), dest.getHeight(),
format, data.getConsecutiveSize(),
data.getData());
}
break;
case GL_TEXTURE_3D:
if (dest.left == 0 && dest.top == 0 && dest.front == 0)
{
glCompressedTexImage3D(GL_TEXTURE_3D, mLevel,
format,
dest.getWidth(),
dest.getHeight(),
dest.getDepth(),
0,
data.getConsecutiveSize(),
data.getData());
}
else
{
glCompressedTexSubImage3D(GL_TEXTURE_3D, mLevel,
dest.left, dest.top, dest.front,
dest.getWidth(), dest.getHeight(), dest.getDepth(),
format, data.getConsecutiveSize(),
data.getData());
}
break;
}
}
else
{
if(data.getWidth() != data.getRowPitch())
glPixelStorei(GL_UNPACK_ROW_LENGTH, data.getRowPitch());
if(data.getHeight()*data.getWidth() != data.getSlicePitch())
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, (data.getSlicePitch()/data.getWidth()));
if(data.getLeft() > 0 || data.getTop() > 0 || data.getFront() > 0)
glPixelStorei(GL_UNPACK_SKIP_PIXELS, data.getLeft() + data.getRowPitch() * data.getTop() + data.getSlicePitch() * data.getFront());
if((data.getWidth()*PixelUtil::getNumElemBytes(data.getFormat())) & 3)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
switch(mTarget) {
case GL_TEXTURE_1D:
glTexSubImage1D(GL_TEXTURE_1D, mLevel,
dest.left,
dest.getWidth(),
GLPixelUtil::getGLOriginFormat(data.getFormat()), GLPixelUtil::getGLOriginDataType(data.getFormat()),
data.getData());
break;
case GL_TEXTURE_2D:
case GL_TEXTURE_CUBE_MAP:
glTexSubImage2D(mFaceTarget, mLevel,
dest.left, dest.top,
dest.getWidth(), dest.getHeight(),
GLPixelUtil::getGLOriginFormat(data.getFormat()), GLPixelUtil::getGLOriginDataType(data.getFormat()),
data.getData());
break;
case GL_TEXTURE_3D:
glTexSubImage3D(
GL_TEXTURE_3D, mLevel,
dest.left, dest.top, dest.front,
dest.getWidth(), dest.getHeight(), dest.getDepth(),
GLPixelUtil::getGLOriginFormat(data.getFormat()), GLPixelUtil::getGLOriginDataType(data.getFormat()),
data.getData());
break;
}
}
// Restore defaults
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_Texture);
}
void GLTextureBuffer::upload(const PixelData& data, const PixelVolume& dest)
{
if ((mUsage & TU_DEPTHSTENCIL) != 0)
{
LOGERR("Writing to depth stencil texture from CPU not supported.");
return;
}
glBindTexture(mTarget, mTextureID);
BS_CHECK_GL_ERROR();
if(PixelUtil::isCompressed(data.getFormat()))
{
// Block-compressed data cannot be smaller than 4x4, and must be a multiple of 4
const UINT32 actualWidth = Math::divideAndRoundUp(std::max(mWidth, 4U), 4U) * 4U;
const UINT32 actualHeight = Math::divideAndRoundUp(std::max(mHeight, 4U), 4U) * 4U;
const UINT32 expectedRowPitch = actualWidth;
const UINT32 expectedSlicePitch = actualWidth * actualHeight;
const bool isConsecutive = data.getRowPitch() == expectedRowPitch && data.getSlicePitch() == expectedSlicePitch;
if (data.getFormat() != mFormat || !isConsecutive)
{
LOGERR("Compressed images must be consecutive, in the source format");
return;
}
GLenum format = GLPixelUtil::getGLInternalFormat(mFormat, mHwGamma);
switch(mTarget)
{
case GL_TEXTURE_1D:
glCompressedTexSubImage1D(GL_TEXTURE_1D, mLevel,
dest.left,
dest.getWidth(),
format, data.getConsecutiveSize(),
data.getData());
BS_CHECK_GL_ERROR();
break;
case GL_TEXTURE_2D:
case GL_TEXTURE_CUBE_MAP:
glCompressedTexSubImage2D(mFaceTarget, mLevel,
dest.left, dest.top,
dest.getWidth(), dest.getHeight(),
format, data.getConsecutiveSize(),
data.getData());
BS_CHECK_GL_ERROR();
break;
case GL_TEXTURE_3D:
glCompressedTexSubImage3D(GL_TEXTURE_3D, mLevel,
dest.left, dest.top, dest.front,
dest.getWidth(), dest.getHeight(), dest.getDepth(),
format, data.getConsecutiveSize(),
data.getData());
BS_CHECK_GL_ERROR();
break;
default:
break;
}
}
else
{
if (data.getWidth() != data.getRowPitch())
{
glPixelStorei(GL_UNPACK_ROW_LENGTH, data.getRowPitch());
BS_CHECK_GL_ERROR();
}
if (data.getHeight()*data.getWidth() != data.getSlicePitch())
{
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, (data.getSlicePitch() / data.getWidth()));
BS_CHECK_GL_ERROR();
}
if (data.getLeft() > 0 || data.getTop() > 0 || data.getFront() > 0)
{
glPixelStorei(
GL_UNPACK_SKIP_PIXELS,
data.getLeft() + data.getRowPitch() * data.getTop() + data.getSlicePitch() * data.getFront());
BS_CHECK_GL_ERROR();
}
if ((data.getWidth()*PixelUtil::getNumElemBytes(data.getFormat())) & 3)
{
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
BS_CHECK_GL_ERROR();
}
switch(mTarget) {
case GL_TEXTURE_1D:
glTexSubImage1D(GL_TEXTURE_1D, mLevel,
dest.left,
dest.getWidth(),
GLPixelUtil::getGLOriginFormat(data.getFormat()), GLPixelUtil::getGLOriginDataType(data.getFormat()),
data.getData());
BS_CHECK_GL_ERROR();
break;
case GL_TEXTURE_2D:
case GL_TEXTURE_CUBE_MAP:
glTexSubImage2D(mFaceTarget, mLevel,
dest.left, dest.top,
dest.getWidth(), dest.getHeight(),
GLPixelUtil::getGLOriginFormat(data.getFormat()), GLPixelUtil::getGLOriginDataType(data.getFormat()),
data.getData());
BS_CHECK_GL_ERROR();
break;
case GL_TEXTURE_2D_ARRAY:
case GL_TEXTURE_3D:
glTexSubImage3D(
mTarget, mLevel,
dest.left, dest.top, dest.front,
dest.getWidth(), dest.getHeight(), dest.getDepth(),
GLPixelUtil::getGLOriginFormat(data.getFormat()), GLPixelUtil::getGLOriginDataType(data.getFormat()),
data.getData());
BS_CHECK_GL_ERROR();
break;
}
}
// Restore defaults
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
BS_CHECK_GL_ERROR();
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0);
BS_CHECK_GL_ERROR();
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
BS_CHECK_GL_ERROR();
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
BS_CHECK_GL_ERROR();
BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_Texture);
}
void OGLTexture1D::Unmap1D(uint32_t array_index, uint32_t level)
{
OGLRenderEngine& re = *checked_cast<OGLRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
switch (last_tma_)
{
case TMA_Read_Only:
re.BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
re.BindBuffer(GL_PIXEL_PACK_BUFFER, pbos_[array_index * num_mip_maps_ + level]);
glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
break;
case TMA_Write_Only:
case TMA_Read_Write:
{
GLint gl_internalFormat;
GLenum gl_format;
GLenum gl_type;
OGLMapping::MappingFormat(gl_internalFormat, gl_format, gl_type, format_);
uint32_t const w = this->Width(level);
re.BindTexture(0, target_type_, texture_);
re.BindBuffer(GL_PIXEL_PACK_BUFFER, 0);
re.BindBuffer(GL_PIXEL_UNPACK_BUFFER, pbos_[array_index * num_mip_maps_ + level]);
glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
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, gl_format, image_size, nullptr);
}
else
{
glCompressedTexSubImage1D(target_type_, level, 0,
w, gl_format, image_size, nullptr);
}
}
else
{
if (array_size_ > 1)
{
glTexSubImage2D(target_type_, level, 0, array_index, w, 1,
gl_format, gl_type, nullptr);
}
else
{
glTexSubImage1D(target_type_, level, 0, w, gl_format, gl_type, nullptr);
}
}
}
break;
default:
BOOST_ASSERT(false);
break;
}
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage1D(JNIEnv *__env, jclass clazz, jint target, jint level, jint xoffset, jint width, jint format, jint imageSize, jlong dataAddress, jlong __functionAddress) {
const GLvoid *data = (const GLvoid *)(intptr_t)dataAddress;
glCompressedTexSubImage1DPROC glCompressedTexSubImage1D = (glCompressedTexSubImage1DPROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
DDSTexture::DDSTexture(string filename) {
filename = FOLDER + filename;
gli::texture texture = gli::load(filename);
if (texture.empty())
return;
gli::gl GL;
gli::gl::format const Format = GL.translate(texture.format());
this->target = GL.translate(texture.target());
glGenTextures(1, &glId);
glBindTexture(target, glId);
glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, static_cast<GLint>(texture.levels() - 1));
glTexParameteri(target, GL_TEXTURE_SWIZZLE_R, Format.Swizzle[0]);
glTexParameteri(target, GL_TEXTURE_SWIZZLE_G, Format.Swizzle[1]);
glTexParameteri(target, GL_TEXTURE_SWIZZLE_B, Format.Swizzle[2]);
glTexParameteri(target, GL_TEXTURE_SWIZZLE_A, Format.Swizzle[3]);
glm::tvec3<GLsizei> const Dimensions(texture.dimensions());
GLsizei const FaceTotal = static_cast<GLsizei>(texture.layers() * texture.faces());
switch (texture.target())
{
case gli::TARGET_1D:
glTexStorage1D(target, static_cast<GLint>(texture.levels()), Format.Internal, Dimensions.x);
break;
case gli::TARGET_1D_ARRAY:
case gli::TARGET_2D:
case gli::TARGET_CUBE:
glTexStorage2D(
target, static_cast<GLint>(texture.levels()), Format.Internal,
Dimensions.x, texture.target() == gli::TARGET_2D ? Dimensions.y : FaceTotal);
break;
case gli::TARGET_2D_ARRAY:
case gli::TARGET_3D:
case gli::TARGET_CUBE_ARRAY:
glTexStorage3D(
target, static_cast<GLint>(texture.levels()), Format.Internal,
Dimensions.x, Dimensions.y, texture.target() == gli::TARGET_3D ? Dimensions.z : FaceTotal);
break;
default: assert(0); break;
}
for (std::size_t Layer = 0; Layer < texture.layers(); ++Layer) {
for (std::size_t Face = 0; Face < texture.faces(); ++Face) {
for (std::size_t Level = 0; Level < texture.levels(); ++Level)
{
GLsizei const LayerGL = static_cast<GLsizei>(Layer);
glm::tvec3<GLsizei> Dimensions(texture.dimensions(Level));
if (gli::is_target_cube(texture.target()))
target = static_cast<GLenum>(GL_TEXTURE_CUBE_MAP_POSITIVE_X + Face);
switch (texture.target())
{
case gli::TARGET_1D:
if (gli::is_compressed(texture.format()))
glCompressedTexSubImage1D(
target, static_cast<GLint>(Level), 0, Dimensions.x,
Format.Internal, static_cast<GLsizei>(texture.size(Level)),
texture.data(Layer, Face, Level));
else
glTexSubImage1D(
target, static_cast<GLint>(Level), 0, Dimensions.x, Format.External, Format.Type,
texture.data(Layer, Face, Level));
break;
case gli::TARGET_1D_ARRAY:
case gli::TARGET_2D:
case gli::TARGET_CUBE:
if (gli::is_compressed(texture.format()))
glCompressedTexSubImage2D(
target, static_cast<GLint>(Level), 0, 0,
Dimensions.x, texture.target() == gli::TARGET_1D_ARRAY ? 0 : Dimensions.y,
Format.Internal, static_cast<GLsizei>(texture.size(Level)),
texture.data(Layer, Face, Level));
else
glTexSubImage2D(
target, static_cast<GLint>(Level), 0, 0,
Dimensions.x, texture.target() == gli::TARGET_1D_ARRAY ? LayerGL : Dimensions.y,
Format.External, Format.Type, texture.data(Layer, Face, Level));
break;
case gli::TARGET_2D_ARRAY:
case gli::TARGET_3D:
case gli::TARGET_CUBE_ARRAY:
if (gli::is_compressed(texture.format()))
glCompressedTexSubImage3D(
target, static_cast<GLint>(Level), 0, 0, 0,
Dimensions.x, Dimensions.y, texture.target() == gli::TARGET_3D ? Dimensions.z : LayerGL,
Format.Internal, static_cast<GLsizei>(texture.size(Level)),
texture.data(Layer, Face, Level));
else
glTexSubImage3D(
target, static_cast<GLint>(Level), 0, 0, 0,
Dimensions.x, Dimensions.y, texture.target() == gli::TARGET_3D ? Dimensions.z : LayerGL,
Format.External, Format.Type, texture.data(Layer, Face, Level));
break;
default: assert(0); break;
}
}
}
}
glGenerateMipmap(target);
glBindTexture(target, 0);
}
void gl4es_glCompressedMultiTexSubImage1D(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data) {
text(glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data));
}
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;
}
void OGLTexture1D::Unmap1D(uint32_t array_index, uint32_t level)
{
OGLRenderEngine& re = *checked_cast<OGLRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
switch (last_tma_)
{
case TMA_Read_Only:
re.BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
re.BindBuffer(GL_PIXEL_PACK_BUFFER, pbo_);
glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
break;
case TMA_Write_Only:
case TMA_Read_Write:
{
GLint gl_internalFormat;
GLenum gl_format;
GLenum gl_type;
OGLMapping::MappingFormat(gl_internalFormat, gl_format, gl_type, format_);
uint32_t const w = this->Width(level);
re.BindTexture(0, target_type_, texture_);
re.BindBuffer(GL_PIXEL_PACK_BUFFER, 0);
re.BindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo_);
glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
GLvoid* offset = reinterpret_cast<GLvoid*>(
static_cast<GLintptr>(array_index * mipmap_start_offset_.back() + mipmap_start_offset_[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)
{
glCompressedTexSubImage2D(target_type_, level, 0, array_index,
w, 1, gl_format, image_size, offset);
}
else
{
glCompressedTexSubImage1D(target_type_, level, 0,
w, gl_format, image_size, offset);
}
}
else
{
if (array_size_ > 1)
{
glTexSubImage2D(target_type_, level, 0, array_index, w, 1,
gl_format, gl_type, offset);
}
else
{
glTexSubImage1D(target_type_, level, 0, w, gl_format, gl_type, offset);
}
}
}
break;
default:
KFL_UNREACHABLE("Invalid texture map access mode");
}
}
