void LightSource::SkylightTex(TexturePtr const & tex_y, TexturePtr const & tex_c)
{
KFL_UNUSED(tex_y);
KFL_UNUSED(tex_c);
KFL_UNREACHABLE("Can't be called");
}
D3D11_SHADER_RESOURCE_VIEW_DESC D3D11TextureCube::FillSRVDesc(uint32_t first_array_index, uint32_t num_items,
uint32_t first_level, uint32_t num_levels) const
{
BOOST_ASSERT(0 == first_array_index);
BOOST_ASSERT(1 == num_items);
KFL_UNUSED(first_array_index);
KFL_UNUSED(num_items);
D3D11_SHADER_RESOURCE_VIEW_DESC desc;
switch (format_)
{
case EF_D16:
desc.Format = DXGI_FORMAT_R16_UNORM;
break;
case EF_D24S8:
desc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
break;
case EF_D32F:
desc.Format = DXGI_FORMAT_R32_FLOAT;
break;
default:
desc.Format = dxgi_fmt_;
break;
}
desc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURECUBE;
desc.TextureCube.MostDetailedMip = first_level;
desc.TextureCube.MipLevels = num_levels;
return desc;
}
void OGLESRenderWindow::WindowMovedOrResized(Window const & win)
{
WindowPtr const & main_wnd = Context::Instance().AppInstance().MainWnd();
float const dpi_scale = main_wnd->DPIScale();
#if defined KLAYGE_PLATFORM_WINDOWS
KFL_UNUSED(win);
::RECT rect;
::GetClientRect(hWnd_, &rect);
uint32_t new_left = static_cast<uint32_t>(rect.left * dpi_scale + 0.5f);
uint32_t new_top = static_cast<uint32_t>(rect.top * dpi_scale + 0.5f);
if ((new_left != left_) || (new_top != top_))
{
this->Reposition(new_left, new_top);
}
uint32_t new_width = rect.right - rect.left;
uint32_t new_height = rect.bottom - rect.top;
#elif defined KLAYGE_PLATFORM_LINUX
int screen = DefaultScreen(x_display_);
uint32_t new_width = DisplayWidth(x_display_, screen);
uint32_t new_height = DisplayHeight(x_display_, screen);
#elif defined KLAYGE_PLATFORM_ANDROID
// TODO: Is it correct?
uint32_t new_left = win.Left() / 2;
uint32_t new_top = win.Top() / 2;
if ((new_left != left_) || (new_top != top_))
{
this->Reposition(new_left, new_top);
}
EGLint w, h;
eglQuerySurface(display_, surf_, EGL_WIDTH, &w);
eglQuerySurface(display_, surf_, EGL_HEIGHT, &h);
uint32_t new_width = w - new_left;
uint32_t new_height = h - new_top;
#elif defined KLAYGE_PLATFORM_DARWIN
KFL_UNUSED(win);
uint2 screen = Context::Instance().AppInstance().MainWnd()->GetNSViewSize();
uint32_t new_width = screen[0];
uint32_t new_height = screen[1];
#elif defined KLAYGE_PLATFORM_IOS
KFL_UNUSED(win);
uint2 screen = Context::Instance().AppInstance().MainWnd()->GetGLKViewSize();
uint32_t new_width = screen[0];
uint32_t new_height = screen[1];
#endif
new_width = static_cast<uint32_t>(new_width * dpi_scale + 0.5f);
new_height = static_cast<uint32_t>(new_height * dpi_scale + 0.5f);
if ((new_width != width_) || (new_height != height_))
{
Context::Instance().RenderFactoryInstance().RenderEngineInstance().Resize(new_width, new_height);
}
}
uint32_t D3D11Texture::Depth(uint32_t level) const
{
KFL_UNUSED(level);
BOOST_ASSERT(level < num_mip_maps_);
return 1;
}
uint32_t OGLESTexture::Width(uint32_t level) const
{
KFL_UNUSED(level);
BOOST_ASSERT(level < num_mip_maps_);
return 1;
}
D3D12UnorderedAccessViewSimulationPtr const & D3D12Texture3D::RetriveD3DUnorderedAccessView(uint32_t first_array_index, uint32_t num_items, uint32_t level)
{
BOOST_ASSERT(this->AccessHint() & EAH_GPU_Unordered);
BOOST_ASSERT(0 == first_array_index);
BOOST_ASSERT(1 == num_items);
KFL_UNUSED(num_items);
return this->RetriveD3DUnorderedAccessView(first_array_index, 0, depth_, level);
}
NullSoundBuffer::NullSoundBuffer(AudioDataSourcePtr const & data_source, uint32_t num_sources, float volume)
: SoundBuffer(data_source)
{
KFL_UNUSED(num_sources);
this->Position(float3(0, 0, 0));
this->Velocity(float3(0, 0, 0));
this->Direction(float3(0, 0, 0));
this->Reset();
this->Volume(volume);
}
D3D12UnorderedAccessViewSimulationPtr const & D3D12Texture3D::RetriveD3DUnorderedAccessView(uint32_t array_index, uint32_t first_slice, uint32_t num_slices, uint32_t level)
{
BOOST_ASSERT(0 == array_index);
KFL_UNUSED(array_index);
D3D12_UNORDERED_ACCESS_VIEW_DESC desc;
desc.Format = dxgi_fmt_;
desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE3D;
desc.Texture3D.MipSlice = level;
desc.Texture3D.FirstWSlice = first_slice;
desc.Texture3D.WSize = num_slices;
return this->RetriveD3DUAV(desc);
}
D3D12ShaderResourceViewSimulationPtr const & D3D12Texture3D::RetriveD3DShaderResourceView(uint32_t first_array_index, uint32_t num_items, uint32_t first_level, uint32_t num_levels)
{
BOOST_ASSERT(this->AccessHint() & EAH_GPU_Read);
BOOST_ASSERT(0 == first_array_index);
BOOST_ASSERT(1 == num_items);
KFL_UNUSED(first_array_index);
KFL_UNUSED(num_items);
D3D12_SHADER_RESOURCE_VIEW_DESC desc;
switch (format_)
{
case EF_D16:
desc.Format = DXGI_FORMAT_R16_UNORM;
break;
case EF_D24S8:
desc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
break;
case EF_D32F:
desc.Format = DXGI_FORMAT_R32_FLOAT;
break;
default:
desc.Format = dxgi_fmt_;
break;
}
desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE3D;
desc.Texture3D.MostDetailedMip = first_level;
desc.Texture3D.MipLevels = num_levels;
desc.Texture3D.ResourceMinLODClamp = 0;
return this->RetriveD3DSRV(desc);
}
D3D12RenderTargetViewSimulationPtr const & D3D12Texture3D::RetriveD3DRenderTargetView(uint32_t array_index, uint32_t first_slice, uint32_t num_slices, uint32_t level)
{
BOOST_ASSERT(this->AccessHint() & EAH_GPU_Write);
BOOST_ASSERT(0 == array_index);
KFL_UNUSED(array_index);
D3D12_RENDER_TARGET_VIEW_DESC desc;
desc.Format = D3D12Mapping::MappingFormat(this->Format());
desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE3D;
desc.Texture3D.MipSlice = level;
desc.Texture3D.FirstWSlice = first_slice;
desc.Texture3D.WSize = num_slices;
return this->RetriveD3DRTV(desc);
}
D3D12_SHADER_RESOURCE_VIEW_DESC D3D12TextureCube::FillSRVDesc(uint32_t first_array_index, uint32_t num_items, uint32_t first_level,
uint32_t num_levels) const
{
BOOST_ASSERT(0 == first_array_index);
BOOST_ASSERT(1 == num_items);
KFL_UNUSED(first_array_index);
KFL_UNUSED(num_items);
D3D12_SHADER_RESOURCE_VIEW_DESC desc;
switch (format_)
{
case EF_D16:
desc.Format = DXGI_FORMAT_R16_UNORM;
break;
case EF_D24S8:
desc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
break;
case EF_D32F:
desc.Format = DXGI_FORMAT_R32_FLOAT;
break;
default:
desc.Format = dxgi_fmt_;
break;
}
desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBE;
desc.TextureCube.MostDetailedMip = first_level;
desc.TextureCube.MipLevels = num_levels;
desc.TextureCube.ResourceMinLODClamp = 0;
return desc;
}
MemStreamBuf::pos_type MemStreamBuf::seekpos(pos_type sp, std::ios_base::openmode which)
{
BOOST_ASSERT(which == std::ios_base::in);
KFL_UNUSED(which);
if (sp < end_ - begin_)
{
current_ = begin_ + static_cast<int>(sp);
}
else
{
sp = -1;
}
return sp;
}
MemStreamBuf::pos_type MemStreamBuf::seekoff(off_type off, std::ios_base::seekdir way,
std::ios_base::openmode which)
{
BOOST_ASSERT(which == std::ios_base::in);
KFL_UNUSED(which);
switch (way)
{
case std::ios_base::beg:
if (off <= end_ - begin_)
{
current_ = begin_ + off;
}
else
{
off = -1;
}
break;
case std::ios_base::end:
if (end_ - off >= begin_)
{
current_ = end_ - off;
off = current_ - begin_;
}
else
{
off = -1;
}
break;
case std::ios_base::cur:
default:
if (current_ + off <= end_)
{
current_ += off;
off = current_ - begin_;
}
else
{
off = -1;
}
break;
}
return off;
}
void OGLESTexture3D::Map3D(uint32_t array_index, uint32_t level, TextureMapAccess tma,
uint32_t x_offset, uint32_t y_offset, uint32_t z_offset,
uint32_t /*width*/, uint32_t /*height*/, uint32_t /*depth*/,
void*& data, uint32_t& row_pitch, uint32_t& slice_pitch)
{
BOOST_ASSERT(0 == array_index);
KFL_UNUSED(array_index);
last_tma_ = tma;
uint32_t const texel_size = NumFormatBytes(format_);
uint32_t const w = this->Width(level);
uint32_t const h = this->Height(level);
row_pitch = w * texel_size;
slice_pitch = row_pitch * h;
uint8_t* p = &tex_data_[level][0];
data = p + ((z_offset * h + y_offset) * w + x_offset) * texel_size;
}
D3D12DepthStencilViewSimulationPtr const & D3D12Texture3D::RetriveD3DDepthStencilView(uint32_t array_index, uint32_t first_slice, uint32_t num_slices, uint32_t level)
{
BOOST_ASSERT(this->AccessHint() & EAH_GPU_Write);
BOOST_ASSERT(0 == array_index);
KFL_UNUSED(array_index);
D3D12_DEPTH_STENCIL_VIEW_DESC desc;
desc.Format = D3D12Mapping::MappingFormat(this->Format());
desc.Flags = D3D12_DSV_FLAG_NONE;
if (this->SampleCount() > 1)
{
desc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY;
}
else
{
desc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2DARRAY;
}
desc.Texture2DArray.MipSlice = level;
desc.Texture2DArray.ArraySize = num_slices;
desc.Texture2DArray.FirstArraySlice = first_slice;
return this->RetriveD3DDSV(desc);
}
void D3D11TextureCube::CreateHWResource(ArrayRef<ElementInitData> init_data, float4 const * clear_value_hint)
{
KFL_UNUSED(clear_value_hint);
D3D11_TEXTURE2D_DESC desc;
desc.Width = width_;
desc.Height = width_;
desc.MipLevels = num_mip_maps_;
desc.ArraySize = 6 * array_size_;
desc.Format = D3D11Mapping::MappingFormat(format_);
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
this->GetD3DFlags(desc.Usage, desc.BindFlags, desc.CPUAccessFlags, desc.MiscFlags);
desc.MiscFlags |= D3D11_RESOURCE_MISC_TEXTURECUBE;
std::vector<D3D11_SUBRESOURCE_DATA> subres_data;
if (!init_data.empty())
{
BOOST_ASSERT(init_data.size() == 6 * array_size_ * num_mip_maps_);
subres_data.resize(init_data.size());
for (size_t i = 0; i < init_data.size(); ++ i)
{
subres_data[i].pSysMem = init_data[i].data;
subres_data[i].SysMemPitch = init_data[i].row_pitch;
subres_data[i].SysMemSlicePitch = init_data[i].slice_pitch;
}
}
ID3D11Texture2D* d3d_tex;
TIFHR(d3d_device_->CreateTexture2D(&desc, subres_data.data(), &d3d_tex));
d3d_texture_ = MakeCOMPtr(d3d_tex);
if ((access_hint_ & (EAH_GPU_Read | EAH_Generate_Mips)) && (num_mip_maps_ > 1))
{
this->RetriveD3DShaderResourceView(0, array_size_, 0, num_mip_maps_);
}
}
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 NullSoundBuffer::Play(bool loop)
{
KFL_UNUSED(loop);
}
void NullSoundBuffer::Volume(float vol)
{
KFL_UNUSED(vol);
}
void OGLESTexture2D::CopyToSubTextureCube(Texture& target,
uint32_t dst_array_index, CubeFaces dst_face, uint32_t dst_level, uint32_t dst_x_offset, uint32_t dst_y_offset, uint32_t dst_width, uint32_t dst_height,
uint32_t src_array_index, CubeFaces src_face, uint32_t src_level, uint32_t src_x_offset, uint32_t src_y_offset, uint32_t src_width, uint32_t src_height)
{
KFL_UNUSED(src_face);
BOOST_ASSERT(TT_Cube == target.Type());
OGLESRenderEngine& re = *checked_cast<OGLESRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
if (glloader_GLES_VERSION_3_0() && ((sample_count_ > 1) && !IsCompressedFormat(format_) && (glloader_GLES_EXT_texture_rg() || (4 == NumComponents(format_)))))
{
GLuint fbo_src, fbo_dst;
re.GetFBOForBlit(fbo_src, fbo_dst);
GLuint old_fbo = re.BindFramebuffer();
glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo_src);
if (array_size_ > 1)
{
glFramebufferTextureLayer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texture_, src_level, src_array_index);
}
else
{
if (sample_count_ <= 1)
{
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target_type_, texture_, src_level);
}
else
{
glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER, texture_);
}
}
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo_dst);
if (target.ArraySize() > 1)
{
glFramebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texture_, dst_level, dst_array_index * 6 + dst_face - CF_Positive_X);
}
else
{
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X + dst_face, checked_cast<OGLESTexture*>(&target)->GLTexture(), dst_level);
}
glBlitFramebuffer(src_x_offset, src_y_offset, src_x_offset + src_width, src_y_offset + src_height,
dst_x_offset, dst_y_offset, dst_x_offset + dst_width, dst_y_offset + dst_height,
GL_COLOR_BUFFER_BIT, ((src_width == dst_width) && (src_height == dst_height)) ? GL_NEAREST : GL_LINEAR);
re.BindFramebuffer(old_fbo, true);
}
else
{
if ((src_width == dst_width) && (src_height == dst_height) && (format_ == target.Format()))
{
if (IsCompressedFormat(format_))
{
BOOST_ASSERT((0 == (src_x_offset & 0x3)) && (0 == (src_y_offset & 0x3)));
BOOST_ASSERT((0 == (dst_x_offset & 0x3)) && (0 == (dst_y_offset & 0x3)));
BOOST_ASSERT((0 == (src_width & 0x3)) && (0 == (src_height & 0x3)));
BOOST_ASSERT((0 == (dst_width & 0x3)) && (0 == (dst_height & 0x3)));
Texture::Mapper mapper_src(*this, src_array_index, src_level, TMA_Read_Only, src_x_offset, src_y_offset, src_width, src_height);
Texture::Mapper mapper_dst(target, dst_array_index, dst_face, dst_level, TMA_Write_Only, dst_x_offset, dst_y_offset, dst_width, dst_height);
uint32_t const block_size = NumFormatBytes(format_) * 4;
uint8_t const * s = mapper_src.Pointer<uint8_t>();
uint8_t* d = mapper_dst.Pointer<uint8_t>();
for (uint32_t y = 0; y < src_height; y += 4)
{
std::memcpy(d, s, src_width / 4 * block_size);
s += mapper_src.RowPitch();
d += mapper_dst.RowPitch();
}
}
else
{
size_t const format_size = NumFormatBytes(format_);
Texture::Mapper mapper_src(*this, src_array_index, src_level, TMA_Read_Only, src_x_offset, src_y_offset, src_width, src_height);
Texture::Mapper mapper_dst(target, dst_array_index, dst_face, dst_level, TMA_Write_Only, dst_x_offset, dst_y_offset, dst_width, dst_height);
uint8_t const * s = mapper_src.Pointer<uint8_t>();
uint8_t* d = mapper_dst.Pointer<uint8_t>();
for (uint32_t y = 0; y < src_height; ++ y)
{
std::memcpy(d, s, src_width * format_size);
s += mapper_src.RowPitch();
d += mapper_dst.RowPitch();
}
}
}
else
{
this->ResizeTextureCube(target, dst_array_index, dst_face, dst_level, dst_x_offset, dst_y_offset, dst_width, dst_height,
src_array_index, CF_Positive_X, src_level, src_x_offset, src_y_offset, src_width, src_height, true);
}
}
}
ShowState NullShowEngine::State(long ms_timeout)
{
KFL_UNUSED(ms_timeout);
return state_;
}
void NullShowEngine::Load(std::string const & file_name)
{
KFL_UNUSED(file_name);
state_ = SS_Stopped;
}
void OGLESTexture3D::Unmap3D(uint32_t array_index, uint32_t level)
{
BOOST_ASSERT(0 == array_index);
KFL_UNUSED(array_index);
switch (last_tma_)
{
case TMA_Read_Only:
break;
case TMA_Write_Only:
case TMA_Read_Write:
{
GLint gl_internalFormat;
GLenum gl_format;
GLenum gl_type;
OGLESMapping::MappingFormat(gl_internalFormat, gl_format, gl_type, format_);
uint32_t const w = this->Width(level);
uint32_t const h = this->Height(level);
uint32_t const d = this->Depth(level);
OGLESRenderEngine& re = *checked_cast<OGLESRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
re.BindTexture(0, target_type_, texture_);
if (IsCompressedFormat(format_))
{
uint32_t const block_size = NumFormatBytes(format_) * 4;
GLsizei const image_size = ((w + 3) / 4) * ((h + 3) / 4) * d * block_size;
if (glloader_GLES_VERSION_3_0())
{
glCompressedTexSubImage3D(target_type_, level, 0, 0, 0,
w, h, d, gl_format, image_size, &tex_data_[level][0]);
}
else
{
glCompressedTexSubImage3DOES(target_type_, level, 0, 0, 0,
w, h, d, gl_format, image_size, &tex_data_[level][0]);
}
}
else
{
if (glloader_GLES_VERSION_3_0())
{
glTexSubImage3D(target_type_, level,
0, 0, 0, w, h, d, gl_format, gl_type, &tex_data_[level][0]);
}
else
{
glTexSubImage3DOES(target_type_, level,
0, 0, 0, w, h, d, gl_format, gl_type, &tex_data_[level][0]);
}
}
}
break;
default:
BOOST_ASSERT(false);
break;
}
}
void OGLESTexture3D::CopyToSubTexture3D(Texture& target,
uint32_t dst_array_index, uint32_t dst_level, uint32_t dst_x_offset, uint32_t dst_y_offset, uint32_t dst_z_offset, uint32_t dst_width, uint32_t dst_height, uint32_t dst_depth,
uint32_t src_array_index, uint32_t src_level, uint32_t src_x_offset, uint32_t src_y_offset, uint32_t src_z_offset, uint32_t src_width, uint32_t src_height, uint32_t src_depth)
{
KFL_UNUSED(dst_depth);
BOOST_ASSERT(type_ == target.Type());
BOOST_ASSERT(0 == src_array_index);
BOOST_ASSERT(0 == dst_array_index);
if ((src_width == dst_width) && (src_height == dst_height) && (src_depth == dst_depth) && (format_ == target.Format()))
{
if (IsCompressedFormat(format_))
{
BOOST_ASSERT((0 == (src_x_offset & 0x3)) && (0 == (src_y_offset & 0x3)));
BOOST_ASSERT((0 == (dst_x_offset & 0x3)) && (0 == (dst_y_offset & 0x3)));
BOOST_ASSERT((0 == (src_width & 0x3)) && (0 == (src_height & 0x3)));
BOOST_ASSERT((0 == (dst_width & 0x3)) && (0 == (dst_height & 0x3)));
for (uint32_t z = 0; z < src_depth; ++ z)
{
Texture::Mapper mapper_src(*this, src_array_index, src_level, TMA_Read_Only,
src_x_offset, src_y_offset, src_z_offset + z, src_width, src_height, 1);
Texture::Mapper mapper_dst(target, dst_array_index, dst_level, TMA_Write_Only,
dst_x_offset, dst_y_offset, dst_z_offset + z, dst_width, dst_height, 1);
uint32_t const block_size = NumFormatBytes(format_) * 4;
uint8_t const * s = mapper_src.Pointer<uint8_t>();
uint8_t* d = mapper_dst.Pointer<uint8_t>();
for (uint32_t y = 0; y < src_height; y += 4)
{
std::memcpy(d, s, src_width / 4 * block_size);
s += mapper_src.RowPitch();
d += mapper_dst.RowPitch();
}
}
}
else
{
for (uint32_t z = 0; z < src_depth; ++ z)
{
size_t const format_size = NumFormatBytes(format_);
Texture::Mapper mapper_src(*this, src_array_index, src_level, TMA_Read_Only,
src_x_offset, src_y_offset, src_z_offset + z, src_width, src_height, 1);
Texture::Mapper mapper_dst(target, dst_array_index, dst_level, TMA_Write_Only,
dst_x_offset, dst_y_offset, dst_z_offset + z, dst_width, dst_height, 1);
uint8_t const * s = mapper_src.Pointer<uint8_t>();
uint8_t* d = mapper_dst.Pointer<uint8_t>();
for (uint32_t y = 0; y < src_height; ++ y)
{
std::memcpy(d, s, src_width * format_size);
s += mapper_src.RowPitch();
d += mapper_dst.RowPitch();
}
}
}
}
else
{
this->ResizeTexture3D(target, dst_array_index, dst_level, dst_x_offset, dst_y_offset, dst_z_offset, dst_width, dst_height, dst_depth,
src_array_index, src_level, src_x_offset, src_y_offset, src_z_offset, src_width, src_height, src_depth, true);
}
}
void LightSource::Radius(float radius)
{
KFL_UNUSED(radius);
}
void LightSource::Extend(float3 const & extend)
{
KFL_UNUSED(extend);
}
void TubeAreaLightSource::Falloff(float3 const & fall_off)
{
KFL_UNUSED(fall_off);
LightSource::Falloff(float3(1, 0, 0));
}
