Cycles/Eevee: unify depth of field settings for cameras
authorJeroen Bakker <j.bakker@atmind.nl>
Fri, 17 May 2019 14:57:31 +0000 (16:57 +0200)
committerBrecht Van Lommel <brechtvanlommel@gmail.com>
Fri, 17 May 2019 15:59:26 +0000 (17:59 +0200)
There is now a checkbox to enable/disable depth of field per camera. For Eevee
this replace the scene level setting. For Cycles there is now only an F-Stop
value, no longer a Radius.

Existing files are converted based on Cycles or Eevee being set in the scene.

Differential Revision: https://developer.blender.org/D4882

28 files changed:
intern/cycles/blender/addon/properties.py
intern/cycles/blender/addon/ui.py
intern/cycles/blender/blender_camera.cpp
release/scripts/startup/bl_ui/properties_data_camera.py
release/scripts/startup/bl_ui/properties_render.py
source/blender/alembic/intern/abc_camera.cc
source/blender/blenkernel/BKE_blender_version.h
source/blender/blenkernel/BKE_camera.h
source/blender/blenkernel/intern/camera.c
source/blender/blenkernel/intern/library_query.c
source/blender/blenloader/intern/readfile.c
source/blender/blenloader/intern/versioning_280.c
source/blender/blenloader/intern/versioning_cycles.c
source/blender/depsgraph/intern/builder/deg_builder_relations.cc
source/blender/draw/engines/eevee/eevee_depth_of_field.c
source/blender/draw/engines/gpencil/gpencil_shader_fx.c
source/blender/draw/engines/workbench/workbench_effect_dof.c
source/blender/editors/include/ED_view3d.h
source/blender/editors/space_view3d/view3d_draw.c
source/blender/editors/space_view3d/view3d_gizmo_camera.c
source/blender/makesdna/DNA_camera_types.h
source/blender/makesdna/DNA_scene_types.h
source/blender/makesdna/intern/makesdna.c
source/blender/makesrna/RNA_access.h
source/blender/makesrna/intern/rna_camera.c
source/blender/makesrna/intern/rna_scene.c
source/blender/python/gpu/gpu_py_offscreen.c
tests/python/eevee_render_tests.py

index 35f9e17..d9e145c 100644 (file)
@@ -68,11 +68,6 @@ enum_filter_types = (
     ('BLACKMAN_HARRIS', "Blackman-Harris", "Blackman-Harris filter"),
 )
 
-enum_aperture_types = (
-    ('RADIUS', "Radius", "Directly change the size of the aperture"),
-    ('FSTOP', "F-stop", "Change the size of the aperture by f-stop"),
-)
-
 enum_panorama_types = (
     ('EQUIRECTANGULAR', "Equirectangular", "Render the scene with a spherical camera, also known as Lat Long panorama"),
     ('FISHEYE_EQUIDISTANT', "Fisheye Equidistant", "Ideal for fulldomes, ignore the sensor dimensions"),
@@ -742,49 +737,6 @@ class CyclesRenderSettings(bpy.types.PropertyGroup):
 
 class CyclesCameraSettings(bpy.types.PropertyGroup):
 
-    aperture_type: EnumProperty(
-        name="Aperture Type",
-        description="Use f-stop number or aperture radius",
-        items=enum_aperture_types,
-        default='RADIUS',
-    )
-    aperture_fstop: FloatProperty(
-        name="Aperture f-stop",
-        description="F-stop ratio (lower numbers give more defocus, higher numbers give a sharper image)",
-        min=0.0, soft_min=0.1, soft_max=64.0,
-        default=5.6,
-        step=10,
-        precision=1,
-    )
-    aperture_size: FloatProperty(
-        name="Aperture Size",
-        description="Radius of the aperture for depth of field (higher values give more defocus)",
-        min=0.0, soft_max=10.0,
-        default=0.0,
-        step=1,
-        precision=4,
-        subtype='DISTANCE',
-    )
-    aperture_blades: IntProperty(
-        name="Aperture Blades",
-        description="Number of blades in aperture for polygonal bokeh (at least 3)",
-        min=0, max=100,
-        default=0,
-    )
-    aperture_rotation: FloatProperty(
-        name="Aperture Rotation",
-        description="Rotation of blades in aperture",
-        soft_min=-pi, soft_max=pi,
-        subtype='ANGLE',
-        default=0,
-    )
-    aperture_ratio: FloatProperty(
-        name="Aperture Ratio",
-        description="Distortion to simulate anamorphic lens bokeh",
-        min=0.01, soft_min=1.0, soft_max=2.0,
-        default=1.0,
-        precision=4,
-    )
     panorama_type: EnumProperty(
         name="Panorama Type",
         description="Distortion to use for the calculation",
index 86f5876..80b4159 100644 (file)
@@ -1016,20 +1016,27 @@ class CYCLES_CAMERA_PT_dof(CyclesButtonsPanel, Panel):
     def poll(cls, context):
         return context.camera and CyclesButtonsPanel.poll(context)
 
+    def draw_header(self, context):
+        cam = context.camera
+        dof = cam.dof
+        self.layout.prop(dof, "use_dof", text="")
+
     def draw(self, context):
         layout = self.layout
         layout.use_property_split = True
 
         cam = context.camera
+        dof = cam.dof
+        layout.active = dof.use_dof
 
         split = layout.split()
 
         col = split.column()
-        col.prop(cam, "dof_object", text="Focus Object")
+        col.prop(dof, "focus_object", text="Focus Object")
 
         sub = col.row()
-        sub.active = cam.dof_object is None
-        sub.prop(cam, "dof_distance", text="Distance")
+        sub.active = dof.focus_object is None
+        sub.prop(dof, "focus_distance", text="Distance")
 
 
 class CYCLES_CAMERA_PT_dof_aperture(CyclesButtonsPanel, Panel):
@@ -1043,44 +1050,17 @@ class CYCLES_CAMERA_PT_dof_aperture(CyclesButtonsPanel, Panel):
     def draw(self, context):
         layout = self.layout
         layout.use_property_split = True
-        flow = layout.grid_flow(row_major=True, columns=0, even_columns=True, even_rows=False, align=False)
 
         cam = context.camera
-        ccam = cam.cycles
-
-        col = flow.column()
-        col.prop(ccam, "aperture_type")
-        if ccam.aperture_type == 'RADIUS':
-            col.prop(ccam, "aperture_size", text="Size")
-        elif ccam.aperture_type == 'FSTOP':
-            col.prop(ccam, "aperture_fstop", text="Number")
-        col.separator()
-
-        col = flow.column()
-        col.prop(ccam, "aperture_blades", text="Blades")
-        col.prop(ccam, "aperture_rotation", text="Rotation")
-        col.prop(ccam, "aperture_ratio", text="Ratio")
-
-
-class CYCLES_CAMERA_PT_dof_viewport(CyclesButtonsPanel, Panel):
-    bl_label = "Viewport"
-    bl_parent_id = "CYCLES_CAMERA_PT_dof"
-
-    @classmethod
-    def poll(cls, context):
-        return context.camera and CyclesButtonsPanel.poll(context)
-
-    def draw(self, context):
-        layout = self.layout
-        layout.use_property_split = True
+        dof = cam.dof
+        layout.active = dof.use_dof
         flow = layout.grid_flow(row_major=True, columns=0, even_columns=True, even_rows=False, align=False)
 
-        cam = context.camera
-        dof_options = cam.gpu_dof
-
-        sub = flow.column(align=True)
-        sub.prop(dof_options, "fstop")
-        sub.prop(dof_options, "blades")
+        col = flow.column()
+        col.prop(dof, "aperture_fstop")
+        col.prop(dof, "aperture_blades")
+        col.prop(dof, "aperture_rotation")
+        col.prop(dof, "aperture_ratio")
 
 
 class CYCLES_PT_context_material(CyclesButtonsPanel, Panel):
@@ -2147,7 +2127,6 @@ classes = (
     CYCLES_PT_post_processing,
     CYCLES_CAMERA_PT_dof,
     CYCLES_CAMERA_PT_dof_aperture,
-    CYCLES_CAMERA_PT_dof_viewport,
     CYCLES_PT_context_material,
     CYCLES_OBJECT_PT_motion_blur,
     CYCLES_OBJECT_PT_cycles_settings,
index b3bfaa9..92dc8a8 100644 (file)
@@ -119,10 +119,10 @@ static float blender_camera_focal_distance(BL::RenderEngine &b_engine,
                                            BL::Camera &b_camera,
                                            BlenderCamera *bcam)
 {
-  BL::Object b_dof_object = b_camera.dof_object();
+  BL::Object b_dof_object = b_camera.dof().focus_object();
 
   if (!b_dof_object)
-    return b_camera.dof_distance();
+    return b_camera.dof().focus_distance();
 
   /* for dof object, return distance along camera Z direction */
   BL::Array<float, 16> b_ob_matrix;
@@ -191,26 +191,30 @@ static void blender_camera_from_object(BlenderCamera *bcam,
 
     bcam->lens = b_camera.lens();
 
-    /* allow f/stop number to change aperture_size but still
-     * give manual control over aperture radius */
-    int aperture_type = get_enum(ccamera, "aperture_type");
-
-    if (aperture_type == 1) {
-      float fstop = RNA_float_get(&ccamera, "aperture_fstop");
+    if (b_camera.dof().use_dof()) {
+      /* allow f/stop number to change aperture_size but still
+       * give manual control over aperture radius */
+      float fstop = b_camera.dof().aperture_fstop();
       fstop = max(fstop, 1e-5f);
 
       if (bcam->type == CAMERA_ORTHOGRAPHIC)
         bcam->aperturesize = 1.0f / (2.0f * fstop);
       else
         bcam->aperturesize = (bcam->lens * 1e-3f) / (2.0f * fstop);
-    }
-    else
-      bcam->aperturesize = RNA_float_get(&ccamera, "aperture_size");
 
-    bcam->apertureblades = RNA_int_get(&ccamera, "aperture_blades");
-    bcam->aperturerotation = RNA_float_get(&ccamera, "aperture_rotation");
-    bcam->focaldistance = blender_camera_focal_distance(b_engine, b_ob, b_camera, bcam);
-    bcam->aperture_ratio = RNA_float_get(&ccamera, "aperture_ratio");
+      bcam->apertureblades = b_camera.dof().aperture_blades();
+      bcam->aperturerotation = b_camera.dof().aperture_rotation();
+      bcam->focaldistance = blender_camera_focal_distance(b_engine, b_ob, b_camera, bcam);
+      bcam->aperture_ratio = b_camera.dof().aperture_ratio();
+    }
+    else {
+      /* DOF is turned of for the camera. */
+      bcam->aperturesize = 0.0f;
+      bcam->apertureblades = 0;
+      bcam->aperturerotation = 0.0f;
+      bcam->focaldistance = 0.0f;
+      bcam->aperture_ratio = 1.0f;
+    }
 
     bcam->shift.x = b_engine.camera_shift_x(b_ob, bcam->use_spherical_stereo);
     bcam->shift.y = b_camera.shift_y();
index 6ba3ad4..3181dab 100644 (file)
@@ -212,19 +212,27 @@ class DATA_PT_camera(CameraButtonsPanel, Panel):
 class DATA_PT_camera_dof(CameraButtonsPanel, Panel):
     bl_label = "Depth of Field"
     bl_options = {'DEFAULT_CLOSED'}
-    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_WORKBENCH'}
+    COMPAT_ENGINES = {'BLENDER_EEVEE', 'BLENDER_WORKBENCH'}
+
+    def draw_header(self, context):
+        cam = context.camera
+        dof = cam.dof
+        self.layout.prop(dof, "use_dof", text="")
+
 
     def draw(self, context):
         layout = self.layout
         layout.use_property_split = True
 
         cam = context.camera
+        dof = cam.dof
+        layout.active = dof.use_dof
 
         col = layout.column()
-        col.prop(cam, "dof_object", text="Focus on Object")
+        col.prop(dof, "focus_object", text="Focus on Object")
         sub = col.column()
-        sub.active = (cam.dof_object is None)
-        sub.prop(cam, "dof_distance", text="Focus Distance")
+        sub.active = (dof.focus_object is None)
+        sub.prop(dof, "focus_distance", text="Focus Distance")
 
 
 class DATA_PT_camera_dof_aperture(CameraButtonsPanel, Panel):
@@ -237,17 +245,18 @@ class DATA_PT_camera_dof_aperture(CameraButtonsPanel, Panel):
         layout.use_property_split = True
 
         cam = context.camera
-        dof_options = cam.gpu_dof
+        dof = cam.dof
+        layout.active = dof.use_dof
 
         flow = layout.grid_flow(row_major=True, columns=0, even_columns=True, even_rows=False, align=False)
 
         col = flow.column()
-        col.prop(dof_options, "fstop")
-        col.prop(dof_options, "blades")
+        col.prop(dof, "aperture_fstop")
 
         col = flow.column()
-        col.prop(dof_options, "rotation")
-        col.prop(dof_options, "ratio")
+        col.prop(dof, "aperture_blades")
+        col.prop(dof, "aperture_rotation")
+        col.prop(dof, "aperture_ratio")
 
 
 class DATA_PT_camera_background_image(CameraButtonsPanel, Panel):
index b99e2b9..45a492c 100644 (file)
@@ -183,18 +183,12 @@ class RENDER_PT_eevee_depth_of_field(RenderButtonsPanel, Panel):
     def poll(cls, context):
         return (context.engine in cls.COMPAT_ENGINES)
 
-    def draw_header(self, context):
-        scene = context.scene
-        props = scene.eevee
-        self.layout.prop(props, "use_dof", text="")
-
     def draw(self, context):
         layout = self.layout
         layout.use_property_split = True
         scene = context.scene
         props = scene.eevee
 
-        layout.active = props.use_dof
         col = layout.column()
         col.prop(props, "bokeh_max_size")
         # Not supported yet
index b156087..dc7f00b 100644 (file)
@@ -80,19 +80,19 @@ void AbcCameraWriter::do_write()
   m_camera_sample.setNearClippingPlane(cam->clip_start);
   m_camera_sample.setFarClippingPlane(cam->clip_end);
 
-  if (cam->dof_ob) {
-    Imath::V3f v(m_object->loc[0] - cam->dof_ob->loc[0],
-                 m_object->loc[1] - cam->dof_ob->loc[1],
-                 m_object->loc[2] - cam->dof_ob->loc[2]);
+  if (cam->dof.focus_object) {
+    Imath::V3f v(m_object->loc[0] - cam->dof.focus_object->loc[0],
+                 m_object->loc[1] - cam->dof.focus_object->loc[1],
+                 m_object->loc[2] - cam->dof.focus_object->loc[2]);
     m_camera_sample.setFocusDistance(v.length());
   }
   else {
-    m_camera_sample.setFocusDistance(cam->gpu_dof.focus_distance);
+    m_camera_sample.setFocusDistance(cam->dof.focus_distance);
   }
 
   /* Blender camera does not have an fstop param, so try to find a custom prop
    * instead. */
-  m_camera_sample.setFStop(cam->gpu_dof.fstop);
+  m_camera_sample.setFStop(cam->dof.aperture_fstop);
 
   m_camera_sample.setLensSqueezeRatio(1.0);
   m_camera_schema.set(m_camera_sample);
@@ -166,8 +166,8 @@ void AbcCameraReader::readObjectData(Main *bmain, const ISampleSelector &sample_
   bcam->shifty = v_film_offset / apperture_y / film_aspect;
   bcam->clip_start = max_ff(0.1f, static_cast<float>(cam_sample.getNearClippingPlane()));
   bcam->clip_end = static_cast<float>(cam_sample.getFarClippingPlane());
-  bcam->gpu_dof.focus_distance = static_cast<float>(cam_sample.getFocusDistance());
-  bcam->gpu_dof.fstop = static_cast<float>(cam_sample.getFStop());
+  bcam->dof.focus_distance = static_cast<float>(cam_sample.getFocusDistance());
+  bcam->dof.aperture_fstop = static_cast<float>(cam_sample.getFStop());
 
   m_object = BKE_object_add_only_object(bmain, OB_CAMERA, m_object_name.c_str());
   m_object->data = bcam;
index 0afcd37..5d659d6 100644 (file)
@@ -27,7 +27,7 @@
  * \note Use #STRINGIFY() rather than defining with quotes.
  */
 #define BLENDER_VERSION 280
-#define BLENDER_SUBVERSION 68
+#define BLENDER_SUBVERSION 69
 /** Several breakages with 280, e.g. collections vs layers. */
 #define BLENDER_MINVERSION 280
 #define BLENDER_MINSUBVERSION 0
index 10cd129..caed495 100644 (file)
@@ -139,8 +139,6 @@ bool BKE_camera_view_frame_fit_to_coords(const struct Depsgraph *depsgraph,
                                          float r_co[3],
                                          float *r_scale);
 
-void BKE_camera_to_gpu_dof(struct Object *camera, struct GPUFXSettings *r_fx_settings);
-
 /* Camera multi-view API */
 
 struct Object *BKE_camera_multiview_render(struct Scene *scene,
index 25399d3..a17cbb2 100644 (file)
@@ -66,8 +66,9 @@ void BKE_camera_init(Camera *cam)
   cam->flag |= CAM_SHOWPASSEPARTOUT;
   cam->passepartalpha = 0.5f;
 
-  cam->gpu_dof.fstop = 128.0f;
-  cam->gpu_dof.ratio = 1.0f;
+  cam->dof.aperture_fstop = 5.6f;
+  cam->dof.aperture_ratio = 1.0f;
+  cam->dof.focus_distance = 10.0f;
 
   /* stereoscopy 3d */
   cam->stereo.interocular_distance = 0.065f;
@@ -134,13 +135,13 @@ float BKE_camera_object_dof_distance(Object *ob)
   if (ob->type != OB_CAMERA) {
     return 0.0f;
   }
-  if (cam->dof_ob) {
+  if (cam->dof.focus_object) {
     float view_dir[3], dof_dir[3];
     normalize_v3_v3(view_dir, ob->obmat[2]);
-    sub_v3_v3v3(dof_dir, ob->obmat[3], cam->dof_ob->obmat[3]);
+    sub_v3_v3v3(dof_dir, ob->obmat[3], cam->dof.focus_object->obmat[3]);
     return fabsf(dot_v3v3(view_dir, dof_dir));
   }
-  return cam->dof_distance;
+  return cam->dof.focus_distance;
 }
 
 float BKE_camera_sensor_size(int sensor_fit, float sensor_x, float sensor_y)
@@ -1016,18 +1017,6 @@ void BKE_camera_multiview_params(RenderData *rd,
   }
 }
 
-void BKE_camera_to_gpu_dof(struct Object *camera, struct GPUFXSettings *r_fx_settings)
-{
-  if (camera->type == OB_CAMERA) {
-    Camera *cam = camera->data;
-    r_fx_settings->dof = &cam->gpu_dof;
-    r_fx_settings->dof->focal_length = cam->lens;
-    r_fx_settings->dof->sensor = BKE_camera_sensor_size(
-        cam->sensor_fit, cam->sensor_x, cam->sensor_y);
-    r_fx_settings->dof->focus_distance = BKE_camera_object_dof_distance(camera);
-  }
-}
-
 CameraBGImage *BKE_camera_background_image_new(Camera *cam)
 {
   CameraBGImage *bgpic = MEM_callocN(sizeof(CameraBGImage), "Background Image");
index d0515d8..a95069a 100644 (file)
@@ -755,7 +755,7 @@ static void library_foreach_ID_link(Main *bmain,
 
       case ID_CA: {
         Camera *camera = (Camera *)id;
-        CALLBACK_INVOKE(camera->dof_ob, IDWALK_CB_NOP);
+        CALLBACK_INVOKE(camera->dof.focus_object, IDWALK_CB_NOP);
         for (CameraBGImage *bgpic = camera->bg_images.first; bgpic; bgpic = bgpic->next) {
           if (bgpic->source == CAM_BGIMG_SOURCE_IMAGE) {
             CALLBACK_INVOKE(bgpic->ima, IDWALK_CB_USER);
index 15749cf..77deb86 100644 (file)
@@ -3882,9 +3882,10 @@ static void lib_link_camera(FileData *fd, Main *main)
       IDP_LibLinkProperty(ca->id.properties, fd);
       lib_link_animdata(fd, &ca->id, ca->adt);
 
-      ca->ipo = newlibadr_us(fd, ca->id.lib, ca->ipo);  // XXX deprecated - old animation system
+      ca->ipo = newlibadr_us(fd, ca->id.lib, ca->ipo); /* deprecated, for versioning */
 
-      ca->dof_ob = newlibadr(fd, ca->id.lib, ca->dof_ob);
+      ca->dof_ob = newlibadr(fd, ca->id.lib, ca->dof_ob); /* deprecated, for versioning */
+      ca->dof.focus_object = newlibadr(fd, ca->id.lib, ca->dof.focus_object);
 
       for (CameraBGImage *bgpic = ca->bg_images.first; bgpic; bgpic = bgpic->next) {
         bgpic->ima = newlibadr_us(fd, ca->id.lib, bgpic->ima);
index e55687d..23e8aba 100644 (file)
@@ -1670,7 +1670,7 @@ void blo_do_versions_280(FileData *fd, Library *UNUSED(lib), Main *bmain)
     } \
   } \
   ((void)0)
-
+        const int SCE_EEVEE_DOF_ENABLED = (1 << 7);
         IDProperty *props = IDP_GetPropertyFromGroup(scene->layer_properties,
                                                      RE_engine_id_BLENDER_EEVEE);
         // EEVEE_GET_BOOL(props, volumetric_enable, SCE_EEVEE_VOLUMETRIC_ENABLED);
@@ -3423,5 +3423,31 @@ void blo_do_versions_280(FileData *fd, Library *UNUSED(lib), Main *bmain)
         light->sun_angle = 2.0f * atanf(light->area_size);
       }
     }
+
+    /* Unify DOF settings (EEVEE part only) */
+    if (!DNA_struct_elem_find(fd->filesdna, "Camera", "CameraDOFSettings", "dof")) {
+      const int SCE_EEVEE_DOF_ENABLED = (1 << 7);
+      LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
+        if (STREQ(scene->r.engine, RE_engine_id_BLENDER_EEVEE)) {
+          if (scene->eevee.flag & SCE_EEVEE_DOF_ENABLED) {
+            Object *cam_ob = scene->camera;
+            if (cam_ob && cam_ob->type == OB_CAMERA) {
+              Camera *cam = cam_ob->data;
+              cam->dof.flag |= CAM_DOF_ENABLED;
+            }
+          }
+        }
+      }
+
+      LISTBASE_FOREACH (Camera *, camera, &bmain->cameras) {
+        camera->dof.focus_object = camera->dof_ob;
+        camera->dof.focus_distance = camera->dof_distance;
+        camera->dof.aperture_fstop = camera->gpu_dof.fstop;
+        camera->dof.aperture_rotation = camera->gpu_dof.rotation;
+        camera->dof.aperture_ratio = camera->gpu_dof.ratio;
+        camera->dof.aperture_blades = camera->gpu_dof.num_blades;
+        camera->dof_ob = NULL;
+      }
+    }
   }
 }
index 3fc6d98..81a2dd8 100644 (file)
@@ -32,6 +32,7 @@
 #include "DNA_light_types.h"
 #include "DNA_node_types.h"
 #include "DNA_particle_types.h"
+#include "DNA_camera_types.h"
 
 #include "BKE_colortools.h"
 #include "BKE_idprop.h"
@@ -67,12 +68,26 @@ static float cycles_property_float(IDProperty *idprop, const char *name, float d
   return (prop) ? IDP_Float(prop) : default_value;
 }
 
+static float cycles_property_int(IDProperty *idprop, const char *name, int default_value)
+{
+  IDProperty *prop = IDP_GetPropertyTypeFromGroup(idprop, name, IDP_INT);
+  return (prop) ? IDP_Int(prop) : default_value;
+}
+
 static bool cycles_property_boolean(IDProperty *idprop, const char *name, bool default_value)
 {
   IDProperty *prop = IDP_GetPropertyTypeFromGroup(idprop, name, IDP_INT);
   return (prop) ? IDP_Int(prop) : default_value;
 }
 
+static const char *cycles_property_string(IDProperty *idprop,
+                                          const char *name,
+                                          const char *default_value)
+{
+  IDProperty *prop = IDP_GetPropertyTypeFromGroup(idprop, name, IDP_STRING);
+  return (prop) ? IDP_String(prop) : default_value;
+}
+
 static void displacement_node_insert(bNodeTree *ntree)
 {
   bool need_update = false;
@@ -398,7 +413,7 @@ void blo_do_versions_cycles(FileData *UNUSED(fd), Library *UNUSED(lib), Main *bm
   }
 
   if (!MAIN_VERSION_ATLEAST(bmain, 280, 68)) {
-    /* Unify Cycles and EEVEE Film Transparency. */
+    /* Unify Cycles and Eevee film transparency. */
     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
       if (STREQ(scene->r.engine, RE_engine_id_CYCLES)) {
         IDProperty *cscene = cycles_properties_from_ID(&scene->id);
@@ -410,6 +425,47 @@ void blo_do_versions_cycles(FileData *UNUSED(fd), Library *UNUSED(lib), Main *bm
       }
     }
   }
+
+  if (!MAIN_VERSION_ATLEAST(bmain, 280, 69)) {
+    /* Unify Cycles and Eevee depth of field. */
+    Scene *scene = bmain->scenes.first;
+    const char *engine = (scene) ? scene->r.engine : "CYCLES";
+
+    if (STREQ(engine, RE_engine_id_CYCLES)) {
+      for (Camera *camera = bmain->cameras.first; camera; camera = camera->id.next) {
+        IDProperty *ccamera = cycles_properties_from_ID(&camera->id);
+        if (ccamera) {
+          const char *aperture_type = cycles_property_string(ccamera, "aperture_type", "RADIUS");
+
+          camera->dof.aperture_fstop = cycles_property_float(ccamera, "aperture_fstop", 5.6f);
+          camera->dof.aperture_blades = cycles_property_int(ccamera, "aperture_blades", 0);
+          camera->dof.aperture_rotation = cycles_property_float(ccamera, "aperture_rotation", 0.0);
+          camera->dof.aperture_ratio = cycles_property_float(ccamera, "aperture_ratio", 1.0f);
+          camera->dof.flag |= CAM_DOF_ENABLED;
+
+          float aperture_size = cycles_property_float(ccamera, "aperture_size", 0.0f);
+
+          if (STREQ(aperture_type, "RADIUS") && aperture_size > 0.0f) {
+            if (camera->type == CAM_ORTHO) {
+              camera->dof.aperture_fstop = 1.0f / (2.0f * aperture_size);
+            }
+            else {
+              camera->dof.aperture_fstop = (camera->lens * 1e-3f) / (2.0f * aperture_size);
+            }
+
+            continue;
+          }
+        }
+
+        /* No depth of field, set default settings. */
+        camera->dof.aperture_fstop = 5.6f;
+        camera->dof.aperture_blades = 0;
+        camera->dof.aperture_rotation = 0.0f;
+        camera->dof.aperture_ratio = 1.0f;
+        camera->dof.flag &= ~CAM_DOF_ENABLED;
+      }
+    }
+  }
 }
 
 void do_versions_after_linking_cycles(Main *bmain)
index 515adab..5686bca 100644 (file)
@@ -2069,9 +2069,9 @@ void DepsgraphRelationBuilder::build_camera(Camera *camera)
   }
   build_animdata(&camera->id);
   build_parameters(&camera->id);
-  if (camera->dof_ob != NULL) {
+  if (camera->dof.focus_object != NULL) {
     ComponentKey camera_parameters_key(&camera->id, NodeType::PARAMETERS);
-    ComponentKey dof_ob_key(&camera->dof_ob->id, NodeType::TRANSFORM);
+    ComponentKey dof_ob_key(&camera->dof.focus_object->id, NodeType::TRANSFORM);
     add_relation(dof_ob_key, camera_parameters_key, "Camera DOF");
   }
 }
index 3d058f7..25d256e 100644 (file)
@@ -79,7 +79,9 @@ int EEVEE_depth_of_field_init(EEVEE_ViewLayerData *UNUSED(sldata),
   const DRWContextState *draw_ctx = DRW_context_state_get();
   const Scene *scene_eval = DEG_get_evaluated_scene(draw_ctx->depsgraph);
 
-  if (scene_eval->eevee.flag & SCE_EEVEE_DOF_ENABLED) {
+  Camera *cam = (camera != NULL) ? camera->data : NULL;
+
+  if (cam && (cam->dof.flag & CAM_DOF_ENABLED)) {
     RegionView3D *rv3d = draw_ctx->rv3d;
     const bool use_alpha = !DRW_state_draw_background();
 
@@ -87,94 +89,89 @@ int EEVEE_depth_of_field_init(EEVEE_ViewLayerData *UNUSED(sldata),
       eevee_create_shader_depth_of_field(use_alpha);
     }
 
-    if (camera) {
-      const float *viewport_size = DRW_viewport_size_get();
-      Camera *cam = (Camera *)camera->data;
-
-      /* Retrieve Near and Far distance */
-      effects->dof_near_far[0] = -cam->clip_start;
-      effects->dof_near_far[1] = -cam->clip_end;
-
-      int buffer_size[2] = {(int)viewport_size[0] / 2, (int)viewport_size[1] / 2};
-
-      eGPUTextureFormat down_format = DRW_state_draw_background() ? GPU_R11F_G11F_B10F :
-                                                                    GPU_RGBA16F;
-
-      effects->dof_down_near = DRW_texture_pool_query_2d(
-          buffer_size[0], buffer_size[1], down_format, &draw_engine_eevee_type);
-      effects->dof_down_far = DRW_texture_pool_query_2d(
-          buffer_size[0], buffer_size[1], down_format, &draw_engine_eevee_type);
-      effects->dof_coc = DRW_texture_pool_query_2d(
-          buffer_size[0], buffer_size[1], GPU_RG16F, &draw_engine_eevee_type);
-
-      GPU_framebuffer_ensure_config(&fbl->dof_down_fb,
-                                    {GPU_ATTACHMENT_NONE,
-                                     GPU_ATTACHMENT_TEXTURE(effects->dof_down_near),
-                                     GPU_ATTACHMENT_TEXTURE(effects->dof_down_far),
-                                     GPU_ATTACHMENT_TEXTURE(effects->dof_coc)});
-
-      /* Go full 32bits for rendering and reduce the color artifacts. */
-      eGPUTextureFormat fb_format = DRW_state_is_image_render() ? GPU_RGBA32F : GPU_RGBA16F;
-
-      effects->dof_blur = DRW_texture_pool_query_2d(
-          buffer_size[0] * 2, buffer_size[1], fb_format, &draw_engine_eevee_type);
-
-      GPU_framebuffer_ensure_config(&fbl->dof_scatter_fb,
-                                    {
-                                        GPU_ATTACHMENT_NONE,
-                                        GPU_ATTACHMENT_TEXTURE(effects->dof_blur),
-                                    });
-
-      if (!DRW_state_draw_background()) {
-        effects->dof_blur_alpha = DRW_texture_pool_query_2d(
-            buffer_size[0] * 2, buffer_size[1], GPU_R32F, &draw_engine_eevee_type);
-        GPU_framebuffer_texture_attach(fbl->dof_scatter_fb, effects->dof_blur_alpha, 1, 0);
-      }
-
-      /* Parameters */
-      /* TODO UI Options */
-      float fstop = cam->gpu_dof.fstop;
-      float blades = cam->gpu_dof.num_blades;
-      float rotation = cam->gpu_dof.rotation;
-      float ratio = 1.0f / cam->gpu_dof.ratio;
-      float sensor = BKE_camera_sensor_size(cam->sensor_fit, cam->sensor_x, cam->sensor_y);
-      float focus_dist = BKE_camera_object_dof_distance(camera);
-      float focal_len = cam->lens;
-
-      /* this is factor that converts to the scene scale. focal length and sensor are expressed in
-       * mm unit.scale_length is how many meters per blender unit we have. We want to convert to
-       * blender units though because the shader reads coordinates in world space, which is in
-       * blender units.
-       * Note however that focus_distance is already in blender units and shall not be scaled here
-       * (see T48157). */
-      float scale = (scene_eval->unit.system) ? scene_eval->unit.scale_length : 1.0f;
-      float scale_camera = 0.001f / scale;
-      /* we want radius here for the aperture number  */
-      float aperture = 0.5f * scale_camera * focal_len / fstop;
-      float focal_len_scaled = scale_camera * focal_len;
-      float sensor_scaled = scale_camera * sensor;
-
-      if (rv3d != NULL) {
-        sensor_scaled *= rv3d->viewcamtexcofac[0];
-      }
-
-      effects->dof_params[1] = aperture *
-                               fabsf(focal_len_scaled / (focus_dist - focal_len_scaled));
-      effects->dof_params[1] *= viewport_size[0] / sensor_scaled;
-      effects->dof_params[0] = -focus_dist * effects->dof_params[1];
-
-      effects->dof_bokeh[0] = rotation;
-      effects->dof_bokeh[1] = ratio;
-      effects->dof_bokeh[2] = scene_eval->eevee.bokeh_max_size;
-
-      /* Precompute values to save instructions in fragment shader. */
-      effects->dof_bokeh_sides[0] = blades;
-      effects->dof_bokeh_sides[1] = blades > 0.0f ? 2.0f * M_PI / blades : 0.0f;
-      effects->dof_bokeh_sides[2] = blades / (2.0f * M_PI);
-      effects->dof_bokeh_sides[3] = blades > 0.0f ? cosf(M_PI / blades) : 0.0f;
-
-      return EFFECT_DOF | EFFECT_POST_BUFFER;
+    const float *viewport_size = DRW_viewport_size_get();
+
+    /* Retrieve Near and Far distance */
+    effects->dof_near_far[0] = -cam->clip_start;
+    effects->dof_near_far[1] = -cam->clip_end;
+
+    int buffer_size[2] = {(int)viewport_size[0] / 2, (int)viewport_size[1] / 2};
+
+    eGPUTextureFormat down_format = DRW_state_draw_background() ? GPU_R11F_G11F_B10F : GPU_RGBA16F;
+
+    effects->dof_down_near = DRW_texture_pool_query_2d(
+        buffer_size[0], buffer_size[1], down_format, &draw_engine_eevee_type);
+    effects->dof_down_far = DRW_texture_pool_query_2d(
+        buffer_size[0], buffer_size[1], down_format, &draw_engine_eevee_type);
+    effects->dof_coc = DRW_texture_pool_query_2d(
+        buffer_size[0], buffer_size[1], GPU_RG16F, &draw_engine_eevee_type);
+
+    GPU_framebuffer_ensure_config(&fbl->dof_down_fb,
+                                  {GPU_ATTACHMENT_NONE,
+                                   GPU_ATTACHMENT_TEXTURE(effects->dof_down_near),
+                                   GPU_ATTACHMENT_TEXTURE(effects->dof_down_far),
+                                   GPU_ATTACHMENT_TEXTURE(effects->dof_coc)});
+
+    /* Go full 32bits for rendering and reduce the color artifacts. */
+    eGPUTextureFormat fb_format = DRW_state_is_image_render() ? GPU_RGBA32F : GPU_RGBA16F;
+
+    effects->dof_blur = DRW_texture_pool_query_2d(
+        buffer_size[0] * 2, buffer_size[1], fb_format, &draw_engine_eevee_type);
+
+    GPU_framebuffer_ensure_config(&fbl->dof_scatter_fb,
+                                  {
+                                      GPU_ATTACHMENT_NONE,
+                                      GPU_ATTACHMENT_TEXTURE(effects->dof_blur),
+                                  });
+
+    if (!DRW_state_draw_background()) {
+      effects->dof_blur_alpha = DRW_texture_pool_query_2d(
+          buffer_size[0] * 2, buffer_size[1], GPU_R32F, &draw_engine_eevee_type);
+      GPU_framebuffer_texture_attach(fbl->dof_scatter_fb, effects->dof_blur_alpha, 1, 0);
+    }
+
+    /* Parameters */
+    /* TODO UI Options */
+    float fstop = cam->dof.aperture_fstop;
+    float blades = cam->dof.aperture_blades;
+    float rotation = cam->dof.aperture_rotation;
+    float ratio = 1.0f / cam->dof.aperture_ratio;
+    float sensor = BKE_camera_sensor_size(cam->sensor_fit, cam->sensor_x, cam->sensor_y);
+    float focus_dist = BKE_camera_object_dof_distance(camera);
+    float focal_len = cam->lens;
+
+    /* this is factor that converts to the scene scale. focal length and sensor are expressed in
+     * mm unit.scale_length is how many meters per blender unit we have. We want to convert to
+     * blender units though because the shader reads coordinates in world space, which is in
+     * blender units.
+     * Note however that focus_distance is already in blender units and shall not be scaled here
+     * (see T48157). */
+    float scale = (scene_eval->unit.system) ? scene_eval->unit.scale_length : 1.0f;
+    float scale_camera = 0.001f / scale;
+    /* we want radius here for the aperture number  */
+    float aperture = 0.5f * scale_camera * focal_len / fstop;
+    float focal_len_scaled = scale_camera * focal_len;
+    float sensor_scaled = scale_camera * sensor;
+
+    if (rv3d != NULL) {
+      sensor_scaled *= rv3d->viewcamtexcofac[0];
     }
+
+    effects->dof_params[1] = aperture * fabsf(focal_len_scaled / (focus_dist - focal_len_scaled));
+    effects->dof_params[1] *= viewport_size[0] / sensor_scaled;
+    effects->dof_params[0] = -focus_dist * effects->dof_params[1];
+
+    effects->dof_bokeh[0] = rotation;
+    effects->dof_bokeh[1] = ratio;
+    effects->dof_bokeh[2] = scene_eval->eevee.bokeh_max_size;
+
+    /* Precompute values to save instructions in fragment shader. */
+    effects->dof_bokeh_sides[0] = blades;
+    effects->dof_bokeh_sides[1] = blades > 0.0f ? 2.0f * M_PI / blades : 0.0f;
+    effects->dof_bokeh_sides[2] = blades / (2.0f * M_PI);
+    effects->dof_bokeh_sides[3] = blades > 0.0f ? cosf(M_PI / blades) : 0.0f;
+
+    return EFFECT_DOF | EFFECT_POST_BUFFER;
   }
 
   /* Cleanup to release memory */
index ccb79ea..d46e850 100644 (file)
@@ -115,7 +115,7 @@ static void GPENCIL_dof_nearfar(Object *camera, float coc, float nearfar[2])
   Scene *scene = draw_ctx->scene;
   Camera *cam = (Camera *)camera->data;
 
-  float fstop = cam->gpu_dof.fstop;
+  float fstop = cam->dof.aperture_fstop;
   float focus_dist = BKE_camera_object_dof_distance(camera);
   float focal_len = cam->lens;
 
index ee8c8a0..6886b73 100644 (file)
@@ -136,7 +136,9 @@ void workbench_dof_engine_init(WORKBENCH_Data *vedata, Object *camera)
   WORKBENCH_PrivateData *wpd = stl->g_data;
   WORKBENCH_FramebufferList *fbl = vedata->fbl;
 
-  if ((wpd->shading.flag & V3D_SHADING_DEPTH_OF_FIELD) == 0 || (camera == NULL)) {
+  Camera *cam = camera != NULL ? camera->data : NULL;
+  if ((wpd->shading.flag & V3D_SHADING_DEPTH_OF_FIELD) == 0 || (cam == NULL) ||
+      ((cam->dof.flag & CAM_DOF_ENABLED) == 0)) {
     wpd->dof_enabled = false;
     return;
   }
@@ -231,11 +233,10 @@ void workbench_dof_engine_init(WORKBENCH_Data *vedata, Object *camera)
     const DRWContextState *draw_ctx = DRW_context_state_get();
     const Scene *scene_eval = DEG_get_evaluated_scene(draw_ctx->depsgraph);
     RegionView3D *rv3d = draw_ctx->rv3d;
-    Camera *cam = (Camera *)camera->data;
 
     /* Parameters */
     /* TODO UI Options */
-    float fstop = cam->gpu_dof.fstop;
+    float fstop = cam->dof.aperture_fstop;
     float sensor = BKE_camera_sensor_size(cam->sensor_fit, cam->sensor_x, cam->sensor_y);
     float focus_dist = BKE_camera_object_dof_distance(camera);
     float focal_len = cam->lens;
@@ -265,9 +266,9 @@ void workbench_dof_engine_init(WORKBENCH_Data *vedata, Object *camera)
     wpd->dof_near_far[0] = -cam->clip_start;
     wpd->dof_near_far[1] = -cam->clip_end;
 
-    float blades = cam->gpu_dof.num_blades;
-    float rotation = cam->gpu_dof.rotation;
-    float ratio = 1.0f / cam->gpu_dof.ratio;
+    float blades = cam->dof.aperture_blades;
+    float rotation = cam->dof.aperture_rotation;
+    float ratio = 1.0f / cam->dof.aperture_ratio;
 
     if (wpd->dof_ubo == NULL || blades != wpd->dof_blades || rotation != wpd->dof_rotation ||
         ratio != wpd->dof_ratio) {
index 8974f3d..cd4cefe 100644 (file)
@@ -570,7 +570,6 @@ void ED_view3d_draw_offscreen(struct Depsgraph *depsgraph,
                               bool do_sky,
                               bool is_persp,
                               const char *viewname,
-                              struct GPUFXSettings *fx_settings,
                               const bool do_color_managment,
                               struct GPUOffScreen *ofs,
                               struct GPUViewport *viewport);
index 8c5f1c1..afc3b80 100644 (file)
@@ -1503,7 +1503,6 @@ void ED_view3d_draw_offscreen(Depsgraph *depsgraph,
                               bool do_sky,
                               bool UNUSED(is_persp),
                               const char *viewname,
-                              GPUFXSettings *UNUSED(fx_settings),
                               const bool do_color_management,
                               GPUOffScreen *ofs,
                               GPUViewport *viewport)
@@ -1593,7 +1592,6 @@ ImBuf *ED_view3d_draw_offscreen_imbuf(Depsgraph *depsgraph,
   const bool use_full_sample = (draw_flags & V3D_OFSDRAW_USE_FULL_SAMPLE);
 
   /* view state */
-  GPUFXSettings fx_settings = v3d->fx_settings;
   bool is_ortho = false;
   float winmat[4][4];
 
@@ -1640,8 +1638,6 @@ ImBuf *ED_view3d_draw_offscreen_imbuf(Depsgraph *depsgraph,
     BKE_camera_params_compute_viewplane(&params, sizex, sizey, scene->r.xasp, scene->r.yasp);
     BKE_camera_params_compute_matrix(&params);
 
-    BKE_camera_to_gpu_dof(camera, &fx_settings);
-
     is_ortho = params.is_ortho;
     copy_m4_m4(winmat, params.winmat);
   }
@@ -1686,7 +1682,6 @@ ImBuf *ED_view3d_draw_offscreen_imbuf(Depsgraph *depsgraph,
                              draw_sky,
                              !is_ortho,
                              viewname,
-                             &fx_settings,
                              do_color_management,
                              ofs,
                              NULL);
@@ -1724,7 +1719,6 @@ ImBuf *ED_view3d_draw_offscreen_imbuf(Depsgraph *depsgraph,
                              draw_sky,
                              !is_ortho,
                              viewname,
-                             &fx_settings,
                              false,
                              ofs,
                              viewport);
@@ -1750,7 +1744,6 @@ ImBuf *ED_view3d_draw_offscreen_imbuf(Depsgraph *depsgraph,
                                draw_sky,
                                !is_ortho,
                                viewname,
-                               &fx_settings,
                                false,
                                ofs,
                                viewport);
index 0b8c3b8..5fe62a7 100644 (file)
@@ -154,7 +154,7 @@ static void WIDGETGROUP_camera_refresh(const bContext *C, wmGizmoGroup *gzgroup)
 
     /* need to set property here for undo. TODO would prefer to do this in _init */
     WM_gizmo_target_property_def_rna(
-        cagzgroup->dop_dist, "offset", &camera_ptr, "dof_distance", -1);
+        cagzgroup->dop_dist, "offset", &camera_ptr, "dof.focus_distance", -1);
   }
   else {
     WM_gizmo_set_flag(cagzgroup->dop_dist, WM_GIZMO_HIDDEN, true);
@@ -262,7 +262,7 @@ static void WIDGETGROUP_camera_message_subscribe(const bContext *C,
   };
 
   {
-    extern PropertyRNA rna_Camera_dof_distance;
+    extern PropertyRNA rna_CameraDOFSettings_focus_distance;
     extern PropertyRNA rna_Camera_display_size;
     extern PropertyRNA rna_Camera_ortho_scale;
     extern PropertyRNA rna_Camera_sensor_fit;
@@ -273,7 +273,7 @@ static void WIDGETGROUP_camera_message_subscribe(const bContext *C,
     extern PropertyRNA rna_Camera_type;
     extern PropertyRNA rna_Camera_lens;
     const PropertyRNA *props[] = {
-        &rna_Camera_dof_distance,
+        &rna_CameraDOFSettings_focus_distance,
         &rna_Camera_display_size,
         &rna_Camera_ortho_scale,
         &rna_Camera_sensor_fit,
index 8c5d911..b78b2f6 100644 (file)
@@ -67,6 +67,19 @@ typedef struct CameraBGImage {
   short source;
 } CameraBGImage;
 
+/** Properties for dof effect. */
+typedef struct CameraDOFSettings {
+  /** Focal distance for depth of field. */
+  struct Object *focus_object;
+  float focus_distance;
+  float aperture_fstop;
+  float aperture_rotation;
+  float aperture_ratio;
+  int aperture_blades;
+  short flag;
+  char _pad[2];
+} CameraDOFSettings;
+
 typedef struct Camera_Runtime {
   /* For draw manager. */
   float drw_corners[2][4][2];
@@ -91,13 +104,14 @@ typedef struct Camera {
   float lens, ortho_scale, drawsize;
   float sensor_x, sensor_y;
   float shiftx, shifty;
-  float dof_distance;
+  float dof_distance DNA_DEPRECATED;
 
   /** Old animation system, deprecated for 2.5. */
   struct Ipo *ipo DNA_DEPRECATED;
 
-  struct Object *dof_ob;
-  struct GPUDOFSettings gpu_dof;
+  struct Object *dof_ob DNA_DEPRECATED;
+  struct GPUDOFSettings gpu_dof DNA_DEPRECATED;
+  struct CameraDOFSettings dof;
 
   /* CameraBGImage reference images */
   struct ListBase bg_images;
@@ -204,6 +218,11 @@ enum {
   CAM_BGIMG_SOURCE_MOVIE = 1,
 };
 
+/* CameraDOFSettings->flag */
+enum {
+  CAM_DOF_ENABLED = (1 << 0),
+};
+
 #ifdef __cplusplus
 }
 #endif
index c64a593..0f6d028 100644 (file)
@@ -2376,7 +2376,7 @@ enum {
   SCE_EEVEE_GTAO_ENABLED = (1 << 4),
   SCE_EEVEE_GTAO_BENT_NORMALS = (1 << 5),
   SCE_EEVEE_GTAO_BOUNCE = (1 << 6),
-  SCE_EEVEE_DOF_ENABLED = (1 << 7),
+  // SCE_EEVEE_DOF_ENABLED = (1 << 7), /* Moved to camera->dof.flag */
   SCE_EEVEE_BLOOM_ENABLED = (1 << 8),
   SCE_EEVEE_MOTION_BLUR_ENABLED = (1 << 9),
   SCE_EEVEE_SHADOW_HIGH_BITDEPTH = (1 << 10),
index 0ea1ca9..c09ada4 100644 (file)
@@ -41,6 +41,8 @@
  * numbers give more output.
  */
 
+#define DNA_DEPRECATED_ALLOW
+
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
index 5aee34d..e3be9fd 100644 (file)
@@ -97,6 +97,7 @@ extern StructRNA RNA_BuildGpencilModifier;
 extern StructRNA RNA_BuildModifier;
 extern StructRNA RNA_CacheFile;
 extern StructRNA RNA_Camera;
+extern StructRNA RNA_CameraDOFSettings;
 extern StructRNA RNA_CastModifier;
 extern StructRNA RNA_ChildOfConstraint;
 extern StructRNA RNA_ChildParticle;
index 1f35662..6bab07d 100644 (file)
@@ -131,6 +131,38 @@ static void rna_Camera_dof_update(Main *bmain, Scene *scene, PointerRNA *UNUSED(
   WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
 }
 
+char *rna_CameraDOFSettings_path(PointerRNA *ptr)
+{
+  /* if there is ID-data, resolve the path using the index instead of by name,
+   * since the name used is the name of the texture assigned, but the texture
+   * may be used multiple times in the same stack
+   */
+  if (ptr->id.data) {
+    if (GS(((ID *)ptr->id.data)->name) == ID_CA) {
+      return BLI_strdup("dof");
+    }
+  }
+
+  return BLI_strdup("");
+}
+
+static void rna_CameraDOFSettings_aperture_blades_set(PointerRNA *ptr, const int value)
+{
+  CameraDOFSettings *dofsettings = (CameraDOFSettings *)ptr->data;
+
+  if (value == 1 || value == 2) {
+    if (dofsettings->aperture_blades == 0) {
+      dofsettings->aperture_blades = 3;
+    }
+    else {
+      dofsettings->aperture_blades = 0;
+    }
+  }
+  else {
+    dofsettings->aperture_blades = value;
+  }
+}
+
 #else
 
 static void rna_def_camera_background_image(BlenderRNA *brna)
@@ -376,6 +408,68 @@ static void rna_def_camera_stereo_data(BlenderRNA *brna)
   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
 }
 
+static void rna_def_camera_dof_settings_data(BlenderRNA *brna)
+{
+  StructRNA *srna;
+  PropertyRNA *prop;
+
+  srna = RNA_def_struct(brna, "CameraDOFSettings", NULL);
+  RNA_def_struct_sdna(srna, "CameraDOFSettings");
+  RNA_def_struct_path_func(srna, "rna_CameraDOFSettings_path");
+  RNA_def_struct_ui_text(srna, "Depth of Field", "Depth of Field settings");
+
+  prop = RNA_def_property(srna, "use_dof", PROP_BOOLEAN, PROP_NONE);
+  RNA_def_property_boolean_sdna(prop, NULL, "flag", CAM_DOF_ENABLED);
+  RNA_def_property_ui_text(prop, "Depth of Field", "Use Depth of Field");
+  RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Camera_dof_update");
+
+  prop = RNA_def_property(srna, "focus_object", PROP_POINTER, PROP_NONE);
+  RNA_def_property_struct_type(prop, "Object");
+  RNA_def_property_pointer_sdna(prop, NULL, "focus_object");
+  RNA_def_property_flag(prop, PROP_EDITABLE);
+  RNA_def_property_ui_text(
+      prop, "Focus Object", "Use this object to define the depth of field focal point");
+  RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Camera_dependency_update");
+
+  prop = RNA_def_property(srna, "focus_distance", PROP_FLOAT, PROP_DISTANCE);
+  RNA_def_property_float_default(prop, 10.0f);
+  // RNA_def_property_pointer_sdna(prop, NULL, "focus_distance");
+  RNA_def_property_range(prop, 0.0f, FLT_MAX);
+  RNA_def_property_ui_range(prop, 0.0f, 5000.0f, 1, 2);
+  RNA_def_property_ui_text(
+      prop, "Focus Distance", "Distance to the focus point for depth of field");
+  RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Camera_dof_update");
+
+  prop = RNA_def_property(srna, "aperture_fstop", PROP_FLOAT, PROP_NONE);
+  RNA_def_property_ui_text(
+      prop,
+      "F-Stop",
+      "F-Stop ratio (lower numbers give more defocus, higher numbers give a sharper image)");
+  RNA_def_property_float_default(prop, 5.6f);
+  RNA_def_property_range(prop, 0.0f, FLT_MAX);
+  RNA_def_property_ui_range(prop, 0.1f, 128.0f, 10, 1);
+  RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Camera_dof_update");
+
+  prop = RNA_def_property(srna, "aperture_blades", PROP_INT, PROP_NONE);
+  RNA_def_property_ui_text(
+      prop, "Blades", "Number of blades in aperture for polygonal bokeh (at least 3)");
+  RNA_def_property_range(prop, 0, 16);
+  RNA_def_property_int_funcs(prop, NULL, "rna_CameraDOFSettings_aperture_blades_set", NULL);
+  RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Camera_dof_update");
+
+  prop = RNA_def_property(srna, "aperture_rotation", PROP_FLOAT, PROP_ANGLE);
+  RNA_def_property_ui_text(prop, "Rotation", "Rotation of blades in aperture");
+  RNA_def_property_range(prop, -M_PI, M_PI);
+  RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Camera_dof_update");
+
+  prop = RNA_def_property(srna, "aperture_ratio", PROP_FLOAT, PROP_NONE);
+  RNA_def_property_ui_text(prop, "Ratio", "Distortion to simulate anamorphic lens bokeh");
+  RNA_def_property_float_default(prop, 1.0f);
+  RNA_def_property_range(prop, 0.01f, FLT_MAX);
+  RNA_def_property_ui_range(prop, 1.0f, 2.0f, 0.1, 3);
+  RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Camera_dof_update");
+}
+
 void RNA_def_camera(BlenderRNA *brna)
 {
   StructRNA *srna;
@@ -525,12 +619,6 @@ void RNA_def_camera(BlenderRNA *brna)
   RNA_def_property_ui_text(prop, "Shift Y", "Camera vertical shift");
   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Camera_update");
 
-  prop = RNA_def_property(srna, "dof_distance", PROP_FLOAT, PROP_DISTANCE);
-  RNA_def_property_range(prop, 0.0f, FLT_MAX);
-  RNA_def_property_ui_range(prop, 0.0f, 5000.0f, 1, 2);
-  RNA_def_property_ui_text(prop, "DOF Distance", "Distance to the focus point for depth of field");
-  RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Camera_dof_update");
-
   /* Stereo Settings */
   prop = RNA_def_property(srna, "stereo", PROP_POINTER, PROP_NONE);
   RNA_def_property_flag(prop, PROP_NEVER_NULL);
@@ -645,17 +733,9 @@ void RNA_def_camera(BlenderRNA *brna)
   RNA_def_property_update(prop, NC_CAMERA | ND_DRAW_RENDER_VIEWPORT, NULL);
 
   /* pointers */
-  prop = RNA_def_property(srna, "dof_object", PROP_POINTER, PROP_NONE);
-  RNA_def_property_struct_type(prop, "Object");
-  RNA_def_property_pointer_sdna(prop, NULL, "dof_ob");
-  RNA_def_property_flag(prop, PROP_EDITABLE);
-  RNA_def_property_ui_text(
-      prop, "DOF Object", "Use this object to define the depth of field focal point");
-  RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Camera_dependency_update");
-
-  prop = RNA_def_property(srna, "gpu_dof", PROP_POINTER, PROP_NONE);
-  RNA_def_property_struct_type(prop, "GPUDOFSettings");
-  RNA_def_property_ui_text(prop, "GPU Depth Of Field", "");
+  prop = RNA_def_property(srna, "dof", PROP_POINTER, PROP_NONE);
+  RNA_def_property_struct_type(prop, "CameraDOFSettings");
+  RNA_def_property_ui_text(prop, "Depth Of Field", "");
   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
 
   prop = RNA_def_property(srna, "background_images", PROP_COLLECTION, PROP_NONE);
@@ -674,6 +754,7 @@ void RNA_def_camera(BlenderRNA *brna)
 
   /* *** Animated *** */
   rna_def_camera_stereo_data(brna);
+  rna_def_camera_dof_settings_data(brna);
 
   /* Camera API */
   RNA_api_camera(srna);
index 4584cad..a4d263b 100644 (file)
@@ -2155,45 +2155,6 @@ void rna_FreestyleSettings_module_remove(ID *id,
   WM_main_add_notifier(NC_SCENE | ND_RENDER_OPTIONS, NULL);
 }
 
-char *rna_GPUDOF_path(PointerRNA *ptr)
-{
-  /* if there is ID-data, resolve the path using the index instead of by name,
-   * since the name used is the name of the texture assigned, but the texture
-   * may be used multiple times in the same stack
-   */
-  if (ptr->id.data) {
-    if (GS(((ID *)ptr->id.data)->name) == ID_CA) {
-      return BLI_strdup("gpu_dof");
-    }
-  }
-
-  return BLI_strdup("");
-}
-
-static void rna_GPUDOFSettings_blades_set(PointerRNA *ptr, const int value)
-{
-  GPUDOFSettings *dofsettings = (GPUDOFSettings *)ptr->data;
-
-  if (value == 1 || value == 2) {
-    if (dofsettings->num_blades == 0) {
-      dofsettings->num_blades = 3;
-    }
-    else {
-      dofsettings->num_blades = 0;
-    }
-  }
-  else {
-    dofsettings->num_blades = value;
-  }
-}
-
-static void rna_GPUDOFSettings_update(Main *bmain, Scene *scene, PointerRNA *UNUSED(ptr))
-{
-  /* TODO(sergey): Can be more selective here. */
-  BKE_sequencer_cache_cleanup_all(bmain);
-  WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
-}
-
 static void rna_Stereo3dFormat_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
 {
   ID *id = ptr->id.data;
@@ -4734,60 +4695,6 @@ static void rna_def_bake_data(BlenderRNA *brna)
   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 }
 
-static void rna_def_gpu_dof_fx(BlenderRNA *brna)
-{
-  StructRNA *srna;
-  PropertyRNA *prop;
-
-  srna = RNA_def_struct(brna, "GPUDOFSettings", NULL);
-  RNA_def_struct_ui_text(srna, "GPU DOF", "Settings for GPU based depth of field");
-  RNA_def_struct_path_func(srna, "rna_GPUDOF_path");
-
-  prop = RNA_def_property(srna, "focus_distance", PROP_FLOAT, PROP_DISTANCE);
-  RNA_def_property_ui_text(prop, "Focus distance", "Viewport depth of field focus distance");
-  RNA_def_property_range(prop, 0.0f, FLT_MAX);
-  RNA_def_property_ui_range(prop, 0.0f, 5000.0f, 1, 2);
-  RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_GPUDOFSettings_update");
-
-  prop = RNA_def_property(srna, "focal_length", PROP_FLOAT, PROP_DISTANCE_CAMERA);
-  RNA_def_property_ui_text(prop, "Focal Length", "Focal length for dof effect");
-  RNA_def_property_range(prop, 1.0f, FLT_MAX);
-  RNA_def_property_ui_range(prop, 1.0f, 5000.0f, 1, 2);
-  RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_GPUDOFSettings_update");
-
-  prop = RNA_def_property(srna, "sensor", PROP_FLOAT, PROP_DISTANCE_CAMERA);
-  RNA_def_property_ui_text(prop, "Sensor", "Size of sensor");
-  RNA_def_property_range(prop, 1.0f, FLT_MAX);
-  RNA_def_property_ui_range(prop, 1.0f, 5000.0f, 1, 2);
-  RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_GPUDOFSettings_update");
-
-  prop = RNA_def_property(srna, "fstop", PROP_FLOAT, PROP_NONE);
-  RNA_def_property_ui_text(prop, "F-stop", "F-stop for dof effect");
-  RNA_def_property_float_default(prop, 128.0f);
-  RNA_def_property_range(prop, 0.0f, FLT_MAX);
-  RNA_def_property_ui_range(prop, 0.1f, 128.0f, 10, 1);
-  RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_GPUDOFSettings_update");
-
-  prop = RNA_def_property(srna, "blades", PROP_INT, PROP_NONE);
-  RNA_def_property_int_sdna(prop, NULL, "num_blades");
-  RNA_def_property_ui_text(prop, "Blades", "Blades for dof effect");
-  RNA_def_property_range(prop, 0, 16);
-  RNA_def_property_int_funcs(prop, NULL, "rna_GPUDOFSettings_blades_set", NULL);
-  RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_GPUDOFSettings_update");
-
-  prop = RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_ANGLE);
-  RNA_def_property_ui_text(prop, "Rotation", "Rotation of blades in aperture");
-  RNA_def_property_range(prop, -M_PI, M_PI);
-  RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
-
-  prop = RNA_def_property(srna, "ratio", PROP_FLOAT, PROP_NONE);
-  RNA_def_property_ui_text(prop, "Ratio", "Distortion to simulate anamorphic lens bokeh");
-  RNA_def_property_float_default(prop, 1.0f);
-  RNA_def_property_range(prop, 0.01f, FLT_MAX);
-  RNA_def_property_ui_range(prop, 1.0f, 2.0f, 0.1, 3);
-  RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
-}
-
 static void rna_def_gpu_ssao_fx(BlenderRNA *brna)
 {
   StructRNA *srna;
@@ -4832,23 +4739,10 @@ static void rna_def_gpu_fx(BlenderRNA *brna)
   PropertyRNA *prop;
 
   rna_def_gpu_ssao_fx(brna);
-  rna_def_gpu_dof_fx(brna);
 
   srna = RNA_def_struct(brna, "GPUFXSettings", NULL);
   RNA_def_struct_ui_text(srna, "GPU FX Settings", "Settings for GPU based compositing");
 
-  prop = RNA_def_property(srna, "dof", PROP_POINTER, PROP_NONE);
-  RNA_def_property_flag(prop, PROP_NEVER_NULL);
-  RNA_def_property_struct_type(prop, "GPUDOFSettings");
-  RNA_def_property_ui_text(prop, "Depth Of Field settings", "");
-
-  prop = RNA_def_property(srna, "use_dof", PROP_BOOLEAN, PROP_NONE);
-  RNA_def_property_boolean_sdna(prop, NULL, "fx_flag", GPU_FX_FLAG_DOF);
-  RNA_def_property_ui_text(prop,
-                           "Depth Of Field",
-                           "Use depth of field on viewport using the values from active camera");
-  RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
-
   prop = RNA_def_property(srna, "ssao", PROP_POINTER, PROP_NONE);
   RNA_def_property_flag(prop, PROP_NEVER_NULL);
   RNA_def_property_struct_type(prop, "GPUSSAOSettings");
@@ -7004,14 +6898,6 @@ static void rna_def_scene_eevee(BlenderRNA *brna)
   RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 
   /* Depth of Field */
-  prop = RNA_def_property(srna, "use_dof", PROP_BOOLEAN, PROP_NONE);
-  RNA_def_property_boolean_sdna(prop, NULL, "flag", SCE_EEVEE_DOF_ENABLED);
-  RNA_def_property_boolean_default(prop, 0);
-  RNA_def_property_ui_text(
-      prop, "Depth of Field", "Enable depth of field using the values from the active camera");
-  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
-  RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
-
   prop = RNA_def_property(srna, "bokeh_max_size", PROP_FLOAT, PROP_PIXEL);
   RNA_def_property_float_default(prop, 100.0f);
   RNA_def_property_ui_text(
index 5ea747b..561aff4 100644 (file)
@@ -256,7 +256,6 @@ static PyObject *bpygpu_offscreen_draw_view3d(BPyGPUOffScreen *self,
                            false,
                            true,
                            "",
-                           NULL,
                            true,
                            self->ofs,
                            NULL);
index 5deb51f..b410f5f 100755 (executable)
@@ -19,11 +19,9 @@ def setup():
     scene = bpy.context.scene
     eevee = scene.eevee
 
-    eevee.use_sss = True
     eevee.use_ssr = True
     eevee.use_ssr_refraction = True
     eevee.use_gtao = True
-    eevee.use_dof = False
 
     eevee.use_volumetric_shadows = True
     eevee.volumetric_tile_size = '2'