diff --git a/source/blender/blenkernel/intern/scene.c b/source/blender/blenkernel/intern/scene.c index f5916fb17b0..aebfa54fe1e 100644 --- a/source/blender/blenkernel/intern/scene.c +++ b/source/blender/blenkernel/intern/scene.c @@ -172,6 +172,12 @@ Scene *add_scene(char *name) sce->r.posthue= 1.0; sce->r.postmul= 1.0; + sce->r.focus= 0.9; + sce->r.zgamma= 1.0; + sce->r.zsigma= 4.0; + sce->r.zblur= 10.0; + sce->r.zmin= 0.8; + sce->r.xplay= 640; sce->r.yplay= 480; sce->r.freqplay= 60; diff --git a/source/blender/blenloader/intern/readfile.c b/source/blender/blenloader/intern/readfile.c index e1c65dba344..ff3953296df 100644 --- a/source/blender/blenloader/intern/readfile.c +++ b/source/blender/blenloader/intern/readfile.c @@ -4641,6 +4641,13 @@ static void do_versions(Main *main) while(sce) { if(sce->r.postsat==0.0) sce->r.postsat= 1.0; + if(sce->r.zgamma==0.0) { + sce->r.focus= 0.9; + sce->r.zgamma= 1.0; + sce->r.zsigma= 4.0; + sce->r.zblur= 10.0; + sce->r.zmin= 0.8; + } sce= sce->id.next; } while(cam) { @@ -4701,15 +4708,6 @@ static void do_versions(Main *main) } } } - /*Camera *ca; - - for (ca= main->camera.first; ca; ca= ca->id.next) { - ca->focus= 0.9; - ca->zgamma= 1.0; - ca->zblur= 10.0; - ca->zmin= 0.8; - ca->flag |= CAM_AUTOFOCUS; - }*/ } /* don't forget to set version number in blender.c! */ diff --git a/source/blender/include/BIF_editview.h b/source/blender/include/BIF_editview.h index 1cbee01f99b..345f21cdb9e 100644 --- a/source/blender/include/BIF_editview.h +++ b/source/blender/include/BIF_editview.h @@ -35,6 +35,7 @@ struct Base; struct Object; +struct Camera; void arrows_move_cursor(unsigned short event); void borderselect(void); diff --git a/source/blender/include/butspace.h b/source/blender/include/butspace.h index 4b5f5a67258..755b5c127fa 100644 --- a/source/blender/include/butspace.h +++ b/source/blender/include/butspace.h @@ -77,6 +77,7 @@ extern void do_fontbuts(unsigned short event); extern void do_mballbuts(unsigned short event); extern void do_latticebuts(unsigned short event); extern void do_fpaintbuts(unsigned short event); +extern void do_cambuts(unsigned short event); extern char *get_vertexgroup_menustr(struct Object *ob); // used in object buttons /* shading */ @@ -281,6 +282,9 @@ void test_idbutton_cb(void *namev, void *arg2_unused); #define B_SWITCHRENDER 1641 #define B_FBUF_REDO 1642 +#define B_SET_EDGE 1643 +#define B_SET_ZBLUR 1644 + #ifdef __NLA /* *********************** */ enum { diff --git a/source/blender/makesdna/DNA_camera_types.h b/source/blender/makesdna/DNA_camera_types.h index 8b6f0eb369b..2041aae3429 100644 --- a/source/blender/makesdna/DNA_camera_types.h +++ b/source/blender/makesdna/DNA_camera_types.h @@ -54,7 +54,7 @@ typedef struct Camera { float YF_dofdist, YF_aperture; short YF_bkhtype, YF_bkhbias; float YF_bkhrot; - + struct Ipo *ipo; ScriptLink scriptlink; @@ -72,6 +72,7 @@ typedef struct Camera { /* yafray: dof sampling switch */ #define CAM_YF_NO_QMC 4 + #ifdef __cplusplus } #endif diff --git a/source/blender/makesdna/DNA_scene_types.h b/source/blender/makesdna/DNA_scene_types.h index 8d6fed13b88..d285a46c3ae 100644 --- a/source/blender/makesdna/DNA_scene_types.h +++ b/source/blender/makesdna/DNA_scene_types.h @@ -215,7 +215,9 @@ typedef struct RenderData { /* Dither noise intensity */ float dither_intensity; - float pad_dither; + + /* Zblur settings */ + float zmin, focus, zgamma, zsigma, zblur; /* yafray: global panel params. TODO: move elsewhere */ short GIquality, GIcache, GImethod, GIphotons, GIdirect; @@ -303,6 +305,8 @@ typedef struct Scene { #define R_GAUSS 0x20000 #define R_FBUF 0x40000 #define R_THREADS 0x80000 +#define R_ZBLUR 0x100000 + /* yafray: renderer flag (not only exclusive to yafray) */ #define R_INTERN 0 diff --git a/source/blender/render/SConscript b/source/blender/render/SConscript index 1537f402f7a..71be91f1be3 100644 --- a/source/blender/render/SConscript +++ b/source/blender/render/SConscript @@ -22,6 +22,7 @@ source_files = ['intern/source/RE_callbacks.c', 'intern/source/shadbuf.c', 'intern/source/texture.c', 'intern/source/vanillaRenderPipe.c', + 'intern/source/zblur.c', 'intern/source/zbuf.c', 'intern/source/zbufferdatastruct.c'] diff --git a/source/blender/render/intern/include/zblur.h b/source/blender/render/intern/include/zblur.h new file mode 100644 index 00000000000..a0e1c6a39ce --- /dev/null +++ b/source/blender/render/intern/include/zblur.h @@ -0,0 +1,48 @@ +/* + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef ZBLUR_H +#define ZBLUR_H + +#ifdef __cplusplus +extern "C" { +#endif + +/*-----------------------------------------------------------*/ +/* Includes */ +/*-----------------------------------------------------------*/ + +/*-----------------------------------------------------------*/ +/* Function */ +/*-----------------------------------------------------------*/ + +void add_zblur(void); + +#ifdef __cplusplus +} +#endif + +#endif + diff --git a/source/blender/render/intern/source/initrender.c b/source/blender/render/intern/source/initrender.c index c4668a9f816..24f836688cf 100644 --- a/source/blender/render/intern/source/initrender.c +++ b/source/blender/render/intern/source/initrender.c @@ -99,6 +99,7 @@ #include "renderHelp.h" #include "jitter.h" #include "gammaCorrectionTables.h" +#include "zblur.h" /* Own includes */ #include "initrender.h" @@ -1065,6 +1066,10 @@ static void mainRenderLoop(void) /* here the PART and FIELD loops */ if(RE_local_test_break()==0) add_halo_flare(); } + if( (R.r.mode & R_ZBLUR)) { + if(RE_local_test_break()==0) add_zblur(); + } + if(R.r.mode & R_MBLUR) { add_to_blurbuf(blur); } diff --git a/source/blender/render/intern/source/shadbuf.c b/source/blender/render/intern/source/shadbuf.c index 8510df2de3d..c942232bebb 100644 --- a/source/blender/render/intern/source/shadbuf.c +++ b/source/blender/render/intern/source/shadbuf.c @@ -522,6 +522,7 @@ float testshadowbuf(struct ShadBuf *shb, float *rco, float *dxco, float *dyco, f for(a=num;a>0;a--) { /* instead of jit i tried random: ugly! */ /* note: the plus 0.5 gives best sampling results, jit used to go from 0-1 */ + /* xs1 and ys1 are already corrected to be corner of sample area */ xs= xs1 + xres*(j[0] + 0.5); ys= ys1 + yres*(j[1] + 0.5); j+=2; diff --git a/source/blender/render/intern/source/zblur.c b/source/blender/render/intern/source/zblur.c new file mode 100644 index 00000000000..4cb1e010e83 --- /dev/null +++ b/source/blender/render/intern/source/zblur.c @@ -0,0 +1,817 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +/* + * This file is largely based on the focal blur plugin by onk, 8.99 + * + */ + +#include +#include +#include +#include + +#include "MEM_guardedalloc.h" + +#include "DNA_camera_types.h" +#include "DNA_scene_types.h" + +#include "BKE_global.h" +#include "BKE_utildefines.h" + +#include "RE_callbacks.h" + +#include "render.h" +#include "pixelblending.h" + +#include "blendef.h" + +//#include "BIF_gl.h" + +/* ------------------------------------------------- + * defines, protos */ + +typedef enum { I_GRAY, I_FLOAT, I_FLOAT4 } IMGTYPE; + +typedef struct { + int x, y; + int size, el_size; + IMGTYPE type; + char *data; +} Image; + +typedef struct { /* blur mask struct */ + int size; + float fac; + float *val; +} Mask; + +typedef Mask* Maskarray; + +/* don't change these */ +#define NMASKS_SHIFT 2 +#define NMASKS 64 + + +static Image *alloc_img(int x, int y, IMGTYPE type) +{ + Image *ret; + int size, typesize; + + switch (type) { + case I_GRAY: + typesize = 1; + break; + case I_FLOAT: + typesize = sizeof(float); + break; + case I_FLOAT4: + typesize = 4 * sizeof(float); + break; + default: + return 0; + } + + size = x * y; + + ret = (Image *) MEM_mallocN(sizeof(Image) + size*typesize, "zblur_img"); + if (ret) { + ret->x = x; + ret->y = y; + ret->size = size; + ret->el_size = typesize; + ret->type = type; + ret->data = (char *) (ret + 1); + size *= typesize; + memset(ret->data, 0, size); + } + + return ret; +} + +static int free_img(Image *img) +{ + MEM_freeN(img); + return 1; +} + +/* 32 bits (int) rect to float buf */ +static void recti2imgf(int *src, Image *dest, int x, int y) +{ + char *from; + float *to; + int i, ix, iy; + + if(dest->type != I_FLOAT4) return; + + from = (char *) src; + to = (float *) dest->data; + + if (R.r.mode & R_FIELDS) { /* double each scanline */ + for (iy=0; iytype != I_FLOAT4) return; + + from = src; + to = (float *) dest->data; + + if (R.r.mode & R_FIELDS) { /* double each scanline */ + for (iy=0; iytype != I_FLOAT4) return; + + from = (float *) src->data; + to = (char *) dest; + + if (R.r.mode & R_FIELDS) { + for (iy=0; iyy; iy++) { + for (ix=0; ixx; ix++) { + *to++ = (char)(from[0]*255.0); + *to++ = (char)(from[1]*255.0); + *to++ = (char)(from[2]*255.0); + *to++ = (char)(from[3]*255.0); + from += 4; + } + iy++; + from+= 4*src->x; + } + } + else { + i = src->x * src->y; + while(i--) { + *to++ = (char)(from[0]*255.0); + *to++ = (char)(from[1]*255.0); + *to++ = (char)(from[2]*255.0); + *to++ = (char)(from[3]*255.0); + from += 4; + } + } +} + +/* floatbuf back to float rect */ +static void imgf2rectf(Image *src, float *dest) +{ + float *from; + float *to; + int i, iy; + + if(src->type != I_FLOAT4) return; + + from = (float *) src->data; + to = dest; + + if (R.r.mode & R_FIELDS) { + for (iy=0; iyy; iy++) { + + memcpy(to, from, 4*sizeof(float)*src->x); + + iy++; + to+= 4*src->x; + from+= 8*src->x; + } + } + else { + i = src->x * src->y; + memcpy(to, from, 4*sizeof(float)*i); + } +} + + +static void imgf_gamma(Image *src, float gamma) +{ + float *to; + int i; + + if(gamma==1.0) return; + + i = 4 * src->x * src->y; + to= (float *) src->data; + while(i--) { + *to = powf(*to, gamma); + to++; + } +} + +#if 0 +/* create new image with alpha & color zero where mask is zero */ +static Image *imgf_apply_mask(Image *src, Image *zmask) +{ + Image *dest; + float *from, *to; + int i; + char *zptr; + + dest = alloc_img(src->x, src->y, I_FLOAT4); + + i= src->x * src->y; + from= (float *) src->data; + to= (float *) dest->data; + zptr= (char *)zmask->data; + + while(i--) { + if(*zptr) { + to[0]= from[0]; + to[1]= from[1]; + to[2]= from[2]; + to[3]= from[3]; + } + else { + to[0]= to[1]= to[2]= to[3]= 0.0f; + } + zptr++; + to+= 4; + from+= 4; + } + + return dest; +} + +static void imgf_alpha_over(Image *dest, Image *src) +{ + float *from, *to; + int i; + + i= src->x * src->y; + from= (float *) src->data; + to= (float *) dest->data; + + while(i--) { + addAlphaOverFloat(to, from); + to+= 4; + from+= 4; + } +} + +#endif + +/* --------------------------------------------------------------------- */ +/* mask routines */ + +static Mask *alloc_mask(int size) +{ + Mask *m; + int memsize; + + memsize = (sizeof(Mask) + (2 * size +1) * (2 * size +1) * sizeof(float)); + + m = (Mask*) MEM_mallocN(memsize, "zblur_mask"); + m->size = size; + m->val = (float *) (m + 1); + + return m; +} + +static void free_mask(Mask *m) +{ + int memsize; + + memsize = 2 * m->size + 1; + memsize *= memsize * sizeof(float); + memsize += sizeof(Mask); + + MEM_freeN(m); +} + +/* normalize mask to 1 */ + +static void norm_mask(Mask *m) +{ + float fac; + int size; + float *v; + + fac = m->fac; + size = (2 * m->size +1)*(2 * m->size +1); + + v = m->val; + while(size--) { + *v++ *= fac; + } + m->fac = 1.0; +} + +/* filters a grayvalue image with a gaussian IIR filter with blur radius "rad" + * For large blurs, it's more efficient to call the routine several times + * instead of using big blur radii. + * The original image is changed */ + + +static void gauss_blur(Image *img, float rad) +{ + Image *new; + register float sum, val; + float gval; + float *gausstab, *v; + int r, n, m; + int x, y; + int i; + int step, bigstep; + char *src, *dest; + + r = (1.5 * rad + 1.5); + n = 2 * r + 1; + + /* ugly : */ + if ((img->x <= n) || (img->y <= n)) { + return; + } + + gausstab = (float *) MEM_mallocN(n * sizeof(float), "zblur_gauss"); + if (!gausstab) { + return; + } + + sum = 0.0; + v = gausstab; + for (x = -r; x <= r; x++) { + + val = exp(-4*(float ) (x*x)/ (float) (r*r)); + sum += val; + *v++ = val; + } + + i = n; + v = gausstab; + while (i--) { + *v++ /= sum; + } + + new = alloc_img(img->x, img->y, I_GRAY); + if (!new) { + return; + } + + /* horizontal */ + + step = (n - 1); + + for (y = 0; y < img->y; y++) { + src = (char *)img->data + (y * img->x); + dest = (char *)new->data + (y * img->x); + + for (x = r; x > 0 ; x--) { + m = n - x; + gval = 0.0; + sum = 0.0; + v = gausstab + x; + for (i = 0; i < m; i++) { + val = *v++; + sum += val; + gval += val * (*src++); + } + *dest++ = gval / sum; + src -= m; + } + + for (x = 0; x <= (img->x - n); x++) { + gval = 0.0; + v = gausstab; + + for (i = 0; i < n; i++) { + val = *v++; + gval += val * (*src++); + } + *dest++ = gval; + src -= step; + } + + for (x = 1; x <= r ; x++) { + m = n - x; + gval = 0.0; + sum = 0.0; + v = gausstab; + for (i = 0; i < m; i++) { + val = *v++; + sum += val; + gval += val * (*src++); + } + *dest++ = gval / sum; + src -= (m - 1); + } + } + + /* vertical */ + + step = img->x; + bigstep = (n - 1) * step; + for (x = 0; x < step ; x++) { + src = new->data + x; + dest = img->data + x; + + for (y = r; y > 0; y--) { + m = n - y; + gval = 0.0; + sum = 0.0; + v = gausstab + y; + for (i = 0; i < m; i++) { + val = *v++; + sum += val; + gval += val * src[0]; + src += step; + } + dest[0] = gval / sum; + src -= m * step; + dest+= step; + } + for (y = 0; y <= (img->y - n); y++) { + gval = 0.0; + v = gausstab; + for (i = 0; i < n; i++) { + val = *v++; + gval += val * src[0]; + src += step; + } + dest[0] = gval; + dest += step; + src -= bigstep; + } + for (y = 1; y <= r ; y++) { + m = n - y; + gval = 0.0; + sum = 0.0; + v = gausstab; + for (i = 0; i < m; i++) { + val = *v++; + sum += val; + gval += val * src[0]; + src += step; + } + dest[0] = gval / sum; + dest += step; + src -= (m - 1) * step; + } + } + MEM_freeN(gausstab); + free_img(new); +} + +static float zigma(float x, float sigma, float sigma4) +{ + //return 1.0/(1.0+pow(x, sigma)); + + if(x < sigma) { + x*= sigma; + return 1.0/exp(x*x) - sigma4; + } + return 0.0; +} + + +static Mask *gauss_mask(float rad, float sigma) +{ + Mask *m; + float sum, val, *v, fac, radsq= rad*rad; + float sigma4; + int r; + int ix, iy; + + r = (1.0 * rad + 1.0); + m = alloc_mask(r); + v = m->val; + sum = 0.0; + + sigma4= 1.0/exp(sigma*sigma*sigma*sigma); + + for (iy = -r; iy <= r; iy++) { + for (ix = -r; ix <= r; ix++) { + + fac= ((float)(ix*ix + iy*iy))/(radsq); + val = zigma(fac, sigma, sigma4); + + // val = exp(-(float) (ix*ix + iy*iy)/(rad * rad)); + sum += val; + *v++ = val; + } + } + + m->fac = 1.0 / sum; + + norm_mask(m); + return m; +} + +/* generates #num masks with the maximal blur radius 'rad' + * */ +static Maskarray *init_masks(int num, float rad, float sigma) +{ + int i; + float r, step; + Maskarray *maskarray; + + maskarray = (Maskarray*) MEM_mallocN(num * sizeof (Maskarray), "zblur_masks"); + step = rad / num; + r = 0.1; + for (i = 0; i < num; i++) { + maskarray[i] = gauss_mask(r, sigma); + r += step; + } + return maskarray; +} + + +/* ********************* Do the blur ******************************** */ + +static Image *zblur(Image *src, Image *zbuf, float radius, float sigma) +{ + Image *dest; + Maskarray *mar; + Mask *m; + float *sptr, *dptr; + float *mval; /* mask value pointer */ + float rval, gval, bval, aval; + float norm, fac; + int tmp; + int zval; + int size; + int row; + int mrow; + int x, y; + int i; + int sx, sy, ex, ey; + int mx, my; + char *zptr; + + if(src->type != I_FLOAT4) return NULL; + + dest = alloc_img(src->x, src->y, I_FLOAT4); + row = src->x * 4; + + mar = init_masks(NMASKS, radius, sigma); + + for (y = 0; y < src->y ; y++) { + for (x = 0; x < src->x; x++) { + dptr = (float *) (dest->data + ((y * src->x + x) * src->el_size)); + zptr = zbuf->data + (y * src->x + x); + zval = *zptr; + sptr = (float *) (src->data + ((y *src->x + x )* src->el_size)); + + m = mar[zval >> NMASKS_SHIFT]; + + size = m->size; + + if(size==0 || zval==0) { + dptr[0] = sptr[0]; + dptr[1] = sptr[1]; + dptr[2] = sptr[2]; + dptr[3] = sptr[3]; + continue; + } + + ex = src->x - x; + ey = src->y - y; + + sx = (x < size) ? x : size; + sy = (y < size) ? y : size; + ex = (ex <= size) ? ex - 1: size; + ey = (ey <= size) ? ey - 1: size; + + sptr -= sy *src->x * 4; + zptr -= sy * src->x; + mrow = (size << 1) + 1; + mval = m->val + (size - sy) * mrow + size; + + norm = rval = gval = bval = aval= 0.0; + + for (my = -sy; my <= ey; my++) { + for (mx = -sx; mx <= ex; mx++) { + if( zptr[mx] ) { + tmp = 4 * mx; + fac = mval[mx] * (float) zptr[mx] /255.0 ; + + norm += fac; + rval += fac * sptr[tmp]; + gval += fac * sptr[tmp + 1]; + bval += fac * sptr[tmp + 2]; + aval += fac * sptr[tmp + 3]; + } + } + mval += mrow; + sptr += row; + zptr += src->x; + } + + dptr[0] = rval / norm; + dptr[1] = gval / norm; + dptr[2] = bval / norm; + dptr[3] = aval / norm; + } + if(!(y % 4) && RE_local_test_break()) break; + } + + for (i= 0; i < NMASKS; i++) { + free_mask(mar[i]); + } + + MEM_freeN(mar); + + return dest; +} + + +/* this splits the z-buffer into 2 gray-images (background, foreground) +* which are used for the weighted blur */ + +static void zsplit(int *zptr, Image *fg, Image *bg, int zfocus, int zmax, int zmin, int x, int y) +{ + char *p, *q; + int i, ix, iy; + float fdist; + float fgnorm, bgnorm; + + p = fg->data; + q = bg->data; + bgnorm = 255.0 / ((float) zmax - (float) zfocus); + fgnorm = 255.0 / ((float) zfocus - (float) zmin); + + if (R.r.mode & R_FIELDS) { + for (iy=0; iyzfocus) zmin= zfocus; + + zfront = alloc_img(x, y, I_GRAY); + zback = alloc_img(x, y, I_GRAY); + orig = alloc_img(x, y, I_FLOAT4); + + if(R.rectftot) rectf2imgf(R.rectftot, orig, x, y); + else recti2imgf(R.rectot, orig, x, y); + + imgf_gamma(orig, R.r.zgamma); // pregamma correct if required + + + /* split up z buffer into 2 gray images */ + zsplit(R.rectz, zfront, zback, zfocus, INT_MAX, zmin, x, y); + +// glDrawBuffer(GL_FRONT); +// glRasterPos2i(0, 0); +// glDrawPixels(x, y, GL_RED, GL_UNSIGNED_BYTE, zback->data); +// glFlush(); +// glDrawBuffer(GL_BACK); + + gauss_blur(zback, 1.0); + gauss_blur(zfront, zblurr); + + /* blur back part */ + work = zblur(orig, zback, zblurr, R.r.zsigma); + free_img(orig); + + /* blur front part */ + orig = zblur(work, zfront, zblurr, R.r.zsigma); + + imgf_gamma(orig, 1.0/R.r.zgamma); // pregamma correct if required + + if(R.rectftot) imgf2rectf(orig, R.rectftot); + else imgf2recti(orig, R.rectot); + + free_img(work); + free_img(orig); + free_img(zfront); + free_img(zback); + + /* make new display rect */ + if(R.rectftot) RE_floatbuffer_to_output(); +} + + diff --git a/source/blender/render/intern/source/zbufferdatastruct.c b/source/blender/render/intern/source/zbufferdatastruct.c index 4ab8a401c20..d237b7d64f4 100644 --- a/source/blender/render/intern/source/zbufferdatastruct.c +++ b/source/blender/render/intern/source/zbufferdatastruct.c @@ -262,7 +262,7 @@ void insertFlatObjectNoOsa(RE_APixstrExt *ap, int dist, int mask) { - int counter; + int counter=0; while(ap) { if(ap->t[0] == RE_NONE) { diff --git a/source/blender/src/butspace.c b/source/blender/src/butspace.c index 0c5b07d4b38..b0917a1123d 100644 --- a/source/blender/src/butspace.c +++ b/source/blender/src/butspace.c @@ -288,7 +288,7 @@ void do_butspace(unsigned short event) do_fontbuts(event); } else if(event<=B_CAMBUTS) { - ; + do_cambuts(event); } else if(event<=B_MBALLBUTS) { do_mballbuts(event); diff --git a/source/blender/src/buttons_editing.c b/source/blender/src/buttons_editing.c index 92275e67950..c55574d9791 100644 --- a/source/blender/src/buttons_editing.c +++ b/source/blender/src/buttons_editing.c @@ -1344,10 +1344,10 @@ static void editing_panel_camera_type(Object *ob, Camera *cam) uiDefButF(block, NUM,REDRAWVIEW3D, "DrawSize:", 470,90,160,20, &cam->drawsize, 0.1*grid, 10.0, 10, 0, "Specify the drawsize of the camera"); - uiDefButS(block, TOG, REDRAWVIEW3D, "Ortho", 470,49,61,40, &cam->type, 0, 0, 0, 0, "Render orthogonally"); + uiDefButS(block, TOG, REDRAWVIEW3D, "Ortho", 470,29,61,60, &cam->type, 0, 0, 0, 0, "Render orthogonally"); uiBlockBeginAlign(block); - uiDefButS(block, TOG|BIT|0,REDRAWVIEW3D, "ShowLimits", 533,69,97,20, &cam->flag, 0, 0, 0, 0, "Draw the field of view"); - uiDefButS(block, TOG|BIT|1,REDRAWVIEW3D, "Show Mist", 533,49,97,20, &cam->flag, 0, 0, 0, 0, "Draw a line that indicates the mist area"); + uiDefButS(block, TOG|BIT|0,REDRAWVIEW3D, "ShowLimits", 533,59,97,30, &cam->flag, 0, 0, 0, 0, "Draw the field of view"); + uiDefButS(block, TOG|BIT|1,REDRAWVIEW3D, "Show Mist", 533,29,97,30, &cam->flag, 0, 0, 0, 0, "Draw a line that indicates the mist area"); uiBlockEndAlign(block); } @@ -1379,6 +1379,23 @@ static void editing_panel_camera_yafraydof(Object *ob, Camera *cam) } +/* **************************** CAMERA *************************** */ + +void do_cambuts(unsigned short event) +{ + Object *ob; + Camera *cam; + + ob= OBACT; + if (ob==0) return; + cam= ob->data; + + switch(event) { + case 0: + ; + break; + } +} /* *************************** MBALL ******************************** */ diff --git a/source/blender/src/buttons_scene.c b/source/blender/src/buttons_scene.c index 2db758f35fb..8072262839a 100644 --- a/source/blender/src/buttons_scene.c +++ b/source/blender/src/buttons_scene.c @@ -763,6 +763,14 @@ void do_render_panels(unsigned short event) BIF_redraw_render_rect(); } break; + case B_SET_EDGE: + G.scene->r.mode &= ~R_ZBLUR; + allqueue(REDRAWBUTSSCENE, 0); + break; + case B_SET_ZBLUR: + G.scene->r.mode &= ~R_EDGE; + allqueue(REDRAWBUTSSCENE, 0); + break; } } @@ -1031,23 +1039,6 @@ static void render_panel_output(void) uiDefButS(block, TOG|BIT|4, 0, "Extensions", 205, 10, 105, 19, &G.scene->r.scemode, 0.0, 0.0, 0, 0, "Adds extensions to the output when rendering animations"); - /* Dither control */ - uiDefButF(block, NUM,B_DIFF, "Dither:", 205,31,105,19, &G.scene->r.dither_intensity, 0.0, 2.0, 0, 0, "The amount of dithering noise present in the output image (0.0 = no dithering)"); - - /* Toon shading buttons */ - uiBlockBeginAlign(block); - uiDefButI(block, TOG|BIT|5, 0,"Edge", 100, 94, 70, 20, &G.scene->r.mode, 0, 0, 0, 0, "Enable Toon edge shading"); - uiDefBlockBut(block, edge_render_menu, NULL, "Edge Settings", 170, 94, 140, 20, "Display edge settings"); - - /* postprocess render buttons */ - uiBlockBeginAlign(block); - if(R.rectftot) - uiDefIconTextButI(block, TOG|BIT|18, B_NOP, ICON_IMAGE_DEHLT," Fbuf", 100, 68, 70, 20, &G.scene->r.mode, 0, 0, 0, 0, "Keep RGBA float buffer after render; buffer available"); - else - uiDefButI(block, TOG|BIT|18, 0,"Fbuf", 100, 68, 70, 20, &G.scene->r.mode, 0, 0, 0, 0, "Keep RGBA float buffer after render, no buffer available now"); - uiDefBlockBut(block, post_render_menu, NULL, "Post process", 170, 68, 140, 20, "Applies on RGBA floats while render or with Fbuf available"); - uiBlockEndAlign(block); - /* removed, for time being unified and normal render will use same gamma for blending (2.0) */ //if (G.scene->r.mode & R_GAMMA) { // uiDefButF(block, NUMSLI, 0,"Gamma:", 10, 68, 142, 20, @@ -1093,7 +1084,7 @@ static void render_panel_render(void) uiDefButS(block, ROW,800,"Premul", 405,13,50,20,&G.scene->r.alphamode,3.0,1.0, 0, 0, "Multiply alpha in advance"); uiDefButS(block, ROW,800,"Key", 456,13,35,20,&G.scene->r.alphamode,3.0,2.0, 0, 0, "Alpha and colour values remain unchanged"); uiBlockEndAlign(block); - + if(G.scene->r.mode & R_RAYTRACE) uiDefButS(block, MENU, B_DIFF,"Octree resolution %t|64 %x64|128 %x128|256 %x256|512 %x512", 496,13,64,20,&G.scene->r.ocres,0.0,0.0, 0, 0, "Octree resolution for ray tracing"); @@ -1317,12 +1308,12 @@ static void render_panel_yafrayGlobal() uiDefButF(block, NUMSLI, B_DIFF,"Bi ", 5,35,150,20, &(G.scene->r.YF_raybias), 0.0, 10.0 ,0,0, "Shadow ray bias to avoid self shadowing"); - uiDefButI(block, NUM, B_DIFF, "Raydepth ", 5,60,150,20, + uiDefButI(block, NUM, B_DIFF, "Raydepth ", 5,60,150,20, &G.scene->r.YF_raydepth, 1.0, 80.0, 10, 10, "Maximum render ray depth from the camera"); uiDefButF(block, NUMSLI, B_DIFF, "Gam ", 5,10,150,20, &G.scene->r.YF_gamma, 0.001, 5.0, 0, 0, "Gamma correction, 1 is off"); uiDefButF(block, NUMSLI, B_DIFF, "Exp ", 160,10,150,20,&G.scene->r.YF_exposure, 0.0, 10.0, 0, 0, "Exposure adjustment, 0 is off"); - uiDefButI(block, NUM, B_DIFF, "Processors:", 160,35,150,20, + uiDefButI(block, NUM, B_DIFF, "Processors:", 160,35,150,20, &G.scene->r.YF_numprocs, 1.0, 8.0, 10, 10, "Number of processors to use"); /*AA Settings*/ @@ -1339,11 +1330,48 @@ static void render_panel_yafrayGlobal() } } +static void render_panel_sfx(void) +{ + uiBlock *block; + + block= uiNewBlock(&curarea->uiblocks, "editing_panel_camera_dof", UI_EMBOSS, UI_HELV, curarea->win); + uiNewPanelTabbed("Output", "Render"); + if(uiNewPanel(curarea, block, "Post Effects", "Render", 320, 0, 318, 204)==0) return; + + uiBlockBeginAlign(block); + uiDefButI(block, TOG|BIT|20,B_SET_ZBLUR,"Zblur", 10,180,140,20,&G.scene->r.mode,0,0, 0, 0, "Apply blur based on depth values in z-buffer"); + uiDefButF(block, NUM,B_DIFF, "ZMin:", 10,160,140,20, &G.scene->r.zmin, 0.0, 1.0, 0, 0, "Specify the start distance with maximum blur"); + uiDefButF(block, NUM,B_DIFF, "Focus:", 10,140,140,20, &G.scene->r.focus, 0.0, 1.0, 0, 0, "Specify the focus distance (not blurred)"); + uiDefButF(block, NUM,B_DIFF, "Blur:", 10,120,140,20, &G.scene->r.zblur, 1.0, 100.0, 0, 0, "Specify the maximum blur radius"); + uiDefButF(block, NUM,B_DIFF, "Gamma:", 10,100,140,20, &G.scene->r.zgamma, 0.05, 2.0, 0, 0, "Use Gamma corrected addition of colors"); + uiDefButF(block, NUM,B_DIFF, "Sigma:", 10,80,140,20, &G.scene->r.zsigma, 1.0, 20.0, 0, 0, "Filter type control, higher value is stronger gaussian"); + + /* Toon shading buttons */ + uiBlockBeginAlign(block); + uiDefButI(block, TOG|BIT|5, B_SET_EDGE, "Edge", 160, 180, 150, 20, &G.scene->r.mode, 0, 0, 0, 0, "Enable Toon edge shading"); + uiDefBlockBut(block, edge_render_menu, NULL, "Edge Settings", 160, 160, 150, 20, "Display edge settings"); + + /* postprocess render buttons */ + uiBlockBeginAlign(block); + if(R.rectftot) + uiDefIconTextButI(block, TOG|BIT|18, B_NOP, ICON_IMAGE_DEHLT," Fbuf", 160, 130, 150, 20, &G.scene->r.mode, 0, 0, 0, 0, "Keep RGBA float buffer after render; buffer available"); + else + uiDefButI(block, TOG|BIT|18, 0,"Fbuf", 160, 130, 150, 20, &G.scene->r.mode, 0, 0, 0, 0, "Keep RGBA float buffer after render, no buffer available now"); + uiDefBlockBut(block, post_render_menu, NULL, "Post process", 160, 110, 150, 20, "Applies on RGBA floats while render or with Fbuf available"); + uiBlockEndAlign(block); + + /* Dither control */ + uiDefButF(block, NUM,B_DIFF, "Dither:", 160,80,150,20, &G.scene->r.dither_intensity, 0.0, 2.0, 0, 0, "The amount of dithering noise present in the output image (0.0 = no dithering)"); + +} + + void render_panels() { render_panel_output(); + render_panel_sfx(); render_panel_render(); render_panel_anim(); render_panel_format(); diff --git a/source/blender/src/renderwin.c b/source/blender/src/renderwin.c index 07d95d2c1b3..ffa917530b0 100644 --- a/source/blender/src/renderwin.c +++ b/source/blender/src/renderwin.c @@ -365,15 +365,15 @@ static void renderwin_mouse_moved(RenderWin *rw) if (rw->flags & RW_FLAGS_PIXEL_EXAMINING) { int imgco[2]; char buf[64]; - unsigned int *pxl2; - unsigned char *pxl; + int *pxlz; // zbuffer is signed + char *pxl; if (R.rectot && renderwin_win_to_image_co(rw, rw->lmouse, imgco)) { pxl= (char*) &R.rectot[R.rectx*imgco[1] + imgco[0]]; if (R.rectz) { - pxl2= &R.rectz[R.rectx*imgco[1] + imgco[0]]; - sprintf(buf, "R: %d, G: %d, B: %d, A: %d, Z: %f", pxl[0], pxl[1], pxl[2], pxl[3], (float)(((float)*pxl2-(float)INT_MIN)/(float)UINT_MAX)); + pxlz= &R.rectz[R.rectx*imgco[1] + imgco[0]]; + sprintf(buf, "R: %d, G: %d, B: %d, A: %d, Z: %f", pxl[0], pxl[1], pxl[2], pxl[3], 0.5+0.5*( ((float)*pxlz)/(float)INT_MAX) ); } else { sprintf(buf, "R: %d, G: %d, B: %d, A: %d", pxl[0], pxl[1], pxl[2], pxl[3]);