Merge branch 'master' into HEAD

Author: dedoardo

CMakeLists.txt

@@ -99,15 +99,15 @@ option(WITH_CUDA_DYNLOAD           "Dynamically load CUDA libraries at runtime"
 mark_as_advanced(WITH_CUDA_DYNLOAD)
 
 # ====== Tangent Rez Deps
-option(BUILD_WITH_REZ "Build with rez" ON)
-option(BUILD_WITH_HOUDINI "Build with houdini" OFF)
-
-if(${BUILD_WITH_REZ})
+if(DEFINED ENV{TA_USING_REZ})
+    message(STATUS "Building with REZ")
     include(src/cmake/rez_deps.cmake)
-elseif(${BUILD_WITH_HOUDINI})
-	include(src/cmake/hou_deps.cmake)
-elseif(${BUILD_WITH_USD})
-	include(src/cmake/pxr_deps.cmake)
+elseif(DEFINED HOUDINI_ROOT)
+    message(STATUS "Building with Houdini")
+    include(src/cmake/hou_deps.cmake)
+elseif(DEFINED USD_ROOT)
+    message(STATUS "Building with Pixar")
+    include(src/cmake/pxr_deps.cmake)
 else()
     set(USE_OPENGL TRUE)
     add_definitions(-DUSE_OPENGL)

package.py

@@ -2,7 +2,8 @@
 
 name = 'cycles'
 
-version = '1.13.0-ta.1.12.0'
+
+version = '1.13.0-ta.1.14.7'
 
 authors = [
     'benjamin.skinner',

src/CMakeLists.txt

@@ -405,13 +405,24 @@ endif()
 
 if(WITH_CYCLES_STANDALONE)
   add_library(Cycles INTERFACE)
+  add_library(Cycles::Cycles ALIAS Cycles)
 
   target_include_directories(Cycles
           INTERFACE
-          $<BUILD_INTERFACE:.>
+          $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+          $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../third_party/atomic>
           $<INSTALL_INTERFACE:include>
           )
 
+  target_link_libraries(Cycles
+          INTERFACE
+          $<BUILD_INTERFACE:${OPENEXR_HALF_LIBRARY}>
+          $<BUILD_INTERFACE:${OPENIMAGEIO_LIBRARY}>
+          $<BUILD_INTERFACE:${OPENCOLORIO_OPENCOLORIO_LIBRARY}>
+          $<BUILD_INTERFACE:${OPENSUBDIV_OSDGPU_LIBRARY}>
+          $<BUILD_INTERFACE:${OPENSUBDIV_OSDCPU_LIBRARY}>
+          )
+
   target_link_libraries(Cycles
           INTERFACE
           extern_sky
@@ -423,6 +434,7 @@ if(WITH_CYCLES_STANDALONE)
           cycles_device
           cycles_subd
           cycles_kernel
+          cycles_graph
           )
 
   # create target export and install actual targets

src/app/cycles_xml.cpp

@@ -202,6 +202,17 @@ static void xml_read_camera(XMLReadState &state, xml_node node)
 
   cam->need_update = true;
   cam->update(state.scene);
+
+  // dicing camera
+  Camera *dicing_cam = state.scene->dicing_camera;
+  dicing_cam->width = cam->width;
+  dicing_cam->height = cam->height;
+  dicing_cam->full_width = cam->full_width;
+  dicing_cam->full_height = cam->full_height;
+
+  dicing_cam->matrix = state.tfm;
+  dicing_cam->need_update = true;
+  dicing_cam->update(state.scene);
 }
 
 /* Shader */
@@ -391,6 +402,122 @@ static Mesh *xml_add_mesh(Scene *scene, const Transform &tfm)
   return mesh;
 }
 
+static void xml_read_mesh_attributes(const XMLReadState &state, Mesh *mesh, xml_node attribute_node)
+{
+  AttributeSet &attributes = mesh->subdivision_type == Mesh::SUBDIVISION_NONE ?
+                                 mesh->attributes :
+                                 mesh->subd_attributes;
+
+  xml_attribute name_attr = attribute_node.attribute("name");
+  if (!name_attr) {
+    return;
+  }
+
+  if (state.scene->integrator->motion_blur
+      && string_iequals(name_attr.value(), "motion_vertex_position")) {
+    vector<float3> data;
+
+    if (xml_read_float3_array(data, attribute_node, "data")) {
+      if (data.size() % mesh->verts.size() != 0) {
+        return;
+      }
+
+      mesh->motion_steps = 1 + data.size() / mesh->verts.size();
+      mesh->use_motion_blur = true;
+
+      Attribute *motion_vertex_position = attributes.add(ATTR_STD_MOTION_VERTEX_POSITION);
+      float3 *motion = motion_vertex_position->data_float3();
+
+      for (size_t i = 0; i < data.size(); ++i) {
+        motion[i] = data[i];
+      }
+    }
+  }
+
+  xml_attribute data_attr = attribute_node.attribute("data");
+  if (!data_attr) {
+    return;
+  }
+
+  // TODO: add support for standard attributes  such as P, UV etc
+
+  // custom attribute
+  xml_attribute type_attr = attribute_node.attribute("type");
+  xml_attribute elem_attr = attribute_node.attribute("element");
+  if (!type_attr || !elem_attr) {
+    return;
+  }
+
+  // type
+  TypeDesc type_desc = TypeUnknown;
+  int type_size = 0;
+  if (string_iequals(type_attr.value(), "float")) {
+    type_desc = TypeFloat;
+    type_size = 1;
+  }
+  else if (string_iequals(type_attr.value(), "float2")) {
+    type_desc = TypeFloat2;
+    type_size = 2;
+  }
+  else if (string_iequals(type_attr.value(), "color")) {
+    type_desc = TypeColor;
+    type_size = 3;
+  }
+
+  if (type_desc == TypeUnknown) {
+    fprintf(stderr, "Unknown attribute type \"%s\".\n", name_attr.value());
+    return;
+  }
+
+  // element
+  AttributeElement element = AttributeElement::ATTR_ELEMENT_NONE;
+  if (string_iequals(elem_attr.value(), "vertex")) {
+    element = AttributeElement::ATTR_ELEMENT_VERTEX;
+  }
+  if (string_iequals(elem_attr.value(), "face")) {
+    element = AttributeElement::ATTR_ELEMENT_FACE;
+  }
+  if (string_iequals(elem_attr.value(), "corner")) {
+    element = AttributeElement::ATTR_ELEMENT_CORNER;
+  }
+
+  // unknown element
+  if (element == AttributeElement::ATTR_ELEMENT_NONE) {
+    fprintf(stderr, "Unknown attribute element \"%s\".\n", name_attr.value());
+    return;
+  }
+
+  // create
+  vector<float> data;
+  if (xml_read_float_array(data, attribute_node, "data")) {
+    auto size = mesh->element_size(element, attributes.prim);
+    if (data.size() != size * type_size) {
+      fprintf(stderr, "Invalid attribute size \"%s\".\n", name_attr.value());
+      return;
+    }
+
+    Attribute *attrib = attributes.add(ustring{name_attr.value()}, type_desc, element);
+    if (type_desc == TypeFloat) {
+      auto adata = attrib->data_float();
+      for (size_t i = 0; i < size; ++i) {
+        adata[i] = data[i];
+      }
+    }
+    else if (type_desc == TypeFloat2) {
+      auto adata = attrib->data_float2();
+      for (size_t i = 0, o = 0; i < size; ++i, o += type_size) {
+        adata[i] = make_float2(data[o], data[o + 1]);
+      }
+    }
+    else if (type_desc == TypeColor) {
+      auto adata = attrib->data_float3();
+      for (size_t i = 0, o = 0; i < size; ++i, o += type_size) {
+        adata[i] = make_float3(data[o], data[o + 1], data[o + 2]);
+      }
+    }
+  }
+}
+
 static void xml_read_mesh(const XMLReadState &state, xml_node node)
 {
   /* add mesh */
@@ -460,7 +587,6 @@ static void xml_read_mesh(const XMLReadState &state, xml_node node)
 
           assert(v0 * 2 + 1 < (int)UV.size());
           assert(v1 * 2 + 1 < (int)UV.size());
-          assert(v2 * 2 + 1 < (int)UV.size());
 
           fdata[0] = make_float2(UV[v0 * 2], UV[v0 * 2 + 1]);
           fdata[1] = make_float2(UV[v1 * 2], UV[v1 * 2 + 1]);
@@ -496,7 +622,7 @@ static void xml_read_mesh(const XMLReadState &state, xml_node node)
     if (xml_read_float_array(UV, node, "UV")) {
       ustring name = ustring("UVMap");
       Attribute *attr = mesh->subd_attributes.add(ATTR_STD_UV, name);
-      float3 *fdata = attr->data_float3();
+      float2 *fdata = attr->data_float2();
 
 #if 0
       if (subdivide_uvs) {
@@ -507,7 +633,9 @@ static void xml_read_mesh(const XMLReadState &state, xml_node node)
       index_offset = 0;
       for (size_t i = 0; i < nverts.size(); i++) {
         for (int j = 0; j < nverts[i]; j++) {
-          *(fdata++) = make_float3(UV[index_offset++]);
+          auto u = UV[index_offset++];
+          auto v = UV[index_offset++];
+          *(fdata++) = make_float2(u, v);
         }
       }
     }
@@ -525,6 +653,13 @@ static void xml_read_mesh(const XMLReadState &state, xml_node node)
     sdparams.objecttoworld = state.tfm;
   }
 
+  for (xml_node child_node = node.first_child(); child_node;
+       child_node = child_node.next_sibling()) {
+    if (string_iequals(child_node.name(), "attribute")) {
+      xml_read_mesh_attributes(state, mesh, child_node);
+    }
+  }
+
   /* we don't yet support arbitrary attributes, for now add vertex
    * coordinates as generated coordinates if requested */
   if (mesh->need_attribute(state.scene, ATTR_STD_GENERATED)) {

src/blender/addon/engine.py

@@ -291,6 +291,14 @@ def list_render_passes(scene, srl):
                 if any(getattr(crl, option) for option in clean_options):
                     yield ("Denoising Clean", "RGB", 'COLOR')
 
+    # Light groups.
+    lightgroup_names = []
+    for lightgroup in crl.lightgroups:
+        name = lightgroup.name
+        if (lightgroup.collection or lightgroup.include_world) and not name in lightgroup_names:
+            yield (name + ".Combined", "RGB", 'COLOR')
+            lightgroup_names.append(name)
+
     # Custom AOV passes.
     for aov in crl.aovs:
         if aov.type == 'VALUE':

src/blender/addon/operators.py

@@ -74,6 +74,87 @@ def execute(self, context):
         return {'FINISHED'}
 
 
+class CYCLES_OT_lightgroup_add(bpy.types.Operator):
+    """Add a lightgroup"""
+    bl_idname="cycles.lightgroup_add"
+    bl_label="Add Lightgroup"
+
+    def execute(self, context):
+        view_layer = context.view_layer
+        cycles_view_layer = view_layer.cycles
+        lgs = cycles_view_layer.lightgroups
+
+        new_lg = lgs.add()
+
+        number = 0
+        name = "Lightgroup"
+        while name in lgs.keys():
+            number = number + 1
+            name = "Lightgroup.{:03d}".format(number)
+        new_lg.name = name
+
+        cycles_view_layer.active_lightgroup = len(lgs) - 1
+
+        view_layer.update_render_passes()
+        return {'FINISHED'}
+
+
+class CYCLES_OT_lightgroup_remove(bpy.types.Operator):
+    """Remove a lightgroup"""
+    bl_idname="cycles.lightgroup_remove"
+    bl_label="Remove Lightgroup"
+
+    def execute(self, context):
+        view_layer = context.view_layer
+        cycles_view_layer = view_layer.cycles
+        lgs = cycles_view_layer.lightgroups
+
+        cycles_view_layer.lightgroups.remove(cycles_view_layer.active_lightgroup)
+
+        if cycles_view_layer.active_lightgroup >= len(lgs):
+            cycles_view_layer.active_lightgroup = max(len(lgs) - 1, 0)
+
+        view_layer.update_render_passes()
+        return {'FINISHED'}
+
+
+class CYCLES_OT_lightgroup_move(bpy.types.Operator):
+    bl_idname = "cycles.lightgroup_move"
+    bl_label = "Move Lightgroup"
+
+    direction: bpy.props.EnumProperty(
+        name="Move Direction",
+        description="Direction to move the active Lightgroup: UP (default) or DOWN",
+        items=[
+            ('UP', "Up", "", -1),
+            ('DOWN', "Down", "", 1),
+        ],
+        default='UP',
+        options={'HIDDEN'},
+    )
+
+    @classmethod
+    def poll(cls, context):
+        view_layer = context.view_layer
+        cycles_view_layer = view_layer.cycles
+        return len(cycles_view_layer.lightgroups) > 1
+
+    def execute(self, context):
+        view_layer = context.view_layer
+        cycles_view_layer = view_layer.cycles
+
+        active_idx = cycles_view_layer.active_lightgroup
+        new_idx = active_idx + (-1 if self.direction == 'UP' else 1)
+
+        if new_idx < 0 or new_idx >= len(cycles_view_layer.lightgroups):
+            return {'FINISHED'}
+
+        cycles_view_layer.lightgroups.move(active_idx, new_idx)
+        cycles_view_layer.active_lightgroup = new_idx
+
+        return {'FINISHED'}
+
+
 class CYCLES_OT_denoise_animation(Operator):
     "Denoise rendered animation sequence using current scene and view " \
     "layer settings. Requires denoising data passes and output to " \
@@ -200,6 +281,9 @@ def execute(self, context):
     CYCLES_OT_add_aov,
     CYCLES_OT_remove_aov,
     CYCLES_OT_denoise_animation,
+    CYCLES_OT_lightgroup_add,
+    CYCLES_OT_lightgroup_remove,
+    CYCLES_OT_lightgroup_move,
     CYCLES_OT_merge_images
 )