Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later.
Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
This commit is contained in:
Ton Roosendaal
230
intern/cycles/kernel/svm/svm_noise.h
Normal file
230
intern/cycles/kernel/svm/svm_noise.h
Normal file
@@ -0,0 +1,230 @@
|
||||
/*
|
||||
* Adapted from Open Shading Language with this license:
|
||||
*
|
||||
* Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Modifications Copyright 2011, Blender Foundation.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
* met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* * Neither the name of Sony Pictures Imageworks nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from
|
||||
* this software without specific prior written permission.
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
CCL_NAMESPACE_BEGIN
|
||||
|
||||
__device int quick_floor(float x)
|
||||
{
|
||||
return (int)x - ((x < 0) ? 1 : 0);
|
||||
}
|
||||
|
||||
__device float bits_to_01(uint bits)
|
||||
{
|
||||
return bits * (1.0f/(float)0xFFFFFFFF);
|
||||
}
|
||||
|
||||
__device uint hash(uint kx, uint ky, uint kz)
|
||||
{
|
||||
// define some handy macros
|
||||
#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
|
||||
#define final(a,b,c) \
|
||||
{ \
|
||||
c ^= b; c -= rot(b,14); \
|
||||
a ^= c; a -= rot(c,11); \
|
||||
b ^= a; b -= rot(a,25); \
|
||||
c ^= b; c -= rot(b,16); \
|
||||
a ^= c; a -= rot(c,4); \
|
||||
b ^= a; b -= rot(a,14); \
|
||||
c ^= b; c -= rot(b,24); \
|
||||
}
|
||||
// now hash the data!
|
||||
uint a, b, c, len = 3;
|
||||
a = b = c = 0xdeadbeef + (len << 2) + 13;
|
||||
|
||||
c += kz;
|
||||
b += ky;
|
||||
a += kx;
|
||||
final(a, b, c);
|
||||
|
||||
return c;
|
||||
// macros not needed anymore
|
||||
#undef rot
|
||||
#undef final
|
||||
}
|
||||
|
||||
__device int imod(int a, int b)
|
||||
{
|
||||
a %= b;
|
||||
return a < 0 ? a + b : a;
|
||||
}
|
||||
|
||||
__device uint phash(int kx, int ky, int kz, int3 p)
|
||||
{
|
||||
return hash(imod(kx, p.x), imod(ky, p.y), imod(kz, p.z));
|
||||
}
|
||||
|
||||
__device float floorfrac(float x, int* i)
|
||||
{
|
||||
*i = quick_floor(x);
|
||||
return x - *i;
|
||||
}
|
||||
|
||||
__device float fade(float t)
|
||||
{
|
||||
return t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f);
|
||||
}
|
||||
|
||||
__device float nerp(float t, float a, float b)
|
||||
{
|
||||
return (1.0f - t) * a + t * b;
|
||||
}
|
||||
|
||||
__device float grad(int hash, float x, float y, float z)
|
||||
{
|
||||
// use vectors pointing to the edges of the cube
|
||||
int h = hash & 15;
|
||||
float u = h<8 ? x : y;
|
||||
float v = h<4 ? y : h==12||h==14 ? x : z;
|
||||
return ((h&1) ? -u : u) + ((h&2) ? -v : v);
|
||||
}
|
||||
|
||||
__device float scale3(float result)
|
||||
{
|
||||
return 0.9820f * result;
|
||||
}
|
||||
|
||||
__device float perlin(float x, float y, float z)
|
||||
{
|
||||
int X; float fx = floorfrac(x, &X);
|
||||
int Y; float fy = floorfrac(y, &Y);
|
||||
int Z; float fz = floorfrac(z, &Z);
|
||||
|
||||
float u = fade(fx);
|
||||
float v = fade(fy);
|
||||
float w = fade(fz);
|
||||
|
||||
float result;
|
||||
|
||||
result = nerp (w, nerp (v, nerp (u, grad (hash (X , Y , Z ), fx , fy , fz ),
|
||||
grad (hash (X+1, Y , Z ), fx-1.0f, fy , fz )),
|
||||
nerp (u, grad (hash (X , Y+1, Z ), fx , fy-1.0f, fz ),
|
||||
grad (hash (X+1, Y+1, Z ), fx-1.0f, fy-1.0f, fz ))),
|
||||
nerp (v, nerp (u, grad (hash (X , Y , Z+1), fx , fy , fz-1.0f ),
|
||||
grad (hash (X+1, Y , Z+1), fx-1.0f, fy , fz-1.0f )),
|
||||
nerp (u, grad (hash (X , Y+1, Z+1), fx , fy-1.0f, fz-1.0f ),
|
||||
grad (hash (X+1, Y+1, Z+1), fx-1.0f, fy-1.0f, fz-1.0f ))));
|
||||
return scale3(result);
|
||||
}
|
||||
|
||||
__device float perlin_periodic(float x, float y, float z, float3 pperiod)
|
||||
{
|
||||
int X; float fx = floorfrac(x, &X);
|
||||
int Y; float fy = floorfrac(y, &Y);
|
||||
int Z; float fz = floorfrac(z, &Z);
|
||||
|
||||
int3 p;
|
||||
|
||||
p.x = fmaxf(quick_floor(pperiod.x), 1);
|
||||
p.y = fmaxf(quick_floor(pperiod.y), 1);
|
||||
p.z = fmaxf(quick_floor(pperiod.z), 1);
|
||||
|
||||
float u = fade(fx);
|
||||
float v = fade(fy);
|
||||
float w = fade(fz);
|
||||
|
||||
float result;
|
||||
|
||||
result = nerp (w, nerp (v, nerp (u, grad (phash (X , Y , Z , p), fx , fy , fz ),
|
||||
grad (phash (X+1, Y , Z , p), fx-1.0f, fy , fz )),
|
||||
nerp (u, grad (phash (X , Y+1, Z , p), fx , fy-1.0f, fz ),
|
||||
grad (phash (X+1, Y+1, Z , p), fx-1.0f, fy-1.0f, fz ))),
|
||||
nerp (v, nerp (u, grad (phash (X , Y , Z+1, p), fx , fy , fz-1.0f ),
|
||||
grad (phash (X+1, Y , Z+1, p), fx-1.0f, fy , fz-1.0f )),
|
||||
nerp (u, grad (phash (X , Y+1, Z+1, p), fx , fy-1.0f, fz-1.0f ),
|
||||
grad (phash (X+1, Y+1, Z+1, p), fx-1.0f, fy-1.0f, fz-1.0f ))));
|
||||
return scale3(result);
|
||||
}
|
||||
|
||||
/* perlin noise in range 0..1 */
|
||||
__device float noise(float3 p)
|
||||
{
|
||||
float r = perlin(p.x, p.y, p.z);
|
||||
return 0.5f*r + 0.5f;
|
||||
}
|
||||
|
||||
/* perlin noise in range -1..1 */
|
||||
__device float snoise(float3 p)
|
||||
{
|
||||
return perlin(p.x, p.y, p.z);
|
||||
}
|
||||
|
||||
/* cell noise */
|
||||
__device float cellnoise(float3 p)
|
||||
{
|
||||
uint ix = quick_floor(p.x);
|
||||
uint iy = quick_floor(p.y);
|
||||
uint iz = quick_floor(p.z);
|
||||
|
||||
return bits_to_01(hash(ix, iy, iz));
|
||||
}
|
||||
|
||||
__device float3 cellnoise_color(float3 p)
|
||||
{
|
||||
float r = cellnoise(p);
|
||||
float g = cellnoise(make_float3(p.y, p.x, p.z));
|
||||
float b = cellnoise(make_float3(p.y, p.z, p.x));
|
||||
|
||||
return make_float3(r, g, b);
|
||||
}
|
||||
|
||||
/* periodic perlin noise in range 0..1 */
|
||||
__device float pnoise(float3 p, float3 pperiod)
|
||||
{
|
||||
float r = perlin_periodic(p.x, p.y, p.z, pperiod);
|
||||
return 0.5f*r + 0.5f;
|
||||
}
|
||||
|
||||
/* periodic perlin noise in range -1..1 */
|
||||
__device float psnoise(float3 p, float3 pperiod)
|
||||
{
|
||||
return perlin_periodic(p.x, p.y, p.z, pperiod);
|
||||
}
|
||||
|
||||
/* turbulence */
|
||||
__device float turbulence(float3 P, int oct, bool hard)
|
||||
{
|
||||
float amp = 1.0f, fscale = 1.0f, sum = 0.0f;
|
||||
int i;
|
||||
|
||||
for(i=0; i<=oct; i++, amp *= 0.5f, fscale *= 2.0f) {
|
||||
float t = noise(fscale*P);
|
||||
if(hard) t = fabsf(2.0f*t - 1.0f);
|
||||
sum += t * amp;
|
||||
}
|
||||
|
||||
sum *= ((float)(1<<oct)/(float)((1<<(oct+1))-1));
|
||||
|
||||
return sum;
|
||||
}
|
||||
|
||||
CCL_NAMESPACE_END
|
||||
|
||||
Reference in New Issue
Block a user