GPencil: Use correct comparison for non-bit values
[blender.git] / intern / cycles / render / image.h
1 /*
2  * Copyright 2011-2013 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #ifndef __IMAGE_H__
18 #define __IMAGE_H__
19
20 #include "device/device.h"
21 #include "device/device_memory.h"
22
23 #include "render/colorspace.h"
24
25 #include "util/util_image.h"
26 #include "util/util_string.h"
27 #include "util/util_thread.h"
28 #include "util/util_unique_ptr.h"
29 #include "util/util_vector.h"
30
31 CCL_NAMESPACE_BEGIN
32
33 class Device;
34 class Progress;
35 class RenderStats;
36 class Scene;
37 class ColorSpaceProcessor;
38
39 class ImageMetaData {
40  public:
41   /* Must be set by image file or builtin callback. */
42   bool is_float, is_half;
43   int channels;
44   size_t width, height, depth;
45   bool builtin_free_cache;
46
47   /* Automatically set. */
48   ImageDataType type;
49   ustring colorspace;
50   bool compress_as_srgb;
51
52   ImageMetaData()
53       : is_float(false),
54         is_half(false),
55         channels(0),
56         width(0),
57         height(0),
58         depth(0),
59         builtin_free_cache(false),
60         type((ImageDataType)0),
61         colorspace(u_colorspace_raw),
62         compress_as_srgb(false)
63   {
64   }
65
66   bool operator==(const ImageMetaData &other) const
67   {
68     return is_float == other.is_float && is_half == other.is_half && channels == other.channels &&
69            width == other.width && height == other.height && depth == other.depth &&
70            type == other.type && colorspace == other.colorspace &&
71            compress_as_srgb == other.compress_as_srgb;
72   }
73 };
74
75 class ImageManager {
76  public:
77   explicit ImageManager(const DeviceInfo &info);
78   ~ImageManager();
79
80   int add_image(const string &filename,
81                 void *builtin_data,
82                 bool animated,
83                 float frame,
84                 InterpolationType interpolation,
85                 ExtensionType extension,
86                 ImageAlphaType alpha_type,
87                 ustring colorspace,
88                 ImageMetaData &metadata);
89   void add_image_user(int flat_slot);
90   void remove_image(int flat_slot);
91   void remove_image(const string &filename,
92                     void *builtin_data,
93                     InterpolationType interpolation,
94                     ExtensionType extension,
95                     ImageAlphaType alpha_type,
96                     ustring colorspace);
97   void tag_reload_image(const string &filename,
98                         void *builtin_data,
99                         InterpolationType interpolation,
100                         ExtensionType extension,
101                         ImageAlphaType alpha_type,
102                         ustring colorspace);
103   bool get_image_metadata(const string &filename,
104                           void *builtin_data,
105                           ustring colorspace,
106                           ImageMetaData &metadata);
107   bool get_image_metadata(int flat_slot, ImageMetaData &metadata);
108
109   void device_update(Device *device, Scene *scene, Progress &progress);
110   void device_update_slot(Device *device, Scene *scene, int flat_slot, Progress *progress);
111   void device_free(Device *device);
112
113   void device_load_builtin(Device *device, Scene *scene, Progress &progress);
114   void device_free_builtin(Device *device);
115
116   void set_osl_texture_system(void *texture_system);
117   bool set_animation_frame_update(int frame);
118
119   device_memory *image_memory(int flat_slot);
120
121   void collect_statistics(RenderStats *stats);
122
123   bool need_update;
124
125   /* NOTE: Here pixels_size is a size of storage, which equals to
126    *       width * height * depth.
127    *       Use this to avoid some nasty memory corruptions.
128    */
129   function<void(const string &filename, void *data, ImageMetaData &metadata)>
130       builtin_image_info_cb;
131   function<bool(const string &filename,
132                 void *data,
133                 unsigned char *pixels,
134                 const size_t pixels_size,
135                 const bool associate_alpha,
136                 const bool free_cache)>
137       builtin_image_pixels_cb;
138   function<bool(const string &filename,
139                 void *data,
140                 float *pixels,
141                 const size_t pixels_size,
142                 const bool associate_alpha,
143                 const bool free_cache)>
144       builtin_image_float_pixels_cb;
145
146   struct Image {
147     string filename;
148     void *builtin_data;
149     ImageMetaData metadata;
150
151     ustring colorspace;
152     ImageAlphaType alpha_type;
153     bool need_load;
154     bool animated;
155     float frame;
156     InterpolationType interpolation;
157     ExtensionType extension;
158
159     string mem_name;
160     device_memory *mem;
161
162     int users;
163   };
164
165  private:
166   int tex_num_images[IMAGE_DATA_NUM_TYPES];
167   int max_num_images;
168   bool has_half_images;
169
170   thread_mutex device_mutex;
171   int animation_frame;
172
173   vector<Image *> images[IMAGE_DATA_NUM_TYPES];
174   void *osl_texture_system;
175
176   bool file_load_image_generic(Image *img, unique_ptr<ImageInput> *in);
177
178   template<TypeDesc::BASETYPE FileFormat, typename StorageType, typename DeviceType>
179   bool file_load_image(Image *img,
180                        ImageDataType type,
181                        int texture_limit,
182                        device_vector<DeviceType> &tex_img);
183
184   void metadata_detect_colorspace(ImageMetaData &metadata, const char *file_format);
185
186   void device_load_image(
187       Device *device, Scene *scene, ImageDataType type, int slot, Progress *progress);
188   void device_free_image(Device *device, ImageDataType type, int slot);
189 };
190
191 CCL_NAMESPACE_END
192
193 #endif /* __IMAGE_H__ */