Differential D12367 Diff 41308 intern/cycles/kernel/svm/svm_tex_coord.h

Changeset View

Standalone View

intern/cycles/kernel/svm/svm_tex_coord.h

/*		/*
* Copyright 2011-2013 Blender Foundation		* Copyright 2011-2013 Blender Foundation
*		*
* Licensed under the Apache License, Version 2.0 (the "License");		* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.		* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at		* You may obtain a copy of the License at
*		*
* http://www.apache.org/licenses/LICENSE-2.0		* http://www.apache.org/licenses/LICENSE-2.0
*		*
* Unless required by applicable law or agreed to in writing, software		* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,		* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and		* See the License for the specific language governing permissions and
* limitations under the License.		* limitations under the License.
*/		*/

		#include "kernel/geom/geom.h"
		#include "kernel/kernel_camera.h"
		#include "kernel/kernel_montecarlo.h"

CCL_NAMESPACE_BEGIN		CCL_NAMESPACE_BEGIN

/* Texture Coordinate Node */		/* Texture Coordinate Node */

ccl_device void svm_node_tex_coord(		ccl_device_noinline int svm_node_tex_coord(
KernelGlobals kg, ShaderData sd, int path_flag, float stack, uint4 node, int offset)		const KernelGlobals kg, ShaderData sd, int path_flag, float *stack, uint4 node, int offset)
{		{
float3 data;		float3 data;
uint type = node.y;		uint type = node.y;
uint out_offset = node.z;		uint out_offset = node.z;

switch (type) {		switch (type) {
case NODE_TEXCO_OBJECT: {		case NODE_TEXCO_OBJECT: {
data = sd->P;		data = sd->P;
if (node.w == 0) {		if (node.w == 0) {
if (sd->object != OBJECT_NONE) {		if (sd->object != OBJECT_NONE) {
object_inverse_position_transform(kg, sd, &data);		object_inverse_position_transform(kg, sd, &data);
}		}
}		}
else {		else {
Transform tfm;		Transform tfm;
tfm.x = read_node_float(kg, offset);		tfm.x = read_node_float(kg, &offset);
tfm.y = read_node_float(kg, offset);		tfm.y = read_node_float(kg, &offset);
tfm.z = read_node_float(kg, offset);		tfm.z = read_node_float(kg, &offset);
data = transform_point(&tfm, data);		data = transform_point(&tfm, data);
}		}
break;		break;
}		}
case NODE_TEXCO_NORMAL: {		case NODE_TEXCO_NORMAL: {
data = sd->N;		data = sd->N;
object_inverse_normal_transform(kg, sd, &data);		object_inverse_normal_transform(kg, sd, &data);
break;		break;
Show All 38 Lines	#ifdef __VOLUME__
if (sd->object != OBJECT_NONE)		if (sd->object != OBJECT_NONE)
data = volume_normalized_position(kg, sd, data);		data = volume_normalized_position(kg, sd, data);
#endif		#endif
break;		break;
}		}
}		}

stack_store_float3(stack, out_offset, data);		stack_store_float3(stack, out_offset, data);
		return offset;
}		}

ccl_device void svm_node_tex_coord_bump_dx(		ccl_device_noinline int svm_node_tex_coord_bump_dx(
KernelGlobals kg, ShaderData sd, int path_flag, float stack, uint4 node, int offset)		const KernelGlobals kg, ShaderData sd, int path_flag, float *stack, uint4 node, int offset)
{		{
#ifdef __RAY_DIFFERENTIALS__		#ifdef __RAY_DIFFERENTIALS__
float3 data;		float3 data;
uint type = node.y;		uint type = node.y;
uint out_offset = node.z;		uint out_offset = node.z;

switch (type) {		switch (type) {
case NODE_TEXCO_OBJECT: {		case NODE_TEXCO_OBJECT: {
data = sd->P + sd->dP.dx;		data = sd->P + sd->dP.dx;
if (node.w == 0) {		if (node.w == 0) {
if (sd->object != OBJECT_NONE) {		if (sd->object != OBJECT_NONE) {
object_inverse_position_transform(kg, sd, &data);		object_inverse_position_transform(kg, sd, &data);
}		}
}		}
else {		else {
Transform tfm;		Transform tfm;
tfm.x = read_node_float(kg, offset);		tfm.x = read_node_float(kg, &offset);
tfm.y = read_node_float(kg, offset);		tfm.y = read_node_float(kg, &offset);
tfm.z = read_node_float(kg, offset);		tfm.z = read_node_float(kg, &offset);
data = transform_point(&tfm, data);		data = transform_point(&tfm, data);
}		}
break;		break;
}		}
case NODE_TEXCO_NORMAL: {		case NODE_TEXCO_NORMAL: {
data = sd->N;		data = sd->N;
object_inverse_normal_transform(kg, sd, &data);		object_inverse_normal_transform(kg, sd, &data);
break;		break;
}		}
case NODE_TEXCO_CAMERA: {		case NODE_TEXCO_CAMERA: {
Transform tfm = kernel_data.cam.worldtocamera;		Transform tfm = kernel_data.cam.worldtocamera;

if (sd->object != OBJECT_NONE)		if (sd->object != OBJECT_NONE)
data = transform_point(&tfm, sd->P + sd->dP.dx);		data = transform_point(&tfm, sd->P + sd->dP.dx);
else		else
data = transform_point(&tfm, sd->P + sd->dP.dx + camera_position(kg));		data = transform_point(&tfm, sd->P + sd->dP.dx + camera_position(kg));
break;		break;
}		}
case NODE_TEXCO_WINDOW: {		case NODE_TEXCO_WINDOW: {
if ((path_flag & PATH_RAY_CAMERA) && sd->object == OBJECT_NONE &&		if ((path_flag & PATH_RAY_CAMERA) && sd->object == OBJECT_NONE &&
kernel_data.cam.type == CAMERA_ORTHOGRAPHIC)		kernel_data.cam.type == CAMERA_ORTHOGRAPHIC)
data = camera_world_to_ndc(kg, sd, sd->ray_P + sd->ray_dP.dx);		data = camera_world_to_ndc(kg, sd, sd->ray_P); /* TODO: + sd->ray_dP.dx); */
else		else
data = camera_world_to_ndc(kg, sd, sd->P + sd->dP.dx);		data = camera_world_to_ndc(kg, sd, sd->P + sd->dP.dx);
data.z = 0.0f;		data.z = 0.0f;
break;		break;
}		}
case NODE_TEXCO_REFLECTION: {		case NODE_TEXCO_REFLECTION: {
if (sd->object != OBJECT_NONE)		if (sd->object != OBJECT_NONE)
data = 2.0f * dot(sd->N, sd->I) * sd->N - sd->I;		data = 2.0f * dot(sd->N, sd->I) * sd->N - sd->I;
Show All 16 Lines	# ifdef __VOLUME__
if (sd->object != OBJECT_NONE)		if (sd->object != OBJECT_NONE)
data = volume_normalized_position(kg, sd, data);		data = volume_normalized_position(kg, sd, data);
# endif		# endif
break;		break;
}		}
}		}

stack_store_float3(stack, out_offset, data);		stack_store_float3(stack, out_offset, data);
		return offset;
#else		#else
svm_node_tex_coord(kg, sd, path_flag, stack, node, offset);		return svm_node_tex_coord(kg, sd, path_flag, stack, node, offset);
#endif		#endif
}		}

ccl_device void svm_node_tex_coord_bump_dy(		ccl_device_noinline int svm_node_tex_coord_bump_dy(
KernelGlobals kg, ShaderData sd, int path_flag, float stack, uint4 node, int offset)		const KernelGlobals kg, ShaderData sd, int path_flag, float *stack, uint4 node, int offset)
{		{
#ifdef __RAY_DIFFERENTIALS__		#ifdef __RAY_DIFFERENTIALS__
float3 data;		float3 data;
uint type = node.y;		uint type = node.y;
uint out_offset = node.z;		uint out_offset = node.z;

switch (type) {		switch (type) {
case NODE_TEXCO_OBJECT: {		case NODE_TEXCO_OBJECT: {
data = sd->P + sd->dP.dy;		data = sd->P + sd->dP.dy;
if (node.w == 0) {		if (node.w == 0) {
if (sd->object != OBJECT_NONE) {		if (sd->object != OBJECT_NONE) {
object_inverse_position_transform(kg, sd, &data);		object_inverse_position_transform(kg, sd, &data);
}		}
}		}
else {		else {
Transform tfm;		Transform tfm;
tfm.x = read_node_float(kg, offset);		tfm.x = read_node_float(kg, &offset);
tfm.y = read_node_float(kg, offset);		tfm.y = read_node_float(kg, &offset);
tfm.z = read_node_float(kg, offset);		tfm.z = read_node_float(kg, &offset);
data = transform_point(&tfm, data);		data = transform_point(&tfm, data);
}		}
break;		break;
}		}
case NODE_TEXCO_NORMAL: {		case NODE_TEXCO_NORMAL: {
data = sd->N;		data = sd->N;
object_inverse_normal_transform(kg, sd, &data);		object_inverse_normal_transform(kg, sd, &data);
break;		break;
}		}
case NODE_TEXCO_CAMERA: {		case NODE_TEXCO_CAMERA: {
Transform tfm = kernel_data.cam.worldtocamera;		Transform tfm = kernel_data.cam.worldtocamera;

if (sd->object != OBJECT_NONE)		if (sd->object != OBJECT_NONE)
data = transform_point(&tfm, sd->P + sd->dP.dy);		data = transform_point(&tfm, sd->P + sd->dP.dy);
else		else
data = transform_point(&tfm, sd->P + sd->dP.dy + camera_position(kg));		data = transform_point(&tfm, sd->P + sd->dP.dy + camera_position(kg));
break;		break;
}		}
case NODE_TEXCO_WINDOW: {		case NODE_TEXCO_WINDOW: {
if ((path_flag & PATH_RAY_CAMERA) && sd->object == OBJECT_NONE &&		if ((path_flag & PATH_RAY_CAMERA) && sd->object == OBJECT_NONE &&
kernel_data.cam.type == CAMERA_ORTHOGRAPHIC)		kernel_data.cam.type == CAMERA_ORTHOGRAPHIC)
data = camera_world_to_ndc(kg, sd, sd->ray_P + sd->ray_dP.dy);		data = camera_world_to_ndc(kg, sd, sd->ray_P); /* TODO: + sd->ray_dP.dy); */
else		else
data = camera_world_to_ndc(kg, sd, sd->P + sd->dP.dy);		data = camera_world_to_ndc(kg, sd, sd->P + sd->dP.dy);
data.z = 0.0f;		data.z = 0.0f;
break;		break;
}		}
case NODE_TEXCO_REFLECTION: {		case NODE_TEXCO_REFLECTION: {
if (sd->object != OBJECT_NONE)		if (sd->object != OBJECT_NONE)
data = 2.0f * dot(sd->N, sd->I) * sd->N - sd->I;		data = 2.0f * dot(sd->N, sd->I) * sd->N - sd->I;
Show All 16 Lines	# ifdef __VOLUME__
if (sd->object != OBJECT_NONE)		if (sd->object != OBJECT_NONE)
data = volume_normalized_position(kg, sd, data);		data = volume_normalized_position(kg, sd, data);
# endif		# endif
break;		break;
}		}
}		}

stack_store_float3(stack, out_offset, data);		stack_store_float3(stack, out_offset, data);
		return offset;
#else		#else
svm_node_tex_coord(kg, sd, path_flag, stack, node, offset);		return svm_node_tex_coord(kg, sd, path_flag, stack, node, offset);
#endif		#endif
}		}

ccl_device void svm_node_normal_map(KernelGlobals kg, ShaderData sd, float *stack, uint4 node)		ccl_device_noinline void svm_node_normal_map(const KernelGlobals *kg,
		ShaderData *sd,
		float *stack,
		uint4 node)
{		{
uint color_offset, strength_offset, normal_offset, space;		uint color_offset, strength_offset, normal_offset, space;
svm_unpack_node_uchar4(node.y, &color_offset, &strength_offset, &normal_offset, &space);		svm_unpack_node_uchar4(node.y, &color_offset, &strength_offset, &normal_offset, &space);

float3 color = stack_load_float3(stack, color_offset);		float3 color = stack_load_float3(stack, color_offset);
color = 2.0f * make_float3(color.x - 0.5f, color.y - 0.5f, color.z - 0.5f);		color = 2.0f * make_float3(color.x - 0.5f, color.y - 0.5f, color.z - 0.5f);

bool is_backfacing = (sd->flag & SD_BACKFACING) != 0;		bool is_backfacing = (sd->flag & SD_BACKFACING) != 0;
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines	ccl_device_noinline void svm_node_normal_map(const KernelGlobals *kg,

if (is_zero(N)) {		if (is_zero(N)) {
N = sd->N;		N = sd->N;
}		}

stack_store_float3(stack, normal_offset, N);		stack_store_float3(stack, normal_offset, N);
}		}

ccl_device void svm_node_tangent(KernelGlobals kg, ShaderData sd, float *stack, uint4 node)		ccl_device_noinline void svm_node_tangent(const KernelGlobals *kg,
		ShaderData *sd,
		float *stack,
		uint4 node)
{		{
uint tangent_offset, direction_type, axis;		uint tangent_offset, direction_type, axis;
svm_unpack_node_uchar3(node.y, &tangent_offset, &direction_type, &axis);		svm_unpack_node_uchar3(node.y, &tangent_offset, &direction_type, &axis);

float3 tangent;		float3 tangent;
float3 attribute_value;		float3 attribute_value;
const AttributeDescriptor desc = find_attribute(kg, sd, node.z);		const AttributeDescriptor desc = find_attribute(kg, sd, node.z);
if (desc.offset != ATTR_STD_NOT_FOUND) {		if (desc.offset != ATTR_STD_NOT_FOUND) {
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines