[Bf-blender-cvs] [90bf17f95e6] new-object-types: Merge branch 'master' into HEAD

Brecht Van Lommel noreply at git.blender.org
Fri Mar 13 11:53:24 CET 2020


Commit: 90bf17f95e635407dda8b4a612a9c0dd656f30a4
Author: Brecht Van Lommel
Date:   Thu Mar 12 17:33:36 2020 +0100
Branches: new-object-types
https://developer.blender.org/rB90bf17f95e635407dda8b4a612a9c0dd656f30a4

Merge branch 'master' into HEAD

===================================================================



===================================================================

diff --cc intern/cycles/device/device_memory.cpp
index 1a21d2ee70e,36a0247bb3d..3c4f68cfc77
--- a/intern/cycles/device/device_memory.cpp
+++ b/intern/cycles/device/device_memory.cpp
@@@ -141,4 -137,91 +137,93 @@@ device_sub_ptr::~device_sub_ptr(
    device->mem_free_sub_ptr(ptr);
  }
  
+ /* Device Texture */
+ 
+ device_texture::device_texture(Device *device,
+                                const char *name,
+                                const uint slot,
+                                ImageDataType image_data_type,
+                                InterpolationType interpolation,
+                                ExtensionType extension)
+     : device_memory(device, name, MEM_TEXTURE), slot(slot)
+ {
+   switch (image_data_type) {
+     case IMAGE_DATA_TYPE_FLOAT4:
+       data_type = TYPE_FLOAT;
+       data_elements = 4;
+       break;
+     case IMAGE_DATA_TYPE_FLOAT:
+       data_type = TYPE_FLOAT;
+       data_elements = 1;
+       break;
+     case IMAGE_DATA_TYPE_BYTE4:
+       data_type = TYPE_UCHAR;
+       data_elements = 4;
+       break;
+     case IMAGE_DATA_TYPE_BYTE:
+       data_type = TYPE_UCHAR;
+       data_elements = 1;
+       break;
+     case IMAGE_DATA_TYPE_HALF4:
+       data_type = TYPE_HALF;
+       data_elements = 4;
+       break;
+     case IMAGE_DATA_TYPE_HALF:
+       data_type = TYPE_HALF;
+       data_elements = 1;
+       break;
+     case IMAGE_DATA_TYPE_USHORT4:
+       data_type = TYPE_UINT16;
+       data_elements = 4;
+       break;
+     case IMAGE_DATA_TYPE_USHORT:
+       data_type = TYPE_UINT16;
+       data_elements = 1;
+       break;
+     case IMAGE_DATA_NUM_TYPES:
+       assert(0);
+       return;
+   }
+ 
+   memset(&info, 0, sizeof(info));
+   info.data_type = image_data_type;
+   info.interpolation = interpolation;
+   info.extension = extension;
+ }
+ 
+ device_texture::~device_texture()
+ {
++  device_free();
++  host_free();
+ }
+ 
+ /* Host memory allocation. */
+ void *device_texture::alloc(const size_t width, const size_t height, const size_t depth)
+ {
+   const size_t new_size = size(width, height, depth);
+ 
+   if (new_size != data_size) {
+     device_free();
+     host_free();
+     host_pointer = host_alloc(data_elements * datatype_size(data_type) * new_size);
+     assert(device_pointer == 0);
+   }
+ 
+   data_size = new_size;
+   data_width = width;
+   data_height = height;
+   data_depth = depth;
+ 
+   info.width = width;
+   info.height = height;
+   info.depth = depth;
+ 
+   return host_pointer;
+ }
+ 
+ void device_texture::copy_to_device()
+ {
+   device_copy_to();
+ }
+ 
  CCL_NAMESPACE_END
diff --cc intern/cycles/render/image.cpp
index 825c9f536eb,78c854c9261..5a02647ef55
--- a/intern/cycles/render/image.cpp
+++ b/intern/cycles/render/image.cpp
@@@ -633,15 -619,15 +621,17 @@@ void ImageManager::device_load_image(De
      img->mem = NULL;
    }
  
+   img->mem = new device_texture(
+       device, img->mem_name.c_str(), slot, type, img->params.interpolation, img->params.extension);
++  img->mem->info.use_transform_3d = img->metadata.use_transform_3d;
++  img->mem->info.transform_3d = img->metadata.transform_3d;
+ 
    /* Create new texture. */
    if (type == IMAGE_DATA_TYPE_FLOAT4) {
-     device_vector<float4> *tex_img = new device_vector<float4>(
-         device, img->mem_name.c_str(), MEM_TEXTURE);
- 
-     if (!file_load_image<TypeDesc::FLOAT, float>(img, texture_limit, *tex_img)) {
+     if (!file_load_image<TypeDesc::FLOAT, float>(img, texture_limit)) {
        /* on failure to load, we set a 1x1 pixels pink image */
        thread_scoped_lock device_lock(device_mutex);
-       float *pixels = (float *)tex_img->alloc(1, 1);
+       float *pixels = (float *)img->mem->alloc(1, 1);
  
        pixels[0] = TEX_IMAGE_MISSING_R;
        pixels[1] = TEX_IMAGE_MISSING_G;
diff --cc intern/cycles/render/image_vdb.cpp
index 37959150757,00000000000..f61a73d9d1d
mode 100644,000000..100644
--- a/intern/cycles/render/image_vdb.cpp
+++ b/intern/cycles/render/image_vdb.cpp
@@@ -1,179 -1,0 +1,179 @@@
 +/*
 + * Copyright 2011-2020 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.
 + */
 +
 +#include "render/image_vdb.h"
 +
 +#ifdef WITH_OPENVDB
 +#  include <openvdb/openvdb.h>
 +#  include <openvdb/tools/Dense.h>
 +#endif
 +
 +CCL_NAMESPACE_BEGIN
 +
 +VDBImageLoader::VDBImageLoader(const string &grid_name) : grid_name(grid_name)
 +{
 +}
 +
 +VDBImageLoader::~VDBImageLoader()
 +{
 +}
 +
 +bool VDBImageLoader::load_metadata(ImageMetaData &metadata)
 +{
 +#ifdef WITH_OPENVDB
 +  if (!grid) {
 +    return false;
 +  }
 +
 +  bbox = grid->evalActiveVoxelBoundingBox();
 +  if (bbox.empty()) {
 +    return false;
 +  }
 +
 +  /* Set dimensions. */
 +  openvdb::Coord dim = bbox.dim();
 +  openvdb::Coord min = bbox.min();
 +  metadata.width = dim.x();
 +  metadata.height = dim.y();
 +  metadata.depth = dim.z();
 +
 +  /* Set data type. */
 +  if (grid->isType<openvdb::FloatGrid>()) {
 +    metadata.channels = 1;
 +  }
 +  else if (grid->isType<openvdb::Vec3fGrid>()) {
 +    metadata.channels = 3;
 +  }
 +  else if (grid->isType<openvdb::BoolGrid>()) {
 +    metadata.channels = 1;
 +  }
 +  else if (grid->isType<openvdb::DoubleGrid>()) {
 +    metadata.channels = 1;
 +  }
 +  else if (grid->isType<openvdb::Int32Grid>()) {
 +    metadata.channels = 1;
 +  }
 +  else if (grid->isType<openvdb::Int64Grid>()) {
 +    metadata.channels = 1;
 +  }
 +  else if (grid->isType<openvdb::Vec3IGrid>()) {
 +    metadata.channels = 3;
 +  }
 +  else if (grid->isType<openvdb::Vec3dGrid>()) {
 +    metadata.channels = 3;
 +  }
 +  else if (grid->isType<openvdb::MaskGrid>()) {
 +    metadata.channels = 1;
 +  }
 +  else {
 +    return false;
 +  }
 +
 +  if (metadata.channels == 1) {
 +    metadata.type = IMAGE_DATA_TYPE_FLOAT;
 +  }
 +  else {
 +    metadata.type = IMAGE_DATA_TYPE_FLOAT4;
 +  }
 +
 +  /* Set transform from object space to voxel index. */
 +  openvdb::math::Mat4f grid_matrix = grid->transform().baseMap()->getAffineMap()->getMat4();
 +  Transform index_to_object;
 +  for (int col = 0; col < 4; col++) {
 +    for (int row = 0; row < 3; row++) {
-       index_to_object[row][col] = grid_matrix[row][col];
++      index_to_object[row][col] = grid_matrix[col][row];
 +    }
 +  }
 +
 +  Transform texture_to_index = transform_translate(min.x(), min.y(), min.z()) *
 +                               transform_scale(dim.x(), dim.y(), dim.z());
 +
 +  metadata.transform_3d = transform_inverse(index_to_object * texture_to_index);
 +  metadata.use_transform_3d = true;
 +
 +  return true;
 +#else
 +  (void)metadata;
 +  return false;
 +#endif
 +}
 +
 +bool VDBImageLoader::load_pixels(const ImageMetaData &metadata,
 +                                 void *pixels,
 +                                 const size_t,
 +                                 const bool associate_alpha)
 +{
 +  if (grid->isType<openvdb::FloatGrid>()) {
 +    openvdb::tools::Dense<float, openvdb::tools::LayoutXYZ> dense(bbox, (float *)pixels);
 +    openvdb::tools::copyToDense(*openvdb::gridConstPtrCast<openvdb::FloatGrid>(grid), dense);
 +  }
 +  else if (grid->isType<openvdb::Vec3fGrid>()) {
 +    openvdb::tools::Dense<openvdb::Vec3f, openvdb::tools::LayoutXYZ> dense(
 +        bbox, (openvdb::Vec3f *)pixels);
 +    openvdb::tools::copyToDense(*openvdb::gridConstPtrCast<openvdb::Vec3fGrid>(grid), dense);
 +  }
 +  else if (grid->isType<openvdb::BoolGrid>()) {
 +    openvdb::tools::Dense<float, openvdb::tools::LayoutXYZ> dense(bbox, (float *)pixels);
 +    openvdb::tools::copyToDense(*openvdb::gridConstPtrCast<openvdb::BoolGrid>(grid), dense);
 +  }
 +  else if (grid->isType<openvdb::DoubleGrid>()) {
 +    openvdb::tools::Dense<float, openvdb::tools::LayoutXYZ> dense(bbox, (float *)pixels);
 +    openvdb::tools::copyToDense(*openvdb::gridConstPtrCast<openvdb::DoubleGrid>(grid), dense);
 +  }
 +  else if (grid->isType<openvdb::Int32Grid>()) {
 +    openvdb::tools::Dense<float, openvdb::tools::LayoutXYZ> dense(bbox, (float *)pixels);
 +    openvdb::tools::copyToDense(*openvdb::gridConstPtrCast<openvdb::Int32Grid>(grid), dense);
 +  }
 +  else if (grid->isType<openvdb::Int64Grid>()) {
 +    openvdb::tools::Dense<float, openvdb::tools::LayoutXYZ> dense(bbox, (float *)pixels);
 +    openvdb::tools::copyToDense(*openvdb::gridConstPtrCast<openvdb::Int64Grid>(grid), dense);
 +  }
 +  else if (grid->isType<openvdb::Vec3IGrid>()) {
 +    openvdb::tools::Dense<openvdb::Vec3f, openvdb::tools::LayoutXYZ> dense(
 +        bbox, (openvdb::Vec3f *)pixels);
 +    openvdb::tools::copyToDense(*openvdb::gridConstPtrCast<openvdb::Vec3IGrid>(grid), dense);
 +  }
 +  else if (grid->isType<openvdb::Vec3dGrid>()) {
 +    openvdb::tools::Dense<openvdb::Vec3f, openvdb::tools::LayoutXYZ> dense(
 +        bbox, (openvdb::Vec3f *)pixels);
 +    openvdb::tools::copyToDense(*openvdb::gridConstPtrCast<openvdb::Vec3dGrid>(grid), dense);
 +  }
 +  else if (grid->isType<openvdb::MaskGrid>()) {
 +    openvdb::tools::Dense<float, openvdb::tools::LayoutXYZ> dense(bbox, (float *)pixels);
 +    openvdb::tools::copyToDense(*openvdb::gridConstPtrCast<openvdb::MaskGrid>(grid), dense);
 +  }
 +
 +  return true;
 +}
 +
 +string VDBImageLoader::name() const
 +{
 +  return grid_name;
 +}
 +
 +bool VDBImageLoader::equals(const ImageLoader &other) const
 +{
 +  const VDBImageLoader &other_loader = (const VDBImageLoader &)other;
 +  return grid == other_loader.grid;
 +}
 +
 +void VDBImageLoader::cleanup()
 +{
 +  /* Free OpenVDB grid memory as soon as we can. */
 +  grid.reset();
 +}
 +
 +CCL_NAMESPACE_END
diff --cc intern/cycles/render/mesh_volume.cpp
index cd26122253e,3c91aba511d..6087fba7a98
--- a/intern/cycles/render/mesh_volume.cpp
+++ b/int

@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list