Differential D12888 Diff 43495 intern/cycles/kernel/svm/svm_ao.h

Changeset View

Standalone View

intern/cycles/kernel/svm/svm_ao.h

Show All 15 Lines

#include "kernel/bvh/bvh.h"		#include "kernel/bvh/bvh.h"

CCL_NAMESPACE_BEGIN		CCL_NAMESPACE_BEGIN

#ifdef __SHADER_RAYTRACE__		#ifdef __SHADER_RAYTRACE__

# ifdef __KERNEL_OPTIX__		# ifdef __KERNEL_OPTIX__
extern "C" __device__ float __direct_callable__svm_node_ao(INTEGRATOR_STATE_CONST_ARGS,		extern "C" __device__ float __direct_callable__svm_node_ao(KernelGlobals kg,
		ConstIntegratorState state,
# else		# else
ccl_device float svm_ao(INTEGRATOR_STATE_CONST_ARGS,		ccl_device float svm_ao(KernelGlobals kg,
		ConstIntegratorState state,
# endif		# endif
ccl_private ShaderData *sd,		ccl_private ShaderData *sd,
float3 N,		float3 N,
float max_dist,		float max_dist,
int num_samples,		int num_samples,
int flags)		int flags)
{		{
if (flags & NODE_AO_GLOBAL_RADIUS) {		if (flags & NODE_AO_GLOBAL_RADIUS) {
Show All 14 Lines	if (flags & NODE_AO_INSIDE) {
N = -N;		N = -N;
}		}

float3 T, B;		float3 T, B;
make_orthonormals(N, &T, &B);		make_orthonormals(N, &T, &B);

/* TODO: support ray-tracing in shadow shader evaluation? */		/* TODO: support ray-tracing in shadow shader evaluation? */
RNGState rng_state;		RNGState rng_state;
path_state_rng_load(INTEGRATOR_STATE_PASS, &rng_state);		path_state_rng_load(state, &rng_state);

int unoccluded = 0;		int unoccluded = 0;
for (int sample = 0; sample < num_samples; sample++) {		for (int sample = 0; sample < num_samples; sample++) {
float disk_u, disk_v;		float disk_u, disk_v;
path_branched_rng_2D(kg, &rng_state, sample, num_samples, PRNG_BEVEL_U, &disk_u, &disk_v);		path_branched_rng_2D(kg, &rng_state, sample, num_samples, PRNG_BEVEL_U, &disk_u, &disk_v);

float2 d = concentric_sample_disk(disk_u, disk_v);		float2 d = concentric_sample_disk(disk_u, disk_v);
float3 D = make_float3(d.x, d.y, safe_sqrtf(1.0f - dot(d, d)));		float3 D = make_float3(d.x, d.y, safe_sqrtf(1.0f - dot(d, d)));
Show All 25 Lines

template<uint node_feature_mask>		template<uint node_feature_mask>
# if defined(__KERNEL_OPTIX__)		# if defined(__KERNEL_OPTIX__)
ccl_device_inline		ccl_device_inline
# else		# else
ccl_device_noinline		ccl_device_noinline
# endif		# endif
void		void
svm_node_ao(INTEGRATOR_STATE_CONST_ARGS,		svm_node_ao(KernelGlobals kg,
		ConstIntegratorState state,
ccl_private ShaderData *sd,		ccl_private ShaderData *sd,
ccl_private float *stack,		ccl_private float *stack,
uint4 node)		uint4 node)
{		{
uint flags, dist_offset, normal_offset, out_ao_offset;		uint flags, dist_offset, normal_offset, out_ao_offset;
svm_unpack_node_uchar4(node.y, &flags, &dist_offset, &normal_offset, &out_ao_offset);		svm_unpack_node_uchar4(node.y, &flags, &dist_offset, &normal_offset, &out_ao_offset);

uint color_offset, out_color_offset, samples;		uint color_offset, out_color_offset, samples;
svm_unpack_node_uchar3(node.z, &color_offset, &out_color_offset, &samples);		svm_unpack_node_uchar3(node.z, &color_offset, &out_color_offset, &samples);

float dist = stack_load_float_default(stack, dist_offset, node.w);		float dist = stack_load_float_default(stack, dist_offset, node.w);
float3 normal = stack_valid(normal_offset) ? stack_load_float3(stack, normal_offset) : sd->N;		float3 normal = stack_valid(normal_offset) ? stack_load_float3(stack, normal_offset) : sd->N;

float ao = 1.0f;		float ao = 1.0f;

if (KERNEL_NODES_FEATURE(RAYTRACE)) {		IF_KERNEL_NODES_FEATURE(RAYTRACE)
		{
# ifdef __KERNEL_OPTIX__		# ifdef __KERNEL_OPTIX__
ao = optixDirectCall<float>(0, INTEGRATOR_STATE_PASS, sd, normal, dist, samples, flags);		ao = optixDirectCall<float>(0, kg, state, sd, normal, dist, samples, flags);
# else		# else
ao = svm_ao(INTEGRATOR_STATE_PASS, sd, normal, dist, samples, flags);		ao = svm_ao(kg, state, sd, normal, dist, samples, flags);
# endif		# endif
}		}

if (stack_valid(out_ao_offset)) {		if (stack_valid(out_ao_offset)) {
stack_store_float(stack, out_ao_offset, ao);		stack_store_float(stack, out_ao_offset, ao);
}		}

if (stack_valid(out_color_offset)) {		if (stack_valid(out_color_offset)) {
float3 color = stack_load_float3(stack, color_offset);		float3 color = stack_load_float3(stack, color_offset);
stack_store_float3(stack, out_color_offset, ao * color);		stack_store_float3(stack, out_color_offset, ao * color);
}		}
}		}

#endif /* __SHADER_RAYTRACE__ */		#endif /* __SHADER_RAYTRACE__ */

CCL_NAMESPACE_END		CCL_NAMESPACE_END