16#include "util/colorspace.h"
48 other.image_texture =
nullptr;
49 other.manager =
nullptr;
71 other.image_texture =
nullptr;
72 other.manager =
nullptr;
108 return udim->
tiles.size();
119 manager->load_image_metadata(img, progress);
124 return udim->
tiles[0].second.metadata(progress);
136 if (!
tile.second.metadata(progress).has_tiles_and_mipmaps) {
174 if (loader ==
nullptr) {
206 images.insert(
static_cast<const ImageSingle *
>(
tile.second.image_texture));
234 if (frame != animation_frame) {
236 animation_frame = frame;
239 if (img && img->params.animated) {
264 const ImageLoaderParams params = {.use_texture_cache = use_texture_cache,
265 .auto_texture_cache = auto_texture_cache,
266 .texture_cache_path = texture_cache_path,
269 .load_failure_num = load_failure_num,
270 .tx_failure_num = tx_failure_num};
272 ImageMetaData &metadata = img->
metadata;
276 if (img->
loader->load_metadata(metadata, params, progress)) {
291 ImageSingle *
image = add_image_texture(make_unique<OIIOImageLoader>(filename), params,
false);
305 string tile_filename = filename;
311 const int u = ((
tile - 1001) % 10);
312 const int v = ((
tile - 1001) / 10);
316 make_unique<OIIOImageLoader>(tile_filename), params,
false);
320 ImageUDIM *udim = add_image_texture(std::move(udim_tiles));
339 std::swap(loader, local_loader);
340 ImageSingle *
image = add_image_texture(std::move(local_loader), params,
true);
344 ImageUDIM *udim = add_image_texture(std::move(udim_tiles));
357 size_t image_texture_id;
358 for (image_texture_id = 0; image_texture_id < images.
size(); image_texture_id++) {
366 for (image_texture_id = 0; image_texture_id < images.size(); image_texture_id++) {
367 if (!images[image_texture_id]) {
372 if (image_texture_id == images.size()) {
373 images.resize(images.size() + 1);
377 unique_ptr<ImageSingle> img = make_unique<ImageSingle>();
379 img->image_texture_id = image_texture_id;
380 img->params = params;
381 img->loader = std::move(loader);
382 img->builtin = builtin;
384 images.replace(image_texture_id, std::move(img));
388 return images[image_texture_id];
396 size_t image_texture_id;
397 for (image_texture_id = 0; image_texture_id < image_udims.size(); image_texture_id++) {
398 ImageUDIM *udim = image_udims[image_texture_id];
405 for (image_texture_id = 0; image_texture_id < image_udims.size(); image_texture_id++) {
406 if (!image_udims[image_texture_id]) {
411 if (image_texture_id == image_udims.size()) {
412 image_udims.resize(image_udims.size() + 1);
416 unique_ptr<ImageUDIM> img = make_unique<ImageUDIM>();
418 img->id = -num_udim_tiles - 1;
419 img->tiles = std::move(
tiles);
421 num_udim_tiles += img->tiles.size() + 1;
423 image_udims.replace(image_texture_id, std::move(img));
427 return image_udims[image_texture_id];
430void ImageManager::device_resize_image_textures(
Scene *scene)
433 DeviceScene &dscene = scene->
dscene;
440void ImageManager::device_copy_image_textures(
Device *device,
Scene *scene)
442 image_cache.copy_to_device(scene->
dscene);
445 DeviceScene &dscene = scene->
dscene;
454 [
this, device, scene](
size_t image_texture_id,
459 this->device_cpu_load_requested(
460 device, scene, image_texture_id, miplevel,
x,
y, tile_descriptor);
462 [
this, device, scene](DeviceQueue &queue) {
463 this->device_gpu_load_requested(device, queue, scene);
467void ImageManager::device_load_image(
Device *device,
469 const size_t image_texture_id,
476 ImageSingle *img = images[image_texture_id];
480 load_image_metadata(img, progress);
482 KernelImageTexture tex;
497 while (texture_limit > 0 && max_dim > texture_limit) {
503 image_cache.load_image_tiled(img->
metadata, tex);
509 if (texture_limit > 0 && max_dim > texture_limit) {
510 texture_resolution = std::min(texture_resolution,
float(texture_limit) /
float(max_dim));
512 img->
vdb_memory = image_cache.load_image_full(
525void ImageManager::device_load_tiled_descriptors(
Scene *scene)
527 DeviceScene &dscene = scene->
dscene;
528 image_cache.load_image_tiled_descriptors(
532void ImageManager::device_free_image(
Scene *scene,
size_t image_texture_id)
534 ImageSingle *img = images[image_texture_id];
535 if (img ==
nullptr) {
541 image_cache.free_image(scene->
dscene, tex);
544 images.steal(image_texture_id);
547void ImageManager::device_cpu_load_requested(
Device *device,
549 size_t image_texture_id,
556 const ImageSingle *img = images[image_texture_id];
558 image_cache.load_requested_tile(*device,
572 DeviceScene &dscene = scene->
dscene;
576 vector<uint8_t> local_storage;
581 parallel_for(blocked_range<size_t>(0, images.size(), 1), [&](
const blocked_range<size_t> &r) {
582 for (size_t i = r.begin(); i != r.end(); i++) {
583 if (images[i] && dscene.image_textures[i].tile_descriptor_offset != KERNEL_TILE_LOAD_NONE) {
584 ImageSingle *img = images[i];
585 image_cache.load_requested_tiles(*device,
587 dscene.image_textures[i],
590 img->miplevel_offset,
598 image_cache.copy_to_device(dscene, queue);
601void ImageManager::device_update_udims(
Device * ,
Scene *scene)
605 if (device_udims.
size() == num_udim_tiles) {
609 device_udims.
resize(num_udim_tiles);
611 for (
auto [udim_id, udim] : image_udims.enumerate()) {
612 if (udim ==
nullptr) {
616 if (udim->
users == 0) {
617 image_udims.replace(udim_id,
nullptr);
620 const uint udim_offset = -udim->
id - 1;
621 KernelImageUDIM *udim_data = device_udims.
data() + udim_offset;
623 udim_data[0] = KernelImageUDIM{.tile = int(udim->
tiles.size()), .image_texture_id = 0};
624 for (
int i = 0; i < udim->
tiles.size(); i++) {
626 udim_data[i + 1] = KernelImageUDIM{.tile =
tile.first,
627 .image_texture_id =
tile.second.kernel_id()};
642 scene->
update_stats->image.times.add_entry({
"device_update", time});
647 KernelImage *kimage = &scene->
dscene.
data.image;
653 device_update_udims(device, scene);
656 device_resize_image_textures(scene);
660 for (
auto [image_texture_id, img] : images.enumerate()) {
661 if (img && img->
users == 0) {
662 device_free_image(scene, image_texture_id);
665 pool.
push([
this, device, scene, image_texture_id, &progress] {
666 device_load_image(device, scene, image_texture_id, progress);
672 device_load_tiled_descriptors(scene);
676 device_copy_image_textures(device, scene);
678 need_update_ =
false;
684 const set<const ImageSingle *> &images)
687 KernelImage *kimage = &scene->
dscene.
data.image;
693 device_update_udims(device, scene);
696 device_resize_image_textures(scene);
701 pool.
push([
this, device, scene, img, &progress] {
703 if (img->
users == 0) {
712 device_load_tiled_descriptors(scene);
716 device_copy_image_textures(device, scene);
727 device_resize_image_textures(scene);
730 for (
auto [image_texture_id, img] : images.enumerate()) {
732 pool.
push([
this, device, scene, image_texture_id, &progress] {
733 device_load_image(device, scene, image_texture_id, progress);
739 device_load_tiled_descriptors(scene);
746 for (
auto [image_texture_id, img] : images.enumerate()) {
748 device_free_image(scene, image_texture_id);
756 for (
auto [image_texture_id, img] : images.enumerate()) {
757 device_free_image(scene, image_texture_id);
760 image_cache.device_free(scene->
dscene);
767 if (!
DebugFlags().texture_cache.use_eviction) {
774 if (tile_access.
size() == 0) {
781 image_cache.evict_unused(*device,
791 device_copy_image_textures(device, scene);
798 for (
auto [image_texture_id,
image] : images.enumerate()) {
811 image_cache.collect_statistics(dscene, tex,
image->metadata, tile_stats);
826 image_cache.memory_size(dscene);
849 return use_texture_cache;
854 return auto_texture_cache;
857void ImageManager::report_failures()
862 const int load_num = load_failure_num.exchange(0);
864 LOG_ERROR <<
"Failed to load " << load_num <<
" image files";
867 const int tx_num = tx_failure_num.exchange(0);
869 LOG_ERROR <<
"Failed to generate " << tx_num <<
" tx files";
virtual void * copy_from_device_synchronized(device_memory &mem, vector< uint8_t > &storage)=0
device_vector< uint8_t > image_texture_tile_access_state
device_vector< KernelImageUDIM > image_texture_udims
device_vector< KernelImageTexture > image_textures
virtual void mem_or_from_device(device_memory &mem)
virtual void set_image_cache_func(KernelImageLoadRequestedCPU, KernelImageLoadRequestedGPU image_load_requested_gpu)
device_image * vdb_image_memory() const
ImageMetaData metadata(Progress &progress)
ImageManager * get_manager() const
bool operator==(const ImageHandle &other) const
friend class ImageManager
ImageHandle & operator=(const ImageHandle &other)
VDBImageLoader * vdb_loader() const
bool all_udim_tiled(Progress &progress)
void add_to_set(set< const ImageSingle * > &images) const
ImageTexture * image_texture
virtual bool equals(const ImageLoader &other) const =0
virtual bool is_vdb_loader() const
void evict_unused(Device *device, Scene *scene)
void collect_statistics(RenderStats *stats, Scene *scene)
void device_update(Device *device, Scene *scene, Progress &progress)
void device_load_images(Device *device, Scene *scene, Progress &progress, const set< const ImageSingle * > &images)
void device_free(Scene *scene)
void device_free_builtin(Scene *scene)
void device_load_builtin(Device *device, Scene *scene, Progress &progress)
bool set_animation_frame_update(const int frame)
ImageManager(const DeviceInfo &info, const SceneParams ¶ms)
ImageHandle add_image(const string &filename, const ImageParams ¶ms)
bool get_use_texture_cache() const
bool get_auto_texture_cache() const
ImageAlphaType alpha_type
InterpolationType interpolation
device_image * vdb_memory
unique_ptr< ImageLoader > loader
vector< ImageTileStats > tiled_images
size_t tiled_images_peak_size
ImageEvictionStats eviction
NamedSizeStats full_images
enum ImageTexture::@125057243052132335305237234015050125102306363074 type
vector< std::pair< int, ImageHandle > > tiles
void add_entry(const NamedSizeEntry &entry)
void set_status(const string &status_, const string &substatus_="")
std::string texture_cache_path
unique_ptr< SceneUpdateStats > update_stats
void push(TaskRunFunction &&task)
void wait_work(Summary *stats=nullptr)
void copy_to_device_if_modified()
T * resize(const size_t width, const size_t height=0)
#define CCL_NAMESPACE_END
#define assert(assertion)
#define image(slot, qualifiers, format)
ccl_gpu_kernel_postfix ccl_global KernelWorkTile * tiles
const ccl_global KernelWorkTile * tile
#define KERNEL_TILE_LOAD_NONE
#define KERNEL_IMAGE_NONE
#define KERNEL_TILE_ACCESS_NONE
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
auto isolate_task(const Function &function)
CCL_NAMESPACE_BEGIN string string_printf(const char *format,...)
void string_replace(string &haystack, const string &needle, const string &other)
uint tile_descriptor_offset
std::unique_lock< std::mutex > thread_scoped_lock
uint KernelTileDescriptor