Differential D1223 Diff 6116 intern/cycles/blender/blender_camera.cpp

Changeset View

Standalone View

intern/cycles/blender/blender_camera.cpp

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines	struct BlenderCamera {

PanoramaType panorama_type;		PanoramaType panorama_type;
float fisheye_fov;		float fisheye_fov;
float fisheye_lens;		float fisheye_lens;
float latitude_min;		float latitude_min;
float latitude_max;		float latitude_max;
float longitude_min;		float longitude_min;
float longitude_max;		float longitude_max;
		bool use_spherical_stereo;
		float interocular_distance;
		float convergence_distance;

enum { AUTO, HORIZONTAL, VERTICAL } sensor_fit;		enum { AUTO, HORIZONTAL, VERTICAL } sensor_fit;
float sensor_width;		float sensor_width;
float sensor_height;		float sensor_height;

int full_width;		int full_width;
int full_height;		int full_height;

Show All 30 Lines	static void blender_camera_init(BlenderCamera *bcam,
bcam->full_width = render_resolution_x(b_render);		bcam->full_width = render_resolution_x(b_render);
bcam->full_height = render_resolution_y(b_render);		bcam->full_height = render_resolution_y(b_render);

/* pixel aspect */		/* pixel aspect */
bcam->pixelaspect.x = b_render.pixel_aspect_x();		bcam->pixelaspect.x = b_render.pixel_aspect_x();
bcam->pixelaspect.y = b_render.pixel_aspect_y();		bcam->pixelaspect.y = b_render.pixel_aspect_y();
}		}

static float blender_camera_focal_distance(BL::RenderEngine& b_engine,		static float blender_camera_focal_distance(BL::RenderEngine& b_engine,
BL::Object& b_ob,		BL::Object& b_ob,
BL::Camera& b_camera)		BL::Camera& b_camera,
		sergeyUnsubmitted Not Done Inline Actions Guess this is because `b_engine.camera_shift_x` applies offset for an eye? Worth mentioning this in the comment. sergey: Guess this is because `b_engine.camera_shift_x` applies offset for an eye? Worth mentioning…
		BlenderCamera *bcam)
		sergeyUnsubmitted Not Done Inline Actions Why exactly we need to have special handling of those two functions? Something tells me it's better idea to make it so camera's RNA API will be giving you proper shift/matrix depending on it's settings? Might be missing something tho.. sergey: Why exactly we need to have special handling of those two functions? Something tells me it's…
		dfelintoAuthorUnsubmitted Not Done Inline Actions The RNA API (b_engine.camera_shift_x) is not aware of this special case of stereo (since Blender Internal doesn't support it). dfelinto: The RNA API (b_engine.camera_shift_x) is not aware of this special case of stereo (since…
		sergeyUnsubmitted Not Done Inline Actions Think it's more clear to pass `bcam` and access to `bcam->use_spherical_stereo`. So if shift/matrix will ever depend on more settings you don't need to pass them sergey: Think it's more clear to pass `bcam` and access to `bcam->use_spherical_stereo`. So if…
{		{
BL::Object b_dof_object = b_camera.dof_object();		BL::Object b_dof_object = b_camera.dof_object();

if(!b_dof_object)		if(!b_dof_object)
return b_camera.dof_distance();		return b_camera.dof_distance();
		sergeyUnsubmitted Not Done Inline Actions Same as above. sergey: Same as above.

/* for dof object, return distance along camera Z direction */		/* for dof object, return distance along camera Z direction */
BL::Array<float, 16> b_ob_matrix;		BL::Array<float, 16> b_ob_matrix;
		sergeyUnsubmitted Not Done Inline Actions Seems phab got confused here with comments.. Still think we can make more clear Py-API for such things, but at least please bother explaining why it's special case here as well ;) sergey: Seems phab got confused here with comments.. Still think we can make more clear Py-API for…
b_engine.camera_model_matrix(b_ob, b_ob_matrix);		b_engine.camera_model_matrix(b_ob, bcam->use_spherical_stereo, b_ob_matrix);
Transform obmat = get_transform(b_ob_matrix);		Transform obmat = transform_clear_scale(get_transform(b_ob_matrix));
Transform dofmat = get_transform(b_dof_object.matrix_world());		Transform dofmat = get_transform(b_dof_object.matrix_world());
float3 view_dir = normalize(transform_get_column(&obmat, 2));		float3 view_dir = normalize(transform_get_column(&obmat, 2));
float3 dof_dir = transform_get_column(&obmat, 3) - transform_get_column(&dofmat, 3);		float3 dof_dir = transform_get_column(&obmat, 3) - transform_get_column(&dofmat, 3);
return fabsf(dot(view_dir, dof_dir));		return fabsf(dot(view_dir, dof_dir));
		sergeyUnsubmitted Not Done Inline Actions Same. sergey: Same.
}		}

static void blender_camera_from_object(BlenderCamera *bcam,		static void blender_camera_from_object(BlenderCamera *bcam,
BL::RenderEngine& b_engine,		BL::RenderEngine& b_engine,
BL::Object& b_ob,		BL::Object& b_ob,
bool skip_panorama = false)		bool skip_panorama = false)
		sergeyUnsubmitted Not Done Inline Actions Use `RenderSettings::view_format_STEREO_3D` instead of 0. sergey: Use `RenderSettings::view_format_STEREO_3D` instead of 0.
		dfelintoAuthorUnsubmitted Not Done Inline Actions done dfelinto: done
{		{
BL::ID b_ob_data = b_ob.data();		BL::ID b_ob_data = b_ob.data();

if(b_ob_data.is_a(&RNA_Camera)) {		if(b_ob_data.is_a(&RNA_Camera)) {
BL::Camera b_camera(b_ob_data);		BL::Camera b_camera(b_ob_data);
PointerRNA ccamera = RNA_pointer_get(&b_camera.ptr, "cycles");		PointerRNA ccamera = RNA_pointer_get(&b_camera.ptr, "cycles");

bcam->nearclip = b_camera.clip_start();		bcam->nearclip = b_camera.clip_start();
Show All 23 Lines	if(b_ob_data.is_a(&RNA_Camera)) {

bcam->fisheye_fov = RNA_float_get(&ccamera, "fisheye_fov");		bcam->fisheye_fov = RNA_float_get(&ccamera, "fisheye_fov");
bcam->fisheye_lens = RNA_float_get(&ccamera, "fisheye_lens");		bcam->fisheye_lens = RNA_float_get(&ccamera, "fisheye_lens");
bcam->latitude_min = RNA_float_get(&ccamera, "latitude_min");		bcam->latitude_min = RNA_float_get(&ccamera, "latitude_min");
bcam->latitude_max = RNA_float_get(&ccamera, "latitude_max");		bcam->latitude_max = RNA_float_get(&ccamera, "latitude_max");
bcam->longitude_min = RNA_float_get(&ccamera, "longitude_min");		bcam->longitude_min = RNA_float_get(&ccamera, "longitude_min");
bcam->longitude_max = RNA_float_get(&ccamera, "longitude_max");		bcam->longitude_max = RNA_float_get(&ccamera, "longitude_max");

		bcam->interocular_distance = b_camera.stereo().interocular_distance();
		bcam->convergence_distance = b_camera.stereo().convergence_distance();
		bcam->use_spherical_stereo = b_engine.use_spherical_stereo(b_ob);

bcam->ortho_scale = b_camera.ortho_scale();		bcam->ortho_scale = b_camera.ortho_scale();

bcam->lens = b_camera.lens();		bcam->lens = b_camera.lens();

/* allow f/stop number to change aperture_size but still		/* allow f/stop number to change aperture_size but still
* give manual control over aperture radius */		* give manual control over aperture radius */
int aperture_type = get_enum(ccamera, "aperture_type");		int aperture_type = get_enum(ccamera, "aperture_type");

if(aperture_type == 1) {		if(aperture_type == 1) {
float fstop = RNA_float_get(&ccamera, "aperture_fstop");		float fstop = RNA_float_get(&ccamera, "aperture_fstop");
fstop = max(fstop, 1e-5f);		fstop = max(fstop, 1e-5f);

if(bcam->type == CAMERA_ORTHOGRAPHIC)		if(bcam->type == CAMERA_ORTHOGRAPHIC)
bcam->aperturesize = 1.0f/(2.0f*fstop);		bcam->aperturesize = 1.0f/(2.0f*fstop);
else		else
bcam->aperturesize = (bcam->lens1e-3f)/(2.0ffstop);		bcam->aperturesize = (bcam->lens1e-3f)/(2.0ffstop);
}		}
else		else
bcam->aperturesize = RNA_float_get(&ccamera, "aperture_size");		bcam->aperturesize = RNA_float_get(&ccamera, "aperture_size");

bcam->apertureblades = RNA_int_get(&ccamera, "aperture_blades");		bcam->apertureblades = RNA_int_get(&ccamera, "aperture_blades");
bcam->aperturerotation = RNA_float_get(&ccamera, "aperture_rotation");		bcam->aperturerotation = RNA_float_get(&ccamera, "aperture_rotation");
bcam->focaldistance = blender_camera_focal_distance(b_engine, b_ob, b_camera);		bcam->focaldistance = blender_camera_focal_distance(b_engine, b_ob, b_camera, bcam);
bcam->aperture_ratio = RNA_float_get(&ccamera, "aperture_ratio");		bcam->aperture_ratio = RNA_float_get(&ccamera, "aperture_ratio");

bcam->shift.x = b_engine.camera_shift_x(b_ob);		bcam->shift.x = b_engine.camera_shift_x(b_ob, bcam->use_spherical_stereo);
bcam->shift.y = b_camera.shift_y();		bcam->shift.y = b_camera.shift_y();

bcam->sensor_width = b_camera.sensor_width();		bcam->sensor_width = b_camera.sensor_width();
bcam->sensor_height = b_camera.sensor_height();		bcam->sensor_height = b_camera.sensor_height();

if(b_camera.sensor_fit() == BL::Camera::sensor_fit_AUTO)		if(b_camera.sensor_fit() == BL::Camera::sensor_fit_AUTO)
bcam->sensor_fit = BlenderCamera::AUTO;		bcam->sensor_fit = BlenderCamera::AUTO;
else if(b_camera.sensor_fit() == BL::Camera::sensor_fit_HORIZONTAL)		else if(b_camera.sensor_fit() == BL::Camera::sensor_fit_HORIZONTAL)
▲ Show 20 Lines • Show All 125 Lines • ▼ Show 20 Lines	if(viewplane != NULL) {
viewplane->left += dx;		viewplane->left += dx;
viewplane->right += dx;		viewplane->right += dx;
viewplane->bottom += dy;		viewplane->bottom += dy;
viewplane->top += dy;		viewplane->top += dy;
}		}
}		}
}		}

static void blender_camera_sync(Camera cam, BlenderCamera bcam, int width, int height)		static void blender_camera_sync(Camera cam, BlenderCamera bcam, int width, int height, const char *viewname)
{		{
/* copy camera to compare later */		/* copy camera to compare later */
Camera prevcam = *cam;		Camera prevcam = *cam;
float aspectratio, sensor_size;		float aspectratio, sensor_size;

/* viewplane */		/* viewplane */
blender_camera_viewplane(bcam, width, height,		blender_camera_viewplane(bcam, width, height,
&cam->viewplane, &aspectratio, &sensor_size);		&cam->viewplane, &aspectratio, &sensor_size);
Show All 40 Lines	static void blender_camera_sync(Camera cam, BlenderCamera bcam, int width, int height, const char *viewname)
cam->fisheye_fov = bcam->fisheye_fov;		cam->fisheye_fov = bcam->fisheye_fov;
cam->fisheye_lens = bcam->fisheye_lens;		cam->fisheye_lens = bcam->fisheye_lens;
cam->latitude_min = bcam->latitude_min;		cam->latitude_min = bcam->latitude_min;
cam->latitude_max = bcam->latitude_max;		cam->latitude_max = bcam->latitude_max;

cam->longitude_min = bcam->longitude_min;		cam->longitude_min = bcam->longitude_min;
cam->longitude_max = bcam->longitude_max;		cam->longitude_max = bcam->longitude_max;

		/* panorama stereo */
		cam->interocular_distance = bcam->interocular_distance;
		cam->convergence_distance = bcam->convergence_distance;
		cam->use_spherical_stereo = bcam->use_spherical_stereo;

		if(cam->use_spherical_stereo) {
		if(strcmp(viewname, "left") == 0)
		cam->stereo_eye = Camera::STEREO_LEFT;
		sergeyUnsubmitted Not Done Inline Actions Think we can avoid exposing eyes to the underlying camera classes. See comments below in the kernel. sergey: Think we can avoid exposing eyes to the underlying camera classes. See comments below in the…
		else if(strcmp(viewname, "right") == 0)
		cam->stereo_eye = Camera::STEREO_RIGHT;
		else
		cam->stereo_eye = Camera::STEREO_NONE;
		}

/* anamorphic lens bokeh */		/* anamorphic lens bokeh */
cam->aperture_ratio = bcam->aperture_ratio;		cam->aperture_ratio = bcam->aperture_ratio;

/* perspective */		/* perspective */
cam->fov = 2.0f * atanf((0.5f * sensor_size) / bcam->lens / aspectratio);		cam->fov = 2.0f * atanf((0.5f * sensor_size) / bcam->lens / aspectratio);
cam->focaldistance = bcam->focaldistance;		cam->focaldistance = bcam->focaldistance;
cam->aperturesize = bcam->aperturesize;		cam->aperturesize = bcam->aperturesize;
cam->blades = bcam->apertureblades;		cam->blades = bcam->apertureblades;
Show All 25 Lines	static void blender_camera_sync(Camera cam, BlenderCamera bcam, int width, int height, const char *viewname)
if(cam->modified(prevcam))		if(cam->modified(prevcam))
cam->tag_update();		cam->tag_update();
}		}

/* Sync Render Camera */		/* Sync Render Camera */

void BlenderSync::sync_camera(BL::RenderSettings& b_render,		void BlenderSync::sync_camera(BL::RenderSettings& b_render,
BL::Object& b_override,		BL::Object& b_override,
int width, int height)		int width, int height,
		const char *viewname)
{		{
BlenderCamera bcam;		BlenderCamera bcam;
blender_camera_init(&bcam, b_render);		blender_camera_init(&bcam, b_render);

/* pixel aspect */		/* pixel aspect */
bcam.pixelaspect.x = b_render.pixel_aspect_x();		bcam.pixelaspect.x = b_render.pixel_aspect_x();
bcam.pixelaspect.y = b_render.pixel_aspect_y();		bcam.pixelaspect.y = b_render.pixel_aspect_y();
bcam.shuttertime = b_render.motion_blur_shutter();		bcam.shuttertime = b_render.motion_blur_shutter();
Show All 26 Lines	void BlenderSync::sync_camera(BL::RenderSettings& b_render,
BL::Object b_ob = b_scene.camera();		BL::Object b_ob = b_scene.camera();

if(b_override)		if(b_override)
b_ob = b_override;		b_ob = b_override;

if(b_ob) {		if(b_ob) {
BL::Array<float, 16> b_ob_matrix;		BL::Array<float, 16> b_ob_matrix;
blender_camera_from_object(&bcam, b_engine, b_ob);		blender_camera_from_object(&bcam, b_engine, b_ob);
b_engine.camera_model_matrix(b_ob, b_ob_matrix);		b_engine.camera_model_matrix(b_ob, bcam.use_spherical_stereo, b_ob_matrix);
bcam.matrix = get_transform(b_ob_matrix);		bcam.matrix = get_transform(b_ob_matrix);
}		}

/* sync */		/* sync */
Camera *cam = scene->camera;		Camera *cam = scene->camera;
blender_camera_sync(cam, &bcam, width, height);		blender_camera_sync(cam, &bcam, width, height, viewname);
}		}

void BlenderSync::sync_camera_motion(BL::RenderSettings& b_render,		void BlenderSync::sync_camera_motion(BL::RenderSettings& b_render,
BL::Object& b_ob,		BL::Object& b_ob,
		sergeyUnsubmitted Not Done Inline Actions Some API questions. Is it always limited to "left" and "right"? Is there some non-string constants to distinguish those two? sergey: Some API questions. Is it always limited to "left" and "right"? Is there some non-string…
		dfelintoAuthorUnsubmitted Not Done Inline Actions It is always limited to "left" and "right", and we have the constants in Blender (STEREO_LEFT_NAME/STEREO_RIGHT_NAME). I wasn't sure how to proceed here (whether to expose the Blender constants to Cycles, or to re-define them here) dfelinto: It is always limited to "left" and "right", and we have the constants in Blender…
		sergeyUnsubmitted Not Done Inline Actions That's a bit weird: Cycles sets current view to the render engine, so in theory it knows which view to use without querying the engine View is set from the render loop Camera is sync before render loop So seems would have some redundant updates. sergey: That's a bit weird: - Cycles sets current view to the render engine, so in theory it knows…
int width, int height,		int width, int height,
float motion_time)		float motion_time)
		sergeyUnsubmitted Not Done Inline Actions Would it make sense to have some sort of `view.type` which could be `{VIEW_LEFT, VIEW_RIGHT, VIEW_CUSTOM}`? sergey: Would it make sense to have some sort of `view.type` which could be `{VIEW_LEFT, VIEW_RIGHT…
{		{
if(!b_ob)		if(!b_ob)
return;		return;

Camera *cam = scene->camera;		Camera *cam = scene->camera;
BL::Array<float, 16> b_ob_matrix;		BL::Array<float, 16> b_ob_matrix;
b_engine.camera_model_matrix(b_ob, b_ob_matrix);		b_engine.camera_model_matrix(b_ob, cam->use_spherical_stereo, b_ob_matrix);
Transform tfm = get_transform(b_ob_matrix);		Transform tfm = get_transform(b_ob_matrix);
		sergeyUnsubmitted Not Done Inline Actions That' wrong. Camera is to be tagged for update only if it was modified, which is already checked in `blender_camera_sync`. So my guess this code belongs to other place of the file and no force tag is needed. sergey: That' wrong. Camera is to be tagged for update only if it was modified, which is already…
tfm = blender_camera_matrix(tfm, cam->type, cam->panorama_type);		tfm = blender_camera_matrix(tfm, cam->type, cam->panorama_type);

if(tfm != cam->matrix) {		if(tfm != cam->matrix) {
VLOG(1) << "Camera " << b_ob.name() << " motion detected.";		VLOG(1) << "Camera " << b_ob.name() << " motion detected.";
if(motion_time == -1.0f) {		if(motion_time == -1.0f) {
cam->motion.pre = tfm;		cam->motion.pre = tfm;
cam->use_motion = true;		cam->use_motion = true;
}		}
▲ Show 20 Lines • Show All 251 Lines • ▼ Show 20 Lines	blender_camera_from_view(&bcam,
width, height);		width, height);
blender_camera_border(&bcam,		blender_camera_border(&bcam,
b_engine,		b_engine,
b_render_settings,		b_render_settings,
b_scene,		b_scene,
b_v3d,		b_v3d,
b_rv3d,		b_rv3d,
width, height);		width, height);
blender_camera_sync(scene->camera, &bcam, width, height);		blender_camera_sync(scene->camera, &bcam, width, height, "");
}		}

BufferParams BlenderSync::get_buffer_params(BL::RenderSettings& b_render,		BufferParams BlenderSync::get_buffer_params(BL::RenderSettings& b_render,
BL::SpaceView3D& b_v3d,		BL::SpaceView3D& b_v3d,
BL::RegionView3D& b_rv3d,		BL::RegionView3D& b_rv3d,
Camera *cam,		Camera *cam,
int width, int height)		int width, int height)
{		{
Show All 34 Lines