Cycles: adaptive subdivision support for panoramic cameras.

Adds the code to get screen size of a point in world space, which is
used for subdividing geometry to the correct level. The approximate
method of treating the point as if it were directly in front of the
camera is used, as panoramic projections can become very distorted
near the edges of an image. This should be fine for most uses.

There is also no support yet for offscreen dicing scale, though
panorama cameras are often used for rendering 360° renders anyway.

Fixes T49254.

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

1 files changed, 32 insertions, 32 deletions

diff --git a/intern/cycles/kernel/kernel_camera.h b/intern/cycles/kernel/kernel_camera.h
index 77e3446329a..96cdb04d955 100644
--- a/intern/cycles/kernel/kernel_camera.h
+++ b/intern/cycles/kernel/kernel_camera.h
@@ -18,9 +18,9 @@ CCL_NAMESPACE_BEGIN
 
 /* Perspective Camera */
 
-ccl_device float2 camera_sample_aperture(KernelGlobals *kg, float u, float v)
+ccl_device float2 camera_sample_aperture(ccl_constant KernelCamera *cam, float u, float v)
 {
-	float blades = kernel_data.cam.blades;
+	float blades = cam->blades;
 	float2 bokeh;
 
 	if(blades == 0.0f) {
@@ -29,12 +29,12 @@ ccl_device float2 camera_sample_aperture(KernelGlobals *kg, float u, float v)
 	}
 	else {
 		/* sample polygon */
-		float rotation = kernel_data.cam.bladesrotation;
+		float rotation = cam->bladesrotation;
 		bokeh = regular_polygon_sample(blades, rotation, u, v);
 	}
 
 	/* anamorphic lens bokeh */
-	bokeh.x *= kernel_data.cam.inv_aperture_ratio;
+	bokeh.x *= cam->inv_aperture_ratio;
 
 	return bokeh;
 }
@@ -76,7 +76,7 @@ ccl_device void camera_sample_perspective(KernelGlobals *kg, float raster_x, flo
 
 	if(aperturesize > 0.0f) {
 		/* sample point on aperture */
-		float2 lensuv = camera_sample_aperture(kg, lens_u, lens_v)*aperturesize;
+		float2 lensuv = camera_sample_aperture(&kernel_data.cam, lens_u, lens_v)*aperturesize;
 
 		/* compute point on plane of focus */
 		float ft = kernel_data.cam.focaldistance/D.z;
@@ -124,7 +124,7 @@ ccl_device void camera_sample_perspective(KernelGlobals *kg, float raster_x, flo
 	}
 	else {
 		/* Spherical stereo */
-		spherical_stereo_transform(kg, &P, &D);
+		spherical_stereo_transform(&kernel_data.cam, &P, &D);
 		ray->P = P;
 		ray->D = D;
 
@@ -138,12 +138,12 @@ ccl_device void camera_sample_perspective(KernelGlobals *kg, float raster_x, flo
 		float3 Pcenter = Pnostereo;
 		float3 Dcenter = Pcamera;
 		Dcenter = normalize(transform_direction(&cameratoworld, Dcenter));
-		spherical_stereo_transform(kg, &Pcenter, &Dcenter);
+		spherical_stereo_transform(&kernel_data.cam, &Pcenter, &Dcenter);
 
 		float3 Px = Pnostereo;
 		float3 Dx = transform_perspective(&rastertocamera, make_float3(raster_x + 1.0f, raster_y, 0.0f));
 		Dx = normalize(transform_direction(&cameratoworld, Dx));
-		spherical_stereo_transform(kg, &Px, &Dx);
+		spherical_stereo_transform(&kernel_data.cam, &Px, &Dx);
 
 		ray->dP.dx = Px - Pcenter;
 		ray->dD.dx = Dx - Dcenter;
@@ -151,7 +151,7 @@ ccl_device void camera_sample_perspective(KernelGlobals *kg, float raster_x, flo
 		float3 Py = Pnostereo;
 		float3 Dy = transform_perspective(&rastertocamera, make_float3(raster_x, raster_y + 1.0f, 0.0f));
 		Dy = normalize(transform_direction(&cameratoworld, Dy));
-		spherical_stereo_transform(kg, &Py, &Dy);
+		spherical_stereo_transform(&kernel_data.cam, &Py, &Dy);
 
 		ray->dP.dy = Py - Pcenter;
 		ray->dD.dy = Dy - Dcenter;
@@ -186,7 +186,7 @@ ccl_device void camera_sample_orthographic(KernelGlobals *kg, float raster_x, fl
 
 	if(aperturesize > 0.0f) {
 		/* sample point on aperture */
-		float2 lensuv = camera_sample_aperture(kg, lens_u, lens_v)*aperturesize;
+		float2 lensuv = camera_sample_aperture(&kernel_data.cam, lens_u, lens_v)*aperturesize;
 
 		/* compute point on plane of focus */
 		float3 Pfocus = D * kernel_data.cam.focaldistance;
@@ -238,17 +238,17 @@ ccl_device void camera_sample_orthographic(KernelGlobals *kg, float raster_x, fl
 
 /* Panorama Camera */
 
-ccl_device_inline void camera_sample_panorama(KernelGlobals *kg,
+ccl_device_inline void camera_sample_panorama(ccl_constant KernelCamera *cam,
                                               float raster_x, float raster_y,
                                               float lens_u, float lens_v,
                                               ccl_addr_space Ray *ray)
 {
-	Transform rastertocamera = kernel_data.cam.rastertocamera;
+	Transform rastertocamera = cam->rastertocamera;
 	float3 Pcamera = transform_perspective(&rastertocamera, make_float3(raster_x, raster_y, 0.0f));
 
 	/* create ray form raster position */
 	float3 P = make_float3(0.0f, 0.0f, 0.0f);
-	float3 D = panorama_to_direction(kg, Pcamera.x, Pcamera.y);
+	float3 D = panorama_to_direction(cam, Pcamera.x, Pcamera.y);
 
 	/* indicates ray should not receive any light, outside of the lens */
 	if(is_zero(D)) {
@@ -257,15 +257,15 @@ ccl_device_inline void camera_sample_panorama(KernelGlobals *kg,
 	}
 
 	/* modify ray for depth of field */
-	float aperturesize = kernel_data.cam.aperturesize;
+	float aperturesize = cam->aperturesize;
 
 	if(aperturesize > 0.0f) {
 		/* sample point on aperture */
-		float2 lensuv = camera_sample_aperture(kg, lens_u, lens_v)*aperturesize;
+		float2 lensuv = camera_sample_aperture(cam, lens_u, lens_v)*aperturesize;
 
 		/* compute point on plane of focus */
 		float3 Dfocus = normalize(D);
-		float3 Pfocus = Dfocus * kernel_data.cam.focaldistance;
+		float3 Pfocus = Dfocus * cam->focaldistance;
 
 		/* calculate orthonormal coordinates perpendicular to Dfocus */
 		float3 U, V;
@@ -278,18 +278,18 @@ ccl_device_inline void camera_sample_panorama(KernelGlobals *kg,
 	}
 
 	/* transform ray from camera to world */
-	Transform cameratoworld = kernel_data.cam.cameratoworld;
+	Transform cameratoworld = cam->cameratoworld;
 
 #ifdef __CAMERA_MOTION__
-	if(kernel_data.cam.have_motion) {
+	if(cam->have_motion) {
 #  ifdef __KERNEL_OPENCL__
-		const MotionTransform tfm = kernel_data.cam.motion;
+		const MotionTransform tfm = cam->motion;
 		transform_motion_interpolate(&cameratoworld,
 		                             &tfm,
 		                             ray->time);
 #  else
 		transform_motion_interpolate(&cameratoworld,
-		                             &kernel_data.cam.motion,
+		                             &cam->motion,
 		                             ray->time);
 #  endif
 	}
@@ -299,9 +299,9 @@ ccl_device_inline void camera_sample_panorama(KernelGlobals *kg,
 	D = normalize(transform_direction(&cameratoworld, D));
 
 	/* Stereo transform */
-	bool use_stereo = kernel_data.cam.interocular_offset != 0.0f;
+	bool use_stereo = cam->interocular_offset != 0.0f;
 	if(use_stereo) {
-		spherical_stereo_transform(kg, &P, &D);
+		spherical_stereo_transform(cam, &P, &D);
 	}
 
 	ray->P = P;
@@ -313,30 +313,30 @@ ccl_device_inline void camera_sample_panorama(KernelGlobals *kg,
 	 * ray origin and direction for the center and two neighbouring pixels
 	 * and simply take their differences. */
 	float3 Pcenter = Pcamera;
-	float3 Dcenter = panorama_to_direction(kg, Pcenter.x, Pcenter.y);
+	float3 Dcenter = panorama_to_direction(cam, Pcenter.x, Pcenter.y);
 	Pcenter = transform_point(&cameratoworld, Pcenter);
 	Dcenter = normalize(transform_direction(&cameratoworld, Dcenter));
 	if(use_stereo) {
-		spherical_stereo_transform(kg, &Pcenter, &Dcenter);
+		spherical_stereo_transform(cam, &Pcenter, &Dcenter);
 	}
 
 	float3 Px = transform_perspective(&rastertocamera, make_float3(raster_x + 1.0f, raster_y, 0.0f));
-	float3 Dx = panorama_to_direction(kg, Px.x, Px.y);
+	float3 Dx = panorama_to_direction(cam, Px.x, Px.y);
 	Px = transform_point(&cameratoworld, Px);
 	Dx = normalize(transform_direction(&cameratoworld, Dx));
 	if(use_stereo) {
-		spherical_stereo_transform(kg, &Px, &Dx);
+		spherical_stereo_transform(cam, &Px, &Dx);
 	}
 
 	ray->dP.dx = Px - Pcenter;
 	ray->dD.dx = Dx - Dcenter;
 
 	float3 Py = transform_perspective(&rastertocamera, make_float3(raster_x, raster_y + 1.0f, 0.0f));
-	float3 Dy = panorama_to_direction(kg, Py.x, Py.y);
+	float3 Dy = panorama_to_direction(cam, Py.x, Py.y);
 	Py = transform_point(&cameratoworld, Py);
 	Dy = normalize(transform_direction(&cameratoworld, Dy));
 	if(use_stereo) {
-		spherical_stereo_transform(kg, &Py, &Dy);
+		spherical_stereo_transform(cam, &Py, &Dy);
 	}
 
 	ray->dP.dy = Py - Pcenter;
@@ -345,11 +345,11 @@ ccl_device_inline void camera_sample_panorama(KernelGlobals *kg,
 
 #ifdef __CAMERA_CLIPPING__
 	/* clipping */
-	float nearclip = kernel_data.cam.nearclip;
+	float nearclip = cam->nearclip;
 	ray->P += nearclip * ray->D;
 	ray->dP.dx += nearclip * ray->dD.dx;
 	ray->dP.dy += nearclip * ray->dD.dy;
-	ray->t = kernel_data.cam.cliplength;
+	ray->t = cam->cliplength;
 #else
 	ray->t = FLT_MAX;
 #endif
@@ -415,7 +415,7 @@ ccl_device_inline void camera_sample(KernelGlobals *kg,
 	else if(kernel_data.cam.type == CAMERA_ORTHOGRAPHIC)
 		camera_sample_orthographic(kg, raster_x, raster_y, lens_u, lens_v, ray);
 	else
-		camera_sample_panorama(kg, raster_x, raster_y, lens_u, lens_v, ray);
+		camera_sample_panorama(&kernel_data.cam, raster_x, raster_y, lens_u, lens_v, ray);
 }
 
 /* Utilities */
@@ -472,7 +472,7 @@ ccl_device_inline float3 camera_world_to_ndc(KernelGlobals *kg, ShaderData *sd,
 		else
 			P = normalize(transform_direction(&tfm, P));
 
-		float2 uv = direction_to_panorama(kg, P);
+		float2 uv = direction_to_panorama(&kernel_data.cam, P);
 
 		return make_float3(uv.x, uv.y, 0.0f);
 	}