diff options
Diffstat (limited to 'intern/cycles/kernel')
134 files changed, 17143 insertions, 0 deletions
diff --git a/intern/cycles/kernel/CMakeLists.txt b/intern/cycles/kernel/CMakeLists.txt new file mode 100644 index 00000000000..30b618eb1ad --- /dev/null +++ b/intern/cycles/kernel/CMakeLists.txt @@ -0,0 +1,104 @@ + +SET(sources + kernel.cpp + kernel.cl + kernel.cu) + +SET(headers + kernel.h + kernel_bvh.h + kernel_camera.h + kernel_compat_cpu.h + kernel_compat_cuda.h + kernel_compat_opencl.h + kernel_differential.h + kernel_displace.h + kernel_emission.h + kernel_film.h + kernel_globals.h + kernel_light.h + kernel_math.h + kernel_mbvh.h + kernel_montecarlo.h + kernel_object.h + kernel_path.h + kernel_qbvh.h + kernel_random.h + kernel_shader.h + kernel_triangle.h + kernel_types.h + svm/bsdf.h + svm/bsdf_ashikhmin_velvet.h + svm/bsdf_diffuse.h + svm/bsdf_microfacet.h + svm/bsdf_reflection.h + svm/bsdf_refraction.h + svm/bsdf_transparent.h + svm/bsdf_ward.h + svm/bsdf_westin.h + svm/emissive.h + svm/svm.h + svm/svm_attribute.h + svm/svm_blend.h + svm/svm_bsdf.h + svm/svm_closure.h + svm/svm_clouds.h + svm/svm_convert.h + svm/svm_displace.h + svm/svm_distorted_noise.h + svm/svm_fresnel.h + svm/svm_geometry.h + svm/svm_image.h + svm/svm_light_path.h + svm/svm_magic.h + svm/svm_mapping.h + svm/svm_marble.h + svm/svm_math.h + svm/svm_mix.h + svm/svm_musgrave.h + svm/svm_noise.h + svm/svm_noisetex.h + svm/svm_sky.h + svm/svm_stucci.h + svm/svm_tex_coord.h + svm/svm_texture.h + svm/svm_types.h + svm/svm_value.h + svm/svm_voronoi.h + svm/svm_wood.h + svm/volume.h + ) + +# CUDA module + +IF(WITH_CUDA) + SET(cuda_sources kernel.cu ${headers}) + SET(cuda_cubins) + + FOREACH(arch ${CUDA_ARCH}) + SET(cuda_cubin kernel_${arch}.cubin) + + ADD_CUSTOM_COMMAND( + OUTPUT ${cuda_cubin} + COMMAND ${CUDA_NVCC} -arch=${arch} -m64 --cubin ${CMAKE_CURRENT_SOURCE_DIR}/kernel.cu --use_fast_math -o ${CMAKE_CURRENT_BINARY_DIR}/${cuda_cubin} --ptxas-options="-v" --maxrregcount=${CUDA_MAXREG} --opencc-options -OPT:Olimit=0 -I${CMAKE_CURRENT_SOURCE_DIR}/../util -I${CMAKE_CURRENT_SOURCE_DIR}/svm -DCCL_NAMESPACE_BEGIN= -DCCL_NAMESPACE_END= + DEPENDS ${cuda_sources}) + + INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${cuda_cubin} DESTINATION ${INSTALL_PATH}/cycles/lib) + LIST(APPEND cuda_cubins ${cuda_cubin}) + ENDFOREACH() + + ADD_CUSTOM_TARGET(kernel_cuda ALL DEPENDS ${cuda_cubins}) +ENDIF(WITH_CUDA) + +# OSL module + +IF(WITH_OSL) + ADD_SUBDIRECTORY(osl) +ENDIF(WITH_OSL) + +# CPU module + +INCLUDE_DIRECTORIES(. ../util osl svm) + +ADD_LIBRARY(kernel ${sources} ${headers}) + diff --git a/intern/cycles/kernel/kernel.cl b/intern/cycles/kernel/kernel.cl new file mode 100644 index 00000000000..a22db5fe040 --- /dev/null +++ b/intern/cycles/kernel/kernel.cl @@ -0,0 +1,105 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +/* OpenCL kernel entry points - unfinished */ + +#include "kernel_compat_opencl.h" +#include "kernel_math.h" +#include "kernel_types.h" +#include "kernel_globals.h" + +typedef struct KernelGlobals { + __constant KernelData *data; + + __global float *__response_curve_R; + int __response_curve_R_width; + + __global float *__response_curve_G; + int __response_curve_G_width; + + __global float *__response_curve_B; + int __response_curve_B_width; +} KernelGlobals; + +#include "kernel_film.h" +//#include "kernel_path.h" +//#include "kernel_displace.h" + +__kernel void kernel_ocl_path_trace(__constant KernelData *data, __global float4 *buffer, __global uint *rng_state, int pass, int sx, int sy, int sw, int sh) +{ + KernelGlobals kglobals, *kg = &kglobals; + kg->data = data; + + int x = get_global_id(0); + int y = get_global_id(1); + int w = kernel_data.cam.width; + + if(x < sx + sw && y < sy + sh) { + if(pass == 0) { + buffer[x + w*y].x = 0.5f; + buffer[x + w*y].y = 0.5f; + buffer[x + w*y].z = 0.5f; + } + else { + buffer[x + w*y].x += 0.5f; + buffer[x + w*y].y += 0.5f; + buffer[x + w*y].z += 0.5f; + } + + //= make_float3(1.0f, 0.9f, 0.0f); + //kernel_path_trace(buffer, rng_state, pass, x, y); + } +} + +__kernel void kernel_ocl_tonemap( + __constant KernelData *data, + __global uchar4 *rgba, + __global float4 *buffer, + __global float *__response_curve_R, + int __response_curve_R_width, + __global float *__response_curve_G, + int __response_curve_G_width, + __global float *__response_curve_B, + int __response_curve_B_width, + int pass, int resolution, + int sx, int sy, int sw, int sh) +{ + KernelGlobals kglobals, *kg = &kglobals; + + kg->data = data; + kg->__response_curve_R = __response_curve_R; + kg->__response_curve_R_width = __response_curve_R_width; + kg->__response_curve_G = __response_curve_G; + kg->__response_curve_G_width = __response_curve_G_width; + kg->__response_curve_B = __response_curve_B; + kg->__response_curve_B_width = __response_curve_B_width; + + int x = sx + get_global_id(0); + int y = sy + get_global_id(1); + + if(x < sx + sw && y < sy + sh) + kernel_film_tonemap(kg, rgba, buffer, pass, resolution, x, y); +} + +__kernel void kernel_ocl_displace(__global uint4 *input, __global float3 *offset, int sx) +{ + int x = sx + get_global_id(0); + + kernel_displace(input, offset, x); +} + diff --git a/intern/cycles/kernel/kernel.cpp b/intern/cycles/kernel/kernel.cpp new file mode 100644 index 00000000000..656e90eb526 --- /dev/null +++ b/intern/cycles/kernel/kernel.cpp @@ -0,0 +1,300 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +/* CPU kernel entry points */ + +#include "kernel.h" +#include "kernel_compat_cpu.h" +#include "kernel_math.h" +#include "kernel_types.h" +#include "kernel_globals.h" +#include "kernel_film.h" +#include "kernel_path.h" +#include "kernel_displace.h" + +CCL_NAMESPACE_BEGIN + +/* Globals */ + +KernelGlobals *kernel_globals_create() +{ + KernelGlobals *kg = new KernelGlobals(); +#ifdef WITH_OSL + kg->osl.use = false; +#endif + return kg; +} + +void kernel_globals_free(KernelGlobals *kg) +{ + delete kg; +} + +/* OSL */ + +#ifdef WITH_OSL + +void *kernel_osl_memory(KernelGlobals *kg) +{ + return (void*)&kg->osl; +} + +bool kernel_osl_use(KernelGlobals *kg) +{ + return kg->osl.use; +} + +#endif + +/* Memory Copy */ + +void kernel_const_copy(KernelGlobals *kg, const char *name, void *host, size_t size) +{ + if(strcmp(name, "__data") == 0) + memcpy(&kg->__data, host, size); + else + assert(0); +} + +void kernel_tex_copy(KernelGlobals *kg, const char *name, device_ptr mem, size_t width, size_t height) +{ + if(strcmp(name, "__bvh_nodes") == 0) { + kg->__bvh_nodes.data = (float4*)mem; + kg->__bvh_nodes.width = width; + } + else if(strcmp(name, "__objects") == 0) { + kg->__objects.data = (float4*)mem; + kg->__objects.width = width; + } + else if(strcmp(name, "__tri_normal") == 0) { + kg->__tri_normal.data = (float4*)mem; + kg->__tri_normal.width = width; + } + else if(strcmp(name, "__tri_woop") == 0) { + kg->__tri_woop.data = (float4*)mem; + kg->__tri_woop.width = width; + } + else if(strcmp(name, "__prim_index") == 0) { + kg->__prim_index.data = (uint*)mem; + kg->__prim_index.width = width; + } + else if(strcmp(name, "__prim_object") == 0) { + kg->__prim_object.data = (uint*)mem; + kg->__prim_object.width = width; + } + else if(strcmp(name, "__object_node") == 0) { + kg->__object_node.data = (uint*)mem; + kg->__object_node.width = width; + } + else if(strcmp(name, "__tri_vnormal") == 0) { + kg->__tri_vnormal.data = (float4*)mem; + kg->__tri_vnormal.width = width; + } + else if(strcmp(name, "__tri_vindex") == 0) { + kg->__tri_vindex.data = (float4*)mem; + kg->__tri_vindex.width = width; + } + else if(strcmp(name, "__tri_verts") == 0) { + kg->__tri_verts.data = (float4*)mem; + kg->__tri_verts.width = width; + } + else if(strcmp(name, "__light_distribution") == 0) { + kg->__light_distribution.data = (float4*)mem; + kg->__light_distribution.width = width; + } + else if(strcmp(name, "__light_point") == 0) { + kg->__light_point.data = (float4*)mem; + kg->__light_point.width = width; + } + else if(strcmp(name, "__svm_nodes") == 0) { + kg->__svm_nodes.data = (uint4*)mem; + kg->__svm_nodes.width = width; + } + else if(strcmp(name, "__filter_table") == 0) { + kg->__filter_table.data = (float*)mem; + kg->__filter_table.width = width; + } + else if(strcmp(name, "__response_curve_R") == 0) { + kg->__response_curve_R.data = (float*)mem; + kg->__response_curve_R.width = width; + } + else if(strcmp(name, "__response_curve_B") == 0) { + kg->__response_curve_B.data = (float*)mem; + kg->__response_curve_B.width = width; + } + else if(strcmp(name, "__response_curve_G") == 0) { + kg->__response_curve_G.data = (float*)mem; + kg->__response_curve_G.width = width; + } + else if(strcmp(name, "__sobol_directions") == 0) { + kg->__sobol_directions.data = (uint*)mem; + kg->__sobol_directions.width = width; + } + else if(strcmp(name, "__attributes_map") == 0) { + kg->__attributes_map.data = (uint4*)mem; + kg->__attributes_map.width = width; + } + else if(strcmp(name, "__attributes_float") == 0) { + kg->__attributes_float.data = (float*)mem; + kg->__attributes_float.width = width; + } + else if(strcmp(name, "__attributes_float3") == 0) { + kg->__attributes_float3.data = (float4*)mem; + kg->__attributes_float3.width = width; + } + else if(strstr(name, "__tex_image")) { + texture_image_uchar4 *tex = NULL; + int id = atoi(name + strlen("__tex_image_")); + + switch(id) { + case 0: tex = &kg->__tex_image_000; break; + case 1: tex = &kg->__tex_image_001; break; + case 2: tex = &kg->__tex_image_002; break; + case 3: tex = &kg->__tex_image_003; break; + case 4: tex = &kg->__tex_image_004; break; + case 5: tex = &kg->__tex_image_005; break; + case 6: tex = &kg->__tex_image_006; break; + case 7: tex = &kg->__tex_image_007; break; + case 8: tex = &kg->__tex_image_008; break; + case 9: tex = &kg->__tex_image_009; break; + case 10: tex = &kg->__tex_image_010; break; + case 11: tex = &kg->__tex_image_011; break; + case 12: tex = &kg->__tex_image_012; break; + case 13: tex = &kg->__tex_image_013; break; + case 14: tex = &kg->__tex_image_014; break; + case 15: tex = &kg->__tex_image_015; break; + case 16: tex = &kg->__tex_image_016; break; + case 17: tex = &kg->__tex_image_017; break; + case 18: tex = &kg->__tex_image_018; break; + case 19: tex = &kg->__tex_image_019; break; + case 20: tex = &kg->__tex_image_020; break; + case 21: tex = &kg->__tex_image_021; break; + case 22: tex = &kg->__tex_image_022; break; + case 23: tex = &kg->__tex_image_023; break; + case 24: tex = &kg->__tex_image_024; break; + case 25: tex = &kg->__tex_image_025; break; + case 26: tex = &kg->__tex_image_026; break; + case 27: tex = &kg->__tex_image_027; break; + case 28: tex = &kg->__tex_image_028; break; + case 29: tex = &kg->__tex_image_029; break; + case 30: tex = &kg->__tex_image_030; break; + case 31: tex = &kg->__tex_image_031; break; + case 32: tex = &kg->__tex_image_032; break; + case 33: tex = &kg->__tex_image_033; break; + case 34: tex = &kg->__tex_image_034; break; + case 35: tex = &kg->__tex_image_035; break; + case 36: tex = &kg->__tex_image_036; break; + case 37: tex = &kg->__tex_image_037; break; + case 38: tex = &kg->__tex_image_038; break; + case 39: tex = &kg->__tex_image_039; break; + case 40: tex = &kg->__tex_image_040; break; + case 41: tex = &kg->__tex_image_041; break; + case 42: tex = &kg->__tex_image_042; break; + case 43: tex = &kg->__tex_image_043; break; + case 44: tex = &kg->__tex_image_044; break; + case 45: tex = &kg->__tex_image_045; break; + case 46: tex = &kg->__tex_image_046; break; + case 47: tex = &kg->__tex_image_047; break; + case 48: tex = &kg->__tex_image_048; break; + case 49: tex = &kg->__tex_image_049; break; + case 50: tex = &kg->__tex_image_050; break; + case 51: tex = &kg->__tex_image_051; break; + case 52: tex = &kg->__tex_image_052; break; + case 53: tex = &kg->__tex_image_053; break; + case 54: tex = &kg->__tex_image_054; break; + case 55: tex = &kg->__tex_image_055; break; + case 56: tex = &kg->__tex_image_056; break; + case 57: tex = &kg->__tex_image_057; break; + case 58: tex = &kg->__tex_image_058; break; + case 59: tex = &kg->__tex_image_059; break; + case 60: tex = &kg->__tex_image_060; break; + case 61: tex = &kg->__tex_image_061; break; + case 62: tex = &kg->__tex_image_062; break; + case 63: tex = &kg->__tex_image_063; break; + case 64: tex = &kg->__tex_image_064; break; + case 65: tex = &kg->__tex_image_065; break; + case 66: tex = &kg->__tex_image_066; break; + case 67: tex = &kg->__tex_image_067; break; + case 68: tex = &kg->__tex_image_068; break; + case 69: tex = &kg->__tex_image_069; break; + case 70: tex = &kg->__tex_image_070; break; + case 71: tex = &kg->__tex_image_071; break; + case 72: tex = &kg->__tex_image_072; break; + case 73: tex = &kg->__tex_image_073; break; + case 74: tex = &kg->__tex_image_074; break; + case 75: tex = &kg->__tex_image_075; break; + case 76: tex = &kg->__tex_image_076; break; + case 77: tex = &kg->__tex_image_077; break; + case 78: tex = &kg->__tex_image_078; break; + case 79: tex = &kg->__tex_image_079; break; + case 80: tex = &kg->__tex_image_080; break; + case 81: tex = &kg->__tex_image_081; break; + case 82: tex = &kg->__tex_image_082; break; + case 83: tex = &kg->__tex_image_083; break; + case 84: tex = &kg->__tex_image_084; break; + case 85: tex = &kg->__tex_image_085; break; + case 86: tex = &kg->__tex_image_086; break; + case 87: tex = &kg->__tex_image_087; break; + case 88: tex = &kg->__tex_image_088; break; + case 89: tex = &kg->__tex_image_089; break; + case 90: tex = &kg->__tex_image_090; break; + case 91: tex = &kg->__tex_image_091; break; + case 92: tex = &kg->__tex_image_092; break; + case 93: tex = &kg->__tex_image_093; break; + case 94: tex = &kg->__tex_image_094; break; + case 95: tex = &kg->__tex_image_095; break; + case 96: tex = &kg->__tex_image_096; break; + case 97: tex = &kg->__tex_image_097; break; + case 98: tex = &kg->__tex_image_098; break; + case 99: tex = &kg->__tex_image_099; break; + default: break; + } + + if(tex) { + tex->data = (uchar4*)mem; + tex->width = width; + tex->height = height; + } + } + else + assert(0); +} + +/* Path Tracing */ + +void kernel_cpu_path_trace(KernelGlobals *kg, float4 *buffer, unsigned int *rng_state, int pass, int x, int y) +{ + kernel_path_trace(kg, buffer, rng_state, pass, x, y); +} + +/* Tonemapping */ + +void kernel_cpu_tonemap(KernelGlobals *kg, uchar4 *rgba, float4 *buffer, int pass, int resolution, int x, int y) +{ + kernel_film_tonemap(kg, rgba, buffer, pass, resolution, x, y); +} + +/* Displacement */ + +void kernel_cpu_displace(KernelGlobals *kg, uint4 *input, float3 *offset, int i) +{ + kernel_displace(kg, input, offset, i); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/kernel.cu b/intern/cycles/kernel/kernel.cu new file mode 100644 index 00000000000..5e5b445ac2c --- /dev/null +++ b/intern/cycles/kernel/kernel.cu @@ -0,0 +1,53 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +/* CUDA kernel entry points */ + +#include "kernel_compat_cuda.h" +#include "kernel_math.h" +#include "kernel_types.h" +#include "kernel_globals.h" +#include "kernel_film.h" +#include "kernel_path.h" +#include "kernel_displace.h" + +extern "C" __global__ void kernel_cuda_path_trace(float4 *buffer, uint *rng_state, int pass, int sx, int sy, int sw, int sh) +{ + int x = sx + blockDim.x*blockIdx.x + threadIdx.x; + int y = sy + blockDim.y*blockIdx.y + threadIdx.y; + + if(x < sx + sw && y < sy + sh) + kernel_path_trace(NULL, buffer, rng_state, pass, x, y); +} + +extern "C" __global__ void kernel_cuda_tonemap(uchar4 *rgba, float4 *buffer, int pass, int resolution, int sx, int sy, int sw, int sh) +{ + int x = sx + blockDim.x*blockIdx.x + threadIdx.x; + int y = sy + blockDim.y*blockIdx.y + threadIdx.y; + + if(x < sx + sw && y < sy + sh) + kernel_film_tonemap(NULL, rgba, buffer, pass, resolution, x, y); +} + +extern "C" __global__ void kernel_cuda_displace(uint4 *input, float3 *offset, int sx) +{ + int x = sx + blockDim.x*blockIdx.x + threadIdx.x; + + kernel_displace(NULL, input, offset, x); +} + diff --git a/intern/cycles/kernel/kernel.h b/intern/cycles/kernel/kernel.h new file mode 100644 index 00000000000..2bab585c6e6 --- /dev/null +++ b/intern/cycles/kernel/kernel.h @@ -0,0 +1,47 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __KERNEL_H__ +#define __KERNEL_H__ + +/* CPU Kernel Interfae */ + +#include "util_types.h" + +CCL_NAMESPACE_BEGIN + +struct KernelGlobals; + +KernelGlobals *kernel_globals_create(); +void kernel_globals_free(KernelGlobals *kg); + +void *kernel_osl_memory(KernelGlobals *kg); +bool kernel_osl_use(KernelGlobals *kg); + +void kernel_const_copy(KernelGlobals *kg, const char *name, void *host, size_t size); +void kernel_tex_copy(KernelGlobals *kg, const char *name, device_ptr mem, size_t width, size_t height); + +void kernel_cpu_path_trace(KernelGlobals *kg, float4 *buffer, unsigned int *rng_state, int pass, int x, int y); +void kernel_cpu_tonemap(KernelGlobals *kg, uchar4 *rgba, float4 *buffer, int pass, int resolution, int x, int y); + +void kernel_cpu_displace(KernelGlobals *kg, uint4 *input, float3 *offset, int i); + +CCL_NAMESPACE_END + +#endif /* __KERNEL_H__ */ + diff --git a/intern/cycles/kernel/kernel_bvh.h b/intern/cycles/kernel/kernel_bvh.h new file mode 100644 index 00000000000..4dea540e31c --- /dev/null +++ b/intern/cycles/kernel/kernel_bvh.h @@ -0,0 +1,361 @@ +/* + * Adapted from code Copyright 2009-2010 NVIDIA Corporation + * Modifications Copyright 2011, Blender Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +CCL_NAMESPACE_BEGIN + +/* + * "Persistent while-while kernel" used in: + * + * "Understanding the Efficiency of Ray Traversal on GPUs", + * Timo Aila and Samuli Laine, + * Proc. High-Performance Graphics 2009 + */ + +/* bottom-most stack entry, indicating the end of traversal */ + +#define ENTRYPOINT_SENTINEL 0x76543210 +/* 64 object BVH + 64 mesh BVH + 64 object node splitting */ +#define BVH_STACK_SIZE 192 +#define BVH_NODE_SIZE 4 +#define TRI_NODE_SIZE 3 + +__device_inline float3 bvh_inverse_direction(float3 dir) +{ + /* avoid divide by zero (ooeps = exp2f(-80.0f)) */ + float ooeps = 0.00000000000000000000000082718061255302767487140869206996285356581211090087890625f; + float3 idir; + + idir.x = 1.0f/((fabsf(dir.x) > ooeps)? dir.x: copysignf(ooeps, dir.x)); + idir.y = 1.0f/((fabsf(dir.y) > ooeps)? dir.y: copysignf(ooeps, dir.y)); + idir.z = 1.0f/((fabsf(dir.z) > ooeps)? dir.z: copysignf(ooeps, dir.z)); + + return idir; +} + +__device_inline void bvh_instance_push(KernelGlobals *kg, int object, const Ray *ray, float3 *P, float3 *idir, float *t, const float tmax) +{ + Transform tfm = object_fetch_transform(kg, object, OBJECT_INVERSE_TRANSFORM); + + *P = transform(&tfm, ray->P); + + float3 dir = transform_direction(&tfm, ray->D); + + float len; + dir = normalize_len(dir, &len); + + *idir = bvh_inverse_direction(dir); + + if(*t != FLT_MAX) + *t *= len; +} + +__device_inline void bvh_instance_pop(KernelGlobals *kg, int object, const Ray *ray, float3 *P, float3 *idir, float *t, const float tmax) +{ + Transform tfm = object_fetch_transform(kg, object, OBJECT_TRANSFORM); + + if(*t != FLT_MAX) + *t *= len(transform_direction(&tfm, 1.0f/(*idir))); + + *P = ray->P; + *idir = bvh_inverse_direction(ray->D); +} + +/* intersect two bounding boxes */ +__device_inline void bvh_node_intersect(KernelGlobals *kg, + bool *traverseChild0, bool *traverseChild1, + bool *closestChild1, int *nodeAddr0, int *nodeAddr1, + float3 P, float3 idir, float t, int nodeAddr) +{ + /* fetch node data */ + float4 n0xy = kernel_tex_fetch(__bvh_nodes, nodeAddr*BVH_NODE_SIZE+0); + float4 n1xy = kernel_tex_fetch(__bvh_nodes, nodeAddr*BVH_NODE_SIZE+1); + float4 nz = kernel_tex_fetch(__bvh_nodes, nodeAddr*BVH_NODE_SIZE+2); + float4 cnodes = kernel_tex_fetch(__bvh_nodes, nodeAddr*BVH_NODE_SIZE+3); + + /* intersect ray against child nodes */ + float3 ood = P * idir; + float c0lox = n0xy.x * idir.x - ood.x; + float c0hix = n0xy.y * idir.x - ood.x; + float c0loy = n0xy.z * idir.y - ood.y; + float c0hiy = n0xy.w * idir.y - ood.y; + float c0loz = nz.x * idir.z - ood.z; + float c0hiz = nz.y * idir.z - ood.z; + float c1loz = nz.z * idir.z - ood.z; + float c1hiz = nz.w * idir.z - ood.z; + + float c0min_x = min(c0lox, c0hix); + float c0min_y = min(c0loy, c0hiy); + float c0min_z = min(c0loz, c0hiz); + + float c0min = max4(c0min_x, c0min_y, c0min_z, 0.0f); + float c0max = min4(max(c0lox, c0hix), max(c0loy, c0hiy), max(c0loz, c0hiz), t); + float c1lox = n1xy.x * idir.x - ood.x; + float c1hix = n1xy.y * idir.x - ood.x; + float c1loy = n1xy.z * idir.y - ood.y; + float c1hiy = n1xy.w * idir.y - ood.y; + float c1min = max4(min(c1lox, c1hix), min(c1loy, c1hiy), min(c1loz, c1hiz), 0.0f); + float c1max = min4(max(c1lox, c1hix), max(c1loy, c1hiy), max(c1loz, c1hiz), t); + + /* decide which nodes to traverse next */ + *traverseChild0 = (c0max >= c0min); + *traverseChild1 = (c1max >= c1min); + + *nodeAddr0 = __float_as_int(cnodes.x); + *nodeAddr1 = __float_as_int(cnodes.y); + + *closestChild1 = (c1min < c0min); +} + +/* Sven Woop's algorithm */ +__device_inline void bvh_triangle_intersect(KernelGlobals *kg, Intersection *isect, float3 P, float3 idir, int object, int triAddr) +{ + /* compute and check intersection t-value */ + float4 v00 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+0); + float4 v11 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+1); + float3 dir = 1.0f/idir; + + float Oz = v00.w - P.x*v00.x - P.y*v00.y - P.z*v00.z; + float invDz = 1.0f/(dir.x*v00.x + dir.y*v00.y + dir.z*v00.z); + float t = Oz * invDz; + + if(t > 0.0f && t < isect->t) { + /* compute and check barycentric u */ + float Ox = v11.w + P.x*v11.x + P.y*v11.y + P.z*v11.z; + float Dx = dir.x*v11.x + dir.y*v11.y + dir.z*v11.z; + float u = Ox + t*Dx; + + if(u >= 0.0f) { + /* compute and check barycentric v */ + float4 v22 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+2); + float Oy = v22.w + P.x*v22.x + P.y*v22.y + P.z*v22.z; + float Dy = dir.x*v22.x + dir.y*v22.y + dir.z*v22.z; + float v = Oy + t*Dy; + + if(v >= 0.0f && u + v <= 1.0f) { + /* record intersection */ + isect->prim = triAddr; + isect->object = object; + isect->u = u; + isect->v = v; + isect->t = t; + } + } + } +} + +__device_inline bool scene_intersect(KernelGlobals *kg, const Ray *ray, const bool isshadowray, Intersection *isect) +{ + /* traversal stack in CUDA thread-local memory */ + int traversalStack[BVH_STACK_SIZE]; + traversalStack[0] = ENTRYPOINT_SENTINEL; + + /* traversal variables in registers */ + int stackPtr = 0; + int nodeAddr = kernel_data.bvh.root; + + /* ray parameters in registers */ + const float tmax = ray->t; + float3 P = ray->P; + float3 idir = bvh_inverse_direction(ray->D); + int object = ~0; + + isect->t = tmax; + isect->object = ~0; + isect->prim = ~0; + isect->u = 0.0f; + isect->v = 0.0f; + + /* traversal loop */ + do { + do + { + /* traverse internal nodes */ + while(nodeAddr >= 0 && nodeAddr != ENTRYPOINT_SENTINEL) + { + bool traverseChild0, traverseChild1, closestChild1; + int nodeAddrChild1; + + bvh_node_intersect(kg, &traverseChild0, &traverseChild1, + &closestChild1, &nodeAddr, &nodeAddrChild1, + P, idir, isect->t, nodeAddr); + + if(traverseChild0 != traverseChild1) { + /* one child was intersected */ + if(traverseChild1) { + nodeAddr = nodeAddrChild1; + } + } + else { + if(!traverseChild0) { + /* neither child was intersected */ + nodeAddr = traversalStack[stackPtr]; + --stackPtr; + } + else { + /* both children were intersected, push the farther one */ + if(closestChild1) { + int tmp = nodeAddr; + nodeAddr = nodeAddrChild1; + nodeAddrChild1 = tmp; + } + + ++stackPtr; + traversalStack[stackPtr] = nodeAddrChild1; + } + } + } + + /* if node is leaf, fetch triangle list */ + if(nodeAddr < 0) { + float4 leaf = kernel_tex_fetch(__bvh_nodes, (-nodeAddr-1)*BVH_NODE_SIZE+(BVH_NODE_SIZE-1)); + int primAddr = __float_as_int(leaf.x); + +#ifdef __INSTANCING__ + if(primAddr >= 0) { +#endif + int primAddr2 = __float_as_int(leaf.y); + + /* pop */ + nodeAddr = traversalStack[stackPtr]; + --stackPtr; + + /* triangle intersection */ + while(primAddr < primAddr2) { + /* intersect ray against triangle */ + bvh_triangle_intersect(kg, isect, P, idir, object, primAddr); + + /* shadow ray early termination */ + if(isshadowray && isect->prim != ~0) + return true; + + primAddr++; + } +#ifdef __INSTANCING__ + } + else { + /* instance push */ + object = kernel_tex_fetch(__prim_object, -primAddr-1); + + bvh_instance_push(kg, object, ray, &P, &idir, &isect->t, tmax); + + ++stackPtr; + traversalStack[stackPtr] = ENTRYPOINT_SENTINEL; + + nodeAddr = kernel_tex_fetch(__object_node, object); + } +#endif + } + } while(nodeAddr != ENTRYPOINT_SENTINEL); + +#ifdef __INSTANCING__ + if(stackPtr >= 0) { + kernel_assert(object != ~0); + + /* instance pop */ + bvh_instance_pop(kg, object, ray, &P, &idir, &isect->t, tmax); + object = ~0; + nodeAddr = traversalStack[stackPtr]; + --stackPtr; + } +#endif + } while(nodeAddr != ENTRYPOINT_SENTINEL); + + return (isect->prim != ~0); +} + +__device_inline float3 ray_offset(float3 P, float3 Ng) +{ +#ifdef __INTERSECTION_REFINE__ + const float epsilon_f = 1e-5f; + const int epsilon_i = 32; + + float3 res; + + /* x component */ + if(fabsf(P.x) < epsilon_f) { + res.x = P.x + Ng.x*epsilon_f; + } + else { + uint ix = __float_as_uint(P.x); + ix += ((ix ^ __float_as_uint(Ng.x)) >> 31)? -epsilon_i: epsilon_i; + res.x = __uint_as_float(ix); + } + + /* y component */ + if(fabsf(P.y) < epsilon_f) { + res.y = P.y + Ng.y*epsilon_f; + } + else { + uint iy = __float_as_uint(P.y); + iy += ((iy ^ __float_as_uint(Ng.y)) >> 31)? -epsilon_i: epsilon_i; + res.y = __uint_as_float(iy); + } + + /* z component */ + if(fabsf(P.z) < epsilon_f) { + res.z = P.z + Ng.z*epsilon_f; + } + else { + uint iz = __float_as_uint(P.z); + iz += ((iz ^ __float_as_uint(Ng.z)) >> 31)? -epsilon_i: epsilon_i; + res.z = __uint_as_float(iz); + } + + return res; +#else + const float epsilon_f = 1e-4f; + return P + epsilon_f*Ng; +#endif +} + +__device_inline float3 bvh_triangle_refine(KernelGlobals *kg, const Intersection *isect, const Ray *ray) +{ + float3 P = ray->P; + float3 D = ray->D; + float t = isect->t; + +#ifdef __INTERSECTION_REFINE__ + if(isect->object != ~0) { + Transform tfm = object_fetch_transform(kg, isect->object, OBJECT_INVERSE_TRANSFORM); + + P = transform(&tfm, P); + D = transform_direction(&tfm, D*t); + D = normalize_len(D, &t); + } + + P = P + D*t; + + float4 v00 = kernel_tex_fetch(__tri_woop, isect->prim*TRI_NODE_SIZE+0); + float Oz = v00.w - P.x*v00.x - P.y*v00.y - P.z*v00.z; + float invDz = 1.0f/(D.x*v00.x + D.y*v00.y + D.z*v00.z); + float rt = Oz * invDz; + + P = P + D*rt; + + if(isect->object != ~0) { + Transform tfm = object_fetch_transform(kg, isect->object, OBJECT_TRANSFORM); + P = transform(&tfm, P); + } + + return P; +#else + return P + D*t; +#endif +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/kernel_camera.h b/intern/cycles/kernel/kernel_camera.h new file mode 100644 index 00000000000..1f93394e078 --- /dev/null +++ b/intern/cycles/kernel/kernel_camera.h @@ -0,0 +1,132 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Perspective Camera */ + +__device void camera_sample_perspective(KernelGlobals *kg, float raster_x, float raster_y, float lens_u, float lens_v, Ray *ray) +{ + /* create ray form raster position */ + Transform rastertocamera = kernel_data.cam.rastertocamera; + float3 Pcamera = transform(&rastertocamera, make_float3(raster_x, raster_y, 0.0f)); + + ray->P = make_float3(0.0f, 0.0f, 0.0f); + ray->D = Pcamera; + + /* modify ray for depth of field */ + float lensradius = kernel_data.cam.lensradius; + + if(lensradius > 0.0f) { + /* sample point on lens */ + float2 lensuv; + + lensuv = concentric_sample_disk(lens_u, lens_v); + lensuv *= lensradius; + + /* compute point on plane of focus */ + float ft = kernel_data.cam.focaldistance/ray->D.z; + float3 Pfocus = ray->P + ray->D*ft; + + /* update ray for effect of lens */ + ray->P = make_float3(lensuv.x, lensuv.y, 0.0f); + ray->D = normalize(Pfocus - ray->P); + } + + /* transform ray from camera to world */ + Transform cameratoworld = kernel_data.cam.cameratoworld; + + ray->P = transform(&cameratoworld, ray->P); + ray->D = transform_direction(&cameratoworld, ray->D); + ray->D = normalize(ray->D); + +#ifdef __RAY_DIFFERENTIALS__ + /* ray differential */ + float3 Ddiff = transform_direction(&cameratoworld, Pcamera); + + ray->dP.dx = make_float3(0.0f, 0.0f, 0.0f); + ray->dP.dy = make_float3(0.0f, 0.0f, 0.0f); + + ray->dD.dx = normalize(Ddiff + kernel_data.cam.dx) - normalize(Ddiff); + ray->dD.dy = normalize(Ddiff + kernel_data.cam.dy) - normalize(Ddiff); +#endif + +#ifdef __CAMERA_CLIPPING__ + /* clipping */ + ray->P += kernel_data.cam.nearclip*ray->D; + ray->t = kernel_data.cam.cliplength; +#else + ray->t = FLT_MAX; +#endif +} + +/* Orthographic Camera */ + +__device void camera_sample_orthographic(KernelGlobals *kg, float raster_x, float raster_y, Ray *ray) +{ + /* create ray form raster position */ + Transform rastertocamera = kernel_data.cam.rastertocamera; + float3 Pcamera = transform(&rastertocamera, make_float3(raster_x, raster_y, 0.0f)); + + ray->P = Pcamera; + ray->D = make_float3(0.0f, 0.0f, 1.0f); + + /* transform ray from camera to world */ + Transform cameratoworld = kernel_data.cam.cameratoworld; + + ray->P = transform(&cameratoworld, ray->P); + ray->D = transform_direction(&cameratoworld, ray->D); + ray->D = normalize(ray->D); + +#ifdef __RAY_DIFFERENTIALS__ + /* ray differential */ + ray->dP.dx = kernel_data.cam.dx; + ray->dP.dy = kernel_data.cam.dy; + + ray->dD.dx = make_float3(0.0f, 0.0f, 0.0f); + ray->dD.dy = make_float3(0.0f, 0.0f, 0.0f); +#endif + +#ifdef __CAMERA_CLIPPING__ + /* clipping */ + ray->t = kernel_data.cam.cliplength; +#else + ray->t = FLT_MAX; +#endif +} + +/* Common */ + +__device void camera_sample(KernelGlobals *kg, int x, int y, float filter_u, float filter_v, float lens_u, float lens_v, Ray *ray) +{ + /* pixel filter */ + float raster_x = x + kernel_tex_interp(__filter_table, filter_u); + float raster_y = y + kernel_tex_interp(__filter_table, filter_v); + + /* motion blur */ + //ray->time = lerp(time_t, kernel_data.cam.shutter_open, kernel_data.cam.shutter_close); + + /* sample */ + if(kernel_data.cam.ortho) + camera_sample_orthographic(kg, raster_x, raster_y, ray); + else + camera_sample_perspective(kg, raster_x, raster_y, lens_u, lens_v, ray); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/kernel_compat_cpu.h b/intern/cycles/kernel/kernel_compat_cpu.h new file mode 100644 index 00000000000..cee0710492f --- /dev/null +++ b/intern/cycles/kernel/kernel_compat_cpu.h @@ -0,0 +1,162 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __KERNEL_COMPAT_CPU_H__ +#define __KERNEL_COMPAT_CPU_H__ + +#define __KERNEL_CPU__ + +#include "util_debug.h" +#include "util_math.h" +#include "util_types.h" + +CCL_NAMESPACE_BEGIN + +/* Assertions inside the kernel only work for the CPU device, so we wrap it in + a macro which is empty for other devices */ + +#define kernel_assert(cond) assert(cond) + +/* Texture types to be compatible with CUDA textures. These are really just + simple arrays and after inlining fetch hopefully revert to being a simple + pointer lookup. */ + +template<typename T> struct texture { + T fetch(int index) + { + kernel_assert(index >= 0 && index < width); + return data[index]; + } + + __m128 fetch_m128(int index) + { + kernel_assert(index >= 0 && index < width); + return ((__m128*)data)[index]; + } + + __m128i fetch_m128i(int index) + { + kernel_assert(index >= 0 && index < width); + return ((__m128i*)data)[index]; + } + + float interp(float x) + { + x = clamp(x, 0.0f, 1.0f)*width; + + int index = min((int)x, width-1); + int nindex = min(index+1, width-1); + float t = x - index; + + return (1.0f - t)*data[index] + t*data[nindex]; + } + + T *data; + int width; +}; + +template<typename T> struct texture_image { + float4 read(float4 r) + { + return r; + } + + float4 read(uchar4 r) + { + float f = 1.0f/255.0f; + return make_float4(r.x*f, r.y*f, r.z*f, r.w*f); + } + + int wrap_periodic(int x, int width) + { + x %= width; + if(x < 0) + x += width; + return x; + } + + int wrap_clamp(int x, int width) + { + return clamp(x, 0, width-1); + } + + float frac(float x, int *ix) + { + int i = (int)x - ((x < 0.0f)? 1: 0); + *ix = i; + return x - (float)i; + } + + float4 interp(float x, float y, bool periodic = true) + { + if(!data) + return make_float4(0.0f, 0.0f, 0.0f, 0.0f); + + int ix, iy, nix, niy; + float tx = frac(x*width, &ix); + float ty = frac(y*height, &iy); + + if(periodic) { + ix = wrap_periodic(ix, width); + iy = wrap_periodic(iy, height); + + nix = wrap_periodic(ix+1, width); + niy = wrap_periodic(iy+1, height); + } + else { + ix = wrap_clamp(ix, width); + iy = wrap_clamp(iy, height); + + nix = wrap_clamp(ix+1, width); + niy = wrap_clamp(iy+1, height); + } + + float4 r = (1.0f - ty)*(1.0f - tx)*read(data[ix + iy*width]); + r += (1.0f - ty)*tx*read(data[nix + iy*width]); + r += ty*(1.0f - tx)*read(data[ix + niy*width]); + r += ty*tx*read(data[nix + niy*width]); + + return r; + } + + T *data; + int width, height; +}; + +typedef texture<float4> texture_float4; +typedef texture<float> texture_float; +typedef texture<uint> texture_uint; +typedef texture<int> texture_int; +typedef texture<uint4> texture_uint4; +typedef texture_image<float4> texture_image_float4; +typedef texture_image<uchar4> texture_image_uchar4; + +/* Macros to handle different memory storage on different devices */ + +#define kernel_tex_fetch(tex, index) (kg->tex.fetch(index)) +#define kernel_tex_fetch_m128(tex, index) (kg->tex.fetch_m128(index)) +#define kernel_tex_fetch_m128i(tex, index) (kg->tex.fetch_m128i(index)) +#define kernel_tex_interp(tex, t) (kg->tex.interp(t)) +#define kernel_tex_image_interp(tex, x, y) (kg->tex.interp(x, y)) + +#define kernel_data (kg->__data) + +CCL_NAMESPACE_END + +#endif /* __KERNEL_COMPAT_CPU_H__ */ + diff --git a/intern/cycles/kernel/kernel_compat_cuda.h b/intern/cycles/kernel/kernel_compat_cuda.h new file mode 100644 index 00000000000..99c1df1fb1a --- /dev/null +++ b/intern/cycles/kernel/kernel_compat_cuda.h @@ -0,0 +1,65 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __KERNEL_COMPAT_CUDA_H__ +#define __KERNEL_COMPAT_CUDA_H__ + +#define __KERNEL_GPU__ +#define __KERNEL_CUDA__ + +#include <cuda.h> +#include <float.h> + +#include "util_types.h" + +CCL_NAMESPACE_BEGIN + +/* Qualifier wrappers for different names on different devices */ + +#define __device __device__ __inline__ +#define __device_inline __device__ __inline__ +#define __global +#define __shared __shared__ +#define __constant __constant__ + +/* No assert supported for CUDA */ + +#define kernel_assert(cond) + +/* Textures */ + +typedef texture<float4, 1> texture_float4; +typedef texture<float, 1> texture_float; +typedef texture<uint, 1> texture_uint; +typedef texture<int, 1> texture_int; +typedef texture<uint4, 1> texture_uint4; +typedef texture<float4, 2> texture_image_float4; +typedef texture<uchar4, 2, cudaReadModeNormalizedFloat> texture_image_uchar4; + +/* Macros to handle different memory storage on different devices */ + +#define kernel_tex_fetch(t, index) tex1Dfetch(t, index) +#define kernel_tex_interp(t, x) tex1D(t, x) +#define kernel_tex_image_interp(t, x, y) tex2D(t, x, y) + +#define kernel_data __data + +CCL_NAMESPACE_END + +#endif /* __KERNEL_COMPAT_CUDA_H__ */ + diff --git a/intern/cycles/kernel/kernel_compat_opencl.h b/intern/cycles/kernel/kernel_compat_opencl.h new file mode 100644 index 00000000000..16ddca5305b --- /dev/null +++ b/intern/cycles/kernel/kernel_compat_opencl.h @@ -0,0 +1,50 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __KERNEL_COMPAT_OPENCL_H__ +#define __KERNEL_COMPAT_OPENCL_H__ + +#define __KERNEL_GPU__ +#define __KERNEL_OPENCL__ + +#include "util_types.h" + +CCL_NAMESPACE_BEGIN + +#define __device +#define __device_inline + +__device float kernel_tex_interp_(__global float *data, int width, float x) +{ + x = clamp(x, 0.0f, 1.0f)*width; + + int index = min((int)x, width-1); + int nindex = min(index+1, width-1); + float t = x - index; + + return (1.0f - t)*data[index] + t*data[nindex]; +} + +#define kernel_data (*kg->data) +#define kernel_tex_interp(t, x) \ + kernel_tex_interp_(kg->t, kg->t##_width, x); + +CCL_NAMESPACE_END + +#endif /* __KERNEL_COMPAT_OPENCL_H__ */ + diff --git a/intern/cycles/kernel/kernel_differential.h b/intern/cycles/kernel/kernel_differential.h new file mode 100644 index 00000000000..4e2b1ea7d13 --- /dev/null +++ b/intern/cycles/kernel/kernel_differential.h @@ -0,0 +1,90 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* See "Tracing Ray Differentials", Homan Igehy, 1999. */ + +__device void differential_transfer(differential3 *dP_, const differential3 dP, float3 D, const differential3 dD, float3 Ng, float t) +{ + /* ray differential transfer through homogenous medium, to + * compute dPdx/dy at a shading point from the incoming ray */ + + float3 tmp = D/dot(D, Ng); + float3 tmpx = dP.dx + t*dD.dx; + float3 tmpy = dP.dy + t*dD.dy; + + dP_->dx = tmpx - dot(tmpx, Ng)*tmp; + dP_->dy = tmpy - dot(tmpy, Ng)*tmp; +} + +__device void differential_incoming(differential3 *dI, const differential3 dD) +{ + /* compute dIdx/dy at a shading point, we just need to negate the + * differential of the ray direction */ + + dI->dx = -dD.dx; + dI->dy = -dD.dy; +} + +__device void differential_dudv(differential *du, differential *dv, float3 dPdu, float3 dPdv, differential3 dP, float3 Ng) +{ + /* now we have dPdx/dy from the ray differential transfer, and dPdu/dv + * from the primitive, we can compute dudx/dy and dvdx/dy. these are + * mainly used for differentials of arbitrary mesh attributes. */ + + /* find most stable axis to project to 2D */ + float xn= fabsf(Ng.x); + float yn= fabsf(Ng.y); + float zn= fabsf(Ng.z); + + if(zn < xn || zn < yn) { + if(yn < xn || yn < zn) { + dPdu.x = dPdu.y; + dPdv.x = dPdv.y; + dP.dx.x = dP.dx.y; + dP.dy.x = dP.dy.y; + } + + dPdu.y = dPdu.z; + dPdv.y = dPdv.z; + dP.dx.y = dP.dx.z; + dP.dy.y = dP.dy.z; + } + + /* using Cramer's rule, we solve for dudx and dvdx in a 2x2 linear system, + * and the same for dudy and dvdy. the denominator is the same for both + * solutions, so we compute it only once. + * + * dP.dx = dPdu * dudx + dPdv * dvdx; + * dP.dy = dPdu * dudy + dPdv * dvdy; */ + + float det = (dPdu.x*dPdv.y - dPdv.x*dPdu.y); + + if(det != 0.0f) + det = 1.0f/det; + + du->dx = (dP.dx.x*dPdv.y - dP.dx.y*dPdv.x)*det; + dv->dx = (dP.dx.y*dPdu.x - dP.dx.x*dPdu.y)*det; + + du->dy = (dP.dy.x*dPdv.y - dP.dy.y*dPdv.x)*det; + dv->dy = (dP.dy.y*dPdu.x - dP.dy.x*dPdu.y)*det; +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/kernel_displace.h b/intern/cycles/kernel/kernel_displace.h new file mode 100644 index 00000000000..ef6c3810a75 --- /dev/null +++ b/intern/cycles/kernel/kernel_displace.h @@ -0,0 +1,35 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +__device void kernel_displace(KernelGlobals *kg, uint4 *input, float3 *offset, int i) +{ + /* setup shader data */ + ShaderData sd; + uint4 in = input[i]; + shader_setup_from_displace(kg, &sd, in.x, in.y, __int_as_float(in.z), __int_as_float(in.w)); + + /* evaluate */ + float3 P = sd.P; + shader_eval_displacement(kg, &sd); + offset[i] = sd.P - P; +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/kernel_emission.h b/intern/cycles/kernel/kernel_emission.h new file mode 100644 index 00000000000..6b6033e9ebd --- /dev/null +++ b/intern/cycles/kernel/kernel_emission.h @@ -0,0 +1,118 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Direction Emission */ + +__device float3 direct_emissive_eval(KernelGlobals *kg, float rando, + LightSample *ls, float u, float v, float3 I) +{ + /* setup shading at emitter */ + ShaderData sd; + + shader_setup_from_sample(kg, &sd, ls->P, ls->Ng, I, ls->shader, ls->object, ls->prim, u, v); + ls->Ng = sd.Ng; + + /* no path flag, we're evaluating this for all closures. that's weak but + we'd have to do multiple evaluations otherwise */ + shader_eval_surface(kg, &sd, rando, 0); + + float3 eval; + + /* evaluate emissive closure */ + if(sd.flag & SD_EMISSION) + eval = shader_emissive_eval(kg, &sd); + else + eval = make_float3(0.0f, 0.0f, 0.0f); + + shader_release(kg, &sd); + + return eval; +} + +__device bool direct_emission(KernelGlobals *kg, ShaderData *sd, float randt, float rando, + float randu, float randv, Ray *ray, float3 *eval) +{ + /* sample a position on a light */ + LightSample ls; + + light_sample(kg, randt, randu, randv, sd->P, &ls); + + /* compute incoming direction and distance */ + float t; + float3 omega_in = normalize_len(ls.P - sd->P, &t); + + /* compute pdf */ + float pdf = light_pdf(kg, &ls, -omega_in, t); + + /* evaluate closure */ + *eval = direct_emissive_eval(kg, rando, &ls, randu, randv, -omega_in); + + if(is_zero(*eval) || pdf == 0.0f) + return false; + + /* evaluate BSDF at shading point */ + float bsdf_pdf; + float3 bsdf_eval = shader_bsdf_eval(kg, sd, omega_in, &bsdf_pdf); + + *eval *= bsdf_eval/pdf; + + if(is_zero(*eval)) + return false; + + if(ls.prim != ~0) { + /* multiple importance sampling */ + float mis_weight = power_heuristic(pdf, bsdf_pdf); + *eval *= mis_weight; + } + else { + /* ensure point light works in Watts, this should be handled + * elsewhere but for now together with the diffuse emission + * closure it works out to the right value */ + *eval *= 0.25f; + } + + /* setup ray */ + ray->P = ray_offset(sd->P, sd->Ng); + ray->D = ray_offset(ls.P, ls.Ng) - ray->P; + ray->D = normalize_len(ray->D, &ray->t); + + return true; +} + +/* Indirect Emission */ + +__device float3 indirect_emission(KernelGlobals *kg, ShaderData *sd, float t, int path_flag, float bsdf_pdf) +{ + /* evaluate emissive closure */ + float3 L = shader_emissive_eval(kg, sd); + + if(!(path_flag & PATH_RAY_SINGULAR)) { + /* multiple importance sampling */ + float pdf = triangle_light_pdf(kg, sd->Ng, sd->I, t); + float mis_weight = power_heuristic(bsdf_pdf, pdf); + + return L*mis_weight; + } + + return L; +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/kernel_film.h b/intern/cycles/kernel/kernel_film.h new file mode 100644 index 00000000000..04ea889f4c0 --- /dev/null +++ b/intern/cycles/kernel/kernel_film.h @@ -0,0 +1,68 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +__device float4 film_map(KernelGlobals *kg, float4 irradiance, int pass) +{ + float scale = kernel_data.film.exposure*(1.0f/(pass+1)); + float4 result = irradiance*scale; + + if(kernel_data.film.use_response_curve) { + /* camera response curve */ + result.x = kernel_tex_interp(__response_curve_R, result.x); + result.y = kernel_tex_interp(__response_curve_G, result.y); + result.z = kernel_tex_interp(__response_curve_B, result.z); + } + else { + /* conversion to srgb */ + result.x = color_scene_linear_to_srgb(result.x); + result.y = color_scene_linear_to_srgb(result.y); + result.z = color_scene_linear_to_srgb(result.z); + } + + return result; +} + +__device uchar4 film_float_to_byte(float4 color) +{ + uchar4 result; + + /* simple float to byte conversion */ + result.x = clamp(color.x*255.0f, 0.0f, 255.0f); + result.y = clamp(color.y*255.0f, 0.0f, 255.0f); + result.z = clamp(color.z*255.0f, 0.0f, 255.0f); + result.w = 255; + + return result; +} + +__device void kernel_film_tonemap(KernelGlobals *kg, __global uchar4 *rgba, __global float4 *buffer, int pass, int resolution, int x, int y) +{ + int w = kernel_data.cam.width; + int index = x + y*w; + float4 irradiance = buffer[index]; + + float4 float_result = film_map(kg, irradiance, pass); + uchar4 byte_result = film_float_to_byte(float_result); + + rgba[index] = byte_result; +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/kernel_globals.h b/intern/cycles/kernel/kernel_globals.h new file mode 100644 index 00000000000..4c4f35bb508 --- /dev/null +++ b/intern/cycles/kernel/kernel_globals.h @@ -0,0 +1,208 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +/* Constant Globals */ + +#ifdef __KERNEL_CPU__ + +#ifdef WITH_OSL +#include "osl_globals.h" +#endif + +CCL_NAMESPACE_BEGIN + +/* On the CPU, we pass along the struct KernelGlobals to nearly everywhere in + the kernel, to access constant data. These are all stored as "textures", but + these are really just standard arrays. We can't use actually globals because + multiple renders may be running inside the same process. */ +typedef struct KernelGlobals { + +#else + +/* On the GPU, constant memory textures must be globals, so we can't put them + into a struct. As a result we don't actually use this struct and use actual + globals and simply pass along a NULL pointer everywhere, which we hope gets + optimized out. */ +#ifdef __KERNEL_CUDA__ +typedef struct KernelGlobals {} KernelGlobals; +#endif + +#endif + +/* globals */ +__constant KernelData __data; + +#ifndef __KERNEL_OPENCL__ + +/* bvh */ +texture_float4 __bvh_nodes; +texture_float4 __tri_woop; +texture_uint __prim_index; +texture_uint __prim_object; +texture_uint __object_node; + +/* objects */ +texture_float4 __objects; + +/* triangles */ +texture_float4 __tri_normal; +texture_float4 __tri_vnormal; +texture_float4 __tri_vindex; +texture_float4 __tri_verts; + +/* attributes */ +texture_uint4 __attributes_map; +texture_float __attributes_float; +texture_float4 __attributes_float3; + +/* lights */ +texture_float4 __light_distribution; +texture_float4 __light_point; + +/* shaders */ +texture_uint4 __svm_nodes; + +/* camera/film */ +texture_float __filter_table; +texture_float __response_curve_R; +texture_float __response_curve_G; +texture_float __response_curve_B; + +/* sobol */ +texture_uint __sobol_directions; + +/* image */ +texture_image_uchar4 __tex_image_000; +texture_image_uchar4 __tex_image_001; +texture_image_uchar4 __tex_image_002; +texture_image_uchar4 __tex_image_003; +texture_image_uchar4 __tex_image_004; +texture_image_uchar4 __tex_image_005; +texture_image_uchar4 __tex_image_006; +texture_image_uchar4 __tex_image_007; +texture_image_uchar4 __tex_image_008; +texture_image_uchar4 __tex_image_009; +texture_image_uchar4 __tex_image_010; +texture_image_uchar4 __tex_image_011; +texture_image_uchar4 __tex_image_012; +texture_image_uchar4 __tex_image_013; +texture_image_uchar4 __tex_image_014; +texture_image_uchar4 __tex_image_015; +texture_image_uchar4 __tex_image_016; +texture_image_uchar4 __tex_image_017; +texture_image_uchar4 __tex_image_018; +texture_image_uchar4 __tex_image_019; +texture_image_uchar4 __tex_image_020; +texture_image_uchar4 __tex_image_021; +texture_image_uchar4 __tex_image_022; +texture_image_uchar4 __tex_image_023; +texture_image_uchar4 __tex_image_024; +texture_image_uchar4 __tex_image_025; +texture_image_uchar4 __tex_image_026; +texture_image_uchar4 __tex_image_027; +texture_image_uchar4 __tex_image_028; +texture_image_uchar4 __tex_image_029; +texture_image_uchar4 __tex_image_030; +texture_image_uchar4 __tex_image_031; +texture_image_uchar4 __tex_image_032; +texture_image_uchar4 __tex_image_033; +texture_image_uchar4 __tex_image_034; +texture_image_uchar4 __tex_image_035; +texture_image_uchar4 __tex_image_036; +texture_image_uchar4 __tex_image_037; +texture_image_uchar4 __tex_image_038; +texture_image_uchar4 __tex_image_039; +texture_image_uchar4 __tex_image_040; +texture_image_uchar4 __tex_image_041; +texture_image_uchar4 __tex_image_042; +texture_image_uchar4 __tex_image_043; +texture_image_uchar4 __tex_image_044; +texture_image_uchar4 __tex_image_045; +texture_image_uchar4 __tex_image_046; +texture_image_uchar4 __tex_image_047; +texture_image_uchar4 __tex_image_048; +texture_image_uchar4 __tex_image_049; +texture_image_uchar4 __tex_image_050; +texture_image_uchar4 __tex_image_051; +texture_image_uchar4 __tex_image_052; +texture_image_uchar4 __tex_image_053; +texture_image_uchar4 __tex_image_054; +texture_image_uchar4 __tex_image_055; +texture_image_uchar4 __tex_image_056; +texture_image_uchar4 __tex_image_057; +texture_image_uchar4 __tex_image_058; +texture_image_uchar4 __tex_image_059; +texture_image_uchar4 __tex_image_060; +texture_image_uchar4 __tex_image_061; +texture_image_uchar4 __tex_image_062; +texture_image_uchar4 __tex_image_063; +texture_image_uchar4 __tex_image_064; +texture_image_uchar4 __tex_image_065; +texture_image_uchar4 __tex_image_066; +texture_image_uchar4 __tex_image_067; +texture_image_uchar4 __tex_image_068; +texture_image_uchar4 __tex_image_069; +texture_image_uchar4 __tex_image_070; +texture_image_uchar4 __tex_image_071; +texture_image_uchar4 __tex_image_072; +texture_image_uchar4 __tex_image_073; +texture_image_uchar4 __tex_image_074; +texture_image_uchar4 __tex_image_075; +texture_image_uchar4 __tex_image_076; +texture_image_uchar4 __tex_image_077; +texture_image_uchar4 __tex_image_078; +texture_image_uchar4 __tex_image_079; +texture_image_uchar4 __tex_image_080; +texture_image_uchar4 __tex_image_081; +texture_image_uchar4 __tex_image_082; +texture_image_uchar4 __tex_image_083; +texture_image_uchar4 __tex_image_084; +texture_image_uchar4 __tex_image_085; +texture_image_uchar4 __tex_image_086; +texture_image_uchar4 __tex_image_087; +texture_image_uchar4 __tex_image_088; +texture_image_uchar4 __tex_image_089; +texture_image_uchar4 __tex_image_090; +texture_image_uchar4 __tex_image_091; +texture_image_uchar4 __tex_image_092; +texture_image_uchar4 __tex_image_093; +texture_image_uchar4 __tex_image_094; +texture_image_uchar4 __tex_image_095; +texture_image_uchar4 __tex_image_096; +texture_image_uchar4 __tex_image_097; +texture_image_uchar4 __tex_image_098; +texture_image_uchar4 __tex_image_099; + +#endif + +#ifdef __KERNEL_CPU__ + +#ifdef WITH_OSL + +/* On the CPU, we also have the OSL globals here. Most data structures are shared + with SVM, the difference is in the shaders and object/mesh attributes. */ + +OSLGlobals osl; + +#endif + +} KernelGlobals; +#endif + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/kernel_light.h b/intern/cycles/kernel/kernel_light.h new file mode 100644 index 00000000000..537f7ea00f0 --- /dev/null +++ b/intern/cycles/kernel/kernel_light.h @@ -0,0 +1,145 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +struct LightSample { + float3 P; + float3 Ng; + int object; + int prim; + int shader; + float weight; +}; + +/* Point Light */ + +__device void point_light_sample(KernelGlobals *kg, int point, + float randu, float randv, float3 P, LightSample *ls) +{ + float4 f = kernel_tex_fetch(__light_point, point); + + ls->P = make_float3(f.x, f.y, f.z); + ls->Ng = normalize(ls->P - P); + ls->shader = __float_as_int(f.w); + ls->object = ~0; + ls->prim = ~0; +} + +__device float point_light_pdf(KernelGlobals *kg, float t) +{ + return t*t*kernel_data.integrator.pdf_lights; +} + +/* Triangle Light */ + +__device void triangle_light_sample(KernelGlobals *kg, int prim, int object, + float randu, float randv, LightSample *ls) +{ + /* triangle, so get position, normal, shader */ + ls->P = triangle_sample_MT(kg, prim, randu, randv); + ls->Ng = triangle_normal_MT(kg, prim, &ls->shader); + ls->object = object; + ls->prim = prim; + +#ifdef __INSTANCING__ + /* instance transform */ + if(ls->object >= 0) { + object_position_transform(kg, ls->object, &ls->P); + object_normal_transform(kg, ls->object, &ls->Ng); + } +#endif +} + +__device float triangle_light_pdf(KernelGlobals *kg, + const float3 Ng, const float3 I, float t) +{ + float cos_pi = fabsf(dot(Ng, I)); + + if(cos_pi == 0.0f) + return 0.0f; + + return (t*t*kernel_data.integrator.pdf_triangles)/cos_pi; +} + +/* Light Distribution */ + +__device int light_distribution_sample(KernelGlobals *kg, float randt) +{ + /* this is basically std::upper_bound as used by pbrt, to find a point light or + triangle to emit from, proportional to area. a good improvement would be to + also sample proportional to power, though it's not so well defined with + OSL shaders. */ + int first = 0; + int len = kernel_data.integrator.num_distribution + 1; + + while(len > 0) { + int half_len = len >> 1; + int middle = first + half_len; + + if(randt < kernel_tex_fetch(__light_distribution, middle).x) { + len = half_len; + } + else { + first = middle + 1; + len = len - half_len - 1; + } + } + + first = max(0, first-1); + kernel_assert(first >= 0 && first < kernel_data.integrator.num_distribution); + + return first; +} + +/* Generic Light */ + +__device void light_sample(KernelGlobals *kg, float randt, float randu, float randv, float3 P, LightSample *ls) +{ + /* sample index */ + int index = light_distribution_sample(kg, randt); + + /* fetch light data */ + float4 l = kernel_tex_fetch(__light_distribution, index); + int prim = __float_as_int(l.y); + ls->weight = l.z; + + if(prim >= 0) { + int object = __float_as_int(l.w); + triangle_light_sample(kg, prim, object, randu, randv, ls); + } + else { + int point = -prim-1; + point_light_sample(kg, point, randu, randv, P, ls); + } +} + +__device float light_pdf(KernelGlobals *kg, LightSample *ls, float3 I, float t) +{ + float pdf; + + if(ls->prim != ~0) + pdf = triangle_light_pdf(kg, ls->Ng, I, t); + else + pdf = point_light_pdf(kg, t); + + return pdf; +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/kernel_math.h b/intern/cycles/kernel/kernel_math.h new file mode 100644 index 00000000000..165535077da --- /dev/null +++ b/intern/cycles/kernel/kernel_math.h @@ -0,0 +1,27 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __KERNEL_MATH_H__ +#define __KERNEL_MATH_H__ + +#include "util_color.h" +#include "util_math.h" +#include "util_transform.h" + +#endif /* __KERNEL_MATH_H__ */ + diff --git a/intern/cycles/kernel/kernel_mbvh.h b/intern/cycles/kernel/kernel_mbvh.h new file mode 100644 index 00000000000..3995e782abd --- /dev/null +++ b/intern/cycles/kernel/kernel_mbvh.h @@ -0,0 +1,394 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +#define MBVH_OBJECT_SENTINEL 0x76543210 +#define MBVH_NODE_SIZE 8 +#define MBVH_STACK_SIZE 1024 +#define MBVH_RAY_STACK_SIZE 10000 + +typedef struct MBVHTask { + int node; + int index; + int num; + int object; +} MBVHTask; + +typedef struct MVBHRay { + float3 P; + float u; + float3 idir; + float v; + float t; + int index; + int object; + + float3 origP; + float3 origD; + float tmax; +} MBVHRay; + +__device float3 mbvh_inverse_direction(float3 dir) +{ + // Avoid divide by zero (ooeps = exp2f(-80.0f)) + float ooeps = 0.00000000000000000000000082718061255302767487140869206996285356581211090087890625f; + float3 idir; + + idir.x = 1.0f / (fabsf(dir.x) > ooeps ? dir.x : copysignf(ooeps, dir.x)); + idir.y = 1.0f / (fabsf(dir.y) > ooeps ? dir.y : copysignf(ooeps, dir.y)); + idir.z = 1.0f / (fabsf(dir.z) > ooeps ? dir.z : copysignf(ooeps, dir.z)); + + return idir; +} + +__device void mbvh_instance_push(KernelGlobals *kg, int object, MBVHRay *ray) +{ + Transform tfm = object_fetch_transform(kg, object, OBJECT_INVERSE_TRANSFORM); + + ray->P = transform(&tfm, ray->origP); + + float3 dir = ray->origD; + + if(ray->t != ray->tmax) dir *= ray->t; + + dir = transform_direction(&tfm, dir); + ray->idir = mbvh_inverse_direction(normalize(dir)); + + if(ray->t != ray->tmax) ray->t = len(dir); +} + +__device void mbvh_instance_pop(KernelGlobals *kg, int object, MBVHRay *ray) +{ + Transform tfm = object_fetch_transform(kg, object, OBJECT_TRANSFORM); + + if(ray->t != ray->tmax) + ray->t = len(transform_direction(&tfm, (1.0f/(ray->idir)) * (ray->t))); + + ray->P = ray->origP; + ray->idir = mbvh_inverse_direction(ray->origD); +} + +/* Sven Woop's algorithm */ +__device void mbvh_triangle_intersect(KernelGlobals *kg, MBVHRay *ray, int object, int triAddr) +{ + float3 P = ray->P; + float3 idir = ray->idir; + + /* compute and check intersection t-value */ + float4 v00 = kernel_tex_fetch(__tri_woop, triAddr*MBVH_NODE_SIZE+0); + float4 v11 = kernel_tex_fetch(__tri_woop, triAddr*MBVH_NODE_SIZE+1); + float3 dir = 1.0f/idir; + + float Oz = v00.w - P.x*v00.x - P.y*v00.y - P.z*v00.z; + float invDz = 1.0f/(dir.x*v00.x + dir.y*v00.y + dir.z*v00.z); + float t = Oz * invDz; + + if(t > 0.0f && t < ray->t) { + /* compute and check barycentric u */ + float Ox = v11.w + P.x*v11.x + P.y*v11.y + P.z*v11.z; + float Dx = dir.x*v11.x + dir.y*v11.y + dir.z*v11.z; + float u = Ox + t*Dx; + + if(u >= 0.0f) { + /* compute and check barycentric v */ + float4 v22 = kernel_tex_fetch(__tri_woop, triAddr*MBVH_NODE_SIZE+2); + float Oy = v22.w + P.x*v22.x + P.y*v22.y + P.z*v22.z; + float Dy = dir.x*v22.x + dir.y*v22.y + dir.z*v22.z; + float v = Oy + t*Dy; + + if(v >= 0.0f && u + v <= 1.0f) { + /* record intersection */ + ray->index = triAddr; + ray->object = object; + ray->u = u; + ray->v = v; + ray->t = t; + } + } + } +} + +__device void mbvh_node_intersect(KernelGlobals *kg, __m128 *traverseChild, + __m128 *tHit, float3 P, float3 idir, float t, int nodeAddr) +{ + /* X axis */ + const __m128 bminx = kernel_tex_fetch_m128(__bvh_nodes, nodeAddr*MBVH_NODE_SIZE+0); + const __m128 t0x = _mm_mul_ps(_mm_sub_ps(bminx, _mm_set_ps1(P.x)), _mm_set_ps1(idir.x)); + const __m128 bmaxx = kernel_tex_fetch_m128(__bvh_nodes, nodeAddr*MBVH_NODE_SIZE+1); + const __m128 t1x = _mm_mul_ps(_mm_sub_ps(bmaxx, _mm_set_ps1(P.x)), _mm_set_ps1(idir.x)); + + __m128 tmin = _mm_max_ps(_mm_min_ps(t0x, t1x), _mm_setzero_ps()); + __m128 tmax = _mm_min_ps(_mm_max_ps(t0x, t1x), _mm_set_ps1(t)); + + /* Y axis */ + const __m128 bminy = kernel_tex_fetch_m128(__bvh_nodes, nodeAddr*MBVH_NODE_SIZE+2); + const __m128 t0y = _mm_mul_ps(_mm_sub_ps(bminy, _mm_set_ps1(P.y)), _mm_set_ps1(idir.y)); + const __m128 bmaxy = kernel_tex_fetch_m128(__bvh_nodes, nodeAddr*MBVH_NODE_SIZE+3); + const __m128 t1y = _mm_mul_ps(_mm_sub_ps(bmaxy, _mm_set_ps1(P.y)), _mm_set_ps1(idir.y)); + + tmin = _mm_max_ps(_mm_min_ps(t0y, t1y), tmin); + tmax = _mm_min_ps(_mm_max_ps(t0y, t1y), tmax); + + /* Z axis */ + const __m128 bminz = kernel_tex_fetch_m128(__bvh_nodes, nodeAddr*MBVH_NODE_SIZE+4); + const __m128 t0z = _mm_mul_ps(_mm_sub_ps(bminz, _mm_set_ps1(P.z)), _mm_set_ps1(idir.z)); + const __m128 bmaxz = kernel_tex_fetch_m128(__bvh_nodes, nodeAddr*MBVH_NODE_SIZE+5); + const __m128 t1z = _mm_mul_ps(_mm_sub_ps(bmaxz, _mm_set_ps1(P.z)), _mm_set_ps1(idir.z)); + + tmin = _mm_max_ps(_mm_min_ps(t0z, t1z), tmin); + tmax = _mm_min_ps(_mm_max_ps(t0z, t1z), tmax); + + /* compare and get mask */ + *traverseChild = _mm_cmple_ps(tmin, tmax); + + /* get distance XXX probably wrong */ + *tHit = tmin; +} + +static void mbvh_sort_by_length(int id[4], float len[4]) +{ + for(int i = 1; i < 4; i++) { + int j = i - 1; + + while(j >= 0 && len[j] > len[j+1]) { + swap(len[j], len[j+1]); + swap(id[j], id[j+1]); + j--; + } + } +} + +__device void scene_intersect(KernelGlobals *kg, MBVHRay *rays, int numrays) +{ + /* traversal stacks */ + MBVHTask task_stack[MBVH_STACK_SIZE]; + int active_ray_stacks[4][MBVH_RAY_STACK_SIZE]; + int num_task, num_active[4] = {0, 0, 0, 0}; + __m128i one_mm = _mm_set1_epi32(1); + + /* push root node task on stack */ + task_stack[0].node = kernel_data.bvh.root; + task_stack[0].index = 0; + task_stack[0].num = numrays; + task_stack[0].object = ~0; + num_task = 1; + + /* push all rays in first SIMD lane */ + for(int i = 0; i < numrays; i++) + active_ray_stacks[0][i] = i; + num_active[0] = numrays; + + while(num_task >= 1) { + /* pop task */ + MBVHTask task = task_stack[--num_task]; + + if(task.node == MBVH_OBJECT_SENTINEL) { + /* instance pop */ + + /* pop rays from stack */ + num_active[task.index] -= task.num; + int ray_offset = num_active[task.index]; + + /* transform rays */ + for(int i = 0; i < task.num; i++) { + MBVHRay *ray = &rays[active_ray_stacks[task.index][ray_offset + i]]; + mbvh_instance_pop(kg, task.object, ray); + } + } + else if(task.node >= 0) { + /* inner node? */ + + /* pop rays from stack*/ + num_active[task.index] -= task.num; + int ray_offset = num_active[task.index]; + + /* initialze simd values */ + __m128i num_active_mm = _mm_load_si128((__m128i*)num_active); + __m128 len_mm = _mm_set_ps1(0.0f); + + for(int i = 0; i < task.num; i++) { + int rayid = active_ray_stacks[task.index][ray_offset + i]; + MVBHRay *ray = rays + rayid; + + /* intersect 4 QBVH node children */ + __m128 result; + __m128 thit; + + mbvh_node_intersect(kg, &result, &thit, ray->P, ray->idir, ray->t, task.node); + + /* update length for sorting */ + len_mm = _mm_add_ps(len_mm, _mm_and_ps(thit, result)); + + /* push rays on stack */ + for(int j = 0; j < 4; j++) + active_ray_stacks[j][num_active[j]] = rayid; + + /* update num active */ + __m128i resulti = _mm_and_si128(*((__m128i*)&result), one_mm); + num_active_mm = _mm_add_epi32(resulti, num_active_mm); + _mm_store_si128((__m128i*)num_active, num_active_mm); + } + + if(num_active[0] || num_active[1] || num_active[2] || num_active[3]) { + /* load child node addresses */ + float4 cnodes = kernel_tex_fetch(__bvh_nodes, task.node); + int child[4] = { + __float_as_int(cnodes.x), + __float_as_int(cnodes.y), + __float_as_int(cnodes.z), + __float_as_int(cnodes.w)}; + + /* sort nodes by average intersection distance */ + int ids[4] = {0, 1, 2, 3}; + float len[4]; + + _mm_store_ps(len, len_mm); + mbvh_sort_by_length(ids, len); + + /* push new tasks on stack */ + for(int j = 0; j < 4; j++) { + if(num_active[j]) { + int id = ids[j]; + + task_stack[num_task].node = child[id]; + task_stack[num_task].index = id; + task_stack[num_task].num = num_active[id]; + task_stack[num_task].object = task.object; + num_task++; + } + } + } + } + else { + /* fetch leaf node data */ + float4 leaf = kernel_tex_fetch(__bvh_nodes, (-task.node-1)*MBVH_NODE_SIZE+(MBVH_NODE_SIZE-2)); + int triAddr = __float_as_int(leaf.x); + int triAddr2 = __float_as_int(leaf.y); + + /* pop rays from stack*/ + num_active[task.index] -= task.num; + int ray_offset = num_active[task.index]; + + /* triangles */ + if(triAddr >= 0) { + int i, numq = (task.num >> 2) << 2; + + /* SIMD ray leaf intersection */ + for(i = 0; i < numq; i += 4) { + MBVHRay *ray4[4] = { + &rays[active_ray_stacks[task.index][ray_offset + i + 0]], + &rays[active_ray_stacks[task.index][ray_offset + i + 1]], + &rays[active_ray_stacks[task.index][ray_offset + i + 2]], + &rays[active_ray_stacks[task.index][ray_offset + i + 3]]}; + + /* load SoA */ + + while(triAddr < triAddr2) { + mbvh_triangle_intersect(ray4[0], task.object, task.node); + mbvh_triangle_intersect(ray4[1], task.object, task.node); + mbvh_triangle_intersect(ray4[2], task.object, task.node); + mbvh_triangle_intersect(ray4[3], task.object, task.node); + triAddr++; + + /* some shadow ray optim could be done by setting t=0 */ + } + + /* store AoS */ + } + + /* mono ray leaf intersection */ + for(; i < task.num; i++) { + MBVHRay *ray = &rays[active_ray_stacks[task.index][ray_offset + i]]; + + while(triAddr < triAddr2) { + mbvh_triangle_intersect(kg, ray, task.object, task.node); + triAddr++; + } + } + } + else { + /* instance push */ + int object = -triAddr-1; + int node = triAddr; + + /* push instance pop task */ + task_stack[num_task].node = MBVH_OBJECT_SENTINEL; + task_stack[num_task].index = task.index; + task_stack[num_task].num = task.num; + task_stack[num_task].object = object; + num_task++; + + num_active[task.index] += task.num; + + /* push node task */ + task_stack[num_task].node = node; + task_stack[num_task].index = task.index; + task_stack[num_task].num = task.num; + task_stack[num_task].object = object; + num_task++; + + for(int i = 0; i < task.num; i++) { + int rayid = active_ray_stacks[task.index][ray_offset + i]; + + /* push on stack for last task */ + active_ray_stacks[task.index][num_active[task.index]] = rayid; + num_active[task.index]++; + + /* transform ray */ + MBVHRay *ray = &rays[rayid]; + mbvh_instance_push(kg, object, ray); + } + } + } + } +} + +__device void mbvh_set_ray(MBVHRay *rays, int i, Ray *ray, float tmax) +{ + MBVHRay *mray = &rays[i]; + + /* ray parameters in registers */ + mray->P = ray->P; + mray->idir = mbvh_inverse_direction(ray->D); + mray->t = tmax; +} + +__device bool mbvh_get_intersection(MVBHRay *rays, int i, Intersection *isect, float tmax) +{ + MBVHRay *mray = &rays[i]; + + if(mray->t == tmax) + return false; + + isect->t = mray->t; + isect->u = mray->u; + isect->v = mray->v; + isect->index = mray->index; + isect->object = mray->object; + + return true; +} + +__device bool mbvh_get_shadow(MBVHRay *rays, int i, float tmax) +{ + return (rays[i].t == tmax); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/kernel_montecarlo.h b/intern/cycles/kernel/kernel_montecarlo.h new file mode 100644 index 00000000000..6f3a3dd3421 --- /dev/null +++ b/intern/cycles/kernel/kernel_montecarlo.h @@ -0,0 +1,196 @@ +/* + * Parts 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. +*/ + +#ifndef __KERNEL_MONTECARLO_CL__ +#define __KERNEL_MONTECARLO_CL__ + +CCL_NAMESPACE_BEGIN + +/// Given values x and y on [0,1], convert them in place to values on +/// [-1,1] uniformly distributed over a unit sphere. This code is +/// derived from Peter Shirley, "Realistic Ray Tracing", p. 103. +__device void to_unit_disk(float *x, float *y) +{ + float r, phi; + float a = 2.0f * (*x) - 1.0f; + float b = 2.0f * (*y) - 1.0f; + if(a > -b) { + if(a > b) { + r = a; + phi = M_PI_4_F *(b/a); + } else { + r = b; + phi = M_PI_4_F *(2.0f - a/b); + } + } else { + if(a < b) { + r = -a; + phi = M_PI_4_F *(4.0f + b/a); + } else { + r = -b; + if(b != 0.0f) + phi = M_PI_4_F *(6.0f - a/b); + else + phi = 0.0f; + } + } + *x = r * cosf(phi); + *y = r * sinf(phi); +} + +__device_inline void make_orthonormals(const float3 N, float3 *a, float3 *b) +{ + if(N.x != N.y || N.x != N.z) + *a = make_float3(N.z-N.y, N.x-N.z, N.y-N.x); //(1,1,1)x N + else + *a = make_float3(N.z-N.y, N.x+N.z, -N.y-N.x); //(-1,1,1)x N + + *a = normalize(*a); + *b = cross(N, *a); +} + +__device void make_orthonormals_tangent(const float3 N, const float3 T, float3 *a, float3 *b) +{ + *b = cross(N, T); + *a = cross(*b, N); +} + +__device_inline void sample_cos_hemisphere(const float3 N, + float randu, float randv, float3 *omega_in, float *pdf) +{ + // Default closure BSDF implementation: uniformly sample + // cosine-weighted hemisphere above the point. + to_unit_disk(&randu, &randv); + float costheta = sqrtf(max(1.0f - randu * randu - randv * randv, 0.0f)); + float3 T, B; + make_orthonormals(N, &T, &B); + *omega_in = randu * T + randv * B + costheta * N; + *pdf = costheta *M_1_PI_F; +} + +__device_inline void sample_uniform_hemisphere(const float3 N, + float randu, float randv, + float3 *omega_in, float *pdf) +{ + float z = randu; + float r = sqrtf(max(0.f, 1.f - z*z)); + float phi = 2.f * M_PI_F * randv; + float x = r * cosf(phi); + float y = r * sinf(phi); + + float3 T, B; + make_orthonormals (N, &T, &B); + *omega_in = x * T + y * B + z * N; + *pdf = 0.5f * M_1_PI_F; +} + +__device float3 sample_uniform_sphere(float u1, float u2) +{ + float z = 1.0f - 2.0f*u1; + float r = sqrtf(fmaxf(0.0f, 1.0f - z*z)); + float phi = 2.0f*M_PI_F*u2; + float x = r*cosf(phi); + float y = r*sinf(phi); + + return make_float3(x, y, z); +} + +__device float power_heuristic(float a, float b) +{ + return (a*a)/(a*a + b*b); +} + +__device float2 concentric_sample_disk(float u1, float u2) +{ + float r, theta; + // Map uniform random numbers to $[-1,1]^2$ + float sx = 2 * u1 - 1; + float sy = 2 * u2 - 1; + + // Map square to $(r,\theta)$ + + // Handle degeneracy at the origin + if(sx == 0.0f && sy == 0.0f) { + return make_float2(0.0f, 0.0f); + } + if(sx >= -sy) { + if(sx > sy) { + // Handle first region of disk + r = sx; + if(sy > 0.0f) theta = sy/r; + else theta = 8.0f + sy/r; + } + else { + // Handle second region of disk + r = sy; + theta = 2.0f - sx/r; + } + } + else { + if(sx <= sy) { + // Handle third region of disk + r = -sx; + theta = 4.0f - sy/r; + } + else { + // Handle fourth region of disk + r = -sy; + theta = 6.0f + sx/r; + } + } + + theta *= M_PI_4_F; + return make_float2(r * cosf(theta), r * sinf(theta)); +} + +/* Spherical coordinates <-> Cartesion direction */ + +__device float2 direction_to_spherical(float3 dir) +{ + float theta = acosf(dir.z); + float phi = atan2f(dir.x, dir.y); + + return make_float2(theta, phi); +} + +__device float3 spherical_to_direction(float theta, float phi) +{ + return make_float3( + sinf(theta)*cosf(phi), + sinf(theta)*sinf(phi), + cosf(theta)); +} + +CCL_NAMESPACE_END + +#endif /* __KERNEL_MONTECARLO_CL__ */ + diff --git a/intern/cycles/kernel/kernel_object.h b/intern/cycles/kernel/kernel_object.h new file mode 100644 index 00000000000..b4c42d3bacc --- /dev/null +++ b/intern/cycles/kernel/kernel_object.h @@ -0,0 +1,68 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +enum ObjectTransform { + OBJECT_TRANSFORM = 0, + OBJECT_INVERSE_TRANSFORM = 4, + OBJECT_NORMAL_TRANSFORM = 8, + OBJECT_PROPERTIES = 12 +}; + +__device_inline Transform object_fetch_transform(KernelGlobals *kg, int object, enum ObjectTransform type) +{ + Transform tfm; + + int offset = object*OBJECT_SIZE + (int)type; + + tfm.x = kernel_tex_fetch(__objects, offset + 0); + tfm.y = kernel_tex_fetch(__objects, offset + 1); + tfm.z = kernel_tex_fetch(__objects, offset + 2); + tfm.w = kernel_tex_fetch(__objects, offset + 3); + + return tfm; +} + +__device_inline void object_position_transform(KernelGlobals *kg, int object, float3 *P) +{ + Transform tfm = object_fetch_transform(kg, object, OBJECT_TRANSFORM); + *P = transform(&tfm, *P); +} + +__device_inline void object_normal_transform(KernelGlobals *kg, int object, float3 *N) +{ + Transform tfm = object_fetch_transform(kg, object, OBJECT_NORMAL_TRANSFORM); + *N = normalize(transform_direction(&tfm, *N)); +} + +__device_inline void object_dir_transform(KernelGlobals *kg, int object, float3 *D) +{ + Transform tfm = object_fetch_transform(kg, object, OBJECT_TRANSFORM); + *D = transform_direction(&tfm, *D); +} + +__device_inline float object_surface_area(KernelGlobals *kg, int object) +{ + int offset = object*OBJECT_SIZE + OBJECT_PROPERTIES; + float4 f = kernel_tex_fetch(__objects, offset); + return f.x; +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/kernel_path.h b/intern/cycles/kernel/kernel_path.h new file mode 100644 index 00000000000..15c7e67f101 --- /dev/null +++ b/intern/cycles/kernel/kernel_path.h @@ -0,0 +1,263 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "kernel_differential.h" +#include "kernel_montecarlo.h" +#include "kernel_triangle.h" +#include "kernel_object.h" +#ifdef __QBVH__ +#include "kernel_qbvh.h" +#else +#include "kernel_bvh.h" +#endif +#include "kernel_camera.h" +#include "kernel_shader.h" +#include "kernel_light.h" +#include "kernel_emission.h" +#include "kernel_random.h" + +CCL_NAMESPACE_BEGIN + +#ifdef __MODIFY_TP__ +__device float3 path_terminate_modified_throughput(KernelGlobals *kg, __global float3 *buffer, int x, int y, int pass) +{ + /* modify throughput to influence path termination probability, to avoid + darker regions receiving fewer samples than lighter regions. also RGB + are weighted differently. proper validation still remains to be done. */ + const float3 weights = make_float3(1.0f, 1.33f, 0.66f); + const float3 one = make_float3(1.0f, 1.0f, 1.0f); + const int minpass = 5; + const float minL = 0.1f; + + if(pass >= minpass) { + float3 L = buffer[x + y*kernel_data.cam.width]; + float3 Lmin = make_float3(minL, minL, minL); + float correct = (float)(pass+1)/(float)pass; + + L = film_map(L*correct, pass); + + return weights/clamp(L, Lmin, one); + } + + return weights; +} +#endif + +__device float path_terminate_probability(KernelGlobals *kg, int bounce, const float3 throughput) +{ + if(bounce >= kernel_data.integrator.maxbounce) + return 0.0f; + else if(bounce <= kernel_data.integrator.minbounce) + return 1.0f; + + return average(throughput); +} + +__device int path_flag_from_label(int path_flag, int label) +{ + /* reflect/transmit */ + if(label & LABEL_REFLECT) { + path_flag |= PATH_RAY_REFLECT; + path_flag &= ~PATH_RAY_TRANSMIT; + } + else { + kernel_assert(label & LABEL_TRANSMIT); + + path_flag |= PATH_RAY_TRANSMIT; + path_flag &= ~PATH_RAY_REFLECT; + } + + /* diffuse/glossy/singular */ + if(label & LABEL_DIFFUSE) { + path_flag |= PATH_RAY_DIFFUSE; + path_flag &= ~(PATH_RAY_GLOSSY|PATH_RAY_SINGULAR); + } + else if(label & LABEL_GLOSSY) { + path_flag |= PATH_RAY_GLOSSY; + path_flag &= ~(PATH_RAY_DIFFUSE|PATH_RAY_SINGULAR); + } + else { + kernel_assert(label & (LABEL_SINGULAR|LABEL_STRAIGHT)); + + path_flag |= PATH_RAY_SINGULAR; + path_flag &= ~(PATH_RAY_DIFFUSE|PATH_RAY_GLOSSY); + } + + /* ray through transparent is still camera ray */ + if(!(label & LABEL_STRAIGHT)) + path_flag &= ~PATH_RAY_CAMERA; + + return path_flag; +} + +__device float3 kernel_path_integrate(KernelGlobals *kg, RNG *rng, int pass, Ray ray, float3 throughput) +{ + /* initialize */ + float3 L = make_float3(0.0f, 0.0f, 0.0f); + +#ifdef __EMISSION__ + float ray_pdf = 0.0f; +#endif + int path_flag = PATH_RAY_CAMERA|PATH_RAY_SINGULAR; + int rng_offset = PRNG_BASE_NUM; + + /* path iteration */ + for(int bounce = 0; ; bounce++, rng_offset += PRNG_BOUNCE_NUM) { + /* intersect scene */ + Intersection isect; + + if(!scene_intersect(kg, &ray, false, &isect)) { + /* eval background shader if nothing hit */ +#ifdef __BACKGROUND__ + ShaderData sd; + shader_setup_from_background(kg, &sd, &ray); + L += throughput*shader_eval_background(kg, &sd, path_flag); + shader_release(kg, &sd); +#else + L += throughputmake_float3(0.8f, 0.8f, 0.8f); +#endif + break; + } + + /* setup shading */ + ShaderData sd; + shader_setup_from_ray(kg, &sd, &isect, &ray); + float rbsdf = path_rng(kg, rng, pass, rng_offset + PRNG_BSDF); + shader_eval_surface(kg, &sd, rbsdf, path_flag); + +#ifdef __EMISSION__ + /* emission */ + if(kernel_data.integrator.use_emission) { + if(sd.flag & SD_EMISSION) + L += throughput*indirect_emission(kg, &sd, isect.t, path_flag, ray_pdf); + + /* sample illumination from lights to find path contribution */ + if((sd.flag & SD_BSDF_HAS_EVAL) && + bounce != kernel_data.integrator.maxbounce) { + float light_t = path_rng(kg, rng, pass, rng_offset + PRNG_LIGHT); + float light_o = path_rng(kg, rng, pass, rng_offset + PRNG_LIGHT_F); + float light_u = path_rng(kg, rng, pass, rng_offset + PRNG_LIGHT_U); + float light_v = path_rng(kg, rng, pass, rng_offset + PRNG_LIGHT_V); + + Ray light_ray; + float3 light_L; + + if(direct_emission(kg, &sd, light_t, light_o, light_u, light_v, &light_ray, &light_L)) { + /* trace shadow ray */ + if(!scene_intersect(kg, &light_ray, true, &isect)) + L += throughput*light_L; + } + } + } +#endif + + /* sample BSDF */ + float bsdf_pdf; + float3 bsdf_eval; + float3 bsdf_omega_in; + differential3 bsdf_domega_in; + float bsdf_u = path_rng(kg, rng, pass, rng_offset + PRNG_BSDF_U); + float bsdf_v = path_rng(kg, rng, pass, rng_offset + PRNG_BSDF_V); + int label; + + label = shader_bsdf_sample(kg, &sd, bsdf_u, bsdf_v, &bsdf_eval, + &bsdf_omega_in, &bsdf_domega_in, &bsdf_pdf); + + shader_release(kg, &sd); + + if(bsdf_pdf == 0.0f || is_zero(bsdf_eval)) + break; + + /* modify throughput */ + throughput *= bsdf_eval/bsdf_pdf; + + /* set labels */ +#ifdef __EMISSION__ + ray_pdf = bsdf_pdf; +#endif + + path_flag = path_flag_from_label(path_flag, label); + + /* path termination */ + float probability = path_terminate_probability(kg, bounce, throughput); + float terminate = path_rng(kg, rng, pass, rng_offset + PRNG_TERMINATE); + + if(terminate >= probability) + break; + + throughput /= probability; + + /* setup ray */ + ray.P = ray_offset(sd.P, (label & LABEL_TRANSMIT)? -sd.Ng: sd.Ng); + ray.D = bsdf_omega_in; + ray.t = FLT_MAX; +#ifdef __RAY_DIFFERENTIALS__ + ray.dP = sd.dP; + ray.dD = bsdf_domega_in; +#endif + } + + return L; +} + +__device void kernel_path_trace(KernelGlobals *kg, __global float4 *buffer, __global uint *rng_state, int pass, int x, int y) +{ + /* initialize random numbers */ + RNG rng; + + float filter_u; + float filter_v; + + path_rng_init(kg, rng_state, pass, &rng, x, y, &filter_u, &filter_v); + + /* sample camera ray */ + Ray ray; + + float lens_u = path_rng(kg, &rng, pass, PRNG_LENS_U); + float lens_v = path_rng(kg, &rng, pass, PRNG_LENS_V); + + camera_sample(kg, x, y, filter_u, filter_v, lens_u, lens_v, &ray); + + /* integrate */ +#ifdef __MODIFY_TP__ + float3 throughput = path_terminate_modified_throughput(kg, buffer, x, y, pass); + float3 L = kernel_path_integrate(kg, &rng, pass, ray, throughput)/throughput; +#else + float3 throughput = make_float3(1.0f, 1.0f, 1.0f); + float3 L = kernel_path_integrate(kg, &rng, pass, ray, throughput); +#endif + + /* accumulate result in output buffer */ + int index = x + y*kernel_data.cam.width; + + float4 result; + result.x = L.x; + result.y = L.y; + result.z = L.z; + result.w = 1.0f; + + if(pass == 0) + buffer[index] = result; + else + buffer[index] += result; + + path_rng_end(kg, rng_state, rng, x, y); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/kernel_qbvh.h b/intern/cycles/kernel/kernel_qbvh.h new file mode 100644 index 00000000000..96e68d797dd --- /dev/null +++ b/intern/cycles/kernel/kernel_qbvh.h @@ -0,0 +1,413 @@ +/* + * Adapted from code Copyright 2009-2010 NVIDIA Corporation + * Modifications Copyright 2011, Blender Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +CCL_NAMESPACE_BEGIN + +/* + * "Persistent while-while kernel" used in: + * + * "Understanding the Efficiency of Ray Traversal on GPUs", + * Timo Aila and Samuli Laine, + * Proc. High-Performance Graphics 2009 + */ + +/* bottom-most stack entry, indicating the end of traversal */ + +#define ENTRYPOINT_SENTINEL 0x76543210 +/* 64 object BVH + 64 mesh BVH + 64 object node splitting */ +#define QBVH_STACK_SIZE 192 +#define QBVH_NODE_SIZE 8 +#define TRI_NODE_SIZE 3 + +__device_inline float3 qbvh_inverse_direction(float3 dir) +{ + // Avoid divide by zero (ooeps = exp2f(-80.0f)) + float ooeps = 0.00000000000000000000000082718061255302767487140869206996285356581211090087890625f; + float3 idir; + + idir.x = 1.0f/((fabsf(dir.x) > ooeps)? dir.x: copysignf(ooeps, dir.x)); + idir.y = 1.0f/((fabsf(dir.y) > ooeps)? dir.y: copysignf(ooeps, dir.y)); + idir.z = 1.0f/((fabsf(dir.z) > ooeps)? dir.z: copysignf(ooeps, dir.z)); + + return idir; +} + +__device_inline void qbvh_instance_push(KernelGlobals *kg, int object, const Ray *ray, float3 *P, float3 *idir, float *t, const float tmax) +{ + Transform tfm = object_fetch_transform(kg, object, OBJECT_INVERSE_TRANSFORM); + + *P = transform(&tfm, ray->P); + + float3 dir = transform_direction(&tfm, ray->D); + + float len; + dir = normalize_len(dir, &len); + + *idir = qbvh_inverse_direction(dir); + + if(*t != FLT_MAX) + *t *= len; +} + +__device_inline void qbvh_instance_pop(KernelGlobals *kg, int object, const Ray *ray, float3 *P, float3 *idir, float *t, const float tmax) +{ + Transform tfm = object_fetch_transform(kg, object, OBJECT_TRANSFORM); + + if(*t != FLT_MAX) + *t *= len(transform_direction(&tfm, 1.0f/(*idir))); + + *P = ray->P; + *idir = qbvh_inverse_direction(ray->D); +} + +#ifdef __KERNEL_CPU__ + +__device_inline void qbvh_node_intersect(KernelGlobals *kg, int *traverseChild, + int nodeAddrChild[4], float3 P, float3 idir, float t, int nodeAddr) +{ + /* X axis */ + const __m128 bminx = kernel_tex_fetch_m128(__bvh_nodes, nodeAddr*QBVH_NODE_SIZE+0); + const __m128 t0x = _mm_mul_ps(_mm_sub_ps(bminx, _mm_set_ps1(P.x)), _mm_set_ps1(idir.x)); + const __m128 bmaxx = kernel_tex_fetch_m128(__bvh_nodes, nodeAddr*QBVH_NODE_SIZE+1); + const __m128 t1x = _mm_mul_ps(_mm_sub_ps(bmaxx, _mm_set_ps1(P.x)), _mm_set_ps1(idir.x)); + + __m128 tmin = _mm_max_ps(_mm_min_ps(t0x, t1x), _mm_setzero_ps()); + __m128 tmax = _mm_min_ps(_mm_max_ps(t0x, t1x), _mm_set_ps1(t)); + + /* Y axis */ + const __m128 bminy = kernel_tex_fetch_m128(__bvh_nodes, nodeAddr*QBVH_NODE_SIZE+2); + const __m128 t0y = _mm_mul_ps(_mm_sub_ps(bminy, _mm_set_ps1(P.y)), _mm_set_ps1(idir.y)); + const __m128 bmaxy = kernel_tex_fetch_m128(__bvh_nodes, nodeAddr*QBVH_NODE_SIZE+3); + const __m128 t1y = _mm_mul_ps(_mm_sub_ps(bmaxy, _mm_set_ps1(P.y)), _mm_set_ps1(idir.y)); + + tmin = _mm_max_ps(_mm_min_ps(t0y, t1y), tmin); + tmax = _mm_min_ps(_mm_max_ps(t0y, t1y), tmax); + + /* Z axis */ + const __m128 bminz = kernel_tex_fetch_m128(__bvh_nodes, nodeAddr*QBVH_NODE_SIZE+4); + const __m128 t0z = _mm_mul_ps(_mm_sub_ps(bminz, _mm_set_ps1(P.z)), _mm_set_ps1(idir.z)); + const __m128 bmaxz = kernel_tex_fetch_m128(__bvh_nodes, nodeAddr*QBVH_NODE_SIZE+5); + const __m128 t1z = _mm_mul_ps(_mm_sub_ps(bmaxz, _mm_set_ps1(P.z)), _mm_set_ps1(idir.z)); + + tmin = _mm_max_ps(_mm_min_ps(t0z, t1z), tmin); + tmax = _mm_min_ps(_mm_max_ps(t0z, t1z), tmax); + + /* compare and get mask */ + *traverseChild = _mm_movemask_ps(_mm_cmple_ps(tmin, tmax)); + + /* get node addresses */ + float4 cnodes = kernel_tex_fetch(__bvh_nodes, nodeAddr*QBVH_NODE_SIZE+6); + + nodeAddrChild[0] = __float_as_int(cnodes.x); + nodeAddrChild[1] = __float_as_int(cnodes.y); + nodeAddrChild[2] = __float_as_int(cnodes.z); + nodeAddrChild[3] = __float_as_int(cnodes.w); +} + +#else + +__device_inline bool qbvh_bb_intersect(float3 bmin, float3 bmax, float3 P, float3 idir, float t) +{ + float t0x = (bmin.x - P.x)*idir.x; + float t1x = (bmax.x - P.x)*idir.x; + float t0y = (bmin.y - P.y)*idir.y; + float t1y = (bmax.y - P.y)*idir.y; + float t0z = (bmin.z - P.z)*idir.z; + float t1z = (bmax.z - P.z)*idir.z; + + float minx = min(t0x, t1x); + float maxx = max(t0x, t1x); + float miny = min(t0y, t1y); + float maxy = max(t0y, t1y); + float minz = min(t0z, t1z); + float maxz = max(t0z, t1z); + + float tmin = max4(0.0f, minx, miny, minz); + float tmax = min4(t, maxx, maxy, maxz); + + return (tmin <= tmax); +} + +/* intersect four bounding boxes */ +__device_inline void qbvh_node_intersect(KernelGlobals *kg, int *traverseChild, + int nodeAddrChild[4], float3 P, float3 idir, float t, int nodeAddr) +{ + /* fetch node data */ + float4 minx = kernel_tex_fetch(__bvh_nodes, nodeAddr*QBVH_NODE_SIZE+0); + float4 miny = kernel_tex_fetch(__bvh_nodes, nodeAddr*QBVH_NODE_SIZE+2); + float4 minz = kernel_tex_fetch(__bvh_nodes, nodeAddr*QBVH_NODE_SIZE+4); + float4 maxx = kernel_tex_fetch(__bvh_nodes, nodeAddr*QBVH_NODE_SIZE+1); + float4 maxy = kernel_tex_fetch(__bvh_nodes, nodeAddr*QBVH_NODE_SIZE+3); + float4 maxz = kernel_tex_fetch(__bvh_nodes, nodeAddr*QBVH_NODE_SIZE+5); + + /* intersect bounding boxes */ + bool traverseChild0 = qbvh_bb_intersect(make_float3(minx.x, miny.x, minz.x), make_float3(maxx.x, maxy.x, maxz.x), P, idir, t); + bool traverseChild1 = qbvh_bb_intersect(make_float3(minx.y, miny.y, minz.y), make_float3(maxx.y, maxy.y, maxz.y), P, idir, t); + bool traverseChild2 = qbvh_bb_intersect(make_float3(minx.z, miny.z, minz.z), make_float3(maxx.z, maxy.z, maxz.z), P, idir, t); + bool traverseChild3 = qbvh_bb_intersect(make_float3(minx.w, miny.w, minz.w), make_float3(maxx.w, maxy.w, maxz.w), P, idir, t); + + *traverseChild = 0; + if(traverseChild0) *traverseChild |= 1; + if(traverseChild1) *traverseChild |= 2; + if(traverseChild2) *traverseChild |= 4; + if(traverseChild3) *traverseChild |= 8; + + /* get node addresses */ + float4 cnodes = kernel_tex_fetch(__bvh_nodes, nodeAddr*QBVH_NODE_SIZE+6); + + nodeAddrChild[0] = __float_as_int(cnodes.x); + nodeAddrChild[1] = __float_as_int(cnodes.y); + nodeAddrChild[2] = __float_as_int(cnodes.z); + nodeAddrChild[3] = __float_as_int(cnodes.w); +} + +#endif + +/* Sven Woop's algorithm */ +__device_inline void qbvh_triangle_intersect(KernelGlobals *kg, Intersection *isect, float3 P, float3 idir, int object, int triAddr) +{ + /* compute and check intersection t-value */ + float4 v00 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+0); + float4 v11 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+1); + float3 dir = 1.0f/idir; + + float Oz = v00.w - P.x*v00.x - P.y*v00.y - P.z*v00.z; + float invDz = 1.0f/(dir.x*v00.x + dir.y*v00.y + dir.z*v00.z); + float t = Oz * invDz; + + if(t > 0.0f && t < isect->t) { + /* compute and check barycentric u */ + float Ox = v11.w + P.x*v11.x + P.y*v11.y + P.z*v11.z; + float Dx = dir.x*v11.x + dir.y*v11.y + dir.z*v11.z; + float u = Ox + t*Dx; + + if(u >= 0.0f) { + /* compute and check barycentric v */ + float4 v22 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+2); + float Oy = v22.w + P.x*v22.x + P.y*v22.y + P.z*v22.z; + float Dy = dir.x*v22.x + dir.y*v22.y + dir.z*v22.z; + float v = Oy + t*Dy; + + if(v >= 0.0f && u + v <= 1.0f) { + /* record intersection */ + isect->prim = triAddr; + isect->object = object; + isect->u = u; + isect->v = v; + isect->t = t; + } + } + } +} + +__device_inline bool scene_intersect(KernelGlobals *kg, const Ray *ray, const bool isshadowray, Intersection *isect) +{ + /* traversal stack in CUDA thread-local memory */ + int traversalStack[QBVH_STACK_SIZE]; + traversalStack[0] = ENTRYPOINT_SENTINEL; + + /* traversal variables in registers */ + int stackPtr = 0; + int nodeAddr = kernel_data.bvh.root; + + /* ray parameters in registers */ + const float tmax = ray->t; + float3 P = ray->P; + float3 idir = qbvh_inverse_direction(ray->D); + int object = ~0; + + isect->t = tmax; + isect->object = ~0; + isect->prim = ~0; + isect->u = 0.0f; + isect->v = 0.0f; + + /* traversal loop */ + do { + do + { + /* traverse internal nodes */ + while(nodeAddr >= 0 && nodeAddr != ENTRYPOINT_SENTINEL) + { + int traverseChild, nodeAddrChild[4]; + + qbvh_node_intersect(kg, &traverseChild, nodeAddrChild, + P, idir, isect->t, nodeAddr); + + if(traverseChild & 1) { + ++stackPtr; + traversalStack[stackPtr] = nodeAddrChild[0]; + } + + if(traverseChild & 2) { + ++stackPtr; + traversalStack[stackPtr] = nodeAddrChild[1]; + } + if(traverseChild & 4) { + ++stackPtr; + traversalStack[stackPtr] = nodeAddrChild[2]; + } + + if(traverseChild & 8) { + ++stackPtr; + traversalStack[stackPtr] = nodeAddrChild[3]; + } + + nodeAddr = traversalStack[stackPtr]; + --stackPtr; + } + + /* if node is leaf, fetch triangle list */ + if(nodeAddr < 0) { + float4 leaf = kernel_tex_fetch(__bvh_nodes, (-nodeAddr-1)*QBVH_NODE_SIZE+(QBVH_NODE_SIZE-2)); + int primAddr = __float_as_int(leaf.x); + +#ifdef __INSTANCING__ + if(primAddr >= 0) { +#endif + int primAddr2 = __float_as_int(leaf.y); + + /* pop */ + nodeAddr = traversalStack[stackPtr]; + --stackPtr; + + /* triangle intersection */ + while(primAddr < primAddr2) { + /* intersect ray against triangle */ + qbvh_triangle_intersect(kg, isect, P, idir, object, primAddr); + + /* shadow ray early termination */ + if(isshadowray && isect->prim != ~0) + return true; + + primAddr++; + } +#ifdef __INSTANCING__ + } + else { + /* instance push */ + object = kernel_tex_fetch(__prim_object, -primAddr-1); + + qbvh_instance_push(kg, object, ray, &P, &idir, &isect->t, tmax); + + ++stackPtr; + traversalStack[stackPtr] = ENTRYPOINT_SENTINEL; + + nodeAddr = kernel_tex_fetch(__object_node, object); + } +#endif + } + } while(nodeAddr != ENTRYPOINT_SENTINEL); + +#ifdef __INSTANCING__ + if(stackPtr >= 0) { + kernel_assert(object != ~0); + + /* instance pop */ + qbvh_instance_pop(kg, object, ray, &P, &idir, &isect->t, tmax); + object = ~0; + nodeAddr = traversalStack[stackPtr]; + --stackPtr; + } +#endif + } while(nodeAddr != ENTRYPOINT_SENTINEL); + + return (isect->prim != ~0); +} + +__device_inline float3 ray_offset(float3 P, float3 Ng) +{ +#ifdef __INTERSECTION_REFINE__ + const float epsilon_f = 1e-5f; + const int epsilon_i = 32; + + float3 res; + + /* x component */ + if(fabsf(P.x) < epsilon_f) { + res.x = P.x + Ng.x*epsilon_f; + } + else { + uint ix = __float_as_uint(P.x); + ix += ((ix ^ __float_as_uint(Ng.x)) >> 31)? -epsilon_i: epsilon_i; + res.x = __uint_as_float(ix); + } + + /* y component */ + if(fabsf(P.y) < epsilon_f) { + res.y = P.y + Ng.y*epsilon_f; + } + else { + uint iy = __float_as_uint(P.y); + iy += ((iy ^ __float_as_uint(Ng.y)) >> 31)? -epsilon_i: epsilon_i; + res.y = __uint_as_float(iy); + } + + /* z component */ + if(fabsf(P.z) < epsilon_f) { + res.z = P.z + Ng.z*epsilon_f; + } + else { + uint iz = __float_as_uint(P.z); + iz += ((iz ^ __float_as_uint(Ng.z)) >> 31)? -epsilon_i: epsilon_i; + res.z = __uint_as_float(iz); + } + + return res; +#else + const float epsilon_f = 1e-4f; + return P + epsilon_f*Ng; +#endif +} + +__device_inline float3 bvh_triangle_refine(KernelGlobals *kg, const Intersection *isect, const Ray *ray) +{ + float3 P = ray->P; + float3 D = ray->D; + float t = isect->t; + +#ifdef __INTERSECTION_REFINE__ + if(isect->object != ~0) { + Transform tfm = object_fetch_transform(kg, isect->object, OBJECT_INVERSE_TRANSFORM); + + P = transform(&tfm, P); + D = transform_direction(&tfm, D*t); + D = normalize_len(D, &t); + } + + P = P + D*t; + + float4 v00 = kernel_tex_fetch(__tri_woop, isect->prim*TRI_NODE_SIZE+0); + float Oz = v00.w - P.x*v00.x - P.y*v00.y - P.z*v00.z; + float invDz = 1.0f/(D.x*v00.x + D.y*v00.y + D.z*v00.z); + float rt = Oz * invDz; + + P = P + D*rt; + + if(isect->object != ~0) { + Transform tfm = object_fetch_transform(kg, isect->object, OBJECT_TRANSFORM); + P = transform(&tfm, P); + } + + return P; +#else + return P + D*t; +#endif +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/kernel_random.h b/intern/cycles/kernel/kernel_random.h new file mode 100644 index 00000000000..6c2daafb061 --- /dev/null +++ b/intern/cycles/kernel/kernel_random.h @@ -0,0 +1,175 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +typedef uint RNG; + +#ifdef __SOBOL__ + +/* High Dimensional Sobol */ + +/* van der corput radical inverse */ +__device uint van_der_corput(uint bits) +{ + bits = (bits << 16) | (bits >> 16); + bits = ((bits & 0x00ff00ff) << 8) | ((bits & 0xff00ff00) >> 8); + bits = ((bits & 0x0f0f0f0f) << 4) | ((bits & 0xf0f0f0f0) >> 4); + bits = ((bits & 0x33333333) << 2) | ((bits & 0xcccccccc) >> 2); + bits = ((bits & 0x55555555) << 1) | ((bits & 0xaaaaaaaa) >> 1); + return bits; +} + +/* sobol radical inverse */ +__device uint sobol(uint i) +{ + uint r = 0; + + for(uint v = 1U << 31; i; i >>= 1, v ^= v >> 1) + if(i & 1) + r ^= v; + + return r; +} + +/* inverse of sobol radical inverse */ +__device uint sobol_inverse(uint i) +{ + const uint msb = 1U << 31; + uint r = 0; + + for(uint v = 1; i; i <<= 1, v ^= v << 1) + if(i & msb) + r ^= v; + + return r; +} + +/* multidimensional sobol with generator matrices + dimension 0 and 1 are equal to van_der_corput() and sobol() respectively */ +__device uint sobol_dimension(KernelGlobals *kg, int index, int dimension) +{ + uint result = 0; + uint i = index; + + for(uint j = 0; i; i >>= 1, j++) + if(i & 1) + result ^= kernel_tex_fetch(__sobol_directions, 32*dimension + j); + + return result; +} + +/* lookup index and x/y coordinate, assumes m is a power of two */ +__device uint sobol_lookup(const uint m, const uint frame, const uint ex, const uint ey, uint *x, uint *y) +{ + /* shift is constant per frame */ + const uint shift = frame << (m << 1); + const uint sobol_shift = sobol(shift); + /* van der Corput is its own inverse */ + const uint lower = van_der_corput(ex << (32 - m)); + /* need to compensate for ey difference and shift */ + const uint sobol_lower = sobol(lower); + const uint mask = ~-(1 << m) << (32 - m); /* only m upper bits */ + const uint delta = ((ey << (32 - m)) ^ sobol_lower ^ sobol_shift) & mask; + /* only use m upper bits for the index (m is a power of two) */ + const uint sobol_result = delta | (delta >> m); + const uint upper = sobol_inverse(sobol_result); + const uint index = shift | upper | lower; + *x = van_der_corput(index); + *y = sobol_shift ^ sobol_result ^ sobol_lower; + return index; +} + +__device_inline float path_rng(KernelGlobals *kg, RNG *rng, int pass, int dimension) +{ +#ifdef __SOBOL_FULL_SCREEN__ + uint result = sobol_dimension(kg, *rng, dimension); + float r = (float)result * (1.0f/(float)0xFFFFFFFF); + return r; +#else + /* compute sobol sequence value using direction vectors */ + uint result = sobol_dimension(kg, pass, dimension); + float r = (float)result * (1.0f/(float)0xFFFFFFFF); + + /* Cranly-Patterson rotation using rng seed */ + float shift; + + if(dimension & 1) + shift = (*rng >> 16)/((float)0xFFFF); + else + shift = (*rng & 0xFFFF)/((float)0xFFFF); + + return r + shift - floor(r + shift); +#endif +} + +__device_inline void path_rng_init(KernelGlobals *kg, __global uint *rng_state, int pass, RNG *rng, int x, int y, float *fx, float *fy) +{ +#ifdef __SOBOL_FULL_SCREEN__ + uint px, py; + uint bits = 16; /* limits us to 65536x65536 and 65536 samples */ + uint size = 1 << bits; + uint frame = pass; + + *rng = sobol_lookup(bits, frame, x, y, &px, &py); + + *fx = size * (float)px * (1.0f/(float)0xFFFFFFFF) - x; + *fy = size * (float)py * (1.0f/(float)0xFFFFFFFF) - y; +#else + *rng = rng_state[x + y*kernel_data.cam.width]; + + *fx = path_rng(kg, rng, pass, PRNG_FILTER_U); + *fy = path_rng(kg, rng, pass, PRNG_FILTER_V); +#endif +} + +__device void path_rng_end(KernelGlobals *kg, __global uint *rng_state, RNG rng, int x, int y) +{ + /* nothing to do */ +} + +#else + +/* Linear Congruential Generator */ + +__device float path_rng(KernelGlobals *kg, RNG *rng, int pass, int dimension) +{ + /* implicit mod 2^32 */ + *rng = (1103515245*(*rng) + 12345); + return (float)*rng * (1.0f/(float)0xFFFFFFFF); +} + +__device void path_rng_init(KernelGlobals *kg, __global uint *rng_state, int pass, RNG *rng, int x, int y, float *fx, float *fy) +{ + /* load state */ + *rng = rng_state[x + y*kernel_data.cam.width]; + + *fx = path_rng(kg, rng, pass, PRNG_FILTER_U); + *fy = path_rng(kg, rng, pass, PRNG_FILTER_V); +} + +__device void path_rng_end(KernelGlobals *kg, __global uint *rng_state, RNG rng, int x, int y) +{ + /* store state for next pass */ + rng_state[x + y*kernel_data.cam.width] = rng; +} + +#endif + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/kernel_shader.h b/intern/cycles/kernel/kernel_shader.h new file mode 100644 index 00000000000..f1abbda7ae5 --- /dev/null +++ b/intern/cycles/kernel/kernel_shader.h @@ -0,0 +1,460 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +/* + * ShaderData, used in four steps: + * + * Setup from incoming ray, sampled position and background. + * Execute for surface, volume or displacement. + * Evaluate one or more closures. + * Release. + * + */ + +#include "svm/bsdf.h" +#include "svm/emissive.h" +#include "svm/volume.h" +#include "svm/svm_bsdf.h" +#include "svm/svm.h" + +#ifdef WITH_OSL +#include "osl_shader.h" +#endif + +CCL_NAMESPACE_BEGIN + +/* ShaderData setup from incoming ray */ + +__device_inline void shader_setup_from_ray(KernelGlobals *kg, ShaderData *sd, + const Intersection *isect, const Ray *ray) +{ + /* fetch triangle data */ + int prim = kernel_tex_fetch(__prim_index, isect->prim); + float4 Ns = kernel_tex_fetch(__tri_normal, prim); + float3 Ng = make_float3(Ns.x, Ns.y, Ns.z); + int shader = __float_as_int(Ns.w); + + /* vectors */ + sd->P = bvh_triangle_refine(kg, isect, ray); + sd->Ng = Ng; + sd->N = Ng; + sd->I = -ray->D; + sd->shader = shader; + sd->flag = 0; + + /* triangle */ +#ifdef __INSTANCING__ + sd->object = isect->object; +#endif + sd->prim = prim; +#ifdef __UV__ + sd->u = isect->u; + sd->v = isect->v; +#endif + + /* smooth normal */ + if(sd->shader < 0) { + sd->N = triangle_smooth_normal(kg, sd->prim, sd->u, sd->v); + sd->shader = -sd->shader; + } + +#ifdef __DPDU__ + /* dPdu/dPdv */ + triangle_dPdudv(kg, &sd->dPdu, &sd->dPdv, sd->prim); +#endif + +#ifdef __INSTANCING__ + if(sd->object != ~0) { + /* instance transform */ + object_normal_transform(kg, sd->object, &sd->N); + object_normal_transform(kg, sd->object, &sd->Ng); +#ifdef __DPDU__ + object_dir_transform(kg, sd->object, &sd->dPdu); + object_dir_transform(kg, sd->object, &sd->dPdv); +#endif + } + else { + /* non-instanced object index */ + sd->object = kernel_tex_fetch(__prim_object, isect->prim); + } +#endif + + /* backfacing test */ + bool backfacing = (dot(sd->Ng, sd->I) < 0.0f); + + if(backfacing) { + sd->flag = SD_BACKFACING; + sd->Ng = -sd->Ng; + sd->N = -sd->N; +#ifdef __DPDU__ + sd->dPdu = -sd->dPdu; + sd->dPdv = -sd->dPdv; +#endif + } + +#ifdef __RAY_DIFFERENTIALS__ + /* differentials */ + differential_transfer(&sd->dP, ray->dP, ray->D, ray->dD, sd->Ng, isect->t); + differential_incoming(&sd->dI, ray->dD); + differential_dudv(&sd->du, &sd->dv, sd->dPdu, sd->dPdv, sd->dP, sd->Ng); +#endif +} + +/* ShaderData setup from position sampled on mesh */ + +__device void shader_setup_from_sample(KernelGlobals *kg, ShaderData *sd, + const float3 P, const float3 Ng, const float3 I, + int shader, int object, int prim, float u, float v) +{ + /* vectors */ + sd->P = P; + sd->N = Ng; + sd->Ng = Ng; + sd->I = I; + sd->shader = shader; + sd->flag = 0; + + /* primitive */ +#ifdef __INSTANCING__ + sd->object = object; +#endif + sd->prim = prim; +#ifdef __UV__ + sd->u = u; + sd->v = v; +#endif + + /* detect instancing, for non-instanced the object index is -object-1 */ + bool instanced = false; + + if(sd->prim != ~0) { + if(sd->object >= 0) + instanced = true; + else + sd->object = -sd->object-1; + } + + /* smooth normal */ + if(sd->shader < 0) { + sd->N = triangle_smooth_normal(kg, sd->prim, sd->u, sd->v); + sd->shader = -sd->shader; + +#ifdef __INSTANCING__ + if(instanced) + object_normal_transform(kg, sd->object, &sd->N); +#endif + } + +#ifdef __DPDU__ + /* dPdu/dPdv */ + if(sd->prim == ~0) { + sd->dPdu = make_float3(0.0f, 0.0f, 0.0f); + sd->dPdv = make_float3(0.0f, 0.0f, 0.0f); + } + else { + triangle_dPdudv(kg, &sd->dPdu, &sd->dPdv, sd->prim); + +#ifdef __INSTANCING__ + if(instanced) { + object_dir_transform(kg, sd->object, &sd->dPdu); + object_dir_transform(kg, sd->object, &sd->dPdv); + } +#endif + } +#endif + + /* backfacing test */ + if(sd->prim != ~0) { + bool backfacing = (dot(sd->Ng, sd->I) < 0.0f); + + if(backfacing) { + sd->flag = SD_BACKFACING; + sd->Ng = -sd->Ng; + sd->N = -sd->N; +#ifdef __DPDU__ + sd->dPdu = -sd->dPdu; + sd->dPdv = -sd->dPdv; +#endif + } + } + +#ifdef __RAY_DIFFERENTIALS__ + /* no ray differentials here yet */ + sd->dP.dx = make_float3(0.0f, 0.0f, 0.0f); + sd->dP.dy = make_float3(0.0f, 0.0f, 0.0f); + sd->dI.dx = make_float3(0.0f, 0.0f, 0.0f); + sd->dI.dy = make_float3(0.0f, 0.0f, 0.0f); + sd->du.dx = 0.0f; + sd->du.dy = 0.0f; + sd->dv.dx = 0.0f; + sd->dv.dy = 0.0f; +#endif +} + +/* ShaderData setup for displacement */ + +__device void shader_setup_from_displace(KernelGlobals *kg, ShaderData *sd, + int object, int prim, float u, float v) +{ + float3 P, Ng, I = make_float3(0.0f, 0.0f, 0.0f); + int shader; + + P = triangle_point_MT(kg, prim, u, v); + Ng = triangle_normal_MT(kg, prim, &shader); + + /* force smooth shading for displacement */ + if(shader >= 0) + shader = -shader; + + /* watch out: no instance transform currently */ + + shader_setup_from_sample(kg, sd, P, Ng, I, shader, object, prim, u, v); +} + +/* ShaderData setup from ray into background */ + +__device_inline void shader_setup_from_background(KernelGlobals *kg, ShaderData *sd, const Ray *ray) +{ + /* vectors */ + sd->P = ray->D; + sd->N = -sd->P; + sd->Ng = -sd->P; + sd->I = -sd->P; + sd->shader = kernel_data.background.shader; + sd->flag = 0; + +#ifdef __INSTANCING__ + sd->object = ~0; +#endif + sd->prim = ~0; +#ifdef __UV__ + sd->u = 0.0f; + sd->v = 0.0f; +#endif + +#ifdef __DPDU__ + /* dPdu/dPdv */ + sd->dPdu = make_float3(0.0f, 0.0f, 0.0f); + sd->dPdv = make_float3(0.0f, 0.0f, 0.0f); +#endif + +#ifdef __RAY_DIFFERENTIALS__ + /* differentials */ + sd->dP = ray->dD; + differential_incoming(&sd->dI, sd->dP); + sd->du.dx = 0.0f; + sd->du.dy = 0.0f; + sd->dv.dx = 0.0f; + sd->dv.dy = 0.0f; +#endif +} + +/* BSDF */ + +__device int shader_bsdf_sample(KernelGlobals *kg, const ShaderData *sd, + float randu, float randv, float3 *eval, + float3 *omega_in, differential3 *domega_in, float *pdf) +{ + int label; + + *pdf = 0.0f; + +#ifdef WITH_OSL + if(kg->osl.use) + label = OSLShader::bsdf_sample(sd, randu, randv, *eval, *omega_in, *domega_in, *pdf); + else +#endif + label = svm_bsdf_sample(sd, randu, randv, eval, omega_in, domega_in, pdf); + + return label; +} + +__device float3 shader_bsdf_eval(KernelGlobals *kg, const ShaderData *sd, + const float3 omega_in, float *pdf) +{ + float3 eval; + + *pdf = 0.0f; + +#ifdef WITH_OSL + if(kg->osl.use) + eval = OSLShader::bsdf_eval(sd, omega_in, *pdf); + else +#endif + eval = svm_bsdf_eval(sd, omega_in, pdf); + + return eval; +} + +__device void shader_bsdf_blur(KernelGlobals *kg, ShaderData *sd, float roughness) +{ +#ifdef WITH_OSL + if(!kg->osl.use) +#endif + svm_bsdf_blur(sd, roughness); +} + +/* Emission */ + +__device float3 shader_emissive_eval(KernelGlobals *kg, ShaderData *sd) +{ +#ifdef WITH_OSL + if(kg->osl.use) { + return OSLShader::emissive_eval(sd); + } + else +#endif + { + return svm_emissive_eval(sd); + } +} + +__device void shader_emissive_sample(KernelGlobals *kg, ShaderData *sd, + float randu, float randv, float3 *eval, float3 *I, float *pdf) +{ +#ifdef WITH_OSL + if(kg->osl.use) { + OSLShader::emissive_sample(sd, randu, randv, eval, I, pdf); + } + else +#endif + { + svm_emissive_sample(sd, randu, randv, eval, I, pdf); + } +} + +/* Surface Evaluation */ + +__device void shader_eval_surface(KernelGlobals *kg, ShaderData *sd, + float randb, int path_flag) +{ +#ifdef WITH_OSL + if(kg->osl.use) { + OSLShader::eval_surface(kg, sd, randb, path_flag); + } + else +#endif + { +#ifdef __SVM__ + svm_eval_nodes(kg, sd, SHADER_TYPE_SURFACE, randb, path_flag); +#else + sd->svm_closure = CLOSURE_BSDF_DIFFUSE_ID; + sd->svm_closure_weight = make_float3(0.8f, 0.8f, 0.8f); +#endif + +#ifdef __CAUSTICS_TRICKS__ + /* caustic tricks */ + if((path_flag & PATH_RAY_DIFFUSE) && (sd->flag & SD_BSDF_GLOSSY)) { + if(kernel_data.integrator.no_caustics) { + sd->flag &= ~(SD_BSDF_GLOSSY|SD_BSDF_HAS_EVAL|SD_EMISSION); + sd->svm_closure = NBUILTIN_CLOSURES; + sd->svm_closure_weight = make_float3(0.0f, 0.0f, 0.0f); + } + else if(kernel_data.integrator.blur_caustics > 0.0f) + shader_bsdf_blur(kg, sd, kernel_data.integrator.blur_caustics); + } +#endif + } +} + +/* Background Evaluation */ + +__device float3 shader_eval_background(KernelGlobals *kg, ShaderData *sd, int path_flag) +{ +#ifdef WITH_OSL + if(kg->osl.use) { + return OSLShader::eval_background(kg, sd, path_flag); + } + else +#endif + { +#ifdef __SVM__ + svm_eval_nodes(kg, sd, SHADER_TYPE_SURFACE, 0.0f, path_flag); +#else + sd->svm_closure_weight = make_float3(0.8f, 0.8f, 0.8f); +#endif + + return sd->svm_closure_weight; + } +} + +/* Volume */ + +__device float3 shader_volume_eval_phase(KernelGlobals *kg, ShaderData *sd, + float3 omega_in, float3 omega_out) +{ +#ifdef WITH_OSL + if(kg->osl.use) { + OSLShader::volume_eval_phase(sd, omega_in, omega_out); + } + else +#endif + { + return volume_eval_phase(sd, omega_in, omega_out); + } +} + +/* Volume Evaluation */ + +__device void shader_eval_volume(KernelGlobals *kg, ShaderData *sd, + float randb, int path_flag) +{ +#ifdef WITH_OSL + if(kg->osl.use) { + OSLShader::eval_volume(kg, sd, randb, path_flag); + } + else +#endif + { +#ifdef __SVM__ + svm_eval_nodes(kg, sd, SHADER_TYPE_VOLUME, randb, path_flag); +#endif + } +} + +/* Displacement Evaluation */ + +__device void shader_eval_displacement(KernelGlobals *kg, ShaderData *sd) +{ + /* this will modify sd->P */ + +#ifdef WITH_OSL + if(kg->osl.use) { + OSLShader::eval_displacement(kg, sd); + } + else +#endif + { +#ifdef __SVM__ + svm_eval_nodes(kg, sd, SHADER_TYPE_DISPLACEMENT, 0.0f, 0); +#endif + } +} + +/* Free ShaderData */ + +__device void shader_release(KernelGlobals *kg, ShaderData *sd) +{ +#ifdef WITH_OSL + if(kg->osl.use) + OSLShader::release(kg, sd); +#endif +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/kernel_triangle.h b/intern/cycles/kernel/kernel_triangle.h new file mode 100644 index 00000000000..64cbb2dcb61 --- /dev/null +++ b/intern/cycles/kernel/kernel_triangle.h @@ -0,0 +1,183 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Point on triangle for Moller-Trumbore triangles */ +__device_inline float3 triangle_point_MT(KernelGlobals *kg, int tri_index, float u, float v) +{ + /* load triangle vertices */ + float3 tri_vindex = as_float3(kernel_tex_fetch(__tri_vindex, tri_index)); + + float3 v0 = as_float3(kernel_tex_fetch(__tri_verts, __float_as_int(tri_vindex.x))); + float3 v1 = as_float3(kernel_tex_fetch(__tri_verts, __float_as_int(tri_vindex.y))); + float3 v2 = as_float3(kernel_tex_fetch(__tri_verts, __float_as_int(tri_vindex.z))); + + /* compute point */ + float t = 1.0f - u - v; + return (u*v0 + v*v1 + t*v2); +} + +/* Sample point on triangle */ +__device_inline float3 triangle_sample_MT(KernelGlobals *kg, int tri_index, float randu, float randv) +{ + /* compute point */ + randu = sqrtf(randu); + + float u = 1.0f - randu; + float v = randv*randu; + + return triangle_point_MT(kg, tri_index, u, v); +} + +/* Normal for Moller-Trumbore triangles */ +__device_inline float3 triangle_normal_MT(KernelGlobals *kg, int tri_index, int *shader) +{ +#if 0 + /* load triangle vertices */ + float3 tri_vindex = as_float3(kernel_tex_fetch(__tri_vindex, tri_index)); + + float3 v0 = as_float3(kernel_tex_fetch(__tri_verts, __float_as_int(tri_vindex.x))); + float3 v1 = as_float3(kernel_tex_fetch(__tri_verts, __float_as_int(tri_vindex.y))); + float3 v2 = as_float3(kernel_tex_fetch(__tri_verts, __float_as_int(tri_vindex.z))); + + /* compute normal */ + return normalize(cross(v2 - v0, v1 - v0)); +#else + float4 Nm = kernel_tex_fetch(__tri_normal, tri_index); + *shader = __float_as_int(Nm.w); + return make_float3(Nm.x, Nm.y, Nm.z); +#endif +} + +__device_inline float3 triangle_smooth_normal(KernelGlobals *kg, int tri_index, float u, float v) +{ + /* load triangle vertices */ + float3 tri_vindex = as_float3(kernel_tex_fetch(__tri_vindex, tri_index)); + + float3 n0 = as_float3(kernel_tex_fetch(__tri_vnormal, __float_as_int(tri_vindex.x))); + float3 n1 = as_float3(kernel_tex_fetch(__tri_vnormal, __float_as_int(tri_vindex.y))); + float3 n2 = as_float3(kernel_tex_fetch(__tri_vnormal, __float_as_int(tri_vindex.z))); + + return normalize((1.0f - u - v)*n2 + u*n0 + v*n1); +} + +__device_inline void triangle_dPdudv(KernelGlobals *kg, float3 *dPdu, float3 *dPdv, int tri) +{ + /* fetch triangle vertex coordinates */ + float3 tri_vindex = as_float3(kernel_tex_fetch(__tri_vindex, tri)); + + float3 p0 = as_float3(kernel_tex_fetch(__tri_verts, __float_as_int(tri_vindex.x))); + float3 p1 = as_float3(kernel_tex_fetch(__tri_verts, __float_as_int(tri_vindex.y))); + float3 p2 = as_float3(kernel_tex_fetch(__tri_verts, __float_as_int(tri_vindex.z))); + + /* compute derivatives of P w.r.t. uv */ + *dPdu = (p0 - p2); + *dPdv = (p1 - p2); +} + +/* attributes */ + +__device float triangle_attribute_float(KernelGlobals *kg, const ShaderData *sd, AttributeElement elem, int offset, float *dx, float *dy) +{ + if(elem == ATTR_ELEMENT_FACE) { + if(dx) *dx = 0.0f; + if(dy) *dy = 0.0f; + + return kernel_tex_fetch(__attributes_float, offset + sd->prim); + } + else if(elem == ATTR_ELEMENT_VERTEX) { + float3 tri_vindex = as_float3(kernel_tex_fetch(__tri_vindex, sd->prim)); + + float f0 = kernel_tex_fetch(__attributes_float, offset + __float_as_int(tri_vindex.x)); + float f1 = kernel_tex_fetch(__attributes_float, offset + __float_as_int(tri_vindex.y)); + float f2 = kernel_tex_fetch(__attributes_float, offset + __float_as_int(tri_vindex.z)); + +#ifdef __RAY_DIFFERENTIALS__ + if(dx) *dx = sd->du.dx*f0 + sd->dv.dx*f1 - (sd->du.dx + sd->dv.dx)*f2; + if(dy) *dy = sd->du.dy*f0 + sd->dv.dy*f1 - (sd->du.dy + sd->dv.dy)*f2; +#endif + + return sd->u*f0 + sd->v*f1 + (1.0f - sd->u - sd->v)*f2; + } + else if(elem == ATTR_ELEMENT_CORNER) { + int tri = offset + sd->prim; + float f0 = kernel_tex_fetch(__attributes_float, tri*3 + 0); + float f1 = kernel_tex_fetch(__attributes_float, tri*3 + 1); + float f2 = kernel_tex_fetch(__attributes_float, tri*3 + 2); + +#ifdef __RAY_DIFFERENTIALS__ + if(dx) *dx = sd->du.dx*f0 + sd->dv.dx*f1 - (sd->du.dx + sd->dv.dx)*f2; + if(dy) *dy = sd->du.dy*f0 + sd->dv.dy*f1 - (sd->du.dy + sd->dv.dy)*f2; +#endif + + return sd->u*f0 + sd->v*f1 + (1.0f - sd->u - sd->v)*f2; + } + else { + if(dx) *dx = 0.0f; + if(dy) *dy = 0.0f; + + return 0.0f; + } +} + +__device float3 triangle_attribute_float3(KernelGlobals *kg, const ShaderData *sd, AttributeElement elem, int offset, float3 *dx, float3 *dy) +{ + if(elem == ATTR_ELEMENT_FACE) { + if(dx) *dx = make_float3(0.0f, 0.0f, 0.0f); + if(dy) *dy = make_float3(0.0f, 0.0f, 0.0f); + + return as_float3(kernel_tex_fetch(__attributes_float3, offset + sd->prim)); + } + else if(elem == ATTR_ELEMENT_VERTEX) { + float3 tri_vindex = as_float3(kernel_tex_fetch(__tri_vindex, sd->prim)); + + float3 f0 = as_float3(kernel_tex_fetch(__attributes_float3, offset + __float_as_int(tri_vindex.x))); + float3 f1 = as_float3(kernel_tex_fetch(__attributes_float3, offset + __float_as_int(tri_vindex.y))); + float3 f2 = as_float3(kernel_tex_fetch(__attributes_float3, offset + __float_as_int(tri_vindex.z))); + +#ifdef __RAY_DIFFERENTIALS__ + if(dx) *dx = sd->du.dx*f0 + sd->dv.dx*f1 - (sd->du.dx + sd->dv.dx)*f2; + if(dy) *dy = sd->du.dy*f0 + sd->dv.dy*f1 - (sd->du.dy + sd->dv.dy)*f2; +#endif + + return sd->u*f0 + sd->v*f1 + (1.0f - sd->u - sd->v)*f2; + } + else if(elem == ATTR_ELEMENT_CORNER) { + int tri = offset + sd->prim; + float3 f0 = as_float3(kernel_tex_fetch(__attributes_float3, tri*3 + 0)); + float3 f1 = as_float3(kernel_tex_fetch(__attributes_float3, tri*3 + 1)); + float3 f2 = as_float3(kernel_tex_fetch(__attributes_float3, tri*3 + 2)); + +#ifdef __RAY_DIFFERENTIALS__ + if(dx) *dx = sd->du.dx*f0 + sd->dv.dx*f1 - (sd->du.dx + sd->dv.dx)*f2; + if(dy) *dy = sd->du.dy*f0 + sd->dv.dy*f1 - (sd->du.dy + sd->dv.dy)*f2; +#endif + + return sd->u*f0 + sd->v*f1 + (1.0f - sd->u - sd->v)*f2; + } + else { + if(dx) *dx = make_float3(0.0f, 0.0f, 0.0f); + if(dy) *dy = make_float3(0.0f, 0.0f, 0.0f); + + return make_float3(0.0f, 0.0f, 0.0f); + } +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/kernel_types.h b/intern/cycles/kernel/kernel_types.h new file mode 100644 index 00000000000..8e378d2871b --- /dev/null +++ b/intern/cycles/kernel/kernel_types.h @@ -0,0 +1,374 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __KERNEL_TYPES_H__ +#define __KERNEL_TYPES_H__ + +#include "kernel_math.h" + +#ifndef __KERNEL_OPENCL__ + +#include "svm_types.h" + +#endif + +CCL_NAMESPACE_BEGIN + +#define OBJECT_SIZE 16 + +#define __INSTANCING__ +#define __DPDU__ +#define __UV__ +#define __BACKGROUND__ +#define __EMISSION__ +#define __CAUSTICS_TRICKS__ +#define __SVM__ +#define __SOBOL__ +#define __TEXTURES__ +#define __RAY_DIFFERENTIALS__ +#define __CAMERA_CLIPPING__ +#define __INTERSECTION_REFINE__ +//#define __SOBOL_FULL_SCREEN__ +//#define __MODIFY_TP__ +//#define __QBVH__ + +/* Path Tracing */ + +enum PathTraceDimension { + PRNG_FILTER_U = 0, + PRNG_FILTER_V = 1, + PRNG_LENS_U = 2, + PRNG_LENS_V = 3, + PRNG_BASE_NUM = 4, + + PRNG_BSDF_U = 0, + PRNG_BSDF_V = 1, + PRNG_BSDF = 2, + PRNG_LIGHT = 3, + PRNG_LIGHT_U = 4, + PRNG_LIGHT_V = 5, + PRNG_LIGHT_F = 6, + PRNG_TERMINATE = 7, + PRNG_BOUNCE_NUM = 8 +}; + +/* these flag values correspond exactly to OSL defaults, so be careful not to + * change this, or if you do, set the "raytypes" shading system attribute with + * your own new ray types and bitflag values */ +enum PathRayFlag { + PATH_RAY_CAMERA = 1, + PATH_RAY_SHADOW = 2, + PATH_RAY_REFLECT = 4, + PATH_RAY_TRANSMIT = 8, + PATH_RAY_DIFFUSE = 16, + PATH_RAY_GLOSSY = 32, + PATH_RAY_SINGULAR = 64 +}; + +/* Bidirectional Path Tracing */ + +enum BidirTraceDimension { + BRNG_FILTER_U = 0, + BRNG_FILTER_V = 1, + BRNG_LENS_U = 2, + BRNG_LENS_V = 3, + BRNG_LIGHT_U = 4, + BRNG_LIGHT_V = 5, + BRNG_LIGHT = 6, + BRNG_LIGHT_F = 7, + BRNG_EMISSIVE_U = 8, + BRNG_EMISSIVE_V = 9, + BRNG_BASE_NUM = 10, + + BRNG_BSDF_U = 0, + BRNG_BSDF_V = 1, + BRNG_BSDF = 2, + BRNG_TERMINATE = 3, + BRNG_BOUNCE_NUM = 4 +}; + +/* Closure Label */ + +typedef enum ClosureLabel { + LABEL_NONE = 0, + LABEL_CAMERA = 1, + LABEL_LIGHT = 2, + LABEL_BACKGROUND = 4, + LABEL_TRANSMIT = 8, + LABEL_REFLECT = 16, + LABEL_VOLUME = 32, + LABEL_OBJECT = 64, + LABEL_DIFFUSE = 128, + LABEL_GLOSSY = 256, + LABEL_SINGULAR = 512, + LABEL_STRAIGHT = 1024, + LABEL_STOP = 2048 +} ClosureLabel; + +/* Ray Type */ + +typedef enum RayType { + RayTypeCamera = 1, + RayTypeShadow = 2, + RayTypeReflection = 4, + RayTypeRefraction = 8, + RayTypeDiffuse = 16, + RayTypeGlossy = 32 +} RayType; + +/* Differential */ + +typedef struct differential3 { + float3 dx; + float3 dy; +} differential3; + +typedef struct differential { + float dx; + float dy; +} differential; + +/* Ray */ + +typedef struct Ray { + float3 P; + float3 D; + float t; + +#ifdef __RAY_DIFFERENTIALS__ + differential3 dP; + differential3 dD; +#endif +} Ray; + +/* Intersection */ + +typedef struct Intersection { + float t, u, v; + int prim; + int object; +} Intersection; + +/* Attributes */ + +typedef enum AttributeElement { + ATTR_ELEMENT_FACE, + ATTR_ELEMENT_VERTEX, + ATTR_ELEMENT_CORNER, + ATTR_ELEMENT_VALUE, + ATTR_ELEMENT_NONE +} AttributeElement; + +/* OSL data */ + +#if !defined(__KERNEL_GPU__) && defined(WITH_OSL) + +#define MAX_OSL_CLOSURE 8 + +struct FlatClosure { + void *prim; + float3 weight; + float sample_weight; +}; + +#endif + +/* Shader Data + * + * Main shader state at a point on the surface or in a volume. All coordinates + * are in world space. */ + +enum ShaderDataFlag { + SD_BACKFACING = 1, /* backside of surface? */ + SD_EMISSION = 2, /* have emissive closure? */ + SD_BSDF_HAS_EVAL = 4, /* have non-singular bsdf closure? */ + SD_BSDF_GLOSSY = 8 /* have glossy bsdf */ +}; + +typedef struct ShaderData { + /* position */ + float3 P; + /* smooth normal for shading */ + float3 N; + /* true geometric normal */ + float3 Ng; + /* view/incoming direction */ + float3 I; + /* shader id */ + int shader; + /* booleans describing shader, see ShaderDataFlag */ + int flag; + + /* primitive id if there is one, ~0 otherwise */ + int prim; + /* parametric coordinates + * - barycentric weights for triangles + * - latlong coordinates for background */ + float u, v; + /* object id if there is one, ~0 otherwise */ + int object; + +#ifdef __RAY_DIFFERENTIALS__ + /* differential of P. these are orthogonal to Ng, not N */ + differential3 dP; + /* differential of I */ + differential3 dI; + /* differential of u, v */ + differential du; + differential dv; +#endif +#ifdef __DPDU__ + /* differential of P w.r.t. parametric coordinates. note that dPdu is + * not readily suitable as a tangent for shading on triangles. */ + float3 dPdu, dPdv; +#endif + + /* SVM closure data. we always sample a single closure, to get fixed + * memory usage, svm_closure_data contains closure parameters. */ +#ifndef __KERNEL_OPENCL__ + ClosureType svm_closure; +#endif + float3 svm_closure_weight; + float svm_closure_data[3]; /* CUDA gives compile error if out of bounds */ + +#if !defined(__KERNEL_GPU__) && defined(WITH_OSL) + /* OSL closure data and context. we store all closures flattened into + * lists per type, different from SVM. */ + struct { + FlatClosure bsdf[MAX_OSL_CLOSURE]; + FlatClosure emissive[MAX_OSL_CLOSURE]; + FlatClosure volume[MAX_OSL_CLOSURE]; + + int num_bsdf; + int num_emissive; + int num_volume; + + float bsdf_sample_sum; + float emissive_sample_sum; + float volume_sample_sum; + + float randb; + } osl_closure; + + void *osl_ctx; +#endif +} ShaderData; + +/* Constrant Kernel Data */ + +typedef struct KernelCamera { + /* type */ + int ortho; + int pad; + + /* size */ + int width, height; + + /* matrices */ + Transform cameratoworld; + Transform rastertocamera; + + /* depth of field */ + float lensradius; + float focaldistance; + + /* motion blur */ + float shutteropen; + float shutterclose; + + /* differentials */ + float3 dx, dy; + + /* clipping */ + float nearclip; + float cliplength; + + /* more matrices */ + Transform screentoworld; + Transform rastertoworld; + Transform ndctoworld; + Transform worldtoscreen; + Transform worldtoraster; + Transform worldtondc; + Transform worldtocamera; +} KernelCamera; + +typedef struct KernelFilm { + float exposure; + int use_response_curve; + int pad1, pad2; +} KernelFilm; + +typedef struct KernelBackground { + /* only shader index */ + int shader; + int pad1, pad2, pad3; +} KernelBackground; + +typedef struct KernelSunSky { + /* sun direction in spherical and cartesian */ + float theta, phi; + float3 dir; + float pad; + + /* perez function parameters */ + float zenith_Y, zenith_x, zenith_y; + float perez_Y[5], perez_x[5], perez_y[5]; +} KernelSunSky; + +typedef struct KernelIntegrator { + /* emission */ + int use_emission; + int num_triangles; + int num_distribution; + int num_lights; + float pdf_triangles; + float pdf_lights; + + /* path tracing */ + int minbounce; + int maxbounce; + + /* caustics */ + int no_caustics; + float blur_caustics; + + /* padding */ + int pad; +} KernelIntegrator; + +typedef struct KernelBVH { + /* root node */ + int root; + int attributes_map_stride; + int pad1, pad2; +} KernelBVH; + +typedef struct KernelData { + KernelCamera cam; + KernelFilm film; + KernelBackground background; + KernelSunSky sunsky; + KernelIntegrator integrator; + KernelBVH bvh; +} KernelData; + +CCL_NAMESPACE_END + +#endif /* __KERNEL_TYPES_H__ */ + diff --git a/intern/cycles/kernel/osl/CMakeLists.txt b/intern/cycles/kernel/osl/CMakeLists.txt new file mode 100644 index 00000000000..3ca3fa4cd6b --- /dev/null +++ b/intern/cycles/kernel/osl/CMakeLists.txt @@ -0,0 +1,33 @@ + +INCLUDE_DIRECTORIES(. ../ ../svm ../../render ../../util ../../device) + +SET(sources + background.cpp + bsdf_ashikhmin_velvet.cpp + bsdf_diffuse.cpp + bsdf_microfacet.cpp + bsdf_reflection.cpp + bsdf_refraction.cpp + bsdf_transparent.cpp + bsdf_ward.cpp + bsdf_westin.cpp + bssrdf.cpp + debug.cpp + emissive.cpp + osl_closures.cpp + osl_services.cpp + osl_shader.cpp + vol_subsurface.cpp) + +SET(headers + osl_closures.h + osl_globals.h + osl_services.h + osl_shader.h) + +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${RTTI_DISABLE_FLAGS}") + +ADD_LIBRARY(kernel_osl ${sources} ${headers}) + +ADD_SUBDIRECTORY(nodes) + diff --git a/intern/cycles/kernel/osl/background.cpp b/intern/cycles/kernel/osl/background.cpp new file mode 100644 index 00000000000..c35119ae9cf --- /dev/null +++ b/intern/cycles/kernel/osl/background.cpp @@ -0,0 +1,100 @@ +/* + * 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. + */ + +#include <OpenImageIO/fmath.h> + +#include <OSL/genclosure.h> + +#include "osl_closures.h" + +CCL_NAMESPACE_BEGIN + +using namespace OSL; + +/// Generic background closure +/// +/// We only have a background closure for the shaders +/// to return a color in background shaders. No methods, +/// only the weight is taking into account +/// +class GenericBackgroundClosure : public BackgroundClosure { +public: + GenericBackgroundClosure() { } + + void setup() {}; + + size_t memsize () const { return sizeof(*this); } + + const char *name () const { return "background"; } + + void print_on (std::ostream &out) const { + out << name() << " ()"; + } + +}; + + +/// Holdout closure +/// +/// This will be used by the shader to mark the +/// amount of holdout for the current shading +/// point. No parameters, only the weight will be +/// used +/// +class HoldoutClosure : ClosurePrimitive { +public: + HoldoutClosure () : ClosurePrimitive (Holdout) { } + + void setup() {}; + + size_t memsize () const { return sizeof(*this); } + + const char *name () const { return "holdout"; } + + void print_on (std::ostream &out) const { + out << name() << " ()"; + } +}; + +ClosureParam closure_background_params[] = { + CLOSURE_STRING_KEYPARAM("label"), + CLOSURE_FINISH_PARAM(GenericBackgroundClosure) }; + +CLOSURE_PREPARE(closure_background_prepare, GenericBackgroundClosure) + +ClosureParam closure_holdout_params[] = { + CLOSURE_FINISH_PARAM(HoldoutClosure) }; + +CLOSURE_PREPARE(closure_holdout_prepare, HoldoutClosure) + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/osl/bsdf_ashikhmin_velvet.cpp b/intern/cycles/kernel/osl/bsdf_ashikhmin_velvet.cpp new file mode 100644 index 00000000000..a38c5b55cf5 --- /dev/null +++ b/intern/cycles/kernel/osl/bsdf_ashikhmin_velvet.cpp @@ -0,0 +1,175 @@ +/* + * 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. + */ + +#include <OpenImageIO/fmath.h> + +#include <OSL/genclosure.h> + +#include "osl_closures.h" + +CCL_NAMESPACE_BEGIN + +using namespace OSL; + +class AshikhminVelvetClosure : public BSDFClosure { +public: + Vec3 m_N; + float m_sigma; + float m_invsigma2; + + AshikhminVelvetClosure() : BSDFClosure(Labels::DIFFUSE) { } + + void setup() + { + m_sigma = std::max(m_sigma, 0.01f); + m_invsigma2 = 1.0f/(m_sigma * m_sigma); + } + + bool mergeable (const ClosurePrimitive *other) const { + const AshikhminVelvetClosure *comp = (const AshikhminVelvetClosure *)other; + return m_N == comp->m_N && m_sigma == comp->m_sigma && + BSDFClosure::mergeable(other); + } + + size_t memsize () const { return sizeof(*this); } + + const char *name () const { return "ashikhmin_velvet"; } + + void print_on (std::ostream &out) const + { + out << name() << " ("; + out << "(" << m_N[0] << ", " << m_N[1] << ", " << m_N[2] << "), "; + out << m_sigma; + out << ")"; + } + + float albedo (const Vec3 &omega_out) const + { + return 1.0f; + } + + Color3 eval_reflect (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + float cosNO = m_N.dot(omega_out); + float cosNI = m_N.dot(omega_in); + if (cosNO > 0 && cosNI > 0) { + Vec3 H = omega_in + omega_out; + H.normalize(); + + float cosNH = m_N.dot(H); + float cosHO = fabsf(omega_out.dot(H)); + + float cosNHdivHO = cosNH / cosHO; + cosNHdivHO = std::max(cosNHdivHO, 0.00001f); + + float fac1 = 2 * fabsf(cosNHdivHO * cosNO); + float fac2 = 2 * fabsf(cosNHdivHO * cosNI); + + float sinNH2 = 1 - cosNH * cosNH; + float sinNH4 = sinNH2 * sinNH2; + float cotangent2 = (cosNH * cosNH) / sinNH2; + + float D = expf(-cotangent2 * m_invsigma2) * m_invsigma2 * float(M_1_PI) / sinNH4; + float G = std::min(1.0f, std::min(fac1, fac2)); // TODO: derive G from D analytically + + float out = 0.25f * (D * G) / cosNO; + + pdf = 0.5f * (float) M_1_PI; + return Color3 (out, out, out); + } + return Color3 (0, 0, 0); + } + + Color3 eval_transmit (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + return Color3 (0, 0, 0); + } + + ustring sample (const Vec3 &Ng, + const Vec3 &omega_out, const Vec3 &domega_out_dx, const Vec3 &domega_out_dy, + float randu, float randv, + Vec3 &omega_in, Vec3 &domega_in_dx, Vec3 &domega_in_dy, + float &pdf, Color3 &eval) const + { + // we are viewing the surface from above - send a ray out with uniform + // distribution over the hemisphere + sample_uniform_hemisphere (m_N, omega_out, randu, randv, omega_in, pdf); + if (Ng.dot(omega_in) > 0) { + Vec3 H = omega_in + omega_out; + H.normalize(); + + float cosNI = m_N.dot(omega_in); + float cosNO = m_N.dot(omega_out); + float cosNH = m_N.dot(H); + float cosHO = fabsf(omega_out.dot(H)); + + float cosNHdivHO = cosNH / cosHO; + cosNHdivHO = std::max(cosNHdivHO, 0.00001f); + + float fac1 = 2 * fabsf(cosNHdivHO * cosNO); + float fac2 = 2 * fabsf(cosNHdivHO * cosNI); + + float sinNH2 = 1 - cosNH * cosNH; + float sinNH4 = sinNH2 * sinNH2; + float cotangent2 = (cosNH * cosNH) / sinNH2; + + float D = expf(-cotangent2 * m_invsigma2) * m_invsigma2 * float(M_1_PI) / sinNH4; + float G = std::min(1.0f, std::min(fac1, fac2)); // TODO: derive G from D analytically + + float power = 0.25f * (D * G) / cosNO; + + eval.setValue(power, power, power); + + // TODO: find a better approximation for the retroreflective bounce + domega_in_dx = (2 * m_N.dot(domega_out_dx)) * m_N - domega_out_dx; + domega_in_dy = (2 * m_N.dot(domega_out_dy)) * m_N - domega_out_dy; + domega_in_dx *= 125; + domega_in_dy *= 125; + } else + pdf = 0; + return Labels::REFLECT; + } + +}; + + + +ClosureParam bsdf_ashikhmin_velvet_params[] = { + CLOSURE_VECTOR_PARAM(AshikhminVelvetClosure, m_N), + CLOSURE_FLOAT_PARAM (AshikhminVelvetClosure, m_sigma), + CLOSURE_STRING_KEYPARAM("label"), + CLOSURE_FINISH_PARAM(AshikhminVelvetClosure) }; + +CLOSURE_PREPARE(bsdf_ashikhmin_velvet_prepare, AshikhminVelvetClosure) + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/osl/bsdf_diffuse.cpp b/intern/cycles/kernel/osl/bsdf_diffuse.cpp new file mode 100644 index 00000000000..0d4b3fa471f --- /dev/null +++ b/intern/cycles/kernel/osl/bsdf_diffuse.cpp @@ -0,0 +1,181 @@ +/* + * 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. + */ + +#include <OpenImageIO/fmath.h> + +#include <OSL/genclosure.h> + +#include "osl_closures.h" + +CCL_NAMESPACE_BEGIN + +using namespace OSL; + +class DiffuseClosure : public BSDFClosure { +public: + Vec3 m_N; + + DiffuseClosure() : BSDFClosure(Labels::DIFFUSE) { } + + void setup() {}; + + bool mergeable (const ClosurePrimitive *other) const { + const DiffuseClosure *comp = (const DiffuseClosure *)other; + return m_N == comp->m_N && BSDFClosure::mergeable(other); + } + + size_t memsize () const { return sizeof(*this); } + + const char *name () const { return "diffuse"; } + + void print_on (std::ostream &out) const + { + out << name() << " ((" << m_N[0] << ", " << m_N[1] << ", " << m_N[2] << "))"; + } + + float albedo (const Vec3 &omega_out) const + { + return 1.0f; + } + + Color3 eval_reflect (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + float cos_pi = std::max(m_N.dot(omega_in),0.0f) * (float) M_1_PI; + pdf = cos_pi; + return Color3 (cos_pi, cos_pi, cos_pi); + } + + Color3 eval_transmit (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + return Color3 (0, 0, 0); + } + + ustring sample (const Vec3 &Ng, + const Vec3 &omega_out, const Vec3 &domega_out_dx, const Vec3 &domega_out_dy, + float randu, float randv, + Vec3 &omega_in, Vec3 &domega_in_dx, Vec3 &domega_in_dy, + float &pdf, Color3 &eval) const + { + // we are viewing the surface from the right side - send a ray out with cosine + // distribution over the hemisphere + sample_cos_hemisphere (m_N, omega_out, randu, randv, omega_in, pdf); + if (Ng.dot(omega_in) > 0) { + eval.setValue(pdf, pdf, pdf); + // TODO: find a better approximation for the diffuse bounce + domega_in_dx = (2 * m_N.dot(domega_out_dx)) * m_N - domega_out_dx; + domega_in_dy = (2 * m_N.dot(domega_out_dy)) * m_N - domega_out_dy; + domega_in_dx *= 125; + domega_in_dy *= 125; + } else + pdf = 0; + return Labels::REFLECT; + } +}; + + + +class TranslucentClosure : public BSDFClosure { +public: + Vec3 m_N; + + TranslucentClosure() : BSDFClosure(Labels::DIFFUSE, Back) { } + + void setup() {}; + + bool mergeable (const ClosurePrimitive *other) const { + const TranslucentClosure *comp = (const TranslucentClosure *)other; + return m_N == comp->m_N && BSDFClosure::mergeable(other); + } + + size_t memsize () const { return sizeof(*this); } + + const char *name () const { return "translucent"; } + + void print_on (std::ostream &out) const + { + out << name() << " ((" << m_N[0] << ", " << m_N[1] << ", " << m_N[2] << "))"; + } + + Color3 eval_reflect (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + return Color3 (0, 0, 0); + } + + float albedo (const Vec3 &omega_out) const + { + return 1.0f; + } + + Color3 eval_transmit (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + float cos_pi = std::max(-m_N.dot(omega_in), 0.0f) * (float) M_1_PI; + pdf = cos_pi; + return Color3 (cos_pi, cos_pi, cos_pi); + } + + ustring sample (const Vec3 &Ng, + const Vec3 &omega_out, const Vec3 &domega_out_dx, const Vec3 &domega_out_dy, + float randu, float randv, + Vec3 &omega_in, Vec3 &domega_in_dx, Vec3 &domega_in_dy, + float &pdf, Color3 &eval) const + { + // we are viewing the surface from the right side - send a ray out with cosine + // distribution over the hemisphere + sample_cos_hemisphere (-m_N, omega_out, randu, randv, omega_in, pdf); + if (Ng.dot(omega_in) < 0) { + eval.setValue(pdf, pdf, pdf); + // TODO: find a better approximation for the diffuse bounce + domega_in_dx = (2 * m_N.dot(domega_out_dx)) * m_N - domega_out_dx; + domega_in_dy = (2 * m_N.dot(domega_out_dy)) * m_N - domega_out_dy; + domega_in_dx *= -125; + domega_in_dy *= -125; + } else + pdf = 0; + return Labels::TRANSMIT; + } +}; + +ClosureParam bsdf_diffuse_params[] = { + CLOSURE_VECTOR_PARAM (DiffuseClosure, m_N), + CLOSURE_STRING_KEYPARAM("label"), + CLOSURE_FINISH_PARAM (DiffuseClosure) }; + +ClosureParam bsdf_translucent_params[] = { + CLOSURE_VECTOR_PARAM (TranslucentClosure, m_N), + CLOSURE_STRING_KEYPARAM("label"), + CLOSURE_FINISH_PARAM (TranslucentClosure) }; + +CLOSURE_PREPARE(bsdf_diffuse_prepare, DiffuseClosure) +CLOSURE_PREPARE(bsdf_translucent_prepare, TranslucentClosure) + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/osl/bsdf_microfacet.cpp b/intern/cycles/kernel/osl/bsdf_microfacet.cpp new file mode 100644 index 00000000000..d87268da81e --- /dev/null +++ b/intern/cycles/kernel/osl/bsdf_microfacet.cpp @@ -0,0 +1,533 @@ +/* + * 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. + */ + +#include <OpenImageIO/fmath.h> + +#include <OSL/genclosure.h> + +#include "osl_closures.h" + +#include "util_math.h" + +using namespace OSL; + +CCL_NAMESPACE_BEGIN + +// TODO: fresnel_dielectric is only used for derivatives, could be optimized + +// TODO: refactor these two classes so they share everything by the microfacet +// distribution terms + +// microfacet model with GGX facet distribution +// see http://www.graphics.cornell.edu/~bjw/microfacetbsdf.pdf +template <int Refractive = 0> +class MicrofacetGGXClosure : public BSDFClosure { +public: + Vec3 m_N; + float m_ag; // width parameter (roughness) + float m_eta; // index of refraction (for fresnel term) + MicrofacetGGXClosure() : BSDFClosure(Labels::GLOSSY, Refractive ? Back : Front) { m_eta = 1.0f; } + + void setup() + { + m_ag = clamp(m_ag, 1e-5f, 1.0f); + } + + bool mergeable (const ClosurePrimitive *other) const { + const MicrofacetGGXClosure *comp = (const MicrofacetGGXClosure *)other; + return m_N == comp->m_N && m_ag == comp->m_ag && + m_eta == comp->m_eta && BSDFClosure::mergeable(other); + } + + size_t memsize () const { return sizeof(*this); } + + const char *name () const { + return Refractive ? "microfacet_ggx_refraction" : "microfacet_ggx"; + } + + void print_on (std::ostream &out) const { + out << name() << " ("; + out << "(" << m_N[0] << ", " << m_N[1] << ", " << m_N[2] << "), "; + out << m_ag << ", "; + out << m_eta; + out << ")"; + } + + float albedo (const Vec3 &omega_out) const + { + return 1.0f; + } + + Color3 eval_reflect (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + if (Refractive == 1) return Color3 (0, 0, 0); + float cosNO = m_N.dot(omega_out); + float cosNI = m_N.dot(omega_in); + if (cosNI > 0 && cosNO > 0) { + // get half vector + Vec3 Hr = omega_in + omega_out; + Hr.normalize(); + // eq. 20: (F*G*D)/(4*in*on) + // eq. 33: first we calculate D(m) with m=Hr: + float alpha2 = m_ag * m_ag; + float cosThetaM = m_N.dot(Hr); + float cosThetaM2 = cosThetaM * cosThetaM; + float tanThetaM2 = (1 - cosThetaM2) / cosThetaM2; + float cosThetaM4 = cosThetaM2 * cosThetaM2; + float D = alpha2 / ((float) M_PI * cosThetaM4 * (alpha2 + tanThetaM2) * (alpha2 + tanThetaM2)); + // eq. 34: now calculate G1(i,m) and G1(o,m) + float G1o = 2 / (1 + sqrtf(1 + alpha2 * (1 - cosNO * cosNO) / (cosNO * cosNO))); + float G1i = 2 / (1 + sqrtf(1 + alpha2 * (1 - cosNI * cosNI) / (cosNI * cosNI))); + float G = G1o * G1i; + float out = (G * D) * 0.25f / cosNO; + // eq. 24 + float pm = D * cosThetaM; + // convert into pdf of the sampled direction + // eq. 38 - but see also: + // eq. 17 in http://www.graphics.cornell.edu/~bjw/wardnotes.pdf + pdf = pm * 0.25f / Hr.dot(omega_out); + return Color3 (out, out, out); + } + return Color3 (0, 0, 0); + } + + Color3 eval_transmit (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + if (Refractive == 0) return Color3 (0, 0, 0); + float cosNO = m_N.dot(omega_out); + float cosNI = m_N.dot(omega_in); + if (cosNO <= 0 || cosNI >= 0) + return Color3 (0, 0, 0); // vectors on same side -- not possible + // compute half-vector of the refraction (eq. 16) + Vec3 ht = -(m_eta * omega_in + omega_out); + Vec3 Ht = ht; Ht.normalize(); + float cosHO = Ht.dot(omega_out); + + float cosHI = Ht.dot(omega_in); + // eq. 33: first we calculate D(m) with m=Ht: + float alpha2 = m_ag * m_ag; + float cosThetaM = m_N.dot(Ht); + float cosThetaM2 = cosThetaM * cosThetaM; + float tanThetaM2 = (1 - cosThetaM2) / cosThetaM2; + float cosThetaM4 = cosThetaM2 * cosThetaM2; + float D = alpha2 / ((float) M_PI * cosThetaM4 * (alpha2 + tanThetaM2) * (alpha2 + tanThetaM2)); + // eq. 34: now calculate G1(i,m) and G1(o,m) + float G1o = 2 / (1 + sqrtf(1 + alpha2 * (1 - cosNO * cosNO) / (cosNO * cosNO))); + float G1i = 2 / (1 + sqrtf(1 + alpha2 * (1 - cosNI * cosNI) / (cosNI * cosNI))); + float G = G1o * G1i; + // probability + float invHt2 = 1 / ht.dot(ht); + pdf = D * fabsf(cosThetaM) * (fabsf(cosHI) * (m_eta * m_eta)) * invHt2; + float out = (fabsf(cosHI * cosHO) * (m_eta * m_eta) * (G * D) * invHt2) / cosNO; + return Color3 (out, out, out); + } + + ustring sample (const Vec3 &Ng, + const Vec3 &omega_out, const Vec3 &domega_out_dx, const Vec3 &domega_out_dy, + float randu, float randv, + Vec3 &omega_in, Vec3 &domega_in_dx, Vec3 &domega_in_dy, + float &pdf, Color3 &eval) const + { + float cosNO = m_N.dot(omega_out); + if (cosNO > 0) { + Vec3 X, Y, Z = m_N; + make_orthonormals(Z, X, Y); + // generate a random microfacet normal m + // eq. 35,36: + // we take advantage of cos(atan(x)) == 1/sqrt(1+x^2) + // and sin(atan(x)) == x/sqrt(1+x^2) + float alpha2 = m_ag * m_ag; + float tanThetaM2 = alpha2 * randu / (1 - randu); + float cosThetaM = 1 / sqrtf(1 + tanThetaM2); + float sinThetaM = cosThetaM * sqrtf(tanThetaM2); + float phiM = 2 * float(M_PI) * randv; + Vec3 m = (cosf(phiM) * sinThetaM) * X + + (sinf(phiM) * sinThetaM) * Y + + cosThetaM * Z; + if (Refractive == 0) { + float cosMO = m.dot(omega_out); + if (cosMO > 0) { + // eq. 39 - compute actual reflected direction + omega_in = 2 * cosMO * m - omega_out; + if (Ng.dot(omega_in) > 0) { + // microfacet normal is visible to this ray + // eq. 33 + float cosThetaM2 = cosThetaM * cosThetaM; + float cosThetaM4 = cosThetaM2 * cosThetaM2; + float D = alpha2 / (float(M_PI) * cosThetaM4 * (alpha2 + tanThetaM2) * (alpha2 + tanThetaM2)); + // eq. 24 + float pm = D * cosThetaM; + // convert into pdf of the sampled direction + // eq. 38 - but see also: + // eq. 17 in http://www.graphics.cornell.edu/~bjw/wardnotes.pdf + pdf = pm * 0.25f / cosMO; + // eval BRDF*cosNI + float cosNI = m_N.dot(omega_in); + // eq. 34: now calculate G1(i,m) and G1(o,m) + float G1o = 2 / (1 + sqrtf(1 + alpha2 * (1 - cosNO * cosNO) / (cosNO * cosNO))); + float G1i = 2 / (1 + sqrtf(1 + alpha2 * (1 - cosNI * cosNI) / (cosNI * cosNI))); + float G = G1o * G1i; + // eq. 20: (F*G*D)/(4*in*on) + float out = (G * D) * 0.25f / cosNO; + eval.setValue(out, out, out); + domega_in_dx = (2 * m.dot(domega_out_dx)) * m - domega_out_dx; + domega_in_dy = (2 * m.dot(domega_out_dy)) * m - domega_out_dy; + + /* disabled for now - gives texture filtering problems */ +#if 0 + // Since there is some blur to this reflection, make the + // derivatives a bit bigger. In theory this varies with the + // roughness but the exact relationship is complex and + // requires more ops than are practical. + domega_in_dx *= 10; + domega_in_dy *= 10; +#endif + } + } + } else { + // CAUTION: the i and o variables are inverted relative to the paper + // eq. 39 - compute actual refractive direction + Vec3 R, dRdx, dRdy; + Vec3 T, dTdx, dTdy; + bool inside; + fresnel_dielectric(m_eta, m, omega_out, domega_out_dx, domega_out_dy, + R, dRdx, dRdy, + T, dTdx, dTdy, + inside); + + if (!inside) { + omega_in = T; + domega_in_dx = dTdx; + domega_in_dy = dTdy; + // eq. 33 + float cosThetaM2 = cosThetaM * cosThetaM; + float cosThetaM4 = cosThetaM2 * cosThetaM2; + float D = alpha2 / (float(M_PI) * cosThetaM4 * (alpha2 + tanThetaM2) * (alpha2 + tanThetaM2)); + // eq. 24 + float pm = D * cosThetaM; + // eval BRDF*cosNI + float cosNI = m_N.dot(omega_in); + // eq. 34: now calculate G1(i,m) and G1(o,m) + float G1o = 2 / (1 + sqrtf(1 + alpha2 * (1 - cosNO * cosNO) / (cosNO * cosNO))); + float G1i = 2 / (1 + sqrtf(1 + alpha2 * (1 - cosNI * cosNI) / (cosNI * cosNI))); + float G = G1o * G1i; + // eq. 21 + float cosHI = m.dot(omega_in); + float cosHO = m.dot(omega_out); + float Ht2 = m_eta * cosHI + cosHO; + Ht2 *= Ht2; + float out = (fabsf(cosHI * cosHO) * (m_eta * m_eta) * (G * D)) / (cosNO * Ht2); + // eq. 38 and eq. 17 + pdf = pm * (m_eta * m_eta) * fabsf(cosHI) / Ht2; + eval.setValue(out, out, out); + + /* disabled for now - gives texture filtering problems */ +#if 0 + // Since there is some blur to this refraction, make the + // derivatives a bit bigger. In theory this varies with the + // roughness but the exact relationship is complex and + // requires more ops than are practical. + domega_in_dx *= 10; + domega_in_dy *= 10; +#endif + } + } + } + return Refractive ? Labels::TRANSMIT : Labels::REFLECT; + } +}; + +// microfacet model with Beckmann facet distribution +// see http://www.graphics.cornell.edu/~bjw/microfacetbsdf.pdf +template <int Refractive = 0> +class MicrofacetBeckmannClosure : public BSDFClosure { +public: + Vec3 m_N; + float m_ab; // width parameter (roughness) + float m_eta; // index of refraction (for fresnel term) + MicrofacetBeckmannClosure() : BSDFClosure(Labels::GLOSSY, Refractive ? Back : Front) { } + + void setup() + { + m_ab = clamp(m_ab, 1e-5f, 1.0f); + } + + bool mergeable (const ClosurePrimitive *other) const { + const MicrofacetBeckmannClosure *comp = (const MicrofacetBeckmannClosure *)other; + return m_N == comp->m_N && m_ab == comp->m_ab && + m_eta == comp->m_eta && BSDFClosure::mergeable(other); + } + + size_t memsize () const { return sizeof(*this); } + + const char * name () const { + return Refractive ? "microfacet_beckmann_refraction" + : "microfacet_beckmann"; + } + + void print_on (std::ostream &out) const + { + out << name() << " ("; + out << "(" << m_N[0] << ", " << m_N[1] << ", " << m_N[2] << "), "; + out << m_ab << ", "; + out << m_eta; + out << ")"; + } + + float albedo (const Vec3 &omega_out) const + { + return 1.0f; + } + + Color3 eval_reflect (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + if (Refractive == 1) return Color3 (0, 0, 0); + float cosNO = m_N.dot(omega_out); + float cosNI = m_N.dot(omega_in); + if (cosNO > 0 && cosNI > 0) { + // get half vector + Vec3 Hr = omega_in + omega_out; + Hr.normalize(); + // eq. 20: (F*G*D)/(4*in*on) + // eq. 25: first we calculate D(m) with m=Hr: + float alpha2 = m_ab * m_ab; + float cosThetaM = m_N.dot(Hr); + float cosThetaM2 = cosThetaM * cosThetaM; + float tanThetaM2 = (1 - cosThetaM2) / cosThetaM2; + float cosThetaM4 = cosThetaM2 * cosThetaM2; + float D = expf(-tanThetaM2 / alpha2) / (float(M_PI) * alpha2 * cosThetaM4); + // eq. 26, 27: now calculate G1(i,m) and G1(o,m) + float ao = 1 / (m_ab * sqrtf((1 - cosNO * cosNO) / (cosNO * cosNO))); + float ai = 1 / (m_ab * sqrtf((1 - cosNI * cosNI) / (cosNI * cosNI))); + float G1o = ao < 1.6f ? (3.535f * ao + 2.181f * ao * ao) / (1 + 2.276f * ao + 2.577f * ao * ao) : 1.0f; + float G1i = ai < 1.6f ? (3.535f * ai + 2.181f * ai * ai) / (1 + 2.276f * ai + 2.577f * ai * ai) : 1.0f; + float G = G1o * G1i; + float out = (G * D) * 0.25f / cosNO; + // eq. 24 + float pm = D * cosThetaM; + // convert into pdf of the sampled direction + // eq. 38 - but see also: + // eq. 17 in http://www.graphics.cornell.edu/~bjw/wardnotes.pdf + pdf = pm * 0.25f / Hr.dot(omega_out); + return Color3 (out, out, out); + } + return Color3 (0, 0, 0); + } + + Color3 eval_transmit (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + if (Refractive == 0) return Color3 (0, 0, 0); + float cosNO = m_N.dot(omega_out); + float cosNI = m_N.dot(omega_in); + if (cosNO <= 0 || cosNI >= 0) + return Color3 (0, 0, 0); + // compute half-vector of the refraction (eq. 16) + Vec3 ht = -(m_eta * omega_in + omega_out); + Vec3 Ht = ht; Ht.normalize(); + float cosHO = Ht.dot(omega_out); + + float cosHI = Ht.dot(omega_in); + // eq. 33: first we calculate D(m) with m=Ht: + float alpha2 = m_ab * m_ab; + float cosThetaM = m_N.dot(Ht); + float cosThetaM2 = cosThetaM * cosThetaM; + float tanThetaM2 = (1 - cosThetaM2) / cosThetaM2; + float cosThetaM4 = cosThetaM2 * cosThetaM2; + float D = expf(-tanThetaM2 / alpha2) / (float(M_PI) * alpha2 * cosThetaM4); + // eq. 26, 27: now calculate G1(i,m) and G1(o,m) + float ao = 1 / (m_ab * sqrtf((1 - cosNO * cosNO) / (cosNO * cosNO))); + float ai = 1 / (m_ab * sqrtf((1 - cosNI * cosNI) / (cosNI * cosNI))); + float G1o = ao < 1.6f ? (3.535f * ao + 2.181f * ao * ao) / (1 + 2.276f * ao + 2.577f * ao * ao) : 1.0f; + float G1i = ai < 1.6f ? (3.535f * ai + 2.181f * ai * ai) / (1 + 2.276f * ai + 2.577f * ai * ai) : 1.0f; + float G = G1o * G1i; + // probability + float invHt2 = 1 / ht.dot(ht); + pdf = D * fabsf(cosThetaM) * (fabsf(cosHI) * (m_eta * m_eta)) * invHt2; + float out = (fabsf(cosHI * cosHO) * (m_eta * m_eta) * (G * D) * invHt2) / cosNO; + return Color3 (out, out, out); + } + + ustring sample (const Vec3 &Ng, + const Vec3 &omega_out, const Vec3 &domega_out_dx, const Vec3 &domega_out_dy, + float randu, float randv, + Vec3 &omega_in, Vec3 &domega_in_dx, Vec3 &domega_in_dy, + float &pdf, Color3 &eval) const + { + float cosNO = m_N.dot(omega_out); + if (cosNO > 0) { + Vec3 X, Y, Z = m_N; + make_orthonormals(Z, X, Y); + // generate a random microfacet normal m + // eq. 35,36: + // we take advantage of cos(atan(x)) == 1/sqrt(1+x^2) + // and sin(atan(x)) == x/sqrt(1+x^2) + float alpha2 = m_ab * m_ab; + float tanThetaM = sqrtf(-alpha2 * logf(1 - randu)); + float cosThetaM = 1 / sqrtf(1 + tanThetaM * tanThetaM); + float sinThetaM = cosThetaM * tanThetaM; + float phiM = 2 * float(M_PI) * randv; + Vec3 m = (cosf(phiM) * sinThetaM) * X + + (sinf(phiM) * sinThetaM) * Y + + cosThetaM * Z; + if (Refractive == 0) { + float cosMO = m.dot(omega_out); + if (cosMO > 0) { + // eq. 39 - compute actual reflected direction + omega_in = 2 * cosMO * m - omega_out; + if (Ng.dot(omega_in) > 0) { + // microfacet normal is visible to this ray + // eq. 25 + float cosThetaM2 = cosThetaM * cosThetaM; + float tanThetaM2 = tanThetaM * tanThetaM; + float cosThetaM4 = cosThetaM2 * cosThetaM2; + float D = expf(-tanThetaM2 / alpha2) / (float(M_PI) * alpha2 * cosThetaM4); + // eq. 24 + float pm = D * cosThetaM; + // convert into pdf of the sampled direction + // eq. 38 - but see also: + // eq. 17 in http://www.graphics.cornell.edu/~bjw/wardnotes.pdf + pdf = pm * 0.25f / cosMO; + // Eval BRDF*cosNI + float cosNI = m_N.dot(omega_in); + // eq. 26, 27: now calculate G1(i,m) and G1(o,m) + float ao = 1 / (m_ab * sqrtf((1 - cosNO * cosNO) / (cosNO * cosNO))); + float ai = 1 / (m_ab * sqrtf((1 - cosNI * cosNI) / (cosNI * cosNI))); + float G1o = ao < 1.6f ? (3.535f * ao + 2.181f * ao * ao) / (1 + 2.276f * ao + 2.577f * ao * ao) : 1.0f; + float G1i = ai < 1.6f ? (3.535f * ai + 2.181f * ai * ai) / (1 + 2.276f * ai + 2.577f * ai * ai) : 1.0f; + float G = G1o * G1i; + // eq. 20: (F*G*D)/(4*in*on) + float out = (G * D) * 0.25f / cosNO; + eval.setValue(out, out, out); + domega_in_dx = (2 * m.dot(domega_out_dx)) * m - domega_out_dx; + domega_in_dy = (2 * m.dot(domega_out_dy)) * m - domega_out_dy; + + /* disabled for now - gives texture filtering problems */ +#if 0 + // Since there is some blur to this reflection, make the + // derivatives a bit bigger. In theory this varies with the + // roughness but the exact relationship is complex and + // requires more ops than are practical. + domega_in_dx *= 10; + domega_in_dy *= 10; +#endif + } + } + } else { + // CAUTION: the i and o variables are inverted relative to the paper + // eq. 39 - compute actual refractive direction + Vec3 R, dRdx, dRdy; + Vec3 T, dTdx, dTdy; + bool inside; + fresnel_dielectric(m_eta, m, omega_out, domega_out_dx, domega_out_dy, + R, dRdx, dRdy, + T, dTdx, dTdy, + inside); + if (!inside) { + omega_in = T; + domega_in_dx = dTdx; + domega_in_dy = dTdy; + // eq. 33 + float cosThetaM2 = cosThetaM * cosThetaM; + float tanThetaM2 = tanThetaM * tanThetaM; + float cosThetaM4 = cosThetaM2 * cosThetaM2; + float D = expf(-tanThetaM2 / alpha2) / (float(M_PI) * alpha2 * cosThetaM4); + // eq. 24 + float pm = D * cosThetaM; + // eval BRDF*cosNI + float cosNI = m_N.dot(omega_in); + // eq. 26, 27: now calculate G1(i,m) and G1(o,m) + float ao = 1 / (m_ab * sqrtf((1 - cosNO * cosNO) / (cosNO * cosNO))); + float ai = 1 / (m_ab * sqrtf((1 - cosNI * cosNI) / (cosNI * cosNI))); + float G1o = ao < 1.6f ? (3.535f * ao + 2.181f * ao * ao) / (1 + 2.276f * ao + 2.577f * ao * ao) : 1.0f; + float G1i = ai < 1.6f ? (3.535f * ai + 2.181f * ai * ai) / (1 + 2.276f * ai + 2.577f * ai * ai) : 1.0f; + float G = G1o * G1i; + // eq. 21 + float cosHI = m.dot(omega_in); + float cosHO = m.dot(omega_out); + float Ht2 = m_eta * cosHI + cosHO; + Ht2 *= Ht2; + float out = (fabsf(cosHI * cosHO) * (m_eta * m_eta) * (G * D)) / (cosNO * Ht2); + // eq. 38 and eq. 17 + pdf = pm * (m_eta * m_eta) * fabsf(cosHI) / Ht2; + eval.setValue(out, out, out); + + /* disabled for now - gives texture filtering problems */ +#if 0 + // Since there is some blur to this refraction, make the + // derivatives a bit bigger. In theory this varies with the + // roughness but the exact relationship is complex and + // requires more ops than are practical. + domega_in_dx *= 10; + domega_in_dy *= 10; +#endif + } + } + } + return Refractive ? Labels::TRANSMIT : Labels::REFLECT; + } +}; + + + +ClosureParam bsdf_microfacet_ggx_params[] = { + CLOSURE_VECTOR_PARAM(MicrofacetGGXClosure<0>, m_N), + CLOSURE_FLOAT_PARAM (MicrofacetGGXClosure<0>, m_ag), + CLOSURE_STRING_KEYPARAM("label"), + CLOSURE_FINISH_PARAM(MicrofacetGGXClosure<0>) }; + +ClosureParam bsdf_microfacet_ggx_refraction_params[] = { + CLOSURE_VECTOR_PARAM(MicrofacetGGXClosure<1>, m_N), + CLOSURE_FLOAT_PARAM (MicrofacetGGXClosure<1>, m_ag), + CLOSURE_FLOAT_PARAM (MicrofacetGGXClosure<1>, m_eta), + CLOSURE_STRING_KEYPARAM("label"), + CLOSURE_FINISH_PARAM(MicrofacetGGXClosure<1>) }; + +ClosureParam bsdf_microfacet_beckmann_params[] = { + CLOSURE_VECTOR_PARAM(MicrofacetBeckmannClosure<0>, m_N), + CLOSURE_FLOAT_PARAM (MicrofacetBeckmannClosure<0>, m_ab), + CLOSURE_STRING_KEYPARAM("label"), + CLOSURE_FINISH_PARAM(MicrofacetBeckmannClosure<0>) }; + +ClosureParam bsdf_microfacet_beckmann_refraction_params[] = { + CLOSURE_VECTOR_PARAM(MicrofacetBeckmannClosure<1>, m_N), + CLOSURE_FLOAT_PARAM (MicrofacetBeckmannClosure<1>, m_ab), + CLOSURE_FLOAT_PARAM (MicrofacetBeckmannClosure<1>, m_eta), + CLOSURE_STRING_KEYPARAM("label"), + CLOSURE_FINISH_PARAM(MicrofacetBeckmannClosure<1>) }; + +CLOSURE_PREPARE(bsdf_microfacet_ggx_prepare, MicrofacetGGXClosure<0>) +CLOSURE_PREPARE(bsdf_microfacet_ggx_refraction_prepare, MicrofacetGGXClosure<1>) +CLOSURE_PREPARE(bsdf_microfacet_beckmann_prepare, MicrofacetBeckmannClosure<0>) +CLOSURE_PREPARE(bsdf_microfacet_beckmann_refraction_prepare, MicrofacetBeckmannClosure<1>) + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/osl/bsdf_reflection.cpp b/intern/cycles/kernel/osl/bsdf_reflection.cpp new file mode 100644 index 00000000000..b0caff6df44 --- /dev/null +++ b/intern/cycles/kernel/osl/bsdf_reflection.cpp @@ -0,0 +1,108 @@ +/* + * 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. + */ + +#include <OpenImageIO/fmath.h> + +#include <OSL/genclosure.h> + +#include "osl_closures.h" + +CCL_NAMESPACE_BEGIN + +using namespace OSL; + +class ReflectionClosure : public BSDFClosure { +public: + Vec3 m_N; // shading normal + ReflectionClosure() : BSDFClosure(Labels::SINGULAR) { } + + void setup() {}; + + bool mergeable (const ClosurePrimitive *other) const { + const ReflectionClosure *comp = (const ReflectionClosure *)other; + return m_N == comp->m_N && BSDFClosure::mergeable(other); + } + + size_t memsize () const { return sizeof(*this); } + + const char *name () const { return "reflection"; } + + void print_on (std::ostream &out) const { + out << name() << " ("; + out << "(" << m_N[0] << ", " << m_N[1] << ", " << m_N[2] << "))"; + } + + float albedo (const Vec3 &omega_out) const + { + return 1.0f; + } + + Color3 eval_reflect (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + return Color3 (0, 0, 0); + } + + Color3 eval_transmit (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + return Color3 (0, 0, 0); + } + + ustring sample (const Vec3 &Ng, + const Vec3 &omega_out, const Vec3 &domega_out_dx, const Vec3 &domega_out_dy, + float randu, float randv, + Vec3 &omega_in, Vec3 &domega_in_dx, Vec3 &domega_in_dy, + float &pdf, Color3 &eval) const + { + // only one direction is possible + float cosNO = m_N.dot(omega_out); + if (cosNO > 0) { + omega_in = (2 * cosNO) * m_N - omega_out; + if (Ng.dot(omega_in) > 0) { + domega_in_dx = 2 * m_N.dot(domega_out_dx) * m_N - domega_out_dx; + domega_in_dy = 2 * m_N.dot(domega_out_dy) * m_N - domega_out_dy; + pdf = 1; + eval.setValue(1, 1, 1); + } + } + return Labels::REFLECT; + } +}; + +ClosureParam bsdf_reflection_params[] = { + CLOSURE_VECTOR_PARAM(ReflectionClosure, m_N), + CLOSURE_STRING_KEYPARAM("label"), + CLOSURE_FINISH_PARAM(ReflectionClosure) }; + +CLOSURE_PREPARE(bsdf_reflection_prepare, ReflectionClosure) + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/osl/bsdf_refraction.cpp b/intern/cycles/kernel/osl/bsdf_refraction.cpp new file mode 100644 index 00000000000..3ae7a3811b4 --- /dev/null +++ b/intern/cycles/kernel/osl/bsdf_refraction.cpp @@ -0,0 +1,120 @@ +/* + * 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. + */ + +#include <OpenImageIO/fmath.h> + +#include <OSL/genclosure.h> + +#include "osl_closures.h" + +CCL_NAMESPACE_BEGIN + +using namespace OSL; + +class RefractionClosure : public BSDFClosure { +public: + Vec3 m_N; // shading normal + float m_eta; // ratio of indices of refraction (inside / outside) + RefractionClosure() : BSDFClosure(Labels::SINGULAR, Back) { } + + void setup() {} + + bool mergeable (const ClosurePrimitive *other) const { + const RefractionClosure *comp = (const RefractionClosure *)other; + return m_N == comp->m_N && m_eta == comp->m_eta && + BSDFClosure::mergeable(other); + } + + size_t memsize () const { return sizeof(*this); } + + const char *name () const { return "refraction"; } + + void print_on (std::ostream &out) const { + out << name() << " ("; + out << "(" << m_N[0] << ", " << m_N[1] << ", " << m_N[2] << "), "; + out << m_eta; + out << ")"; + } + + Color3 eval_reflect (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + return Color3 (0, 0, 0); + } + + Color3 eval_transmit (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + return Color3 (0, 0, 0); + } + + float albedo (const Vec3 &omega_out) const + { + return 1.0f; + } + + ustring sample (const Vec3 &Ng, + const Vec3 &omega_out, const Vec3 &domega_out_dx, const Vec3 &domega_out_dy, + float randu, float randv, + Vec3 &omega_in, Vec3 &domega_in_dx, Vec3 &domega_in_dy, + float &pdf, Color3 &eval) const + { + Vec3 R, dRdx, dRdy; + Vec3 T, dTdx, dTdy; + bool inside; + + fresnel_dielectric(m_eta, m_N, + omega_out, domega_out_dx, domega_out_dy, + R, dRdx, dRdy, + T, dTdx, dTdy, + inside); + + if (!inside) { + pdf = 1; + eval.setValue(1.0f, 1.0f, 1.0f); + omega_in = T; + domega_in_dx = dTdx; + domega_in_dy = dTdy; + } + + return Labels::TRANSMIT; + } +}; + +ClosureParam bsdf_refraction_params[] = { + CLOSURE_VECTOR_PARAM(RefractionClosure, m_N), + CLOSURE_FLOAT_PARAM (RefractionClosure, m_eta), + CLOSURE_STRING_KEYPARAM("label"), + CLOSURE_FINISH_PARAM(RefractionClosure) }; + +CLOSURE_PREPARE(bsdf_refraction_prepare, RefractionClosure) + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/osl/bsdf_transparent.cpp b/intern/cycles/kernel/osl/bsdf_transparent.cpp new file mode 100644 index 00000000000..941abd6a483 --- /dev/null +++ b/intern/cycles/kernel/osl/bsdf_transparent.cpp @@ -0,0 +1,97 @@ +/* + * 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. + */ + +#include <OpenImageIO/fmath.h> + +#include <OSL/genclosure.h> + +#include "osl_closures.h" + +CCL_NAMESPACE_BEGIN + +using namespace OSL; + +class TransparentClosure : public BSDFClosure { +public: + TransparentClosure() : BSDFClosure(Labels::STRAIGHT, Back) { } + + void setup() {} + + size_t memsize () const { return sizeof(*this); } + + const char *name () const { return "transparent"; } + + void print_on (std::ostream &out) const { + out << name() << " ()"; + } + + float albedo (const Vec3 &omega_out) const + { + return 1.0f; + } + + Color3 eval_reflect (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + return Color3 (0, 0, 0); + } + + Color3 eval_transmit (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + return Color3 (0, 0, 0); + } + + ustring sample (const Vec3 &Ng, + const Vec3 &omega_out, const Vec3 &domega_out_dx, const Vec3 &domega_out_dy, + float randu, float randv, + Vec3 &omega_in, Vec3 &domega_in_dx, Vec3 &domega_in_dy, + float &pdf, Color3 &eval) const + { + // only one direction is possible + omega_in = -omega_out; + domega_in_dx = -domega_out_dx; + domega_in_dy = -domega_out_dy; + pdf = 1; + eval.setValue(1, 1, 1); + return Labels::TRANSMIT; + } +}; + + + +ClosureParam bsdf_transparent_params[] = { + CLOSURE_STRING_KEYPARAM("label"), + CLOSURE_FINISH_PARAM(TransparentClosure) }; + +CLOSURE_PREPARE(bsdf_transparent_prepare, TransparentClosure) + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/osl/bsdf_ward.cpp b/intern/cycles/kernel/osl/bsdf_ward.cpp new file mode 100644 index 00000000000..a7742a04d13 --- /dev/null +++ b/intern/cycles/kernel/osl/bsdf_ward.cpp @@ -0,0 +1,222 @@ +/* + * 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. + */ + +#include <OpenImageIO/fmath.h> + +#include <OSL/genclosure.h> + +#include "osl_closures.h" + +#include "util_math.h" + +CCL_NAMESPACE_BEGIN + +using namespace OSL; + +// anisotropic ward - leaks energy at grazing angles +// see http://www.graphics.cornell.edu/~bjw/wardnotes.pdf +class WardClosure : public BSDFClosure { +public: + Vec3 m_N; + Vec3 m_T; + float m_ax, m_ay; + WardClosure() : BSDFClosure(Labels::GLOSSY) { } + + void setup() + { + m_ax = clamp(m_ax, 1e-5f, 1.0f); + m_ay = clamp(m_ay, 1e-5f, 1.0f); + } + + bool mergeable (const ClosurePrimitive *other) const { + const WardClosure *comp = (const WardClosure *)other; + return m_N == comp->m_N && m_T == comp->m_T && + m_ax == comp->m_ax && m_ay == comp->m_ay && + BSDFClosure::mergeable(other); + } + + size_t memsize () const { return sizeof(*this); } + + const char *name () const { return "ward"; } + + void print_on (std::ostream &out) const { + out << name() << " (("; + out << m_N[0] << ", " << m_N[1] << ", " << m_N[2] << "), ("; + out << m_T[0] << ", " << m_T[1] << ", " << m_T[2] << "), "; + out << m_ax << ", " << m_ay << ")"; + } + + float albedo (const Vec3 &omega_out) const + { + return 1.0f; + } + + Color3 eval_reflect (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + float cosNO = m_N.dot(omega_out); + float cosNI = m_N.dot(omega_in); + if (cosNI > 0 && cosNO > 0) { + // get half vector and get x,y basis on the surface for anisotropy + Vec3 H = omega_in + omega_out; + H.normalize(); // normalize needed for pdf + Vec3 X, Y; + make_orthonormals(m_N, m_T, X, Y); + // eq. 4 + float dotx = H.dot(X) / m_ax; + float doty = H.dot(Y) / m_ay; + float dotn = H.dot(m_N); + float exp_arg = (dotx * dotx + doty * doty) / (dotn * dotn); + float denom = (4 * (float) M_PI * m_ax * m_ay * sqrtf(cosNO * cosNI)); + float exp_val = expf(-exp_arg); + float out = cosNI * exp_val / denom; + float oh = H.dot(omega_out); + denom = 4 * (float) M_PI * m_ax * m_ay * oh * dotn * dotn * dotn; + pdf = exp_val / denom; + return Color3 (out, out, out); + } + return Color3 (0, 0, 0); + } + + Color3 eval_transmit (const Vec3 &omega_out, const Vec3 &omega_in, float& pdf) const + { + return Color3 (0, 0, 0); + } + + ustring sample (const Vec3 &Ng, + const Vec3 &omega_out, const Vec3 &domega_out_dx, const Vec3 &domega_out_dy, + float randu, float randv, + Vec3 &omega_in, Vec3 &domega_in_dx, Vec3 &domega_in_dy, + float &pdf, Color3 &eval) const + { + float cosNO = m_N.dot(omega_out); + if (cosNO > 0) { + // get x,y basis on the surface for anisotropy + Vec3 X, Y; + make_orthonormals(m_N, m_T, X, Y); + // generate random angles for the half vector + // eq. 7 (taking care around discontinuities to keep + // output angle in the right quadrant) + // we take advantage of cos(atan(x)) == 1/sqrt(1+x^2) + // and sin(atan(x)) == x/sqrt(1+x^2) + float alphaRatio = m_ay / m_ax; + float cosPhi, sinPhi; + if (randu < 0.25f) { + float val = 4 * randu; + float tanPhi = alphaRatio * tanf((float) M_PI_2 * val); + cosPhi = 1 / sqrtf(1 + tanPhi * tanPhi); + sinPhi = tanPhi * cosPhi; + } else if (randu < 0.5) { + float val = 1 - 4 * (0.5f - randu); + float tanPhi = alphaRatio * tanf((float) M_PI_2 * val); + // phi = (float) M_PI - phi; + cosPhi = -1 / sqrtf(1 + tanPhi * tanPhi); + sinPhi = -tanPhi * cosPhi; + } else if (randu < 0.75f) { + float val = 4 * (randu - 0.5f); + float tanPhi = alphaRatio * tanf((float) M_PI_2 * val); + //phi = (float) M_PI + phi; + cosPhi = -1 / sqrtf(1 + tanPhi * tanPhi); + sinPhi = tanPhi * cosPhi; + } else { + float val = 1 - 4 * (1 - randu); + float tanPhi = alphaRatio * tanf((float) M_PI_2 * val); + // phi = 2 * (float) M_PI - phi; + cosPhi = 1 / sqrtf(1 + tanPhi * tanPhi); + sinPhi = -tanPhi * cosPhi; + } + // eq. 6 + // we take advantage of cos(atan(x)) == 1/sqrt(1+x^2) + // and sin(atan(x)) == x/sqrt(1+x^2) + float thetaDenom = (cosPhi * cosPhi) / (m_ax * m_ax) + (sinPhi * sinPhi) / (m_ay * m_ay); + float tanTheta2 = -logf(1 - randv) / thetaDenom; + float cosTheta = 1 / sqrtf(1 + tanTheta2); + float sinTheta = cosTheta * sqrtf(tanTheta2); + + Vec3 h; // already normalized becaused expressed from spherical coordinates + h.x = sinTheta * cosPhi; + h.y = sinTheta * sinPhi; + h.z = cosTheta; + // compute terms that are easier in local space + float dotx = h.x / m_ax; + float doty = h.y / m_ay; + float dotn = h.z; + // transform to world space + h = h.x * X + h.y * Y + h.z * m_N; + // generate the final sample + float oh = h.dot(omega_out); + omega_in.x = 2 * oh * h.x - omega_out.x; + omega_in.y = 2 * oh * h.y - omega_out.y; + omega_in.z = 2 * oh * h.z - omega_out.z; + if (Ng.dot(omega_in) > 0) { + float cosNI = m_N.dot(omega_in); + if (cosNI > 0) { + // eq. 9 + float exp_arg = (dotx * dotx + doty * doty) / (dotn * dotn); + float denom = 4 * (float) M_PI * m_ax * m_ay * oh * dotn * dotn * dotn; + pdf = expf(-exp_arg) / denom; + // compiler will reuse expressions already computed + denom = (4 * (float) M_PI * m_ax * m_ay * sqrtf(cosNO * cosNI)); + float power = cosNI * expf(-exp_arg) / denom; + eval.setValue(power, power, power); + domega_in_dx = (2 * m_N.dot(domega_out_dx)) * m_N - domega_out_dx; + domega_in_dy = (2 * m_N.dot(domega_out_dy)) * m_N - domega_out_dy; + + /* disabled for now - gives texture filtering problems */ +#if 0 + // Since there is some blur to this reflection, make the + // derivatives a bit bigger. In theory this varies with the + // roughness but the exact relationship is complex and + // requires more ops than are practical. + domega_in_dx *= 10; + domega_in_dy *= 10; +#endif + } + } + } + return Labels::REFLECT; + } +}; + + + +ClosureParam bsdf_ward_params[] = { + CLOSURE_VECTOR_PARAM(WardClosure, m_N), + CLOSURE_VECTOR_PARAM(WardClosure, m_T), + CLOSURE_FLOAT_PARAM (WardClosure, m_ax), + CLOSURE_FLOAT_PARAM (WardClosure, m_ay), + CLOSURE_STRING_KEYPARAM("label"), + CLOSURE_FINISH_PARAM(WardClosure) }; + +CLOSURE_PREPARE(bsdf_ward_prepare, WardClosure) + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/osl/bsdf_westin.cpp b/intern/cycles/kernel/osl/bsdf_westin.cpp new file mode 100644 index 00000000000..d322f6a7f7e --- /dev/null +++ b/intern/cycles/kernel/osl/bsdf_westin.cpp @@ -0,0 +1,239 @@ +/* + * 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. + */ + +#include <OpenImageIO/fmath.h> + +#include <OSL/genclosure.h> + +#include "osl_closures.h" + +#include "util_math.h" + +CCL_NAMESPACE_BEGIN + +using namespace OSL; + +class WestinBackscatterClosure : public BSDFClosure { +public: + Vec3 m_N; + float m_roughness; + float m_invroughness; + WestinBackscatterClosure() : BSDFClosure(Labels::GLOSSY) { } + + void setup() + { + m_roughness = clamp(m_roughness, 1e-5f, 1.0f); + m_invroughness = m_roughness > 0 ? 1 / m_roughness : 0; + } + + bool mergeable (const ClosurePrimitive *other) const { + const WestinBackscatterClosure *comp = (const WestinBackscatterClosure *)other; + return m_N == comp->m_N && m_roughness == comp->m_roughness && + BSDFClosure::mergeable(other); + } + + size_t memsize () const { return sizeof(*this); } + + const char *name () const { return "westin_backscatter"; } + + void print_on (std::ostream &out) const + { + out << name() << " ("; + out << "(" << m_N[0] << ", " << m_N[1] << ", " << m_N[2] << "), "; + out << m_roughness; + out << ")"; + } + + float albedo (const Vec3 &omega_out) const + { + return 1.0f; + } + + Color3 eval_reflect (const Vec3 &omega_out, const Vec3 &omega_in, float &pdf) const + { + // pdf is implicitly 0 (no indirect sampling) + float cosNO = m_N.dot(omega_out); + float cosNI = m_N.dot(omega_in); + if (cosNO > 0 && cosNI > 0) { + float cosine = omega_out.dot(omega_in); + pdf = cosine > 0 ? (m_invroughness + 1) * powf(cosine, m_invroughness) : 0; + pdf *= 0.5f * float(M_1_PI); + return Color3 (pdf, pdf, pdf); + } + return Color3 (0, 0, 0); + } + + Color3 eval_transmit (const Vec3 &omega_out, const Vec3 &omega_in, float &pdf) const + { + return Color3 (0, 0, 0); + } + + ustring sample (const Vec3 &Ng, + const Vec3 &omega_out, const Vec3 &domega_out_dx, const Vec3 &domega_out_dy, + float randu, float randv, + Vec3 &omega_in, Vec3 &domega_in_dx, Vec3 &domega_in_dy, + float &pdf, Color3 &eval) const + { + float cosNO = m_N.dot(omega_out); + if (cosNO > 0) { + domega_in_dx = domega_out_dx; + domega_in_dy = domega_out_dy; + Vec3 T, B; + make_orthonormals (omega_out, T, B); + float phi = 2 * (float) M_PI * randu; + float cosTheta = powf(randv, 1 / (m_invroughness + 1)); + float sinTheta2 = 1 - cosTheta * cosTheta; + float sinTheta = sinTheta2 > 0 ? sqrtf(sinTheta2) : 0; + omega_in = (cosf(phi) * sinTheta) * T + + (sinf(phi) * sinTheta) * B + + ( cosTheta) * omega_out; + if (Ng.dot(omega_in) > 0) + { + // common terms for pdf and eval + float cosNI = m_N.dot(omega_in); + // make sure the direction we chose is still in the right hemisphere + if (cosNI > 0) + { + pdf = 0.5f * (float) M_1_PI * powf(cosTheta, m_invroughness); + pdf = (m_invroughness + 1) * pdf; + eval.setValue(pdf, pdf, pdf); + // Since there is some blur to this reflection, make the + // derivatives a bit bigger. In theory this varies with the + // exponent but the exact relationship is complex and + // requires more ops than are practical. + domega_in_dx *= 10; + domega_in_dy *= 10; + } + } + } + return Labels::REFLECT; + } + +}; + + +class WestinSheenClosure : public BSDFClosure { +public: + Vec3 m_N; + float m_edginess; +// float m_normalization; + WestinSheenClosure() : BSDFClosure(Labels::DIFFUSE) { } + + void setup() {}; + + bool mergeable (const ClosurePrimitive *other) const { + const WestinSheenClosure *comp = (const WestinSheenClosure *)other; + return m_N == comp->m_N && m_edginess == comp->m_edginess && + BSDFClosure::mergeable(other); + } + + size_t memsize () const { return sizeof(*this); } + + const char *name () const { return "westin_sheen"; } + + void print_on (std::ostream &out) const + { + out << name() << " ("; + out << "(" << m_N[0] << ", " << m_N[1] << ", " << m_N[2] << "), "; + out << m_edginess; + out << ")"; + } + + float albedo (const Vec3 &omega_out) const + { + return 1.0f; + } + + Color3 eval_reflect (const Vec3 &omega_out, const Vec3 &omega_in, float &pdf) const + { + // pdf is implicitly 0 (no indirect sampling) + float cosNO = m_N.dot(omega_out); + float cosNI = m_N.dot(omega_in); + if (cosNO > 0 && cosNI > 0) { + float sinNO2 = 1 - cosNO * cosNO; + pdf = cosNI * float(M_1_PI); + float westin = sinNO2 > 0 ? powf(sinNO2, 0.5f * m_edginess) * pdf : 0; + return Color3 (westin, westin, westin); + } + return Color3 (0, 0, 0); + } + + Color3 eval_transmit (const Vec3 &omega_out, const Vec3 &omega_in, float &pdf) const + { + return Color3 (0, 0, 0); + } + + ustring sample (const Vec3 &Ng, + const Vec3 &omega_out, const Vec3 &domega_out_dx, const Vec3 &domega_out_dy, + float randu, float randv, + Vec3 &omega_in, Vec3 &domega_in_dx, Vec3 &domega_in_dy, + float &pdf, Color3 &eval) const + { + // we are viewing the surface from the right side - send a ray out with cosine + // distribution over the hemisphere + sample_cos_hemisphere (m_N, omega_out, randu, randv, omega_in, pdf); + if (Ng.dot(omega_in) > 0) { + // TODO: account for sheen when sampling + float cosNO = m_N.dot(omega_out); + float sinNO2 = 1 - cosNO * cosNO; + float westin = sinNO2 > 0 ? powf(sinNO2, 0.5f * m_edginess) * pdf : 0; + eval.setValue(westin, westin, westin); + // TODO: find a better approximation for the diffuse bounce + domega_in_dx = (2 * m_N.dot(domega_out_dx)) * m_N - domega_out_dx; + domega_in_dy = (2 * m_N.dot(domega_out_dy)) * m_N - domega_out_dy; + domega_in_dx *= 125; + domega_in_dy *= 125; + } else + pdf = 0; + return Labels::REFLECT; + } +}; + + + +ClosureParam bsdf_westin_backscatter_params[] = { + CLOSURE_VECTOR_PARAM(WestinBackscatterClosure, m_N), + CLOSURE_FLOAT_PARAM (WestinBackscatterClosure, m_roughness), + CLOSURE_STRING_KEYPARAM("label"), + CLOSURE_FINISH_PARAM(WestinBackscatterClosure) }; + +ClosureParam bsdf_westin_sheen_params[] = { + CLOSURE_VECTOR_PARAM(WestinSheenClosure, m_N), + CLOSURE_FLOAT_PARAM (WestinSheenClosure, m_edginess), + CLOSURE_STRING_KEYPARAM("label"), + CLOSURE_FINISH_PARAM(WestinSheenClosure) }; + +CLOSURE_PREPARE(bsdf_westin_backscatter_prepare, WestinBackscatterClosure) +CLOSURE_PREPARE(bsdf_westin_sheen_prepare, WestinSheenClosure) + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/osl/bssrdf.cpp b/intern/cycles/kernel/osl/bssrdf.cpp new file mode 100644 index 00000000000..66d7818e677 --- /dev/null +++ b/intern/cycles/kernel/osl/bssrdf.cpp @@ -0,0 +1,105 @@ +/* + * 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. + */ + +#include <OpenImageIO/fmath.h> + +#include <OSL/genclosure.h> + +#include "osl_closures.h" + +CCL_NAMESPACE_BEGIN + +using namespace OSL; + +class BSSRDFCubicClosure : public BSSRDFClosure { +public: + Color3 m_radius; + Color3 m_scale; + float m_max_radius; + + template <typename T> + static inline T pow3 (const T &x) { return x * x * x; } + + template <typename T> + static inline T pow5 (const T &x) { T x2 = x * x; return x2 * x2 * x; } + + BSSRDFCubicClosure() { } + + void setup() + { + // pre-compute some terms + m_max_radius = 0; + for (int i = 0; i < 3; i++) { + m_scale[i] = m_radius[i] > 0 ? 4 / pow5 (m_radius[i]) : 0; + m_max_radius = std::max (m_max_radius, m_radius[i]); + } + } + + bool mergeable (const ClosurePrimitive *other) const { + const BSSRDFCubicClosure *comp = (const BSSRDFCubicClosure *)other; + return m_radius == comp->m_radius && BSSRDFClosure::mergeable(other); + } + + size_t memsize () const { return sizeof(*this); } + + const char *name () const { return "bssrdf_cubic"; } + + void print_on (std::ostream &out) const + { + out << name() << " ((" << m_radius[0] << ", " << m_radius[1] << ", " << m_radius[2] << "), (" + << m_scale[0] << ", " << m_scale[1] << ", " << m_scale[2] << "))"; + } + + Color3 eval (float r) const + { + return Color3 ((r < m_radius.x) ? pow3 (m_radius.x - r) * m_scale.x : 0, + (r < m_radius.y) ? pow3 (m_radius.y - r) * m_scale.y : 0, + (r < m_radius.z) ? pow3 (m_radius.z - r) * m_scale.z : 0); + } + + float max_radius() const + { + return m_max_radius; + } +}; + + + +ClosureParam closure_bssrdf_cubic_params[] = { + CLOSURE_COLOR_PARAM (BSSRDFCubicClosure, m_radius), + CLOSURE_STRING_KEYPARAM ("label"), + CLOSURE_FINISH_PARAM(BSSRDFCubicClosure) }; + +CLOSURE_PREPARE(closure_bssrdf_cubic_prepare, BSSRDFCubicClosure) + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/osl/debug.cpp b/intern/cycles/kernel/osl/debug.cpp new file mode 100644 index 00000000000..8c3f8b2b323 --- /dev/null +++ b/intern/cycles/kernel/osl/debug.cpp @@ -0,0 +1,80 @@ +/* + * 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. + */ + +#include <OpenImageIO/fmath.h> + +#include <OSL/genclosure.h> + +#include "osl_closures.h" + +CCL_NAMESPACE_BEGIN + +using namespace OSL; + +/// Debug closure +/// +/// This is going to be used for mask AOV's and similar +/// purposes. A tag (string) is always associated with +/// this closure, that "selects: the channel where the +/// weight should be sent. + +class DebugClosure : public ClosurePrimitive { +public: + ustring m_tag; + + DebugClosure () : ClosurePrimitive (Debug) { } + + bool mergeable (const ClosurePrimitive *other) const { + const DebugClosure *comp = (const DebugClosure *)other; + return m_tag == comp->m_tag && + ClosurePrimitive::mergeable(other); + } + + size_t memsize () const { return sizeof(*this); } + + const char *name () const { return "debug"; } + + void print_on (std::ostream &out) const { + out << name() << " (\"" << m_tag.c_str() << "\")"; + } + +}; + +ClosureParam closure_debug_params[] = { + CLOSURE_STRING_PARAM(DebugClosure, m_tag), + CLOSURE_STRING_KEYPARAM("label"), + CLOSURE_FINISH_PARAM(DebugClosure) }; + +CLOSURE_PREPARE(closure_debug_prepare, DebugClosure) + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/osl/emissive.cpp b/intern/cycles/kernel/osl/emissive.cpp new file mode 100644 index 00000000000..28d3c73e59b --- /dev/null +++ b/intern/cycles/kernel/osl/emissive.cpp @@ -0,0 +1,107 @@ +/* + * 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. + */ + +#include <OpenImageIO/fmath.h> + +#include <OSL/genclosure.h> + +#include "osl_closures.h" + +CCL_NAMESPACE_BEGIN + +using namespace OSL; + +/// Variable cone emissive closure +/// +/// This primitive emits in a cone having a configurable +/// penumbra area where the light decays to 0 reaching the +/// outer_angle limit. It can also behave as a lambertian emitter +/// if the provided angles are PI/2, which is the default +/// +class GenericEmissiveClosure : public EmissiveClosure { +public: + GenericEmissiveClosure() { } + + void setup() { } + + size_t memsize () const { return sizeof(*this); } + + const char *name () const { return "emission"; } + + void print_on (std::ostream &out) const { + out << name() << "()"; + } + + Color3 eval (const Vec3 &Ng, const Vec3 &omega_out) const + { + float cosNO = fabsf(Ng.dot(omega_out)); + float res = cosNO > 0 ? 1.0f / float(M_PI) : 0.0f; + return Color3(res, res, res); + } + + void sample (const Vec3 &Ng, float randu, float randv, + Vec3 &omega_out, float &pdf) const + { + // We don't do anything sophisticated here for the step + // We just sample the whole cone uniformly to the cosine + Vec3 T, B; + make_orthonormals(Ng, T, B); + float phi = 2 * (float) M_PI * randu; + float cosTheta = sqrtf(1.0f - 1.0f * randv); + float sinTheta = sqrtf(1.0f - cosTheta * cosTheta); + omega_out = (cosf(phi) * sinTheta) * T + + (sinf(phi) * sinTheta) * B + + cosTheta * Ng; + pdf = 1.0f / float(M_PI); + } + + /// Return the probability distribution function in the direction omega_out, + /// given the parameters and the light's surface normal. This MUST match + /// the PDF computed by sample(). + float pdf (const Vec3 &Ng, + const Vec3 &omega_out) const + { + float cosNO = Ng.dot(omega_out); + return cosNO > 0 ? 1.0f / float(M_PI) : 0.0f; + } +}; + + + +ClosureParam closure_emission_params[] = { + CLOSURE_STRING_KEYPARAM("label"), + CLOSURE_FINISH_PARAM(GenericEmissiveClosure) }; + +CLOSURE_PREPARE(closure_emission_prepare, GenericEmissiveClosure) + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/osl/nodes/CMakeLists.txt b/intern/cycles/kernel/osl/nodes/CMakeLists.txt new file mode 100644 index 00000000000..435acc5f680 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/CMakeLists.txt @@ -0,0 +1,69 @@ + +# OSL node shaders + +SET(osl_sources + node_add_closure.osl + node_attribute.osl + node_background.osl + node_blend_texture.osl + node_bump.osl + node_clouds_texture.osl + node_convert_from_color.osl + node_convert_from_float.osl + node_convert_from_normal.osl + node_convert_from_point.osl + node_convert_from_vector.osl + node_diffuse_bsdf.osl + node_distorted_noise_texture.osl + node_emission.osl + node_environment_texture.osl + node_fresnel.osl + node_geometry.osl + node_glass_bsdf.osl + node_glossy_bsdf.osl + node_image_texture.osl + node_light_path.osl + node_magic_texture.osl + node_mapping.osl + node_marble_texture.osl + node_math.osl + node_mix.osl + node_mix_closure.osl + node_musgrave_texture.osl + node_noise_texture.osl + node_output_displacement.osl + node_output_surface.osl + node_output_volume.osl + node_sky_texture.osl + node_stucci_texture.osl + node_texture_coordinate.osl + node_translucent_bsdf.osl + node_transparent_bsdf.osl + node_value.osl + node_vector_math.osl + node_velvet_bsdf.osl + node_voronoi_texture.osl + node_ward_bsdf.osl + node_wood_texture.osl) + +SET(osl_headers + node_texture.h + stdosl.h) + +SET(oso_sources) + +FOREACH(_file ${osl_sources}) + SET(osl_file ${CMAKE_CURRENT_SOURCE_DIR}/${_file}) + STRING(REPLACE ".osl" ".oso" oso_file ${osl_file}) + STRING(REPLACE ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR} oso_file ${oso_file}) + ADD_CUSTOM_COMMAND( + OUTPUT ${oso_file} + COMMAND ${OSL_COMPILER} -O2 ${osl_file} + DEPENDS ${osl_file} ${osl_headers}) + LIST(APPEND oso_sources ${oso_file}) +ENDFOREACH() + +ADD_CUSTOM_TARGET(shader ALL DEPENDS ${oso_sources} ${osl_headers}) + +INSTALL(FILES ${oso_sources} DESTINATION ${INSTALL_PATH}/cycles/shader) + diff --git a/intern/cycles/kernel/osl/nodes/node_add_closure.osl b/intern/cycles/kernel/osl/nodes/node_add_closure.osl new file mode 100644 index 00000000000..ecf6bf5912e --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_add_closure.osl @@ -0,0 +1,28 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_add_closure( + closure color Closure1 = background(), + closure color Closure2 = background(), + output closure color Closure = background()) +{ + Closure = Closure1 + Closure2; +} + diff --git a/intern/cycles/kernel/osl/nodes/node_attribute.osl b/intern/cycles/kernel/osl/nodes/node_attribute.osl new file mode 100644 index 00000000000..d273d0c68d7 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_attribute.osl @@ -0,0 +1,43 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_attribute( + string bump_offset = "center", + string name = "", + output point Vector = point(0.0, 0.0, 0.0), + output color Color = color(0.0, 0.0, 0.0), + output float Fac = 0.0) +{ + getattribute(name, Color); + Vector = point(Color); + getattribute(name, Fac); + + if(bump_offset == "dx") { + Color += Dx(Color); + Vector += Dx(Vector); + Fac += Dx(Fac); + } + else if(bump_offset == "dy") { + Color += Dy(Color); + Vector += Dy(Vector); + Fac += Dy(Fac); + } +} + diff --git a/intern/cycles/kernel/osl/nodes/node_background.osl b/intern/cycles/kernel/osl/nodes/node_background.osl new file mode 100644 index 00000000000..69f8d85a82e --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_background.osl @@ -0,0 +1,28 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_background( + color Color = color(0.8, 0.8, 0.8), + float Strength = 1.0, + output closure color Background = background()) +{ + Background = Color*Strength*background(); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_blend_texture.osl b/intern/cycles/kernel/osl/nodes/node_blend_texture.osl new file mode 100644 index 00000000000..de1bdaca90b --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_blend_texture.osl @@ -0,0 +1,78 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" +#include "node_texture.h" + +/* Blend */ + +float blend(point p, string progression, string axis) +{ + float x, y; + + if(axis == "Vertical") { + x= p[1]; + y= p[0]; + } + else { + x= p[0]; + y= p[1]; + } + + float result = 0.0; + + if(progression == "Linear") { + result = (1.0 + x)/2.0; + } + else if(progression == "Quadratic") { + float r = max((1.0 + x)/2.0, 0.0); + result = r*r; + } + else if(progression == "Easing") { + float r = min(max((1.0 + x)/2.0, 0.0), 1.0); + float t = r*r; + + result = (3.0*t - 2.0*t*r); + } + else if(progression == "Diagonal") { + result = (2.0 + x + y)/4.0; + } + else if(progression == "Radial") { + result = atan2(y, x)/(2*M_PI) + 0.5; + } + else { + float r = max(1.0 - sqrt(x*x + y*y + p[2]*p[2]), 0.0); + + if(progression == "Quadratic Sphere") + result = r*r; + else if(progression == "Spherical") + result = r; + } + + return result; +} + +shader node_blend_texture( + string Progression = "Linear", + string Axis = "Horizontal", + point Vector = P, + output float Fac = 0.0) +{ + Fac = blend(Vector, Progression, Axis); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_bump.osl b/intern/cycles/kernel/osl/nodes/node_bump.osl new file mode 100644 index 00000000000..a3849e70f98 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_bump.osl @@ -0,0 +1,46 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +/* "Bump Mapping Unparametrized Surfaces on the GPU" + * Morten S. Mikkelsen, 2010 */ + +surface node_bump( + float SampleCenter = 0.0, + float SampleX = 0.0, + float SampleY = 0.0, + output normal Normal = N) +{ + float dx = SampleX - SampleCenter; + float dy = SampleY - SampleCenter; + + vector dPdx = Dx(P); + vector dPdy = Dy(P); + + vector Rx = cross(dPdy, N); + vector Ry = cross(N, dPdx); + + float det = dot(dPdx, Rx); + vector surfgrad = dx*Rx + dy*Ry; + + surfgrad *= 0.1; /* todo: remove this factor */ + + Normal = normalize(abs(det)*N - sign(det)*surfgrad); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_clouds_texture.osl b/intern/cycles/kernel/osl/nodes/node_clouds_texture.osl new file mode 100644 index 00000000000..6d244d81e27 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_clouds_texture.osl @@ -0,0 +1,42 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" +#include "node_texture.h" + +/* Turbulence */ + +shader node_clouds_texture( + string Basis = "Perlin", + int Hard = 0, + int Depth = 2, + float Size = 0.25, + point Vector = P, + output float Fac = 0.0, + output color Color = color(0.0, 0.0, 0.0)) +{ + float size = nonzero(Size, 1e-5); + point p = Vector/size; + + Fac = noise_turbulence(p, Basis, Depth, Hard); + + Color[0] = Fac; + Color[1] = noise_turbulence(point(p[1], p[0], p[2]), Basis, Depth, Hard); + Color[2] = noise_turbulence(point(p[1], p[2], p[0]), Basis, Depth, Hard); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_convert_from_color.osl b/intern/cycles/kernel/osl/nodes/node_convert_from_color.osl new file mode 100644 index 00000000000..97356139c48 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_convert_from_color.osl @@ -0,0 +1,33 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_convert_from_color( + color Color = color(0.0, 0.0, 0.0), + output float Val = 0.0, + output vector Vector = vector(0.0, 0.0, 0.0), + output point Point = point(0.0, 0.0, 0.0), + output normal Normal = normal(0.0, 0.0, 0.0)) +{ + Val = Color[0]*0.2126 + Color[1]*0.7152 + Color[2]*0.0722; + Vector = vector(Color[0], Color[1], Color[2]); + Point = point(Color[0], Color[1], Color[2]); + Normal = normal(Color[0], Color[1], Color[2]); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_convert_from_float.osl b/intern/cycles/kernel/osl/nodes/node_convert_from_float.osl new file mode 100644 index 00000000000..00e78f3bab4 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_convert_from_float.osl @@ -0,0 +1,33 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_convert_from_float( + float Val = 0.0, + output color Color = color(0.0, 0.0, 0.0), + output vector Vector = vector(0.0, 0.0, 0.0), + output point Point = point(0.0, 0.0, 0.0), + output normal Normal = normal(0.0, 0.0, 0.0)) +{ + Color = color(Val, Val, Val); + Vector = vector(Val, Val, Val); + Point = point(Val, Val, Val); + Normal = normal(Val, Val, Val); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_convert_from_normal.osl b/intern/cycles/kernel/osl/nodes/node_convert_from_normal.osl new file mode 100644 index 00000000000..0bb9092591d --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_convert_from_normal.osl @@ -0,0 +1,33 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_convert_from_normal( + normal Normal = normal(0.0, 0.0, 0.0), + output float Val = 0.0, + output vector Vector = vector(0.0, 0.0, 0.0), + output color Color = color(0.0, 0.0, 0.0), + output point Point = point(0.0, 0.0, 0.0)) +{ + Val = (Normal[0] + Normal[1] + Normal[2])*(1.0/3.0); + Vector = vector(Normal[0], Normal[1], Normal[2]); + Color = color(Normal[0], Normal[1], Normal[2]); + Point = point(Normal[0], Normal[1], Normal[2]); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_convert_from_point.osl b/intern/cycles/kernel/osl/nodes/node_convert_from_point.osl new file mode 100644 index 00000000000..e66d6a864d6 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_convert_from_point.osl @@ -0,0 +1,33 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_convert_from_point( + point Point = point(0.0, 0.0, 0.0), + output float Val = 0.0, + output vector Vector = vector(0.0, 0.0, 0.0), + output color Color = color(0.0, 0.0, 0.0), + output normal Normal = normal(0.0, 0.0, 0.0)) +{ + Val = (Point[0] + Point[1] + Point[2])*(1.0/3.0); + Vector = vector(Point[0], Point[1], Point[2]); + Color = color(Point[0], Point[1], Point[2]); + Normal = normal(Point[0], Point[1], Point[2]); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_convert_from_vector.osl b/intern/cycles/kernel/osl/nodes/node_convert_from_vector.osl new file mode 100644 index 00000000000..37ba9582cad --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_convert_from_vector.osl @@ -0,0 +1,33 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_convert_from_vector( + vector Vector = vector(0.0, 0.0, 0.0), + output float Val = 0.0, + output color Color = color(0.0, 0.0, 0.0), + output point Point = point(0.0, 0.0, 0.0), + output normal Normal = normal(0.0, 0.0, 0.0)) +{ + Val = (Vector[0] + Vector[1] + Vector[2])*(1.0/3.0); + Color = color(Vector[0], Vector[1], Vector[2]); + Point = point(Vector[0], Vector[1], Vector[2]); + Normal = normal(Vector[0], Vector[1], Vector[2]); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_diffuse_bsdf.osl b/intern/cycles/kernel/osl/nodes/node_diffuse_bsdf.osl new file mode 100644 index 00000000000..8cf161c17cc --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_diffuse_bsdf.osl @@ -0,0 +1,28 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_diffuse_bsdf( + color Color = color(0.8, 0.8, 0.8), + normal Normal = N, + output closure color BSDF = diffuse(Normal)) +{ + BSDF = Color*diffuse(Normal); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_distorted_noise_texture.osl b/intern/cycles/kernel/osl/nodes/node_distorted_noise_texture.osl new file mode 100644 index 00000000000..bb338c4ef0f --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_distorted_noise_texture.osl @@ -0,0 +1,46 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" +#include "node_texture.h" + +/* Distorted Noise (variable lacunarity noise) */ + +float noise_distorted(point p, string basis, string distortion_basis, float distortion) +{ + point r; + + r[0] = noise_basis(p + point(13.5), basis) * distortion; + r[1] = noise_basis(p, basis) * distortion; + r[2] = noise_basis(p - point(13.5), basis) * distortion; + + return noise_basis(p + r, distortion_basis); /* distorted-domain noise */ +} + +shader node_distorted_noise_texture( + string Basis = "Perlin", + string DistortionBasis = "Perlin", + float Distortion = 1.0, + float Size = 0.25, + point Vector = P, + output float Fac = 0.0) +{ + float size = nonzero(Size, 1e-5); + Fac = noise_distorted(Vector/size, Basis, DistortionBasis, Distortion); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_emission.osl b/intern/cycles/kernel/osl/nodes/node_emission.osl new file mode 100644 index 00000000000..8bfd1af173a --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_emission.osl @@ -0,0 +1,32 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_emission( + int TotalPower = 0, + color Color = color(0.8, 0.8, 0.8), + float Strength = 1.0, + output closure color Emission = emission()) +{ + if(TotalPower) + Emission = ((Strength/surfacearea())*Color)*emission(); + else + Emission = (Strength*Color)*emission(); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_environment_texture.osl b/intern/cycles/kernel/osl/nodes/node_environment_texture.osl new file mode 100644 index 00000000000..569b22d53ec --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_environment_texture.osl @@ -0,0 +1,28 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_environment_texture( + vector Vector = P, + string filename = "", + output color Color = color(0.0, 0.0, 0.0)) +{ + Color = (color)environment(filename, Vector); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_fresnel.h b/intern/cycles/kernel/osl/nodes/node_fresnel.h new file mode 100644 index 00000000000..0c8a5276ede --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_fresnel.h @@ -0,0 +1,21 @@ + +float fresnel_dielectric(vector Incoming, normal Normal, float eta) +{ + /* compute fresnel reflectance without explicitly computing + the refracted direction */ + float c = fabs(dot(Incoming, Normal)); + float g = eta * eta - 1 + c * c; + float result; + + if(g > 0) { + g = sqrt(g); + float A =(g - c)/(g + c); + float B =(c *(g + c)- 1)/(c *(g - c)+ 1); + result = 0.5 * A * A *(1 + B * B); + } + else + result = 1.0; /* TIR (no refracted component) */ + + return result; +} + diff --git a/intern/cycles/kernel/osl/nodes/node_fresnel.osl b/intern/cycles/kernel/osl/nodes/node_fresnel.osl new file mode 100644 index 00000000000..ddc86db130f --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_fresnel.osl @@ -0,0 +1,30 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" +#include "node_fresnel.h" + +shader node_fresnel( + float Fresnel = 0.3, + normal Normal = N, + output float Fac = 0.0) +{ + float f = max(1.0 - Fresnel, 0.00001); + Fac = fresnel_dielectric(I, Normal, backfacing()? f: 1.0/f); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_geometry.osl b/intern/cycles/kernel/osl/nodes/node_geometry.osl new file mode 100644 index 00000000000..bf76e2e597a --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_geometry.osl @@ -0,0 +1,50 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_geometry( + normal NormalIn = N, + string bump_offset = "center", + + output point Position = point(0.0, 0.0, 0.0), + output normal Normal = normal(0.0, 0.0, 0.0), + output normal Tangent = normal(0.0, 0.0, 0.0), + output normal TrueNormal = normal(0.0, 0.0, 0.0), + output vector Incoming = vector(0.0, 0.0, 0.0), + output point UV = point(0.0, 0.0, 0.0), + output float Backfacing = 0.0) +{ + Position = P; + Normal = NormalIn; + Tangent = normalize(dPdu); + TrueNormal = Ng; + Incoming = I; + UV = point(u, v, 0.0); + Backfacing = backfacing(); + + if(bump_offset == "dx") { + Position += Dx(Position); + UV += Dx(UV); + } + else if(bump_offset == "dy") { + Position += Dy(Position); + UV += Dy(UV); + } +} + diff --git a/intern/cycles/kernel/osl/nodes/node_glass_bsdf.osl b/intern/cycles/kernel/osl/nodes/node_glass_bsdf.osl new file mode 100644 index 00000000000..af946048011 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_glass_bsdf.osl @@ -0,0 +1,41 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" +#include "node_fresnel.h" + +shader node_glass_bsdf( + color Color = color(0.8, 0.8, 0.8), + string distribution = "Sharp", + float Roughness = 0.2, + float Fresnel = 0.3, + normal Normal = N, + output closure color BSDF = diffuse(Normal)) +{ + float f = clamp(1.0 - Fresnel, 1e-5, 1.0 - 1e-5); + float eta = backfacing()? f: 1.0/f; + float Fr = fresnel_dielectric(I, Normal, eta); + + if(distribution == "Sharp") + BSDF = Color*(Fr*reflection(Normal) + (1.0-Fr)*refraction(Normal, eta)); + else if(distribution == "Beckmann") + BSDF = Color*(Fr*microfacet_beckmann(Normal, Roughness) + (1.0-Fr)*microfacet_beckmann_refraction(Normal, Roughness, eta)); + else if(distribution == "GGX") + BSDF = Color*(Fr*microfacet_ggx(Normal, Roughness) + (1.0-Fr)*microfacet_ggx_refraction(Normal, Roughness, eta)); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_glossy_bsdf.osl b/intern/cycles/kernel/osl/nodes/node_glossy_bsdf.osl new file mode 100644 index 00000000000..ca6bee74b38 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_glossy_bsdf.osl @@ -0,0 +1,45 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" +#include "node_fresnel.h" + +shader node_glossy_bsdf( + color Color = color(0.8, 0.8, 0.8), + string distribution = "Beckmann", + float Roughness = 0.2, + float Fresnel = 1.0, + normal Normal = N, + output closure color BSDF = diffuse(Normal)) +{ + float Fr = 1.0; + + if(Fresnel < 1.0) { + float eta = 1.0/clamp(1.0 - Fresnel, 1e-5, 1.0 - 1e-5); + Fr = fresnel_dielectric(I, Normal, eta); + } + + if(distribution == "Sharp") + BSDF = (Fr*Color)*reflection(Normal); + else if(distribution == "Beckmann") + BSDF = (Fr*Color)*microfacet_beckmann(Normal, Roughness); + else if(distribution == "GGX") + BSDF = (Fr*Color)*microfacet_ggx(Normal, Roughness); + +} + diff --git a/intern/cycles/kernel/osl/nodes/node_image_texture.osl b/intern/cycles/kernel/osl/nodes/node_image_texture.osl new file mode 100644 index 00000000000..0dbcc122deb --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_image_texture.osl @@ -0,0 +1,28 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_image_texture( + point Vector = P, + string filename = "", + output color Color = color(0.0, 0.0, 0.0)) +{ + Color = (color)texture(filename, Vector[0], 1.0-Vector[1], "wrap", "periodic"); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_light_path.osl b/intern/cycles/kernel/osl/nodes/node_light_path.osl new file mode 100644 index 00000000000..081640428ab --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_light_path.osl @@ -0,0 +1,36 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_light_path( + output float IsCameraRay = 0.0, + output float IsShadowRay = 0.0, + output float IsDiffuseRay = 0.0, + output float IsGlossyRay = 0.0, + output float IsReflectionRay = 0.0, + output float IsTransmissionRay = 0.0) +{ + IsCameraRay = raytype("camera"); + IsShadowRay = raytype("shadow"); + IsDiffuseRay = raytype("diffuse"); + IsGlossyRay = raytype("glossy"); + IsReflectionRay = raytype("reflection"); + IsTransmissionRay = raytype("refraction"); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_magic_texture.osl b/intern/cycles/kernel/osl/nodes/node_magic_texture.osl new file mode 100644 index 00000000000..0b6e980debc --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_magic_texture.osl @@ -0,0 +1,103 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" +#include "node_texture.h" + +/* Magic */ + +color magic(point p, int n, float turbulence) +{ + float turb = turbulence/5.0; + + float x = sin((p[0] + p[1] + p[2])*5.0); + float y = cos((-p[0] + p[1] - p[2])*5.0); + float z = -cos((-p[0] - p[1] + p[2])*5.0); + + if(n > 0) { + x *= turb; + y *= turb; + z *= turb; + y = -cos(x-y+z); + y *= turb; + + if(n > 1) { + x= cos(x-y-z); + x *= turb; + + if(n > 2) { + z= sin(-x-y-z); + z *= turb; + + if(n > 3) { + x= -cos(-x+y-z); + x *= turb; + + if(n > 4) { + y= -sin(-x+y+z); + y *= turb; + + if(n > 5) { + y= -cos(-x+y+z); + y *= turb; + + if(n > 6) { + x= cos(x+y+z); + x *= turb; + + if(n > 7) { + z= sin(x+y-z); + z *= turb; + + if(n > 8) { + x= -cos(-x-y+z); + x *= turb; + + if(n > 9) { + y= -sin(x-y+z); + y *= turb; + } + } + } + } + } + } + } + } + } + } + + if(turb != 0.0) { + turb *= 2.0; + x /= turb; + y /= turb; + z /= turb; + } + + return color(0.5 - x, 0.5 - y, 0.5 - z); +} + +shader node_magic_texture( + int Depth = 2, + float Turbulence = 5.0, + point Vector = P, + output color Color = color(0.0, 0.0, 0.0)) +{ + Color = magic(Vector, Depth, Turbulence); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_mapping.osl b/intern/cycles/kernel/osl/nodes/node_mapping.osl new file mode 100644 index 00000000000..f342837d3c9 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_mapping.osl @@ -0,0 +1,28 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_mapping( + matrix Matrix = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), + point Vector = point(0.0, 0.0, 0.0), + output point Vector_ = point(0.0, 0.0, 0.0)) +{ + Vector_ = transform(Matrix, Vector); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_marble_texture.osl b/intern/cycles/kernel/osl/nodes/node_marble_texture.osl new file mode 100644 index 00000000000..9e18dee3235 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_marble_texture.osl @@ -0,0 +1,58 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" +#include "node_texture.h" + +/* Marble */ + +float marble(point p, float size, string type, string wave, string basis, int hard, float turb, int depth) +{ + float x = p[0]; + float y = p[1]; + float z = p[2]; + + float n = 5.0 * (x + y + z); + + float mi = n + turb * noise_turbulence(p/size, basis, depth, hard); + + mi = noise_wave(wave, mi); + + if(type == "Sharp") + mi = sqrt(mi); + else if(type == "Sharper") + mi = sqrt(sqrt(mi)); + + return mi; +} + +shader node_marble_texture( + string Type = "Soft", + string Wave = "Sine", + string Basis = "Perlin", + int Hard = 0, + float Size = 0.25, + float Turbulence = 5.0, + int Depth = 2, + point Vector = P, + output float Fac = 0.0) +{ + float size = nonzero(Size, 1e-5); + Fac = marble(Vector, size, Type, Wave, Basis, Hard, Turbulence, Depth); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_math.osl b/intern/cycles/kernel/osl/nodes/node_math.osl new file mode 100644 index 00000000000..be9bb71d511 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_math.osl @@ -0,0 +1,84 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +float safe_divide(float a, float b) +{ + float result; + + if(b == 0.0) + result = 0.0; + else + result = a/b; + + return result; +} + +float safe_log(float a, float b) +{ + if(a < 0.0 || b < 0.0) + return 0.0; + + return log(a)/log(b); +} + +shader node_math( + string type = "Add", + float Value1 = 0.0, + float Value2 = 0.0, + output float Value = 0.0) +{ + /* OSL asin, acos, pow check for values that could give rise to nan */ + + if(type == "Add") + Value = Value1 + Value2; + if(type == "Subtract") + Value = Value1 - Value2; + if(type == "Multiply") + Value = Value1*Value2; + if(type == "Divide") + Value = safe_divide(Value1, Value2); + if(type == "Sine") + Value = sin(Value1); + if(type == "Cosine") + Value = cos(Value1); + if(type == "Tangent") + Value = tan(Value1); + if(type == "Arcsine") + Value = asin(Value1); + if(type == "Arccosine") + Value = acos(Value1); + if(type == "Arctangent") + Value = atan(Value1); + if(type == "Power") + Value = pow(Value1, Value2); + if(type == "Logarithm") + Value = safe_log(Value1, Value2); + if(type == "Minimum") + Value = min(Value1, Value2); + if(type == "Maximum") + Value = max(Value1, Value2); + if(type == "Round") + Value = floor(Value1 + 0.5); + if(type == "Less Than") + Value = Value1 < Value2; + if(type == "Greater Than") + Value = Value1 > Value2; +} + diff --git a/intern/cycles/kernel/osl/nodes/node_mix.osl b/intern/cycles/kernel/osl/nodes/node_mix.osl new file mode 100644 index 00000000000..582aa7b3c60 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_mix.osl @@ -0,0 +1,388 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +color rgb_to_hsv(color rgb) +{ + float cmax, cmin, h, s, v, cdelta; + color c; + + cmax = max(rgb[0], max(rgb[1], rgb[2])); + cmin = min(rgb[0], min(rgb[1], rgb[2])); + cdelta = cmax - cmin; + + v = cmax; + + if(cmax != 0.0) { + s = cdelta/cmax; + } + else { + s = 0.0; + h = 0.0; + } + + if(s == 0.0) { + h = 0.0; + } + else { + c = (color(cmax, cmax, cmax) - rgb)/cdelta; + + if(rgb[0] == cmax) h = c[2] - c[1]; + else if(rgb[1] == cmax) h = 2.0 + c[0] - c[2]; + else h = 4.0 + c[1] - c[0]; + + h /= 6.0; + + if(h < 0.0) + h += 1.0; + } + + return color(h, s, v); +} + +color hsv_to_rgb(color hsv) +{ + float i, f, p, q, t, h, s, v; + color rgb; + + h = hsv[0]; + s = hsv[1]; + v = hsv[2]; + + if(s==0.0) { + rgb = color(v, v, v); + } + else { + if(h==1.0) + h = 0.0; + + h *= 6.0; + i = floor(h); + f = h - i; + rgb = color(f, f, f); + p = v*(1.0-s); + q = v*(1.0-(s*f)); + t = v*(1.0-(s*(1.0-f))); + + if(i == 0.0) rgb = color(v, t, p); + else if(i == 1.0) rgb = color(q, v, p); + else if(i == 2.0) rgb = color(p, v, t); + else if(i == 3.0) rgb = color(p, q, v); + else if(i == 4.0) rgb = color(t, p, v); + else rgb = color(v, p, q); + } + + return rgb; +} + +color node_mix_blend(float t, color col1, color col2) +{ + return mix(col1, col2, t); +} + +color node_mix_add(float t, color col1, color col2) +{ + return mix(col1, col1 + col2, t); +} + +color node_mix_mul(float t, color col1, color col2) +{ + return mix(col1, col1 * col2, t); +} + +color node_mix_screen(float t, color col1, color col2) +{ + float tm = 1.0 - t; + + return color(1.0) - (color(tm) + t*(color(1.0) - col2))*(color(1.0) - col1); +} + +color node_mix_overlay(float t, color col1, color col2) +{ + float tm = 1.0 - t; + + color outcol = col1; + + if(outcol[0] < 0.5) + outcol[0] *= tm + 2.0*t*col2[0]; + else + outcol[0] = 1.0 - (tm + 2.0*t*(1.0 - col2[0]))*(1.0 - outcol[0]); + + if(outcol[1] < 0.5) + outcol[1] *= tm + 2.0*t*col2[1]; + else + outcol[1] = 1.0 - (tm + 2.0*t*(1.0 - col2[1]))*(1.0 - outcol[1]); + + if(outcol[2] < 0.5) + outcol[2] *= tm + 2.0*t*col2[2]; + else + outcol[2] = 1.0 - (tm + 2.0*t*(1.0 - col2[2]))*(1.0 - outcol[2]); + + return outcol; +} + +color node_mix_sub(float t, color col1, color col2) +{ + return mix(col1, col1 - col2, t); +} + +color node_mix_div(float t, color col1, color col2) +{ + float tm = 1.0 - t; + + color outcol = col1; + + if(col2[0] != 0.0) outcol[0] = tm*outcol[0] + t*outcol[0]/col2[0]; + if(col2[1] != 0.0) outcol[1] = tm*outcol[1] + t*outcol[1]/col2[1]; + if(col2[2] != 0.0) outcol[2] = tm*outcol[2] + t*outcol[2]/col2[2]; + + return outcol; +} + +color node_mix_diff(float t, color col1, color col2) +{ + return mix(col1, abs(col1 - col2), t); +} + +color node_mix_dark(float t, color col1, color col2) +{ + return min(col1, col2*t); +} + +color node_mix_light(float t, color col1, color col2) +{ + return max(col1, col2*t); +} + +color node_mix_dodge(float t, color col1, color col2) +{ + color outcol = col1; + + if(outcol[0] != 0.0) { + float tmp = 1.0 - t*col2[0]; + if(tmp <= 0.0) + outcol[0] = 1.0; + else if((tmp = outcol[0]/tmp) > 1.0) + outcol[0] = 1.0; + else + outcol[0] = tmp; + } + if(outcol[1] != 0.0) { + float tmp = 1.0 - t*col2[1]; + if(tmp <= 0.0) + outcol[1] = 1.0; + else if((tmp = outcol[1]/tmp) > 1.0) + outcol[1] = 1.0; + else + outcol[1] = tmp; + } + if(outcol[2] != 0.0) { + float tmp = 1.0 - t*col2[2]; + if(tmp <= 0.0) + outcol[2] = 1.0; + else if((tmp = outcol[2]/tmp) > 1.0) + outcol[2] = 1.0; + else + outcol[2] = tmp; + } + + return outcol; +} + +color node_mix_burn(float t, color col1, color col2) +{ + float tmp, tm = 1.0 - t; + + color outcol = col1; + + tmp = tm + t*col2[0]; + if(tmp <= 0.0) + outcol[0] = 0.0; + else if((tmp = (1.0 - (1.0 - outcol[0])/tmp)) < 0.0) + outcol[0] = 0.0; + else if(tmp > 1.0) + outcol[0] = 1.0; + else + outcol[0] = tmp; + + tmp = tm + t*col2[1]; + if(tmp <= 0.0) + outcol[1] = 0.0; + else if((tmp = (1.0 - (1.0 - outcol[1])/tmp)) < 0.0) + outcol[1] = 0.0; + else if(tmp > 1.0) + outcol[1] = 1.0; + else + outcol[1] = tmp; + + tmp = tm + t*col2[2]; + if(tmp <= 0.0) + outcol[2] = 0.0; + else if((tmp = (1.0 - (1.0 - outcol[2])/tmp)) < 0.0) + outcol[2] = 0.0; + else if(tmp > 1.0) + outcol[2] = 1.0; + else + outcol[2] = tmp; + + return outcol; +} + +color node_mix_hue(float t, color col1, color col2) +{ + color outcol = col1; + color hsv2 = rgb_to_hsv(col2); + + if(hsv2[1] != 0.0) { + color hsv = rgb_to_hsv(outcol); + hsv[0] = hsv2[0]; + color tmp = hsv_to_rgb(hsv); + + outcol = mix(outcol, tmp, t); + } + + return outcol; +} + +color node_mix_sat(float t, color col1, color col2) +{ + float tm = 1.0 - t; + + color outcol = col1; + + color hsv = rgb_to_hsv(outcol); + + if(hsv[1] != 0.0) { + color hsv2 = rgb_to_hsv(col2); + + hsv[1] = tm*hsv[1] + t*hsv2[1]; + outcol = hsv_to_rgb(hsv); + } + + return outcol; +} + +color node_mix_val(float t, color col1, color col2) +{ + float tm = 1.0 - t; + + color hsv = rgb_to_hsv(col1); + color hsv2 = rgb_to_hsv(col2); + + hsv[2] = tm*hsv[2] + t*hsv2[2]; + + return hsv_to_rgb(hsv); +} + +color node_mix_color(float t, color col1, color col2) +{ + color outcol = col1; + color hsv2 = rgb_to_hsv(col2); + + if(hsv2[1] != 0.0) { + color hsv = rgb_to_hsv(outcol); + hsv[0] = hsv2[0]; + hsv[1] = hsv2[1]; + color tmp = hsv_to_rgb(hsv); + + outcol = mix(outcol, tmp, t); + } + + return outcol; +} + +color node_mix_soft(float t, color col1, color col2) +{ + float tm = 1.0 - t; + + color one= color(1.0); + color scr= one - (one - col2)*(one - col1); + + return tm*col1 + t*((one - col1)*col2*col1 + col1*scr); +} + +color node_mix_linear(float t, color col1, color col2) +{ + color outcol = col1; + + if(col2[0] > 0.5) + outcol[0]= col1[0] + t*(2.0*(col2[0] - 0.5)); + else + outcol[0]= col1[0] + t*(2.0*(col2[0]) - 1.0); + + if(col2[1] > 0.5) + outcol[1]= col1[1] + t*(2.0*(col2[1] - 0.5)); + else + outcol[1]= col1[1] + t*(2.0*(col2[1]) - 1.0); + + if(col2[2] > 0.5) + outcol[2]= col1[2] + t*(2.0*(col2[2] - 0.5)); + else + outcol[2]= col1[2] + t*(2.0*(col2[2]) - 1.0); + + return outcol; +} + +shader node_mix( + string type = "Mix", + float Fac = 0.5, + color Color1 = color(0.0, 0.0, 0.0), + color Color2 = color(0.0, 0.0, 0.0), + output color Color = color(0.0, 0.0, 0.0)) +{ + float t = clamp(Fac, 0.0, 1.0); + + if(type == "Mix") + Color = node_mix_blend(t, Color1, Color2); + if(type == "Add") + Color = node_mix_add(t, Color1, Color2); + if(type == "Multiply") + Color = node_mix_mul(t, Color1, Color2); + if(type == "Screen") + Color = node_mix_screen(t, Color1, Color2); + if(type == "Overlay") + Color = node_mix_overlay(t, Color1, Color2); + if(type == "Subtract") + Color = node_mix_sub(t, Color1, Color2); + if(type == "Divide") + Color = node_mix_div(t, Color1, Color2); + if(type == "Difference") + Color = node_mix_diff(t, Color1, Color2); + if(type == "Darken") + Color = node_mix_dark(t, Color1, Color2); + if(type == "Lighten") + Color = node_mix_light(t, Color1, Color2); + if(type == "Dodge") + Color = node_mix_dodge(t, Color1, Color2); + if(type == "Burn") + Color = node_mix_burn(t, Color1, Color2); + if(type == "Hue") + Color = node_mix_hue(t, Color1, Color2); + if(type == "Saturation") + Color = node_mix_sat(t, Color1, Color2); + if(type == "Value") + Color = node_mix_val (t, Color1, Color2); + if(type == "Color") + Color = node_mix_color(t, Color1, Color2); + if(type == "Soft Light") + Color = node_mix_soft(t, Color1, Color2); + if(type == "Linear Light") + Color = node_mix_linear(t, Color1, Color2); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_mix_closure.osl b/intern/cycles/kernel/osl/nodes/node_mix_closure.osl new file mode 100644 index 00000000000..1a377abd381 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_mix_closure.osl @@ -0,0 +1,30 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_mix_closure( + float Fac = 0.5, + closure color Closure1 = background(), + closure color Closure2 = background(), + output closure color Closure = background()) +{ + float t = clamp(Fac, 0.0, 1.0); + Closure = (1.0 - t)*Closure1 + t*Closure2; +} + diff --git a/intern/cycles/kernel/osl/nodes/node_musgrave_texture.osl b/intern/cycles/kernel/osl/nodes/node_musgrave_texture.osl new file mode 100644 index 00000000000..fbd0ce5c3bd --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_musgrave_texture.osl @@ -0,0 +1,218 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" +#include "node_texture.h" + +/* Musgrave fBm + * + * H: fractal increment parameter + * lacunarity: gap between successive frequencies + * octaves: number of frequencies in the fBm + * + * from "Texturing and Modelling: A procedural approach" + */ + +float noise_musgrave_fBm(point p, string basis, float H, float lacunarity, float octaves) +{ + float rmd; + float value = 0.0; + float pwr = 1.0; + float pwHL = pow(lacunarity, -H); + int i; + + for(i = 0; i < (int)octaves; i++) { + value += noise_basis(p, basis) * pwr; + pwr *= pwHL; + p *= lacunarity; + } + + rmd = octaves - floor(octaves); + if(rmd != 0.0) + value += rmd * noise_basis(p, basis) * pwr; + + return value; +} + +/* Musgrave Multifractal + * + * H: highest fractal dimension + * lacunarity: gap between successive frequencies + * octaves: number of frequencies in the fBm + */ + +float noise_musgrave_multi_fractal(point p, string basis, float H, float lacunarity, float octaves) +{ + float rmd; + float value = 1.0; + float pwr = 1.0; + float pwHL = pow(lacunarity, -H); + int i; + + for(i = 0; i < (int)octaves; i++) { + value *= (pwr * noise_basis(p, basis) + 1.0); + pwr *= pwHL; + p *= lacunarity; + } + + rmd = octaves - floor(octaves); + if(rmd != 0.0) + value *= (rmd * pwr * noise_basis(p, basis) + 1.0); /* correct? */ + + return value; +} + +/* Musgrave Heterogeneous Terrain + * + * H: fractal dimension of the roughest area + * lacunarity: gap between successive frequencies + * octaves: number of frequencies in the fBm + * offset: raises the terrain from `sea level' + */ + +float noise_musgrave_hetero_terrain(point p, string basis, float H, float lacunarity, float octaves, float offset) +{ + float value, increment, rmd; + float pwHL = pow(lacunarity, -H); + float pwr = pwHL; + int i; + + /* first unscaled octave of function; later octaves are scaled */ + value = offset + noise_basis(p, basis); + p *= lacunarity; + + for(i = 1; i < (int)octaves; i++) { + increment = (noise_basis(p, basis) + offset) * pwr * value; + value += increment; + pwr *= pwHL; + p *= lacunarity; + } + + rmd = octaves - floor(octaves); + if(rmd != 0.0) { + increment = (noise_basis(p, basis) + offset) * pwr * value; + value += rmd * increment; + } + + return value; +} + +/* Hybrid Additive/Multiplicative Multifractal Terrain + * + * H: fractal dimension of the roughest area + * lacunarity: gap between successive frequencies + * octaves: number of frequencies in the fBm + * offset: raises the terrain from `sea level' + */ + +float noise_musgrave_hybrid_multi_fractal(point p, string basis, float H, float lacunarity, float octaves, float offset, float gain) +{ + float result, signal, weight, rmd; + float pwHL = pow(lacunarity, -H); + float pwr = pwHL; + int i; + + result = noise_basis(p, basis) + offset; + weight = gain * result; + p *= lacunarity; + + for(i = 1; (weight > 0.001) && (i < (int)octaves); i++) { + if(weight > 1.0) + weight = 1.0; + + signal = (noise_basis(p, basis) + offset) * pwr; + pwr *= pwHL; + result += weight * signal; + weight *= gain * signal; + p *= lacunarity; + } + + rmd = octaves - floor(octaves); + if(rmd != 0.0) + result += rmd * ((noise_basis(p, basis) + offset) * pwr); + + return result; +} + +/* Ridged Multifractal Terrain + * + * H: fractal dimension of the roughest area + * lacunarity: gap between successive frequencies + * octaves: number of frequencies in the fBm + * offset: raises the terrain from `sea level' + */ + +float noise_musgrave_ridged_multi_fractal(point p, string basis, float H, float lacunarity, float octaves, float offset, float gain) +{ + float result, signal, weight; + float pwHL = pow(lacunarity, -H); + float pwr = pwHL; + int i; + + signal = offset - fabs(noise_basis(p, basis)); + signal *= signal; + result = signal; + weight = 1.0; + + for(i = 1; i < (int)octaves; i++) { + p *= lacunarity; + weight = clamp(signal * gain, 0.0, 1.0); + signal = offset - fabs(noise_basis(p, basis)); + signal *= signal; + signal *= weight; + result += signal * pwr; + pwr *= pwHL; + } + + return result; +} + +/* Shader */ + +shader node_musgrave_texture( + string Type = "fBM", + string Basis = "Perlin", + float Dimension = 2.0, + float Lacunarity = 1.0, + float Octaves = 2.0, + float Offset = 0.0, + float Intensity = 1.0, + float Gain = 1.0, + float Size = 0.25, + point Vector = P, + output float Fac = 0.0) +{ + float dimension = max(Dimension, 0.0); + float octaves = max(Octaves, 0.0); + float lacunarity = max(Lacunarity, 1e-5); + float size = nonzero(Size, 1e-5); + + point p = Vector/size; + + if(Type == "Multifractal") + Fac = Intensity*noise_musgrave_multi_fractal(p, Basis, dimension, lacunarity, octaves); + else if(Type == "fBM") + Fac = Intensity*noise_musgrave_fBm(p, Basis, dimension, lacunarity, octaves); + else if(Type == "Hybrid Multifractal") + Fac = Intensity*noise_musgrave_hybrid_multi_fractal(p, Basis, dimension, lacunarity, octaves, Offset, Gain); + else if(Type == "Ridged Multifractal") + Fac = Intensity*noise_musgrave_ridged_multi_fractal(p, Basis, dimension, lacunarity, octaves, Offset, Gain); + else if(Type == "Hetero Terrain") + Fac = Intensity*noise_musgrave_hetero_terrain(p, Basis, dimension, lacunarity, octaves, Offset); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_noise_texture.osl b/intern/cycles/kernel/osl/nodes/node_noise_texture.osl new file mode 100644 index 00000000000..193ed67d16e --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_noise_texture.osl @@ -0,0 +1,36 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" +#include "node_texture.h" + +shader node_noise_texture( + point Vector = P, + output color Color = color(0.0, 0.0, 0.0), + output float Fac = 0.0) +{ + point p = Vector*1e8; + + float r = cellnoise(p); + float g = cellnoise(point(p[1], p[0], p[2])); + float b = cellnoise(point(p[1], p[2], p[0])); + + Fac = r; + Color = color(r, g, b); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_output_displacement.osl b/intern/cycles/kernel/osl/nodes/node_output_displacement.osl new file mode 100644 index 00000000000..a6b452c532a --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_output_displacement.osl @@ -0,0 +1,25 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +displacement node_output_displacement(float Displacement = 0.0) +{ + P += N*Displacement*0.1; /* todo: get rid of this factor */ +} + diff --git a/intern/cycles/kernel/osl/nodes/node_output_surface.osl b/intern/cycles/kernel/osl/nodes/node_output_surface.osl new file mode 100644 index 00000000000..6efaf91121b --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_output_surface.osl @@ -0,0 +1,25 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +surface node_output_surface(closure color Surface = background()) +{ + Ci = Surface; +} + diff --git a/intern/cycles/kernel/osl/nodes/node_output_volume.osl b/intern/cycles/kernel/osl/nodes/node_output_volume.osl new file mode 100644 index 00000000000..18094242dc7 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_output_volume.osl @@ -0,0 +1,25 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +volume node_output_volume(closure color Volume = background()) +{ + Ci = Volume; +} + diff --git a/intern/cycles/kernel/osl/nodes/node_sky_texture.osl b/intern/cycles/kernel/osl/nodes/node_sky_texture.osl new file mode 100644 index 00000000000..fdb9b1d9708 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_sky_texture.osl @@ -0,0 +1,162 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +struct KernelSunSky { + /* sun direction in spherical and cartesian */ + float theta, phi; + vector dir; + + /* perez function parameters */ + float zenith_Y, zenith_x, zenith_y; + float perez_Y[5], perez_x[5], perez_y[5]; +}; + +color xyY_to_xyz(float x, float y, float Y) +{ + float X, Z; + + if(y != 0.0) X = (x / y) * Y; + else X = 0.0; + + if(y != 0.0 && Y != 0.0) Z = ((1.0 - x - y) / y) * Y; + else Z = 0.0; + + return color(X, Y, Z); +} + +color xyz_to_rgb(float x, float y, float z) +{ + return color(3.240479 * x + -1.537150 * y + -0.498535 * z, + -0.969256 * x + 1.875991 * y + 0.041556 * z, + 0.055648 * x + -0.204043 * y + 1.057311 * z); +} + +float sky_angle_between(float thetav, float phiv, float theta, float phi) +{ + float cospsi = sin(thetav)*sin(theta)*cos(phi - phiv) + cos(thetav)*cos(theta); + + if(cospsi > 1.0) + return 0.0; + if(cospsi < -1.0) + return M_PI; + + return acos(cospsi); +} + +vector sky_spherical_coordinates(vector dir) +{ + return vector(acos(dir[2]), atan2(dir[0], dir[1]), 0); +} + +float sky_perez_function(float lam[5], float theta, float gamma) +{ + float ctheta = cos(theta); + float cgamma = cos(gamma); + + return (1.0 + lam[0]*exp(lam[1] / ctheta)) * (1.0 + lam[2]*exp(lam[3]*gamma) + lam[4]*cgamma*cgamma); +} + +color sky_xyz_radiance(KernelSunSky sunsky, vector dir) +{ + /* convert vector to spherical coordinates */ + vector spherical = sky_spherical_coordinates(dir); + float theta = spherical[0]; + float phi = spherical[1]; + + /* angle between sun direction and dir */ + float gamma = sky_angle_between(theta, phi, sunsky.theta, sunsky.phi); + + /* clamp theta to horizon */ + theta = min(theta, M_PI_2 - 0.001); + + /* compute xyY color space values */ + float x = sunsky.zenith_x * sky_perez_function(sunsky.perez_x, theta, gamma); + float y = sunsky.zenith_y * sky_perez_function(sunsky.perez_y, theta, gamma); + float Y = sunsky.zenith_Y * sky_perez_function(sunsky.perez_Y, theta, gamma); + + /* convert to RGB */ + color xyz = xyY_to_xyz(x, y, Y); + return xyz_to_rgb(xyz[0], xyz[1], xyz[2]); +} + +void precompute_sunsky(vector dir, float turbidity, output KernelSunSky sunsky) +{ + vector spherical = sky_spherical_coordinates(dir); + float theta = spherical[0]; + float phi = spherical[1]; + + sunsky.theta = theta; + sunsky.phi = phi; + sunsky.dir = dir; + + float theta2 = theta*theta; + float theta3 = theta*theta*theta; + float T = turbidity; + float T2 = T*T; + + float chi = (4.0/ 9.0- T / 120.0) * (M_PI - 2.0* theta); + sunsky.zenith_Y = (4.0453*T - 4.9710) * tan(chi) - 0.2155*T + 2.4192; + sunsky.zenith_Y *= 0.06; + + sunsky.zenith_x = + (0.00166* theta3 - 0.00375* theta2 + 0.00209* theta)*T2 + + (-0.02903* theta3 + 0.06377* theta2 - 0.03202* theta + 0.00394)*T + + (0.11693* theta3 - 0.21196* theta2 + 0.06052* theta + 0.25886); + + sunsky.zenith_y = + (0.00275* theta3 - 0.00610* theta2 + 0.00317* theta)*T2 + + (-0.04214* theta3 + 0.08970* theta2 - 0.04153* theta + 0.00516)*T + + (0.15346* theta3 - 0.26756* theta2 + 0.06670* theta + 0.26688); + + sunsky.perez_Y[0] = (0.1787*T - 1.4630); + sunsky.perez_Y[1] = (-0.3554*T + 0.4275); + sunsky.perez_Y[2] = (-0.0227*T + 5.3251); + sunsky.perez_Y[3] = (0.1206*T - 2.5771); + sunsky.perez_Y[4] = (-0.0670*T + 0.3703); + + sunsky.perez_x[0] = (-0.0193*T - 0.2592); + sunsky.perez_x[1] = (-0.0665*T + 0.0008); + sunsky.perez_x[2] = (-0.0004*T + 0.2125); + sunsky.perez_x[3] = (-0.0641*T - 0.8989); + sunsky.perez_x[4] = (-0.0033*T + 0.0452); + + sunsky.perez_y[0] = (-0.0167*T - 0.2608); + sunsky.perez_y[1] = (-0.0950*T + 0.0092); + sunsky.perez_y[2] = (-0.0079*T + 0.2102); + sunsky.perez_y[3] = (-0.0441*T - 1.6537); + sunsky.perez_y[4] = (-0.0109*T + 0.0529); + + sunsky.zenith_Y /= sky_perez_function(sunsky.perez_Y, 0, theta); + sunsky.zenith_x /= sky_perez_function(sunsky.perez_x, 0, theta); + sunsky.zenith_y /= sky_perez_function(sunsky.perez_y, 0, theta); +} + +shader node_sky_texture( + vector Vector = P, + vector sun_direction = vector(0, 0, 1), + float turbidity = 2.2, + output color Color = color(0.0, 0.0, 0.0)) +{ + KernelSunSky sunsky; + + precompute_sunsky(sun_direction, turbidity, sunsky); + Color = sky_xyz_radiance(sunsky, Vector); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_stucci_texture.osl b/intern/cycles/kernel/osl/nodes/node_stucci_texture.osl new file mode 100644 index 00000000000..f03e03d9a98 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_stucci_texture.osl @@ -0,0 +1,49 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" +#include "node_texture.h" + +/* Stucci */ + +shader node_stucci_texture( + string Type = "Plastic", + string Basis = "Perlin", + int Hard = 0, + float Turbulence = 1.0, + float Size = 0.25, + point Vector = P, + output float Fac = 0.0) +{ + float size = nonzero(Size, 1e-5); + point p = Vector/size; + + float b2 = noise_basis_hard(p, Basis, Hard); + float ofs = Turbulence/200.0; + + if(Type != "Plastic") + ofs *= b2*b2; + + Fac = noise_basis_hard(point(p[0], p[1], p[2]+ofs), Basis, Hard); + + if(Type == "Wall Out") + Fac = 1.0 - Fac; + + Fac = max(Fac, 0.0); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_texture.h b/intern/cycles/kernel/osl/nodes/node_texture.h new file mode 100644 index 00000000000..8adb0e8aeb5 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_texture.h @@ -0,0 +1,251 @@ +/* + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +/* Voronoi Distances */ + +float voronoi_distance(string distance_metric, vector d, float e) +{ + float result = 0.0; + + if(distance_metric == "Distance Squared") + result = dot(d, d); + if(distance_metric == "Actual Distance") + result = length(d); + if(distance_metric == "Manhattan") + result = fabs(d[0]) + fabs(d[1]) + fabs(d[2]); + if(distance_metric == "Chebychev") + result = max(fabs(d[0]), max(fabs(d[1]), fabs(d[2]))); + if(distance_metric == "Minkovsky 1/2") + result = sqrt(fabs(d[0])) + sqrt(fabs(d[1])) + sqrt(fabs(d[1])); + if(distance_metric == "Minkovsky 4") + result = sqrt(sqrt(dot(d*d, d*d))); + if(distance_metric == "Minkovsky") + result = pow(pow(fabs(d[0]), e) + pow(fabs(d[1]), e) + pow(fabs(d[2]), e), 1.0/e); + + return result; +} + +/* Voronoi / Worley like */ + +color cellnoise_color(point p) +{ + float r = cellnoise(p); + float g = cellnoise(point(p[1], p[0], p[2])); + float b = cellnoise(point(p[1], p[2], p[0])); + + return color(r, g, b); +} + +void voronoi(point p, string distance_metric, float e, float da[4], point pa[4]) +{ + /* returns distances in da and point coords in pa */ + int xx, yy, zz, xi, yi, zi; + + xi = (int)floor(p[0]); + yi = (int)floor(p[1]); + zi = (int)floor(p[2]); + + da[0] = 1e10; + da[1] = 1e10; + da[2] = 1e10; + da[3] = 1e10; + + for(xx = xi-1; xx <= xi+1; xx++) { + for(yy = yi-1; yy <= yi+1; yy++) { + for(zz = zi-1; zz <= zi+1; zz++) { + point ip = point(xx, yy, zz); + point vp = (point)cellnoise_color(ip); + point pd = p - (vp + ip); + float d = voronoi_distance(distance_metric, pd, e); + + vp += point(xx, yy, zz); + + if(d < da[0]) { + da[3] = da[2]; + da[2] = da[1]; + da[1] = da[0]; + da[0] = d; + + pa[3] = pa[2]; + pa[2] = pa[1]; + pa[1] = pa[0]; + pa[0] = vp; + } + else if(d < da[1]) { + da[3] = da[2]; + da[2] = da[1]; + da[1] = d; + + pa[3] = pa[2]; + pa[2] = pa[1]; + pa[1] = vp; + } + else if(d < da[2]) { + da[3] = da[2]; + da[2] = d; + + pa[3] = pa[2]; + pa[2] = vp; + } + else if(d < da[3]) { + da[3] = d; + pa[3] = vp; + } + } + } + } +} + +float voronoi_Fn(point p, int n) +{ + float da[4]; + point pa[4]; + + voronoi(p, "Distance Squared", 0, da, pa); + + return da[n]; +} + +float voronoi_FnFn(point p, int n1, int n2) +{ + float da[4]; + point pa[4]; + + voronoi(p, "Distance Squared", 0, da, pa); + + return da[n2] - da[n1]; +} + +float voronoi_F1(point p) { return voronoi_Fn(p, 0); } +float voronoi_F2(point p) { return voronoi_Fn(p, 1); } +float voronoi_F3(point p) { return voronoi_Fn(p, 2); } +float voronoi_F4(point p) { return voronoi_Fn(p, 3); } +float voronoi_F1F2(point p) { return voronoi_FnFn(p, 0, 1); } + +float voronoi_Cr(point p) +{ + /* crackle type pattern, just a scale/clamp of F2-F1 */ + float t = 10.0*voronoi_F1F2(p); + return (t > 1.0)? 1.0: t; +} + +float voronoi_F1S(point p) { return 2.0*voronoi_F1(p) - 1.0; } +float voronoi_F2S(point p) { return 2.0*voronoi_F2(p) - 1.0; } +float voronoi_F3S(point p) { return 2.0*voronoi_F3(p) - 1.0; } +float voronoi_F4S(point p) { return 2.0*voronoi_F4(p) - 1.0; } +float voronoi_F1F2S(point p) { return 2.0*voronoi_F1F2(p) - 1.0; } +float voronoi_CrS(point p) { return 2.0*voronoi_Cr(p) - 1.0; } + +/* Noise Bases */ + +float noise_basis(point p, string basis) +{ + float result = 0.0; + + if(basis == "Perlin") + result = noise(p); + if(basis == "Voronoi F1") + result = voronoi_F1S(p); + if(basis == "Voronoi F2") + result = voronoi_F2S(p); + if(basis == "Voronoi F3") + result = voronoi_F3S(p); + if(basis == "Voronoi F4") + result = voronoi_F4S(p); + if(basis == "Voronoi F2-F1") + result = voronoi_F1F2S(p); + if(basis == "Voronoi Crackle") + result = voronoi_CrS(p); + if(basis == "Cell Noise") + result = cellnoise(p); + + return result; +} + +/* Soft/Hard Noise */ + +float noise_basis_hard(point p, string basis, int hard) +{ + float t = noise_basis(p, basis); + return (hard)? fabs(2.0*t - 1.0): t; +} + +/* Waves */ + +float noise_wave(string wave, float a) +{ + float result = 0.0; + + if(wave == "Sine") { + result = 0.5 + 0.5*sin(a); + } + else if(wave == "Saw") { + float b = 2*M_PI; + int n = (int)(a / b); + a -= n*b; + if(a < 0) a += b; + + result = a / b; + } + else if(wave == "Tri") { + float b = 2*M_PI; + float rmax = 1.0; + + result = rmax - 2.0*fabs(floor((a*(1.0/b))+0.5) - (a*(1.0/b))); + } + + return result; +} + +/* Turbulence */ + +float noise_turbulence(point p, string basis, int octaves, int hard) +{ + float fscale = 1.0; + float amp = 1.0; + float sum = 0.0; + int i; + + for(i = 0; i <= octaves; i++) { + float t = noise_basis(fscale*p, basis); + + if(hard) + t = fabs(2.0*t - 1.0); + + sum += t*amp; + amp *= 0.5; + fscale *= 2.0; + } + + sum *= ((float)(1 << octaves)/(float)((1 << (octaves+1)) - 1)); + + return sum; +} + +/* Utility */ + +float nonzero(float f, float eps) +{ + float r; + + if(abs(f) < eps) + r = sign(f)*eps; + else + r = f; + + return r; +} + diff --git a/intern/cycles/kernel/osl/nodes/node_texture_coordinate.osl b/intern/cycles/kernel/osl/nodes/node_texture_coordinate.osl new file mode 100644 index 00000000000..2acf72aef54 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_texture_coordinate.osl @@ -0,0 +1,66 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_texture_coordinate( + normal Normal = N, + int is_background = 0, + string bump_offset = "center", + + output point Generated = point(0.0, 0.0, 0.0), + output point UV = point(0.0, 0.0, 0.0), + output point Object = point(0.0, 0.0, 0.0), + output point Camera = point(0.0, 0.0, 0.0), + output point Window = point(0.0, 0.0, 0.0), + output point Reflection = point(0.0, 0.0, 0.0)) +{ + if(is_background) { + Generated = P; + UV = point(0.0, 0.0, 0.0); + Object = P; + point Pcam = transform("camera", "world", point(0, 0, 0)); + Camera = transform("camera", P + Pcam); + Window = transform("NDC", P + Pcam); + Reflection = I; + } + else { + getattribute("std::generated", Generated); + getattribute("std::uv", UV); + Object = transform("object", P); + Camera = transform("camera", P); + Window = transform("NDC", P); + Reflection = reflect(I, Normal); + } + + if(bump_offset == "dx") { + Generated += Dx(Generated); + UV += Dx(UV); + Object += Dx(Object); + Camera += Dx(Camera); + Window += Dx(Window); + } + else if(bump_offset == "dy") { + Generated += Dy(Generated); + UV += Dy(UV); + Object += Dy(Object); + Camera += Dy(Camera); + Window += Dy(Window); + } +} + diff --git a/intern/cycles/kernel/osl/nodes/node_translucent_bsdf.osl b/intern/cycles/kernel/osl/nodes/node_translucent_bsdf.osl new file mode 100644 index 00000000000..9acd46756d2 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_translucent_bsdf.osl @@ -0,0 +1,28 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_translucent_bsdf( + color Color = color(0.8, 0.8, 0.8), + normal Normal = N, + output closure color BSDF = diffuse(Normal)) +{ + BSDF = Color*translucent(Normal); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_transparent_bsdf.osl b/intern/cycles/kernel/osl/nodes/node_transparent_bsdf.osl new file mode 100644 index 00000000000..b347bfb116b --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_transparent_bsdf.osl @@ -0,0 +1,28 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_transparent_bsdf( + color Color = color(0.8, 0.8, 0.8), + normal Normal = N, + output closure color BSDF = diffuse(Normal)) +{ + BSDF = Color*transparent(); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_value.osl b/intern/cycles/kernel/osl/nodes/node_value.osl new file mode 100644 index 00000000000..bee6f39f2bc --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_value.osl @@ -0,0 +1,33 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_value( + float value_value = 0.0, + vector vector_value = vector(0.0, 0.0, 0.0), + color color_value = color(0.0, 0.0, 0.0), + output float Value = 0.0, + output vector Vector = vector(0.0, 0.0, 0.0), + output color Color = color(0.0, 0.0, 0.0)) +{ + Value = value_value; + Vector = vector_value; + Color = color_value; +} + diff --git a/intern/cycles/kernel/osl/nodes/node_vector_math.osl b/intern/cycles/kernel/osl/nodes/node_vector_math.osl new file mode 100644 index 00000000000..c6231d4350d --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_vector_math.osl @@ -0,0 +1,53 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_vector_math( + string type = "Add", + vector Vector1 = vector(0.0, 0.0, 0.0), + vector Vector2 = vector(0.0, 0.0, 0.0), + output float Fac = 0.0, + output vector Vector = vector(0.0, 0.0, 0.0)) +{ + if(type == "Add") { + Vector = Vector1 + Vector2; + Fac = (abs(Vector[0]) + abs(Vector[1]) + abs(Vector[2]))/3.0; + } + if(type == "Subtract") { + Vector = Vector1 + Vector2; + Fac = (abs(Vector[0]) + abs(Vector[1]) + abs(Vector[2]))/3.0; + } + if(type == "Average") { + Fac = length(Vector1 + Vector2); + Vector = normalize(Vector1 + Vector2); + } + if(type == "Dot Product") { + Fac = dot(Vector1, Vector2); + } + if(type == "Cross Product") { + vector c = cross(Vector1, Vector2); + Fac = length(c); + Vector = normalize(c); + } + if(type == "Normalize") { + Fac = length(Vector1); + Vector = normalize(Vector1); + } +} + diff --git a/intern/cycles/kernel/osl/nodes/node_velvet_bsdf.osl b/intern/cycles/kernel/osl/nodes/node_velvet_bsdf.osl new file mode 100644 index 00000000000..2b6219f6325 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_velvet_bsdf.osl @@ -0,0 +1,40 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" +#include "node_fresnel.h" + +shader node_velvet_bsdf( + color Color = color(0.8, 0.8, 0.8), + float Sigma = 0.0, + float Fresnel = 0.3, + normal Normal = N, + output closure color BSDF = diffuse(Normal)) +{ + float Fr = 1.0; + + if(Fresnel < 1.0) { + float eta = 1.0/clamp(1.0 - Fresnel, 1e-5, 1.0 - 1e-5); + Fr = fresnel_dielectric(I, Normal, eta); + } + + float sigma = clamp(Sigma, 0.0, 1.0); + + BSDF = (Fr*Color)*ashikhmin_velvet(Normal, sigma); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_voronoi_texture.osl b/intern/cycles/kernel/osl/nodes/node_voronoi_texture.osl new file mode 100644 index 00000000000..140ba6a6ba1 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_voronoi_texture.osl @@ -0,0 +1,82 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" +#include "node_texture.h" + +/* Voronoi */ + +shader node_voronoi_texture( + string DistanceMetric = "Actual Distance", + string Coloring = "Intensity", + float Weight1 = 1.0, + float Weight2 = 0.0, + float Weight3 = 0.0, + float Weight4 = 0.0, + float Exponent = 2.5, + float Intensity = 1.0, + float Size = 0.25, + point Vector = P, + output float Fac = 0.0, + output color Color = color(0.0, 0.0, 0.0)) +{ + float exponent = max(Exponent, 1e-5); + float size = nonzero(Size, 1e-5); + + float aw1 = fabs(Weight1); + float aw2 = fabs(Weight2); + float aw3 = fabs(Weight3); + float aw4 = fabs(Weight4); + float sc = (aw1 + aw2 + aw3 + aw4); + + if(sc != 0.0) + sc = Intensity/sc; + + /* compute distance and point coordinate of 4 nearest neighbours */ + float da[4]; + point pa[4]; + + voronoi(Vector/size, DistanceMetric, exponent, da, pa); + + /* Scalar output */ + Fac = sc * fabs(Weight1*da[0] + Weight2*da[1] + Weight3*da[2] + Weight4*da[3]); + + /* Colored output */ + if(Coloring == "Intensity") { + Color = color(Fac, Fac, Fac); + } + else { + Color = aw1*cellnoise_color(pa[0]); + Color += aw2*cellnoise_color(pa[1]); + Color += aw3*cellnoise_color(pa[2]); + Color += aw4*cellnoise_color(pa[3]); + + if(Coloring != "Position") { + float t1 = min((da[1] - da[0])*10.0, 1.0); + + if(Coloring == "Position, Outline, and Intensity") + Color *= t1*Fac; + else if(Coloring == "Position and Outline") + Color *= t1*sc; + } + else { + Color *= sc; + } + } +} + diff --git a/intern/cycles/kernel/osl/nodes/node_ward_bsdf.osl b/intern/cycles/kernel/osl/nodes/node_ward_bsdf.osl new file mode 100644 index 00000000000..68db07109ed --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_ward_bsdf.osl @@ -0,0 +1,30 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" + +shader node_ward_bsdf( + color Color = color(0.8, 0.8, 0.8), + float RoughnessU = 0.0, + float RoughnessV = 0.0, + normal Normal = N, + output closure color BSDF = diffuse(Normal)) +{ + BSDF = Color*ward(Normal, normalize(dPdu), RoughnessU, RoughnessV); +} + diff --git a/intern/cycles/kernel/osl/nodes/node_wood_texture.osl b/intern/cycles/kernel/osl/nodes/node_wood_texture.osl new file mode 100644 index 00000000000..f1d2e278597 --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/node_wood_texture.osl @@ -0,0 +1,63 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "stdosl.h" +#include "node_texture.h" + +/* Wood */ + +float wood(point p, float size, string type, string wave, string basis, int hard, float turb) +{ + float x = p[0]; + float y = p[1]; + float z = p[2]; + + float result = 0.0; + + if(type == "Bands") { + result = noise_wave(wave, (x + y + z)*10.0); + } + else if(type == "Rings") { + result = noise_wave(wave, sqrt(x*x + y*y + z*z)*20.0); + } + else if (type == "Band Noise") { + float wi = turb*noise_basis_hard(p/size, basis, hard); + result = noise_wave(wave, (x + y + z)*10.0 + wi); + } + else if (type == "Ring Noise") { + float wi = turb*noise_basis_hard(p/size, basis, hard); + result = noise_wave(wave, sqrt(x*x + y*y + z*z)*20.0 + wi); + } + + return result; +} + +shader node_wood_texture( + string Type = "Bands", + string Wave = "Sine", + string Basis = "Perlin", + int Hard = 0, + float Size = 0.25, + float Turbulence = 5.0, + point Vector = P, + output float Fac = 0.0) +{ + float size = nonzero(Size, 1e-5); + Fac = wood(Vector, size, Type, Wave, Basis, Hard, Turbulence); +} + diff --git a/intern/cycles/kernel/osl/nodes/stdosl.h b/intern/cycles/kernel/osl/nodes/stdosl.h new file mode 100644 index 00000000000..6fe4f52df4a --- /dev/null +++ b/intern/cycles/kernel/osl/nodes/stdosl.h @@ -0,0 +1,471 @@ +///////////////////////////////////////////////////////////////////////////// +// Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al. All Rights Reserved. +// +// 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. +///////////////////////////////////////////////////////////////////////////// + + +#ifndef CCL_STDOSL_H +#define CCL_STDOSL_H + + +#ifndef M_PI +#define M_PI 3.1415926535897932 /* pi */ +#define M_PI_2 1.5707963267948966 /* pi/2 */ +#define M_PI_4 0.7853981633974483 /* pi/4 */ +#define M_2_PI 0.6366197723675813 /* 2/pi */ +#define M_2_SQRTPI 1.1283791670955126 /* 2/sqrt(pi) */ +#define M_E 2.7182818284590452 /* e (Euler's number) */ +#define M_LN2 0.6931471805599453 /* ln(2) */ +#define M_LN10 2.3025850929940457 /* ln(10) */ +#define M_LOG2E 1.4426950408889634 /* log_2(e) */ +#define M_LOG10E 0.4342944819032518 /* log_10(e) */ +#define M_SQRT2 1.4142135623730950 /* sqrt(2) */ +#define M_SQRT1_2 0.7071067811865475 /* 1/sqrt(2) */ +#endif + + + +// Declaration of built-in functions and closures +#define BUILTIN [[ int builtin = 1 ]] +#define BUILTIN_DERIV [[ int builtin = 1, int deriv = 1 ]] + +#define PERCOMP1(name) \ + normal name (normal x) BUILTIN; \ + vector name (vector x) BUILTIN; \ + point name (point x) BUILTIN; \ + color name (color x) BUILTIN; \ + float name (float x) BUILTIN; + +#define PERCOMP2(name) \ + normal name (normal x, normal y) BUILTIN; \ + vector name (vector x, vector y) BUILTIN; \ + point name (point x, point y) BUILTIN; \ + color name (color x, color y) BUILTIN; \ + float name (float x, float y) BUILTIN; + +#define PERCOMP2F(name) \ + normal name (normal x, float y) BUILTIN; \ + vector name (vector x, float y) BUILTIN; \ + point name (point x, float y) BUILTIN; \ + color name (color x, float y) BUILTIN; \ + float name (float x, float y) BUILTIN; + + +// Basic math +normal degrees (normal x) { return x*(180.0/M_PI); } +vector degrees (vector x) { return x*(180.0/M_PI); } +point degrees (point x) { return x*(180.0/M_PI); } +color degrees (color x) { return x*(180.0/M_PI); } +float degrees (float x) { return x*(180.0/M_PI); } +normal radians (normal x) { return x*(M_PI/180.0); } +vector radians (vector x) { return x*(M_PI/180.0); } +point radians (point x) { return x*(M_PI/180.0); } +color radians (color x) { return x*(M_PI/180.0); } +float radians (float x) { return x*(M_PI/180.0); } +PERCOMP1 (cos) +PERCOMP1 (sin) +PERCOMP1 (tan) +PERCOMP1 (acos) +PERCOMP1 (asin) +PERCOMP1 (atan) +PERCOMP2 (atan2) +PERCOMP1 (cosh) +PERCOMP1 (sinh) +PERCOMP1 (tanh) +PERCOMP2F (pow) +PERCOMP1 (exp) +PERCOMP1 (exp2) +PERCOMP1 (expm1) +PERCOMP1 (log) +point log (point a, float b) { return log(a)/log(b); } +vector log (vector a, float b) { return log(a)/log(b); } +color log (color a, float b) { return log(a)/log(b); } +float log (float a, float b) { return log(a)/log(b); } +PERCOMP1 (log2) +PERCOMP1 (log10) +PERCOMP1 (logb) +PERCOMP1 (sqrt) +PERCOMP1 (inversesqrt) +float hypot (float a, float b) { return sqrt (a*a + b*b); } +float hypot (float a, float b, float c) { return sqrt (a*a + b*b + c*c); } +PERCOMP1 (abs) +int abs (int x) BUILTIN; +PERCOMP1 (fabs) +int fabs (int x) BUILTIN; +PERCOMP1 (sign) +PERCOMP1 (floor) +PERCOMP1 (ceil) +PERCOMP1 (round) +PERCOMP1 (trunc) +PERCOMP2 (fmod) +PERCOMP2F (fmod) +PERCOMP2 (mod) +PERCOMP2F (mod) +int mod (int x, int y) BUILTIN; +PERCOMP2 (min) +PERCOMP2 (max) +normal clamp (normal x, normal minval, normal maxval) { return max(min(x,maxval),minval); } +vector clamp (vector x, vector minval, vector maxval) { return max(min(x,maxval),minval); } +point clamp (point x, point minval, point maxval) { return max(min(x,maxval),minval); } +color clamp (color x, color minval, color maxval) { return max(min(x,maxval),minval); } +float clamp (float x, float minval, float maxval) { return max(min(x,maxval),minval); } +//normal clamp (normal x, normal minval, normal maxval) BUILTIN; +//vector clamp (vector x, vector minval, vector maxval) BUILTIN; +//point clamp (point x, point minval, point maxval) BUILTIN; +//color clamp (color x, color minval, color maxval) BUILTIN; +//float clamp (float x, float minval, float maxval) BUILTIN; +normal mix (normal x, normal y, normal a) { return x*(1-a) + y*a; } +normal mix (normal x, normal y, float a) { return x*(1-a) + y*a; } +vector mix (vector x, vector y, vector a) { return x*(1-a) + y*a; } +vector mix (vector x, vector y, float a) { return x*(1-a) + y*a; } +point mix (point x, point y, point a) { return x*(1-a) + y*a; } +point mix (point x, point y, float a) { return x*(1-a) + y*a; } +color mix (color x, color y, color a) { return x*(1-a) + y*a; } +color mix (color x, color y, float a) { return x*(1-a) + y*a; } +float mix (float x, float y, float a) { return x*(1-a) + y*a; } +int isnan (float x) BUILTIN; +int isinf (float x) BUILTIN; +int isfinite (float x) BUILTIN; +float erf (float x) BUILTIN; +float erfc (float x) BUILTIN; + +// Vector functions + +vector cross (vector a, vector b) BUILTIN; +float dot (vector a, vector b) BUILTIN; +float length (vector v) BUILTIN; +float distance (point a, point b) BUILTIN; +float distance (point a, point b, point q) BUILTIN; +normal normalize (normal v) BUILTIN; +vector normalize (vector v) BUILTIN; +vector faceforward (vector N, vector I, vector Nref) BUILTIN; +vector faceforward (vector N, vector I) BUILTIN; +vector reflect (vector I, vector N) { return I - 2*dot(N,I)*N; } +vector refract (vector I, vector N, float eta) { + float IdotN = dot (I, N); + float k = 1 - eta*eta * (1 - IdotN*IdotN); + return (k < 0) ? vector(0,0,0) : (eta*I - N * (eta*IdotN + sqrt(k))); +} +void fresnel (vector I, normal N, float eta, + output float Kr, output float Kt, + output vector R, output vector T) +{ + float sqr(float x) { return x*x; } + float c = dot(I, N); + if (c < 0) + c = -c; + R = reflect(I, N); + float g = 1.0 / sqr(eta) - 1.0 + c * c; + if (g >= 0.0) { + g = sqrt (g); + float beta = g - c; + float F = (c * (g+c) - 1.0) / (c * beta + 1.0); + F = 0.5 * (1.0 + sqr(F)); + F *= sqr (beta / (g+c)); + Kr = F; + Kt = (1.0 - Kr) * eta*eta; + // OPT: the following recomputes some of the above values, but it + // gives us the same result as if the shader-writer called refract() + T = refract(I, N, eta); + } else { + // total internal reflection + Kr = 1.0; + Kt = 0.0; + T = vector (0,0,0); + } +#undef sqr +} + +void fresnel (vector I, normal N, float eta, + output float Kr, output float Kt) +{ + vector R, T; + fresnel(I, N, eta, Kr, Kt, R, T); +} + +point rotate (point q, float angle, point a, point b) BUILTIN; + +normal transform (matrix Mto, normal p) BUILTIN; +vector transform (matrix Mto, vector p) BUILTIN; +point transform (matrix Mto, point p) BUILTIN; + +// Implementation of transform-with-named-space in terms of matrices: + +point transform (string tospace, point x) +{ + return transform (matrix ("common", tospace), x); +} + +point transform (string fromspace, string tospace, point x) +{ + return transform (matrix (fromspace, tospace), x); +} + + +vector transform (string tospace, vector x) +{ + return transform (matrix ("common", tospace), x); +} + +vector transform (string fromspace, string tospace, vector x) +{ + return transform (matrix (fromspace, tospace), x); +} + + +normal transform (string tospace, normal x) +{ + return transform (matrix ("common", tospace), x); +} + +normal transform (string fromspace, string tospace, normal x) +{ + return transform (matrix (fromspace, tospace), x); +} + +float transformu (string tounits, float x) BUILTIN; +float transformu (string fromunits, string tounits, float x) BUILTIN; + + +// Color functions + +float luminance (color c) { + return dot ((vector)c, vector(0.2126, 0.7152, 0.0722)); +} + + + +color transformc (string to, color x) +{ + color rgb_to_hsv (color rgb) { // See Foley & van Dam + float r = rgb[0], g = rgb[1], b = rgb[2]; + float mincomp = min (r, min (g, b)); + float maxcomp = max (r, max (g, b)); + float delta = maxcomp - mincomp; // chroma + float h, s, v; + v = maxcomp; + if (maxcomp > 0) + s = delta / maxcomp; + else s = 0; + if (s <= 0) + h = 0; + else { + if (r >= maxcomp) h = (g-b) / delta; + else if (g >= maxcomp) h = 2 + (b-r) / delta; + else h = 4 + (r-g) / delta; + h /= 6; + if (h < 0) + h += 1; + } + return color (h, s, v); + } + + color rgb_to_hsl (color rgb) { // See Foley & van Dam + // First convert rgb to hsv, then to hsl + float minval = min (rgb[0], min (rgb[1], rgb[2])); + color hsv = rgb_to_hsv (rgb); + float maxval = hsv[2]; // v == maxval + float h = hsv[0], s, l = (minval+maxval) / 2; + if (minval == maxval) + s = 0; // special 'achromatic' case, hue is 0 + else if (l <= 0.5) + s = (maxval - minval) / (maxval + minval); + else + s = (maxval - minval) / (2 - maxval - minval); + return color (h, s, l); + } + + color r; + if (to == "rgb" || to == "RGB") + r = x; + else if (to == "hsv") + r = rgb_to_hsv (x); + else if (to == "hsl") + r = rgb_to_hsl (x); + else if (to == "YIQ") + r = color (dot (vector(0.299, 0.587, 0.114), (vector)x), + dot (vector(0.596, -0.275, -0.321), (vector)x), + dot (vector(0.212, -0.523, 0.311), (vector)x)); + else if (to == "xyz") + r = color (dot (vector(0.412453, 0.357580, 0.180423), (vector)x), + dot (vector(0.212671, 0.715160, 0.072169), (vector)x), + dot (vector(0.019334, 0.119193, 0.950227), (vector)x)); + else { + error ("Unknown color space \"%s\"", to); + r = x; + } + return r; +} + + +color transformc (string from, string to, color x) +{ + color hsv_to_rgb (color c) { // Reference: Foley & van Dam + float h = c[0], s = c[1], v = c[2]; + color r; + if (s < 0.0001) { + r = v; + } else { + h = 6 * (h - floor(h)); // expand to [0..6) + int hi = (int)h; + float f = h - hi; + float p = v * (1-s); + float q = v * (1-s*f); + float t = v * (1-s*(1-f)); + if (hi == 0) r = color (v, t, p); + else if (hi == 1) r = color (q, v, p); + else if (hi == 2) r = color (p, v, t); + else if (hi == 3) r = color (p, q, v); + else if (hi == 4) r = color (t, p, v); + else r = color (v, p, q); + } + return r; + } + + color hsl_to_rgb (color c) { + float h = c[0], s = c[1], l = c[2]; + // Easiest to convert hsl -> hsv, then hsv -> RGB (per Foley & van Dam) + float v = (l <= 0.5) ? (l * (1 + s)) : (l * (1 - s) + s); + color r; + if (v <= 0) { + r = 0; + } else { + float min = 2 * l - v; + s = (v - min) / v; + r = hsv_to_rgb (color (h, s, v)); + } + return r; + } + + color r; + if (from == "rgb" || from == "RGB") + r = x; + else if (from == "hsv") + r = hsv_to_rgb (x); + else if (from == "hsl") + r = hsl_to_rgb (x); + else if (from == "YIQ") + r = color (dot (vector(1, 0.9557, 0.6199), (vector)x), + dot (vector(1, -0.2716, -0.6469), (vector)x), + dot (vector(1, -1.1082, 1.7051), (vector)x)); + else if (from == "xyz") + r = color (dot (vector( 3.240479, -1.537150, -0.498535), (vector)x), + dot (vector(-0.969256, 1.875991, 0.041556), (vector)x), + dot (vector( 0.055648, -0.204043, 1.057311), (vector)x)); + else { + error ("Unknown color space \"%s\"", to); + r = x; + } + return transformc (to, r); +} + + + +// Matrix functions + +float determinant (matrix m) BUILTIN; +matrix transpose (matrix m) BUILTIN; + + + +// Pattern generation + +float step (float edge, float x) BUILTIN; +color step (color edge, color x) BUILTIN; +point step (point edge, point x) BUILTIN; +vector step (vector edge, vector x) BUILTIN; +normal step (normal edge, normal x) BUILTIN; +float smoothstep (float edge0, float edge1, float x) BUILTIN; + + +// Derivatives and area operators + + +// Displacement functions + + +// String functions + +int strlen (string s) BUILTIN; +int startswith (string s, string prefix) BUILTIN; +int endswith (string s, string suffix) BUILTIN; +string substr (string s, int start, int len) BUILTIN; +string substr (string s, int start) { return substr (s, start, strlen(s)); } + +// Define concat in terms of shorter concat +string concat (string a, string b, string c) { + return concat(concat(a,b), c); +} +string concat (string a, string b, string c, string d) { + return concat(concat(a,b,c), d); +} +string concat (string a, string b, string c, string d, string e) { + return concat(concat(a,b,c,d), e); +} +string concat (string a, string b, string c, string d, string e, string f) { + return concat(concat(a,b,c,d,e), f); +} + + +// Texture + + +// Closures + +closure color diffuse(normal N) BUILTIN; +closure color translucent(normal N) BUILTIN; +closure color reflection(normal N, float eta) BUILTIN; +closure color reflection(normal N) { return reflection (N, 0.0); } +closure color refraction(normal N, float eta) BUILTIN; +closure color dielectric(normal N, float eta) BUILTIN; +closure color transparent() BUILTIN; +closure color microfacet_ggx(normal N, float ag) BUILTIN; +closure color microfacet_ggx_refraction(normal N, float ag, float eta) BUILTIN; +closure color microfacet_beckmann(normal N, float ab) BUILTIN; +closure color microfacet_beckmann_refraction(normal N, float ab, float eta) BUILTIN; +closure color ward(normal N, vector T,float ax, float ay) BUILTIN; +closure color ashikhmin_velvet(normal N, float sigma) BUILTIN; +closure color westin_backscatter(normal N, float roughness) BUILTIN; +closure color westin_sheen(normal N, float edginess) BUILTIN; +closure color bssrdf_cubic(color radius) BUILTIN; +closure color emission(float inner_angle, float outer_angle) BUILTIN; +closure color emission(float outer_angle) BUILTIN; +closure color emission() BUILTIN; +closure color debug(string tag) BUILTIN; +closure color background() BUILTIN; +closure color holdout() BUILTIN; +closure color subsurface(float eta, float g, float mfp, float albedo) BUILTIN; + +// Renderer state +int raytype (string typename) BUILTIN; + +#undef BUILTIN +#undef BUILTIN_DERIV +#undef PERCOMP1 +#undef PERCOMP2 +#undef PERCOMP2F + +#endif /* CCL_STDOSL_H */ + diff --git a/intern/cycles/kernel/osl/osl_closures.cpp b/intern/cycles/kernel/osl/osl_closures.cpp new file mode 100644 index 00000000000..4c2261942fd --- /dev/null +++ b/intern/cycles/kernel/osl/osl_closures.cpp @@ -0,0 +1,93 @@ +/* + * Adapted from Open Shading Language with this license: + * + * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., closure_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. + */ + +#include <OSL/genclosure.h> +#include <OSL/oslclosure.h> + +#include "osl_closures.h" +#include "osl_shader.h" + +#include "util_debug.h" +#include "util_param.h" + +CCL_NAMESPACE_BEGIN + +static void generic_closure_setup(OSL::RendererServices *, int id, void *data) +{ + assert(data); + OSL::ClosurePrimitive *prim = (OSL::ClosurePrimitive *)data; + prim->setup(); +} + +static bool generic_closure_mergeable(int id, const void *dataA, const void *dataB) +{ + assert(dataA && dataB); + + OSL::ClosurePrimitive *primA = (OSL::ClosurePrimitive *)dataA; + OSL::ClosurePrimitive *primB = (OSL::ClosurePrimitive *)dataB; + return primA->mergeable(primB); +} + +static void register_closure(OSL::ShadingSystem *ss, const char *name, int id, OSL::ClosureParam *params, OSL::PrepareClosureFunc prepare) +{ + int j; + for(j = 0; params[j].type != TypeDesc(); ++j) {} + int size = params[j].offset; + + ss->register_closure(name, id, params, size, prepare, generic_closure_setup, generic_closure_mergeable); +} + +void OSLShader::register_closures(OSL::ShadingSystem *ss) +{ + register_closure(ss, "diffuse", OSL_CLOSURE_BSDF_DIFFUSE_ID, bsdf_diffuse_params, bsdf_diffuse_prepare); + register_closure(ss, "translucent", OSL_CLOSURE_BSDF_TRANSLUCENT_ID, bsdf_translucent_params, bsdf_translucent_prepare); + register_closure(ss, "reflection", OSL_CLOSURE_BSDF_REFLECTION_ID, bsdf_reflection_params, bsdf_reflection_prepare); + register_closure(ss, "refraction", OSL_CLOSURE_BSDF_REFRACTION_ID, bsdf_refraction_params, bsdf_refraction_prepare); + register_closure(ss, "transparent", OSL_CLOSURE_BSDF_TRANSPARENT_ID, bsdf_transparent_params, bsdf_transparent_prepare); + register_closure(ss, "microfacet_ggx", OSL_CLOSURE_BSDF_MICROFACET_GGX_ID, bsdf_microfacet_ggx_params, bsdf_microfacet_ggx_prepare); + register_closure(ss, "microfacet_ggx_refraction", OSL_CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID, bsdf_microfacet_ggx_refraction_params, bsdf_microfacet_ggx_refraction_prepare); + register_closure(ss, "microfacet_beckmann", OSL_CLOSURE_BSDF_MICROFACET_BECKMANN_ID, bsdf_microfacet_beckmann_params, bsdf_microfacet_beckmann_prepare); + register_closure(ss, "microfacet_beckmann_refraction", OSL_CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID, bsdf_microfacet_beckmann_refraction_params, bsdf_microfacet_beckmann_refraction_prepare); + register_closure(ss, "ward", OSL_CLOSURE_BSDF_WARD_ID, bsdf_ward_params, bsdf_ward_prepare); + register_closure(ss, "ashikhmin_velvet", OSL_CLOSURE_BSDF_ASHIKHMIN_VELVET_ID, bsdf_ashikhmin_velvet_params, bsdf_ashikhmin_velvet_prepare); + register_closure(ss, "westin_backscatter", OSL_CLOSURE_BSDF_WESTIN_BACKSCATTER_ID, bsdf_westin_backscatter_params, bsdf_westin_backscatter_prepare); + register_closure(ss, "westin_sheen", OSL_CLOSURE_BSDF_WESTIN_SHEEN_ID, bsdf_westin_sheen_params, bsdf_westin_sheen_prepare); + register_closure(ss, "bssrdf_cubic", OSL_CLOSURE_BSSRDF_CUBIC_ID, closure_bssrdf_cubic_params, closure_bssrdf_cubic_prepare); + register_closure(ss, "emission", OSL_CLOSURE_EMISSION_ID, closure_emission_params, closure_emission_prepare); + register_closure(ss, "debug", OSL_CLOSURE_DEBUG_ID, closure_debug_params, closure_debug_prepare); + register_closure(ss, "background", OSL_CLOSURE_BACKGROUND_ID, closure_background_params, closure_background_prepare); + register_closure(ss, "holdout", OSL_CLOSURE_HOLDOUT_ID, closure_holdout_params, closure_holdout_prepare); + register_closure(ss, "subsurface", OSL_CLOSURE_SUBSURFACE_ID, closure_subsurface_params, closure_subsurface_prepare); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/osl/osl_closures.h b/intern/cycles/kernel/osl/osl_closures.h new file mode 100644 index 00000000000..20a759586b0 --- /dev/null +++ b/intern/cycles/kernel/osl/osl_closures.h @@ -0,0 +1,114 @@ +/* + * 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. + */ + +#ifndef __OSL_CLOSURES_H__ +#define __OSL_CLOSURES_H__ + +#include <OSL/oslclosure.h> +#include <OSL/oslexec.h> +#include <OSL/genclosure.h> + +CCL_NAMESPACE_BEGIN + +enum { + OSL_CLOSURE_BSDF_DIFFUSE_ID, + OSL_CLOSURE_BSDF_TRANSLUCENT_ID, + OSL_CLOSURE_BSDF_REFLECTION_ID, + OSL_CLOSURE_BSDF_REFRACTION_ID, + OSL_CLOSURE_BSDF_TRANSPARENT_ID, + OSL_CLOSURE_BSDF_MICROFACET_GGX_ID, + OSL_CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID, + OSL_CLOSURE_BSDF_MICROFACET_BECKMANN_ID, + OSL_CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID, + OSL_CLOSURE_BSDF_WARD_ID, + OSL_CLOSURE_BSDF_ASHIKHMIN_VELVET_ID, + OSL_CLOSURE_BSDF_WESTIN_BACKSCATTER_ID, + OSL_CLOSURE_BSDF_WESTIN_SHEEN_ID, + OSL_CLOSURE_BSSRDF_CUBIC_ID, + OSL_CLOSURE_EMISSION_ID, + OSL_CLOSURE_DEBUG_ID, + OSL_CLOSURE_BACKGROUND_ID, + OSL_CLOSURE_HOLDOUT_ID, + OSL_CLOSURE_SUBSURFACE_ID +}; + +extern OSL::ClosureParam bsdf_diffuse_params[]; +extern OSL::ClosureParam bsdf_translucent_params[]; +extern OSL::ClosureParam bsdf_reflection_params[]; +extern OSL::ClosureParam bsdf_refraction_params[]; +extern OSL::ClosureParam bsdf_transparent_params[]; +extern OSL::ClosureParam bsdf_microfacet_ggx_params[]; +extern OSL::ClosureParam bsdf_microfacet_ggx_refraction_params[]; +extern OSL::ClosureParam bsdf_microfacet_beckmann_params[]; +extern OSL::ClosureParam bsdf_microfacet_beckmann_refraction_params[]; +extern OSL::ClosureParam bsdf_ward_params[]; +extern OSL::ClosureParam bsdf_ashikhmin_velvet_params[]; +extern OSL::ClosureParam bsdf_westin_backscatter_params[]; +extern OSL::ClosureParam bsdf_westin_sheen_params[]; +extern OSL::ClosureParam closure_bssrdf_cubic_params[]; +extern OSL::ClosureParam closure_emission_params[]; +extern OSL::ClosureParam closure_debug_params[]; +extern OSL::ClosureParam closure_background_params[]; +extern OSL::ClosureParam closure_holdout_params[]; +extern OSL::ClosureParam closure_subsurface_params[]; + +void bsdf_diffuse_prepare(OSL::RendererServices *, int id, void *data); +void bsdf_translucent_prepare(OSL::RendererServices *, int id, void *data); +void bsdf_reflection_prepare(OSL::RendererServices *, int id, void *data); +void bsdf_refraction_prepare(OSL::RendererServices *, int id, void *data); +void bsdf_transparent_prepare(OSL::RendererServices *, int id, void *data); +void bsdf_microfacet_ggx_prepare(OSL::RendererServices *, int id, void *data); +void bsdf_microfacet_ggx_refraction_prepare(OSL::RendererServices *, int id, void *data); +void bsdf_microfacet_beckmann_prepare(OSL::RendererServices *, int id, void *data); +void bsdf_microfacet_beckmann_refraction_prepare(OSL::RendererServices *, int id, void *data); +void bsdf_ward_prepare(OSL::RendererServices *, int id, void *data); +void bsdf_ashikhmin_velvet_prepare(OSL::RendererServices *, int id, void *data); +void bsdf_westin_backscatter_prepare(OSL::RendererServices *, int id, void *data); +void bsdf_westin_sheen_prepare(OSL::RendererServices *, int id, void *data); +void closure_bssrdf_cubic_prepare(OSL::RendererServices *, int id, void *data); +void closure_emission_prepare(OSL::RendererServices *, int id, void *data); +void closure_debug_prepare(OSL::RendererServices *, int id, void *data); +void closure_background_prepare(OSL::RendererServices *, int id, void *data); +void closure_holdout_prepare(OSL::RendererServices *, int id, void *data); +void closure_subsurface_prepare(OSL::RendererServices *, int id, void *data); + +#define CLOSURE_PREPARE(name, classname) \ +void name(RendererServices *, int id, void *data) \ +{ \ + memset(data, 0, sizeof(classname)); \ + new (data) classname(); \ +} + +CCL_NAMESPACE_END + +#endif /* __OSL_CLOSURES_H__ */ + diff --git a/intern/cycles/kernel/osl/osl_globals.h b/intern/cycles/kernel/osl/osl_globals.h new file mode 100644 index 00000000000..90746c385c7 --- /dev/null +++ b/intern/cycles/kernel/osl/osl_globals.h @@ -0,0 +1,74 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __OSL_GLOBALS_H__ +#define __OSL_GLOBALS_H__ + +#ifdef WITH_OSL + +#include <OSL/oslexec.h> + +#include "util_map.h" +#include "util_param.h" +#include "util_thread.h" +#include "util_vector.h" + +CCL_NAMESPACE_BEGIN + +struct OSLGlobals { + /* use */ + bool use; + + /* shading system */ + OSL::ShadingSystem *ss; + + /* shader states */ + vector<OSL::ShadingAttribStateRef> surface_state; + vector<OSL::ShadingAttribStateRef> volume_state; + vector<OSL::ShadingAttribStateRef> displacement_state; + OSL::ShadingAttribStateRef background_state; + + /* attributes */ + struct Attribute { + TypeDesc type; + AttributeElement elem; + int offset; + ParamValue value; + }; + + typedef unordered_map<ustring, Attribute, ustringHash> AttributeMap; + typedef unordered_map<ustring, int, ustringHash> ObjectNameMap; + + vector<AttributeMap> attribute_map; + ObjectNameMap object_name_map; + + /* thread key for thread specific data lookup */ + struct ThreadData { + OSL::ShaderGlobals globals; + void *thread_info; + }; + + static tls_ptr(ThreadData, thread_data); +}; + +CCL_NAMESPACE_END + +#endif + +#endif /* __OSL_GLOBALS_H__ */ + diff --git a/intern/cycles/kernel/osl/osl_services.cpp b/intern/cycles/kernel/osl/osl_services.cpp new file mode 100644 index 00000000000..ded3a68d667 --- /dev/null +++ b/intern/cycles/kernel/osl/osl_services.cpp @@ -0,0 +1,424 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include <string.h> + +#include "mesh.h" +#include "object.h" +#include "scene.h" + +#include "osl_services.h" +#include "osl_shader.h" + +#include "util_foreach.h" +#include "util_string.h" + +#include "kernel_compat_cpu.h" +#include "kernel_globals.h" +#include "kernel_object.h" +#include "kernel_triangle.h" + +CCL_NAMESPACE_BEGIN + +/* RenderServices implementation */ + +#define TO_MATRIX44(m) (*(OSL::Matrix44*)&(m)) + +/* static ustrings */ +ustring OSLRenderServices::u_distance("distance"); +ustring OSLRenderServices::u_index("index"); +ustring OSLRenderServices::u_camera("camera"); +ustring OSLRenderServices::u_screen("screen"); +ustring OSLRenderServices::u_raster("raster"); +ustring OSLRenderServices::u_ndc("NDC"); +ustring OSLRenderServices::u_empty; + +OSLRenderServices::OSLRenderServices() +{ + kernel_globals = NULL; +} + +OSLRenderServices::~OSLRenderServices() +{ +} + +void OSLRenderServices::thread_init(KernelGlobals *kernel_globals_) +{ + kernel_globals = kernel_globals_; +} + +bool OSLRenderServices::get_matrix(OSL::Matrix44 &result, OSL::TransformationPtr xform, float time) +{ + /* this is only used for shader and object space, we don't really have + a concept of shader space, so we just use object space for both. */ + if(xform) { + KernelGlobals *kg = kernel_globals; + const ShaderData *sd = (const ShaderData*)xform; + int object = sd->object; + + if(object != ~0) { + Transform tfm = object_fetch_transform(kg, object, OBJECT_TRANSFORM); + tfm = transform_transpose(tfm); + result = TO_MATRIX44(tfm); + + return true; + } + } + + return false; +} + +bool OSLRenderServices::get_inverse_matrix(OSL::Matrix44 &result, OSL::TransformationPtr xform, float time) +{ + /* this is only used for shader and object space, we don't really have + a concept of shader space, so we just use object space for both. */ + if(xform) { + KernelGlobals *kg = kernel_globals; + const ShaderData *sd = (const ShaderData*)xform; + int object = sd->object; + + if(object != ~0) { + Transform tfm = object_fetch_transform(kg, object, OBJECT_INVERSE_TRANSFORM); + tfm = transform_transpose(tfm); + result = TO_MATRIX44(tfm); + + return true; + } + } + + return false; +} + +bool OSLRenderServices::get_matrix(OSL::Matrix44 &result, ustring from, float time) +{ + KernelGlobals *kg = kernel_globals; + + if(from == u_ndc) { + Transform tfm = transform_transpose(kernel_data.cam.ndctoworld); + result = TO_MATRIX44(tfm); + return true; + } + else if(from == u_raster) { + Transform tfm = transform_transpose(kernel_data.cam.rastertoworld); + result = TO_MATRIX44(tfm); + return true; + } + else if(from == u_screen) { + Transform tfm = transform_transpose(kernel_data.cam.screentoworld); + result = TO_MATRIX44(tfm); + return true; + } + else if(from == u_camera) { + Transform tfm = transform_transpose(kernel_data.cam.cameratoworld); + result = TO_MATRIX44(tfm); + return true; + } + + return false; +} + +bool OSLRenderServices::get_inverse_matrix(OSL::Matrix44 &result, ustring to, float time) +{ + KernelGlobals *kg = kernel_globals; + + if(to == u_ndc) { + Transform tfm = transform_transpose(kernel_data.cam.worldtondc); + result = TO_MATRIX44(tfm); + return true; + } + else if(to == u_raster) { + Transform tfm = transform_transpose(kernel_data.cam.worldtoraster); + result = TO_MATRIX44(tfm); + return true; + } + else if(to == u_screen) { + Transform tfm = transform_transpose(kernel_data.cam.worldtoscreen); + result = TO_MATRIX44(tfm); + return true; + } + else if(to == u_camera) { + Transform tfm = transform_transpose(kernel_data.cam.worldtocamera); + result = TO_MATRIX44(tfm); + return true; + } + + return false; +} + +bool OSLRenderServices::get_array_attribute(void *renderstate, bool derivatives, + ustring object, TypeDesc type, ustring name, + int index, void *val) +{ + return false; +} + +static bool get_mesh_attribute(KernelGlobals *kg, const ShaderData *sd, + const OSLGlobals::Attribute& attr, bool derivatives, void *val) +{ + if(attr.type == TypeDesc::TypeFloat) { + float *fval = (float*)val; + fval[0] = triangle_attribute_float(kg, sd, attr.elem, attr.offset, + (derivatives)? &fval[1]: NULL, (derivatives)? &fval[2]: NULL); + } + else { + float3 *fval = (float3*)val; + fval[0] = triangle_attribute_float3(kg, sd, attr.elem, attr.offset, + (derivatives)? &fval[1]: NULL, (derivatives)? &fval[2]: NULL); + } + + return true; +} + +static bool get_mesh_attribute_convert(KernelGlobals *kg, const ShaderData *sd, + const OSLGlobals::Attribute& attr, const TypeDesc& type, bool derivatives, void *val) +{ + if(attr.type == TypeDesc::TypeFloat) { + float tmp[3]; + float3 *fval = (float3*)val; + + get_mesh_attribute(kg, sd, attr, derivatives, tmp); + + fval[0] = make_float3(tmp[0], tmp[0], tmp[0]); + if(derivatives) { + fval[1] = make_float3(tmp[1], tmp[1], tmp[1]); + fval[2] = make_float3(tmp[2], tmp[2], tmp[2]); + } + + return true; + } + else if(attr.type == TypeDesc::TypePoint || attr.type == TypeDesc::TypeVector || + attr.type == TypeDesc::TypeNormal || attr.type == TypeDesc::TypeColor) { + float3 tmp[3]; + float *fval = (float*)val; + + get_mesh_attribute(kg, sd, attr, derivatives, tmp); + + fval[0] = average(tmp[0]); + if(derivatives) { + fval[1] = average(tmp[1]); + fval[2] = average(tmp[2]); + } + + return true; + } + else + return false; +} + +static void get_object_attribute(const OSLGlobals::Attribute& attr, bool derivatives, void *val) +{ + size_t datasize = attr.value.datasize(); + + memcpy(val, attr.value.data(), datasize); + if(derivatives) + memset((char*)val + datasize, 0, datasize*2); +} + +bool OSLRenderServices::get_attribute(void *renderstate, bool derivatives, ustring object_name, + TypeDesc type, ustring name, void *val) +{ + KernelGlobals *kg = kernel_globals; + const ShaderData *sd = (const ShaderData*)renderstate; + int object = sd->object; + int tri = sd->prim; + + /* lookup of attribute on another object */ + if(object_name != u_empty) { + OSLGlobals::ObjectNameMap::iterator it = kg->osl.object_name_map.find(object_name); + + if(it == kg->osl.object_name_map.end()) + return false; + + object = it->second; + tri = ~0; + } + else if(object == ~0) { + /* no background attributes supported */ + return false; + } + + /* find attribute on object */ + OSLGlobals::AttributeMap& attribute_map = kg->osl.attribute_map[object]; + OSLGlobals::AttributeMap::iterator it = attribute_map.find(name); + + if(it == attribute_map.end()) + return false; + + /* type mistmatch? */ + const OSLGlobals::Attribute& attr = it->second; + + if(attr.elem != ATTR_ELEMENT_VALUE) { + /* triangle and vertex attributes */ + if(tri != ~0) { + if(attr.type == type || (attr.type == TypeDesc::TypeColor && + (type == TypeDesc::TypePoint || type == TypeDesc::TypeVector || type == TypeDesc::TypeNormal))) + return get_mesh_attribute(kg, sd, attr, derivatives, val); + else + return get_mesh_attribute_convert(kg, sd, attr, type, derivatives, val); + } + } + else { + /* object attribute */ + get_object_attribute(attr, derivatives, val); + return true; + } + + return false; +} + +bool OSLRenderServices::get_userdata(bool derivatives, ustring name, TypeDesc type, + void *renderstate, void *val) +{ + return false; /* disabled by lockgeom */ +} + +bool OSLRenderServices::has_userdata(ustring name, TypeDesc type, void *renderstate) +{ + return false; /* never called by OSL */ +} + +void *OSLRenderServices::get_pointcloud_attr_query(ustring *attr_names, + TypeDesc *attr_types, int nattrs) +{ +#ifdef WITH_PARTIO + m_attr_queries.push_back(AttrQuery()); + AttrQuery &query = m_attr_queries.back(); + + /* make space for what we need. the only reason to use + std::vector is to skip the delete */ + query.attr_names.resize(nattrs); + query.attr_partio_types.resize(nattrs); + /* capacity will keep the length of the smallest array passed + to the query. Just to prevent buffer overruns */ + query.capacity = -1; + + for(int i = 0; i < nattrs; ++i) + { + query.attr_names[i] = attr_names[i]; + + TypeDesc element_type = attr_types[i].elementtype (); + + if(query.capacity < 0) + query.capacity = attr_types[i].numelements(); + else + query.capacity = min(query.capacity, (int)attr_types[i].numelements()); + + /* convert the OSL (OIIO) type to the equivalent Partio type so + we can do a fast check at query time. */ + if(element_type == TypeDesc::TypeFloat) + query.attr_partio_types[i] = Partio::FLOAT; + else if(element_type == TypeDesc::TypeInt) + query.attr_partio_types[i] = Partio::INT; + else if(element_type == TypeDesc::TypeColor || element_type == TypeDesc::TypePoint || + element_type == TypeDesc::TypeVector || element_type == TypeDesc::TypeNormal) + query.attr_partio_types[i] = Partio::VECTOR; + else + return NULL; /* report some error of unknown type */ + } + + /* this is valid until the end of RenderServices */ + return &query; +#else + return NULL; +#endif +} + +#ifdef WITH_PARTIO +Partio::ParticlesData *OSLRenderServices::get_pointcloud(ustring filename) +{ + return Partio::readCached(filename.c_str(), true); +} + +#endif + +int OSLRenderServices::pointcloud(ustring filename, const OSL::Vec3 ¢er, float radius, + int max_points, void *_attr_query, void **attr_outdata) +{ + /* todo: this code has never been tested, and most likely does not + work. it's based on the example code in OSL */ + +#ifdef WITH_PARTIO + /* query Partio for this pointcloud lookup using cached attr_query */ + if(!_attr_query) + return 0; + + AttrQuery *attr_query = (AttrQuery *)_attr_query; + if(attr_query->capacity < max_points) + return 0; + + /* get the pointcloud entry for the given filename */ + Partio::ParticlesData *cloud = get_pointcloud(filename); + + /* now we have to look up all the attributes in the file. we can't do this + before hand cause we never know what we are going to load. */ + int nattrs = attr_query->attr_names.size(); + Partio::ParticleAttribute *attr = (Partio::ParticleAttribute *)alloca(sizeof(Partio::ParticleAttribute) * nattrs); + + for(int i = 0; i < nattrs; ++i) { + /* special case attributes */ + if(attr_query->attr_names[i] == u_distance || attr_query->attr_names[i] == u_index) + continue; + + /* lookup the attribute by name*/ + if(!cloud->attributeInfo(attr_query->attr_names[i].c_str(), attr[i])) { + /* issue an error here and return, types don't match */ + Partio::endCachedAccess(cloud); + cloud->release(); + return 0; + } + } + + std::vector<Partio::ParticleIndex> indices; + std::vector<float> dist2; + + Partio::beginCachedAccess(cloud); + + /* finally, do the lookup */ + cloud->findNPoints((const float *)¢er, max_points, radius, indices, dist2); + int count = indices.size(); + + /* retrieve the attributes directly to user space */ + for(int j = 0; j < nattrs; ++j) { + /* special cases */ + if(attr_query->attr_names[j] == u_distance) { + for(int i = 0; i < count; ++i) + ((float *)attr_outdata[j])[i] = sqrtf(dist2[i]); + } + else if(attr_query->attr_names[j] == u_index) { + for(int i = 0; i < count; ++i) + ((int *)attr_outdata[j])[i] = indices[i]; + } + else { + /* note we make a single call per attribute, we don't loop over the + points. Partio does it, so it is there that we have to care about + performance */ + cloud->data(attr[j], count, &indices[0], true, attr_outdata[j]); + } + } + + Partio::endCachedAccess(cloud); + cloud->release(); + + return count; +#else + return 0; +#endif +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/osl/osl_services.h b/intern/cycles/kernel/osl/osl_services.h new file mode 100644 index 00000000000..e5003074822 --- /dev/null +++ b/intern/cycles/kernel/osl/osl_services.h @@ -0,0 +1,111 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __OSL_SERVICES_H__ +#define __OSL_SERVICES_H__ + +/* OSL Render Services + * + * Implementation of OSL render services, to retriever matrices, attributes, + * textures and point clouds. In principle this should only be accessing + * kernel data, but currently we also reach back into the Scene to retrieve + * attributes. + */ + +#include <OSL/oslexec.h> +#include <OSL/oslclosure.h> + +#ifdef WITH_PARTIO +#include <Partio.h> +#endif + +CCL_NAMESPACE_BEGIN + +class Object; +class Scene; +class Shader; +class ShaderData; +class float3; +class KernelGlobals; + +class OSLRenderServices : public OSL::RendererServices +{ +public: + OSLRenderServices(); + ~OSLRenderServices(); + + void thread_init(KernelGlobals *kernel_globals); + + bool get_matrix(OSL::Matrix44 &result, OSL::TransformationPtr xform, float time); + bool get_inverse_matrix(OSL::Matrix44 &result, OSL::TransformationPtr xform, float time); + bool get_matrix(OSL::Matrix44 &result, ustring from, float time); + bool get_inverse_matrix(OSL::Matrix44 &result, ustring to, float time); + + bool get_array_attribute(void *renderstate, bool derivatives, + ustring object, TypeDesc type, ustring name, + int index, void *val); + bool get_attribute(void *renderstate, bool derivatives, ustring object, + TypeDesc type, ustring name, void *val); + + bool get_userdata(bool derivatives, ustring name, TypeDesc type, + void *renderstate, void *val); + bool has_userdata(ustring name, TypeDesc type, void *renderstate); + + void *get_pointcloud_attr_query(ustring *attr_names, + TypeDesc *attr_types, int nattrs); + int pointcloud(ustring filename, const OSL::Vec3 ¢er, float radius, + int max_points, void *attr_query, void **attr_outdata); + +private: + KernelGlobals *kernel_globals; + +#ifdef WITH_PARTIO + /* OSL gets pointers to this but its definition is private. + right now it only caches the types already converted to + Partio constants. this is what get_pointcloud_attr_query + returns */ + struct AttrQuery + { + /* names of the attributes to query */ + std::vector<ustring> attr_names; + /* types as (enum Partio::ParticleAttributeType) of the + attributes in the query */ + std::vector<int> attr_partio_types; + /* for sanity checks, capacity of the output arrays */ + int capacity; + }; + + Partio::ParticlesData *get_pointcloud(ustring filename); + + /* keep a list so adding elements doesn't invalidate pointers */ + std::list<AttrQuery> m_attr_queries; +#endif + + static ustring u_distance; + static ustring u_index; + static ustring u_camera; + static ustring u_screen; + static ustring u_raster; + static ustring u_ndc; + static ustring u_empty; +}; + +CCL_NAMESPACE_END + +#endif /* __OSL_SERVICES_H__ */ + diff --git a/intern/cycles/kernel/osl/osl_shader.cpp b/intern/cycles/kernel/osl/osl_shader.cpp new file mode 100644 index 00000000000..f4ae0248bef --- /dev/null +++ b/intern/cycles/kernel/osl/osl_shader.cpp @@ -0,0 +1,559 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "kernel_compat_cpu.h" +#include "kernel_types.h" +#include "kernel_globals.h" +#include "kernel_object.h" + +#include "osl_services.h" +#include "osl_shader.h" + +#include "util_foreach.h" + +#include <OSL/oslexec.h> +#include <oslexec_pvt.h> + +CCL_NAMESPACE_BEGIN + +tls_ptr(ThreadData, OSLGlobals::thread_data); + +/* Threads */ + +void OSLShader::thread_init(KernelGlobals *kg) +{ + OSL::pvt::ShadingSystemImpl *ssi = (OSL::pvt::ShadingSystemImpl*)kg->osl.ss; + + OSLGlobals::ThreadData *tdata = new OSLGlobals::ThreadData(); + + memset(&tdata->globals, 0, sizeof(OSL::ShaderGlobals)); + tdata->thread_info = ssi->create_thread_info(); + + tls_set(kg->osl.thread_data, tdata); + + ((OSLRenderServices*)ssi->renderer())->thread_init(kg); +} + +void OSLShader::thread_free(KernelGlobals *kg) +{ + OSL::pvt::ShadingSystemImpl *ssi = (OSL::pvt::ShadingSystemImpl*)kg->osl.ss; + + OSLGlobals::ThreadData *tdata = tls_get(OSLGlobals::ThreadData, kg->osl.thread_data); + + ssi->destroy_thread_info(tdata->thread_info); + + delete tdata; +} + +/* Globals */ + +#define TO_VEC3(v) (*(OSL::Vec3*)&(v)) +#define TO_COLOR3(v) (*(OSL::Color3*)&(v)) +#define TO_FLOAT3(v) make_float3(v[0], v[1], v[2]) + +static void shaderdata_to_shaderglobals(KernelGlobals *kg, ShaderData *sd, + int path_flag, OSL::ShaderGlobals *globals) +{ + /* copy from shader data to shader globals */ + globals->P = TO_VEC3(sd->P); + globals->dPdx = TO_VEC3(sd->dP.dx); + globals->dPdy = TO_VEC3(sd->dP.dy); + globals->I = TO_VEC3(sd->I); + globals->dIdx = TO_VEC3(sd->dI.dx); + globals->dIdy = TO_VEC3(sd->dI.dy); + globals->N = TO_VEC3(sd->N); + globals->Ng = TO_VEC3(sd->Ng); + globals->u = sd->u; + globals->dudx = sd->du.dx; + globals->dudy = sd->du.dy; + globals->v = sd->v; + globals->dvdx = sd->dv.dx; + globals->dvdy = sd->dv.dy; + globals->dPdu = TO_VEC3(sd->dPdu); + globals->dPdv = TO_VEC3(sd->dPdv); + globals->surfacearea = (sd->object == ~0)? 1.0f: object_surface_area(kg, sd->object); + + /* booleans */ + globals->raytype = path_flag; + globals->backfacing = (sd->flag & SD_BACKFACING); + + /* don't know yet if we need this */ + globals->flipHandedness = false; + + /* shader data to be used in services callbacks */ + globals->renderstate = sd; + + /* hacky, we leave it to services to fetch actual object matrix */ + globals->shader2common = sd; + globals->object2common = sd; + + /* must be set to NULL before execute */ + globals->Ci = NULL; +} + +/* Surface */ + +static void flatten_surface_closure_tree(ShaderData *sd, bool no_glossy, + const OSL::ClosureColor *closure, float3 weight = make_float3(1.0f, 1.0f, 1.0f)) +{ + /* OSL gives use a closure tree, we flatten it into arrays per + * closure type, for evaluation, sampling, etc later on. */ + + if(closure->type == OSL::ClosureColor::COMPONENT) { + OSL::ClosureComponent *comp = (OSL::ClosureComponent*)closure; + OSL::ClosurePrimitive *prim = (OSL::ClosurePrimitive*)comp->data(); + + if(prim) { + FlatClosure flat; + flat.prim = prim; + flat.weight = weight; + + switch(prim->category()) { + case ClosurePrimitive::BSDF: { + if(sd->osl_closure.num_bsdf == MAX_OSL_CLOSURE) + return; + + OSL::BSDFClosure *bsdf = (OSL::BSDFClosure*)prim; + ustring scattering = bsdf->scattering(); + + /* no caustics option */ + if(no_glossy && scattering == OSL::Labels::GLOSSY) + return; + + /* sample weight */ + float albedo = bsdf->albedo(TO_VEC3(sd->I)); + float sample_weight = fabsf(average(weight))*albedo; + float sample_sum = sd->osl_closure.bsdf_sample_sum + sample_weight; + + flat.sample_weight = sample_weight; + sd->osl_closure.bsdf_sample_sum = sample_sum; + + /* scattering flags */ + if(scattering == OSL::Labels::DIFFUSE) + sd->flag |= SD_BSDF_HAS_EVAL; + else if(scattering == OSL::Labels::GLOSSY) + sd->flag |= SD_BSDF_HAS_EVAL|SD_BSDF_GLOSSY; + + /* add */ + sd->osl_closure.bsdf[sd->osl_closure.num_bsdf++] = flat; + break; + } + case ClosurePrimitive::Emissive: { + if(sd->osl_closure.num_bsdf == MAX_OSL_CLOSURE) + return; + + /* sample weight */ + float sample_weight = fabsf(average(weight)); + float sample_sum = sd->osl_closure.emissive_sample_sum + sample_weight; + + flat.sample_weight = sample_weight; + sd->osl_closure.emissive_sample_sum = sample_sum; + + /* flag */ + sd->flag |= SD_EMISSION; + + sd->osl_closure.emissive[sd->osl_closure.num_emissive++] = flat; + break; + } + case ClosurePrimitive::BSSRDF: + case ClosurePrimitive::Holdout: + case ClosurePrimitive::Debug: + break; /* not implemented */ + case ClosurePrimitive::Background: + case ClosurePrimitive::Volume: + break; /* not relevant */ + } + } + } + else if(closure->type == OSL::ClosureColor::MUL) { + OSL::ClosureMul *mul = (OSL::ClosureMul*)closure; + flatten_surface_closure_tree(sd, no_glossy, mul->closure, TO_FLOAT3(mul->weight) * weight); + } + else if(closure->type == OSL::ClosureColor::ADD) { + OSL::ClosureAdd *add = (OSL::ClosureAdd*)closure; + flatten_surface_closure_tree(sd, no_glossy, add->closureA, weight); + flatten_surface_closure_tree(sd, no_glossy, add->closureB, weight); + } +} + +void OSLShader::eval_surface(KernelGlobals *kg, ShaderData *sd, float randb, int path_flag) +{ + /* gather pointers */ + OSL::pvt::ShadingSystemImpl *ssi = (OSL::pvt::ShadingSystemImpl*)kg->osl.ss; + OSLGlobals::ThreadData *tdata = tls_get(OSLGlobals::ThreadData, kg->osl.thread_data); + OSL::ShaderGlobals *globals = &tdata->globals; + OSL::pvt::ShadingContext *ctx = ssi->get_context(tdata->thread_info); + + /* setup shader globals from shader data */ + sd->osl_ctx = ctx; + shaderdata_to_shaderglobals(kg, sd, path_flag, globals); + + /* execute shader for this point */ + if(kg->osl.surface_state[sd->shader]) + ctx->execute(OSL::pvt::ShadUseSurface, *(kg->osl.surface_state[sd->shader]), *globals); + + /* flatten closure tree */ + sd->osl_closure.bsdf_sample_sum = 0.0f; + sd->osl_closure.emissive_sample_sum = 0.0f; + sd->osl_closure.num_bsdf = 0; + sd->osl_closure.num_emissive = 0; + sd->osl_closure.randb = randb; + + if(globals->Ci) { + bool no_glossy = (path_flag & PATH_RAY_DIFFUSE) && kernel_data.integrator.no_caustics; + flatten_surface_closure_tree(sd, no_glossy, globals->Ci); + } +} + +/* Background */ + +static float3 flatten_background_closure_tree(const OSL::ClosureColor *closure) +{ + /* OSL gives use a closure tree, if we are shading for background there + * is only one supported closure type at the moment, which has no evaluation + * functions, so we just sum the weights */ + + if(closure->type == OSL::ClosureColor::COMPONENT) { + OSL::ClosureComponent *comp = (OSL::ClosureComponent*)closure; + OSL::ClosurePrimitive *prim = (OSL::ClosurePrimitive*)comp->data(); + + if(prim && prim->category() == OSL::ClosurePrimitive::Background) + return make_float3(1.0f, 1.0f, 1.0f); + } + else if(closure->type == OSL::ClosureColor::MUL) { + OSL::ClosureMul *mul = (OSL::ClosureMul*)closure; + + return TO_FLOAT3(mul->weight) * flatten_background_closure_tree(mul->closure); + } + else if(closure->type == OSL::ClosureColor::ADD) { + OSL::ClosureAdd *add = (OSL::ClosureAdd*)closure; + + return flatten_background_closure_tree(add->closureA) + + flatten_background_closure_tree(add->closureB); + } + + return make_float3(0.0f, 0.0f, 0.0f); +} + +float3 OSLShader::eval_background(KernelGlobals *kg, ShaderData *sd, int path_flag) +{ + /* gather pointers */ + OSL::pvt::ShadingSystemImpl *ssi = (OSL::pvt::ShadingSystemImpl*)kg->osl.ss; + OSLGlobals::ThreadData *tdata = tls_get(OSLGlobals::ThreadData, kg->osl.thread_data); + OSL::ShaderGlobals *globals = &tdata->globals; + OSL::pvt::ShadingContext *ctx = ssi->get_context(tdata->thread_info); + + /* setup shader globals from shader data */ + sd->osl_ctx = ctx; + shaderdata_to_shaderglobals(kg, sd, path_flag, globals); + + /* execute shader for this point */ + if(kg->osl.background_state) + ctx->execute(OSL::pvt::ShadUseSurface, *kg->osl.background_state, *globals); + + /* return background color immediately */ + if(globals->Ci) + return flatten_background_closure_tree(globals->Ci); + + return make_float3(0.0f, 0.0f, 0.0f); +} + +/* Volume */ + +static void flatten_volume_closure_tree(ShaderData *sd, + const OSL::ClosureColor *closure, float3 weight = make_float3(1.0f, 1.0f, 1.0f)) +{ + /* OSL gives use a closure tree, we flatten it into arrays per + * closure type, for evaluation, sampling, etc later on. */ + + if(closure->type == OSL::ClosureColor::COMPONENT) { + OSL::ClosureComponent *comp = (OSL::ClosureComponent*)closure; + OSL::ClosurePrimitive *prim = (OSL::ClosurePrimitive*)comp->data(); + + if(prim) { + FlatClosure flat; + flat.prim = prim; + flat.weight = weight; + + switch(prim->category()) { + case ClosurePrimitive::Volume: { + if(sd->osl_closure.num_bsdf == MAX_OSL_CLOSURE) + return; + + /* sample weight */ + float sample_weight = fabsf(average(weight)); + float sample_sum = sd->osl_closure.volume_sample_sum + sample_weight; + + flat.sample_weight = sample_weight; + sd->osl_closure.volume_sample_sum = sample_sum; + + /* add */ + sd->osl_closure.volume[sd->osl_closure.num_volume++] = flat; + break; + } + case ClosurePrimitive::Holdout: + case ClosurePrimitive::Debug: + break; /* not implemented */ + case ClosurePrimitive::Background: + case ClosurePrimitive::BSDF: + case ClosurePrimitive::Emissive: + case ClosurePrimitive::BSSRDF: + break; /* not relevant */ + } + } + } + else if(closure->type == OSL::ClosureColor::MUL) { + OSL::ClosureMul *mul = (OSL::ClosureMul*)closure; + flatten_volume_closure_tree(sd, mul->closure, TO_FLOAT3(mul->weight) * weight); + } + else if(closure->type == OSL::ClosureColor::ADD) { + OSL::ClosureAdd *add = (OSL::ClosureAdd*)closure; + flatten_volume_closure_tree(sd, add->closureA, weight); + flatten_volume_closure_tree(sd, add->closureB, weight); + } +} + +void OSLShader::eval_volume(KernelGlobals *kg, ShaderData *sd, float randb, int path_flag) +{ + /* gather pointers */ + OSL::pvt::ShadingSystemImpl *ssi = (OSL::pvt::ShadingSystemImpl*)kg->osl.ss; + OSLGlobals::ThreadData *tdata = tls_get(OSLGlobals::ThreadData, kg->osl.thread_data); + OSL::ShaderGlobals *globals = &tdata->globals; + OSL::pvt::ShadingContext *ctx = ssi->get_context(tdata->thread_info); + + /* setup shader globals from shader data */ + sd->osl_ctx = ctx; + shaderdata_to_shaderglobals(kg, sd, path_flag, globals); + + /* execute shader */ + ctx->execute(OSL::pvt::ShadUseSurface, *(kg->osl.volume_state[sd->shader]), *globals); + + /* retrieve resulting closures */ + sd->osl_closure.volume_sample_sum = 0.0f; + sd->osl_closure.num_volume = 0; + sd->osl_closure.randb = randb; + + if(globals->Ci) + flatten_volume_closure_tree(sd, globals->Ci); +} + +/* Displacement */ + +void OSLShader::eval_displacement(KernelGlobals *kg, ShaderData *sd) +{ + /* gather pointers */ + OSL::pvt::ShadingSystemImpl *ssi = (OSL::pvt::ShadingSystemImpl*)kg->osl.ss; + OSLGlobals::ThreadData *tdata = tls_get(OSLGlobals::ThreadData, kg->osl.thread_data); + OSL::ShaderGlobals *globals = &tdata->globals; + OSL::pvt::ShadingContext *ctx = ssi->get_context(tdata->thread_info); + + /* setup shader globals from shader data */ + sd->osl_ctx = ctx; + shaderdata_to_shaderglobals(kg, sd, 0, globals); + + /* execute shader */ + ctx->execute(OSL::pvt::ShadUseSurface, *(kg->osl.displacement_state[sd->shader]), *globals); + + /* get back position */ + sd->P = TO_FLOAT3(globals->P); +} + +void OSLShader::release(KernelGlobals *kg, const ShaderData *sd) +{ + OSL::pvt::ShadingSystemImpl *ssi = (OSL::pvt::ShadingSystemImpl*)kg->osl.ss; + OSLGlobals::ThreadData *tdata = tls_get(OSLGlobals::ThreadData, kg->osl.thread_data); + + ssi->release_context((OSL::pvt::ShadingContext*)sd->osl_ctx, tdata->thread_info); +} + +/* BSDF Closure */ + +int OSLShader::bsdf_sample(const ShaderData *sd, float randu, float randv, float3& eval, float3& omega_in, differential3& domega_in, float& pdf) +{ + OSL::BSDFClosure *sample_bsdf = NULL; + int label = LABEL_NONE; + float r = sd->osl_closure.randb*sd->osl_closure.bsdf_sample_sum; + float sample_sum = 0.0f; + + pdf = 0.0f; + + if(sd->osl_closure.bsdf_sample_sum == 0.0f) + return LABEL_NONE; + + /* find a closure to sample */ + for(int i = 0; i < sd->osl_closure.num_bsdf; i++) { + const FlatClosure *flat = &sd->osl_closure.bsdf[i]; + sample_sum += flat->sample_weight; + + if(r > sample_sum) + continue; + + /* sample BSDF closure */ + sample_bsdf = (OSL::BSDFClosure*)flat->prim; + ustring ulabel; + + ulabel = sample_bsdf->sample(TO_VEC3(sd->Ng), + TO_VEC3(sd->I), TO_VEC3(sd->dI.dx), TO_VEC3(sd->dI.dy), + randu, randv, + TO_VEC3(omega_in), TO_VEC3(domega_in.dx), TO_VEC3(domega_in.dy), + pdf, TO_COLOR3(eval)); + + /* convert OSL label */ + if(ulabel == OSL::Labels::REFLECT) + label = LABEL_REFLECT; + else if(ulabel == OSL::Labels::TRANSMIT) + label = LABEL_TRANSMIT; + else + return LABEL_NONE; /* sampling failed */ + + /* convert scattering to our bitflag label */ + ustring uscattering = sample_bsdf->scattering(); + + if(uscattering == OSL::Labels::DIFFUSE) + label |= LABEL_DIFFUSE; + else if(uscattering == OSL::Labels::GLOSSY) + label |= LABEL_GLOSSY; + else if(uscattering == OSL::Labels::SINGULAR) + label |= LABEL_SINGULAR; + else + label |= LABEL_STRAIGHT; + + /* eval + pdf */ + eval *= flat->weight; + pdf *= flat->sample_weight; + + break; + } + + if(!sample_bsdf || pdf == 0.0f) + return LABEL_NONE; + + /* add eval/pdf from other BSDF closures */ + for(int i = 0; i < sd->osl_closure.num_bsdf; i++) { + const FlatClosure *flat = &sd->osl_closure.bsdf[i]; + OSL::BSDFClosure *bsdf = (OSL::BSDFClosure*)flat->prim; + + if(bsdf != sample_bsdf) { + OSL::Color3 bsdf_eval; + float bsdf_pdf = 0.0f; + + if(dot(sd->Ng, omega_in) >= 0.0f) + bsdf_eval = bsdf->eval_reflect(TO_VEC3(sd->I), TO_VEC3(omega_in), bsdf_pdf); + else + bsdf_eval = bsdf->eval_transmit(TO_VEC3(sd->I), TO_VEC3(omega_in), bsdf_pdf); + + if(bsdf_pdf != 0.0f) { + eval += TO_FLOAT3(bsdf_eval)*flat->weight; + pdf += bsdf_pdf*flat->sample_weight; + } + } + } + + pdf *= 1.0f/(sd->osl_closure.bsdf_sample_sum); + + return label; +} + +float3 OSLShader::bsdf_eval(const ShaderData *sd, const float3& omega_in, float& pdf) +{ + float3 eval = make_float3(0.0f, 0.0f, 0.0f); + + pdf = 0.0f; + + for(int i = 0; i < sd->osl_closure.num_bsdf; i++) { + const FlatClosure *flat = &sd->osl_closure.bsdf[i]; + OSL::BSDFClosure *bsdf = (OSL::BSDFClosure*)flat->prim; + OSL::Color3 bsdf_eval; + float bsdf_pdf = 0.0f; + + if(dot(sd->Ng, omega_in) >= 0.0f) + bsdf_eval = bsdf->eval_reflect(TO_VEC3(sd->I), TO_VEC3(omega_in), bsdf_pdf); + else + bsdf_eval = bsdf->eval_transmit(TO_VEC3(sd->I), TO_VEC3(omega_in), bsdf_pdf); + + if(bsdf_pdf != 0.0f) { + eval += TO_FLOAT3(bsdf_eval)*flat->weight; + pdf += bsdf_pdf*flat->sample_weight; + } + } + + pdf *= 1.0f/sd->osl_closure.bsdf_sample_sum; + + return eval; +} + +/* Emissive Closure */ + +float3 OSLShader::emissive_eval(const ShaderData *sd) +{ + float3 eval = make_float3(0.0f, 0.0f, 0.0f); + + for(int i = 0; i < sd->osl_closure.num_emissive; i++) { + const FlatClosure *flat = &sd->osl_closure.emissive[i]; + OSL::EmissiveClosure *emissive = (OSL::EmissiveClosure*)flat->prim; + OSL::Color3 emissive_eval = emissive->eval(TO_VEC3(sd->Ng), TO_VEC3(sd->I)); + eval += TO_FLOAT3(emissive_eval)*flat->weight; + } + + return eval; +} + +void OSLShader::emissive_sample(const ShaderData *sd, float randu, float randv, float3 *eval, float3 *I, float *pdf) +{ + float r = sd->osl_closure.randb*sd->osl_closure.emissive_sample_sum; + float sample_sum = 0.0f; + + *pdf = 0.0f; + + if(sd->osl_closure.emissive_sample_sum == 0.0f) + return; + + /* find a closure to sample */ + for(int i = 0; i < sd->osl_closure.num_emissive; i++) { + const FlatClosure *flat = &sd->osl_closure.emissive[i]; + sample_sum += flat->sample_weight; + + if(r <= sample_sum) { + /* sample emissive closure */ + OSL::EmissiveClosure *emissive = (OSL::EmissiveClosure*)flat->prim; + emissive->sample(TO_VEC3(sd->Ng), randu, randv, TO_VEC3(*I), *pdf); + *eval = flat->weight; + *pdf *= flat->sample_weight/sd->osl_closure.emissive_sample_sum; + return; + } + } +} + +/* Volume Closure */ + +float3 OSLShader::volume_eval_phase(const ShaderData *sd, const float3 omega_in, const float3 omega_out) +{ + float3 eval = make_float3(0.0f, 0.0f, 0.0f); + + for(int i = 0; i < sd->osl_closure.num_volume; i++) { + const FlatClosure *flat = &sd->osl_closure.volume[i]; + OSL::VolumeClosure *volume = (OSL::VolumeClosure*)flat->prim; + OSL::Color3 volume_eval = volume->eval_phase(TO_VEC3(omega_in), TO_VEC3(omega_out)); + eval += TO_FLOAT3(volume_eval)*flat->weight; + } + + return eval; +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/osl/osl_shader.h b/intern/cycles/kernel/osl/osl_shader.h new file mode 100644 index 00000000000..2e5279c12ce --- /dev/null +++ b/intern/cycles/kernel/osl/osl_shader.h @@ -0,0 +1,87 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __OSL_SHADER_H__ +#define __OSL_SHADER_H__ + +#ifdef WITH_OSL + +/* OSL Shader Engine + * + * Holds all variables to execute and use OSL shaders from the kernel. These + * are initialized externally by OSLShaderManager before rendering starts. + * + * Before/after a thread starts rendering, thread_init/thread_free must be + * called, which will store any per thread OSL state in thread local storage. + * This means no thread state must be passed along in the kernel itself. + */ + +#include <OSL/oslexec.h> +#include <OSL/oslclosure.h> + +#include "kernel_types.h" + +#include "util_map.h" +#include "util_param.h" +#include "util_vector.h" + +CCL_NAMESPACE_BEGIN + +namespace OSL = ::OSL; + +class OSLRenderServices; +class Scene; +class ShaderData; +class differential3; +class KernelGlobals; + +class OSLShader { +public: + /* init */ + static void register_closures(OSL::ShadingSystem *ss); + + /* per thread data */ + static void thread_init(KernelGlobals *kg); + static void thread_free(KernelGlobals *kg); + + /* eval */ + static void eval_surface(KernelGlobals *kg, ShaderData *sd, float randb, int path_flag); + static float3 eval_background(KernelGlobals *kg, ShaderData *sd, int path_flag); + static void eval_volume(KernelGlobals *kg, ShaderData *sd, float randb, int path_flag); + static void eval_displacement(KernelGlobals *kg, ShaderData *sd); + + /* sample & eval */ + static int bsdf_sample(const ShaderData *sd, float randu, float randv, + float3& eval, float3& omega_in, differential3& domega_in, float& pdf); + static float3 bsdf_eval(const ShaderData *sd, const float3& omega_in, float& pdf); + static float3 emissive_eval(const ShaderData *sd); + static void emissive_sample(const ShaderData *sd, float randu, float randv, + float3 *eval, float3 *I, float *pdf); + static float3 volume_eval_phase(const ShaderData *sd, const float3 omega_in, + const float3 omega_out); + + /* release */ + static void release(KernelGlobals *kg, const ShaderData *sd); +}; + +CCL_NAMESPACE_END + +#endif + +#endif /* __OSL_SHADER_H__ */ + diff --git a/intern/cycles/kernel/osl/vol_subsurface.cpp b/intern/cycles/kernel/osl/vol_subsurface.cpp new file mode 100644 index 00000000000..0cd3060051b --- /dev/null +++ b/intern/cycles/kernel/osl/vol_subsurface.cpp @@ -0,0 +1,135 @@ +/* + * 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. + */ + +#include <OpenImageIO/fmath.h> + +#include <OSL/genclosure.h> + +#include "osl_closures.h" + +CCL_NAMESPACE_BEGIN + +using namespace OSL; + +// Computes scattering properties based on Jensen's reparameterization +// described in: +// http://graphics.ucsd.edu/~henrik/papers/fast_bssrdf/ + +class SubsurfaceClosure : public VolumeClosure { +public: + float m_g; + float m_eta; + Color3 m_mfp, m_albedo; + static float root_find_Rd(const float Rd0, const float A) { + // quick exit for trivial cases + if (Rd0 <= 0) return 0; + const float A43 = A * 4.0f / 3.0f; + // Find alpha such that f(alpha) = Rd (see eq.15). A simple bisection + // method can be used because this function is monotonicaly increasing. + float lo = 0, hi = 1; + for (int i = 0; i < 20; i++) { // 2^20 divisions should be sufficient + // eval function at midpoint + float alpha = 0.5f * (lo + hi); + float a1 = sqrtf(3 * (1 - alpha)); + float e1 = expf(-a1); + float e2 = expf(-A43 * a1); + float Rd = 0.5f * alpha * (1 + e2) * e1 - Rd0; + if (fabsf(Rd) < 1e-6f) + return alpha; // close enough + else if (Rd > 0) + hi = alpha; // root is on left side + else + lo = alpha; // root is on right side + } + // didn't quite converge, pick result in the middle of remaining interval + return 0.5f * (lo + hi); + } + SubsurfaceClosure() { } + + void setup() + { + ior(m_eta); + + if (m_g >= 0.99f) m_g = 0.99f; + if (m_g <= -0.99f) m_g = -0.99f; + + // eq.10 + float inv_eta = 1 / m_eta; + float Fdr = -1.440f * inv_eta * inv_eta + 0.710 * inv_eta + 0.668f + 0.0636 * m_eta; + float A = (1 + Fdr) / (1 - Fdr); + // compute sigma_s, sigma_a (eq.16) + Color3 alpha_prime = Color3 (root_find_Rd(m_albedo[0], A), + root_find_Rd(m_albedo[1], A), + root_find_Rd(m_albedo[2], A)); + Color3 sigma_t_prime = Color3 (m_mfp.x > 0 ? 1.0f / (m_mfp[0] * sqrtf(3 * (1 - alpha_prime[0]))) : 0.0f, + m_mfp.y > 0 ? 1.0f / (m_mfp[1] * sqrtf(3 * (1 - alpha_prime[1]))) : 0.0f, + m_mfp.z > 0 ? 1.0f / (m_mfp[2] * sqrtf(3 * (1 - alpha_prime[2]))) : 0.0f); + Color3 sigma_s_prime = alpha_prime * sigma_t_prime; + + sigma_s((1.0f / (1 - m_g)) * sigma_s_prime); + sigma_a(sigma_t_prime - sigma_s_prime); + } + + bool mergeable (const ClosurePrimitive *other) const { + const SubsurfaceClosure *comp = (const SubsurfaceClosure *)other; + return m_g == comp->m_g && VolumeClosure::mergeable(other); + } + + size_t memsize () const { return sizeof(*this); } + + const char *name () const { return "subsurface"; } + + void print_on (std::ostream &out) const { + out << name() << " ()"; + } + + virtual Color3 eval_phase(const Vec3 &omega_in, const Vec3 &omega_out) const { + float costheta = omega_in.dot(omega_out); + float ph = 0.25f * float(M_1_PI) * ((1 - m_g * m_g) / powf(1 + m_g * m_g - 2.0f * m_g * costheta, 1.5f)); + return Color3 (ph, ph, ph); + } +}; + + + +ClosureParam closure_subsurface_params[] = { + CLOSURE_FLOAT_PARAM (SubsurfaceClosure, m_eta), + CLOSURE_FLOAT_PARAM (SubsurfaceClosure, m_g), + CLOSURE_COLOR_PARAM (SubsurfaceClosure, m_mfp), + CLOSURE_COLOR_PARAM (SubsurfaceClosure, m_albedo), + CLOSURE_STRING_KEYPARAM("label"), + CLOSURE_FINISH_PARAM(SubsurfaceClosure) }; + +CLOSURE_PREPARE(closure_subsurface_prepare, SubsurfaceClosure) + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/bsdf.h b/intern/cycles/kernel/svm/bsdf.h new file mode 100644 index 00000000000..18c1da73fbd --- /dev/null +++ b/intern/cycles/kernel/svm/bsdf.h @@ -0,0 +1,135 @@ +/* + * 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. +*/ + +#ifndef __OSL_BSDF_H__ +#define __OSL_BSDF_H__ + +CCL_NAMESPACE_BEGIN + +__device float fresnel_dielectric(float eta, const float3 N, + const float3 I, float3 *R, float3 *T, +#ifdef __RAY_DIFFERENTIALS__ + const float3 dIdx, const float3 dIdy, + float3 *dRdx, float3 *dRdy, + float3 *dTdx, float3 *dTdy, +#endif + bool *is_inside) +{ + float cos = dot(N, I), neta; + float3 Nn; + // compute reflection + *R =(2 * cos)* N - I; +#ifdef __RAY_DIFFERENTIALS__ + *dRdx = (2 * dot(N, dIdx)) * N - dIdx; + *dRdy = (2 * dot(N, dIdy)) * N - dIdy; +#endif + // check which side of the surface we are on + if(cos > 0) { + // we are on the outside of the surface, going in + neta = 1 / eta; + Nn = N; + *is_inside = false; + } else { + // we are inside the surface, + cos = -cos; + neta = eta; + Nn = -N; + *is_inside = true; + } + *R =(2 * cos)* Nn - I; + float arg = 1 -(neta * neta *(1 -(cos * cos))); + if(arg < 0) { + *T= make_float3(0.0f, 0.0f, 0.0f); +#ifdef __RAY_DIFFERENTIALS__ + *dTdx= make_float3(0.0f, 0.0f, 0.0f); + *dTdy= make_float3(0.0f, 0.0f, 0.0f); +#endif + return 1; // total internal reflection + } else { + float dnp = sqrtf(arg); + float nK =(neta * cos)- dnp; + *T = -(neta * I)+(nK * Nn); +#ifdef __RAY_DIFFERENTIALS__ + *dTdx = -(neta * dIdx) + ((neta - neta * neta * cos / dnp) * dot(dIdx, Nn)) * Nn; + *dTdy = -(neta * dIdy) + ((neta - neta * neta * cos / dnp) * dot(dIdy, Nn)) * Nn; +#endif + // compute Fresnel terms + float cosTheta1 = cos; // N.R + float cosTheta2 = -dot(Nn, *T); + float pPara =(cosTheta1 - eta * cosTheta2)/(cosTheta1 + eta * cosTheta2); + float pPerp =(eta * cosTheta1 - cosTheta2)/(eta * cosTheta1 + cosTheta2); + return 0.5f * (pPara * pPara + pPerp * pPerp); + } +} + +__device float fresnel_dielectric_cos(float cosi, float eta) +{ + // compute fresnel reflectance without explicitly computing + // the refracted direction + float c = fabsf(cosi); + float g = eta * eta - 1 + c * c; + if(g > 0) { + g = sqrtf(g); + float A =(g - c)/(g + c); + float B =(c *(g + c)- 1)/(c *(g - c)+ 1); + return 0.5f * A * A *(1 + B * B); + } + return 1.0f; // TIR(no refracted component) +} + +__device float fresnel_conductor(float cosi, float eta, float k) +{ + float tmp_f = eta * eta + k * k; + float tmp = tmp_f * cosi * cosi; + float Rparl2 =(tmp -(2.0f * eta * cosi)+ 1)/ + (tmp +(2.0f * eta * cosi)+ 1); + float Rperp2 =(tmp_f -(2.0f * eta * cosi)+ cosi * cosi)/ + (tmp_f +(2.0f * eta * cosi)+ cosi * cosi); + return(Rparl2 + Rperp2) * 0.5f; +} + +__device float smooth_step(float edge0, float edge1, float x) +{ + float result; + if(x < edge0) result = 0.0f; + else if(x >= edge1) result = 1.0f; + else { + float t = (x - edge0)/(edge1 - edge0); + result = (3.0f-2.0f*t)*(t*t); + } + return result; +} + +CCL_NAMESPACE_END + +#endif /* __OSL_BSDF_H__ */ + diff --git a/intern/cycles/kernel/svm/bsdf_ashikhmin_velvet.h b/intern/cycles/kernel/svm/bsdf_ashikhmin_velvet.h new file mode 100644 index 00000000000..40bae72a6c5 --- /dev/null +++ b/intern/cycles/kernel/svm/bsdf_ashikhmin_velvet.h @@ -0,0 +1,154 @@ +/* + * 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. +*/ + +#ifndef __BSDF_ASHIKHMIN_VELVET_H__ +#define __BSDF_ASHIKHMIN_VELVET_H__ + +CCL_NAMESPACE_BEGIN + +typedef struct BsdfAshikhminVelvetClosure { + //float3 m_N; + float m_invsigma2; +} BsdfAshikhminVelvetClosure; + +__device void bsdf_ashikhmin_velvet_setup(ShaderData *sd, float3 N, float sigma) +{ + BsdfAshikhminVelvetClosure *self = (BsdfAshikhminVelvetClosure*)sd->svm_closure_data; + + sigma = fmaxf(sigma, 0.01f); + + //self->m_N = N; + self->m_invsigma2 = 1.0f/(sigma * sigma); + + sd->svm_closure = CLOSURE_BSDF_ASHIKHMIN_VELVET_ID; + sd->flag |= SD_BSDF_HAS_EVAL; +} + +__device void bsdf_ashikhmin_velvet_blur(ShaderData *sd, float roughness) +{ +} + +__device float3 bsdf_ashikhmin_velvet_eval_reflect(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + const BsdfAshikhminVelvetClosure *self = (const BsdfAshikhminVelvetClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + float cosNO = dot(m_N, I); + float cosNI = dot(m_N, omega_in); + if(cosNO > 0 && cosNI > 0) { + float3 H = normalize(omega_in + I); + + float cosNH = dot(m_N, H); + float cosHO = fabsf(dot(I, H)); + + float cosNHdivHO = cosNH / cosHO; + cosNHdivHO = fmaxf(cosNHdivHO, 0.00001f); + + float fac1 = 2 * fabsf(cosNHdivHO * cosNO); + float fac2 = 2 * fabsf(cosNHdivHO * cosNI); + + float sinNH2 = 1 - cosNH * cosNH; + float sinNH4 = sinNH2 * sinNH2; + float cotangent2 = (cosNH * cosNH) / sinNH2; + + float D = expf(-cotangent2 * self->m_invsigma2) * self->m_invsigma2 * M_1_PI_F / sinNH4; + float G = min(1.0f, min(fac1, fac2)); // TODO: derive G from D analytically + + float out = 0.25f * (D * G) / cosNO; + + *pdf = 0.5f * M_1_PI_F; + return make_float3(out, out, out); + } + return make_float3(0, 0, 0); +} + +__device float3 bsdf_ashikhmin_velvet_eval_transmit(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + return make_float3(0.0f, 0.0f, 0.0f); +} + +__device float bsdf_ashikhmin_velvet_albedo(const ShaderData *sd, const float3 I) +{ + return 1.0f; +} + +__device int bsdf_ashikhmin_velvet_sample(const ShaderData *sd, float randu, float randv, float3 *eval, float3 *omega_in, float3 *domega_in_dx, float3 *domega_in_dy, float *pdf) +{ + const BsdfAshikhminVelvetClosure *self = (const BsdfAshikhminVelvetClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + // we are viewing the surface from above - send a ray out with uniform + // distribution over the hemisphere + sample_uniform_hemisphere(m_N, randu, randv, omega_in, pdf); + + if(dot(sd->Ng, *omega_in) > 0) { + float3 H = normalize(*omega_in + sd->I); + + float cosNI = dot(m_N, *omega_in); + float cosNO = dot(m_N, sd->I); + float cosNH = dot(m_N, H); + float cosHO = fabsf(dot(sd->I, H)); + + float cosNHdivHO = cosNH / cosHO; + cosNHdivHO = fmaxf(cosNHdivHO, 0.00001f); + + float fac1 = 2 * fabsf(cosNHdivHO * cosNO); + float fac2 = 2 * fabsf(cosNHdivHO * cosNI); + + float sinNH2 = 1 - cosNH * cosNH; + float sinNH4 = sinNH2 * sinNH2; + float cotangent2 = (cosNH * cosNH) / sinNH2; + + float D = expf(-cotangent2 * self->m_invsigma2) * self->m_invsigma2 * M_1_PI_F / sinNH4; + float G = min(1.0f, min(fac1, fac2)); // TODO: derive G from D analytically + + float power = 0.25f * (D * G) / cosNO; + + *eval = make_float3(power, power, power); + +#ifdef __RAY_DIFFERENTIALS__ + // TODO: find a better approximation for the retroreflective bounce + *domega_in_dx = (2 * dot(m_N, sd->dI.dx)) * m_N - sd->dI.dx; + *domega_in_dy = (2 * dot(m_N, sd->dI.dy)) * m_N - sd->dI.dy; + *domega_in_dx *= 125; + *domega_in_dy *= 125; +#endif + } else + *pdf = 0.0f; + + return LABEL_REFLECT|LABEL_DIFFUSE; +} + +CCL_NAMESPACE_END + +#endif /* __BSDF_ASHIKHMIN_VELVET_H__ */ + diff --git a/intern/cycles/kernel/svm/bsdf_diffuse.h b/intern/cycles/kernel/svm/bsdf_diffuse.h new file mode 100644 index 00000000000..c505de036aa --- /dev/null +++ b/intern/cycles/kernel/svm/bsdf_diffuse.h @@ -0,0 +1,166 @@ +/* + * 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. +*/ + +#ifndef __BSDF_DIFFUSE_H__ +#define __BSDF_DIFFUSE_H__ + +CCL_NAMESPACE_BEGIN + +/* DIFFUSE */ + +typedef struct BsdfDiffuseClosure { + //float3 m_N; +} BsdfDiffuseClosure; + +__device void bsdf_diffuse_setup(ShaderData *sd, float3 N) +{ + //BsdfDiffuseClosure *self = (BsdfDiffuseClosure*)sd->svm_closure_data; + //self->m_N = N; + + sd->svm_closure = CLOSURE_BSDF_DIFFUSE_ID; + sd->flag |= SD_BSDF_HAS_EVAL; +} + +__device void bsdf_diffuse_blur(ShaderData *sd, float roughness) +{ +} + +__device float3 bsdf_diffuse_eval_reflect(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + //const BsdfDiffuseClosure *self = (const BsdfDiffuseClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + float cos_pi = fmaxf(dot(m_N, omega_in), 0.0f) * M_1_PI_F; + *pdf = cos_pi; + return make_float3(cos_pi, cos_pi, cos_pi); +} + +__device float3 bsdf_diffuse_eval_transmit(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + return make_float3(0.0f, 0.0f, 0.0f); +} + +__device float bsdf_diffuse_albedo(const ShaderData *sd, const float3 I) +{ + return 1.0f; +} + +__device int bsdf_diffuse_sample(const ShaderData *sd, float randu, float randv, float3 *eval, float3 *omega_in, float3 *domega_in_dx, float3 *domega_in_dy, float *pdf) +{ + //const BsdfDiffuseClosure *self = (const BsdfDiffuseClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + // distribution over the hemisphere + sample_cos_hemisphere(m_N, randu, randv, omega_in, pdf); + + if(dot(sd->Ng, *omega_in) > 0.0f) { + *eval = make_float3(*pdf, *pdf, *pdf); +#ifdef __RAY_DIFFERENTIALS__ + // TODO: find a better approximation for the diffuse bounce + *domega_in_dx = (2 * dot(m_N, sd->dI.dx)) * m_N - sd->dI.dx; + *domega_in_dy = (2 * dot(m_N, sd->dI.dy)) * m_N - sd->dI.dy; + *domega_in_dx *= 125; + *domega_in_dy *= 125; +#endif + } + else + *pdf = 0.0f; + + return LABEL_REFLECT|LABEL_DIFFUSE; +} + +/* TRANSLUCENT */ + +typedef struct BsdfTranslucentClosure { + //float3 m_N; +} BsdfTranslucentClosure; + +__device void bsdf_translucent_setup(ShaderData *sd, float3 N) +{ + //BsdfTranslucentClosure *self = (BsdfTranslucentClosure*)sd->svm_closure_data; + //self->m_N = N; + + sd->svm_closure = CLOSURE_BSDF_TRANSLUCENT_ID; + sd->flag |= SD_BSDF_HAS_EVAL; +} + +__device void bsdf_translucent_blur(ShaderData *sd, float roughness) +{ +} + +__device float3 bsdf_translucent_eval_reflect(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + return make_float3(0.0f, 0.0f, 0.0f); +} + +__device float3 bsdf_translucent_eval_transmit(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + //const BsdfTranslucentClosure *self = (const BsdfTranslucentClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + float cos_pi = fmaxf(-dot(m_N, omega_in), 0.0f) * M_1_PI_F; + *pdf = cos_pi; + return make_float3 (cos_pi, cos_pi, cos_pi); +} + +__device float bsdf_translucent_albedo(const ShaderData *sd, const float3 I) +{ + return 1.0f; +} + +__device int bsdf_translucent_sample(const ShaderData *sd, float randu, float randv, float3 *eval, float3 *omega_in, float3 *domega_in_dx, float3 *domega_in_dy, float *pdf) +{ + //const BsdfTranslucentClosure *self = (const BsdfTranslucentClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + // we are viewing the surface from the right side - send a ray out with cosine + // distribution over the hemisphere + sample_cos_hemisphere (-m_N, randu, randv, omega_in, pdf); + if(dot(sd->Ng, *omega_in) < 0) { + *eval = make_float3(*pdf, *pdf, *pdf); +#ifdef __RAY_DIFFERENTIALS__ + // TODO: find a better approximation for the diffuse bounce + *domega_in_dx = (2 * dot(m_N, sd->dI.dx)) * m_N - sd->dI.dx; + *domega_in_dy = (2 * dot(m_N, sd->dI.dy)) * m_N - sd->dI.dy; + *domega_in_dx *= -125; + *domega_in_dy *= -125; +#endif + } else + *pdf = 0; + + return LABEL_TRANSMIT|LABEL_DIFFUSE; +} + +CCL_NAMESPACE_END + +#endif /* __BSDF_DIFFUSE_H__ */ + diff --git a/intern/cycles/kernel/svm/bsdf_microfacet.h b/intern/cycles/kernel/svm/bsdf_microfacet.h new file mode 100644 index 00000000000..b6baa1e90d8 --- /dev/null +++ b/intern/cycles/kernel/svm/bsdf_microfacet.h @@ -0,0 +1,493 @@ +/* + * 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. +*/ + +#ifndef __BSDF_MICROFACET_H__ +#define __BSDF_MICROFACET_H__ + +CCL_NAMESPACE_BEGIN + +/* GGX */ + +typedef struct BsdfMicrofacetGGXClosure { + //float3 m_N; + float m_ag; + float m_eta; + int m_refractive; +} BsdfMicrofacetGGXClosure; + +__device void bsdf_microfacet_ggx_setup(ShaderData *sd, float3 N, float ag, float eta, bool refractive) +{ + BsdfMicrofacetGGXClosure *self = (BsdfMicrofacetGGXClosure*)sd->svm_closure_data; + + //self->m_N = N; + self->m_ag = clamp(ag, 1e-5f, 1.0f); + self->m_eta = eta; + self->m_refractive = (refractive)? 1: 0; + + if(refractive) + sd->svm_closure = CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID; + else + sd->svm_closure = CLOSURE_BSDF_MICROFACET_GGX_ID; + + sd->flag |= SD_BSDF_HAS_EVAL|SD_BSDF_GLOSSY; +} + +__device void bsdf_microfacet_ggx_blur(ShaderData *sd, float roughness) +{ + BsdfMicrofacetGGXClosure *self = (BsdfMicrofacetGGXClosure*)sd->svm_closure_data; + self->m_ag = fmaxf(roughness, self->m_ag); +} + +__device float3 bsdf_microfacet_ggx_eval_reflect(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + const BsdfMicrofacetGGXClosure *self = (const BsdfMicrofacetGGXClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + if(self->m_refractive == 1) return make_float3 (0, 0, 0); + float cosNO = dot(m_N, I); + float cosNI = dot(m_N, omega_in); + if(cosNI > 0 && cosNO > 0) { + // get half vector + float3 Hr = normalize(omega_in + I); + // eq. 20: (F*G*D)/(4*in*on) + // eq. 33: first we calculate D(m) with m=Hr: + float alpha2 = self->m_ag * self->m_ag; + float cosThetaM = dot(m_N, Hr); + float cosThetaM2 = cosThetaM * cosThetaM; + float tanThetaM2 = (1 - cosThetaM2) / cosThetaM2; + float cosThetaM4 = cosThetaM2 * cosThetaM2; + float D = alpha2 / (M_PI_F * cosThetaM4 * (alpha2 + tanThetaM2) * (alpha2 + tanThetaM2)); + // eq. 34: now calculate G1(i,m) and G1(o,m) + float G1o = 2 / (1 + sqrtf(1 + alpha2 * (1 - cosNO * cosNO) / (cosNO * cosNO))); + float G1i = 2 / (1 + sqrtf(1 + alpha2 * (1 - cosNI * cosNI) / (cosNI * cosNI))); + float G = G1o * G1i; + float out = (G * D) * 0.25f / cosNO; + // eq. 24 + float pm = D * cosThetaM; + // convert into pdf of the sampled direction + // eq. 38 - but see also: + // eq. 17 in http://www.graphics.cornell.edu/~bjw/wardnotes.pdf + *pdf = pm * 0.25f / dot(Hr, I); + return make_float3 (out, out, out); + } + return make_float3 (0, 0, 0); +} + +__device float3 bsdf_microfacet_ggx_eval_transmit(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + const BsdfMicrofacetGGXClosure *self = (const BsdfMicrofacetGGXClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + if(self->m_refractive == 0) return make_float3 (0, 0, 0); + float cosNO = dot(m_N, I); + float cosNI = dot(m_N, omega_in); + if(cosNO <= 0 || cosNI >= 0) + return make_float3 (0, 0, 0); // vectors on same side -- not possible + // compute half-vector of the refraction (eq. 16) + float3 ht = -(self->m_eta * omega_in + I); + float3 Ht = normalize(ht); + float cosHO = dot(Ht, I); + + float cosHI = dot(Ht, omega_in); + // eq. 33: first we calculate D(m) with m=Ht: + float alpha2 = self->m_ag * self->m_ag; + float cosThetaM = dot(m_N, Ht); + float cosThetaM2 = cosThetaM * cosThetaM; + float tanThetaM2 = (1 - cosThetaM2) / cosThetaM2; + float cosThetaM4 = cosThetaM2 * cosThetaM2; + float D = alpha2 / (M_PI_F * cosThetaM4 * (alpha2 + tanThetaM2) * (alpha2 + tanThetaM2)); + // eq. 34: now calculate G1(i,m) and G1(o,m) + float G1o = 2 / (1 + sqrtf(1 + alpha2 * (1 - cosNO * cosNO) / (cosNO * cosNO))); + float G1i = 2 / (1 + sqrtf(1 + alpha2 * (1 - cosNI * cosNI) / (cosNI * cosNI))); + float G = G1o * G1i; + // probability + float invHt2 = 1 / dot(ht, ht); + *pdf = D * fabsf(cosThetaM) * (fabsf(cosHI) * (self->m_eta * self->m_eta)) * invHt2; + float out = (fabsf(cosHI * cosHO) * (self->m_eta * self->m_eta) * (G * D) * invHt2) / cosNO; + return make_float3 (out, out, out); +} + +__device float bsdf_microfacet_ggx_albedo(const ShaderData *sd, const float3 I) +{ + return 1.0f; +} + +__device int bsdf_microfacet_ggx_sample(const ShaderData *sd, float randu, float randv, float3 *eval, float3 *omega_in, float3 *domega_in_dx, float3 *domega_in_dy, float *pdf) +{ + const BsdfMicrofacetGGXClosure *self = (const BsdfMicrofacetGGXClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + float cosNO = dot(m_N, sd->I); + if(cosNO > 0) { + float3 X, Y, Z = m_N; + make_orthonormals(Z, &X, &Y); + // generate a random microfacet normal m + // eq. 35,36: + // we take advantage of cos(atan(x)) == 1/sqrt(1+x^2) + //tttt and sin(atan(x)) == x/sqrt(1+x^2) + float alpha2 = self->m_ag * self->m_ag; + float tanThetaM2 = alpha2 * randu / (1 - randu); + float cosThetaM = 1 / sqrtf(1 + tanThetaM2); + float sinThetaM = cosThetaM * sqrtf(tanThetaM2); + float phiM = 2 * M_PI_F * randv; + float3 m = (cosf(phiM) * sinThetaM) * X + + (sinf(phiM) * sinThetaM) * Y + + cosThetaM * Z; + if(self->m_refractive == 0) { + float cosMO = dot(m, sd->I); + if(cosMO > 0) { + // eq. 39 - compute actual reflected direction + *omega_in = 2 * cosMO * m - sd->I; + if(dot(sd->Ng, *omega_in) > 0) { + // microfacet normal is visible to this ray + // eq. 33 + float cosThetaM2 = cosThetaM * cosThetaM; + float cosThetaM4 = cosThetaM2 * cosThetaM2; + float D = alpha2 / (M_PI_F * cosThetaM4 * (alpha2 + tanThetaM2) * (alpha2 + tanThetaM2)); + // eq. 24 + float pm = D * cosThetaM; + // convert into pdf of the sampled direction + // eq. 38 - but see also: + // eq. 17 in http://www.graphics.cornell.edu/~bjw/wardnotes.pdf + *pdf = pm * 0.25f / cosMO; + // eval BRDF*cosNI + float cosNI = dot(m_N, *omega_in); + // eq. 34: now calculate G1(i,m) and G1(o,m) + float G1o = 2 / (1 + sqrtf(1 + alpha2 * (1 - cosNO * cosNO) / (cosNO * cosNO))); + float G1i = 2 / (1 + sqrtf(1 + alpha2 * (1 - cosNI * cosNI) / (cosNI * cosNI))); + float G = G1o * G1i; + // eq. 20: (F*G*D)/(4*in*on) + float out = (G * D) * 0.25f / cosNO; + *eval = make_float3(out, out, out); +#ifdef __RAY_DIFFERENTIALS__ + *domega_in_dx = (2 * dot(m, sd->dI.dx)) * m - sd->dI.dx; + *domega_in_dy = (2 * dot(m, sd->dI.dy)) * m - sd->dI.dy; + // Since there is some blur to this reflection, make the + // derivatives a bit bigger. In theory this varies with the + // roughness but the exact relationship is complex and + // requires more ops than are practical. + *domega_in_dx *= 10; + *domega_in_dy *= 10; +#endif + } + } + } else { + // CAUTION: the i and o variables are inverted relative to the paper + // eq. 39 - compute actual refractive direction + float3 R, T; +#ifdef __RAY_DIFFERENTIALS__ + float3 dRdx, dRdy, dTdx, dTdy; +#endif + bool inside; + fresnel_dielectric(self->m_eta, m, sd->I, &R, &T, +#ifdef __RAY_DIFFERENTIALS__ + sd->dI.dx, sd->dI.dy, &dRdx, &dRdy, &dTdx, &dTdy, +#endif + &inside); + + if(!inside) { + *omega_in = T; +#ifdef __RAY_DIFFERENTIALS__ + *domega_in_dx = dTdx; + *domega_in_dy = dTdy; +#endif + // eq. 33 + float cosThetaM2 = cosThetaM * cosThetaM; + float cosThetaM4 = cosThetaM2 * cosThetaM2; + float D = alpha2 / (M_PI_F * cosThetaM4 * (alpha2 + tanThetaM2) * (alpha2 + tanThetaM2)); + // eq. 24 + float pm = D * cosThetaM; + // eval BRDF*cosNI + float cosNI = dot(m_N, *omega_in); + // eq. 34: now calculate G1(i,m) and G1(o,m) + float G1o = 2 / (1 + sqrtf(1 + alpha2 * (1 - cosNO * cosNO) / (cosNO * cosNO))); + float G1i = 2 / (1 + sqrtf(1 + alpha2 * (1 - cosNI * cosNI) / (cosNI * cosNI))); + float G = G1o * G1i; + // eq. 21 + float cosHI = dot(m, *omega_in); + float cosHO = dot(m, sd->I); + float Ht2 = self->m_eta * cosHI + cosHO; + Ht2 *= Ht2; + float out = (fabsf(cosHI * cosHO) * (self->m_eta * self->m_eta) * (G * D)) / (cosNO * Ht2); + // eq. 38 and eq. 17 + *pdf = pm * (self->m_eta * self->m_eta) * fabsf(cosHI) / Ht2; + *eval = make_float3(out, out, out); +#ifdef __RAY_DIFFERENTIALS__ + // Since there is some blur to this refraction, make the + // derivatives a bit bigger. In theory this varies with the + // roughness but the exact relationship is complex and + // requires more ops than are practical. + *domega_in_dx *= 10; + *domega_in_dy *= 10; +#endif + } + } + } + return (self->m_refractive == 1) ? LABEL_TRANSMIT|LABEL_GLOSSY : LABEL_REFLECT|LABEL_GLOSSY; +} + +/* BECKMANN */ + +typedef struct BsdfMicrofacetBeckmannClosure { + //float3 m_N; + float m_ab; + float m_eta; + int m_refractive; +} BsdfMicrofacetBeckmannClosure; + +__device void bsdf_microfacet_beckmann_setup(ShaderData *sd, float3 N, float ab, float eta, bool refractive) +{ + BsdfMicrofacetBeckmannClosure *self = (BsdfMicrofacetBeckmannClosure*)sd->svm_closure_data; + + //self->m_N = N; + self->m_ab = clamp(ab, 1e-5f, 1.0f); + self->m_eta = eta; + self->m_refractive = (refractive)? 1: 0; + + if(refractive) + sd->svm_closure = CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID; + else + sd->svm_closure = CLOSURE_BSDF_MICROFACET_BECKMANN_ID; + + sd->flag |= SD_BSDF_HAS_EVAL|SD_BSDF_GLOSSY; +} + +__device void bsdf_microfacet_beckmann_blur(ShaderData *sd, float roughness) +{ + BsdfMicrofacetBeckmannClosure *self = (BsdfMicrofacetBeckmannClosure*)sd->svm_closure_data; + self->m_ab = fmaxf(roughness, self->m_ab); +} + +__device float3 bsdf_microfacet_beckmann_eval_reflect(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + const BsdfMicrofacetBeckmannClosure *self = (const BsdfMicrofacetBeckmannClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + if(self->m_refractive == 1) return make_float3 (0, 0, 0); + float cosNO = dot(m_N, I); + float cosNI = dot(m_N, omega_in); + if(cosNO > 0 && cosNI > 0) { + // get half vector + float3 Hr = normalize(omega_in + I); + // eq. 20: (F*G*D)/(4*in*on) + // eq. 25: first we calculate D(m) with m=Hr: + float alpha2 = self->m_ab * self->m_ab; + float cosThetaM = dot(m_N, Hr); + float cosThetaM2 = cosThetaM * cosThetaM; + float tanThetaM2 = (1 - cosThetaM2) / cosThetaM2; + float cosThetaM4 = cosThetaM2 * cosThetaM2; + float D = expf(-tanThetaM2 / alpha2) / (M_PI_F * alpha2 * cosThetaM4); + // eq. 26, 27: now calculate G1(i,m) and G1(o,m) + float ao = 1 / (self->m_ab * sqrtf((1 - cosNO * cosNO) / (cosNO * cosNO))); + float ai = 1 / (self->m_ab * sqrtf((1 - cosNI * cosNI) / (cosNI * cosNI))); + float G1o = ao < 1.6f ? (3.535f * ao + 2.181f * ao * ao) / (1 + 2.276f * ao + 2.577f * ao * ao) : 1.0f; + float G1i = ai < 1.6f ? (3.535f * ai + 2.181f * ai * ai) / (1 + 2.276f * ai + 2.577f * ai * ai) : 1.0f; + float G = G1o * G1i; + float out = (G * D) * 0.25f / cosNO; + // eq. 24 + float pm = D * cosThetaM; + // convert into pdf of the sampled direction + // eq. 38 - but see also: + // eq. 17 in http://www.graphics.cornell.edu/~bjw/wardnotes.pdf + *pdf = pm * 0.25f / dot(Hr, I); + return make_float3 (out, out, out); + } + return make_float3 (0, 0, 0); +} + +__device float3 bsdf_microfacet_beckmann_eval_transmit(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + const BsdfMicrofacetBeckmannClosure *self = (const BsdfMicrofacetBeckmannClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + if(self->m_refractive == 0) return make_float3 (0, 0, 0); + float cosNO = dot(m_N, I); + float cosNI = dot(m_N, omega_in); + if(cosNO <= 0 || cosNI >= 0) + return make_float3 (0, 0, 0); + // compute half-vector of the refraction (eq. 16) + float3 ht = -(self->m_eta * omega_in + I); + float3 Ht = normalize(ht); + float cosHO = dot(Ht, I); + + float cosHI = dot(Ht, omega_in); + // eq. 33: first we calculate D(m) with m=Ht: + float alpha2 = self->m_ab * self->m_ab; + float cosThetaM = dot(m_N, Ht); + float cosThetaM2 = cosThetaM * cosThetaM; + float tanThetaM2 = (1 - cosThetaM2) / cosThetaM2; + float cosThetaM4 = cosThetaM2 * cosThetaM2; + float D = expf(-tanThetaM2 / alpha2) / (M_PI_F * alpha2 * cosThetaM4); + // eq. 26, 27: now calculate G1(i,m) and G1(o,m) + float ao = 1 / (self->m_ab * sqrtf((1 - cosNO * cosNO) / (cosNO * cosNO))); + float ai = 1 / (self->m_ab * sqrtf((1 - cosNI * cosNI) / (cosNI * cosNI))); + float G1o = ao < 1.6f ? (3.535f * ao + 2.181f * ao * ao) / (1 + 2.276f * ao + 2.577f * ao * ao) : 1.0f; + float G1i = ai < 1.6f ? (3.535f * ai + 2.181f * ai * ai) / (1 + 2.276f * ai + 2.577f * ai * ai) : 1.0f; + float G = G1o * G1i; + // probability + float invHt2 = 1 / dot(ht, ht); + *pdf = D * fabsf(cosThetaM) * (fabsf(cosHI) * (self->m_eta * self->m_eta)) * invHt2; + float out = (fabsf(cosHI * cosHO) * (self->m_eta * self->m_eta) * (G * D) * invHt2) / cosNO; + return make_float3 (out, out, out); +} + +__device float bsdf_microfacet_beckmann_albedo(const ShaderData *sd, const float3 I) +{ + return 1.0f; +} + +__device int bsdf_microfacet_beckmann_sample(const ShaderData *sd, float randu, float randv, float3 *eval, float3 *omega_in, float3 *domega_in_dx, float3 *domega_in_dy, float *pdf) +{ + const BsdfMicrofacetBeckmannClosure *self = (const BsdfMicrofacetBeckmannClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + float cosNO = dot(m_N, sd->I); + if(cosNO > 0) { + float3 X, Y, Z = m_N; + make_orthonormals(Z, &X, &Y); + // generate a random microfacet normal m + // eq. 35,36: + // we take advantage of cos(atan(x)) == 1/sqrt(1+x^2) + //tttt and sin(atan(x)) == x/sqrt(1+x^2) + float alpha2 = self->m_ab * self->m_ab; + float tanThetaM = sqrtf(-alpha2 * logf(1 - randu)); + float cosThetaM = 1 / sqrtf(1 + tanThetaM * tanThetaM); + float sinThetaM = cosThetaM * tanThetaM; + float phiM = 2 * M_PI_F * randv; + float3 m = (cosf(phiM) * sinThetaM) * X + + (sinf(phiM) * sinThetaM) * Y + + cosThetaM * Z; + + if(self->m_refractive == 0) { + float cosMO = dot(m, sd->I); + if(cosMO > 0) { + // eq. 39 - compute actual reflected direction + *omega_in = 2 * cosMO * m - sd->I; + if(dot(sd->Ng, *omega_in) > 0) { + // microfacet normal is visible to this ray + // eq. 25 + float cosThetaM2 = cosThetaM * cosThetaM; + float tanThetaM2 = tanThetaM * tanThetaM; + float cosThetaM4 = cosThetaM2 * cosThetaM2; + float D = expf(-tanThetaM2 / alpha2) / (M_PI_F * alpha2 * cosThetaM4); + // eq. 24 + float pm = D * cosThetaM; + // convert into pdf of the sampled direction + // eq. 38 - but see also: + // eq. 17 in http://www.graphics.cornell.edu/~bjw/wardnotes.pdf + *pdf = pm * 0.25f / cosMO; + // Eval BRDF*cosNI + float cosNI = dot(m_N, *omega_in); + // eq. 26, 27: now calculate G1(i,m) and G1(o,m) + float ao = 1 / (self->m_ab * sqrtf((1 - cosNO * cosNO) / (cosNO * cosNO))); + float ai = 1 / (self->m_ab * sqrtf((1 - cosNI * cosNI) / (cosNI * cosNI))); + float G1o = ao < 1.6f ? (3.535f * ao + 2.181f * ao * ao) / (1 + 2.276f * ao + 2.577f * ao * ao) : 1.0f; + float G1i = ai < 1.6f ? (3.535f * ai + 2.181f * ai * ai) / (1 + 2.276f * ai + 2.577f * ai * ai) : 1.0f; + float G = G1o * G1i; + // eq. 20: (F*G*D)/(4*in*on) + float out = (G * D) * 0.25f / cosNO; + *eval = make_float3(out, out, out); +#ifdef __RAY_DIFFERENTIALS__ + *domega_in_dx = (2 * dot(m, sd->dI.dx)) * m - sd->dI.dx; + *domega_in_dy = (2 * dot(m, sd->dI.dy)) * m - sd->dI.dy; + // Since there is some blur to this reflection, make the + // derivatives a bit bigger. In theory this varies with the + // roughness but the exact relationship is complex and + // requires more ops than are practical. + *domega_in_dx *= 10; + *domega_in_dy *= 10; +#endif + } + } + } else { + // CAUTION: the i and o variables are inverted relative to the paper + // eq. 39 - compute actual refractive direction + float3 R, T; +#ifdef __RAY_DIFFERENTIALS__ + float3 dRdx, dRdy, dTdx, dTdy; +#endif + bool inside; + fresnel_dielectric(self->m_eta, m, sd->I, &R, &T, +#ifdef __RAY_DIFFERENTIALS__ + sd->dI.dx, sd->dI.dy, &dRdx, &dRdy, &dTdx, &dTdy, +#endif + &inside); + + if(!inside) { + *omega_in = T; +#ifdef __RAY_DIFFERENTIALS__ + *domega_in_dx = dTdx; + *domega_in_dy = dTdy; +#endif + + // eq. 33 + float cosThetaM2 = cosThetaM * cosThetaM; + float tanThetaM2 = tanThetaM * tanThetaM; + float cosThetaM4 = cosThetaM2 * cosThetaM2; + float D = expf(-tanThetaM2 / alpha2) / (M_PI_F * alpha2 * cosThetaM4); + // eq. 24 + float pm = D * cosThetaM; + // eval BRDF*cosNI + float cosNI = dot(m_N, *omega_in); + // eq. 26, 27: now calculate G1(i,m) and G1(o,m) + float ao = 1 / (self->m_ab * sqrtf((1 - cosNO * cosNO) / (cosNO * cosNO))); + float ai = 1 / (self->m_ab * sqrtf((1 - cosNI * cosNI) / (cosNI * cosNI))); + float G1o = ao < 1.6f ? (3.535f * ao + 2.181f * ao * ao) / (1 + 2.276f * ao + 2.577f * ao * ao) : 1.0f; + float G1i = ai < 1.6f ? (3.535f * ai + 2.181f * ai * ai) / (1 + 2.276f * ai + 2.577f * ai * ai) : 1.0f; + float G = G1o * G1i; + // eq. 21 + float cosHI = dot(m, *omega_in); + float cosHO = dot(m, sd->I); + float Ht2 = self->m_eta * cosHI + cosHO; + Ht2 *= Ht2; + float out = (fabsf(cosHI * cosHO) * (self->m_eta * self->m_eta) * (G * D)) / (cosNO * Ht2); + // eq. 38 and eq. 17 + *pdf = pm * (self->m_eta * self->m_eta) * fabsf(cosHI) / Ht2; + *eval = make_float3(out, out, out); +#ifdef __RAY_DIFFERENTIALS__ + // Since there is some blur to this refraction, make the + // derivatives a bit bigger. In theory this varies with the + // roughness but the exact relationship is complex and + // requires more ops than are practical. + *domega_in_dx *= 10; + *domega_in_dy *= 10; +#endif + } + } + } + return (self->m_refractive == 1) ? LABEL_TRANSMIT|LABEL_GLOSSY : LABEL_REFLECT|LABEL_GLOSSY; +} + +CCL_NAMESPACE_END + +#endif /* __BSDF_MICROFACET_H__ */ + diff --git a/intern/cycles/kernel/svm/bsdf_reflection.h b/intern/cycles/kernel/svm/bsdf_reflection.h new file mode 100644 index 00000000000..287cc9c2506 --- /dev/null +++ b/intern/cycles/kernel/svm/bsdf_reflection.h @@ -0,0 +1,95 @@ +/* + * 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. +*/ + +#ifndef __BSDF_REFLECTION_H__ +#define __BSDF_REFLECTION_H__ + +CCL_NAMESPACE_BEGIN + +/* REFLECTION */ + +typedef struct BsdfReflectionClosure { + //float3 m_N; +} BsdfReflectionClosure; + +__device void bsdf_reflection_setup(ShaderData *sd, float3 N) +{ + //BsdfReflectionClosure *self = (BsdfReflectionClosure*)sd->svm_closure_data; + //self->m_N = N; + + sd->svm_closure = CLOSURE_BSDF_REFLECTION_ID; +} + +__device void bsdf_reflection_blur(ShaderData *sd, float roughness) +{ +} + +__device float3 bsdf_reflection_eval_reflect(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + return make_float3(0.0f, 0.0f, 0.0f); +} + +__device float3 bsdf_reflection_eval_transmit(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + return make_float3(0.0f, 0.0f, 0.0f); +} + +__device float bsdf_reflection_albedo(const ShaderData *sd, const float3 I) +{ + return 1.0f; +} + +__device int bsdf_reflection_sample(const ShaderData *sd, float randu, float randv, float3 *eval, float3 *omega_in, float3 *domega_in_dx, float3 *domega_in_dy, float *pdf) +{ + //const BsdfReflectionClosure *self = (const BsdfReflectionClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + // only one direction is possible + float cosNO = dot(m_N, sd->I); + if(cosNO > 0) { + *omega_in = (2 * cosNO) * m_N - sd->I; + if(dot(sd->Ng, *omega_in) > 0) { +#ifdef __RAY_DIFFERENTIALS__ + *domega_in_dx = 2 * dot(m_N, sd->dI.dx) * m_N - sd->dI.dx; + *domega_in_dy = 2 * dot(m_N, sd->dI.dy) * m_N - sd->dI.dy; +#endif + *pdf = 1; + *eval = make_float3(1, 1, 1); + } + } + return LABEL_REFLECT|LABEL_SINGULAR; +} + +CCL_NAMESPACE_END + +#endif /* __BSDF_REFLECTION_H__ */ + diff --git a/intern/cycles/kernel/svm/bsdf_refraction.h b/intern/cycles/kernel/svm/bsdf_refraction.h new file mode 100644 index 00000000000..55a914f8334 --- /dev/null +++ b/intern/cycles/kernel/svm/bsdf_refraction.h @@ -0,0 +1,103 @@ +/* + * 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. +*/ + +#ifndef __BSDF_REFRACTION_H__ +#define __BSDF_REFRACTION_H__ + +CCL_NAMESPACE_BEGIN + +/* REFRACTION */ + +typedef struct BsdfRefractionClosure { + float m_eta; +} BsdfRefractionClosure; + +__device void bsdf_refraction_setup(ShaderData *sd, float3 N, float eta) +{ + BsdfRefractionClosure *self = (BsdfRefractionClosure*)sd->svm_closure_data; + + self->m_eta = eta; + + sd->svm_closure = CLOSURE_BSDF_REFRACTION_ID; +} + +__device void bsdf_refraction_blur(ShaderData *sd, float roughness) +{ +} + +__device float3 bsdf_refraction_eval_reflect(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + return make_float3(0.0f, 0.0f, 0.0f); +} + +__device float3 bsdf_refraction_eval_transmit(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + return make_float3(0.0f, 0.0f, 0.0f); +} + +__device float bsdf_refraction_albedo(const ShaderData *sd, const float3 I) +{ + return 1.0f; +} + +__device int bsdf_refraction_sample(const ShaderData *sd, float randu, float randv, float3 *eval, float3 *omega_in, float3 *domega_in_dx, float3 *domega_in_dy, float *pdf) +{ + const BsdfRefractionClosure *self = (const BsdfRefractionClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + float3 R, T; +#ifdef __RAY_DIFFERENTIALS__ + float3 dRdx, dRdy, dTdx, dTdy; +#endif + bool inside; + fresnel_dielectric(self->m_eta, m_N, sd->I, &R, &T, +#ifdef __RAY_DIFFERENTIALS__ + sd->dI.dx, sd->dI.dy, &dRdx, &dRdy, &dTdx, &dTdy, +#endif + &inside); + + if(!inside) { + *pdf = 1; + *eval = make_float3(1.0f, 1.0f, 1.0f); + *omega_in = T; +#ifdef __RAY_DIFFERENTIALS__ + *domega_in_dx = dTdx; + *domega_in_dy = dTdy; +#endif + } + return LABEL_TRANSMIT|LABEL_SINGULAR; +} + +CCL_NAMESPACE_END + +#endif /* __BSDF_REFRACTION_H__ */ + diff --git a/intern/cycles/kernel/svm/bsdf_transparent.h b/intern/cycles/kernel/svm/bsdf_transparent.h new file mode 100644 index 00000000000..e689e3db357 --- /dev/null +++ b/intern/cycles/kernel/svm/bsdf_transparent.h @@ -0,0 +1,78 @@ +/* + * 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. +*/ + +#ifndef __BSDF_TRANSPARENT_H__ +#define __BSDF_TRANSPARENT_H__ + +CCL_NAMESPACE_BEGIN + +__device void bsdf_transparent_setup(ShaderData *sd) +{ + sd->svm_closure = CLOSURE_BSDF_TRANSPARENT_ID; +} + +__device void bsdf_transparent_blur(ShaderData *sd, float roughness) +{ +} + +__device float3 bsdf_transparent_eval_reflect(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + return make_float3(0.0f, 0.0f, 0.0f); +} + +__device float3 bsdf_transparent_eval_transmit(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + return make_float3(0.0f, 0.0f, 0.0f); +} + +__device float bsdf_transparent_albedo(const ShaderData *sd, const float3 I) +{ + return 1.0f; +} + +__device int bsdf_transparent_sample(const ShaderData *sd, float randu, float randv, float3 *eval, float3 *omega_in, float3 *domega_in_dx, float3 *domega_in_dy, float *pdf) +{ + // only one direction is possible + *omega_in = -sd->I; +#ifdef __RAY_DIFFERENTIALS__ + *domega_in_dx = -sd->dI.dx; + *domega_in_dy = -sd->dI.dy; +#endif + *pdf = 1; + *eval = make_float3(1, 1, 1); + return LABEL_TRANSMIT|LABEL_STRAIGHT; +} + +CCL_NAMESPACE_END + +#endif /* __BSDF_TRANSPARENT_H__ */ + diff --git a/intern/cycles/kernel/svm/bsdf_ward.h b/intern/cycles/kernel/svm/bsdf_ward.h new file mode 100644 index 00000000000..bf591acc9fa --- /dev/null +++ b/intern/cycles/kernel/svm/bsdf_ward.h @@ -0,0 +1,202 @@ +/* + * 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. +*/ + +#ifndef __BSDF_WARD_H__ +#define __BSDF_WARD_H__ + +CCL_NAMESPACE_BEGIN + +/* WARD */ + +typedef struct BsdfWardClosure { + //float3 m_N; + //float3 m_T; + float m_ax; + float m_ay; +} BsdfWardClosure; + +__device void bsdf_ward_setup(ShaderData *sd, float3 N, float3 T, float ax, float ay) +{ + BsdfWardClosure *self = (BsdfWardClosure*)sd->svm_closure_data; + + //self->m_N = N; + //self->m_T = T; + self->m_ax = clamp(ax, 1e-5f, 1.0f); + self->m_ay = clamp(ay, 1e-5f, 1.0f); + + sd->svm_closure = CLOSURE_BSDF_WARD_ID; + sd->flag |= SD_BSDF_HAS_EVAL|SD_BSDF_GLOSSY; +} + +__device void bsdf_ward_blur(ShaderData *sd, float roughness) +{ + BsdfWardClosure *self = (BsdfWardClosure*)sd->svm_closure_data; + + self->m_ax = fmaxf(roughness, self->m_ax); + self->m_ay = fmaxf(roughness, self->m_ay); +} + +__device float3 bsdf_ward_eval_reflect(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + const BsdfWardClosure *self = (const BsdfWardClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + float3 m_T = normalize(sd->dPdu); + + float cosNO = dot(m_N, I); + float cosNI = dot(m_N, omega_in); + if(cosNI > 0 && cosNO > 0) { + // get half vector and get x,y basis on the surface for anisotropy + float3 H = normalize(omega_in + I); // normalize needed for pdf + float3 X, Y; + make_orthonormals_tangent(m_N, m_T, &X, &Y); + // eq. 4 + float dotx = dot(H, X) / self->m_ax; + float doty = dot(H, Y) / self->m_ay; + float dotn = dot(H, m_N); + float exp_arg = (dotx * dotx + doty * doty) / (dotn * dotn); + float denom = (4 * M_PI_F * self->m_ax * self->m_ay * sqrtf(cosNO * cosNI)); + float exp_val = expf(-exp_arg); + float out = cosNI * exp_val / denom; + float oh = dot(H, I); + denom = 4 * M_PI_F * self->m_ax * self->m_ay * oh * dotn * dotn * dotn; + *pdf = exp_val / denom; + return make_float3 (out, out, out); + } + return make_float3 (0, 0, 0); +} + +__device float3 bsdf_ward_eval_transmit(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + return make_float3(0.0f, 0.0f, 0.0f); +} + +__device float bsdf_ward_albedo(const ShaderData *sd, const float3 I) +{ + return 1.0f; +} + +__device int bsdf_ward_sample(const ShaderData *sd, float randu, float randv, float3 *eval, float3 *omega_in, float3 *domega_in_dx, float3 *domega_in_dy, float *pdf) +{ + const BsdfWardClosure *self = (const BsdfWardClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + float3 m_T = normalize(sd->dPdu); + + float cosNO = dot(m_N, sd->I); + if(cosNO > 0) { + // get x,y basis on the surface for anisotropy + float3 X, Y; + make_orthonormals_tangent(m_N, m_T, &X, &Y); + // generate random angles for the half vector + // eq. 7 (taking care around discontinuities to keep + //ttoutput angle in the right quadrant) + // we take advantage of cos(atan(x)) == 1/sqrt(1+x^2) + //tttt and sin(atan(x)) == x/sqrt(1+x^2) + float alphaRatio = self->m_ay / self->m_ax; + float cosPhi, sinPhi; + if(randu < 0.25f) { + float val = 4 * randu; + float tanPhi = alphaRatio * tanf(M_PI_2_F * val); + cosPhi = 1 / sqrtf(1 + tanPhi * tanPhi); + sinPhi = tanPhi * cosPhi; + } else if(randu < 0.5f) { + float val = 1 - 4 * (0.5f - randu); + float tanPhi = alphaRatio * tanf(M_PI_2_F * val); + // phi = M_PI_F - phi; + cosPhi = -1 / sqrtf(1 + tanPhi * tanPhi); + sinPhi = -tanPhi * cosPhi; + } else if(randu < 0.75f) { + float val = 4 * (randu - 0.5f); + float tanPhi = alphaRatio * tanf(M_PI_2_F * val); + //phi = M_PI_F + phi; + cosPhi = -1 / sqrtf(1 + tanPhi * tanPhi); + sinPhi = tanPhi * cosPhi; + } else { + float val = 1 - 4 * (1 - randu); + float tanPhi = alphaRatio * tanf(M_PI_2_F * val); + // phi = 2 * M_PI_F - phi; + cosPhi = 1 / sqrtf(1 + tanPhi * tanPhi); + sinPhi = -tanPhi * cosPhi; + } + // eq. 6 + // we take advantage of cos(atan(x)) == 1/sqrt(1+x^2) + //tttt and sin(atan(x)) == x/sqrt(1+x^2) + float thetaDenom = (cosPhi * cosPhi) / (self->m_ax * self->m_ax) + (sinPhi * sinPhi) / (self->m_ay * self->m_ay); + float tanTheta2 = -logf(1 - randv) / thetaDenom; + float cosTheta = 1 / sqrtf(1 + tanTheta2); + float sinTheta = cosTheta * sqrtf(tanTheta2); + + float3 h; // already normalized becaused expressed from spherical coordinates + h.x = sinTheta * cosPhi; + h.y = sinTheta * sinPhi; + h.z = cosTheta; + // compute terms that are easier in local space + float dotx = h.x / self->m_ax; + float doty = h.y / self->m_ay; + float dotn = h.z; + // transform to world space + h = h.x * X + h.y * Y + h.z * m_N; + // generate the final sample + float oh = dot(h, sd->I); + omega_in->x = 2 * oh * h.x - sd->I.x; + omega_in->y = 2 * oh * h.y - sd->I.y; + omega_in->z = 2 * oh * h.z - sd->I.z; + if(dot(sd->Ng, *omega_in) > 0) { + float cosNI = dot(m_N, *omega_in); + if(cosNI > 0) { + // eq. 9 + float exp_arg = (dotx * dotx + doty * doty) / (dotn * dotn); + float denom = 4 * M_PI_F * self->m_ax * self->m_ay * oh * dotn * dotn * dotn; + *pdf = expf(-exp_arg) / denom; + // compiler will reuse expressions already computed + denom = (4 * M_PI_F * self->m_ax * self->m_ay * sqrtf(cosNO * cosNI)); + float power = cosNI * expf(-exp_arg) / denom; + *eval = make_float3(power, power, power); +#ifdef __RAY_DIFFERENTIALS__ + *domega_in_dx = (2 * dot(m_N, sd->dI.dx)) * m_N - sd->dI.dx; + *domega_in_dy = (2 * dot(m_N, sd->dI.dy)) * m_N - sd->dI.dy; + // Since there is some blur to this reflection, make the + // derivatives a bit bigger. In theory this varies with the + // roughness but the exact relationship is complex and + // requires more ops than are practical. + *domega_in_dx *= 10; + *domega_in_dy *= 10; +#endif + } + } + } + return LABEL_REFLECT|LABEL_GLOSSY; +} + +CCL_NAMESPACE_END + +#endif /* __BSDF_WARD_H__ */ + diff --git a/intern/cycles/kernel/svm/bsdf_westin.h b/intern/cycles/kernel/svm/bsdf_westin.h new file mode 100644 index 00000000000..7fe10f10dfc --- /dev/null +++ b/intern/cycles/kernel/svm/bsdf_westin.h @@ -0,0 +1,212 @@ +/* + * 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. +*/ + +#ifndef __BSDF_WESTIN_H__ +#define __BSDF_WESTIN_H__ + +CCL_NAMESPACE_BEGIN + +/* WESTIN BACKSCATTER */ + +typedef struct BsdfWestinBackscatterClosure { + //float3 m_N; + float m_invroughness; +} BsdfWestinBackscatterClosure; + +__device void bsdf_westin_backscatter_setup(ShaderData *sd, float3 N, float roughness) +{ + BsdfWestinBackscatterClosure *self = (BsdfWestinBackscatterClosure*)sd->svm_closure_data; + + //self->m_N = N; + roughness = clamp(roughness, 1e-5f, 1.0f); + self->m_invroughness = 1.0f/roughness; + + sd->svm_closure = CLOSURE_BSDF_WESTIN_BACKSCATTER_ID; + sd->flag |= SD_BSDF_HAS_EVAL|SD_BSDF_GLOSSY; +} + +__device void bsdf_westin_backscatter_blur(ShaderData *sd, float roughness) +{ + BsdfWestinBackscatterClosure *self = (BsdfWestinBackscatterClosure*)sd->svm_closure_data; + self->m_invroughness = min(1.0f/roughness, self->m_invroughness); +} + +__device float3 bsdf_westin_backscatter_eval_reflect(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + const BsdfWestinBackscatterClosure *self = (const BsdfWestinBackscatterClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + // pdf is implicitly 0 (no indirect sampling) + float cosNO = dot(m_N, I); + float cosNI = dot(m_N, omega_in); + if(cosNO > 0 && cosNI > 0) { + float cosine = dot(I, omega_in); + *pdf = cosine > 0 ? (self->m_invroughness + 1) * powf(cosine, self->m_invroughness) : 0; + *pdf *= 0.5f * M_1_PI_F; + return make_float3 (*pdf, *pdf, *pdf); + } + return make_float3 (0, 0, 0); +} + +__device float3 bsdf_westin_backscatter_eval_transmit(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + return make_float3(0.0f, 0.0f, 0.0f); +} + +__device float bsdf_westin_backscatter_albedo(const ShaderData *sd, const float3 I) +{ + return 1.0f; +} + +__device int bsdf_westin_backscatter_sample(const ShaderData *sd, float randu, float randv, float3 *eval, float3 *omega_in, float3 *domega_in_dx, float3 *domega_in_dy, float *pdf) +{ + const BsdfWestinBackscatterClosure *self = (const BsdfWestinBackscatterClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + float cosNO = dot(m_N, sd->I); + if(cosNO > 0) { +#ifdef __RAY_DIFFERENTIALS__ + *domega_in_dx = sd->dI.dx; + *domega_in_dy = sd->dI.dy; +#endif + float3 T, B; + make_orthonormals (sd->I, &T, &B); + float phi = 2 * M_PI_F * randu; + float cosTheta = powf(randv, 1 / (self->m_invroughness + 1)); + float sinTheta2 = 1 - cosTheta * cosTheta; + float sinTheta = sinTheta2 > 0 ? sqrtf(sinTheta2) : 0; + *omega_in = (cosf(phi) * sinTheta) * T + + (sinf(phi) * sinTheta) * B + + (cosTheta) * sd->I; + if(dot(sd->Ng, *omega_in) > 0) + { + // common terms for pdf and eval + float cosNI = dot(m_N, *omega_in); + // make sure the direction we chose is still in the right hemisphere + if(cosNI > 0) + { + *pdf = 0.5f * M_1_PI_F * powf(cosTheta, self->m_invroughness); + *pdf = (self->m_invroughness + 1) * (*pdf); + *eval = make_float3(*pdf, *pdf, *pdf); +#ifdef __RAY_DIFFERENTIALS__ + // Since there is some blur to this reflection, make the + // derivatives a bit bigger. In theory this varies with the + // exponent but the exact relationship is complex and + // requires more ops than are practical. + *domega_in_dx *= 10; + *domega_in_dy *= 10; +#endif + } + } + } + return LABEL_REFLECT|LABEL_GLOSSY; +} + +/* WESTIN SHEEN */ + +typedef struct BsdfWestinSheenClosure { + //float3 m_N; + float m_edginess; +} BsdfWestinSheenClosure; + +__device void bsdf_westin_sheen_setup(ShaderData *sd, float3 N, float edginess) +{ + BsdfWestinSheenClosure *self = (BsdfWestinSheenClosure*)sd->svm_closure_data; + + //self->m_N = N; + self->m_edginess = edginess; + + sd->svm_closure = CLOSURE_BSDF_WESTIN_SHEEN_ID; + sd->flag |= SD_BSDF_HAS_EVAL|SD_BSDF_GLOSSY; +} + +__device void bsdf_westin_sheen_blur(ShaderData *sd, float roughness) +{ +} + +__device float3 bsdf_westin_sheen_eval_reflect(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + const BsdfWestinSheenClosure *self = (const BsdfWestinSheenClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + // pdf is implicitly 0 (no indirect sampling) + float cosNO = dot(m_N, I); + float cosNI = dot(m_N, omega_in); + if(cosNO > 0 && cosNI > 0) { + float sinNO2 = 1 - cosNO * cosNO; + *pdf = cosNI * M_1_PI_F; + float westin = sinNO2 > 0 ? powf(sinNO2, 0.5f * self->m_edginess) * (*pdf) : 0; + return make_float3 (westin, westin, westin); + } + return make_float3 (0, 0, 0); +} + +__device float3 bsdf_westin_sheen_eval_transmit(const ShaderData *sd, const float3 I, const float3 omega_in, float *pdf) +{ + return make_float3(0.0f, 0.0f, 0.0f); +} + +__device float bsdf_westin_sheen_albedo(const ShaderData *sd, const float3 I) +{ + return 1.0f; +} + +__device int bsdf_westin_sheen_sample(const ShaderData *sd, float randu, float randv, float3 *eval, float3 *omega_in, float3 *domega_in_dx, float3 *domega_in_dy, float *pdf) +{ + const BsdfWestinSheenClosure *self = (const BsdfWestinSheenClosure*)sd->svm_closure_data; + float3 m_N = sd->N; + + // we are viewing the surface from the right side - send a ray out with cosine + // distribution over the hemisphere + sample_cos_hemisphere(m_N, randu, randv, omega_in, pdf); + if(dot(sd->Ng, *omega_in) > 0) { + // TODO: account for sheen when sampling + float cosNO = dot(m_N, sd->I); + float sinNO2 = 1 - cosNO * cosNO; + float westin = sinNO2 > 0 ? powf(sinNO2, 0.5f * self->m_edginess) * (*pdf) : 0; + *eval = make_float3(westin, westin, westin); +#ifdef __RAY_DIFFERENTIALS__ + // TODO: find a better approximation for the diffuse bounce + *domega_in_dx = (2 * dot(m_N, sd->dI.dx)) * m_N - sd->dI.dx; + *domega_in_dy = (2 * dot(m_N, sd->dI.dy)) * m_N - sd->dI.dy; + *domega_in_dx *= 125; + *domega_in_dy *= 125; +#endif + } else + pdf = 0; + return LABEL_REFLECT|LABEL_DIFFUSE; +} + +CCL_NAMESPACE_END + +#endif /* __BSDF_WESTIN_H__ */ + diff --git a/intern/cycles/kernel/svm/emissive.h b/intern/cycles/kernel/svm/emissive.h new file mode 100644 index 00000000000..ed2b2e4aee8 --- /dev/null +++ b/intern/cycles/kernel/svm/emissive.h @@ -0,0 +1,83 @@ +/* + * 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 + +/* EMISSION CLOSURE */ + +__device float3 emissive_eval(const float3 Ng, const float3 I) +{ + float cosNO = fabsf(dot(Ng, I)); + float res = (cosNO > 0.0f)? M_1_PI_F: 0.0f; + + return make_float3(res, res, res); +} + +__device void emissive_sample(const float3 Ng, float randu, float randv, float3 *I, float *pdf) +{ + // We don't do anything sophisticated here for the step + // We just sample the whole cone uniformly to the cosine + float3 T, B; + make_orthonormals(Ng, &T, &B); + float phi = 2 * M_PI_F * randu; + + float cosTheta = sqrtf(1.0f - 1.0f * randv); + float sinTheta = sqrtf(1.0f - cosTheta * cosTheta); + *I = (cosf(phi) * sinTheta) * T + + (sinf(phi) * sinTheta) * B + + cosTheta * Ng; + + *pdf = M_1_PI_F; +} + +/// Return the probability distribution function in the direction I, +/// given the parameters and the light's surface normal. This MUST match +/// the PDF computed by sample(). +__device float emissive_pdf(const float3 Ng, const float3 I) +{ + float cosNO = fabsf(dot(Ng, I)); + return (cosNO > 0.0f)? M_1_PI_F: 0.0f; +} + +__device float3 svm_emissive_eval(ShaderData *sd) +{ + return sd->svm_closure_weight*emissive_eval(sd->Ng, sd->I); +} + +__device void svm_emissive_sample(ShaderData *sd, float randu, float randv, float3 *eval, float3 *I, float *pdf) +{ + *eval = sd->svm_closure_weight; + emissive_sample(sd->Ng, randu, randv, I, pdf); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm.h b/intern/cycles/kernel/svm/svm.h new file mode 100644 index 00000000000..5bd076c9cab --- /dev/null +++ b/intern/cycles/kernel/svm/svm.h @@ -0,0 +1,271 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __SVM_H__ +#define __SVM_H__ + +/* Shader Virtual Machine + * + * A shader is a list of nodes to be executed. These are simply read one after + * the other and executed, using an node counter. Each node and it's associated + * data is encoded as one or more uint4's in a 1D texture. If the data is larger + * than an uint4, the node can increase the node counter to compensate for this. + * Floats are encoded as int and then converted to float again. + * + * Nodes write their output into a stack. All stack data in the stack is + * floats, since it's all factors, colors and vectors. The stack will be stored + * in local memory on the GPU, as it would take too many register and indexes in + * ways not known at compile time. This seems the only solution even though it + * may be slow, with two positive factors. If the same shader is being executed, + * memory access will be coalesced, and on fermi cards, memory will actually be + * cached. + * + * The result of shader execution will be a single closure. This means the + * closure type, associated label, data and weight. Sampling from multiple + * closures is supported through the mix closure node, the logic for that is + * mostly taken care of in the SVM compiler. + */ + +#include "svm_types.h" + +CCL_NAMESPACE_BEGIN + +/* Stack */ + +__device float3 stack_load_float3(float *stack, uint a) +{ + kernel_assert(a+2 < SVM_STACK_SIZE); + + return make_float3(stack[a+0], stack[a+1], stack[a+2]); +} + +__device void stack_store_float3(float *stack, uint a, float3 f) +{ + kernel_assert(a+2 < SVM_STACK_SIZE); + + stack[a+0] = f.x; + stack[a+1] = f.y; + stack[a+2] = f.z; +} + +__device float stack_load_float(float *stack, uint a) +{ + kernel_assert(a < SVM_STACK_SIZE); + + return stack[a]; +} + +__device float stack_load_float_default(float *stack, uint a, uint value) +{ + return (a == (uint)SVM_STACK_INVALID)? __int_as_float(value): stack_load_float(stack, a); +} + +__device void stack_store_float(float *stack, uint a, float f) +{ + kernel_assert(a < SVM_STACK_SIZE); + + stack[a] = f; +} + +__device bool stack_valid(uint a) +{ + return a != (uint)SVM_STACK_INVALID; +} + +/* Reading Nodes */ + +__device uint4 read_node(KernelGlobals *kg, int *offset) +{ + uint4 node = kernel_tex_fetch(__svm_nodes, *offset); + (*offset)++; + return node; +} + +__device float4 read_node_float(KernelGlobals *kg, int *offset) +{ + uint4 node = kernel_tex_fetch(__svm_nodes, *offset); + float4 f = make_float4(__int_as_float(node.x), __int_as_float(node.y), __int_as_float(node.z), __int_as_float(node.w)); + (*offset)++; + return f; +} + +__device void decode_node_uchar4(uint i, uint *x, uint *y, uint *z, uint *w) +{ + if(x) *x = (i & 0xFF); + if(y) *y = ((i >> 8) & 0xFF); + if(z) *z = ((i >> 16) & 0xFF); + if(w) *w = ((i >> 24) & 0xFF); +} + +CCL_NAMESPACE_END + +/* Nodes */ + +#include "svm_noise.h" +#include "svm_texture.h" + +#include "svm_attribute.h" +#include "svm_blend.h" +#include "svm_closure.h" +#include "svm_clouds.h" +#include "svm_convert.h" +#include "svm_displace.h" +#include "svm_distorted_noise.h" +#include "svm_fresnel.h" +#include "svm_geometry.h" +#include "svm_image.h" +#include "svm_light_path.h" +#include "svm_magic.h" +#include "svm_mapping.h" +#include "svm_marble.h" +#include "svm_math.h" +#include "svm_mix.h" +#include "svm_musgrave.h" +#include "svm_noisetex.h" +#include "svm_sky.h" +#include "svm_stucci.h" +#include "svm_tex_coord.h" +#include "svm_value.h" +#include "svm_voronoi.h" +#include "svm_wood.h" + +CCL_NAMESPACE_BEGIN + +/* Main Interpreter Loop */ + +__device void svm_eval_nodes(KernelGlobals *kg, ShaderData *sd, ShaderType type, float randb, int path_flag) +{ + float stack[SVM_STACK_SIZE]; + float closure_weight = 1.0f; + int offset = sd->shader; + + sd->svm_closure = NBUILTIN_CLOSURES; + sd->svm_closure_weight = make_float3(0.0f, 0.0f, 0.0f); + + while(1) { + uint4 node = read_node(kg, &offset); + + if(node.x == NODE_SHADER_JUMP) { + if(type == SHADER_TYPE_SURFACE) offset = node.y; + else if(type == SHADER_TYPE_VOLUME) offset = node.z; + else if(type == SHADER_TYPE_DISPLACEMENT) offset = node.w; + else return; + } + else if(node.x == NODE_CLOSURE_BSDF) + svm_node_closure_bsdf(sd, node.y, node.z, node.w, randb); + else if(node.x == NODE_CLOSURE_EMISSION) + svm_node_closure_emission(sd); + else if(node.x == NODE_CLOSURE_BACKGROUND) + svm_node_closure_background(sd); + else if(node.x == NODE_CLOSURE_SET_WEIGHT) + svm_node_closure_set_weight(sd, node.y, node.z, node.w); + else if(node.x == NODE_CLOSURE_WEIGHT) + svm_node_closure_weight(sd, stack, node.y); + else if(node.x == NODE_EMISSION_WEIGHT) + svm_node_emission_weight(kg, sd, stack, node); + else if(node.x == NODE_MIX_CLOSURE) + svm_node_mix_closure(sd, stack, node.y, node.z, &offset, &randb); + else if(node.x == NODE_ADD_CLOSURE) + svm_node_add_closure(sd, stack, node.y, node.z, &offset, &randb, &closure_weight); + else if(node.x == NODE_JUMP) + offset = node.y; +#ifdef __TEXTURES__ + else if(node.x == NODE_TEX_NOISE_F) + svm_node_tex_noise_f(sd, stack, node.y, node.z); + else if(node.x == NODE_TEX_NOISE_V) + svm_node_tex_noise_v(sd, stack, node.y, node.z); + else if(node.x == NODE_TEX_IMAGE) + svm_node_tex_image(kg, sd, stack, node.y, node.z, node.w); + else if(node.x == NODE_TEX_ENVIRONMENT) + svm_node_tex_environment(kg, sd, stack, node.y, node.z, node.w); + else if(node.x == NODE_TEX_SKY) + svm_node_tex_sky(kg, sd, stack, node.y, node.z); + else if(node.x == NODE_TEX_BLEND) + svm_node_tex_blend(sd, stack, node); + else if(node.x == NODE_TEX_CLOUDS) + svm_node_tex_clouds(sd, stack, node); + else if(node.x == NODE_TEX_VORONOI) + svm_node_tex_voronoi(kg, sd, stack, node, &offset); + else if(node.x == NODE_TEX_MUSGRAVE) + svm_node_tex_musgrave(kg, sd, stack, node, &offset); + else if(node.x == NODE_TEX_MARBLE) + svm_node_tex_marble(kg, sd, stack, node, &offset); + else if(node.x == NODE_TEX_MAGIC) + svm_node_tex_magic(sd, stack, node); + else if(node.x == NODE_TEX_STUCCI) + svm_node_tex_stucci(kg, sd, stack, node, &offset); + else if(node.x == NODE_TEX_DISTORTED_NOISE) + svm_node_tex_distorted_noise(kg, sd, stack, node, &offset); + else if(node.x == NODE_TEX_WOOD) + svm_node_tex_wood(kg, sd, stack, node, &offset); +#endif + else if(node.x == NODE_GEOMETRY) + svm_node_geometry(sd, stack, node.y, node.z); + else if(node.x == NODE_GEOMETRY_BUMP_DX) + svm_node_geometry_bump_dx(sd, stack, node.y, node.z); + else if(node.x == NODE_GEOMETRY_BUMP_DY) + svm_node_geometry_bump_dy(sd, stack, node.y, node.z); + else if(node.x == NODE_LIGHT_PATH) + svm_node_light_path(sd, stack, node.y, node.z, path_flag); + else if(node.x == NODE_CONVERT) + svm_node_convert(sd, stack, node.y, node.z, node.w); + else if(node.x == NODE_VALUE_F) + svm_node_value_f(kg, sd, stack, node.y, node.z); + else if(node.x == NODE_VALUE_V) + svm_node_value_v(kg, sd, stack, node.y, &offset); + else if(node.x == NODE_MIX) + svm_node_mix(kg, sd, stack, node.y, node.z, node.w, &offset); + else if(node.x == NODE_ATTR) + svm_node_attr(kg, sd, stack, node); + else if(node.x == NODE_ATTR_BUMP_DX) + svm_node_attr_bump_dx(kg, sd, stack, node); + else if(node.x == NODE_ATTR_BUMP_DY) + svm_node_attr_bump_dy(kg, sd, stack, node); + else if(node.x == NODE_FRESNEL) + svm_node_fresnel(sd, stack, node.y, node.z, node.w); + else if(node.x == NODE_SET_DISPLACEMENT) + svm_node_set_displacement(sd, stack, node.y); + else if(node.x == NODE_SET_BUMP) + svm_node_set_bump(sd, stack, node.y, node.z, node.w); + else if(node.x == NODE_MATH) + svm_node_math(kg, sd, stack, node.y, node.z, node.w, &offset); + else if(node.x == NODE_VECTOR_MATH) + svm_node_vector_math(kg, sd, stack, node.y, node.z, node.w, &offset); + else if(node.x == NODE_MAPPING) + svm_node_mapping(kg, sd, stack, node.y, node.z, &offset); + else if(node.x == NODE_TEX_COORD) + svm_node_tex_coord(kg, sd, stack, node.y, node.z); + else if(node.x == NODE_TEX_COORD_BUMP_DX) + svm_node_tex_coord_bump_dx(kg, sd, stack, node.y, node.z); + else if(node.x == NODE_TEX_COORD_BUMP_DY) + svm_node_tex_coord_bump_dy(kg, sd, stack, node.y, node.z); + else if(node.x == NODE_EMISSION_SET_WEIGHT_TOTAL) + svm_node_emission_set_weight_total(kg, sd, node.y, node.z, node.w); + else if(node.x == NODE_END) + break; + else + return; + } + + sd->svm_closure_weight *= closure_weight; +} + +CCL_NAMESPACE_END + +#endif /* __SVM_H__ */ + diff --git a/intern/cycles/kernel/svm/svm_attribute.h b/intern/cycles/kernel/svm/svm_attribute.h new file mode 100644 index 00000000000..3a94f08d42f --- /dev/null +++ b/intern/cycles/kernel/svm/svm_attribute.h @@ -0,0 +1,154 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Attribute Node */ + +__device void svm_node_attr_init(KernelGlobals *kg, ShaderData *sd, + uint4 node, NodeAttributeType *type, + NodeAttributeType *mesh_type, AttributeElement *elem, uint *offset, uint *out_offset) +{ + if(sd->object != ~0) { + /* find attribute by unique id */ + uint id = node.y; + uint attr_offset = sd->object*kernel_data.bvh.attributes_map_stride; + uint4 attr_map = kernel_tex_fetch(__attributes_map, attr_offset); + + while(attr_map.x != id) + attr_map = kernel_tex_fetch(__attributes_map, ++attr_offset); + + /* return result */ + *elem = (AttributeElement)attr_map.y; + *offset = attr_map.z; + *mesh_type = (NodeAttributeType)attr_map.w; + } + else { + /* background */ + *elem = ATTR_ELEMENT_NONE; + *offset = 0; + *mesh_type = (NodeAttributeType)node.w; + } + + *out_offset = node.z; + *type = (NodeAttributeType)node.w; +} + +__device void svm_node_attr(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node) +{ + NodeAttributeType type, mesh_type; + AttributeElement elem; + uint offset, out_offset; + + svm_node_attr_init(kg, sd, node, &type, &mesh_type, &elem, &offset, &out_offset); + + /* fetch and store attribute */ + if(type == NODE_ATTR_FLOAT) { + if(mesh_type == NODE_ATTR_FLOAT) { + float f = triangle_attribute_float(kg, sd, elem, offset, NULL, NULL); + stack_store_float(stack, out_offset, f); + } + else { + float3 f = triangle_attribute_float3(kg, sd, elem, offset, NULL, NULL); + stack_store_float(stack, out_offset, average(f)); + } + } + else { + if(mesh_type == NODE_ATTR_FLOAT3) { + float3 f = triangle_attribute_float3(kg, sd, elem, offset, NULL, NULL); + stack_store_float3(stack, out_offset, f); + } + else { + float f = triangle_attribute_float(kg, sd, elem, offset, NULL, NULL); + stack_store_float3(stack, out_offset, make_float3(f, f, f)); + } + } +} + +__device void svm_node_attr_bump_dx(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node) +{ + NodeAttributeType type, mesh_type; + AttributeElement elem; + uint offset, out_offset; + + svm_node_attr_init(kg, sd, node, &type, &mesh_type, &elem, &offset, &out_offset); + + /* fetch and store attribute */ + if(type == NODE_ATTR_FLOAT) { + if(mesh_type == NODE_ATTR_FLOAT) { + float dx; + float f = triangle_attribute_float(kg, sd, elem, offset, &dx, NULL); + stack_store_float(stack, out_offset, f+dx); + } + else { + float3 dx; + float3 f = triangle_attribute_float3(kg, sd, elem, offset, &dx, NULL); + stack_store_float(stack, out_offset, average(f+dx)); + } + } + else { + if(mesh_type == NODE_ATTR_FLOAT3) { + float3 dx; + float3 f = triangle_attribute_float3(kg, sd, elem, offset, &dx, NULL); + stack_store_float3(stack, out_offset, f+dx); + } + else { + float dx; + float f = triangle_attribute_float(kg, sd, elem, offset, &dx, NULL); + stack_store_float3(stack, out_offset, make_float3(f+dx, f+dx, f+dx)); + } + } +} + +__device void svm_node_attr_bump_dy(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node) +{ + NodeAttributeType type, mesh_type; + AttributeElement elem; + uint offset, out_offset; + + svm_node_attr_init(kg, sd, node, &type, &mesh_type, &elem, &offset, &out_offset); + + /* fetch and store attribute */ + if(type == NODE_ATTR_FLOAT) { + if(mesh_type == NODE_ATTR_FLOAT) { + float dy; + float f = triangle_attribute_float(kg, sd, elem, offset, NULL, &dy); + stack_store_float(stack, out_offset, f+dy); + } + else { + float3 dy; + float3 f = triangle_attribute_float3(kg, sd, elem, offset, NULL, &dy); + stack_store_float(stack, out_offset, average(f+dy)); + } + } + else { + if(mesh_type == NODE_ATTR_FLOAT3) { + float3 dy; + float3 f = triangle_attribute_float3(kg, sd, elem, offset, NULL, &dy); + stack_store_float3(stack, out_offset, f+dy); + } + else { + float dy; + float f = triangle_attribute_float(kg, sd, elem, offset, NULL, &dy); + stack_store_float3(stack, out_offset, make_float3(f+dy, f+dy, f+dy)); + } + } +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_blend.h b/intern/cycles/kernel/svm/svm_blend.h new file mode 100644 index 00000000000..b1be7b7f6bc --- /dev/null +++ b/intern/cycles/kernel/svm/svm_blend.h @@ -0,0 +1,79 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Blend */ + +__device float svm_blend(float3 p, NodeBlendType type, NodeBlendAxis axis) +{ + float x, y; + + if(axis == NODE_BLEND_VERTICAL) { + x= p.y; + y= p.x; + } + else { + x= p.x; + y= p.y; + } + + if(type == NODE_BLEND_LINEAR) { + return (1.0f + x)/2.0f; + } + else if(type == NODE_BLEND_QUADRATIC) { + float r = fmaxf((1.0f + x)/2.0f, 0.0f); + return r*r; + } + else if(type == NODE_BLEND_EASING) { + float r = min(fmaxf((1.0f + x)/2.0f, 0.0f), 1.0f); + float t = r*r; + + return (3.0f*t - 2.0f*t*r); + } + else if(type == NODE_BLEND_DIAGONAL) { + return (2.0f + x + y)/4.0f; + } + else if(type == NODE_BLEND_RADIAL) { + return atan2(y, x)/(2.0f*M_PI_F) + 0.5f; + } + else { + float r = fmaxf(1.0f - sqrtf(x*x + y*y + p.z*p.z), 0.0f); + + if(type == NODE_BLEND_QUADRATIC_SPHERE) + return r*r; + else if(type == NODE_BLEND_SPHERICAL) + return r; + } + + return 0.0f; +} + +__device void svm_node_tex_blend(ShaderData *sd, float *stack, uint4 node) +{ + float3 co = stack_load_float3(stack, node.z); + uint type, axis; + + decode_node_uchar4(node.y, &type, &axis, NULL, NULL); + + float f = svm_blend(co, (NodeBlendType)type, (NodeBlendAxis)axis); + stack_store_float(stack, node.w, f); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_bsdf.h b/intern/cycles/kernel/svm/svm_bsdf.h new file mode 100644 index 00000000000..f02dc786c6b --- /dev/null +++ b/intern/cycles/kernel/svm/svm_bsdf.h @@ -0,0 +1,228 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "bsdf_ashikhmin_velvet.h" +#include "bsdf_diffuse.h" +#include "bsdf_microfacet.h" +#include "bsdf_reflection.h" +#include "bsdf_refraction.h" +#include "bsdf_transparent.h" +#ifdef __DPDU__ +#include "bsdf_ward.h" +#endif +#include "bsdf_westin.h" + +CCL_NAMESPACE_BEGIN + +__device int svm_bsdf_sample(const ShaderData *sd, float randu, float randv, float3 *eval, float3 *omega_in, differential3 *domega_in, float *pdf) +{ + int label; + + switch(sd->svm_closure) { + case CLOSURE_BSDF_DIFFUSE_ID: + label = bsdf_diffuse_sample(sd, randu, randv, eval, omega_in, &domega_in->dx, &domega_in->dy, pdf); + break; + case CLOSURE_BSDF_TRANSLUCENT_ID: + label = bsdf_translucent_sample(sd, randu, randv, eval, omega_in, &domega_in->dx, &domega_in->dy, pdf); + break; + case CLOSURE_BSDF_REFLECTION_ID: + label = bsdf_reflection_sample(sd, randu, randv, eval, omega_in, &domega_in->dx, &domega_in->dy, pdf); + break; + case CLOSURE_BSDF_REFRACTION_ID: + label = bsdf_refraction_sample(sd, randu, randv, eval, omega_in, &domega_in->dx, &domega_in->dy, pdf); + break; + case CLOSURE_BSDF_TRANSPARENT_ID: + label = bsdf_transparent_sample(sd, randu, randv, eval, omega_in, &domega_in->dx, &domega_in->dy, pdf); + break; + case CLOSURE_BSDF_MICROFACET_GGX_ID: + case CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID: + label = bsdf_microfacet_ggx_sample(sd, randu, randv, eval, omega_in, &domega_in->dx, &domega_in->dy, pdf); + break; + case CLOSURE_BSDF_MICROFACET_BECKMANN_ID: + case CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID: + label = bsdf_microfacet_beckmann_sample(sd, randu, randv, eval, omega_in, &domega_in->dx, &domega_in->dy, pdf); + break; +#ifdef __DPDU__ + case CLOSURE_BSDF_WARD_ID: + label = bsdf_ward_sample(sd, randu, randv, eval, omega_in, &domega_in->dx, &domega_in->dy, pdf); + break; +#endif + case CLOSURE_BSDF_ASHIKHMIN_VELVET_ID: + label = bsdf_ashikhmin_velvet_sample(sd, randu, randv, eval, omega_in, &domega_in->dx, &domega_in->dy, pdf); + break; + case CLOSURE_BSDF_WESTIN_BACKSCATTER_ID: + label = bsdf_westin_backscatter_sample(sd, randu, randv, eval, omega_in, &domega_in->dx, &domega_in->dy, pdf); + break; + case CLOSURE_BSDF_WESTIN_SHEEN_ID: + label = bsdf_westin_sheen_sample(sd, randu, randv, eval, omega_in, &domega_in->dx, &domega_in->dy, pdf); + break; + default: + label = LABEL_NONE; + break; + } + + *eval *= sd->svm_closure_weight; + + return label; +} + +__device float3 svm_bsdf_eval(const ShaderData *sd, const float3 omega_in, float *pdf) +{ + float3 eval; + + if(dot(sd->Ng, omega_in) >= 0.0f) { + switch(sd->svm_closure) { + case CLOSURE_BSDF_DIFFUSE_ID: + eval = bsdf_diffuse_eval_reflect(sd, sd->I, omega_in, pdf); + break; + case CLOSURE_BSDF_TRANSLUCENT_ID: + eval = bsdf_translucent_eval_reflect(sd, sd->I, omega_in, pdf); + break; + case CLOSURE_BSDF_REFLECTION_ID: + eval = bsdf_reflection_eval_reflect(sd, sd->I, omega_in, pdf); + break; + case CLOSURE_BSDF_REFRACTION_ID: + eval = bsdf_refraction_eval_reflect(sd, sd->I, omega_in, pdf); + break; + case CLOSURE_BSDF_TRANSPARENT_ID: + eval = bsdf_transparent_eval_reflect(sd, sd->I, omega_in, pdf); + break; + case CLOSURE_BSDF_MICROFACET_GGX_ID: + case CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID: + eval = bsdf_microfacet_ggx_eval_reflect(sd, sd->I, omega_in, pdf); + break; + case CLOSURE_BSDF_MICROFACET_BECKMANN_ID: + case CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID: + eval = bsdf_microfacet_beckmann_eval_reflect(sd, sd->I, omega_in, pdf); + break; +#ifdef __DPDU__ + case CLOSURE_BSDF_WARD_ID: + eval = bsdf_ward_eval_reflect(sd, sd->I, omega_in, pdf); + break; +#endif + case CLOSURE_BSDF_ASHIKHMIN_VELVET_ID: + eval = bsdf_ashikhmin_velvet_eval_reflect(sd, sd->I, omega_in, pdf); + break; + case CLOSURE_BSDF_WESTIN_BACKSCATTER_ID: + eval = bsdf_westin_backscatter_eval_reflect(sd, sd->I, omega_in, pdf); + break; + case CLOSURE_BSDF_WESTIN_SHEEN_ID: + eval = bsdf_westin_sheen_eval_reflect(sd, sd->I, omega_in, pdf); + break; + default: + eval = make_float3(0.0f, 0.0f, 0.0f); + break; + } + } + else { + switch(sd->svm_closure) { + case CLOSURE_BSDF_DIFFUSE_ID: + eval = bsdf_diffuse_eval_transmit(sd, sd->I, omega_in, pdf); + break; + case CLOSURE_BSDF_TRANSLUCENT_ID: + eval = bsdf_translucent_eval_transmit(sd, sd->I, omega_in, pdf); + break; + case CLOSURE_BSDF_REFLECTION_ID: + eval = bsdf_reflection_eval_transmit(sd, sd->I, omega_in, pdf); + break; + case CLOSURE_BSDF_REFRACTION_ID: + eval = bsdf_refraction_eval_transmit(sd, sd->I, omega_in, pdf); + break; + case CLOSURE_BSDF_TRANSPARENT_ID: + eval = bsdf_transparent_eval_transmit(sd, sd->I, omega_in, pdf); + break; + case CLOSURE_BSDF_MICROFACET_GGX_ID: + case CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID: + eval = bsdf_microfacet_ggx_eval_transmit(sd, sd->I, omega_in, pdf); + break; + case CLOSURE_BSDF_MICROFACET_BECKMANN_ID: + case CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID: + eval = bsdf_microfacet_beckmann_eval_transmit(sd, sd->I, omega_in, pdf); + break; +#ifdef __DPDU__ + case CLOSURE_BSDF_WARD_ID: + eval = bsdf_ward_eval_transmit(sd, sd->I, omega_in, pdf); + break; +#endif + case CLOSURE_BSDF_ASHIKHMIN_VELVET_ID: + eval = bsdf_ashikhmin_velvet_eval_transmit(sd, sd->I, omega_in, pdf); + break; + case CLOSURE_BSDF_WESTIN_BACKSCATTER_ID: + eval = bsdf_westin_backscatter_eval_transmit(sd, sd->I, omega_in, pdf); + break; + case CLOSURE_BSDF_WESTIN_SHEEN_ID: + eval = bsdf_westin_sheen_eval_transmit(sd, sd->I, omega_in, pdf); + break; + default: + eval = make_float3(0.0f, 0.0f, 0.0f); + break; + } + } + + eval *= sd->svm_closure_weight; + + return eval; +} + +__device void svm_bsdf_blur(ShaderData *sd, float roughness) +{ + switch(sd->svm_closure) { + case CLOSURE_BSDF_DIFFUSE_ID: + bsdf_diffuse_blur(sd, roughness); + break; + case CLOSURE_BSDF_TRANSLUCENT_ID: + bsdf_translucent_blur(sd, roughness); + break; + case CLOSURE_BSDF_REFLECTION_ID: + bsdf_reflection_blur(sd, roughness); + break; + case CLOSURE_BSDF_REFRACTION_ID: + bsdf_refraction_blur(sd, roughness); + break; + case CLOSURE_BSDF_TRANSPARENT_ID: + bsdf_transparent_blur(sd, roughness); + break; + case CLOSURE_BSDF_MICROFACET_GGX_ID: + case CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID: + bsdf_microfacet_ggx_blur(sd, roughness); + break; + case CLOSURE_BSDF_MICROFACET_BECKMANN_ID: + case CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID: + bsdf_microfacet_beckmann_blur(sd, roughness); + break; +#ifdef __DPDU__ + case CLOSURE_BSDF_WARD_ID: + bsdf_ward_blur(sd, roughness); + break; +#endif + case CLOSURE_BSDF_ASHIKHMIN_VELVET_ID: + bsdf_ashikhmin_velvet_blur(sd, roughness); + break; + case CLOSURE_BSDF_WESTIN_BACKSCATTER_ID: + bsdf_westin_backscatter_blur(sd, roughness); + break; + case CLOSURE_BSDF_WESTIN_SHEEN_ID: + bsdf_westin_sheen_blur(sd, roughness); + break; + default: + break; + } +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_closure.h b/intern/cycles/kernel/svm/svm_closure.h new file mode 100644 index 00000000000..fe9edc36e95 --- /dev/null +++ b/intern/cycles/kernel/svm/svm_closure.h @@ -0,0 +1,208 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Closure Nodes */ + +__device void svm_node_closure_bsdf(ShaderData *sd, uint type, int iparam1, int iparam2, float randb) +{ + float param1 = __int_as_float(iparam1); + float param2 = __int_as_float(iparam2); + + switch(type) { + case CLOSURE_BSDF_DIFFUSE_ID: + bsdf_diffuse_setup(sd, sd->N); + break; + case CLOSURE_BSDF_TRANSLUCENT_ID: + bsdf_translucent_setup(sd, sd->N); + break; + case CLOSURE_BSDF_TRANSPARENT_ID: + bsdf_transparent_setup(sd); + break; + case CLOSURE_BSDF_REFLECTION_ID: + case CLOSURE_BSDF_MICROFACET_GGX_ID: + case CLOSURE_BSDF_MICROFACET_BECKMANN_ID: { + /* roughness */ + /* index of refraction */ + float eta = clamp(1.0f-param2, 1e-5f, 1.0f - 1e-5f); + eta = 1.0f/eta; + + /* fresnel */ + float cosNO = dot(sd->N, sd->I); + float fresnel = fresnel_dielectric_cos(cosNO, eta); + + sd->svm_closure_weight *= fresnel; + + /* setup bsdf */ + if(type == CLOSURE_BSDF_REFLECTION_ID) { + bsdf_reflection_setup(sd, sd->N); + } + else if(type == CLOSURE_BSDF_MICROFACET_BECKMANN_ID) { + float roughness = param1; + bsdf_microfacet_beckmann_setup(sd, sd->N, roughness, eta, false); + } + else { + float roughness = param1; + bsdf_microfacet_ggx_setup(sd, sd->N, roughness, eta, false); + } + break; + } + case CLOSURE_BSDF_REFRACTION_ID: + case CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID: + case CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID: { + /* index of refraction */ + float eta = clamp(1.0f-param2, 1e-5f, 1.0f - 1e-5f); + eta = (sd->flag & SD_BACKFACING)? eta: 1.0f/eta; + + /* fresnel */ + float cosNO = dot(sd->N, sd->I); + float fresnel = fresnel_dielectric_cos(cosNO, eta); + bool refract = (fresnel < randb); + + /* setup bsdf */ + if(type == CLOSURE_BSDF_REFRACTION_ID) { + if(refract) + bsdf_refraction_setup(sd, sd->N, eta); + else + bsdf_reflection_setup(sd, sd->N); + } + else if(type == CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID) { + float roughness = param1; + bsdf_microfacet_beckmann_setup(sd, sd->N, roughness, eta, refract); + } + else { + float roughness = param1; + bsdf_microfacet_ggx_setup(sd, sd->N, roughness, eta, refract); + } + break; + } +#ifdef __DPDU__ + case CLOSURE_BSDF_WARD_ID: { + float roughness_u = param1; + float roughness_v = param2; + bsdf_ward_setup(sd, sd->N, normalize(sd->dPdu), roughness_u, roughness_v); + break; + } +#endif + case CLOSURE_BSDF_ASHIKHMIN_VELVET_ID: { + /* sigma */ + float sigma = clamp(param1, 0.0f, 1.0f); + + /* index of refraction */ + float eta = clamp(1.0f-param2, 1e-5f, 1.0f - 1e-5f); + eta = 1.0f/eta; + + /* fresnel */ + float cosNO = dot(sd->N, sd->I); + float fresnel = fresnel_dielectric_cos(cosNO, eta); + + sd->svm_closure_weight *= fresnel; + + bsdf_ashikhmin_velvet_setup(sd, sd->N, sigma); + break; + } + default: + return; + } +} + +__device void svm_node_closure_emission(ShaderData *sd) +{ + sd->svm_closure = CLOSURE_EMISSION_ID; + sd->flag |= SD_EMISSION; +} + +__device void svm_node_closure_background(ShaderData *sd) +{ + sd->svm_closure = CLOSURE_BACKGROUND_ID; +} + +/* Closure Nodes */ + +__device void svm_node_closure_set_weight(ShaderData *sd, uint r, uint g, uint b) +{ + sd->svm_closure_weight.x = __int_as_float(r); + sd->svm_closure_weight.y = __int_as_float(g); + sd->svm_closure_weight.z = __int_as_float(b); +} + +__device void svm_node_emission_set_weight_total(KernelGlobals *kg, ShaderData *sd, uint r, uint g, uint b) +{ + sd->svm_closure_weight.x = __int_as_float(r); + sd->svm_closure_weight.y = __int_as_float(g); + sd->svm_closure_weight.z = __int_as_float(b); + + if(sd->object != ~0) + sd->svm_closure_weight /= object_surface_area(kg, sd->object); +} + +__device void svm_node_closure_weight(ShaderData *sd, float *stack, uint weight_offset) +{ + sd->svm_closure_weight = stack_load_float3(stack, weight_offset); +} + +__device void svm_node_emission_weight(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node) +{ + uint color_offset = node.y; + uint strength_offset = node.z; + uint total_power = node.w; + + sd->svm_closure_weight = stack_load_float3(stack, color_offset)*stack_load_float(stack, strength_offset); + + if(total_power && sd->object != ~0) + sd->svm_closure_weight /= object_surface_area(kg, sd->object); +} + +__device void svm_node_mix_closure(ShaderData *sd, float *stack, + uint weight_offset, uint node_jump, int *offset, float *randb) +{ + float weight = stack_load_float(stack, weight_offset); + weight = clamp(weight, 0.0f, 1.0f); + + /* pick a closure and make the random number uniform over 0..1 again. + closure 1 starts on the next node, for closure 2 the start is at an + offset from the current node, so we jump */ + if(*randb < weight) { + *offset += node_jump; + *randb = (*randb - weight)/(1.0f - weight); + } + else + *randb = *randb/weight; +} + +__device void svm_node_add_closure(ShaderData *sd, float *stack, uint unused, + uint node_jump, int *offset, float *randb, float *closure_weight) +{ + float weight = 0.5f; + + /* pick one of the two closures with probability 0.5. sampling quality + is not going to be great, for that we'd need to evaluate the weights + of the two closures being added */ + if(*randb < weight) { + *offset += node_jump; + *randb = (*randb - weight)/(1.0f - weight); + } + else + *randb = *randb/weight; + + *closure_weight *= 2.0f; +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_clouds.h b/intern/cycles/kernel/svm/svm_clouds.h new file mode 100644 index 00000000000..e51af684ab9 --- /dev/null +++ b/intern/cycles/kernel/svm/svm_clouds.h @@ -0,0 +1,55 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Clouds */ + +__device void svm_clouds(NodeNoiseBasis basis, int hard, int depth, float size, float3 p, float *fac, float3 *color) +{ + p /= size; + + *fac = noise_turbulence(p, basis, depth, hard); + *color = make_float3(*fac, + noise_turbulence(make_float3(p.y, p.x, p.z), basis, depth, hard), + noise_turbulence(make_float3(p.y, p.z, p.x), basis, depth, hard)); +} + +__device void svm_node_tex_clouds(ShaderData *sd, float *stack, uint4 node) +{ + uint basis, hard, depth; + uint size_offset, co_offset, fac_offset, color_offset; + + decode_node_uchar4(node.y, &basis, &hard, &depth, NULL); + decode_node_uchar4(node.z, &size_offset, &co_offset, &fac_offset, &color_offset); + + float3 co = stack_load_float3(stack, co_offset); + float size = stack_load_float_default(stack, size_offset, node.w); + size = nonzerof(size, 1e-5f); + + float3 color; + float f; + + svm_clouds((NodeNoiseBasis)basis, hard, depth, size, co, &f, &color); + + if(stack_valid(fac_offset)) stack_store_float(stack, fac_offset, f); + if(stack_valid(color_offset)) stack_store_float3(stack, color_offset, color); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_convert.h b/intern/cycles/kernel/svm/svm_convert.h new file mode 100644 index 00000000000..14925569bfb --- /dev/null +++ b/intern/cycles/kernel/svm/svm_convert.h @@ -0,0 +1,48 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Conversion Nodes */ + +__device void svm_node_convert(ShaderData *sd, float *stack, uint type, uint from, uint to) +{ + switch(type) { + case NODE_CONVERT_FV: { + float f = stack_load_float(stack, from); + stack_store_float3(stack, to, make_float3(f, f, f)); + break; + } + case NODE_CONVERT_CF: { + float3 f = stack_load_float3(stack, from); + float g = f.x*0.2126f + f.y*0.7152f + f.z*0.0722f; + stack_store_float(stack, to, g); + break; + } + case NODE_CONVERT_VF: { + float3 f = stack_load_float3(stack, from); + float g = (f.x + f.y + f.z)*(1.0f/3.0f); + stack_store_float(stack, to, g); + break; + } + + } +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_displace.h b/intern/cycles/kernel/svm/svm_displace.h new file mode 100644 index 00000000000..db8a8a13289 --- /dev/null +++ b/intern/cycles/kernel/svm/svm_displace.h @@ -0,0 +1,51 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Bump Node */ + +__device void svm_node_set_bump(ShaderData *sd, float *stack, uint c_offset, uint x_offset, uint y_offset) +{ +#ifdef __RAY_DIFFERENTIALS__ + float h_c = stack_load_float(stack, c_offset); + float h_x = stack_load_float(stack, x_offset); + float h_y = stack_load_float(stack, y_offset); + + float3 Rx = cross(sd->dP.dy, sd->N); + float3 Ry = cross(sd->N, sd->dP.dx); + + float det = dot(sd->dP.dx, Rx); + float3 surfgrad = (h_x - h_c)*Rx + (h_y - h_c)*Ry; + + surfgrad *= 0.1f; /* todo: remove this factor */ + + sd->N = normalize(fabsf(det)*sd->N - signf(det)*surfgrad); +#endif +} + +/* Displacement Node */ + +__device void svm_node_set_displacement(ShaderData *sd, float *stack, uint fac_offset) +{ + float d = stack_load_float(stack, fac_offset); + sd->P += sd->N*d*0.1f; /* todo: get rid of this factor */ +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_distorted_noise.h b/intern/cycles/kernel/svm/svm_distorted_noise.h new file mode 100644 index 00000000000..469313e377d --- /dev/null +++ b/intern/cycles/kernel/svm/svm_distorted_noise.h @@ -0,0 +1,58 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Distorted Noise (variable lacunarity noise) */ + +__device float svm_distorted_noise(float3 p, float size, NodeNoiseBasis basis, NodeNoiseBasis distortion_basis, float distortion) +{ + float3 r; + + p /= size; + + r.x = noise_basis(p + make_float3(13.5f, 13.5f, 13.5f), basis) * distortion; + r.y = noise_basis(p, basis) * distortion; + r.z = noise_basis(p - make_float3(13.5f, 13.5f, 13.5f), basis) * distortion; + + return noise_basis(p + r, distortion_basis); /* distorted-domain noise */ +} + +__device void svm_node_tex_distorted_noise(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node, int *offset) +{ + uint4 node2 = read_node(kg, offset); + + uint basis, distortion_basis; + uint size_offset, distortion_offset, co_offset, fac_offset; + + decode_node_uchar4(node.y, &basis, &distortion_basis, NULL, NULL); + decode_node_uchar4(node.z, &size_offset, &distortion_offset, &co_offset, &fac_offset); + + float3 co = stack_load_float3(stack, co_offset); + float size = stack_load_float_default(stack, size_offset, node2.x); + float distortion = stack_load_float_default(stack, distortion_offset, node2.y); + size = nonzerof(size, 1e-5f); + + float f = svm_distorted_noise(co, size, (NodeNoiseBasis)basis, + (NodeNoiseBasis)distortion_basis, distortion); + + stack_store_float(stack, fac_offset, f); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_fresnel.h b/intern/cycles/kernel/svm/svm_fresnel.h new file mode 100644 index 00000000000..f6122fa3071 --- /dev/null +++ b/intern/cycles/kernel/svm/svm_fresnel.h @@ -0,0 +1,34 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Fresnel Node */ + +__device void svm_node_fresnel(ShaderData *sd, float *stack, uint fresnel_offset, uint fresnel_value, uint out_offset) +{ + float fresnel = (stack_valid(fresnel_offset))? stack_load_float(stack, fresnel_offset): __int_as_float(fresnel_value); + fresnel = fmaxf(1.0f - fresnel, 0.00001f); + + float f = fresnel_dielectric_cos(dot(sd->I, sd->N), (sd->flag & SD_BACKFACING)? fresnel: 1.0f/fresnel); + + stack_store_float(stack, out_offset, f); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_geometry.h b/intern/cycles/kernel/svm/svm_geometry.h new file mode 100644 index 00000000000..77fe26c809e --- /dev/null +++ b/intern/cycles/kernel/svm/svm_geometry.h @@ -0,0 +1,78 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Geometry Node */ + +__device void svm_node_geometry(ShaderData *sd, float *stack, uint type, uint out_offset) +{ + float3 data; + + switch(type) { + case NODE_GEOM_P: data = sd->P; break; + case NODE_GEOM_N: data = sd->N; break; +#ifdef __DPDU__ + case NODE_GEOM_T: data = normalize(sd->dPdu); break; +#endif + case NODE_GEOM_I: data = sd->I; break; + case NODE_GEOM_Ng: data = sd->Ng; break; +#ifdef __UV__ + case NODE_GEOM_uv: data = make_float3(sd->u, sd->v, 0.0f); break; +#endif + } + + stack_store_float3(stack, out_offset, data); +} + +__device void svm_node_geometry_bump_dx(ShaderData *sd, float *stack, uint type, uint out_offset) +{ +#ifdef __RAY_DIFFERENTIALS__ + float3 data; + + switch(type) { + case NODE_GEOM_P: data = sd->P + sd->dP.dx; break; + case NODE_GEOM_uv: data = make_float3(sd->u + sd->du.dx, sd->v + sd->dv.dx, 0.0f); break; + default: svm_node_geometry(sd, stack, type, out_offset); return; + } + + stack_store_float3(stack, out_offset, data); +#else + svm_node_geometry(sd, stack, type, out_offset); +#endif +} + +__device void svm_node_geometry_bump_dy(ShaderData *sd, float *stack, uint type, uint out_offset) +{ +#ifdef __RAY_DIFFERENTIALS__ + float3 data; + + switch(type) { + case NODE_GEOM_P: data = sd->P + sd->dP.dy; break; + case NODE_GEOM_uv: data = make_float3(sd->u + sd->du.dy, sd->v + sd->dv.dy, 0.0f); break; + default: svm_node_geometry(sd, stack, type, out_offset); return; + } + + stack_store_float3(stack, out_offset, data); +#else + svm_node_geometry(sd, stack, type, out_offset); +#endif +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_image.h b/intern/cycles/kernel/svm/svm_image.h new file mode 100644 index 00000000000..c2020b1f69c --- /dev/null +++ b/intern/cycles/kernel/svm/svm_image.h @@ -0,0 +1,162 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +__device float4 svm_image_texture(KernelGlobals *kg, int id, float x, float y) +{ + float4 r; + + /* not particularly proud of this massive switch, what are the + alternatives? + - use a single big 1D texture, and do our own lookup/filtering + - group by size and use a 3d texture, performance impact + - group into larger texture with some padding for correct lerp + + also note that cuda has 128 textures limit, we use 100 now, since + we still need some for other storage */ + + switch(id) { + case 0: r = kernel_tex_image_interp(__tex_image_000, x, y); break; + case 1: r = kernel_tex_image_interp(__tex_image_001, x, y); break; + case 2: r = kernel_tex_image_interp(__tex_image_002, x, y); break; + case 3: r = kernel_tex_image_interp(__tex_image_003, x, y); break; + case 4: r = kernel_tex_image_interp(__tex_image_004, x, y); break; + case 5: r = kernel_tex_image_interp(__tex_image_005, x, y); break; + case 6: r = kernel_tex_image_interp(__tex_image_006, x, y); break; + case 7: r = kernel_tex_image_interp(__tex_image_007, x, y); break; + case 8: r = kernel_tex_image_interp(__tex_image_008, x, y); break; + case 9: r = kernel_tex_image_interp(__tex_image_009, x, y); break; + case 10: r = kernel_tex_image_interp(__tex_image_010, x, y); break; + case 11: r = kernel_tex_image_interp(__tex_image_011, x, y); break; + case 12: r = kernel_tex_image_interp(__tex_image_012, x, y); break; + case 13: r = kernel_tex_image_interp(__tex_image_013, x, y); break; + case 14: r = kernel_tex_image_interp(__tex_image_014, x, y); break; + case 15: r = kernel_tex_image_interp(__tex_image_015, x, y); break; + case 16: r = kernel_tex_image_interp(__tex_image_016, x, y); break; + case 17: r = kernel_tex_image_interp(__tex_image_017, x, y); break; + case 18: r = kernel_tex_image_interp(__tex_image_018, x, y); break; + case 19: r = kernel_tex_image_interp(__tex_image_019, x, y); break; + case 20: r = kernel_tex_image_interp(__tex_image_020, x, y); break; + case 21: r = kernel_tex_image_interp(__tex_image_021, x, y); break; + case 22: r = kernel_tex_image_interp(__tex_image_022, x, y); break; + case 23: r = kernel_tex_image_interp(__tex_image_023, x, y); break; + case 24: r = kernel_tex_image_interp(__tex_image_024, x, y); break; + case 25: r = kernel_tex_image_interp(__tex_image_025, x, y); break; + case 26: r = kernel_tex_image_interp(__tex_image_026, x, y); break; + case 27: r = kernel_tex_image_interp(__tex_image_027, x, y); break; + case 28: r = kernel_tex_image_interp(__tex_image_028, x, y); break; + case 29: r = kernel_tex_image_interp(__tex_image_029, x, y); break; + case 30: r = kernel_tex_image_interp(__tex_image_030, x, y); break; + case 31: r = kernel_tex_image_interp(__tex_image_031, x, y); break; + case 32: r = kernel_tex_image_interp(__tex_image_032, x, y); break; + case 33: r = kernel_tex_image_interp(__tex_image_033, x, y); break; + case 34: r = kernel_tex_image_interp(__tex_image_034, x, y); break; + case 35: r = kernel_tex_image_interp(__tex_image_035, x, y); break; + case 36: r = kernel_tex_image_interp(__tex_image_036, x, y); break; + case 37: r = kernel_tex_image_interp(__tex_image_037, x, y); break; + case 38: r = kernel_tex_image_interp(__tex_image_038, x, y); break; + case 39: r = kernel_tex_image_interp(__tex_image_039, x, y); break; + case 40: r = kernel_tex_image_interp(__tex_image_040, x, y); break; + case 41: r = kernel_tex_image_interp(__tex_image_041, x, y); break; + case 42: r = kernel_tex_image_interp(__tex_image_042, x, y); break; + case 43: r = kernel_tex_image_interp(__tex_image_043, x, y); break; + case 44: r = kernel_tex_image_interp(__tex_image_044, x, y); break; + case 45: r = kernel_tex_image_interp(__tex_image_045, x, y); break; + case 46: r = kernel_tex_image_interp(__tex_image_046, x, y); break; + case 47: r = kernel_tex_image_interp(__tex_image_047, x, y); break; + case 48: r = kernel_tex_image_interp(__tex_image_048, x, y); break; + case 49: r = kernel_tex_image_interp(__tex_image_049, x, y); break; + case 50: r = kernel_tex_image_interp(__tex_image_050, x, y); break; + case 51: r = kernel_tex_image_interp(__tex_image_051, x, y); break; + case 52: r = kernel_tex_image_interp(__tex_image_052, x, y); break; + case 53: r = kernel_tex_image_interp(__tex_image_053, x, y); break; + case 54: r = kernel_tex_image_interp(__tex_image_054, x, y); break; + case 55: r = kernel_tex_image_interp(__tex_image_055, x, y); break; + case 56: r = kernel_tex_image_interp(__tex_image_056, x, y); break; + case 57: r = kernel_tex_image_interp(__tex_image_057, x, y); break; + case 58: r = kernel_tex_image_interp(__tex_image_058, x, y); break; + case 59: r = kernel_tex_image_interp(__tex_image_059, x, y); break; + case 60: r = kernel_tex_image_interp(__tex_image_060, x, y); break; + case 61: r = kernel_tex_image_interp(__tex_image_061, x, y); break; + case 62: r = kernel_tex_image_interp(__tex_image_062, x, y); break; + case 63: r = kernel_tex_image_interp(__tex_image_063, x, y); break; + case 64: r = kernel_tex_image_interp(__tex_image_064, x, y); break; + case 65: r = kernel_tex_image_interp(__tex_image_065, x, y); break; + case 66: r = kernel_tex_image_interp(__tex_image_066, x, y); break; + case 67: r = kernel_tex_image_interp(__tex_image_067, x, y); break; + case 68: r = kernel_tex_image_interp(__tex_image_068, x, y); break; + case 69: r = kernel_tex_image_interp(__tex_image_069, x, y); break; + case 70: r = kernel_tex_image_interp(__tex_image_070, x, y); break; + case 71: r = kernel_tex_image_interp(__tex_image_071, x, y); break; + case 72: r = kernel_tex_image_interp(__tex_image_072, x, y); break; + case 73: r = kernel_tex_image_interp(__tex_image_073, x, y); break; + case 74: r = kernel_tex_image_interp(__tex_image_074, x, y); break; + case 75: r = kernel_tex_image_interp(__tex_image_075, x, y); break; + case 76: r = kernel_tex_image_interp(__tex_image_076, x, y); break; + case 77: r = kernel_tex_image_interp(__tex_image_077, x, y); break; + case 78: r = kernel_tex_image_interp(__tex_image_078, x, y); break; + case 79: r = kernel_tex_image_interp(__tex_image_079, x, y); break; + case 80: r = kernel_tex_image_interp(__tex_image_080, x, y); break; + case 81: r = kernel_tex_image_interp(__tex_image_081, x, y); break; + case 82: r = kernel_tex_image_interp(__tex_image_082, x, y); break; + case 83: r = kernel_tex_image_interp(__tex_image_083, x, y); break; + case 84: r = kernel_tex_image_interp(__tex_image_084, x, y); break; + case 85: r = kernel_tex_image_interp(__tex_image_085, x, y); break; + case 86: r = kernel_tex_image_interp(__tex_image_086, x, y); break; + case 87: r = kernel_tex_image_interp(__tex_image_087, x, y); break; + case 88: r = kernel_tex_image_interp(__tex_image_088, x, y); break; + case 89: r = kernel_tex_image_interp(__tex_image_089, x, y); break; + case 90: r = kernel_tex_image_interp(__tex_image_090, x, y); break; + case 91: r = kernel_tex_image_interp(__tex_image_091, x, y); break; + case 92: r = kernel_tex_image_interp(__tex_image_092, x, y); break; + case 93: r = kernel_tex_image_interp(__tex_image_093, x, y); break; + case 94: r = kernel_tex_image_interp(__tex_image_094, x, y); break; + case 95: r = kernel_tex_image_interp(__tex_image_095, x, y); break; + case 96: r = kernel_tex_image_interp(__tex_image_096, x, y); break; + case 97: r = kernel_tex_image_interp(__tex_image_097, x, y); break; + case 98: r = kernel_tex_image_interp(__tex_image_098, x, y); break; + case 99: r = kernel_tex_image_interp(__tex_image_099, x, y); break; + default: + kernel_assert(0); + return make_float4(0.0f, 0.0f, 0.0f, 0.0f); + } + + return r; +} + +__device void svm_node_tex_image(KernelGlobals *kg, ShaderData *sd, float *stack, uint id, uint co_offset, uint out_offset) +{ + float3 co = stack_load_float3(stack, co_offset); + float4 f = svm_image_texture(kg, id, co.x, co.y); + + stack_store_float3(stack, out_offset, make_float3(f.x, f.y, f.z)); +} + +__device void svm_node_tex_environment(KernelGlobals *kg, ShaderData *sd, float *stack, uint id, uint co_offset, uint out_offset) +{ + float3 co = stack_load_float3(stack, co_offset); + float u = (atan2f(co.y, co.x) + M_PI_F)/(2*M_PI_F); + float v = atan2f(co.z, hypotf(co.x, co.y))/M_PI_F + 0.5f; + float4 f = svm_image_texture(kg, id, u, v); + + stack_store_float3(stack, out_offset, make_float3(f.x, f.y, f.z)); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_light_path.h b/intern/cycles/kernel/svm/svm_light_path.h new file mode 100644 index 00000000000..a4a461f9590 --- /dev/null +++ b/intern/cycles/kernel/svm/svm_light_path.h @@ -0,0 +1,41 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Light Path Node */ + +__device void svm_node_light_path(ShaderData *sd, float *stack, uint type, uint out_offset, int path_flag) +{ + float info = 0.0f; + + switch(type) { + case NODE_LP_camera: info = (path_flag & PATH_RAY_CAMERA)? 1.0f: 0.0f; break; + case NODE_LP_shadow: info = (path_flag & PATH_RAY_SHADOW)? 1.0f: 0.0f; break; + case NODE_LP_diffuse: info = (path_flag & PATH_RAY_DIFFUSE)? 1.0f: 0.0f; break; + case NODE_LP_glossy: info = (path_flag & PATH_RAY_GLOSSY)? 1.0f: 0.0f; break; + case NODE_LP_reflection: info = (path_flag & PATH_RAY_REFLECT)? 1.0f: 0.0f; break; + case NODE_LP_transmission: info = (path_flag & PATH_RAY_TRANSMIT)? 1.0f: 0.0f; break; + case NODE_LP_backfacing: info = (sd->flag & SD_BACKFACING)? 1.0f: 0.0f; break; + } + + stack_store_float(stack, out_offset, info? 1.0f: 0.0f); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_magic.h b/intern/cycles/kernel/svm/svm_magic.h new file mode 100644 index 00000000000..608ca4bbd2f --- /dev/null +++ b/intern/cycles/kernel/svm/svm_magic.h @@ -0,0 +1,108 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Magic */ + +__device float3 svm_magic(float3 p, int n, float turbulence) +{ + float turb = turbulence/5.0f; + + float x = sinf((p.x + p.y + p.z)*5.0f); + float y = cosf((-p.x + p.y - p.z)*5.0f); + float z = -cosf((-p.x - p.y + p.z)*5.0f); + + if(n > 0) { + x *= turb; + y *= turb; + z *= turb; + y = -cosf(x-y+z); + y *= turb; + + if(n > 1) { + x= cosf(x-y-z); + x *= turb; + + if(n > 2) { + z= sinf(-x-y-z); + z *= turb; + + if(n > 3) { + x= -cosf(-x+y-z); + x *= turb; + + if(n > 4) { + y= -sinf(-x+y+z); + y *= turb; + + if(n > 5) { + y= -cosf(-x+y+z); + y *= turb; + + if(n > 6) { + x= cosf(x+y+z); + x *= turb; + + if(n > 7) { + z= sinf(x+y-z); + z *= turb; + + if(n > 8) { + x= -cosf(-x-y+z); + x *= turb; + + if(n > 9) { + y= -sinf(x-y+z); + y *= turb; + } + } + } + } + } + } + } + } + } + } + + if(turb != 0.0f) { + turb *= 2.0f; + x /= turb; + y /= turb; + z /= turb; + } + + return make_float3(0.5f - x, 0.5f - y, 0.5f - z); +} + +__device void svm_node_tex_magic(ShaderData *sd, float *stack, uint4 node) +{ + uint depth, turbulence_offset, co_offset, color_offset; + + decode_node_uchar4(node.y, &depth, &turbulence_offset, &co_offset, &color_offset); + + float3 co = stack_load_float3(stack, co_offset); + float turbulence = stack_load_float_default(stack, turbulence_offset, node.z); + + float3 color = svm_magic(co, depth, turbulence); + stack_store_float3(stack, color_offset, color); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_mapping.h b/intern/cycles/kernel/svm/svm_mapping.h new file mode 100644 index 00000000000..7633c3e783b --- /dev/null +++ b/intern/cycles/kernel/svm/svm_mapping.h @@ -0,0 +1,38 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Mapping Node */ + +__device void svm_node_mapping(KernelGlobals *kg, ShaderData *sd, float *stack, uint vec_offset, uint out_offset, int *offset) +{ + float3 v = stack_load_float3(stack, vec_offset); + + Transform tfm; + tfm.x = read_node_float(kg, offset); + tfm.y = read_node_float(kg, offset); + tfm.z = read_node_float(kg, offset); + tfm.w = read_node_float(kg, offset); + + float3 r = transform(&tfm, v); + stack_store_float3(stack, out_offset, r); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_marble.h b/intern/cycles/kernel/svm/svm_marble.h new file mode 100644 index 00000000000..4284688afb8 --- /dev/null +++ b/intern/cycles/kernel/svm/svm_marble.h @@ -0,0 +1,67 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Marble */ + +__device float svm_marble(float3 p, float size, NodeMarbleType type, NodeWaveType wave, NodeNoiseBasis basis, int hard, float turb, int depth) +{ + float x = p.x; + float y = p.y; + float z = p.z; + + float n = 5.0f * (x + y + z); + + float mi = n + turb * noise_turbulence(p/size, basis, depth, hard); + + mi = noise_wave(wave, mi); + + if(type == NODE_MARBLE_SHARP) + mi = sqrt(mi); + else if(type == NODE_MARBLE_SHARPER) + mi = sqrt(sqrt(mi)); + + return mi; +} + +__device void svm_node_tex_marble(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node, int *offset) +{ + uint4 node2 = read_node(kg, offset); + + uint type, wave, basis, hard; + uint depth; + uint size_offset, turbulence_offset, co_offset, fac_offset; + + decode_node_uchar4(node.y, &type, &wave, &basis, &hard); + decode_node_uchar4(node.z, &depth, NULL, NULL, NULL); + decode_node_uchar4(node.w, &size_offset, &turbulence_offset, &co_offset, &fac_offset); + + float3 co = stack_load_float3(stack, co_offset); + float size = stack_load_float_default(stack, size_offset, node2.x); + float turbulence = stack_load_float_default(stack, turbulence_offset, node2.y); + size = nonzerof(size, 1e-5f); + + float f = svm_marble(co, size, (NodeMarbleType)type, (NodeWaveType)wave, + (NodeNoiseBasis)basis, hard, turbulence, depth); + + stack_store_float(stack, fac_offset, f); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_math.h b/intern/cycles/kernel/svm/svm_math.h new file mode 100644 index 00000000000..6650a10a4d9 --- /dev/null +++ b/intern/cycles/kernel/svm/svm_math.h @@ -0,0 +1,181 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +__device float safe_asinf(float a) +{ + if(a <= -1.0f) + return -M_PI_2; + else if(a >= 1.0f) + return M_PI_2_F; + + return asinf(a); +} + +__device float safe_acosf(float a) +{ + if(a <= -1.0f) + return M_PI_F; + else if(a >= 1.0f) + return 0.0f; + + return acosf(a); +} + +__device float safe_powf(float a, float b) +{ + if(b == 0.0f) + return 1.0f; + if(a == 0.0f) + return 0.0f; + if(a < 0.0f && b != (int)b) + return 0.0f; + + return powf(a, b); +} + +__device float safe_logf(float a, float b) +{ + if(a < 0.0f || b < 0.0f) + return 0.0f; + + return logf(a)/logf(b); +} + +__device float safe_divide(float a, float b) +{ + float result; + + if(b == 0.0f) + result = 0.0f; + else + result = a/b; + + return result; +} + +__device float svm_math(NodeMath type, float Fac1, float Fac2) +{ + float Fac; + + if(type == NODE_MATH_ADD) + Fac = Fac1 + Fac2; + else if(type == NODE_MATH_SUBTRACT) + Fac = Fac1 - Fac2; + else if(type == NODE_MATH_MULTIPLY) + Fac = Fac1*Fac2; + else if(type == NODE_MATH_DIVIDE) + Fac = safe_divide(Fac1, Fac2); + else if(type == NODE_MATH_SINE) + Fac = sinf(Fac1); + else if(type == NODE_MATH_COSINE) + Fac = cosf(Fac1); + else if(type == NODE_MATH_TANGENT) + Fac = tanf(Fac1); + else if(type == NODE_MATH_ARCSINE) + Fac = safe_asinf(Fac1); + else if(type == NODE_MATH_ARCCOSINE) + Fac = safe_acosf(Fac1); + else if(type == NODE_MATH_ARCTANGENT) + Fac = atanf(Fac1); + else if(type == NODE_MATH_POWER) + Fac = safe_powf(Fac1, Fac2); + else if(type == NODE_MATH_LOGARITHM) + Fac = safe_logf(Fac1, Fac2); + else if(type == NODE_MATH_MINIMUM) + Fac = fminf(Fac1, Fac2); + else if(type == NODE_MATH_MAXIMUM) + Fac = fmaxf(Fac1, Fac2); + else if(type == NODE_MATH_ROUND) + Fac = floorf(Fac1 + 0.5f); + else if(type == NODE_MATH_LESS_THAN) + Fac = Fac1 < Fac2; + else if(type == NODE_MATH_GREATER_THAN) + Fac = Fac1 > Fac2; + else + Fac = 0.0f; + + return Fac; +} + +__device void svm_vector_math(float *Fac, float3 *Vector, NodeVectorMath type, float3 Vector1, float3 Vector2) +{ + if(type == NODE_VECTOR_MATH_ADD) { + *Vector = Vector1 + Vector2; + *Fac = (fabsf(Vector->x) + fabsf(Vector->y) + fabsf(Vector->z))/3.0f; + } + else if(type == NODE_VECTOR_MATH_SUBTRACT) { + *Vector = Vector1 + Vector2; + *Fac = (fabsf(Vector->x) + fabsf(Vector->y) + fabsf(Vector->z))/3.0f; + } + else if(type == NODE_VECTOR_MATH_AVERAGE) { + *Fac = len(Vector1 + Vector2); + *Vector = normalize(Vector1 + Vector2); + } + else if(type == NODE_VECTOR_MATH_DOT_PRODUCT) { + *Fac = dot(Vector1, Vector2); + *Vector = make_float3(0.0f, 0.0f, 0.0f); + } + else if(type == NODE_VECTOR_MATH_CROSS_PRODUCT) { + float3 c = cross(Vector1, Vector2); + *Fac = len(c); + *Vector = normalize(c); + } + else if(type == NODE_VECTOR_MATH_NORMALIZE) { + *Fac = len(Vector1); + *Vector = normalize(Vector1); + } + else { + *Fac = 0.0f; + *Vector = make_float3(0.0f, 0.0f, 0.0f); + } +} + +/* Nodes */ + +__device void svm_node_math(KernelGlobals *kg, ShaderData *sd, float *stack, uint itype, uint f1_offset, uint f2_offset, int *offset) +{ + NodeMath type = (NodeMath)itype; + float f1 = stack_load_float(stack, f1_offset); + float f2 = stack_load_float(stack, f2_offset); + float f = svm_math(type, f1, f2); + + uint4 node1 = read_node(kg, offset); + + stack_store_float(stack, node1.y, f); +} + +__device void svm_node_vector_math(KernelGlobals *kg, ShaderData *sd, float *stack, uint itype, uint v1_offset, uint v2_offset, int *offset) +{ + NodeVectorMath type = (NodeVectorMath)itype; + float3 v1 = stack_load_float3(stack, v1_offset); + float3 v2 = stack_load_float3(stack, v2_offset); + float f; + float3 v; + + svm_vector_math(&f, &v, type, v1, v2); + + uint4 node1 = read_node(kg, offset); + + if(stack_valid(node1.y)) stack_store_float(stack, node1.y, f); + if(stack_valid(node1.z)) stack_store_float3(stack, node1.z, v); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_mix.h b/intern/cycles/kernel/svm/svm_mix.h new file mode 100644 index 00000000000..5a8ca2f76dd --- /dev/null +++ b/intern/cycles/kernel/svm/svm_mix.h @@ -0,0 +1,387 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +__device float3 rgb_to_hsv(float3 rgb) +{ + float cmax, cmin, h, s, v, cdelta; + float3 c; + + cmax = fmaxf(rgb.x, fmaxf(rgb.y, rgb.z)); + cmin = min(rgb.x, min(rgb.y, rgb.z)); + cdelta = cmax - cmin; + + v = cmax; + + if(cmax != 0.0f) { + s = cdelta/cmax; + } + else { + s = 0.0f; + h = 0.0f; + } + + if(s == 0.0f) { + h = 0.0f; + } + else { + c = (make_float3(cmax, cmax, cmax) - rgb)/cdelta; + + if(rgb.x == cmax) h = c.z - c.y; + else if(rgb.y == cmax) h = 2.0f + c.x - c.z; + else h = 4.0f + c.y - c.x; + + h /= 6.0f; + + if(h < 0.0f) + h += 1.0f; + } + + return make_float3(h, s, v); +} + +__device float3 hsv_to_rgb(float3 hsv) +{ + float i, f, p, q, t, h, s, v; + float3 rgb; + + h = hsv.x; + s = hsv.y; + v = hsv.z; + + if(s==0.0f) { + rgb = make_float3(v, v, v); + } + else { + if(h==1.0f) + h = 0.0f; + + h *= 6.0f; + i = floor(h); + f = h - i; + rgb = make_float3(f, f, f); + p = v*(1.0f-s); + q = v*(1.0f-(s*f)); + t = v*(1.0f-(s*(1.0f-f))); + + if(i == 0.0f) rgb = make_float3(v, t, p); + else if(i == 1.0f) rgb = make_float3(q, v, p); + else if(i == 2.0f) rgb = make_float3(p, v, t); + else if(i == 3.0f) rgb = make_float3(p, q, v); + else if(i == 4.0f) rgb = make_float3(t, p, v); + else rgb = make_float3(v, p, q); + } + + return rgb; +} + +__device float3 svm_mix_blend(float t, float3 col1, float3 col2) +{ + return lerp(col1, col2, t); +} + +__device float3 svm_mix_add(float t, float3 col1, float3 col2) +{ + return lerp(col1, col1 + col2, t); +} + +__device float3 svm_mix_mul(float t, float3 col1, float3 col2) +{ + return lerp(col1, col1 * col2, t); +} + +__device float3 svm_mix_screen(float t, float3 col1, float3 col2) +{ + float tm = 1.0f - t; + + return make_float3(1.0f, 1.0f, 1.0f) - (make_float3(tm, tm, tm) + t*(make_float3(1.0f, 1.0f, 1.0f) - col2))*(make_float3(1.0f, 1.0f, 1.0f) - col1); +} + +__device float3 svm_mix_overlay(float t, float3 col1, float3 col2) +{ + float tm = 1.0f - t; + + float3 outcol = col1; + + if(outcol.x < 0.5f) + outcol.x *= tm + 2.0f*t*col2.x; + else + outcol.x = 1.0f - (tm + 2.0f*t*(1.0f - col2.x))*(1.0f - outcol.x); + + if(outcol.y < 0.5f) + outcol.y *= tm + 2.0f*t*col2.y; + else + outcol.y = 1.0f - (tm + 2.0f*t*(1.0f - col2.y))*(1.0f - outcol.y); + + if(outcol.z < 0.5f) + outcol.z *= tm + 2.0f*t*col2.z; + else + outcol.z = 1.0f - (tm + 2.0f*t*(1.0f - col2.z))*(1.0f - outcol.z); + + return outcol; +} + +__device float3 svm_mix_sub(float t, float3 col1, float3 col2) +{ + return lerp(col1, col1 - col2, t); +} + +__device float3 svm_mix_div(float t, float3 col1, float3 col2) +{ + float tm = 1.0f - t; + + float3 outcol = col1; + + if(col2.x != 0.0f) outcol.x = tm*outcol.x + t*outcol.x/col2.x; + if(col2.y != 0.0f) outcol.y = tm*outcol.y + t*outcol.y/col2.y; + if(col2.z != 0.0f) outcol.z = tm*outcol.z + t*outcol.z/col2.z; + + return outcol; +} + +__device float3 svm_mix_diff(float t, float3 col1, float3 col2) +{ + return lerp(col1, fabs(col1 - col2), t); +} + +__device float3 svm_mix_dark(float t, float3 col1, float3 col2) +{ + return min(col1, col2*t); +} + +__device float3 svm_mix_light(float t, float3 col1, float3 col2) +{ + return max(col1, col2*t); +} + +__device float3 svm_mix_dodge(float t, float3 col1, float3 col2) +{ + float3 outcol = col1; + + if(outcol.x != 0.0f) { + float tmp = 1.0f - t*col2.x; + if(tmp <= 0.0f) + outcol.x = 1.0f; + else if((tmp = outcol.x/tmp) > 1.0f) + outcol.x = 1.0f; + else + outcol.x = tmp; + } + if(outcol.y != 0.0f) { + float tmp = 1.0f - t*col2.y; + if(tmp <= 0.0f) + outcol.y = 1.0f; + else if((tmp = outcol.y/tmp) > 1.0f) + outcol.y = 1.0f; + else + outcol.y = tmp; + } + if(outcol.z != 0.0f) { + float tmp = 1.0f - t*col2.z; + if(tmp <= 0.0f) + outcol.z = 1.0f; + else if((tmp = outcol.z/tmp) > 1.0f) + outcol.z = 1.0f; + else + outcol.z = tmp; + } + + return outcol; +} + +__device float3 svm_mix_burn(float t, float3 col1, float3 col2) +{ + float tmp, tm = 1.0f - t; + + float3 outcol = col1; + + tmp = tm + t*col2.x; + if(tmp <= 0.0f) + outcol.x = 0.0f; + else if((tmp = (1.0f - (1.0f - outcol.x)/tmp)) < 0.0f) + outcol.x = 0.0f; + else if(tmp > 1.0f) + outcol.x = 1.0f; + else + outcol.x = tmp; + + tmp = tm + t*col2.y; + if(tmp <= 0.0f) + outcol.y = 0.0f; + else if((tmp = (1.0f - (1.0f - outcol.y)/tmp)) < 0.0f) + outcol.y = 0.0f; + else if(tmp > 1.0f) + outcol.y = 1.0f; + else + outcol.y = tmp; + + tmp = tm + t*col2.z; + if(tmp <= 0.0f) + outcol.z = 0.0f; + else if((tmp = (1.0f - (1.0f - outcol.z)/tmp)) < 0.0f) + outcol.z = 0.0f; + else if(tmp > 1.0f) + outcol.z = 1.0f; + else + outcol.z = tmp; + + return outcol; +} + +__device float3 svm_mix_hue(float t, float3 col1, float3 col2) +{ + float3 outcol = col1; + + float3 hsv2 = rgb_to_hsv(col2); + + if(hsv2.y != 0.0f) { + float3 hsv = rgb_to_hsv(outcol); + hsv.x = hsv2.x; + float3 tmp = hsv_to_rgb(hsv); + + outcol = lerp(outcol, tmp, t); + } + + return outcol; +} + +__device float3 svm_mix_sat(float t, float3 col1, float3 col2) +{ + float tm = 1.0f - t; + + float3 outcol = col1; + + float3 hsv = rgb_to_hsv(outcol); + + if(hsv.y != 0.0f) { + float3 hsv2 = rgb_to_hsv(col2); + + hsv.y = tm*hsv.y + t*hsv2.y; + outcol = hsv_to_rgb(hsv); + } + + return outcol; +} + +__device float3 svm_mix_val(float t, float3 col1, float3 col2) +{ + float tm = 1.0f - t; + + float3 hsv = rgb_to_hsv(col1); + float3 hsv2 = rgb_to_hsv(col2); + + hsv.z = tm*hsv.z + t*hsv2.z; + + return hsv_to_rgb(hsv); +} + +__device float3 svm_mix_color(float t, float3 col1, float3 col2) +{ + float3 outcol = col1; + float3 hsv2 = rgb_to_hsv(col2); + + if(hsv2.y != 0.0f) { + float3 hsv = rgb_to_hsv(outcol); + hsv.x = hsv2.x; + hsv.y = hsv2.y; + float3 tmp = hsv_to_rgb(hsv); + + outcol = lerp(outcol, tmp, t); + } + + return outcol; +} + +__device float3 svm_mix_soft(float t, float3 col1, float3 col2) +{ + float tm = 1.0f - t; + + float3 one= make_float3(1.0f, 1.0f, 1.0f); + float3 scr= one - (one - col2)*(one - col1); + + return tm*col1 + t*((one - col1)*col2*col1 + col1*scr); +} + +__device float3 svm_mix_linear(float t, float3 col1, float3 col2) +{ + float3 outcol = col1; + + if(col2.x > 0.5f) + outcol.x= col1.x + t*(2.0f*(col2.x - 0.5f)); + else + outcol.x= col1.x + t*(2.0f*(col2.x) - 1.0f); + + if(col2.y > 0.5f) + outcol.y= col1.y + t*(2.0f*(col2.y - 0.5f)); + else + outcol.y= col1.y + t*(2.0f*(col2.y) - 1.0f); + + if(col2.z > 0.5f) + outcol.z= col1.z + t*(2.0f*(col2.z - 0.5f)); + else + outcol.z= col1.z + t*(2.0f*(col2.z) - 1.0f); + + return outcol; +} + +__device float3 svm_mix(NodeMix type, float fac, float3 c1, float3 c2) +{ + float t = clamp(fac, 0.0f, 1.0f); + + switch(type) { + case NODE_MIX_BLEND: return svm_mix_blend(t, c1, c2); + case NODE_MIX_ADD: return svm_mix_add(t, c1, c2); + case NODE_MIX_MUL: return svm_mix_mul(t, c1, c2); + case NODE_MIX_SCREEN: return svm_mix_screen(t, c1, c2); + case NODE_MIX_OVERLAY: return svm_mix_overlay(t, c1, c2); + case NODE_MIX_SUB: return svm_mix_sub(t, c1, c2); + case NODE_MIX_DIV: return svm_mix_div(t, c1, c2); + case NODE_MIX_DIFF: return svm_mix_diff(t, c1, c2); + case NODE_MIX_DARK: return svm_mix_dark(t, c1, c2); + case NODE_MIX_LIGHT: return svm_mix_light(t, c1, c2); + case NODE_MIX_DODGE: return svm_mix_dodge(t, c1, c2); + case NODE_MIX_BURN: return svm_mix_burn(t, c1, c2); + case NODE_MIX_HUE: return svm_mix_hue(t, c1, c2); + case NODE_MIX_SAT: return svm_mix_sat(t, c1, c2); + case NODE_MIX_VAL: return svm_mix_val (t, c1, c2); + case NODE_MIX_COLOR: return svm_mix_color(t, c1, c2); + case NODE_MIX_SOFT: return svm_mix_soft(t, c1, c2); + case NODE_MIX_LINEAR: return svm_mix_linear(t, c1, c2); + } + + return make_float3(0.0f, 0.0f, 0.0f); +} + +/* Node */ + +__device void svm_node_mix(KernelGlobals *kg, ShaderData *sd, float *stack, uint fac_offset, uint c1_offset, uint c2_offset, int *offset) +{ + /* read extra data */ + uint4 node1 = read_node(kg, offset); + + float fac = stack_load_float(stack, fac_offset); + float3 c1 = stack_load_float3(stack, c1_offset); + float3 c2 = stack_load_float3(stack, c2_offset); + float3 result = svm_mix((NodeMix)node1.y, fac, c1, c2); + + stack_store_float3(stack, node1.z, result); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_musgrave.h b/intern/cycles/kernel/svm/svm_musgrave.h new file mode 100644 index 00000000000..5163b9f2ced --- /dev/null +++ b/intern/cycles/kernel/svm/svm_musgrave.h @@ -0,0 +1,237 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Musgrave fBm + * + * H: fractal increment parameter + * lacunarity: gap between successive frequencies + * octaves: number of frequencies in the fBm + * + * from "Texturing and Modelling: A procedural approach" + */ + +__device float noise_musgrave_fBm(float3 p, NodeNoiseBasis basis, float H, float lacunarity, float octaves) +{ + float rmd; + float value = 0.0f; + float pwr = 1.0f; + float pwHL = pow(lacunarity, -H); + int i; + + for(i = 0; i < (int)octaves; i++) { + value += noise_basis(p, basis) * pwr; + pwr *= pwHL; + p *= lacunarity; + } + + rmd = octaves - floor(octaves); + if(rmd != 0.0f) + value += rmd * noise_basis(p, basis) * pwr; + + return value; +} + +/* Musgrave Multifractal + * + * H: highest fractal dimension + * lacunarity: gap between successive frequencies + * octaves: number of frequencies in the fBm + */ + +__device float noise_musgrave_multi_fractal(float3 p, NodeNoiseBasis basis, float H, float lacunarity, float octaves) +{ + float rmd; + float value = 1.0f; + float pwr = 1.0f; + float pwHL = pow(lacunarity, -H); + int i; + + for(i = 0; i < (int)octaves; i++) { + value *= (pwr * noise_basis(p, basis) + 1.0f); + pwr *= pwHL; + p *= lacunarity; + } + + rmd = octaves - floor(octaves); + if(rmd != 0.0f) + value *= (rmd * pwr * noise_basis(p, basis) + 1.0f); /* correct? */ + + return value; +} + +/* Musgrave Heterogeneous Terrain + * + * H: fractal dimension of the roughest area + * lacunarity: gap between successive frequencies + * octaves: number of frequencies in the fBm + * offset: raises the terrain from `sea level' + */ + +__device float noise_musgrave_hetero_terrain(float3 p, NodeNoiseBasis basis, float H, float lacunarity, float octaves, float offset) +{ + float value, increment, rmd; + float pwHL = pow(lacunarity, -H); + float pwr = pwHL; + int i; + + /* first unscaled octave of function; later octaves are scaled */ + value = offset + noise_basis(p, basis); + p *= lacunarity; + + for(i = 1; i < (int)octaves; i++) { + increment = (noise_basis(p, basis) + offset) * pwr * value; + value += increment; + pwr *= pwHL; + p *= lacunarity; + } + + rmd = octaves - floor(octaves); + if(rmd != 0.0f) { + increment = (noise_basis(p, basis) + offset) * pwr * value; + value += rmd * increment; + } + + return value; +} + +/* Hybrid Additive/Multiplicative Multifractal Terrain + * + * H: fractal dimension of the roughest area + * lacunarity: gap between successive frequencies + * octaves: number of frequencies in the fBm + * offset: raises the terrain from `sea level' + */ + +__device float noise_musgrave_hybrid_multi_fractal(float3 p, NodeNoiseBasis basis, float H, float lacunarity, float octaves, float offset, float gain) +{ + float result, signal, weight, rmd; + float pwHL = pow(lacunarity, -H); + float pwr = pwHL; + int i; + + result = noise_basis(p, basis) + offset; + weight = gain * result; + p *= lacunarity; + + for(i = 1; (weight > 0.001f) && (i < (int)octaves); i++) { + if(weight > 1.0f) + weight = 1.0f; + + signal = (noise_basis(p, basis) + offset) * pwr; + pwr *= pwHL; + result += weight * signal; + weight *= gain * signal; + p *= lacunarity; + } + + rmd = octaves - floor(octaves); + if(rmd != 0.0f) + result += rmd * ((noise_basis(p, basis) + offset) * pwr); + + return result; +} + +/* Ridged Multifractal Terrain + * + * H: fractal dimension of the roughest area + * lacunarity: gap between successive frequencies + * octaves: number of frequencies in the fBm + * offset: raises the terrain from `sea level' + */ + +__device float noise_musgrave_ridged_multi_fractal(float3 p, NodeNoiseBasis basis, float H, float lacunarity, float octaves, float offset, float gain) +{ + float result, signal, weight; + float pwHL = pow(lacunarity, -H); + float pwr = pwHL; + int i; + + signal = offset - fabsf(noise_basis(p, basis)); + signal *= signal; + result = signal; + weight = 1.0f; + + for(i = 1; i < (int)octaves; i++) { + p *= lacunarity; + weight = clamp(signal * gain, 0.0f, 1.0f); + signal = offset - fabsf(noise_basis(p, basis)); + signal *= signal; + signal *= weight; + result += signal * pwr; + pwr *= pwHL; + } + + return result; +} + +/* Shader */ + +__device float svm_musgrave(NodeMusgraveType type, NodeNoiseBasis basis, float dimension, float lacunarity, float octaves, float offset, float intensity, float gain, float size, float3 p) +{ + p /= size; + + if(type == NODE_MUSGRAVE_MULTIFRACTAL) + return intensity*noise_musgrave_multi_fractal(p, basis, dimension, lacunarity, octaves); + else if(type == NODE_MUSGRAVE_FBM) + return intensity*noise_musgrave_fBm(p, basis, dimension, lacunarity, octaves); + else if(type == NODE_MUSGRAVE_HYBRID_MULTIFRACTAL) + return intensity*noise_musgrave_hybrid_multi_fractal(p, basis, dimension, lacunarity, octaves, offset, gain); + else if(type == NODE_MUSGRAVE_RIDGED_MULTIFRACTAL) + return intensity*noise_musgrave_ridged_multi_fractal(p, basis, dimension, lacunarity, octaves, offset, gain); + else if(type == NODE_MUSGRAVE_HETERO_TERRAIN) + return intensity*noise_musgrave_hetero_terrain(p, basis, dimension, lacunarity, octaves, offset); + + return 0.0f; +} + +__device void svm_node_tex_musgrave(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node, int *offset) +{ + uint4 node2 = read_node(kg, offset); + uint4 node3 = read_node(kg, offset); + + uint type, basis, co_offset, fac_offset; + uint dimension_offset, lacunarity_offset, octaves_offset, offset_offset; + uint gain_offset, size_offset; + + decode_node_uchar4(node.y, &type, &basis, &co_offset, &fac_offset); + decode_node_uchar4(node.z, &dimension_offset, &lacunarity_offset, &octaves_offset, &offset_offset); + decode_node_uchar4(node.z, &gain_offset, &size_offset, NULL, NULL); + + float3 co = stack_load_float3(stack, co_offset); + float dimension = stack_load_float_default(stack, dimension_offset, node2.x); + float lacunarity = stack_load_float_default(stack, lacunarity_offset, node2.y); + float octaves = stack_load_float_default(stack, octaves_offset, node2.z); + float foffset = stack_load_float_default(stack, offset_offset, node2.w); + float gain = stack_load_float_default(stack, gain_offset, node3.x); + float size = stack_load_float_default(stack, size_offset, node3.y); + + dimension = fmaxf(dimension, 0.0f); + octaves = fmaxf(octaves, 0.0f); + lacunarity = fmaxf(lacunarity, 1e-5f); + size = nonzerof(size, 1e-5f); + + float f = svm_musgrave((NodeMusgraveType)type, (NodeNoiseBasis)basis, + dimension, lacunarity, octaves, foffset, 1.0f, gain, size, co); + + stack_store_float(stack, fac_offset, f); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_noise.h b/intern/cycles/kernel/svm/svm_noise.h new file mode 100644 index 00000000000..745744e142c --- /dev/null +++ b/intern/cycles/kernel/svm/svm_noise.h @@ -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 + diff --git a/intern/cycles/kernel/svm/svm_noisetex.h b/intern/cycles/kernel/svm/svm_noisetex.h new file mode 100644 index 00000000000..38b249a80fe --- /dev/null +++ b/intern/cycles/kernel/svm/svm_noisetex.h @@ -0,0 +1,48 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +__device float svm_noise_texture_value(float3 p) +{ + return cellnoise(p*1e8f); +} + +__device float3 svm_noise_texture_color(float3 p) +{ + return cellnoise_color(p*1e8f); +} + +__device void svm_node_tex_noise_f(ShaderData *sd, float *stack, uint co_offset, uint out_offset) +{ + float3 co = stack_load_float3(stack, co_offset); + float f = svm_noise_texture_value(co); + + stack_store_float(stack, out_offset, f); +} + +__device void svm_node_tex_noise_v(ShaderData *sd, float *stack, uint co_offset, uint out_offset) +{ + float3 co = stack_load_float3(stack, co_offset); + float3 f = svm_noise_texture_color(co); + + stack_store_float3(stack, out_offset, f); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_sky.h b/intern/cycles/kernel/svm/svm_sky.h new file mode 100644 index 00000000000..dd02cb64cd7 --- /dev/null +++ b/intern/cycles/kernel/svm/svm_sky.h @@ -0,0 +1,92 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +__device float3 xyY_to_xyz(float x, float y, float Y) +{ + float X, Z; + + if(y != 0.0f) X = (x / y) * Y; + else X = 0.0f; + + if(y != 0.0f && Y != 0.0f) Z = (1.0f - x - y) / y * Y; + else Z = 0.0f; + + return make_float3(X, Y, Z); +} + +__device float3 xyz_to_rgb(float x, float y, float z) +{ + return make_float3(3.240479f * x + -1.537150f * y + -0.498535f * z, + -0.969256f * x + 1.875991f * y + 0.041556f * z, + 0.055648f * x + -0.204043f * y + 1.057311f * z); +} + +/* + * "A Practical Analytic Model for Daylight" + * A. J. Preetham, Peter Shirley, Brian Smits + */ + +__device float sky_angle_between(float thetav, float phiv, float theta, float phi) +{ + float cospsi = sinf(thetav)*sinf(theta)*cosf(phi - phiv) + cosf(thetav)*cosf(theta); + return safe_acosf(cospsi); +} + +__device float sky_perez_function(float lam[5], float theta, float gamma) +{ + float ctheta = cosf(theta); + float cgamma = cosf(gamma); + + return (1.0f + lam[0]*expf(lam[1]/ctheta)) * (1.0f + lam[2]*expf(lam[3]*gamma) + lam[4]*cgamma*cgamma); +} + +__device float3 sky_radiance(KernelGlobals *kg, float3 dir) +{ + /* convert vector to spherical coordinates */ + float2 spherical = direction_to_spherical(dir); + float theta = spherical.x; + float phi = spherical.y; + + /* angle between sun direction and dir */ + float gamma = sky_angle_between(theta, phi, kernel_data.sunsky.theta, kernel_data.sunsky.phi); + + /* clamp theta to horizon */ + theta = min(theta, M_PI_2_F - 0.001f); + + /* compute xyY color space values */ + float x = kernel_data.sunsky.zenith_x * sky_perez_function(kernel_data.sunsky.perez_x, theta, gamma); + float y = kernel_data.sunsky.zenith_y * sky_perez_function(kernel_data.sunsky.perez_y, theta, gamma); + float Y = kernel_data.sunsky.zenith_Y * sky_perez_function(kernel_data.sunsky.perez_Y, theta, gamma); + + /* convert to RGB */ + float3 xyz = xyY_to_xyz(x, y, Y); + return xyz_to_rgb(xyz.x, xyz.y, xyz.z); +} + +__device void svm_node_tex_sky(KernelGlobals *kg, ShaderData *sd, float *stack, uint dir_offset, uint out_offset) +{ + float3 dir = stack_load_float3(stack, dir_offset); + float3 f = sky_radiance(kg, dir); + + stack_store_float3(stack, out_offset, f); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_stucci.h b/intern/cycles/kernel/svm/svm_stucci.h new file mode 100644 index 00000000000..be8883b6388 --- /dev/null +++ b/intern/cycles/kernel/svm/svm_stucci.h @@ -0,0 +1,63 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Stucci */ + +__device float svm_stucci(NodeStucciType type, NodeNoiseBasis basis, int hard, float turbulence, float size, float3 p) +{ + p /= size; + + float b2 = noise_basis_hard(p, basis, hard); + float ofs = turbulence/200.0f; + + if(type != NODE_STUCCI_PLASTIC) + ofs *= b2*b2; + + float r = noise_basis_hard(make_float3(p.x, p.y, p.z+ofs), basis, hard); + + if(type == NODE_STUCCI_WALL_OUT) + r = 1.0f - r; + + return fmaxf(r, 0.0f); +} + +__device void svm_node_tex_stucci(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node, int *offset) +{ + uint4 node2 = read_node(kg, offset); + + uint type, basis, hard; + uint size_offset, turbulence_offset, co_offset, fac_offset; + + decode_node_uchar4(node.y, &type, &basis, &hard, NULL); + decode_node_uchar4(node.z, &size_offset, &turbulence_offset, &co_offset, &fac_offset); + + float3 co = stack_load_float3(stack, co_offset); + float size = stack_load_float_default(stack, size_offset, node2.x); + float turbulence = stack_load_float_default(stack, turbulence_offset, node2.y); + size = nonzerof(size, 1e-5f); + + float f = svm_stucci((NodeStucciType)type, (NodeNoiseBasis)basis, hard, + turbulence, size, co); + + stack_store_float(stack, fac_offset, f); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_tex_coord.h b/intern/cycles/kernel/svm/svm_tex_coord.h new file mode 100644 index 00000000000..bcf3716ae57 --- /dev/null +++ b/intern/cycles/kernel/svm/svm_tex_coord.h @@ -0,0 +1,170 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Texture Coordinate Node */ + +__device float3 svm_background_offset(KernelGlobals *kg) +{ + Transform cameratoworld = kernel_data.cam.cameratoworld; + return make_float3(cameratoworld.x.w, cameratoworld.y.w, cameratoworld.z.w); +} + +__device void svm_node_tex_coord(KernelGlobals *kg, ShaderData *sd, float *stack, uint type, uint out_offset) +{ + float3 data; + + switch(type) { + case NODE_TEXCO_OBJECT: { + if(sd->object != ~0) { + Transform tfm = object_fetch_transform(kg, sd->object, OBJECT_INVERSE_TRANSFORM); + data = transform(&tfm, sd->P); + } + else + data = sd->P; + break; + } + case NODE_TEXCO_CAMERA: { + Transform tfm = kernel_data.cam.worldtocamera; + + if(sd->object != ~0) + data = transform(&tfm, sd->P); + else + data = transform(&tfm, sd->P + svm_background_offset(kg)); + break; + } + case NODE_TEXCO_WINDOW: { + Transform tfm = kernel_data.cam.worldtondc; + + if(sd->object != ~0) + data = transform(&tfm, sd->P); + else + data = transform(&tfm, sd->P + svm_background_offset(kg)); + break; + } + case NODE_TEXCO_REFLECTION: { + if(sd->object != ~0) + data = sd->I - 2.0f*dot(sd->N, sd->I)*sd->N; + else + data = sd->I; + break; + } + } + + stack_store_float3(stack, out_offset, data); +} + +__device void svm_node_tex_coord_bump_dx(KernelGlobals *kg, ShaderData *sd, float *stack, uint type, uint out_offset) +{ +#ifdef __RAY_DIFFERENTIALS__ + float3 data; + + switch(type) { + case NODE_TEXCO_OBJECT: { + if(sd->object != ~0) { + Transform tfm = object_fetch_transform(kg, sd->object, OBJECT_INVERSE_TRANSFORM); + data = transform(&tfm, sd->P + sd->dP.dx); + } + else + data = sd->P + sd->dP.dx; + break; + } + case NODE_TEXCO_CAMERA: { + Transform tfm = kernel_data.cam.worldtocamera; + + if(sd->object != ~0) + data = transform(&tfm, sd->P + sd->dP.dx); + else + data = transform(&tfm, sd->P + sd->dP.dx + svm_background_offset(kg)); + break; + } + case NODE_TEXCO_WINDOW: { + Transform tfm = kernel_data.cam.worldtondc; + + if(sd->object != ~0) + data = transform(&tfm, sd->P + sd->dP.dx); + else + data = transform(&tfm, sd->P + sd->dP.dx + svm_background_offset(kg)); + break; + } + case NODE_TEXCO_REFLECTION: { + if(sd->object != ~0) + data = sd->I - 2.0f*dot(sd->N, sd->I)*sd->N; + else + data = sd->I; + break; + } + } + + stack_store_float3(stack, out_offset, data); +#else + svm_node_tex_coord(kg, sd, stack, type, out_offset); +#endif +} + +__device void svm_node_tex_coord_bump_dy(KernelGlobals *kg, ShaderData *sd, float *stack, uint type, uint out_offset) +{ +#ifdef __RAY_DIFFERENTIALS__ + float3 data; + + switch(type) { + case NODE_TEXCO_OBJECT: { + if(sd->object != ~0) { + Transform tfm = object_fetch_transform(kg, sd->object, OBJECT_INVERSE_TRANSFORM); + data = transform(&tfm, sd->P + sd->dP.dy); + } + else + data = sd->P + sd->dP.dy; + break; + } + case NODE_TEXCO_CAMERA: { + Transform tfm = kernel_data.cam.worldtocamera; + + if(sd->object != ~0) + data = transform(&tfm, sd->P + sd->dP.dy); + else + data = transform(&tfm, sd->P + sd->dP.dy + svm_background_offset(kg)); + break; + } + case NODE_TEXCO_WINDOW: { + Transform tfm = kernel_data.cam.worldtondc; + + if(sd->object != ~0) + data = transform(&tfm, sd->P + sd->dP.dy); + else + data = transform(&tfm, sd->P + sd->dP.dy + svm_background_offset(kg)); + break; + } + case NODE_TEXCO_REFLECTION: { + if(sd->object != ~0) + data = sd->I - 2.0f*dot(sd->N, sd->I)*sd->N; + else + data = sd->I; + break; + } + } + + stack_store_float3(stack, out_offset, data); +#else + svm_node_tex_coord(kg, sd, stack, type, out_offset); +#endif +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_texture.h b/intern/cycles/kernel/svm/svm_texture.h new file mode 100644 index 00000000000..c5f71c0d5bd --- /dev/null +++ b/intern/cycles/kernel/svm/svm_texture.h @@ -0,0 +1,240 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Voronoi Distances */ + +__device float voronoi_distance(NodeDistanceMetric distance_metric, float3 d, float e) +{ + if(distance_metric == NODE_VORONOI_DISTANCE_SQUARED) + return dot(d, d); + if(distance_metric == NODE_VORONOI_ACTUAL_DISTANCE) + return len(d); + if(distance_metric == NODE_VORONOI_MANHATTAN) + return fabsf(d.x) + fabsf(d.y) + fabsf(d.z); + if(distance_metric == NODE_VORONOI_CHEBYCHEV) + return fmaxf(fabsf(d.x), fmaxf(fabsf(d.y), fabsf(d.z))); + if(distance_metric == NODE_VORONOI_MINKOVSKY_H) + return sqrtf(fabsf(d.x)) + sqrtf(fabsf(d.y)) + sqrtf(fabsf(d.y)); + if(distance_metric == NODE_VORONOI_MINKOVSKY_4) + return sqrtf(sqrtf(dot(d*d, d*d))); + if(distance_metric == NODE_VORONOI_MINKOVSKY) + return powf(powf(fabsf(d.x), e) + powf(fabsf(d.y), e) + powf(fabsf(d.z), e), 1.0f/e); + + return 0.0f; +} + +/* Voronoi / Worley like */ + +__device void voronoi(float3 p, NodeDistanceMetric distance_metric, float e, float da[4], float3 pa[4]) +{ + /* returns distances in da and point coords in pa */ + int xx, yy, zz, xi, yi, zi; + + xi = (int)floorf(p.x); + yi = (int)floorf(p.y); + zi = (int)floorf(p.z); + + da[0] = 1e10f; + da[1] = 1e10f; + da[2] = 1e10f; + da[3] = 1e10f; + + pa[0] = make_float3(0.0f, 0.0f, 0.0f); + pa[1] = make_float3(0.0f, 0.0f, 0.0f); + pa[2] = make_float3(0.0f, 0.0f, 0.0f); + pa[3] = make_float3(0.0f, 0.0f, 0.0f); + + for(xx = xi-1; xx <= xi+1; xx++) { + for(yy = yi-1; yy <= yi+1; yy++) { + for(zz = zi-1; zz <= zi+1; zz++) { + float3 ip = make_float3(xx, yy, zz); + float3 vp = cellnoise_color(ip); + float3 pd = p - (vp + ip); + float d = voronoi_distance(distance_metric, pd, e); + + vp += make_float3(xx, yy, zz); + + if(d < da[0]) { + da[3] = da[2]; + da[2] = da[1]; + da[1] = da[0]; + da[0] = d; + + pa[3] = pa[2]; + pa[2] = pa[1]; + pa[1] = pa[0]; + pa[0] = vp; + } + else if(d < da[1]) { + da[3] = da[2]; + da[2] = da[1]; + da[1] = d; + + pa[3] = pa[2]; + pa[2] = pa[1]; + pa[1] = vp; + } + else if(d < da[2]) { + da[3] = da[2]; + da[2] = d; + + pa[3] = pa[2]; + pa[2] = vp; + } + else if(d < da[3]) { + da[3] = d; + pa[3] = vp; + } + } + } + } +} + +__device float voronoi_Fn(float3 p, int n) +{ + float da[4]; + float3 pa[4]; + + voronoi(p, NODE_VORONOI_DISTANCE_SQUARED, 0, da, pa); + + return da[n]; +} + +__device float voronoi_FnFn(float3 p, int n1, int n2) +{ + float da[4]; + float3 pa[4]; + + voronoi(p, NODE_VORONOI_DISTANCE_SQUARED, 0, da, pa); + + return da[n2] - da[n1]; +} + +__device float voronoi_F1(float3 p) { return voronoi_Fn(p, 0); } +__device float voronoi_F2(float3 p) { return voronoi_Fn(p, 1); } +__device float voronoi_F3(float3 p) { return voronoi_Fn(p, 2); } +__device float voronoi_F4(float3 p) { return voronoi_Fn(p, 3); } +__device float voronoi_F1F2(float3 p) { return voronoi_FnFn(p, 0, 1); } + +__device float voronoi_Cr(float3 p) +{ + /* crackle type pattern, just a scale/clamp of F2-F1 */ + float t = 10.0f*voronoi_F1F2(p); + return (t > 1.0f)? 1.0f: t; +} + +__device float voronoi_F1S(float3 p) { return 2.0f*voronoi_F1(p) - 1.0f; } +__device float voronoi_F2S(float3 p) { return 2.0f*voronoi_F2(p) - 1.0f; } +__device float voronoi_F3S(float3 p) { return 2.0f*voronoi_F3(p) - 1.0f; } +__device float voronoi_F4S(float3 p) { return 2.0f*voronoi_F4(p) - 1.0f; } +__device float voronoi_F1F2S(float3 p) { return 2.0f*voronoi_F1F2(p) - 1.0f; } +__device float voronoi_CrS(float3 p) { return 2.0f*voronoi_Cr(p) - 1.0f; } + +/* Noise Bases */ + +__device float noise_basis(float3 p, NodeNoiseBasis basis) +{ + /* Only Perlin enabled for now, others break CUDA compile by making kernel + too big, with compile using > 4GB, due to everything being inlined. */ + +#if 0 + if(basis == NODE_NOISE_PERLIN) +#endif + return noise(p); +#if 0 + if(basis == NODE_NOISE_VORONOI_F1) + return voronoi_F1S(p); + if(basis == NODE_NOISE_VORONOI_F2) + return voronoi_F2S(p); + if(basis == NODE_NOISE_VORONOI_F3) + return voronoi_F3S(p); + if(basis == NODE_NOISE_VORONOI_F4) + return voronoi_F4S(p); + if(basis == NODE_NOISE_VORONOI_F2_F1) + return voronoi_F1F2S(p); + if(basis == NODE_NOISE_VORONOI_CRACKLE) + return voronoi_CrS(p); + if(basis == NODE_NOISE_CELL_NOISE) + return cellnoise(p); + + return 0.0f; +#endif +} + +/* Soft/Hard Noise */ + +__device float noise_basis_hard(float3 p, NodeNoiseBasis basis, int hard) +{ + float t = noise_basis(p, basis); + return (hard)? fabsf(2.0f*t - 1.0f): t; +} + +/* Waves */ + +__device float noise_wave(NodeWaveType wave, float a) +{ + if(wave == NODE_WAVE_SINE) { + return 0.5f + 0.5f*sin(a); + } + else if(wave == NODE_WAVE_SAW) { + float b = 2*M_PI; + int n = (int)(a / b); + a -= n*b; + if(a < 0) a += b; + + return a / b; + } + else if(wave == NODE_WAVE_TRI) { + float b = 2*M_PI; + float rmax = 1.0f; + + return rmax - 2.0f*fabsf(floorf((a*(1.0f/b))+0.5f) - (a*(1.0f/b))); + } + + return 0.0f; +} + +/* Turbulence */ + +__device float noise_turbulence(float3 p, NodeNoiseBasis basis, int octaves, int hard) +{ + float fscale = 1.0f; + float amp = 1.0f; + float sum = 0.0f; + int i; + + for(i = 0; i <= octaves; i++) { + float t = noise_basis(fscale*p, basis); + + if(hard) + t = fabsf(2.0f*t - 1.0f); + + sum += t*amp; + amp *= 0.5f; + fscale *= 2.0f; + } + + sum *= ((float)(1 << octaves)/(float)((1 << (octaves+1)) - 1)); + + return sum; +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_types.h b/intern/cycles/kernel/svm/svm_types.h new file mode 100644 index 00000000000..aa58aba79c9 --- /dev/null +++ b/intern/cycles/kernel/svm/svm_types.h @@ -0,0 +1,286 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef __SVM_TYPES_H__ +#define __SVM_TYPES_H__ + +CCL_NAMESPACE_BEGIN + +/* Stack */ + +/* SVM stack has a fixed size */ +#define SVM_STACK_SIZE 64 +/* SVM stack offsets with this value indicate that it's not on the stack */ +#define SVM_STACK_INVALID 255 + +/* Nodes */ + +/* note that we do not simply use 0, 1, 2, .. as values for these. this works + * around an obscure CUDA bug that happens when compiling for fermi. why it + * happens i have no idea, but consecutive values are problematic, maybe it + * generates an incorrect jump table. */ + +enum NodeType { + NODE_END = 0, + NODE_CLOSURE_BSDF = 100, + NODE_CLOSURE_EMISSION = 200, + NODE_CLOSURE_BACKGROUND = 300, + NODE_CLOSURE_SET_WEIGHT = 400, + NODE_CLOSURE_WEIGHT = 500, + NODE_MIX_CLOSURE = 600, + NODE_JUMP = 700, + NODE_TEX_NOISE_F = 800, + NODE_TEX_NOISE_V = 900, + NODE_TEX_IMAGE = 1000, + NODE_TEX_SKY = 1100, + NODE_GEOMETRY = 1200, + NODE_LIGHT_PATH = 1300, + NODE_VALUE_F = 1400, + NODE_VALUE_V = 1500, + NODE_MIX = 1600, + NODE_ATTR = 1700, + NODE_CONVERT = 1900, + NODE_FRESNEL = 2000, + NODE_EMISSION_WEIGHT = 2100, + NODE_TEX_BLEND = 2200, + NODE_TEX_VORONOI = 2300, + NODE_TEX_MUSGRAVE = 2400, + NODE_TEX_MARBLE = 2500, + NODE_TEX_MAGIC = 2600, + NODE_TEX_STUCCI = 2700, + NODE_TEX_DISTORTED_NOISE = 2800, + NODE_TEX_WOOD = 2900, + NODE_TEX_CLOUDS = 3000, + NODE_SHADER_JUMP = 3100, + NODE_SET_DISPLACEMENT = 3200, + NODE_GEOMETRY_BUMP_DX = 3300, + NODE_GEOMETRY_BUMP_DY = 3400, + NODE_SET_BUMP = 3500, + NODE_MATH = 3600, + NODE_VECTOR_MATH = 3700, + NODE_MAPPING = 3800, + NODE_TEX_COORD = 3900, + NODE_TEX_COORD_BUMP_DX = 4000, + NODE_TEX_COORD_BUMP_DY = 4100, + NODE_ADD_CLOSURE = 4200, + NODE_EMISSION_SET_WEIGHT_TOTAL = 4300, + NODE_ATTR_BUMP_DX = 4400, + NODE_ATTR_BUMP_DY = 4500, + NODE_TEX_ENVIRONMENT = 4600 +}; + +enum NodeAttributeType { + NODE_ATTR_FLOAT = 0, + NODE_ATTR_FLOAT3 +}; + +enum NodeGeometry { + NODE_GEOM_P = 0, + NODE_GEOM_N, + NODE_GEOM_T, + NODE_GEOM_I, + NODE_GEOM_Ng, + NODE_GEOM_uv +}; + +enum NodeLightPath { + NODE_LP_camera = 0, + NODE_LP_shadow, + NODE_LP_diffuse, + NODE_LP_glossy, + NODE_LP_reflection, + NODE_LP_transmission, + NODE_LP_backfacing +}; + +enum NodeTexCoord { + NODE_TEXCO_OBJECT, + NODE_TEXCO_CAMERA, + NODE_TEXCO_WINDOW, + NODE_TEXCO_REFLECTION +}; + +enum NodeMix { + NODE_MIX_BLEND = 0, + NODE_MIX_ADD, + NODE_MIX_MUL, + NODE_MIX_SCREEN, + NODE_MIX_OVERLAY, + NODE_MIX_SUB, + NODE_MIX_DIV, + NODE_MIX_DIFF, + NODE_MIX_DARK, + NODE_MIX_LIGHT, + NODE_MIX_DODGE, + NODE_MIX_BURN, + NODE_MIX_HUE, + NODE_MIX_SAT, + NODE_MIX_VAL, + NODE_MIX_COLOR, + NODE_MIX_SOFT, + NODE_MIX_LINEAR +}; + +enum NodeMath { + NODE_MATH_ADD, + NODE_MATH_SUBTRACT, + NODE_MATH_MULTIPLY, + NODE_MATH_DIVIDE, + NODE_MATH_SINE, + NODE_MATH_COSINE, + NODE_MATH_TANGENT, + NODE_MATH_ARCSINE, + NODE_MATH_ARCCOSINE, + NODE_MATH_ARCTANGENT, + NODE_MATH_POWER, + NODE_MATH_LOGARITHM, + NODE_MATH_MINIMUM, + NODE_MATH_MAXIMUM, + NODE_MATH_ROUND, + NODE_MATH_LESS_THAN, + NODE_MATH_GREATER_THAN +}; + +enum NodeVectorMath { + NODE_VECTOR_MATH_ADD, + NODE_VECTOR_MATH_SUBTRACT, + NODE_VECTOR_MATH_AVERAGE, + NODE_VECTOR_MATH_DOT_PRODUCT, + NODE_VECTOR_MATH_CROSS_PRODUCT, + NODE_VECTOR_MATH_NORMALIZE +}; + +enum NodeConvert { + NODE_CONVERT_FV, + NODE_CONVERT_CF, + NODE_CONVERT_VF +}; + +enum NodeDistanceMetric { + NODE_VORONOI_DISTANCE_SQUARED, + NODE_VORONOI_ACTUAL_DISTANCE, + NODE_VORONOI_MANHATTAN, + NODE_VORONOI_CHEBYCHEV, + NODE_VORONOI_MINKOVSKY_H, + NODE_VORONOI_MINKOVSKY_4, + NODE_VORONOI_MINKOVSKY +}; + +enum NodeNoiseBasis { + NODE_NOISE_PERLIN, + NODE_NOISE_VORONOI_F1, + NODE_NOISE_VORONOI_F2, + NODE_NOISE_VORONOI_F3, + NODE_NOISE_VORONOI_F4, + NODE_NOISE_VORONOI_F2_F1, + NODE_NOISE_VORONOI_CRACKLE, + NODE_NOISE_CELL_NOISE +}; + +enum NodeWaveType { + NODE_WAVE_SINE, + NODE_WAVE_SAW, + NODE_WAVE_TRI +}; + +enum NodeMusgraveType { + NODE_MUSGRAVE_MULTIFRACTAL, + NODE_MUSGRAVE_FBM, + NODE_MUSGRAVE_HYBRID_MULTIFRACTAL, + NODE_MUSGRAVE_RIDGED_MULTIFRACTAL, + NODE_MUSGRAVE_HETERO_TERRAIN +}; + +enum NodeWoodType { + NODE_WOOD_BANDS, + NODE_WOOD_RINGS, + NODE_WOOD_BAND_NOISE, + NODE_WOOD_RING_NOISE +}; + +enum NodeBlendType { + NODE_BLEND_LINEAR, + NODE_BLEND_QUADRATIC, + NODE_BLEND_EASING, + NODE_BLEND_DIAGONAL, + NODE_BLEND_RADIAL, + NODE_BLEND_QUADRATIC_SPHERE, + NODE_BLEND_SPHERICAL +}; + +enum NodeBlendAxis { + NODE_BLEND_HORIZONTAL, + NODE_BLEND_VERTICAL +}; + +enum NodeMarbleType { + NODE_MARBLE_SOFT, + NODE_MARBLE_SHARP, + NODE_MARBLE_SHARPER +}; + +enum NodeStucciType { + NODE_STUCCI_PLASTIC, + NODE_STUCCI_WALL_IN, + NODE_STUCCI_WALL_OUT +}; + +enum NodeVoronoiColoring { + NODE_VORONOI_INTENSITY, + NODE_VORONOI_POSITION, + NODE_VORONOI_POSITION_OUTLINE, + NODE_VORONOI_POSITION_OUTLINE_INTENSITY +}; + +enum ShaderType { + SHADER_TYPE_SURFACE, + SHADER_TYPE_VOLUME, + SHADER_TYPE_DISPLACEMENT +}; + +/* Closure */ + +typedef enum ClosureType { + CLOSURE_BSDF_DIFFUSE_ID, + CLOSURE_BSDF_TRANSLUCENT_ID, + CLOSURE_BSDF_REFLECTION_ID, + CLOSURE_BSDF_REFRACTION_ID, + CLOSURE_BSDF_GLASS_ID, + CLOSURE_BSDF_TRANSPARENT_ID, + CLOSURE_BSDF_MICROFACET_GGX_ID, + CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID, + CLOSURE_BSDF_MICROFACET_BECKMANN_ID, + CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID, + CLOSURE_BSDF_WARD_ID, + CLOSURE_BSDF_ASHIKHMIN_VELVET_ID, + CLOSURE_BSDF_WESTIN_BACKSCATTER_ID, + CLOSURE_BSDF_WESTIN_SHEEN_ID, + CLOSURE_BSSRDF_CUBIC_ID, + CLOSURE_EMISSION_ID, + CLOSURE_DEBUG_ID, + CLOSURE_BACKGROUND_ID, + CLOSURE_HOLDOUT_ID, + CLOSURE_SUBSURFACE_ID, + + NBUILTIN_CLOSURES +} ClosureType; + +CCL_NAMESPACE_END + +#endif /* __SVM_TYPES_H__ */ + diff --git a/intern/cycles/kernel/svm/svm_value.h b/intern/cycles/kernel/svm/svm_value.h new file mode 100644 index 00000000000..80cb285f80c --- /dev/null +++ b/intern/cycles/kernel/svm/svm_value.h @@ -0,0 +1,38 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Value Nodes */ + +__device void svm_node_value_f(KernelGlobals *kg, ShaderData *sd, float *stack, uint ivalue, uint out_offset) +{ + stack_store_float(stack, out_offset, __int_as_float(ivalue)); +} + +__device void svm_node_value_v(KernelGlobals *kg, ShaderData *sd, float *stack, uint out_offset, int *offset) +{ + /* read extra data */ + uint4 node1 = read_node(kg, offset); + float3 p = make_float3(__int_as_float(node1.y), __int_as_float(node1.z), __int_as_float(node1.w)); + + stack_store_float3(stack, out_offset, p); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_voronoi.h b/intern/cycles/kernel/svm/svm_voronoi.h new file mode 100644 index 00000000000..df37b8faca8 --- /dev/null +++ b/intern/cycles/kernel/svm/svm_voronoi.h @@ -0,0 +1,105 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Voronoi */ + +__device float svm_voronoi(NodeDistanceMetric distance_metric, NodeVoronoiColoring coloring, + float weight1, float weight2, float weight3, float weight4, + float exponent, float intensity, float size, float3 p, float3 *color) +{ + float aw1 = fabsf(weight1); + float aw2 = fabsf(weight2); + float aw3 = fabsf(weight3); + float aw4 = fabsf(weight4); + float sc = (aw1 + aw2 + aw3 + aw4); + + if(sc != 0.0f) + sc = intensity/sc; + + /* compute distance and point coordinate of 4 nearest neighbours */ + float da[4]; + float3 pa[4]; + + voronoi(p/size, distance_metric, exponent, da, pa); + + /* Scalar output */ + float fac = sc * fabsf(weight1*da[0] + weight2*da[1] + weight3*da[2] + weight4*da[3]); + + /* colored output */ + if(coloring == NODE_VORONOI_INTENSITY) { + *color = make_float3(fac, fac, fac); + } + else { + *color = aw1*cellnoise_color(pa[0]); + *color += aw2*cellnoise_color(pa[1]); + *color += aw3*cellnoise_color(pa[2]); + *color += aw4*cellnoise_color(pa[3]); + + if(coloring != NODE_VORONOI_POSITION) { + float t1 = min((da[1] - da[0])*10.0f, 1.0f); + + if(coloring == NODE_VORONOI_POSITION_OUTLINE_INTENSITY) + *color *= t1*fac; + else if(coloring == NODE_VORONOI_POSITION_OUTLINE) + *color *= t1*sc; + } + else { + *color *= sc; + } + } + + return fac; +} + +__device void svm_node_tex_voronoi(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node, int *offset) +{ + uint4 node2 = read_node(kg, offset); + uint4 node3 = read_node(kg, offset); + + uint distance_metric, coloring, exponent_offset; + uint size_offset, co_offset, fac_offset, color_offset; + uint weight1_offset, weight2_offset, weight3_offset, weight4_offset; + + decode_node_uchar4(node.y, &distance_metric, &coloring, &exponent_offset, NULL); + decode_node_uchar4(node.z, &size_offset, &co_offset, &fac_offset, &color_offset); + decode_node_uchar4(node.w, &weight1_offset, &weight2_offset, &weight3_offset, &weight4_offset); + + float3 co = stack_load_float3(stack, co_offset); + float weight1 = stack_load_float_default(stack, weight1_offset, node2.x); + float weight2 = stack_load_float_default(stack, weight2_offset, node2.y); + float weight3 = stack_load_float_default(stack, weight3_offset, node2.z); + float weight4 = stack_load_float_default(stack, weight4_offset, node2.w); + float exponent = stack_load_float_default(stack, exponent_offset, node3.x); + float size = stack_load_float_default(stack, size_offset, node3.y); + + exponent = fmaxf(exponent, 1e-5f); + size = nonzerof(size, 1e-5f); + + float3 color; + float f = svm_voronoi((NodeDistanceMetric)distance_metric, + (NodeVoronoiColoring)coloring, + weight1, weight2, weight3, weight4, exponent, 1.0f, size, co, &color); + + if(stack_valid(fac_offset)) stack_store_float(stack, fac_offset, f); + if(stack_valid(color_offset)) stack_store_float3(stack, color_offset, color); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/svm_wood.h b/intern/cycles/kernel/svm/svm_wood.h new file mode 100644 index 00000000000..5c94a9fa3a2 --- /dev/null +++ b/intern/cycles/kernel/svm/svm_wood.h @@ -0,0 +1,69 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Wood */ + +__device float svm_wood(float3 p, float size, NodeWoodType type, NodeWaveType wave, NodeNoiseBasis basis, uint hard, float turb) +{ + float x = p.x; + float y = p.y; + float z = p.z; + + if(type == NODE_WOOD_BANDS) { + return noise_wave(wave, (x + y + z)*10.0f); + } + else if(type == NODE_WOOD_RINGS) { + return noise_wave(wave, sqrt(x*x + y*y + z*z)*20.0f); + } + else if (type == NODE_WOOD_BAND_NOISE) { + float wi = turb*noise_basis_hard(p/size, basis, hard); + return noise_wave(wave, (x + y + z)*10.0f + wi); + } + else if (type == NODE_WOOD_RING_NOISE) { + float wi = turb*noise_basis_hard(p/size, basis, hard); + return noise_wave(wave, sqrt(x*x + y*y + z*z)*20.0f + wi); + } + + return 0.0f; +} + +__device void svm_node_tex_wood(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node, int *offset) +{ + uint4 node2 = read_node(kg, offset); + + uint type, wave, basis, hard; + uint co_offset, size_offset, turbulence_offset, fac_offset; + + decode_node_uchar4(node.y, &type, &wave, &basis, &hard); + decode_node_uchar4(node.z, &co_offset, &size_offset, &turbulence_offset, &fac_offset); + + float3 co = stack_load_float3(stack, co_offset); + float size = stack_load_float_default(stack, size_offset, node2.y); + float turbulence = stack_load_float_default(stack, turbulence_offset, node2.z); + size = nonzerof(size, 1e-5f); + + float f = svm_wood(co, size, (NodeWoodType)type, (NodeWaveType)wave, + (NodeNoiseBasis)basis, hard, turbulence); + + stack_store_float(stack, fac_offset, f); +} + +CCL_NAMESPACE_END + diff --git a/intern/cycles/kernel/svm/volume.h b/intern/cycles/kernel/svm/volume.h new file mode 100644 index 00000000000..32e0601ee00 --- /dev/null +++ b/intern/cycles/kernel/svm/volume.h @@ -0,0 +1,43 @@ +/* + * 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 + +/* VOLUME CLOSURE */ + +__device float3 volume_eval_phase(ShaderData *sd, const float3 omega_in, const float3 omega_out) +{ + return make_float3(1.0f, 1.0f, 1.0f); +} + +CCL_NAMESPACE_END + |