From 070a668d04844610059aaedc80c49e9038fd1779 Mon Sep 17 00:00:00 2001 From: Brecht Van Lommel Date: Sat, 21 Oct 2017 01:09:59 +0200 Subject: Code refactor: move more memory allocation logic into device API. * Remove tex_* and pixels_* functions, replace by mem_*. * Add MEM_TEXTURE and MEM_PIXELS as memory types recognized by devices. * No longer create device_memory and call mem_* directly, always go through device_only_memory, device_vector and device_pixels. --- intern/cycles/render/bake.cpp | 22 +++-- intern/cycles/render/buffers.cpp | 91 ++++++--------------- intern/cycles/render/buffers.h | 26 ++---- intern/cycles/render/image.cpp | 82 +++++++++++++------ intern/cycles/render/integrator.cpp | 9 +-- intern/cycles/render/light.cpp | 58 ++++++------- intern/cycles/render/mesh.cpp | 143 ++++++++++++++------------------- intern/cycles/render/mesh_displace.cpp | 22 +++-- intern/cycles/render/object.cpp | 32 +++----- intern/cycles/render/particles.cpp | 11 ++- intern/cycles/render/scene.cpp | 68 ++++++++-------- intern/cycles/render/session.cpp | 12 +-- intern/cycles/render/shader.cpp | 12 ++- intern/cycles/render/svm.cpp | 5 +- intern/cycles/render/tables.cpp | 11 +-- 15 files changed, 264 insertions(+), 340 deletions(-) (limited to 'intern/cycles/render') diff --git a/intern/cycles/render/bake.cpp b/intern/cycles/render/bake.cpp index 66615bf336c..99f68b6aa00 100644 --- a/intern/cycles/render/bake.cpp +++ b/intern/cycles/render/bake.cpp @@ -151,7 +151,7 @@ bool BakeManager::bake(Device *device, DeviceScene *dscene, Scene *scene, Progre /* setup input for device task */ device_vector d_input(device, "bake_input", MEM_READ_ONLY); - uint4 *d_input_data = d_input.resize(shader_size * 2); + uint4 *d_input_data = d_input.alloc(shader_size * 2); size_t d_input_size = 0; for(size_t i = shader_offset; i < (shader_offset + shader_size); i++) { @@ -166,16 +166,13 @@ bool BakeManager::bake(Device *device, DeviceScene *dscene, Scene *scene, Progre /* run device task */ device_vector d_output(device, "bake_output", MEM_READ_WRITE); - d_output.resize(shader_size); + d_output.alloc(shader_size); + d_output.zero_to_device(); + d_input.copy_to_device(); /* needs to be up to data for attribute access */ device->const_copy_to("__data", &dscene->data, sizeof(dscene->data)); - device->mem_alloc(d_input); - device->mem_copy_to(d_input); - device->mem_alloc(d_output); - device->mem_zero(d_output); - DeviceTask task(DeviceTask::SHADER); task.shader_input = d_input.device_pointer; task.shader_output = d_output.device_pointer; @@ -192,15 +189,14 @@ bool BakeManager::bake(Device *device, DeviceScene *dscene, Scene *scene, Progre device->task_wait(); if(progress.get_cancel()) { - device->mem_free(d_input); - device->mem_free(d_output); + d_input.free(); + d_output.free(); m_is_baking = false; return false; } - device->mem_copy_from(d_output, 0, 1, d_output.size(), sizeof(float4)); - device->mem_free(d_input); - device->mem_free(d_output); + d_output.copy_from_device(0, 1, d_output.size()); + d_input.free(); /* read result */ int k = 0; @@ -218,6 +214,8 @@ bool BakeManager::bake(Device *device, DeviceScene *dscene, Scene *scene, Progre } } } + + d_output.free(); } m_is_baking = false; diff --git a/intern/cycles/render/buffers.cpp b/intern/cycles/render/buffers.cpp index 2342dd52d86..01f853dda71 100644 --- a/intern/cycles/render/buffers.cpp +++ b/intern/cycles/render/buffers.cpp @@ -115,54 +115,35 @@ RenderTile::RenderTile() /* Render Buffers */ RenderBuffers::RenderBuffers(Device *device) -: buffer(device, "RenderBuffers", MEM_READ_WRITE), - device(device) +: buffer(device, "RenderBuffers", MEM_READ_WRITE) { } RenderBuffers::~RenderBuffers() { - device_free(); + buffer.free(); } -void RenderBuffers::device_free() -{ - if(buffer.device_pointer) { - device->mem_free(buffer); - buffer.clear(); - } -} - -void RenderBuffers::reset(Device *device, BufferParams& params_) +void RenderBuffers::reset(BufferParams& params_) { params = params_; - /* free existing buffers */ - device_free(); - - /* allocate buffer */ - buffer.resize(params.width*params.height*params.get_passes_size()); - device->mem_alloc(buffer); - device->mem_zero(buffer); + /* re-allocate buffer */ + buffer.alloc(params.width*params.height*params.get_passes_size()); + buffer.zero_to_device(); } -void RenderBuffers::zero(Device *device) +void RenderBuffers::zero() { - if(buffer.device_pointer) { - device->mem_zero(buffer); - } + buffer.zero_to_device(); } -bool RenderBuffers::copy_from_device(Device *from_device) +bool RenderBuffers::copy_from_device() { if(!buffer.device_pointer) return false; - if(!from_device) { - from_device = device; - } - - from_device->mem_copy_from(buffer, 0, params.width, params.height, params.get_passes_size()*sizeof(float)); + buffer.copy_from_device(0, params.width * params.get_passes_size(), params.height); return true; } @@ -402,47 +383,30 @@ DisplayBuffer::DisplayBuffer(Device *device, bool linear) draw_height(0), transparent(true), /* todo: determine from background */ half_float(linear), - rgba_byte(device, "display buffer byte", MEM_WRITE_ONLY), - rgba_half(device, "display buffer half", MEM_WRITE_ONLY), - device(device) + rgba_byte(device, "display buffer byte"), + rgba_half(device, "display buffer half") { } DisplayBuffer::~DisplayBuffer() { - device_free(); -} - -void DisplayBuffer::device_free() -{ - if(rgba_byte.device_pointer) { - device->pixels_free(rgba_byte); - rgba_byte.clear(); - } - if(rgba_half.device_pointer) { - device->pixels_free(rgba_half); - rgba_half.clear(); - } + rgba_byte.free(); + rgba_half.free(); } -void DisplayBuffer::reset(Device *device, BufferParams& params_) +void DisplayBuffer::reset(BufferParams& params_) { draw_width = 0; draw_height = 0; params = params_; - /* free existing buffers */ - device_free(); - /* allocate display pixels */ if(half_float) { - rgba_half.resize(params.width, params.height); - device->pixels_alloc(rgba_half); + rgba_half.alloc_to_device(params.width, params.height); } else { - rgba_byte.resize(params.width, params.height); - device->pixels_alloc(rgba_byte); + rgba_byte.alloc_to_device(params.width, params.height); } } @@ -457,7 +421,8 @@ void DisplayBuffer::draw_set(int width, int height) void DisplayBuffer::draw(Device *device, const DeviceDrawParams& draw_params) { if(draw_width != 0 && draw_height != 0) { - device_memory& rgba = rgba_data(); + device_memory& rgba = (half_float)? (device_memory&)rgba_half: + (device_memory&)rgba_byte; device->draw_pixels(rgba, 0, draw_width, draw_height, params.full_x, params.full_y, params.width, params.height, transparent, draw_params); } @@ -468,7 +433,7 @@ bool DisplayBuffer::draw_ready() return (draw_width != 0 && draw_height != 0); } -void DisplayBuffer::write(Device *device, const string& filename) +void DisplayBuffer::write(const string& filename) { int w = draw_width; int h = draw_height; @@ -480,21 +445,19 @@ void DisplayBuffer::write(Device *device, const string& filename) return; /* read buffer from device */ - device_memory& rgba = rgba_data(); - device->pixels_copy_from(rgba, 0, w, h); + uchar4 *pixels = rgba_byte.copy_from_device(0, w, h); /* write image */ ImageOutput *out = ImageOutput::create(filename); ImageSpec spec(w, h, 4, TypeDesc::UINT8); - int scanlinesize = w*4*sizeof(uchar); out->open(filename, spec); /* conversion for different top/bottom convention */ out->write_image(TypeDesc::UINT8, - (uchar*)rgba.data_pointer + (h-1)*scanlinesize, + (uchar*)(pixels + (h-1)*w), AutoStride, - -scanlinesize, + -w*sizeof(uchar4), AutoStride); out->close(); @@ -502,13 +465,5 @@ void DisplayBuffer::write(Device *device, const string& filename) delete out; } -device_memory& DisplayBuffer::rgba_data() -{ - if(half_float) - return rgba_half; - else - return rgba_byte; -} - CCL_NAMESPACE_END diff --git a/intern/cycles/render/buffers.h b/intern/cycles/render/buffers.h index 2780fc8a68d..8563d6674ec 100644 --- a/intern/cycles/render/buffers.h +++ b/intern/cycles/render/buffers.h @@ -75,20 +75,15 @@ public: /* float buffer */ device_vector buffer; - Device *device; - explicit RenderBuffers(Device *device); ~RenderBuffers(); - void reset(Device *device, BufferParams& params); - void zero(Device *device); + void reset(BufferParams& params); + void zero(); - bool copy_from_device(Device *from_device = NULL); + bool copy_from_device(); bool get_pass_rect(PassType type, float exposure, int sample, int components, float *pixels); bool get_denoising_pass_rect(int offset, float exposure, int sample, int components, float *pixels); - -protected: - void device_free(); }; /* Display Buffer @@ -109,25 +104,18 @@ public: /* use half float? */ bool half_float; /* byte buffer for converted result */ - device_vector rgba_byte; - device_vector rgba_half; + device_pixels rgba_byte; + device_pixels rgba_half; DisplayBuffer(Device *device, bool linear = false); ~DisplayBuffer(); - void reset(Device *device, BufferParams& params); - void write(Device *device, const string& filename); + void reset(BufferParams& params); + void write(const string& filename); void draw_set(int width, int height); void draw(Device *device, const DeviceDrawParams& draw_params); bool draw_ready(); - - device_memory& rgba_data(); - -protected: - void device_free(); - - Device *device; }; /* Render Tile diff --git a/intern/cycles/render/image.cpp b/intern/cycles/render/image.cpp index e7f5ff002b7..625901ff258 100644 --- a/intern/cycles/render/image.cpp +++ b/intern/cycles/render/image.cpp @@ -532,7 +532,8 @@ bool ImageManager::file_load_image(Image *img, pixels = &pixels_storage[0]; } else { - pixels = (StorageType*)tex_img.resize(width, height, depth); + thread_scoped_lock device_lock(device_mutex); + pixels = (StorageType*)tex_img.alloc(width, height, depth); } if(pixels == NULL) { /* Could be that we've run out of memory. */ @@ -686,9 +687,16 @@ bool ImageManager::file_load_image(Image *img, scale_factor, &scaled_pixels, &scaled_width, &scaled_height, &scaled_depth); - StorageType *texture_pixels = (StorageType*)tex_img.resize(scaled_width, - scaled_height, - scaled_depth); + + StorageType *texture_pixels; + + { + thread_scoped_lock device_lock(device_mutex); + texture_pixels = (StorageType*)tex_img.alloc(scaled_width, + scaled_height, + scaled_depth); + } + memcpy(texture_pixels, &scaled_pixels[0], scaled_pixels.size() * sizeof(StorageType)); @@ -722,14 +730,14 @@ void ImageManager::device_load_image(Device *device, /* Free previous texture in slot. */ if(img->mem) { thread_scoped_lock device_lock(device_mutex); - device->tex_free(*img->mem); delete img->mem; img->mem = NULL; } /* Create new texture. */ if(type == IMAGE_DATA_TYPE_FLOAT4) { - device_vector *tex_img = new device_vector(device, name.c_str()); + device_vector *tex_img + = new device_vector(device, name.c_str(), MEM_TEXTURE); if(!file_load_image(img, type, @@ -737,7 +745,7 @@ void ImageManager::device_load_image(Device *device, *tex_img)) { /* on failure to load, we set a 1x1 pixels pink image */ - float *pixels = (float*)tex_img->resize(1, 1); + float *pixels = (float*)tex_img->alloc(1, 1); pixels[0] = TEX_IMAGE_MISSING_R; pixels[1] = TEX_IMAGE_MISSING_G; @@ -746,9 +754,15 @@ void ImageManager::device_load_image(Device *device, } img->mem = tex_img; + img->mem->interpolation = img->interpolation; + img->mem->extension = img->extension; + + thread_scoped_lock device_lock(device_mutex); + tex_img->copy_to_device(); } else if(type == IMAGE_DATA_TYPE_FLOAT) { - device_vector *tex_img = new device_vector(device, name.c_str()); + device_vector *tex_img + = new device_vector(device, name.c_str(), MEM_TEXTURE); if(!file_load_image(img, type, @@ -756,15 +770,21 @@ void ImageManager::device_load_image(Device *device, *tex_img)) { /* on failure to load, we set a 1x1 pixels pink image */ - float *pixels = (float*)tex_img->resize(1, 1); + float *pixels = (float*)tex_img->alloc(1, 1); pixels[0] = TEX_IMAGE_MISSING_R; } img->mem = tex_img; + img->mem->interpolation = img->interpolation; + img->mem->extension = img->extension; + + thread_scoped_lock device_lock(device_mutex); + tex_img->copy_to_device(); } else if(type == IMAGE_DATA_TYPE_BYTE4) { - device_vector *tex_img = new device_vector(device, name.c_str()); + device_vector *tex_img + = new device_vector(device, name.c_str(), MEM_TEXTURE); if(!file_load_image(img, type, @@ -772,7 +792,7 @@ void ImageManager::device_load_image(Device *device, *tex_img)) { /* on failure to load, we set a 1x1 pixels pink image */ - uchar *pixels = (uchar*)tex_img->resize(1, 1); + uchar *pixels = (uchar*)tex_img->alloc(1, 1); pixels[0] = (TEX_IMAGE_MISSING_R * 255); pixels[1] = (TEX_IMAGE_MISSING_G * 255); @@ -781,31 +801,43 @@ void ImageManager::device_load_image(Device *device, } img->mem = tex_img; + img->mem->interpolation = img->interpolation; + img->mem->extension = img->extension; + + thread_scoped_lock device_lock(device_mutex); + tex_img->copy_to_device(); } else if(type == IMAGE_DATA_TYPE_BYTE) { - device_vector *tex_img = new device_vector(device, name.c_str()); + device_vector *tex_img + = new device_vector(device, name.c_str(), MEM_TEXTURE); if(!file_load_image(img, type, texture_limit, *tex_img)) { /* on failure to load, we set a 1x1 pixels pink image */ - uchar *pixels = (uchar*)tex_img->resize(1, 1); + uchar *pixels = (uchar*)tex_img->alloc(1, 1); pixels[0] = (TEX_IMAGE_MISSING_R * 255); } img->mem = tex_img; + img->mem->interpolation = img->interpolation; + img->mem->extension = img->extension; + + thread_scoped_lock device_lock(device_mutex); + tex_img->copy_to_device(); } else if(type == IMAGE_DATA_TYPE_HALF4) { - device_vector *tex_img = new device_vector(device, name.c_str()); + device_vector *tex_img + = new device_vector(device, name.c_str(), MEM_TEXTURE); if(!file_load_image(img, type, texture_limit, *tex_img)) { /* on failure to load, we set a 1x1 pixels pink image */ - half *pixels = (half*)tex_img->resize(1, 1); + half *pixels = (half*)tex_img->alloc(1, 1); pixels[0] = TEX_IMAGE_MISSING_R; pixels[1] = TEX_IMAGE_MISSING_G; @@ -814,37 +846,38 @@ void ImageManager::device_load_image(Device *device, } img->mem = tex_img; + img->mem->interpolation = img->interpolation; + img->mem->extension = img->extension; + + thread_scoped_lock device_lock(device_mutex); + tex_img->copy_to_device(); } else if(type == IMAGE_DATA_TYPE_HALF) { - device_vector *tex_img = new device_vector(device, name.c_str()); + device_vector *tex_img + = new device_vector(device, name.c_str(), MEM_TEXTURE); if(!file_load_image(img, type, texture_limit, *tex_img)) { /* on failure to load, we set a 1x1 pixels pink image */ - half *pixels = (half*)tex_img->resize(1, 1); + half *pixels = (half*)tex_img->alloc(1, 1); pixels[0] = TEX_IMAGE_MISSING_R; } img->mem = tex_img; - } - - /* Copy to device. */ - if(img->mem) { img->mem->interpolation = img->interpolation; img->mem->extension = img->extension; thread_scoped_lock device_lock(device_mutex); - device->tex_alloc(*img->mem); + tex_img->copy_to_device(); } - img->need_load = false; } -void ImageManager::device_free_image(Device *device, ImageDataType type, int slot) +void ImageManager::device_free_image(Device *, ImageDataType type, int slot) { Image *img = images[type][slot]; @@ -858,7 +891,6 @@ void ImageManager::device_free_image(Device *device, ImageDataType type, int slo if(img->mem) { thread_scoped_lock device_lock(device_mutex); - device->tex_free(*img->mem); delete img->mem; } diff --git a/intern/cycles/render/integrator.cpp b/intern/cycles/render/integrator.cpp index b128f18db08..33c3dac9e81 100644 --- a/intern/cycles/render/integrator.cpp +++ b/intern/cycles/render/integrator.cpp @@ -191,11 +191,11 @@ void Integrator::device_update(Device *device, DeviceScene *dscene, Scene *scene int dimensions = PRNG_BASE_NUM + max_samples*PRNG_BOUNCE_NUM; dimensions = min(dimensions, SOBOL_MAX_DIMENSIONS); - uint *directions = dscene->sobol_directions.resize(SOBOL_BITS*dimensions); + uint *directions = dscene->sobol_directions.alloc(SOBOL_BITS*dimensions); sobol_generate_direction_vectors((uint(*)[SOBOL_BITS])directions, dimensions); - device->tex_alloc(dscene->sobol_directions); + dscene->sobol_directions.copy_to_device(); /* Clamping. */ bool use_sample_clamp = (sample_clamp_direct != 0.0f || @@ -208,10 +208,9 @@ void Integrator::device_update(Device *device, DeviceScene *dscene, Scene *scene need_update = false; } -void Integrator::device_free(Device *device, DeviceScene *dscene) +void Integrator::device_free(Device *, DeviceScene *dscene) { - device->tex_free(dscene->sobol_directions); - dscene->sobol_directions.clear(); + dscene->sobol_directions.free(); } bool Integrator::modified(const Integrator& integrator) diff --git a/intern/cycles/render/light.cpp b/intern/cycles/render/light.cpp index 9664e1310d5..b3804f34963 100644 --- a/intern/cycles/render/light.cpp +++ b/intern/cycles/render/light.cpp @@ -39,7 +39,7 @@ static void shade_background_pixels(Device *device, DeviceScene *dscene, int res device_vector d_input(device, "background_input", MEM_READ_ONLY); device_vector d_output(device, "background_output", MEM_WRITE_ONLY); - uint4 *d_input_data = d_input.resize(width*height); + uint4 *d_input_data = d_input.alloc(width*height); for(int y = 0; y < height; y++) { for(int x = 0; x < width; x++) { @@ -52,16 +52,12 @@ static void shade_background_pixels(Device *device, DeviceScene *dscene, int res } /* compute on device */ - d_output.resize(width*height); - memset((void*)d_output.data_pointer, 0, d_output.memory_size()); + d_output.alloc(width*height); + d_output.zero_to_device(); + d_input.copy_to_device(); device->const_copy_to("__data", &dscene->data, sizeof(dscene->data)); - device->mem_alloc(d_input); - device->mem_copy_to(d_input); - device->mem_alloc(d_output); - device->mem_zero(d_output); - DeviceTask main_task(DeviceTask::SHADER); main_task.shader_input = d_input.device_pointer; main_task.shader_output = d_output.device_pointer; @@ -78,13 +74,10 @@ static void shade_background_pixels(Device *device, DeviceScene *dscene, int res foreach(DeviceTask& task, split_tasks) { device->task_add(task); device->task_wait(); - device->mem_copy_from(d_output, task.shader_x, 1, task.shader_w, sizeof(float4)); + d_output.copy_from_device(task.shader_x, 1, task.shader_w); } - device->mem_free(d_input); - device->mem_free(d_output); - - d_input.clear(); + d_input.free(); float4 *d_output_data = reinterpret_cast(d_output.data_pointer); @@ -97,6 +90,8 @@ static void shade_background_pixels(Device *device, DeviceScene *dscene, int res pixels[y*width + x].z = d_output_data[y*width + x].z; } } + + d_output.free(); } /* Light */ @@ -246,7 +241,7 @@ bool LightManager::object_usable_as_light(Object *object) { return false; } -void LightManager::device_update_distribution(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress) +void LightManager::device_update_distribution(Device *, DeviceScene *dscene, Scene *scene, Progress& progress) { progress.set_status("Updating Lights", "Computing distribution"); @@ -292,7 +287,7 @@ void LightManager::device_update_distribution(Device *device, DeviceScene *dscen VLOG(1) << "Total " << num_distribution << " of light distribution primitives."; /* emission area */ - float4 *distribution = dscene->light_distribution.resize(num_distribution + 1); + float4 *distribution = dscene->light_distribution.alloc(num_distribution + 1); float totarea = 0.0f; /* triangles */ @@ -451,7 +446,7 @@ void LightManager::device_update_distribution(Device *device, DeviceScene *dscen kfilm->pass_shadow_scale *= (float)(num_lights - num_background_lights)/(float)num_lights; /* CDF */ - device->tex_alloc(dscene->light_distribution); + dscene->light_distribution.copy_to_device(); /* Portals */ if(num_portals > 0) { @@ -466,7 +461,7 @@ void LightManager::device_update_distribution(Device *device, DeviceScene *dscen } } else { - dscene->light_distribution.clear(); + dscene->light_distribution.free(); kintegrator->num_distribution = 0; kintegrator->num_all_lights = 0; @@ -561,8 +556,8 @@ void LightManager::device_update_background(Device *device, /* build row distributions and column distribution for the infinite area environment light */ int cdf_count = res + 1; - float2 *marg_cdf = dscene->light_background_marginal_cdf.resize(cdf_count); - float2 *cond_cdf = dscene->light_background_conditional_cdf.resize(cdf_count * cdf_count); + float2 *marg_cdf = dscene->light_background_marginal_cdf.alloc(cdf_count); + float2 *cond_cdf = dscene->light_background_conditional_cdf.alloc(cdf_count * cdf_count); double time_start = time_dt(); if(res < 512) { @@ -611,11 +606,11 @@ void LightManager::device_update_background(Device *device, VLOG(2) << "Background MIS build time " << time_dt() - time_start << "\n"; /* update device */ - device->tex_alloc(dscene->light_background_marginal_cdf); - device->tex_alloc(dscene->light_background_conditional_cdf); + dscene->light_background_marginal_cdf.copy_to_device(); + dscene->light_background_conditional_cdf.copy_to_device(); } -void LightManager::device_update_points(Device *device, +void LightManager::device_update_points(Device *, DeviceScene *dscene, Scene *scene) { @@ -628,7 +623,7 @@ void LightManager::device_update_points(Device *device, } } - float4 *light_data = dscene->light_data.resize(num_lights*LIGHT_SIZE); + float4 *light_data = dscene->light_data.alloc(num_lights*LIGHT_SIZE); if(num_lights == 0) { VLOG(1) << "No effective light, ignoring points update."; @@ -813,7 +808,7 @@ void LightManager::device_update_points(Device *device, VLOG(1) << "Number of lights without contribution: " << num_scene_lights - light_index; - device->tex_alloc(dscene->light_data); + dscene->light_data.copy_to_device(); } void LightManager::device_update(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress) @@ -846,17 +841,12 @@ void LightManager::device_update(Device *device, DeviceScene *dscene, Scene *sce need_update = false; } -void LightManager::device_free(Device *device, DeviceScene *dscene) +void LightManager::device_free(Device *, DeviceScene *dscene) { - device->tex_free(dscene->light_distribution); - device->tex_free(dscene->light_data); - device->tex_free(dscene->light_background_marginal_cdf); - device->tex_free(dscene->light_background_conditional_cdf); - - dscene->light_distribution.clear(); - dscene->light_data.clear(); - dscene->light_background_marginal_cdf.clear(); - dscene->light_background_conditional_cdf.clear(); + dscene->light_distribution.free(); + dscene->light_data.free(); + dscene->light_background_marginal_cdf.free(); + dscene->light_background_conditional_cdf.free(); } void LightManager::tag_update(Scene * /*scene*/) diff --git a/intern/cycles/render/mesh.cpp b/intern/cycles/render/mesh.cpp index 685272b80c1..75bdf71616f 100644 --- a/intern/cycles/render/mesh.cpp +++ b/intern/cycles/render/mesh.cpp @@ -1252,7 +1252,7 @@ void MeshManager::update_osl_attributes(Device *device, Scene *scene, vector& mesh_attributes) +void MeshManager::update_svm_attributes(Device *, DeviceScene *dscene, Scene *scene, vector& mesh_attributes) { /* for SVM, the attributes_map table is used to lookup the offset of an * attribute, based on a unique shader attribute id. */ @@ -1267,7 +1267,7 @@ void MeshManager::update_svm_attributes(Device *device, DeviceScene *dscene, Sce return; /* create attribute map */ - uint4 *attr_map = dscene->attributes_map.resize(attr_map_stride*scene->objects.size()); + uint4 *attr_map = dscene->attributes_map.alloc(attr_map_stride*scene->objects.size()); memset(attr_map, 0, dscene->attributes_map.size()*sizeof(uint)); for(size_t i = 0; i < scene->objects.size(); i++) { @@ -1359,7 +1359,7 @@ void MeshManager::update_svm_attributes(Device *device, DeviceScene *dscene, Sce /* copy to device */ dscene->data.bvh.attributes_map_stride = attr_map_stride; - device->tex_alloc(dscene->attributes_map); + dscene->attributes_map.copy_to_device(); } static void update_attribute_element_size(Mesh *mesh, @@ -1554,9 +1554,9 @@ void MeshManager::device_update_attributes(Device *device, DeviceScene *dscene, } } - dscene->attributes_float.resize(attr_float_size); - dscene->attributes_float3.resize(attr_float3_size); - dscene->attributes_uchar4.resize(attr_uchar4_size); + dscene->attributes_float.alloc(attr_float_size); + dscene->attributes_float3.alloc(attr_float3_size); + dscene->attributes_uchar4.alloc(attr_uchar4_size); size_t attr_float_offset = 0; size_t attr_float3_offset = 0; @@ -1617,13 +1617,13 @@ void MeshManager::device_update_attributes(Device *device, DeviceScene *dscene, progress.set_status("Updating Mesh", "Copying Attributes to device"); if(dscene->attributes_float.size()) { - device->tex_alloc(dscene->attributes_float); + dscene->attributes_float.copy_to_device(); } if(dscene->attributes_float3.size()) { - device->tex_alloc(dscene->attributes_float3); + dscene->attributes_float3.copy_to_device(); } if(dscene->attributes_uchar4.size()) { - device->tex_alloc(dscene->attributes_uchar4); + dscene->attributes_uchar4.copy_to_device(); } } @@ -1671,7 +1671,7 @@ void MeshManager::mesh_calc_offset(Scene *scene) } } -void MeshManager::device_update_mesh(Device *device, +void MeshManager::device_update_mesh(Device *, DeviceScene *dscene, Scene *scene, bool for_displacement, @@ -1732,11 +1732,11 @@ void MeshManager::device_update_mesh(Device *device, /* normals */ progress.set_status("Updating Mesh", "Computing normals"); - uint *tri_shader = dscene->tri_shader.resize(tri_size); - float4 *vnormal = dscene->tri_vnormal.resize(vert_size); - uint4 *tri_vindex = dscene->tri_vindex.resize(tri_size); - uint *tri_patch = dscene->tri_patch.resize(tri_size); - float2 *tri_patch_uv = dscene->tri_patch_uv.resize(vert_size); + uint *tri_shader = dscene->tri_shader.alloc(tri_size); + float4 *vnormal = dscene->tri_vnormal.alloc(vert_size); + uint4 *tri_vindex = dscene->tri_vindex.alloc(tri_size); + uint *tri_patch = dscene->tri_patch.alloc(tri_size); + float2 *tri_patch_uv = dscene->tri_patch_uv.alloc(vert_size); foreach(Mesh *mesh, scene->meshes) { mesh->pack_normals(scene, @@ -1754,32 +1754,32 @@ void MeshManager::device_update_mesh(Device *device, /* vertex coordinates */ progress.set_status("Updating Mesh", "Copying Mesh to device"); - device->tex_alloc(dscene->tri_shader); - device->tex_alloc(dscene->tri_vnormal); - device->tex_alloc(dscene->tri_vindex); - device->tex_alloc(dscene->tri_patch); - device->tex_alloc(dscene->tri_patch_uv); + dscene->tri_shader.copy_to_device(); + dscene->tri_vnormal.copy_to_device(); + dscene->tri_vindex.copy_to_device(); + dscene->tri_patch.copy_to_device(); + dscene->tri_patch_uv.copy_to_device(); } if(curve_size != 0) { progress.set_status("Updating Mesh", "Copying Strands to device"); - float4 *curve_keys = dscene->curve_keys.resize(curve_key_size); - float4 *curves = dscene->curves.resize(curve_size); + float4 *curve_keys = dscene->curve_keys.alloc(curve_key_size); + float4 *curves = dscene->curves.alloc(curve_size); foreach(Mesh *mesh, scene->meshes) { mesh->pack_curves(scene, &curve_keys[mesh->curvekey_offset], &curves[mesh->curve_offset], mesh->curvekey_offset); if(progress.get_cancel()) return; } - device->tex_alloc(dscene->curve_keys); - device->tex_alloc(dscene->curves); + dscene->curve_keys.copy_to_device(); + dscene->curves.copy_to_device(); } if(patch_size != 0) { progress.set_status("Updating Mesh", "Copying Patches to device"); - uint *patch_data = dscene->patches.resize(patch_size); + uint *patch_data = dscene->patches.alloc(patch_size); foreach(Mesh *mesh, scene->meshes) { mesh->pack_patches(&patch_data[mesh->patch_offset], mesh->vert_offset, mesh->face_offset, mesh->corner_offset); @@ -1791,11 +1791,11 @@ void MeshManager::device_update_mesh(Device *device, if(progress.get_cancel()) return; } - device->tex_alloc(dscene->patches); + dscene->patches.copy_to_device(); } if(for_displacement) { - float4 *prim_tri_verts = dscene->prim_tri_verts.resize(tri_size * 3); + float4 *prim_tri_verts = dscene->prim_tri_verts.alloc(tri_size * 3); foreach(Mesh *mesh, scene->meshes) { for(size_t i = 0; i < mesh->num_triangles(); ++i) { Mesh::Triangle t = mesh->get_triangle(i); @@ -1805,7 +1805,7 @@ void MeshManager::device_update_mesh(Device *device, prim_tri_verts[offset + 2] = float3_to_float4(mesh->verts[t.v[2]]); } } - device->tex_alloc(dscene->prim_tri_verts); + dscene->prim_tri_verts.copy_to_device(); } } @@ -1841,43 +1841,43 @@ void MeshManager::device_update_bvh(Device *device, DeviceScene *dscene, Scene * if(pack.nodes.size()) { dscene->bvh_nodes.steal_data(pack.nodes); - device->tex_alloc(dscene->bvh_nodes); + dscene->bvh_nodes.copy_to_device(); } if(pack.leaf_nodes.size()) { dscene->bvh_leaf_nodes.steal_data(pack.leaf_nodes); - device->tex_alloc(dscene->bvh_leaf_nodes); + dscene->bvh_leaf_nodes.copy_to_device(); } if(pack.object_node.size()) { dscene->object_node.steal_data(pack.object_node); - device->tex_alloc(dscene->object_node); + dscene->object_node.copy_to_device(); } if(pack.prim_tri_index.size()) { dscene->prim_tri_index.steal_data(pack.prim_tri_index); - device->tex_alloc(dscene->prim_tri_index); + dscene->prim_tri_index.copy_to_device(); } if(pack.prim_tri_verts.size()) { dscene->prim_tri_verts.steal_data(pack.prim_tri_verts); - device->tex_alloc(dscene->prim_tri_verts); + dscene->prim_tri_verts.copy_to_device(); } if(pack.prim_type.size()) { dscene->prim_type.steal_data(pack.prim_type); - device->tex_alloc(dscene->prim_type); + dscene->prim_type.copy_to_device(); } if(pack.prim_visibility.size()) { dscene->prim_visibility.steal_data(pack.prim_visibility); - device->tex_alloc(dscene->prim_visibility); + dscene->prim_visibility.copy_to_device(); } if(pack.prim_index.size()) { dscene->prim_index.steal_data(pack.prim_index); - device->tex_alloc(dscene->prim_index); + dscene->prim_index.copy_to_device(); } if(pack.prim_object.size()) { dscene->prim_object.steal_data(pack.prim_object); - device->tex_alloc(dscene->prim_object); + dscene->prim_object.copy_to_device(); } if(pack.prim_time.size()) { dscene->prim_time.steal_data(pack.prim_time); - device->tex_alloc(dscene->prim_time); + dscene->prim_time.copy_to_device(); } dscene->data.bvh.root = pack.root_index; @@ -2142,51 +2142,28 @@ void MeshManager::device_update(Device *device, DeviceScene *dscene, Scene *scen void MeshManager::device_free(Device *device, DeviceScene *dscene) { - device->tex_free(dscene->bvh_nodes); - device->tex_free(dscene->bvh_leaf_nodes); - device->tex_free(dscene->object_node); - device->tex_free(dscene->prim_tri_verts); - device->tex_free(dscene->prim_tri_index); - device->tex_free(dscene->prim_type); - device->tex_free(dscene->prim_visibility); - device->tex_free(dscene->prim_index); - device->tex_free(dscene->prim_object); - device->tex_free(dscene->prim_time); - device->tex_free(dscene->tri_shader); - device->tex_free(dscene->tri_vnormal); - device->tex_free(dscene->tri_vindex); - device->tex_free(dscene->tri_patch); - device->tex_free(dscene->tri_patch_uv); - device->tex_free(dscene->curves); - device->tex_free(dscene->curve_keys); - device->tex_free(dscene->patches); - device->tex_free(dscene->attributes_map); - device->tex_free(dscene->attributes_float); - device->tex_free(dscene->attributes_float3); - device->tex_free(dscene->attributes_uchar4); - - dscene->bvh_nodes.clear(); - dscene->bvh_leaf_nodes.clear(); - dscene->object_node.clear(); - dscene->prim_tri_verts.clear(); - dscene->prim_tri_index.clear(); - dscene->prim_type.clear(); - dscene->prim_visibility.clear(); - dscene->prim_index.clear(); - dscene->prim_object.clear(); - dscene->prim_time.clear(); - dscene->tri_shader.clear(); - dscene->tri_vnormal.clear(); - dscene->tri_vindex.clear(); - dscene->tri_patch.clear(); - dscene->tri_patch_uv.clear(); - dscene->curves.clear(); - dscene->curve_keys.clear(); - dscene->patches.clear(); - dscene->attributes_map.clear(); - dscene->attributes_float.clear(); - dscene->attributes_float3.clear(); - dscene->attributes_uchar4.clear(); + dscene->bvh_nodes.free(); + dscene->bvh_leaf_nodes.free(); + dscene->object_node.free(); + dscene->prim_tri_verts.free(); + dscene->prim_tri_index.free(); + dscene->prim_type.free(); + dscene->prim_visibility.free(); + dscene->prim_index.free(); + dscene->prim_object.free(); + dscene->prim_time.free(); + dscene->tri_shader.free(); + dscene->tri_vnormal.free(); + dscene->tri_vindex.free(); + dscene->tri_patch.free(); + dscene->tri_patch_uv.free(); + dscene->curves.free(); + dscene->curve_keys.free(); + dscene->patches.free(); + dscene->attributes_map.free(); + dscene->attributes_float.free(); + dscene->attributes_float3.free(); + dscene->attributes_uchar4.free(); #ifdef WITH_OSL OSLGlobals *og = (OSLGlobals*)device->osl_memory(); diff --git a/intern/cycles/render/mesh_displace.cpp b/intern/cycles/render/mesh_displace.cpp index c06cf86ea9c..ab3ae40d931 100644 --- a/intern/cycles/render/mesh_displace.cpp +++ b/intern/cycles/render/mesh_displace.cpp @@ -65,7 +65,7 @@ bool MeshManager::displace(Device *device, DeviceScene *dscene, Scene *scene, Me const size_t num_verts = mesh->verts.size(); vector done(num_verts, false); device_vector d_input(device, "displace_input", MEM_READ_ONLY); - uint4 *d_input_data = d_input.resize(num_verts); + uint4 *d_input_data = d_input.alloc(num_verts); size_t d_input_size = 0; size_t num_triangles = mesh->num_triangles(); @@ -116,16 +116,13 @@ bool MeshManager::displace(Device *device, DeviceScene *dscene, Scene *scene, Me /* run device task */ device_vector d_output(device, "displace_output", MEM_WRITE_ONLY); - d_output.resize(d_input_size); + d_output.alloc(d_input_size); + d_output.zero_to_device(); + d_input.copy_to_device(); /* needs to be up to data for attribute access */ device->const_copy_to("__data", &dscene->data, sizeof(dscene->data)); - device->mem_alloc(d_input); - device->mem_copy_to(d_input); - device->mem_alloc(d_output); - device->mem_zero(d_output); - DeviceTask task(DeviceTask::SHADER); task.shader_input = d_input.device_pointer; task.shader_output = d_output.device_pointer; @@ -139,14 +136,13 @@ bool MeshManager::displace(Device *device, DeviceScene *dscene, Scene *scene, Me device->task_wait(); if(progress.get_cancel()) { - device->mem_free(d_input); - device->mem_free(d_output); + d_input.free(); + d_output.free(); return false; } - device->mem_copy_from(d_output, 0, 1, d_output.size(), sizeof(float4)); - device->mem_free(d_input); - device->mem_free(d_output); + d_output.copy_from_device(0, 1, d_output.size()); + d_input.free(); /* read result */ done.clear(); @@ -183,6 +179,8 @@ bool MeshManager::displace(Device *device, DeviceScene *dscene, Scene *scene, Me } } + d_output.free(); + /* for displacement method both, we only need to recompute the face * normals, as bump mapping in the shader will already alter the * vertex normal, so we start from the non-displaced vertex normals diff --git a/intern/cycles/render/object.cpp b/intern/cycles/render/object.cpp index daa872239ce..57e44861e40 100644 --- a/intern/cycles/render/object.cpp +++ b/intern/cycles/render/object.cpp @@ -488,9 +488,9 @@ void ObjectManager::device_update_transforms(Device *device, state.queue_start_object = 0; state.object_flag = object_flag; - state.objects = dscene->objects.resize(OBJECT_SIZE*scene->objects.size()); + state.objects = dscene->objects.alloc(OBJECT_SIZE*scene->objects.size()); if(state.need_motion == Scene::MOTION_PASS) { - state.objects_vector = dscene->objects_vector.resize(OBJECT_VECTOR_SIZE*scene->objects.size()); + state.objects_vector = dscene->objects_vector.alloc(OBJECT_VECTOR_SIZE*scene->objects.size()); } else { state.objects_vector = NULL; @@ -534,9 +534,9 @@ void ObjectManager::device_update_transforms(Device *device, } } - device->tex_alloc(dscene->objects); + dscene->objects.copy_to_device(); if(state.need_motion == Scene::MOTION_PASS) { - device->tex_alloc(dscene->objects_vector); + dscene->objects_vector.copy_to_device(); } dscene->data.bvh.have_motion = state.have_motion; @@ -557,7 +557,7 @@ void ObjectManager::device_update(Device *device, DeviceScene *dscene, Scene *sc return; /* object info flag */ - uint *object_flag = dscene->object_flag.resize(scene->objects.size()); + uint *object_flag = dscene->object_flag.alloc(scene->objects.size()); /* set object transform matrices, before applying static transforms */ progress.set_status("Updating Objects", "Copying Transformations to device"); @@ -573,7 +573,7 @@ void ObjectManager::device_update(Device *device, DeviceScene *dscene, Scene *sc } } -void ObjectManager::device_update_flags(Device *device, +void ObjectManager::device_update_flags(Device *, DeviceScene *dscene, Scene *scene, Progress& /*progress*/, @@ -638,10 +638,10 @@ void ObjectManager::device_update_flags(Device *device, } /* allocate object flag */ - device->tex_alloc(dscene->object_flag); + dscene->object_flag.copy_to_device(); } -void ObjectManager::device_update_patch_map_offsets(Device *device, DeviceScene *dscene, Scene *scene) +void ObjectManager::device_update_patch_map_offsets(Device *, DeviceScene *dscene, Scene *scene) { if(scene->objects.size() == 0) { return; @@ -671,21 +671,15 @@ void ObjectManager::device_update_patch_map_offsets(Device *device, DeviceScene } if(update) { - device->tex_free(dscene->objects); - device->tex_alloc(dscene->objects); + dscene->objects.copy_to_device(); } } -void ObjectManager::device_free(Device *device, DeviceScene *dscene) +void ObjectManager::device_free(Device *, DeviceScene *dscene) { - device->tex_free(dscene->objects); - dscene->objects.clear(); - - device->tex_free(dscene->objects_vector); - dscene->objects_vector.clear(); - - device->tex_free(dscene->object_flag); - dscene->object_flag.clear(); + dscene->objects.free(); + dscene->objects_vector.free(); + dscene->object_flag.free(); } void ObjectManager::apply_static_transforms(DeviceScene *dscene, Scene *scene, uint *object_flag, Progress& progress) diff --git a/intern/cycles/render/particles.cpp b/intern/cycles/render/particles.cpp index a84ca51f274..06ff45b09bd 100644 --- a/intern/cycles/render/particles.cpp +++ b/intern/cycles/render/particles.cpp @@ -52,7 +52,7 @@ ParticleSystemManager::~ParticleSystemManager() { } -void ParticleSystemManager::device_update_particles(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress) +void ParticleSystemManager::device_update_particles(Device *, DeviceScene *dscene, Scene *scene, Progress& progress) { /* count particles. * adds one dummy particle at the beginning to avoid invalid lookups, @@ -61,7 +61,7 @@ void ParticleSystemManager::device_update_particles(Device *device, DeviceScene for(size_t j = 0; j < scene->particle_systems.size(); j++) num_particles += scene->particle_systems[j]->particles.size(); - float4 *particles = dscene->particles.resize(PARTICLE_SIZE*num_particles); + float4 *particles = dscene->particles.alloc(PARTICLE_SIZE*num_particles); /* dummy particle */ particles[0] = make_float4(0.0f, 0.0f, 0.0f, 0.0f); @@ -91,7 +91,7 @@ void ParticleSystemManager::device_update_particles(Device *device, DeviceScene } } - device->tex_alloc(dscene->particles); + dscene->particles.copy_to_device(); } void ParticleSystemManager::device_update(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress) @@ -112,10 +112,9 @@ void ParticleSystemManager::device_update(Device *device, DeviceScene *dscene, S need_update = false; } -void ParticleSystemManager::device_free(Device *device, DeviceScene *dscene) +void ParticleSystemManager::device_free(Device *, DeviceScene *dscene) { - device->tex_free(dscene->particles); - dscene->particles.clear(); + dscene->particles.free(); } void ParticleSystemManager::tag_update(Scene * /*scene*/) diff --git a/intern/cycles/render/scene.cpp b/intern/cycles/render/scene.cpp index e362a35471d..260a325206c 100644 --- a/intern/cycles/render/scene.cpp +++ b/intern/cycles/render/scene.cpp @@ -41,40 +41,40 @@ CCL_NAMESPACE_BEGIN DeviceScene::DeviceScene(Device *device) -: bvh_nodes(device, "__bvh_nodes"), - bvh_leaf_nodes(device, "__bvh_leaf_nodes"), - object_node(device, "__object_node"), - prim_tri_index(device, "__prim_tri_index"), - prim_tri_verts(device, "__prim_tri_verts"), - prim_type(device, "__prim_type"), - prim_visibility(device, "__prim_visibility"), - prim_index(device, "__prim_index"), - prim_object(device, "__prim_object"), - prim_time(device, "__prim_time"), - tri_shader(device, "__tri_shader"), - tri_vnormal(device, "__tri_vnormal"), - tri_vindex(device, "__tri_vindex"), - tri_patch(device, "__tri_patch"), - tri_patch_uv(device, "__tri_patch_uv"), - curves(device, "__curves"), - curve_keys(device, "__curve_keys"), - patches(device, "__patches"), - objects(device, "__objects"), - objects_vector(device, "__objects_vector"), - attributes_map(device, "__attributes_map"), - attributes_float(device, "__attributes_float"), - attributes_float3(device, "__attributes_float3"), - attributes_uchar4(device, "__attributes_uchar4"), - light_distribution(device, "__light_distribution"), - light_data(device, "__light_data"), - light_background_marginal_cdf(device, "__light_background_marginal_cdf"), - light_background_conditional_cdf(device, "__light_background_conditional_cdf"), - particles(device, "__particles"), - svm_nodes(device, "__svm_nodes"), - shader_flag(device, "__shader_flag"), - object_flag(device, "__object_flag"), - lookup_table(device, "__lookup_table"), - sobol_directions(device, "__sobol_directions") +: bvh_nodes(device, "__bvh_nodes", MEM_TEXTURE), + bvh_leaf_nodes(device, "__bvh_leaf_nodes", MEM_TEXTURE), + object_node(device, "__object_node", MEM_TEXTURE), + prim_tri_index(device, "__prim_tri_index", MEM_TEXTURE), + prim_tri_verts(device, "__prim_tri_verts", MEM_TEXTURE), + prim_type(device, "__prim_type", MEM_TEXTURE), + prim_visibility(device, "__prim_visibility", MEM_TEXTURE), + prim_index(device, "__prim_index", MEM_TEXTURE), + prim_object(device, "__prim_object", MEM_TEXTURE), + prim_time(device, "__prim_time", MEM_TEXTURE), + tri_shader(device, "__tri_shader", MEM_TEXTURE), + tri_vnormal(device, "__tri_vnormal", MEM_TEXTURE), + tri_vindex(device, "__tri_vindex", MEM_TEXTURE), + tri_patch(device, "__tri_patch", MEM_TEXTURE), + tri_patch_uv(device, "__tri_patch_uv", MEM_TEXTURE), + curves(device, "__curves", MEM_TEXTURE), + curve_keys(device, "__curve_keys", MEM_TEXTURE), + patches(device, "__patches", MEM_TEXTURE), + objects(device, "__objects", MEM_TEXTURE), + objects_vector(device, "__objects_vector", MEM_TEXTURE), + attributes_map(device, "__attributes_map", MEM_TEXTURE), + attributes_float(device, "__attributes_float", MEM_TEXTURE), + attributes_float3(device, "__attributes_float3", MEM_TEXTURE), + attributes_uchar4(device, "__attributes_uchar4", MEM_TEXTURE), + light_distribution(device, "__light_distribution", MEM_TEXTURE), + light_data(device, "__light_data", MEM_TEXTURE), + light_background_marginal_cdf(device, "__light_background_marginal_cdf", MEM_TEXTURE), + light_background_conditional_cdf(device, "__light_background_conditional_cdf", MEM_TEXTURE), + particles(device, "__particles", MEM_TEXTURE), + svm_nodes(device, "__svm_nodes", MEM_TEXTURE), + shader_flag(device, "__shader_flag", MEM_TEXTURE), + object_flag(device, "__object_flag", MEM_TEXTURE), + lookup_table(device, "__lookup_table", MEM_TEXTURE), + sobol_directions(device, "__sobol_directions", MEM_TEXTURE) { memset(&data, 0, sizeof(data)); } diff --git a/intern/cycles/render/session.cpp b/intern/cycles/render/session.cpp index 4642dcfa9a1..74cfd02e1a4 100644 --- a/intern/cycles/render/session.cpp +++ b/intern/cycles/render/session.cpp @@ -106,11 +106,11 @@ Session::~Session() delete display; display = new DisplayBuffer(device, false); - display->reset(device, buffers->params); + display->reset(buffers->params); tonemap(params.samples); progress.set_status("Writing Image", params.output_path); - display->write(device, params.output_path); + display->write(params.output_path); } /* clean up */ @@ -399,7 +399,7 @@ bool Session::acquire_tile(Device *tile_device, RenderTile& rtile) /* allocate buffers */ tile->buffers = new RenderBuffers(tile_device); - tile->buffers->reset(tile_device, buffer_params); + tile->buffers->reset(buffer_params); } tile->buffers->params.get_offset_stride(rtile.offset, rtile.stride); @@ -756,9 +756,9 @@ void Session::reset_(BufferParams& buffer_params, int samples) { if(buffers && buffer_params.modified(tile_manager.params)) { gpu_draw_ready = false; - buffers->reset(device, buffer_params); + buffers->reset(buffer_params); if(display) { - display->reset(device, buffer_params); + display->reset(buffer_params); } } @@ -923,7 +923,7 @@ void Session::render() { /* Clear buffers. */ if(buffers && tile_manager.state.sample == tile_manager.range_start_sample) { - buffers->zero(device); + buffers->zero(); } /* Add path trace task. */ diff --git a/intern/cycles/render/shader.cpp b/intern/cycles/render/shader.cpp index a77df55e520..70f6d5bab47 100644 --- a/intern/cycles/render/shader.cpp +++ b/intern/cycles/render/shader.cpp @@ -416,14 +416,13 @@ void ShaderManager::device_update_common(Device *device, Scene *scene, Progress& /*progress*/) { - device->tex_free(dscene->shader_flag); - dscene->shader_flag.clear(); + dscene->shader_flag.free(); if(scene->shaders.size() == 0) return; uint shader_flag_size = scene->shaders.size()*SHADER_SIZE; - uint *shader_flag = dscene->shader_flag.resize(shader_flag_size); + uint *shader_flag = dscene->shader_flag.alloc(shader_flag_size); uint i = 0; bool has_volumes = false; bool has_transparent_shadow = false; @@ -479,7 +478,7 @@ void ShaderManager::device_update_common(Device *device, has_transparent_shadow |= (flag & SD_HAS_TRANSPARENT_SHADOW) != 0; } - device->tex_alloc(dscene->shader_flag); + dscene->shader_flag.copy_to_device(); /* lookup tables */ KernelTables *ktables = &dscene->data.tables; @@ -504,12 +503,11 @@ void ShaderManager::device_update_common(Device *device, kintegrator->transparent_shadows = has_transparent_shadow; } -void ShaderManager::device_free_common(Device *device, DeviceScene *dscene, Scene *scene) +void ShaderManager::device_free_common(Device *, DeviceScene *dscene, Scene *scene) { scene->lookup_tables->remove_table(&beckmann_table_offset); - device->tex_free(dscene->shader_flag); - dscene->shader_flag.clear(); + dscene->shader_flag.free(); } void ShaderManager::add_default(Scene *scene) diff --git a/intern/cycles/render/svm.cpp b/intern/cycles/render/svm.cpp index cf0dc97ef3f..db53e366d1e 100644 --- a/intern/cycles/render/svm.cpp +++ b/intern/cycles/render/svm.cpp @@ -130,7 +130,7 @@ void SVMShaderManager::device_update(Device *device, DeviceScene *dscene, Scene } dscene->svm_nodes.steal_data(svm_nodes); - device->tex_alloc(dscene->svm_nodes); + dscene->svm_nodes.copy_to_device(); for(i = 0; i < scene->shaders.size(); i++) { Shader *shader = scene->shaders[i]; @@ -150,8 +150,7 @@ void SVMShaderManager::device_free(Device *device, DeviceScene *dscene, Scene *s { device_free_common(device, dscene, scene); - device->tex_free(dscene->svm_nodes); - dscene->svm_nodes.clear(); + dscene->svm_nodes.free(); } /* Graph Compiler */ diff --git a/intern/cycles/render/tables.cpp b/intern/cycles/render/tables.cpp index 9d04778abc6..5cda977b7f1 100644 --- a/intern/cycles/render/tables.cpp +++ b/intern/cycles/render/tables.cpp @@ -35,25 +35,22 @@ LookupTables::~LookupTables() assert(lookup_tables.size() == 0); } -void LookupTables::device_update(Device *device, DeviceScene *dscene) +void LookupTables::device_update(Device *, DeviceScene *dscene) { if(!need_update) return; VLOG(1) << "Total " << lookup_tables.size() << " lookup tables."; - device->tex_free(dscene->lookup_table); - if(lookup_tables.size() > 0) - device->tex_alloc(dscene->lookup_table); + dscene->lookup_table.copy_to_device(); need_update = false; } -void LookupTables::device_free(Device *device, DeviceScene *dscene) +void LookupTables::device_free(Device *, DeviceScene *dscene) { - device->tex_free(dscene->lookup_table); - dscene->lookup_table.clear(); + dscene->lookup_table.free(); } static size_t round_up_to_multiple(size_t size, size_t chunk) -- cgit v1.2.3