Blender V5.3
cycles/scene/image.h
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#pragma once
6
7#include "device/memory.h"
8
9#include "scene/image_cache.h"
10#include "scene/image_loader.h"
11
12#include "util/colorspace.h"
13#include "util/image_metadata.h"
14#include "util/set.h"
15#include "util/thread.h"
16#include "util/unique_ptr.h"
17#include "util/vector.h"
18
20
21class Device;
22class DeviceInfo;
23class ImageLoader;
24class ImageSingle;
25class ImageHandle;
26class ImageKey;
27class ImageManager;
28class ImageUDIM;
29class ImageTexture;
30class Progress;
31class RenderStats;
32class Scene;
33class SceneParams;
34class ColorSpaceProcessor;
35class VDBImageLoader;
36
37/* Image Parameters */
56
57/* Image Handle
58 *
59 * Access handle for image in the image manager. Multiple shader nodes may
60 * share the same image, and this class handles reference counting for that.
61 *
62 * This may reference a single image, or a UDIM with multiple images. */
64 public:
67 ImageHandle(const ImageHandle &other);
68 ImageHandle(ImageHandle &&other) noexcept;
69 ImageHandle &operator=(const ImageHandle &other);
70 ImageHandle &operator=(ImageHandle &&other) noexcept;
72
73 bool operator==(const ImageHandle &other) const;
74
75 void clear();
76
77 bool empty() const;
78 int num_tiles() const;
79
81 bool all_udim_tiled(Progress &progress);
82 int kernel_id() const;
83
86
88
89 void add_to_set(set<const ImageSingle *> &images) const;
90
91 protected:
94
95 friend class ImageManager;
96};
97
98/* Image Texture
99 *
100 * Base class for an entry in the image manager, which can either be
101 * a single image or a UDIM. */
103 public:
104 std::atomic<int> users = 0;
105 enum { SINGLE, UDIM } type = SINGLE;
106 bool need_load = true;
107};
108
109/* Image Single
110 *
111 * Representation of single image texture in the image manager. */
112class ImageSingle : public ImageTexture {
113 public:
115
116 /* Index into ImageManager::images and DeviceScene::image_textures. */
118
122
123 bool need_metadata = true;
124 bool builtin = false;
125
126 /* Number of top mip levels in the image file to discard. */
128
130
132};
133
134/* Image UDIM
135 *
136 * Representation of an UDIM image in the image manager. */
137class ImageUDIM : public ImageTexture {
138 public:
139 /* Negative kernel ID encoding offset into DeviceScene::image_texture_udims. */
141
143};
144
145/* Image Manager
146 *
147 * Handles loading and storage of all images in the scene. This includes 2D
148 * texture images and 3D volume images. */
150 public:
151 explicit ImageManager(const DeviceInfo &info, const SceneParams &params);
153
154 ImageHandle add_image(const string &filename, const ImageParams &params);
155 ImageHandle add_image(const string &filename,
156 const ImageParams &params,
157 const array<int> &tiles);
159 const ImageParams &params,
160 const bool builtin = true);
162
163 void device_update(Device *device, Scene *scene, Progress &progress);
164 void device_free(Scene *scene);
165
166 void device_load_builtin(Device *device, Scene *scene, Progress &progress);
167 void device_free_builtin(Scene *scene);
168
169 void device_load_images(Device *device,
170 Scene *scene,
171 Progress &progress,
172 const set<const ImageSingle *> &images);
173
174 bool set_animation_frame_update(const int frame);
175
176 void evict_unused(Device *device, Scene *scene);
177
178 void collect_statistics(RenderStats *stats, Scene *scene);
179
180 void tag_update();
181
182 bool need_update() const;
183
184 bool get_use_texture_cache() const;
185 bool get_auto_texture_cache() const;
186
187 private:
188 bool need_update_ = true;
189
190 thread_mutex device_mutex;
191 thread_mutex images_mutex;
192 int animation_frame = 0;
193
196 int num_udim_tiles = 0;
197
198 ImageCache image_cache;
199
200 bool use_texture_cache = true;
201 bool auto_texture_cache = false;
202 std::string texture_cache_path;
203
204 std::atomic<int> load_failure_num = 0;
205 std::atomic<int> tx_failure_num = 0;
206
207 ImageSingle *add_image_texture(unique_ptr<ImageLoader> &&loader,
208 const ImageParams &params,
209 const bool builtin);
210 ImageUDIM *add_image_texture(vector<std::pair<int, ImageHandle>> &&tiles);
211
212 void load_image_metadata(ImageSingle *img, Progress &progress);
213
214 void device_gpu_load_requested(Device *device, DeviceQueue &queue, Scene *scene);
215 void device_cpu_load_requested(Device *device,
216 Scene *scene,
217 size_t image_texture_id,
218 int miplevel,
219 int x,
220 int y,
221 KernelTileDescriptor &tile_descriptor);
222
223 void device_load_image(Device *device,
224 Scene *scene,
225 const size_t image_texture_id,
226 Progress &progress);
227 void device_load_tiled_descriptors(Scene *scene);
228 void device_free_image(Scene *scene, const size_t image_texture_id);
229
230 void device_update_udims(Device *device, Scene *scene);
231
232 void device_resize_image_textures(Scene *scene);
233 void device_copy_image_textures(Device *device, Scene *scene);
234
235 void report_failures();
236
237 friend class ImageHandle;
238};
239
int num_tiles() const
device_image * vdb_image_memory() const
ImageMetaData metadata(Progress &progress)
ImageManager * get_manager() const
bool operator==(const ImageHandle &other) const
friend class ImageManager
bool empty() const
int kernel_id() const
ImageManager * manager
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
void evict_unused(Device *device, Scene *scene)
void collect_statistics(RenderStats *stats, Scene *scene)
void device_update(Device *device, Scene *scene, Progress &progress)
bool need_update() const
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 &params)
ImageHandle add_image(const string &filename, const ImageParams &params)
bool get_use_texture_cache() const
friend class ImageHandle
bool get_auto_texture_cache() const
bool operator==(const ImageParams &other) const
ImageAlphaType alpha_type
InterpolationType interpolation
ExtensionType extension
device_image * vdb_memory
unique_ptr< ImageLoader > loader
ImageParams params
ImageMetaData metadata
thread_mutex mutex
enum ImageTexture::@125057243052132335305237234015050125102306363074 type
std::atomic< int > users
vector< std::pair< int, ImageHandle > > tiles
Definition scene.h:133
#define CCL_NAMESPACE_END
ccl_gpu_kernel_postfix ccl_global KernelWorkTile * tiles
#define KERNEL_IMAGE_NONE
std::mutex thread_mutex
Definition thread.h:27
uint KernelTileDescriptor
ImageAlphaType
Definition types_image.h:61
@ IMAGE_ALPHA_AUTO
Definition types_image.h:66
InterpolationType
Definition types_image.h:24
@ INTERPOLATION_LINEAR
Definition types_image.h:26
ExtensionType
Definition types_image.h:80
@ EXTENSION_CLIP
Definition types_image.h:86
ustring u_colorspace_scene_linear