forked from bartvdbraak/blender
272412f9c0
Main intention is to give some quick way to control scene's memory usage by clamping textures which are too big. This is really handy on the early production stages when you first create really nice looking hi-res textures and only when it all works and approved start investing time on optimizing your scene. This is a new option in Scene Simplify panel and it acts as following: when texture size is bigger than the given value it'll be scaled down by half for until it fits into given limit. There are various possible improvements, such as: - Use threaded scaling using our own task manager. This is actually one of the main reasons why image resize is manually-implemented instead of using OIIO's resize. Other reason here is that API seems limited to construct 3D texture description easily. - Vectorization of uchar4/float4/half4 textures. - Use something smarter than box filter. Was playing with some other filters, but not sure they are really better: they kind of causes more fuzzy edges. Even with such a TODOs in the code the option is already quite useful. Reviewers: brecht Reviewed By: brecht Subscribers: jtheninja, Blendify, gregzaal, venomgfx Differential Revision: https://developer.blender.org/D2362
246 lines
5.7 KiB
C++
246 lines
5.7 KiB
C++
/*
|
|
* Copyright 2011-2013 Blender Foundation
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef __SCENE_H__
|
|
#define __SCENE_H__
|
|
|
|
#include "image.h"
|
|
#include "shader.h"
|
|
|
|
#include "device_memory.h"
|
|
|
|
#include "util_param.h"
|
|
#include "util_string.h"
|
|
#include "util_system.h"
|
|
#include "util_texture.h"
|
|
#include "util_thread.h"
|
|
#include "util_types.h"
|
|
#include "util_vector.h"
|
|
|
|
CCL_NAMESPACE_BEGIN
|
|
|
|
class AttributeRequestSet;
|
|
class Background;
|
|
class Camera;
|
|
class Device;
|
|
class DeviceInfo;
|
|
class Film;
|
|
class Integrator;
|
|
class Light;
|
|
class LightManager;
|
|
class LookupTables;
|
|
class Mesh;
|
|
class MeshManager;
|
|
class Object;
|
|
class ObjectManager;
|
|
class ParticleSystemManager;
|
|
class ParticleSystem;
|
|
class CurveSystemManager;
|
|
class Shader;
|
|
class ShaderManager;
|
|
class Progress;
|
|
class BakeManager;
|
|
class BakeData;
|
|
|
|
/* Scene Device Data */
|
|
|
|
class DeviceScene {
|
|
public:
|
|
/* BVH */
|
|
device_vector<float4> bvh_nodes;
|
|
device_vector<float4> bvh_leaf_nodes;
|
|
device_vector<uint> object_node;
|
|
device_vector<uint> prim_tri_index;
|
|
device_vector<float4> prim_tri_verts;
|
|
device_vector<uint> prim_type;
|
|
device_vector<uint> prim_visibility;
|
|
device_vector<uint> prim_index;
|
|
device_vector<uint> prim_object;
|
|
|
|
/* mesh */
|
|
device_vector<uint> tri_shader;
|
|
device_vector<float4> tri_vnormal;
|
|
device_vector<uint4> tri_vindex;
|
|
device_vector<uint> tri_patch;
|
|
device_vector<float2> tri_patch_uv;
|
|
|
|
device_vector<float4> curves;
|
|
device_vector<float4> curve_keys;
|
|
|
|
device_vector<uint> patches;
|
|
|
|
/* objects */
|
|
device_vector<float4> objects;
|
|
device_vector<float4> objects_vector;
|
|
|
|
/* attributes */
|
|
device_vector<uint4> attributes_map;
|
|
device_vector<float> attributes_float;
|
|
device_vector<float4> attributes_float3;
|
|
device_vector<uchar4> attributes_uchar4;
|
|
|
|
/* lights */
|
|
device_vector<float4> light_distribution;
|
|
device_vector<float4> light_data;
|
|
device_vector<float2> light_background_marginal_cdf;
|
|
device_vector<float2> light_background_conditional_cdf;
|
|
|
|
/* particles */
|
|
device_vector<float4> particles;
|
|
|
|
/* shaders */
|
|
device_vector<uint4> svm_nodes;
|
|
device_vector<uint> shader_flag;
|
|
device_vector<uint> object_flag;
|
|
|
|
/* lookup tables */
|
|
device_vector<float> lookup_table;
|
|
|
|
/* integrator */
|
|
device_vector<uint> sobol_directions;
|
|
|
|
/* cpu images */
|
|
device_vector<uchar4> tex_byte4_image[TEX_NUM_BYTE4_CPU];
|
|
device_vector<float4> tex_float4_image[TEX_NUM_FLOAT4_CPU];
|
|
device_vector<float> tex_float_image[TEX_NUM_FLOAT_CPU];
|
|
device_vector<uchar> tex_byte_image[TEX_NUM_BYTE_CPU];
|
|
device_vector<half4> tex_half4_image[TEX_NUM_HALF4_CPU];
|
|
device_vector<half> tex_half_image[TEX_NUM_HALF_CPU];
|
|
|
|
/* opencl images */
|
|
device_vector<uchar4> tex_image_byte4_packed;
|
|
device_vector<float4> tex_image_float4_packed;
|
|
device_vector<uchar> tex_image_byte_packed;
|
|
device_vector<float> tex_image_float_packed;
|
|
device_vector<uint4> tex_image_packed_info;
|
|
|
|
KernelData data;
|
|
};
|
|
|
|
/* Scene Parameters */
|
|
|
|
class SceneParams {
|
|
public:
|
|
ShadingSystem shadingsystem;
|
|
enum BVHType {
|
|
BVH_DYNAMIC = 0,
|
|
BVH_STATIC = 1,
|
|
|
|
BVH_NUM_TYPES,
|
|
} bvh_type;
|
|
bool use_bvh_spatial_split;
|
|
bool use_bvh_unaligned_nodes;
|
|
bool use_qbvh;
|
|
bool persistent_data;
|
|
int texture_limit;
|
|
|
|
SceneParams()
|
|
{
|
|
shadingsystem = SHADINGSYSTEM_SVM;
|
|
bvh_type = BVH_DYNAMIC;
|
|
use_bvh_spatial_split = false;
|
|
use_bvh_unaligned_nodes = true;
|
|
use_qbvh = false;
|
|
persistent_data = false;
|
|
texture_limit = 0;
|
|
}
|
|
|
|
bool modified(const SceneParams& params)
|
|
{ return !(shadingsystem == params.shadingsystem
|
|
&& bvh_type == params.bvh_type
|
|
&& use_bvh_spatial_split == params.use_bvh_spatial_split
|
|
&& use_bvh_unaligned_nodes == params.use_bvh_unaligned_nodes
|
|
&& use_qbvh == params.use_qbvh
|
|
&& persistent_data == params.persistent_data
|
|
&& texture_limit == params.texture_limit); }
|
|
};
|
|
|
|
/* Scene */
|
|
|
|
class Scene {
|
|
public:
|
|
/* data */
|
|
Camera *camera;
|
|
LookupTables *lookup_tables;
|
|
Film *film;
|
|
Background *background;
|
|
Integrator *integrator;
|
|
|
|
/* data lists */
|
|
vector<Object*> objects;
|
|
vector<Mesh*> meshes;
|
|
vector<Shader*> shaders;
|
|
vector<Light*> lights;
|
|
vector<ParticleSystem*> particle_systems;
|
|
|
|
/* data managers */
|
|
ImageManager *image_manager;
|
|
LightManager *light_manager;
|
|
ShaderManager *shader_manager;
|
|
MeshManager *mesh_manager;
|
|
ObjectManager *object_manager;
|
|
ParticleSystemManager *particle_system_manager;
|
|
CurveSystemManager *curve_system_manager;
|
|
BakeManager *bake_manager;
|
|
|
|
/* default shaders */
|
|
Shader *default_surface;
|
|
Shader *default_light;
|
|
Shader *default_background;
|
|
Shader *default_empty;
|
|
|
|
/* device */
|
|
Device *device;
|
|
DeviceScene dscene;
|
|
|
|
/* parameters */
|
|
SceneParams params;
|
|
|
|
/* mutex must be locked manually by callers */
|
|
thread_mutex mutex;
|
|
|
|
Scene(const SceneParams& params, const DeviceInfo& device_info);
|
|
~Scene();
|
|
|
|
void device_update(Device *device, Progress& progress);
|
|
|
|
bool need_global_attribute(AttributeStandard std);
|
|
void need_global_attributes(AttributeRequestSet& attributes);
|
|
|
|
enum MotionType { MOTION_NONE = 0, MOTION_PASS, MOTION_BLUR };
|
|
MotionType need_motion(bool advanced_shading = true);
|
|
float motion_shutter_time();
|
|
|
|
bool need_update();
|
|
bool need_reset();
|
|
|
|
void reset();
|
|
void device_free();
|
|
|
|
protected:
|
|
/* Check if some heavy data worth logging was updated.
|
|
* Mainly used to suppress extra annoying logging.
|
|
*/
|
|
bool need_data_update();
|
|
|
|
void free_memory(bool final);
|
|
};
|
|
|
|
CCL_NAMESPACE_END
|
|
|
|
#endif /* __SCENE_H__ */
|
|
|