f45546a1d3
After a couple of experiments with variable blur filters, I tried a more interesting, and who knows... original approach. :) First watch results here: http://www.blender.org/bf/rt0001_0030.avi http://www.blender.org/bf/hand0001_0060.avi These are the steps in producing such results: - In preprocess, the speed vectors to previous and next frame are calculated. Speed vectors are screen-aligned and in pixel size. - while rendering, these vectors get calculated per sample, and accumulated in the vector buffer checking for "minimum speed". (on start the vector buffer is initialized on max speed). - After render: - The entire image, all pixels, then is converted to quad polygons. - Also the z value of the pixels is assigned to the polygons - The vertices for the quads use averaged speed vectors (of the 4 corner faces), using a 'minimum but non-zero' speed rule. This minimal speed trick works very well to prevent 'tearing' apart when multiple faces move in different directions in a pixel, or to be able to separate moving pixels clearly from non-moving ones - So, now we have a sort of 'mask' of quad polygons. The previous steps guaranteed that this mask doesn't have antialias color info, and has speed vectors that ensure individual parts to move nicely without tearing effects. The Z allows multiple layers of moving masks. - Then, in temporal buffer, faces get tagged if they move or not - These tags then go to an anti-alias routine, which assigns alpha values to edge faces, based on the method we used in past to antialias bitmaps (still in our code, check the antialias.c in imbuf!) - finally, the tag buffer is used to tag which z values of the original image have to be included (to allow blur go behind stuff). - OK, now we're ready for accumulating! In a loop, all faces then get drawn (with zbuffer) with increasing influence of their speed vectors. The resulting image then is accumulated on top of the original with a decreasing weighting value. It sounds all quite complex... but the speed is still encouraging. Above images have 64 mblur steps, which takes about 1-3 seconds per frame. Usage notes: - Make sure the render-layer has passes 'Vector' and 'Z' on. - add in Compositor the VectorBlur node, and connect the image, Z and speed to the inputs. - The node allows to set amount of steps (10 steps = 10 forward, 10 back). and to set a maximum speed in pixels... to prevent extreme moving things to blur too wide.
62 lines
1.8 KiB
C
62 lines
1.8 KiB
C
/**
|
|
* blenlib/BKE_anim.h (mar-2001 nzc);
|
|
*
|
|
* $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.
|
|
*
|
|
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
|
* All rights reserved.
|
|
*
|
|
* The Original Code is: all of this file.
|
|
*
|
|
* Contributor(s): none yet.
|
|
*
|
|
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
|
*/
|
|
#ifndef BKE_ANIM_H
|
|
#define BKE_ANIM_H
|
|
|
|
struct Path;
|
|
struct Object;
|
|
struct PartEff;
|
|
struct Scene;
|
|
struct ListBase;
|
|
|
|
typedef struct DupliObject {
|
|
struct DupliObject *next, *prev;
|
|
struct Object *ob;
|
|
unsigned int origlay;
|
|
int index;
|
|
float mat[4][4], omat[4][4];
|
|
} DupliObject;
|
|
|
|
void free_path(struct Path *path);
|
|
void calc_curvepath(struct Object *ob);
|
|
int interval_test(int min, int max, int p1, int cycl);
|
|
int where_on_path(struct Object *ob, float ctime, float *vec, float *dir);
|
|
|
|
struct ListBase *object_duplilist(struct Scene *sce, struct Object *ob);
|
|
void free_object_duplilist(struct ListBase *lb);
|
|
int count_duplilist(struct Object *ob);
|
|
|
|
#endif
|
|
|