Differential D1463 Diff 4888 intern/cycles/kernel/svm/svm_voronoi_crackle.h

Changeset View

Standalone View

intern/cycles/kernel/svm/svm_voronoi_crackle.h

This file was added.

				/*
				* Copyright 2011-2013 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

				/* Voronoi Crackle */

				ccl_device float voronoi_F2F1_distance(NodeVoronoiCrackleMetric distance_metric, float3 p)
				{

				float da = 1e10f;
				float da2 = 1e10f;

				#ifndef __KERNEL_SSE2__
				int ix = floor_to_int(p.x), iy = floor_to_int(p.y), iz = floor_to_int(p.z);

				for(int xx = -1; xx <= 1; xx++) {
				for(int yy = -1; yy <= 1; yy++) {
				for(int zz = -1; zz <= 1; zz++) {
				float3 ip = make_float3(ix + xx, iy + yy, iz + zz);
				float3 vp = ip + cellnoise_color(ip);
				float d;
				switch(distance_metric){
				default:
				d = len_squared(p - vp);
				break;
				case NODE_VORONOI_CRACKLE_DISTANCE:
				d = sqrtf(len_squared(p - vp));
				break;
				case NODE_VORONOI_CRACKLE_MANHATTAN:
				vp = vp - p;
				d = fabsf(vp.x) + fabsf(vp.y) + fabsf(vp.z);
				break;
				case NODE_VORONOI_CRACKLE_CHEBYCHEV:
				vp = vp - p;
				d = fmaxf(fabsf(vp.x), fmaxf(fabsf(vp.y), fabsf(vp.z)));
				break;
				}
				/* to keep the shortest two distances we have to keep them in sorted order, hence the two comparisons */
				if(d < da){
				da2 = da;
				da = d;
				}else if(d < da2){
				da2 = d;
				}
				}
				}
				}
				#else
				ssef vec_p = load4f(p);
				ssei xyzi = quick_floor_sse(vec_p);

				for(int xx = -1; xx <= 1; xx++) {
				for(int yy = -1; yy <= 1; yy++) {
				for(int zz = -1; zz <= 1; zz++) {
				ssef ip = ssef(xyzi + ssei(xx, yy, zz, 0));
				ssef vp = ip + cellnoise_color(ip);
				float d;
				switch(distance_metric){
				default:
				d = len_squared<1, 1, 1, 0>(vec_p - vp);
				break;
				case NODE_VORONOI_CRACKLE_DISTANCE:
				d = sqrtf(len_squared<1, 1, 1, 0>(vec_p - vp));
				break;
				case NODE_VORONOI_CRACKLE_MANHATTAN:
				vp -= vec_p;
				d = fabsf(vp[0]) + fabsf(vp[1]) + fabsf(vp[2]);
				break;
				case NODE_VORONOI_CRACKLE_CHEBYCHEV:
				vp -= vec_p;
				d = fmaxf(fabsf(vp[0]), fmaxf(fabsf(vp[1]), fabsf(vp[2])));
				break;
				}
				/* to keep the shortest two distances we have to keep them in sorted order, hence the two comparisons */
				if(d < da){
				da2 = da;
				da = d;
				}else if(d < da2){
				da2 = d;
				}
				}
				}
				}
				#endif

				return da2 - da;
				}

				ccl_device void svm_node_tex_voronoi_crackle(KernelGlobals kg, ShaderData sd, float stack, uint4 node, int offset)
				{
				uint metric;
				uint scale_offset, co_offset, fac_offset, color_offset;

				decode_node_uchar4(node.y, &metric, NULL, NULL, NULL);
				decode_node_uchar4(node.z, &scale_offset, &co_offset, &fac_offset, &color_offset);

				float3 co = stack_load_float3(stack, co_offset);
				float scale = stack_load_float_default(stack, scale_offset, node.w);

				float result = voronoi_F2F1_distance((NodeVoronoiCrackleMetric)metric, co*scale);
				float3 color = make_float3(result, result, result);

				if(stack_valid(fac_offset)) stack_store_float(stack, fac_offset, result);
				if(stack_valid(color_offset)) stack_store_float3(stack, color_offset, color);
				}

				CCL_NAMESPACE_END