archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
8c3e960dd40cf36f8d4140fe545cb6e584d8900c
blender-archive/source/blender/render/intern/source/pointdensity.c

346 lines
8.3 KiB
C
Raw Normal View History

* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
/*
* ***** BEGIN GPL 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.
*
* 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.
*
* Contributors: Matt Ebb
*
* ***** END GPL LICENSE BLOCK *****
*/
* Re-coded the point density range checking to be a bit cleaner, and not necessary to modify the BVH functions.
2008-10-02 01:38:12 +00:00
#include <math.h>
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
#include <stdlib.h>
#include <stdio.h>
* Re-coded the point density range checking to be a bit cleaner, and not necessary to modify the BVH functions.
2008-10-02 01:38:12 +00:00
#include "MEM_guardedalloc.h"
Point Density texture The Point Density texture now has some additional options for how the point locations are cached. Previously it was all relative to worldspace, but there are now some other options that make things a lot more convenient for mapping the texture to Local (or Orco). Thanks to theeth for helping with the space conversions! The new Object space options allow this sort of thing to be possible - a particle system, instanced on a transformed renderable object: http://mke3.net/blender/devel/rendering/volumetrics/pd_objectspace.mov It's also a lot easier to use multiple instances, just duplicate the renderable objects and move them around. The new particle cache options are: * Emit Object space This caches the particles relative to the emitter object's coordinate space (i.e. relative to the emitter's object center). This makes it possible to map the Texture to Local or Orco easily, so you can easily move, rotate or scale the rendering object that has the Point Density texture. It's relative to the emitter's location, rotation and scale, so if the object you're rendering the texture on is aligned differently to the emitter, the results will be rotated etc. * Emit Object Location This offsets the particles to the emitter object's location in 3D space. It's similar to Emit Object Space, however the emitter object's rotation and scale are ignored. This is probably the easiest to use, since you don't need to worry about the rotation and scale of the emitter object (just the rendered object), so it's the default. * Global Space This is the same as previously, the particles are cached in global space, so to use this effectively you'll need to map the texture to Global, and have the rendered object in the right global location.
2008-09-29 04:19:24 +00:00
#include "BLI_arithb.h"
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
#include "BLI_blenlib.h"
* Point Density texture Replaced the previous KD-tree (for caching points) with a BVH-tree (thanks to Andre 'jaguarandi' Pinto for help here!). The bvh is quite a bit faster and doesn't suffer some of the artifacts that were apparent with the kd-tree. I've also added a choice of falloff types: Standard, Smooth, and Sharp. Standard gives a harder edge, easier to see individual particles, and when used with a larger radius, Smooth and Sharp falloffs make a much cloudier appearance possible. See the image below (note the settings and render times too) http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_bvh.jpg
2008-10-01 03:35:53 +00:00
#include "BLI_kdopbvh.h"
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
#include "BKE_DerivedMesh.h"
#include "BKE_global.h"
#include "BKE_main.h"
Point Density texture The Point Density texture now has some additional options for how the point locations are cached. Previously it was all relative to worldspace, but there are now some other options that make things a lot more convenient for mapping the texture to Local (or Orco). Thanks to theeth for helping with the space conversions! The new Object space options allow this sort of thing to be possible - a particle system, instanced on a transformed renderable object: http://mke3.net/blender/devel/rendering/volumetrics/pd_objectspace.mov It's also a lot easier to use multiple instances, just duplicate the renderable objects and move them around. The new particle cache options are: * Emit Object space This caches the particles relative to the emitter object's coordinate space (i.e. relative to the emitter's object center). This makes it possible to map the Texture to Local or Orco easily, so you can easily move, rotate or scale the rendering object that has the Point Density texture. It's relative to the emitter's location, rotation and scale, so if the object you're rendering the texture on is aligned differently to the emitter, the results will be rotated etc. * Emit Object Location This offsets the particles to the emitter object's location in 3D space. It's similar to Emit Object Space, however the emitter object's rotation and scale are ignored. This is probably the easiest to use, since you don't need to worry about the rotation and scale of the emitter object (just the rendered object), so it's the default. * Global Space This is the same as previously, the particles are cached in global space, so to use this effectively you'll need to map the texture to Global, and have the rendered object in the right global location.
2008-09-29 04:19:24 +00:00
#include "BKE_object.h"
#include "BKE_particle.h"
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
#include "DNA_texture_types.h"
#include "DNA_particle_types.h"
#include "render_types.h"
* New Point Density texture option: 'Object Vertices' This works very similarly to particles, it just uses the object's renderable vertices as the points instead. http://mke3.net/blender/devel/rendering/volumetrics/pd_objectvertices.png
2008-09-29 07:56:41 +00:00
#include "renderdatabase.h"
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
#include "texture.h"
static void pointdensity_cache_psys(Render *re, PointDensity *pd, Object *ob, ParticleSystem *psys)
{
DerivedMesh* dm;
ParticleKey state;
float cfra=bsystem_time(ob,(float)G.scene->r.cfra,0.0);
int i, childexists;
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
int total_particles;
Point Density texture The Point Density texture now has some additional options for how the point locations are cached. Previously it was all relative to worldspace, but there are now some other options that make things a lot more convenient for mapping the texture to Local (or Orco). Thanks to theeth for helping with the space conversions! The new Object space options allow this sort of thing to be possible - a particle system, instanced on a transformed renderable object: http://mke3.net/blender/devel/rendering/volumetrics/pd_objectspace.mov It's also a lot easier to use multiple instances, just duplicate the renderable objects and move them around. The new particle cache options are: * Emit Object space This caches the particles relative to the emitter object's coordinate space (i.e. relative to the emitter's object center). This makes it possible to map the Texture to Local or Orco easily, so you can easily move, rotate or scale the rendering object that has the Point Density texture. It's relative to the emitter's location, rotation and scale, so if the object you're rendering the texture on is aligned differently to the emitter, the results will be rotated etc. * Emit Object Location This offsets the particles to the emitter object's location in 3D space. It's similar to Emit Object Space, however the emitter object's rotation and scale are ignored. This is probably the easiest to use, since you don't need to worry about the rotation and scale of the emitter object (just the rendered object), so it's the default. * Global Space This is the same as previously, the particles are cached in global space, so to use this effectively you'll need to map the texture to Global, and have the rendered object in the right global location.
2008-09-29 04:19:24 +00:00
float partco[3];
float obview[4][4];
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
/* init crap */
if (!psys || !ob || !pd) return;
Point Density texture The Point Density texture now has some additional options for how the point locations are cached. Previously it was all relative to worldspace, but there are now some other options that make things a lot more convenient for mapping the texture to Local (or Orco). Thanks to theeth for helping with the space conversions! The new Object space options allow this sort of thing to be possible - a particle system, instanced on a transformed renderable object: http://mke3.net/blender/devel/rendering/volumetrics/pd_objectspace.mov It's also a lot easier to use multiple instances, just duplicate the renderable objects and move them around. The new particle cache options are: * Emit Object space This caches the particles relative to the emitter object's coordinate space (i.e. relative to the emitter's object center). This makes it possible to map the Texture to Local or Orco easily, so you can easily move, rotate or scale the rendering object that has the Point Density texture. It's relative to the emitter's location, rotation and scale, so if the object you're rendering the texture on is aligned differently to the emitter, the results will be rotated etc. * Emit Object Location This offsets the particles to the emitter object's location in 3D space. It's similar to Emit Object Space, however the emitter object's rotation and scale are ignored. This is probably the easiest to use, since you don't need to worry about the rotation and scale of the emitter object (just the rendered object), so it's the default. * Global Space This is the same as previously, the particles are cached in global space, so to use this effectively you'll need to map the texture to Global, and have the rendered object in the right global location.
2008-09-29 04:19:24 +00:00
Mat4MulMat4(obview, re->viewinv, ob->obmat);
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
/* Just to create a valid rendering context */
psys_render_set(ob, psys, re->viewmat, re->winmat, re->winx, re->winy, 0);
dm = mesh_create_derived_render(ob,CD_MASK_BAREMESH|CD_MASK_MTFACE|CD_MASK_MCOL);
dm->release(dm);
if ( !psys_check_enabled(ob, psys) ){
psys_render_restore(ob, psys);
return;
}
Point Density texture The Point Density texture now has some additional options for how the point locations are cached. Previously it was all relative to worldspace, but there are now some other options that make things a lot more convenient for mapping the texture to Local (or Orco). Thanks to theeth for helping with the space conversions! The new Object space options allow this sort of thing to be possible - a particle system, instanced on a transformed renderable object: http://mke3.net/blender/devel/rendering/volumetrics/pd_objectspace.mov It's also a lot easier to use multiple instances, just duplicate the renderable objects and move them around. The new particle cache options are: * Emit Object space This caches the particles relative to the emitter object's coordinate space (i.e. relative to the emitter's object center). This makes it possible to map the Texture to Local or Orco easily, so you can easily move, rotate or scale the rendering object that has the Point Density texture. It's relative to the emitter's location, rotation and scale, so if the object you're rendering the texture on is aligned differently to the emitter, the results will be rotated etc. * Emit Object Location This offsets the particles to the emitter object's location in 3D space. It's similar to Emit Object Space, however the emitter object's rotation and scale are ignored. This is probably the easiest to use, since you don't need to worry about the rotation and scale of the emitter object (just the rendered object), so it's the default. * Global Space This is the same as previously, the particles are cached in global space, so to use this effectively you'll need to map the texture to Global, and have the rendered object in the right global location.
2008-09-29 04:19:24 +00:00
/* in case ob->imat isn't up-to-date */
Mat4Invert(ob->imat, ob->obmat);
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
total_particles = psys->totpart+psys->totchild;
pd->point_tree = BLI_bvhtree_new(total_particles, 0.0, 2, 6);
if (pd->noise_influence != TEX_PD_NOISE_STATIC)
pd->point_data = MEM_mallocN(sizeof(float)*3*total_particles, "point_data");
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
if (psys->totchild > 0 && !(psys->part->draw & PART_DRAW_PARENT))
childexists = 1;
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
for (i = 0; i < total_particles; i++) {
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
state.time = cfra;
if(psys_get_particle_state(ob, psys, i, &state, 0)) {
Point Density texture The Point Density texture now has some additional options for how the point locations are cached. Previously it was all relative to worldspace, but there are now some other options that make things a lot more convenient for mapping the texture to Local (or Orco). Thanks to theeth for helping with the space conversions! The new Object space options allow this sort of thing to be possible - a particle system, instanced on a transformed renderable object: http://mke3.net/blender/devel/rendering/volumetrics/pd_objectspace.mov It's also a lot easier to use multiple instances, just duplicate the renderable objects and move them around. The new particle cache options are: * Emit Object space This caches the particles relative to the emitter object's coordinate space (i.e. relative to the emitter's object center). This makes it possible to map the Texture to Local or Orco easily, so you can easily move, rotate or scale the rendering object that has the Point Density texture. It's relative to the emitter's location, rotation and scale, so if the object you're rendering the texture on is aligned differently to the emitter, the results will be rotated etc. * Emit Object Location This offsets the particles to the emitter object's location in 3D space. It's similar to Emit Object Space, however the emitter object's rotation and scale are ignored. This is probably the easiest to use, since you don't need to worry about the rotation and scale of the emitter object (just the rendered object), so it's the default. * Global Space This is the same as previously, the particles are cached in global space, so to use this effectively you'll need to map the texture to Global, and have the rendered object in the right global location.
2008-09-29 04:19:24 +00:00
VECCOPY(partco, state.co);
* New Point Density texture option: 'Object Vertices' This works very similarly to particles, it just uses the object's renderable vertices as the points instead. http://mke3.net/blender/devel/rendering/volumetrics/pd_objectvertices.png
2008-09-29 07:56:41 +00:00
if (pd->psys_cache_space == TEX_PD_OBJECTSPACE)
Point Density texture The Point Density texture now has some additional options for how the point locations are cached. Previously it was all relative to worldspace, but there are now some other options that make things a lot more convenient for mapping the texture to Local (or Orco). Thanks to theeth for helping with the space conversions! The new Object space options allow this sort of thing to be possible - a particle system, instanced on a transformed renderable object: http://mke3.net/blender/devel/rendering/volumetrics/pd_objectspace.mov It's also a lot easier to use multiple instances, just duplicate the renderable objects and move them around. The new particle cache options are: * Emit Object space This caches the particles relative to the emitter object's coordinate space (i.e. relative to the emitter's object center). This makes it possible to map the Texture to Local or Orco easily, so you can easily move, rotate or scale the rendering object that has the Point Density texture. It's relative to the emitter's location, rotation and scale, so if the object you're rendering the texture on is aligned differently to the emitter, the results will be rotated etc. * Emit Object Location This offsets the particles to the emitter object's location in 3D space. It's similar to Emit Object Space, however the emitter object's rotation and scale are ignored. This is probably the easiest to use, since you don't need to worry about the rotation and scale of the emitter object (just the rendered object), so it's the default. * Global Space This is the same as previously, the particles are cached in global space, so to use this effectively you'll need to map the texture to Global, and have the rendered object in the right global location.
2008-09-29 04:19:24 +00:00
Mat4MulVecfl(ob->imat, partco);
* New Point Density texture option: 'Object Vertices' This works very similarly to particles, it just uses the object's renderable vertices as the points instead. http://mke3.net/blender/devel/rendering/volumetrics/pd_objectvertices.png
2008-09-29 07:56:41 +00:00
else if (pd->psys_cache_space == TEX_PD_OBJECTLOC) {
Point Density texture The Point Density texture now has some additional options for how the point locations are cached. Previously it was all relative to worldspace, but there are now some other options that make things a lot more convenient for mapping the texture to Local (or Orco). Thanks to theeth for helping with the space conversions! The new Object space options allow this sort of thing to be possible - a particle system, instanced on a transformed renderable object: http://mke3.net/blender/devel/rendering/volumetrics/pd_objectspace.mov It's also a lot easier to use multiple instances, just duplicate the renderable objects and move them around. The new particle cache options are: * Emit Object space This caches the particles relative to the emitter object's coordinate space (i.e. relative to the emitter's object center). This makes it possible to map the Texture to Local or Orco easily, so you can easily move, rotate or scale the rendering object that has the Point Density texture. It's relative to the emitter's location, rotation and scale, so if the object you're rendering the texture on is aligned differently to the emitter, the results will be rotated etc. * Emit Object Location This offsets the particles to the emitter object's location in 3D space. It's similar to Emit Object Space, however the emitter object's rotation and scale are ignored. This is probably the easiest to use, since you don't need to worry about the rotation and scale of the emitter object (just the rendered object), so it's the default. * Global Space This is the same as previously, the particles are cached in global space, so to use this effectively you'll need to map the texture to Global, and have the rendered object in the right global location.
2008-09-29 04:19:24 +00:00
float obloc[3];
VECCOPY(obloc, ob->loc);
VecSubf(partco, partco, obloc);
} else {
* New Point Density texture option: 'Object Vertices' This works very similarly to particles, it just uses the object's renderable vertices as the points instead. http://mke3.net/blender/devel/rendering/volumetrics/pd_objectvertices.png
2008-09-29 07:56:41 +00:00
/* TEX_PD_WORLDSPACE */
Point Density texture The Point Density texture now has some additional options for how the point locations are cached. Previously it was all relative to worldspace, but there are now some other options that make things a lot more convenient for mapping the texture to Local (or Orco). Thanks to theeth for helping with the space conversions! The new Object space options allow this sort of thing to be possible - a particle system, instanced on a transformed renderable object: http://mke3.net/blender/devel/rendering/volumetrics/pd_objectspace.mov It's also a lot easier to use multiple instances, just duplicate the renderable objects and move them around. The new particle cache options are: * Emit Object space This caches the particles relative to the emitter object's coordinate space (i.e. relative to the emitter's object center). This makes it possible to map the Texture to Local or Orco easily, so you can easily move, rotate or scale the rendering object that has the Point Density texture. It's relative to the emitter's location, rotation and scale, so if the object you're rendering the texture on is aligned differently to the emitter, the results will be rotated etc. * Emit Object Location This offsets the particles to the emitter object's location in 3D space. It's similar to Emit Object Space, however the emitter object's rotation and scale are ignored. This is probably the easiest to use, since you don't need to worry about the rotation and scale of the emitter object (just the rendered object), so it's the default. * Global Space This is the same as previously, the particles are cached in global space, so to use this effectively you'll need to map the texture to Global, and have the rendered object in the right global location.
2008-09-29 04:19:24 +00:00
}
* Point Density texture Replaced the previous KD-tree (for caching points) with a BVH-tree (thanks to Andre 'jaguarandi' Pinto for help here!). The bvh is quite a bit faster and doesn't suffer some of the artifacts that were apparent with the kd-tree. I've also added a choice of falloff types: Standard, Smooth, and Sharp. Standard gives a harder edge, easier to see individual particles, and when used with a larger radius, Smooth and Sharp falloffs make a much cloudier appearance possible. See the image below (note the settings and render times too) http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_bvh.jpg
2008-10-01 03:35:53 +00:00
BLI_bvhtree_insert(pd->point_tree, i, partco, 1);
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
if (pd->noise_influence == TEX_PD_NOISE_VEL) {
pd->point_data[i*3 + 0] = state.vel[0];
pd->point_data[i*3 + 1] = state.vel[1];
pd->point_data[i*3 + 2] = state.vel[2];
} else if (pd->noise_influence == TEX_PD_NOISE_ANGVEL) {
pd->point_data[i*3 + 0] = state.ave[0];
pd->point_data[i*3 + 1] = state.ave[1];
pd->point_data[i*3 + 2] = state.ave[2];
}
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
}
}
* Point Density texture Replaced the previous KD-tree (for caching points) with a BVH-tree (thanks to Andre 'jaguarandi' Pinto for help here!). The bvh is quite a bit faster and doesn't suffer some of the artifacts that were apparent with the kd-tree. I've also added a choice of falloff types: Standard, Smooth, and Sharp. Standard gives a harder edge, easier to see individual particles, and when used with a larger radius, Smooth and Sharp falloffs make a much cloudier appearance possible. See the image below (note the settings and render times too) http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_bvh.jpg
2008-10-01 03:35:53 +00:00
BLI_bvhtree_balance(pd->point_tree);
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
psys_render_restore(ob, psys);
}
* New Point Density texture option: 'Object Vertices' This works very similarly to particles, it just uses the object's renderable vertices as the points instead. http://mke3.net/blender/devel/rendering/volumetrics/pd_objectvertices.png
2008-09-29 07:56:41 +00:00
static void pointdensity_cache_object(Render *re, PointDensity *pd, ObjectRen *obr)
{
int i;
if (!obr || !pd) return;
if(!obr->vertnodes) return;
/* in case ob->imat isn't up-to-date */
Mat4Invert(obr->ob->imat, obr->ob->obmat);
* Point Density texture Replaced the previous KD-tree (for caching points) with a BVH-tree (thanks to Andre 'jaguarandi' Pinto for help here!). The bvh is quite a bit faster and doesn't suffer some of the artifacts that were apparent with the kd-tree. I've also added a choice of falloff types: Standard, Smooth, and Sharp. Standard gives a harder edge, easier to see individual particles, and when used with a larger radius, Smooth and Sharp falloffs make a much cloudier appearance possible. See the image below (note the settings and render times too) http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_bvh.jpg
2008-10-01 03:35:53 +00:00
pd->point_tree = BLI_bvhtree_new(obr->totvert, 0.0, 2, 6);
* New Point Density texture option: 'Object Vertices' This works very similarly to particles, it just uses the object's renderable vertices as the points instead. http://mke3.net/blender/devel/rendering/volumetrics/pd_objectvertices.png
2008-09-29 07:56:41 +00:00
for(i=0; i<obr->totvert; i++) {
float ver_co[3];
VertRen *ver= RE_findOrAddVert(obr, i);
VECCOPY(ver_co, ver->co);
Added 'Object Location' option to 'object vertices' mode in Point Density. This brings it consistent with the 'particle system' mode, and allows silly things like this a bit easier (especially after the last fix and BVH improvements!): http://mke3.net/blender/devel/rendering/volumetrics/pd_objectloc.mov
2008-10-01 07:30:56 +00:00
Mat4MulVecfl(re->viewinv, ver_co);
* New Point Density texture option: 'Object Vertices' This works very similarly to particles, it just uses the object's renderable vertices as the points instead. http://mke3.net/blender/devel/rendering/volumetrics/pd_objectvertices.png
2008-09-29 07:56:41 +00:00
if (pd->ob_cache_space == TEX_PD_OBJECTSPACE) {
Mat4MulVecfl(obr->ob->imat, ver_co);
Added 'Object Location' option to 'object vertices' mode in Point Density. This brings it consistent with the 'particle system' mode, and allows silly things like this a bit easier (especially after the last fix and BVH improvements!): http://mke3.net/blender/devel/rendering/volumetrics/pd_objectloc.mov
2008-10-01 07:30:56 +00:00
} else if (pd->psys_cache_space == TEX_PD_OBJECTLOC) {
VecSubf(ver_co, ver_co, obr->ob->loc);
* New Point Density texture option: 'Object Vertices' This works very similarly to particles, it just uses the object's renderable vertices as the points instead. http://mke3.net/blender/devel/rendering/volumetrics/pd_objectvertices.png
2008-09-29 07:56:41 +00:00
} else {
/* TEX_PD_WORLDSPACE */
}
* Point Density texture Replaced the previous KD-tree (for caching points) with a BVH-tree (thanks to Andre 'jaguarandi' Pinto for help here!). The bvh is quite a bit faster and doesn't suffer some of the artifacts that were apparent with the kd-tree. I've also added a choice of falloff types: Standard, Smooth, and Sharp. Standard gives a harder edge, easier to see individual particles, and when used with a larger radius, Smooth and Sharp falloffs make a much cloudier appearance possible. See the image below (note the settings and render times too) http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_bvh.jpg
2008-10-01 03:35:53 +00:00
BLI_bvhtree_insert(pd->point_tree, i, ver_co, 1);
* New Point Density texture option: 'Object Vertices' This works very similarly to particles, it just uses the object's renderable vertices as the points instead. http://mke3.net/blender/devel/rendering/volumetrics/pd_objectvertices.png
2008-09-29 07:56:41 +00:00
}
* Point Density texture Replaced the previous KD-tree (for caching points) with a BVH-tree (thanks to Andre 'jaguarandi' Pinto for help here!). The bvh is quite a bit faster and doesn't suffer some of the artifacts that were apparent with the kd-tree. I've also added a choice of falloff types: Standard, Smooth, and Sharp. Standard gives a harder edge, easier to see individual particles, and when used with a larger radius, Smooth and Sharp falloffs make a much cloudier appearance possible. See the image below (note the settings and render times too) http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_bvh.jpg
2008-10-01 03:35:53 +00:00
BLI_bvhtree_balance(pd->point_tree);
* New Point Density texture option: 'Object Vertices' This works very similarly to particles, it just uses the object's renderable vertices as the points instead. http://mke3.net/blender/devel/rendering/volumetrics/pd_objectvertices.png
2008-09-29 07:56:41 +00:00
}
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
static void cache_pointdensity(Render *re, Tex *tex)
{
PointDensity *pd = tex->pd;
if (pd->point_tree) {
* Point Density texture Replaced the previous KD-tree (for caching points) with a BVH-tree (thanks to Andre 'jaguarandi' Pinto for help here!). The bvh is quite a bit faster and doesn't suffer some of the artifacts that were apparent with the kd-tree. I've also added a choice of falloff types: Standard, Smooth, and Sharp. Standard gives a harder edge, easier to see individual particles, and when used with a larger radius, Smooth and Sharp falloffs make a much cloudier appearance possible. See the image below (note the settings and render times too) http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_bvh.jpg
2008-10-01 03:35:53 +00:00
BLI_bvhtree_free(pd->point_tree);
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
pd->point_tree = NULL;
}
Point Density texture The Point Density texture now has some additional options for how the point locations are cached. Previously it was all relative to worldspace, but there are now some other options that make things a lot more convenient for mapping the texture to Local (or Orco). Thanks to theeth for helping with the space conversions! The new Object space options allow this sort of thing to be possible - a particle system, instanced on a transformed renderable object: http://mke3.net/blender/devel/rendering/volumetrics/pd_objectspace.mov It's also a lot easier to use multiple instances, just duplicate the renderable objects and move them around. The new particle cache options are: * Emit Object space This caches the particles relative to the emitter object's coordinate space (i.e. relative to the emitter's object center). This makes it possible to map the Texture to Local or Orco easily, so you can easily move, rotate or scale the rendering object that has the Point Density texture. It's relative to the emitter's location, rotation and scale, so if the object you're rendering the texture on is aligned differently to the emitter, the results will be rotated etc. * Emit Object Location This offsets the particles to the emitter object's location in 3D space. It's similar to Emit Object Space, however the emitter object's rotation and scale are ignored. This is probably the easiest to use, since you don't need to worry about the rotation and scale of the emitter object (just the rendered object), so it's the default. * Global Space This is the same as previously, the particles are cached in global space, so to use this effectively you'll need to map the texture to Global, and have the rendered object in the right global location.
2008-09-29 04:19:24 +00:00
if (pd->source == TEX_PD_PSYS) {
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
ParticleSystem *psys;
Object *ob = pd->object;
int i;
for(psys=ob->particlesystem.first, i=0; i< pd->psysindex-1; i++)
psys= psys->next;
if (!ob || !psys) return;
pointdensity_cache_psys(re, pd, ob, psys);
}
* New Point Density texture option: 'Object Vertices' This works very similarly to particles, it just uses the object's renderable vertices as the points instead. http://mke3.net/blender/devel/rendering/volumetrics/pd_objectvertices.png
2008-09-29 07:56:41 +00:00
else if (pd->source == TEX_PD_OBJECT) {
Object *ob = pd->object;
ObjectRen *obr;
int found=0;
/* find the obren that corresponds to the object */
for (obr=re->objecttable.first; obr; obr=obr->next) {
if (obr->ob == ob) {
found=1;
break;
}
}
if (!found) return;
pointdensity_cache_object(re, pd, obr);
}
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
}
static void free_pointdensity(Render *re, Tex *tex)
{
PointDensity *pd = tex->pd;
if (pd->point_tree) {
* Point Density texture Replaced the previous KD-tree (for caching points) with a BVH-tree (thanks to Andre 'jaguarandi' Pinto for help here!). The bvh is quite a bit faster and doesn't suffer some of the artifacts that were apparent with the kd-tree. I've also added a choice of falloff types: Standard, Smooth, and Sharp. Standard gives a harder edge, easier to see individual particles, and when used with a larger radius, Smooth and Sharp falloffs make a much cloudier appearance possible. See the image below (note the settings and render times too) http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_bvh.jpg
2008-10-01 03:35:53 +00:00
BLI_bvhtree_free(pd->point_tree);
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
pd->point_tree = NULL;
}
* Point Density texture Replaced the previous KD-tree (for caching points) with a BVH-tree (thanks to Andre 'jaguarandi' Pinto for help here!). The bvh is quite a bit faster and doesn't suffer some of the artifacts that were apparent with the kd-tree. I've also added a choice of falloff types: Standard, Smooth, and Sharp. Standard gives a harder edge, easier to see individual particles, and when used with a larger radius, Smooth and Sharp falloffs make a much cloudier appearance possible. See the image below (note the settings and render times too) http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_bvh.jpg
2008-10-01 03:35:53 +00:00
if (pd->point_data) {
MEM_freeN(pd->point_data);
pd->point_data = NULL;
}
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
}
void make_pointdensities(Render *re)
{
Tex *tex;
if(re->scene->r.scemode & R_PREVIEWBUTS)
return;
re->i.infostr= "Caching Point Densities";
re->stats_draw(&re->i);
for (tex= G.main->tex.first; tex; tex= tex->id.next) {
if(tex->id.us && tex->type==TEX_POINTDENSITY) {
cache_pointdensity(re, tex);
}
}
}
void free_pointdensities(Render *re)
{
Tex *tex;
if(re->scene->r.scemode & R_PREVIEWBUTS)
return;
for (tex= G.main->tex.first; tex; tex= tex->id.next) {
if(tex->id.us && tex->type==TEX_POINTDENSITY) {
free_pointdensity(re, tex);
}
}
}
* Re-coded the point density range checking to be a bit cleaner, and not necessary to modify the BVH functions.
2008-10-02 01:38:12 +00:00
typedef struct PointDensityRangeData
* Fix for volumetric rendering. It previously wasn't multiplying the emission component by the density at the current point, which made the volume too bright in less dense areas. This made it look too rough, as opposed to smooth as it should be. This makes the particle rendering look *much* better, thanks a bunch to ZanQdo for complaining and kicking my butt to make me realise the error. Here's an example of how smooth it looks now: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test03.mov http://mke3.net/blender/devel/rendering/volumetrics/smoke_test03.blend Settings in existing files will have to be tweaked a bit, since what they were set up for before, was incorrect. * Added two new interpolation types to Point Density: Constant and Root. These work similarly to in proportional edit for example, just gives a bit more choice over how hard-edged the particles should look.
2008-10-01 07:13:28 +00:00
{
* Re-coded the point density range checking to be a bit cleaner, and not necessary to modify the BVH functions.
2008-10-02 01:38:12 +00:00
float *density;
float squared_radius;
float *point_data;
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
float *vec;
* Re-coded the point density range checking to be a bit cleaner, and not necessary to modify the BVH functions.
2008-10-02 01:38:12 +00:00
short falloff_type;
} PointDensityRangeData;
* Fix for volumetric rendering. It previously wasn't multiplying the emission component by the density at the current point, which made the volume too bright in less dense areas. This made it look too rough, as opposed to smooth as it should be. This makes the particle rendering look *much* better, thanks a bunch to ZanQdo for complaining and kicking my butt to make me realise the error. Here's an example of how smooth it looks now: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test03.mov http://mke3.net/blender/devel/rendering/volumetrics/smoke_test03.blend Settings in existing files will have to be tweaked a bit, since what they were set up for before, was incorrect. * Added two new interpolation types to Point Density: Constant and Root. These work similarly to in proportional edit for example, just gives a bit more choice over how hard-edged the particles should look.
2008-10-01 07:13:28 +00:00
* Re-coded the point density range checking to be a bit cleaner, and not necessary to modify the BVH functions.
2008-10-02 01:38:12 +00:00
void accum_density(void *userdata, int index, float squared_dist)
* Fix for volumetric rendering. It previously wasn't multiplying the emission component by the density at the current point, which made the volume too bright in less dense areas. This made it look too rough, as opposed to smooth as it should be. This makes the particle rendering look *much* better, thanks a bunch to ZanQdo for complaining and kicking my butt to make me realise the error. Here's an example of how smooth it looks now: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test03.mov http://mke3.net/blender/devel/rendering/volumetrics/smoke_test03.blend Settings in existing files will have to be tweaked a bit, since what they were set up for before, was incorrect. * Added two new interpolation types to Point Density: Constant and Root. These work similarly to in proportional edit for example, just gives a bit more choice over how hard-edged the particles should look.
2008-10-01 07:13:28 +00:00
{
* Re-coded the point density range checking to be a bit cleaner, and not necessary to modify the BVH functions.
2008-10-02 01:38:12 +00:00
PointDensityRangeData *pdr = (PointDensityRangeData *)userdata;
const float dist = pdr->squared_radius - squared_dist;
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
float density;
* Re-coded the point density range checking to be a bit cleaner, and not necessary to modify the BVH functions.
2008-10-02 01:38:12 +00:00
if (pdr->falloff_type == TEX_PD_FALLOFF_STD)
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
density = dist;
* Re-coded the point density range checking to be a bit cleaner, and not necessary to modify the BVH functions.
2008-10-02 01:38:12 +00:00
else if (pdr->falloff_type == TEX_PD_FALLOFF_SMOOTH)
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
density = 3.0f*dist*dist - 2.0f*dist*dist*dist;
* Re-coded the point density range checking to be a bit cleaner, and not necessary to modify the BVH functions.
2008-10-02 01:38:12 +00:00
else if (pdr->falloff_type == TEX_PD_FALLOFF_SHARP)
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
density = dist*dist;
* Re-coded the point density range checking to be a bit cleaner, and not necessary to modify the BVH functions.
2008-10-02 01:38:12 +00:00
else if (pdr->falloff_type == TEX_PD_FALLOFF_CONSTANT)
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
density = pdr->squared_radius;
* Re-coded the point density range checking to be a bit cleaner, and not necessary to modify the BVH functions.
2008-10-02 01:38:12 +00:00
else if (pdr->falloff_type == TEX_PD_FALLOFF_ROOT)
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
density = sqrt(dist);
if (pdr->point_data) {
pdr->vec[0] += pdr->point_data[index*3 + 0];// * density;
pdr->vec[1] += pdr->point_data[index*3 + 1];// * density;
pdr->vec[2] += pdr->point_data[index*3 + 2];// * density;
}
*pdr->density += density;
* Fix for volumetric rendering. It previously wasn't multiplying the emission component by the density at the current point, which made the volume too bright in less dense areas. This made it look too rough, as opposed to smooth as it should be. This makes the particle rendering look *much* better, thanks a bunch to ZanQdo for complaining and kicking my butt to make me realise the error. Here's an example of how smooth it looks now: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test03.mov http://mke3.net/blender/devel/rendering/volumetrics/smoke_test03.blend Settings in existing files will have to be tweaked a bit, since what they were set up for before, was incorrect. * Added two new interpolation types to Point Density: Constant and Root. These work similarly to in proportional edit for example, just gives a bit more choice over how hard-edged the particles should look.
2008-10-01 07:13:28 +00:00
}
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
#define MAX_POINTS_NEAREST 25
int pointdensitytex(Tex *tex, float *texvec, TexResult *texres)
{
int rv = TEX_INT;
PointDensity *pd = tex->pd;
* Re-coded the point density range checking to be a bit cleaner, and not necessary to modify the BVH functions.
2008-10-02 01:38:12 +00:00
PointDensityRangeData pdr;
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
float density=0.0f;
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
float vec[3] = {0.0, 0.0, 0.0};
float tv[3];
float turb;
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
if ((!pd) || (!pd->point_tree)) {
texres->tin = 0.0f;
return 0;
}
* Re-coded the point density range checking to be a bit cleaner, and not necessary to modify the BVH functions.
2008-10-02 01:38:12 +00:00
pdr.squared_radius = pd->radius*pd->radius;
pdr.density = &density;
pdr.point_data = pd->point_data;
pdr.falloff_type = pd->falloff_type;
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
pdr.vec = vec;
* Re-coded the point density range checking to be a bit cleaner, and not necessary to modify the BVH functions.
2008-10-02 01:38:12 +00:00
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
if (pd->flag & TEX_PD_TURBULENCE) {
VECCOPY(tv, texvec);
/* find the average speed vectors, for perturbing final density lookup with */
BLI_bvhtree_range_query(pd->point_tree, texvec, pd->radius, accum_density, &pdr);
density = 0.0f;
Normalize(vec);
* Fix for volumetric rendering. It previously wasn't multiplying the emission component by the density at the current point, which made the volume too bright in less dense areas. This made it look too rough, as opposed to smooth as it should be. This makes the particle rendering look *much* better, thanks a bunch to ZanQdo for complaining and kicking my butt to make me realise the error. Here's an example of how smooth it looks now: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test03.mov http://mke3.net/blender/devel/rendering/volumetrics/smoke_test03.blend Settings in existing files will have to be tweaked a bit, since what they were set up for before, was incorrect. * Added two new interpolation types to Point Density: Constant and Root. These work similarly to in proportional edit for example, just gives a bit more choice over how hard-edged the particles should look.
2008-10-01 07:13:28 +00:00
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
turb = BLI_turbulence(pd->noise_size, texvec[0]+vec[0], texvec[1]+vec[1], texvec[2]+vec[2], pd->noise_depth);
turb -= 0.5f; /* re-center 0.0-1.0 range around 0 to prevent offsetting result */
tv[0] = texvec[0] + pd->noise_fac * turb;
tv[1] = texvec[1] + pd->noise_fac * turb;
tv[2] = texvec[2] + pd->noise_fac * turb;
/* do density lookup with altered coordinates */
BLI_bvhtree_range_query(pd->point_tree, tv, pd->radius, accum_density, &pdr);
}
else
BLI_bvhtree_range_query(pd->point_tree, texvec, pd->radius, accum_density, &pdr);
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
texres->tin = density;
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
//texres->tr = vec[0];
//texres->tg = vec[1];
//texres->tb = vec[2];
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
return TEX_INT;
/*
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
BRICONTRGB;
texres->ta = 1.0;
if (texres->nor!=NULL) {
texres->nor[0] = texres->nor[1] = texres->nor[2] = 0.0f;
}
*/
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
//BRICONT;
* Volumetrics Removed all the old particle rendering code and options I had in there before, in order to make way for... A new procedural texture: 'Point Density' Point Density is a 3d texture that find the density of a group of 'points' in space and returns that in the texture as an intensity value. Right now, its at an early stage and it's only enabled for particles, but it would be cool to extend it later for things like object vertices, or point cache files from disk - i.e. to import point cloud data into Blender for rendering volumetrically. Currently there are just options for an Object and its particle system number, this is the particle system that will get cached before rendering, and then used for the texture's density estimation. It works totally consistent with as any other procedural texture, so previously where I've mapped a clouds texture to volume density to make some of those test renders, now I just map a point density texture to volume density. Here's a version of the same particle smoke test file from before, updated to use the point density texture instead: http://mke3.net/blender/devel/rendering/volumetrics/smoke_test02.blend There are a few cool things about implementing this as a texture: - The one texture (and cache) can be instanced across many different materials: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_instanced.png This means you can calculate and bake one particle system, but render it multiple times across the scene, with different material settings, at no extra memory cost. Right now, the particles are cached in world space, so you have to map it globally, and if you want it offset, you have to do it in the material (as in the file above). I plan to add an option to bake in local space, so you can just map the texture to local and it just works. - It also works for solid surfaces too, it just gets the density at that particular point on the surface, eg: http://mke3.net/blender/devel/rendering/volumetrics/pointdensity_solid.mov - You can map it to whatever you want, not only density but the various emissions and colours as well. I'd like to investigate using the other outputs in the texture too (like the RGB or normal outputs), perhaps with options to colour by particle age, generating normals for making particle 'dents' in a surface, whatever!
2008-09-28 08:00:22 +00:00
* New point density update: Turbulence This addition allows you to perturb the point density with noise, to give the impression of more resolution. It's a quick way to add detail, without having to use large, complex, and slower to render particle systems. Rather than just overlaying noise, like you might do by adding a secondary clouds texture, it uses noise to perturb the actual coordinate looked up in the density evaluation. This gives a much better looking result, as it actually alters the original density. Comparison of the particle cloud render without, and with added turbulence (the render with turbulence only renders slightly more slowly): http://mke3.net/blender/devel/rendering/volumetrics/pd_turbulence.jpg Using the same constant noise function/spatial coordinates will give a static appearance. This is fine (and quicker) if the particles aren't moving, but on animated particle systems, it looks bad, as if the particles are moving through a static noise field. To overcome this, there are additional options for particle systems, to influence the turbulence with the particles' average velocity, or average angular velocity. This information is only available for particle systems at the present. Here you can see the (dramatic) difference between no turbulence, static turbulence, and turbulence influenced by particle velocity: http://mke3.net/blender/devel/rendering/volumetrics/turbu_compare.mov
2008-10-06 12:25:22 +00:00
//return rv;
Point Density texture The Point Density texture now has some additional options for how the point locations are cached. Previously it was all relative to worldspace, but there are now some other options that make things a lot more convenient for mapping the texture to Local (or Orco). Thanks to theeth for helping with the space conversions! The new Object space options allow this sort of thing to be possible - a particle system, instanced on a transformed renderable object: http://mke3.net/blender/devel/rendering/volumetrics/pd_objectspace.mov It's also a lot easier to use multiple instances, just duplicate the renderable objects and move them around. The new particle cache options are: * Emit Object space This caches the particles relative to the emitter object's coordinate space (i.e. relative to the emitter's object center). This makes it possible to map the Texture to Local or Orco easily, so you can easily move, rotate or scale the rendering object that has the Point Density texture. It's relative to the emitter's location, rotation and scale, so if the object you're rendering the texture on is aligned differently to the emitter, the results will be rotated etc. * Emit Object Location This offsets the particles to the emitter object's location in 3D space. It's similar to Emit Object Space, however the emitter object's rotation and scale are ignored. This is probably the easiest to use, since you don't need to worry about the rotation and scale of the emitter object (just the rendered object), so it's the default. * Global Space This is the same as previously, the particles are cached in global space, so to use this effectively you'll need to map the texture to Global, and have the rendered object in the right global location.
2008-09-29 04:19:24 +00:00
}
Copy Permalink