kannonier8/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

Camera: some code refactoring, use an intermediate CameraParams struct instead

Browse Source 
of long list of variables everywhere. Intention is to also let 3d view use this
eventually, instead of duplicating code.
This commit is contained in:
Brecht Van Lommel 2011-11-18 15:52:00 +00:00
parent 02ce6fd59c
commit 539c94a051
11 changed files with 272 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
source/blender/blenkernel/BKE_camera.h
View File

@ -36,6 +36,8 @@
extern "C" { extern "C" {
#endif #endif
#include "DNA_vec_types.h"
struct Camera; struct Camera;
struct Object; struct Object;
struct RenderData; struct RenderData;
@ -48,16 +50,54 @@ struct Camera *copy_camera(struct Camera *cam);
void make_local_camera(struct Camera *cam); void make_local_camera(struct Camera *cam);
void free_camera(struct Camera *ca); void free_camera(struct Camera *ca);
float dof_camera(struct Object *ob); /* Camera Object */
void object_camera_mode(struct RenderData *rd, struct Object *camera); float object_camera_dof_distance(struct Object *ob);
void object_camera_intrinsics(struct Object *camera, struct Camera **cam_r, short *is_ortho, float *shiftx, float *shifty, void object_camera_mode(struct RenderData *rd, struct Object *ob);
float *clipsta, float *clipend, float *lens, float *sensor_x, float *sensor_y, short *sensor_fit);
void object_camera_matrix( /* Camera Parameters:
struct RenderData *rd, struct Object *camera, int winx, int winy, short field_second, *
float winmat[][4], struct rctf *viewplane, float *clipsta, float *clipend, float *lens, * Intermediate struct for storing camera parameters from various sources,
float *sensor_x, float *sensor_y, short *sensor_fit, float *ycor, * to unify computation of viewplane, window matrix, ... */
float *viewdx, float *viewdy);
typedef struct CameraParams {
/* lens */
int is_ortho;
float lens;
float ortho_scale;
float shiftx;
float shifty;
/* sensor */
float sensor_x;
float sensor_y;
int sensor_fit;
/* clipping */
float clipsta;
float clipend;
/* fields */
int use_fields;
int field_second;
int field_odd;
/* compute result */
float ycor;
float viewdx;
float viewdy;
rctf viewplane;
float winmat[4][4];
} CameraParams;
void camera_params_init(CameraParams *params);
void camera_params_from_object(CameraParams *params, struct Object *camera);
void camera_params_compute(CameraParams *params, int winx, int winy, float aspx, float aspy);
/* Camera View Frame */
void camera_view_frame_ex(struct Scene *scene, struct Camera *camera, float drawsize, const short do_clip, const float scale[3], void camera_view_frame_ex(struct Scene *scene, struct Camera *camera, float drawsize, const short do_clip, const float scale[3],
float r_asp[2], float r_shift[2], float *r_drawsize, float r_vec[4][3]); float r_asp[2], float r_shift[2], float *r_drawsize, float r_vec[4][3]);

254
source/blender/blenkernel/intern/camera.c
View File

@ -46,6 +46,8 @@
#include "BKE_library.h" #include "BKE_library.h"
#include "BKE_main.h" #include "BKE_main.h"
/****************************** Camera Datablock *****************************/
void *add_camera(const char *name) void *add_camera(const char *name)
{ {
Camera *cam; Camera *cam;
@ -121,8 +123,26 @@ void make_local_camera(Camera *cam)
} }
} }
void free_camera(Camera *ca)
{
BKE_free_animdata((ID *)ca);
}
/******************************** Camera Usage *******************************/
void object_camera_mode(RenderData *rd, Object *cam_ob)
{
rd->mode &= ~(R_ORTHO|R_PANORAMA);
if(cam_ob && cam_ob->type==OB_CAMERA) {
Camera *cam= cam_ob->data;
if(cam->type == CAM_ORTHO) rd->mode |= R_ORTHO;
if(cam->flag & CAM_PANORAMA) rd->mode |= R_PANORAMA;
}
}
/* get the camera's dof value, takes the dof object into account */ /* get the camera's dof value, takes the dof object into account */
float dof_camera(Object *ob) float object_camera_dof_distance(Object *ob)
{ {
Camera *cam = (Camera *)ob->data; Camera *cam = (Camera *)ob->data;
if (ob->type != OB_CAMERA) if (ob->type != OB_CAMERA)
@ -141,175 +161,155 @@ float dof_camera(Object *ob)
return cam->YF_dofdist; return cam->YF_dofdist;
} }
void free_camera(Camera *ca) /******************************** Camera Params *******************************/
static int camera_sensor_fit(int sensor_fit, float sizex, float sizey)
{ {
BKE_free_animdata((ID *)ca); if(sensor_fit == CAMERA_SENSOR_FIT_AUTO) {
if(sizex >= sizey)
return CAMERA_SENSOR_FIT_HOR;
else
return CAMERA_SENSOR_FIT_VERT;
}
return sensor_fit;
} }
void object_camera_mode(RenderData *rd, Object *camera) void camera_params_init(CameraParams *params)
{ {
rd->mode &= ~(R_ORTHO|R_PANORAMA); memset(params, 0, sizeof(CameraParams));
if(camera && camera->type==OB_CAMERA) {
Camera *cam= camera->data; /* defaults */
if(cam->type == CAM_ORTHO) rd->mode |= R_ORTHO; params->sensor_x= DEFAULT_SENSOR_WIDTH;
if(cam->flag & CAM_PANORAMA) rd->mode |= R_PANORAMA; params->sensor_y= DEFAULT_SENSOR_HEIGHT;
} params->sensor_fit= CAMERA_SENSOR_FIT_AUTO;
} }
void object_camera_intrinsics(Object *camera, Camera **cam_r, short *is_ortho, float *shiftx, float *shifty, void camera_params_from_object(CameraParams *params, Object *ob)
float *clipsta, float *clipend, float *lens, float *sensor_x, float *sensor_y, short *sensor_fit)
{ {
Camera *cam= NULL; if(!ob)
return;
(*shiftx)= 0.0f; if(ob->type==OB_CAMERA) {
(*shifty)= 0.0f; /* camera object */
Camera *cam= ob->data;
(*sensor_x)= DEFAULT_SENSOR_WIDTH; if(cam->type == CAM_ORTHO)
(*sensor_y)= DEFAULT_SENSOR_HEIGHT; params->is_ortho= TRUE;
(*sensor_fit)= CAMERA_SENSOR_FIT_AUTO; params->lens= cam->lens;
params->ortho_scale= cam->ortho_scale;
if(camera->type==OB_CAMERA) { params->shiftx= cam->shiftx;
cam= camera->data; params->shifty= cam->shifty;
if(cam->type == CAM_ORTHO) { params->sensor_x= cam->sensor_x;
*is_ortho= TRUE; params->sensor_y= cam->sensor_y;
} params->sensor_fit= cam->sensor_fit;
/* solve this too... all time depending stuff is in convertblender.c? params->clipsta= cam->clipsta;
* Need to update the camera early because it's used for projection matrices params->clipend= cam->clipend;
* and other stuff BEFORE the animation update loop is done
* */
#if 0 // XXX old animation system
if(cam->ipo) {
calc_ipo(cam->ipo, frame_to_float(re->scene, re->r.cfra));
execute_ipo(&cam->id, cam->ipo);
}
#endif // XXX old animation system
(*shiftx)=cam->shiftx;
(*shifty)=cam->shifty;
(*lens)= cam->lens;
(*sensor_x)= cam->sensor_x;
(*sensor_y)= cam->sensor_y;
(*clipsta)= cam->clipsta;
(*clipend)= cam->clipend;
(*sensor_fit)= cam->sensor_fit;
} }
else if(camera->type==OB_LAMP) { else if(ob->type==OB_LAMP) {
Lamp *la= camera->data; /* lamp object */
Lamp *la= ob->data;
float fac= cosf((float)M_PI*la->spotsize/360.0f); float fac= cosf((float)M_PI*la->spotsize/360.0f);
float phi= acos(fac); float phi= acos(fac);
(*lens)= 16.0f*fac/sinf(phi); params->lens= 16.0f*fac/sinf(phi);
if((*lens)==0.0f) if(params->lens==0.0f)
(*lens)= 35.0f; params->lens= 35.0f;
(*clipsta)= la->clipsta;
(*clipend)= la->clipend;
}
else { /* envmap exception... */;
if((*lens)==0.0f) /* is this needed anymore? */
(*lens)= 16.0f;
if((*clipsta)==0.0f || (*clipend)==0.0f) { params->clipsta= la->clipsta;
(*clipsta)= 0.1f; params->clipend= la->clipend;
(*clipend)= 1000.0f;
}
} }
(*cam_r)= cam;
} }
/* 'lens' may be set for envmap only */ void camera_params_compute(CameraParams *params, int winx, int winy, float xasp, float yasp)
void object_camera_matrix(
RenderData *rd, Object *camera, int winx, int winy, short field_second,
float winmat[][4], rctf *viewplane, float *clipsta, float *clipend, float *lens,
float *sensor_x, float *sensor_y, short *sensor_fit, float *ycor,
float *viewdx, float *viewdy)
{ {
Camera *cam=NULL; rctf viewplane;
float pixsize; float pixsize, winside, viewfac;
float shiftx=0.0, shifty=0.0, winside, viewfac; int sensor_fit;
short is_ortho= FALSE;
/* question mark */ /* fields rendering */
(*ycor)= rd->yasp / rd->xasp; params->ycor= yasp/xasp;
if(rd->mode & R_FIELDS) if(params->use_fields)
(*ycor) *= 2.0f; params->ycor *= 2.0f;
object_camera_intrinsics(camera, &cam, &is_ortho, &shiftx, &shifty, clipsta, clipend, lens, sensor_x, sensor_y, sensor_fit); /* determine sensor fit */
sensor_fit = camera_sensor_fit(params->sensor_fit, xasp*winx, yasp*winy);
/* ortho only with camera available */ if(params->is_ortho) {
if(cam && is_ortho) { /* orthographic camera, scale == 1.0 means exact 1 to 1 mapping */
if((*sensor_fit)==CAMERA_SENSOR_FIT_AUTO) { if(sensor_fit==CAMERA_SENSOR_FIT_HOR)
if(rd->xasp*winx >= rd->yasp*winy) viewfac= winx;
else viewfac= (*ycor) * winy;
}
else if((*sensor_fit)==CAMERA_SENSOR_FIT_HOR) {
viewfac= winx; viewfac= winx;
} else
else { /* if((*sensor_fit)==CAMERA_SENSOR_FIT_VERT) { */ viewfac= params->ycor * winy;
viewfac= (*ycor) * winy;
}
/* ortho_scale == 1.0 means exact 1 to 1 mapping */ pixsize= params->ortho_scale/viewfac;
pixsize= cam->ortho_scale/viewfac;
} }
else { else {
if((*sensor_fit)==CAMERA_SENSOR_FIT_AUTO) { /* perspective camera */
if(rd->xasp*winx >= rd->yasp*winy) viewfac= ((*lens) * winx) / (*sensor_x); float sensor_size;
else viewfac= (*ycor) * ((*lens) * winy) / (*sensor_x);
}
else if((*sensor_fit)==CAMERA_SENSOR_FIT_HOR) {
viewfac= ((*lens) * winx) / (*sensor_x);
}
else { /* if((*sensor_fit)==CAMERA_SENSOR_FIT_VERT) { */
viewfac= ((*lens) * winy) / (*sensor_y);
}
pixsize= (*clipsta) / viewfac; /* note for auto fit sensor_x is both width and height */
if(params->sensor_fit == CAMERA_SENSOR_FIT_VERT)
sensor_size= params->sensor_y;
else
sensor_size= params->sensor_x;
if(sensor_fit == CAMERA_SENSOR_FIT_HOR)
viewfac= (params->lens * winx) / sensor_size;
else
viewfac= params->ycor * (params->lens * winy) / sensor_size;
pixsize= params->clipsta/viewfac;
} }
/* viewplane fully centered, zbuffer fills in jittered between -.5 and +.5 */ /* compute view plane:
winside= MAX2(winx, winy); * fully centered, zbuffer fills in jittered between -.5 and +.5 */
if(sensor_fit == CAMERA_SENSOR_FIT_HOR)
winside= winx;
else
winside= winy;
if(cam) { viewplane.xmin= -0.5f*(float)winx + params->shiftx*winside;
if(cam->sensor_fit==CAMERA_SENSOR_FIT_HOR) viewplane.ymin= -0.5f*params->ycor*(float)winy + params->shifty*winside;
winside= winx; viewplane.xmax= 0.5f*(float)winx + params->shiftx*winside;
else if(cam->sensor_fit==CAMERA_SENSOR_FIT_VERT) viewplane.ymax= 0.5f*params->ycor*(float)winy + params->shifty*winside;
winside= winy;
}
viewplane->xmin= -0.5f*(float)winx + shiftx*winside; if(params->field_second) {
viewplane->ymin= -0.5f*(*ycor)*(float)winy + shifty*winside; if(params->field_odd) {
viewplane->xmax= 0.5f*(float)winx + shiftx*winside; viewplane.ymin-= 0.5f * params->ycor;
viewplane->ymax= 0.5f*(*ycor)*(float)winy + shifty*winside; viewplane.ymax-= 0.5f * params->ycor;
if(field_second) {
if(rd->mode & R_ODDFIELD) {
viewplane->ymin-= 0.5f * (*ycor);
viewplane->ymax-= 0.5f * (*ycor);
} }
else { else {
viewplane->ymin+= 0.5f * (*ycor); viewplane.ymin+= 0.5f * params->ycor;
viewplane->ymax+= 0.5f * (*ycor); viewplane.ymax+= 0.5f * params->ycor;
} }
} }
/* the window matrix is used for clipping, and not changed during OSA steps */ /* the window matrix is used for clipping, and not changed during OSA steps */
/* using an offset of +0.5 here would give clip errors on edges */ /* using an offset of +0.5 here would give clip errors on edges */
viewplane->xmin *= pixsize; viewplane.xmin *= pixsize;
viewplane->xmax *= pixsize; viewplane.xmax *= pixsize;
viewplane->ymin *= pixsize; viewplane.ymin *= pixsize;
viewplane->ymax *= pixsize; viewplane.ymax *= pixsize;
(*viewdx)= pixsize; params->viewdx= pixsize;
(*viewdy)= (*ycor) * pixsize; params->viewdy= params->ycor * pixsize;
if(is_ortho) if(params->is_ortho)
orthographic_m4(winmat, viewplane->xmin, viewplane->xmax, viewplane->ymin, viewplane->ymax, *clipsta, *clipend); orthographic_m4(params->winmat, viewplane.xmin, viewplane.xmax,
viewplane.ymin, viewplane.ymax, params->clipsta, params->clipend);
else else
perspective_m4(winmat, viewplane->xmin, viewplane->xmax, viewplane->ymin, viewplane->ymax, *clipsta, *clipend); perspective_m4(params->winmat, viewplane.xmin, viewplane.xmax,
viewplane.ymin, viewplane.ymax, params->clipsta, params->clipend);
params->viewplane= viewplane;
} }
/***************************** Camera View Frame *****************************/
void camera_view_frame_ex(Scene *scene, Camera *camera, float drawsize, const short do_clip, const float scale[3], void camera_view_frame_ex(Scene *scene, Camera *camera, float drawsize, const short do_clip, const float scale[3],
float r_asp[2], float r_shift[2], float *r_drawsize, float r_vec[4][3]) float r_asp[2], float r_shift[2], float *r_drawsize, float r_vec[4][3])
{ {
@ -331,7 +331,7 @@ void camera_view_frame_ex(Scene *scene, Camera *camera, float drawsize, const sh
r_asp[1]= aspy / aspx; r_asp[1]= aspy / aspx;
} }
} }
else if(camera->sensor_fit==CAMERA_SENSOR_FIT_AUTO) { else if(camera->sensor_fit==CAMERA_SENSOR_FIT_HOR) {
r_asp[0]= aspx / aspy; r_asp[0]= aspx / aspy;
r_asp[1]= 1.0; r_asp[1]= 1.0;
} }

27
source/blender/blenkernel/intern/constraint.c
View File

@ -3988,7 +3988,7 @@ static void followtrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase
MovieTrackingMarker *marker; MovieTrackingMarker *marker;
float vec[3], disp[3], axis[3], mat[4][4]; float vec[3], disp[3], axis[3], mat[4][4];
float aspect= (scene->r.xsch*scene->r.xasp) / (scene->r.ysch*scene->r.yasp); float aspect= (scene->r.xsch*scene->r.xasp) / (scene->r.ysch*scene->r.yasp);
float sensor_x, sensor_y, lens, len, d, ortho_scale= 1.0f; float len, d;
where_is_object_mat(scene, camob, mat); where_is_object_mat(scene, camob, mat);
@ -4006,23 +4006,20 @@ static void followtrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase
len= len_v3(disp); len= len_v3(disp);
if (len > FLT_EPSILON) { if (len > FLT_EPSILON) {
float pos[2], rmat[4][4], shiftx= 0.0f, shifty= 0.0f, clipsta= 0.0f, clipend= 0.0f; CameraParams params;
short is_ortho= 0, sensor_fit= CAMERA_SENSOR_FIT_AUTO; float pos[2], rmat[4][4];
Camera *cam= NULL;
user.framenr= scene->r.cfra; user.framenr= scene->r.cfra;
marker= BKE_tracking_get_marker(track, user.framenr); marker= BKE_tracking_get_marker(track, user.framenr);
add_v2_v2v2(pos, marker->pos, track->offset); add_v2_v2v2(pos, marker->pos, track->offset);
object_camera_intrinsics(camob, &cam, &is_ortho, &shiftx, &shifty, &clipsta, &clipend, &lens, &sensor_x, &sensor_y, &sensor_fit); camera_params_init(&params);
camera_params_from_object(&params, camob);
if (is_ortho) {
if (cam) if (params.is_ortho) {
ortho_scale= cam->ortho_scale; vec[0]= params.ortho_scale * (pos[0]-0.5f+params.shiftx);
vec[1]= params.ortho_scale * (pos[1]-0.5f+params.shifty);
vec[0]= ortho_scale * (pos[0]-0.5f+shiftx);
vec[1]= ortho_scale * (pos[1]-0.5f+shifty);
vec[2]= -len; vec[2]= -len;
if (aspect > 1.0f) vec[1] /= aspect; if (aspect > 1.0f) vec[1] /= aspect;
@ -4037,10 +4034,10 @@ static void followtrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase
copy_v3_v3(cob->matrix[3], disp); copy_v3_v3(cob->matrix[3], disp);
} }
else { else {
d= (len*sensor_x) / (2.0f*lens); d= (len*params.sensor_x) / (2.0f*params.lens);
vec[0]= d*(2.0f*(pos[0]+shiftx)-1.0f); vec[0]= d*(2.0f*(pos[0]+params.shiftx)-1.0f);
vec[1]= d*(2.0f*(pos[1]+shifty)-1.0f); vec[1]= d*(2.0f*(pos[1]+params.shifty)-1.0f);
vec[2]= -len; vec[2]= -len;
if (aspect > 1.0f) vec[1] /= aspect; if (aspect > 1.0f) vec[1] /= aspect;

24
source/blender/editors/sculpt_paint/paint_image.c
View File

@ -3057,25 +3057,23 @@ static void project_paint_begin(ProjPaintState *ps)
invert_m4_m4(viewinv, viewmat); invert_m4_m4(viewinv, viewmat);
} }
else if (ps->source==PROJ_SRC_IMAGE_CAM) { else if (ps->source==PROJ_SRC_IMAGE_CAM) {
Object *camera= ps->scene->camera; Object *cam_ob= ps->scene->camera;
CameraParams params;
/* dont actually use these */
float _viewdx, _viewdy, _ycor, _lens=0.0f, _sensor_x=DEFAULT_SENSOR_WIDTH, _sensor_y= DEFAULT_SENSOR_HEIGHT;
short _sensor_fit= CAMERA_SENSOR_FIT_AUTO;
rctf _viewplane;
/* viewmat & viewinv */ /* viewmat & viewinv */
copy_m4_m4(viewinv, ps->scene->camera->obmat); copy_m4_m4(viewinv, cam_ob->obmat);
normalize_m4(viewinv); normalize_m4(viewinv);
invert_m4_m4(viewmat, viewinv); invert_m4_m4(viewmat, viewinv);
/* camera winmat */ /* window matrix, clipping and ortho */
object_camera_mode(&ps->scene->r, camera); camera_params_init(&params);
object_camera_matrix(&ps->scene->r, camera, ps->winx, ps->winy, 0, camera_params_from_object(&params, cam_ob);
winmat, &_viewplane, &ps->clipsta, &ps->clipend, camera_params_compute(&params, ps->winx, ps->winy, 1.0f, 1.0f); /* XXX aspect? */
&_lens, &_sensor_x, &_sensor_y, &_sensor_fit, &_ycor, &_viewdx, &_viewdy);
ps->is_ortho= (ps->scene->r.mode & R_ORTHO) ? 1 : 0; copy_m4_m4(winmat, params.winmat);
ps->clipsta= params.clipsta;
ps->clipend= params.clipend;
ps->is_ortho= params.is_ortho;
} }
/* same as view3d_get_object_project_mat */ /* same as view3d_get_object_project_mat */

2
source/blender/editors/space_view3d/drawobject.c
View File

@ -1693,7 +1693,7 @@ static void drawcamera(Scene *scene, View3D *v3d, RegionView3D *rv3d, Base *base
if(cam->flag & CAM_SHOWLIMITS) { if(cam->flag & CAM_SHOWLIMITS) {
draw_limit_line(cam->clipsta, cam->clipend, 0x77FFFF); draw_limit_line(cam->clipsta, cam->clipend, 0x77FFFF);
/* qdn: was yafray only, now also enabled for Blender to be used with defocus composit node */ /* qdn: was yafray only, now also enabled for Blender to be used with defocus composit node */
draw_focus_cross(dof_camera(ob), cam->drawsize); draw_focus_cross(object_camera_dof_distance(ob), cam->drawsize);
} }
wrld= scene->world; wrld= scene->world;

26
source/blender/editors/space_view3d/view3d_draw.c
View File

@ -2485,15 +2485,13 @@ ImBuf *ED_view3d_draw_offscreen_imbuf(Scene *scene, View3D *v3d, ARegion *ar, in
/* render 3d view */ /* render 3d view */
if(rv3d->persp==RV3D_CAMOB && v3d->camera) { if(rv3d->persp==RV3D_CAMOB && v3d->camera) {
float winmat[4][4]; CameraParams params;
float _clipsta, _clipend, _lens, _yco, _dx, _dy, _sensor_x= DEFAULT_SENSOR_WIDTH, _sensor_y= DEFAULT_SENSOR_HEIGHT;
short _sensor_fit= CAMERA_SENSOR_FIT_AUTO;
rctf _viewplane;
object_camera_matrix(&scene->r, v3d->camera, sizex, sizey, 0, winmat, &_viewplane, &_clipsta, &_clipend, &_lens, camera_params_init(&params);
&_sensor_x, &_sensor_y, &_sensor_fit, &_yco, &_dx, &_dy); camera_params_from_object(&params, v3d->camera);
camera_params_compute(&params, sizex, sizey, scene->r.xasp, scene->r.yasp);
ED_view3d_draw_offscreen(scene, v3d, ar, sizex, sizey, NULL, winmat); ED_view3d_draw_offscreen(scene, v3d, ar, sizex, sizey, NULL, params.winmat);
} }
else { else {
ED_view3d_draw_offscreen(scene, v3d, ar, sizex, sizey, NULL, NULL); ED_view3d_draw_offscreen(scene, v3d, ar, sizex, sizey, NULL, NULL);
@ -2546,10 +2544,16 @@ ImBuf *ED_view3d_draw_offscreen_imbuf_simple(Scene *scene, Object *camera, int w
invert_m4_m4(rv3d.viewmat, rv3d.viewinv); invert_m4_m4(rv3d.viewmat, rv3d.viewinv);
{ {
float _yco, _dx, _dy, _sensor_x= DEFAULT_SENSOR_WIDTH, _sensor_y= DEFAULT_SENSOR_HEIGHT; CameraParams params;
short _sensor_fit= CAMERA_SENSOR_FIT_AUTO;
rctf _viewplane; camera_params_init(&params);
object_camera_matrix(&scene->r, v3d.camera, width, height, 0, rv3d.winmat, &_viewplane, &v3d.near, &v3d.far, &v3d.lens, &_sensor_x, &_sensor_y, &_sensor_fit, &_yco, &_dx, &_dy); camera_params_from_object(&params, v3d.camera);
camera_params_compute(&params, width, height, scene->r.xasp, scene->r.yasp);
copy_m4_m4(rv3d.winmat, params.winmat);
v3d.near= params.clipsta;
v3d.far= params.clipend;
v3d.lens= params.lens;
} }
mul_m4_m4m4(rv3d.persmat, rv3d.viewmat, rv3d.winmat); mul_m4_m4m4(rv3d.persmat, rv3d.viewmat, rv3d.winmat);

2
source/blender/nodes/composite/nodes/node_composite_defocus.c
View File

@ -261,7 +261,7 @@ static void defocus_blur(bNode *node, CompBuf *new, CompBuf *img, CompBuf *zbuf,
if (camob && camob->type==OB_CAMERA) { if (camob && camob->type==OB_CAMERA) {
Camera* cam = (Camera*)camob->data; Camera* cam = (Camera*)camob->data;
cam_lens = cam->lens; cam_lens = cam->lens;
cam_fdist = dof_camera(camob); cam_fdist = object_camera_dof_distance(camob);
if (cam_fdist==0.0f) cam_fdist = 1e10f; /* if the dof is 0.0 then set it be be far away */ if (cam_fdist==0.0f) cam_fdist = 1e10f; /* if the dof is 0.0 then set it be be far away */
cam_invfdist = 1.f/cam_fdist; cam_invfdist = 1.f/cam_fdist;
} }

1
source/blender/render/extern/include/RE_pipeline.h vendored
View File

@ -188,6 +188,7 @@ void RE_SetDispRect (struct Render *re, rcti *disprect);
/* set up the viewplane/perspective matrix, three choices */ /* set up the viewplane/perspective matrix, three choices */
struct Object *RE_GetCamera(struct Render *re); /* return camera override if set */ struct Object *RE_GetCamera(struct Render *re); /* return camera override if set */
void RE_SetCamera(struct Render *re, struct Object *camera); void RE_SetCamera(struct Render *re, struct Object *camera);
void RE_SetEnvmapCamera(struct Render *re, struct Object *cam_ob, float viewscale, float clipsta, float clipend);
void RE_SetWindow (struct Render *re, rctf *viewplane, float clipsta, float clipend); void RE_SetWindow (struct Render *re, rctf *viewplane, float clipsta, float clipend);
void RE_SetOrtho (struct Render *re, rctf *viewplane, float clipsta, float clipend); void RE_SetOrtho (struct Render *re, rctf *viewplane, float clipsta, float clipend);
void RE_SetPixelSize(struct Render *re, float pixsize); void RE_SetPixelSize(struct Render *re, float pixsize);

3
source/blender/render/intern/include/render_types.h
View File

@ -152,10 +152,7 @@ struct Render
int partx, party; int partx, party;
/* values for viewing */ /* values for viewing */
float lens;
float sensor_x, sensor_y; /* image sensor size, same variable in camera */
float ycor; /* (scene->xasp / scene->yasp), multiplied with 'winy' */ float ycor; /* (scene->xasp / scene->yasp), multiplied with 'winy' */
short sensor_fit;
float panophi, panosi, panoco, panodxp, panodxv; float panophi, panosi, panoco, panodxp, panodxv;

12
source/blender/render/intern/source/envmap.c
View File

@ -131,6 +131,7 @@ static void envmap_split_ima(EnvMap *env, ImBuf *ibuf)
static Render *envmap_render_copy(Render *re, EnvMap *env) static Render *envmap_render_copy(Render *re, EnvMap *env)
{ {
Render *envre; Render *envre;
float viewscale;
int cuberes; int cuberes;
envre= RE_NewRender("Envmap"); envre= RE_NewRender("Envmap");
@ -156,15 +157,8 @@ static Render *envmap_render_copy(Render *re, EnvMap *env)
envre->lay= re->lay; envre->lay= re->lay;
/* view stuff in env render */ /* view stuff in env render */
envre->lens= 16.0f; viewscale= (env->type == ENV_PLANE)? env->viewscale: 1.0f;
envre->sensor_x= 32.0f; RE_SetEnvmapCamera(envre, env->object, viewscale, env->clipsta, env->clipend);
if(env->type==ENV_PLANE)
envre->lens*= env->viewscale;
envre->ycor= 1.0f;
envre->clipsta= env->clipsta; /* render_scene_set_window() respects this for now */
envre->clipend= env->clipend;
RE_SetCamera(envre, env->object);
/* callbacks */ /* callbacks */
envre->display_draw= re->display_draw; envre->display_draw= re->display_draw;

57
source/blender/render/intern/source/initrender.c
View File

@ -451,15 +451,62 @@ struct Object *RE_GetCamera(Render *re)
return re->camera_override ? re->camera_override : re->scene->camera; return re->camera_override ? re->camera_override : re->scene->camera;
} }
static void re_camera_params_get(Render *re, CameraParams *params, Object *cam_ob)
{
copy_m4_m4(re->winmat, params->winmat);
re->clipsta= params->clipsta;
re->clipend= params->clipend;
re->ycor= params->ycor;
re->viewdx= params->viewdx;
re->viewdy= params->viewdy;
re->viewplane= params->viewplane;
object_camera_mode(&re->r, cam_ob);
}
void RE_SetEnvmapCamera(Render *re, Object *cam_ob, float viewscale, float clipsta, float clipend)
{
CameraParams params;
/* setup parameters */
camera_params_init(&params);
camera_params_from_object(&params, cam_ob);
params.lens= 16.0f*viewscale;
params.sensor_x= 32.0f;
params.sensor_y= 32.0f;
params.sensor_fit = CAMERA_SENSOR_FIT_AUTO;
params.clipsta= clipsta;
params.clipend= clipend;
/* compute matrix, viewplane, .. */
camera_params_compute(&params, re->winx, re->winy, 1.0f, 1.0f);
/* extract results */
re_camera_params_get(re, &params, cam_ob);
}
/* call this after InitState() */ /* call this after InitState() */
/* per render, there's one persistent viewplane. Parts will set their own viewplanes */ /* per render, there's one persistent viewplane. Parts will set their own viewplanes */
void RE_SetCamera(Render *re, Object *camera) void RE_SetCamera(Render *re, Object *cam_ob)
{ {
object_camera_mode(&re->r, camera); CameraParams params;
object_camera_matrix(&re->r, camera, re->winx, re->winy, re->flag & R_SEC_FIELD, /* setup parameters */
re->winmat, &re->viewplane, &re->clipsta, &re->clipend, camera_params_init(&params);
&re->lens, &re->sensor_x, &re->sensor_y, &re->sensor_fit, &re->ycor, &re->viewdx, &re->viewdy); camera_params_from_object(&params, cam_ob);
params.use_fields= (re->r.mode & R_FIELDS);
params.field_second= (re->flag & R_SEC_FIELD);
params.field_odd= (re->r.mode & R_ODDFIELD);
/* compute matrix, viewplane, .. */
camera_params_compute(&params, re->winx, re->winy, re->r.xasp, re->r.yasp);
/* extract results */
re_camera_params_get(re, &params, cam_ob);
} }
void RE_SetPixelSize(Render *re, float pixsize) void RE_SetPixelSize(Render *re, float pixsize)