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

Changeset View

Standalone View

intern/cycles/kernel/svm/svm_math.h

	Show All 10 Lines
	* 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.
	*/			*/

	CCL_NAMESPACE_BEGIN			CCL_NAMESPACE_BEGIN

	ccl_device void svm_node_math(KernelGlobals *kg,			ccl_device_noinline void svm_node_math(const KernelGlobals *kg,
	ShaderData *sd,			ShaderData *sd,
	float *stack,			float *stack,
	uint type,			uint type,
	uint inputs_stack_offsets,			uint inputs_stack_offsets,
	uint result_stack_offset,			uint result_stack_offset)
	int *offset)
	{			{
	uint a_stack_offset, b_stack_offset, c_stack_offset;			uint a_stack_offset, b_stack_offset, c_stack_offset;
	svm_unpack_node_uchar3(inputs_stack_offsets, &a_stack_offset, &b_stack_offset, &c_stack_offset);			svm_unpack_node_uchar3(inputs_stack_offsets, &a_stack_offset, &b_stack_offset, &c_stack_offset);

	float a = stack_load_float(stack, a_stack_offset);			float a = stack_load_float(stack, a_stack_offset);
	float b = stack_load_float(stack, b_stack_offset);			float b = stack_load_float(stack, b_stack_offset);
	float c = stack_load_float(stack, c_stack_offset);			float c = stack_load_float(stack, c_stack_offset);
	float result = svm_math((NodeMathType)type, a, b, c);			float result = svm_math((NodeMathType)type, a, b, c);

	stack_store_float(stack, result_stack_offset, result);			stack_store_float(stack, result_stack_offset, result);
	}			}

	ccl_device void svm_node_vector_math(KernelGlobals *kg,			ccl_device_noinline int svm_node_vector_math(const KernelGlobals *kg,
	ShaderData *sd,			ShaderData *sd,
	float *stack,			float *stack,
	uint type,			uint type,
	uint inputs_stack_offsets,			uint inputs_stack_offsets,
	uint outputs_stack_offsets,			uint outputs_stack_offsets,
	int *offset)			int offset)
	{			{
	uint value_stack_offset, vector_stack_offset;			uint value_stack_offset, vector_stack_offset;
	uint a_stack_offset, b_stack_offset, param1_stack_offset;			uint a_stack_offset, b_stack_offset, param1_stack_offset;
	svm_unpack_node_uchar3(			svm_unpack_node_uchar3(
	inputs_stack_offsets, &a_stack_offset, &b_stack_offset, &param1_stack_offset);			inputs_stack_offsets, &a_stack_offset, &b_stack_offset, &param1_stack_offset);
	svm_unpack_node_uchar2(outputs_stack_offsets, &value_stack_offset, &vector_stack_offset);			svm_unpack_node_uchar2(outputs_stack_offsets, &value_stack_offset, &vector_stack_offset);

	float3 a = stack_load_float3(stack, a_stack_offset);			float3 a = stack_load_float3(stack, a_stack_offset);
	float3 b = stack_load_float3(stack, b_stack_offset);			float3 b = stack_load_float3(stack, b_stack_offset);
	float3 c = make_float3(0.0f, 0.0f, 0.0f);			float3 c = make_float3(0.0f, 0.0f, 0.0f);
	float param1 = stack_load_float(stack, param1_stack_offset);			float param1 = stack_load_float(stack, param1_stack_offset);

	float value;			float value;
	float3 vector;			float3 vector;

	/* 3 Vector Operators */			/* 3 Vector Operators */
	if (type == NODE_VECTOR_MATH_WRAP \|\| type == NODE_VECTOR_MATH_FACEFORWARD \|\|			if (type == NODE_VECTOR_MATH_WRAP \|\| type == NODE_VECTOR_MATH_FACEFORWARD \|\|
	type == NODE_VECTOR_MATH_MULTIPLY_ADD) {			type == NODE_VECTOR_MATH_MULTIPLY_ADD) {
	uint4 extra_node = read_node(kg, offset);			uint4 extra_node = read_node(kg, &offset);
	c = stack_load_float3(stack, extra_node.x);			c = stack_load_float3(stack, extra_node.x);
	}			}

	svm_vector_math(&value, &vector, (NodeVectorMathType)type, a, b, c, param1);			svm_vector_math(&value, &vector, (NodeVectorMathType)type, a, b, c, param1);

	if (stack_valid(value_stack_offset))			if (stack_valid(value_stack_offset))
	stack_store_float(stack, value_stack_offset, value);			stack_store_float(stack, value_stack_offset, value);
	if (stack_valid(vector_stack_offset))			if (stack_valid(vector_stack_offset))
	stack_store_float3(stack, vector_stack_offset, vector);			stack_store_float3(stack, vector_stack_offset, vector);
				return offset;
	}			}

	CCL_NAMESPACE_END			CCL_NAMESPACE_END