forked from bartvdbraak/blender
218 lines
7.9 KiB
C
218 lines
7.9 KiB
C
/*
|
|
* 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
|
|
|
|
/* Motion Curve Primitive
|
|
*
|
|
* These are stored as regular curves, plus extra positions and radii at times
|
|
* other than the frame center. Computing the curve keys at a given ray time is
|
|
* a matter of interpolation of the two steps between which the ray time lies.
|
|
*
|
|
* The extra curve keys are stored as ATTR_STD_MOTION_VERTEX_POSITION.
|
|
*/
|
|
|
|
#ifdef __HAIR__
|
|
|
|
ccl_device_inline int find_attribute_curve_motion(KernelGlobals *kg, int object, uint id, AttributeElement *elem)
|
|
{
|
|
/* todo: find a better (faster) solution for this, maybe store offset per object.
|
|
*
|
|
* NOTE: currently it's not a bottleneck because in test scenes the loop below runs
|
|
* zero iterations and rendering is really slow with motion curves. For until other
|
|
* areas are speed up it's probably not so crucial to optimize this out.
|
|
*/
|
|
uint attr_offset = object_attribute_map_offset(kg, object) + ATTR_PRIM_CURVE;
|
|
uint4 attr_map = kernel_tex_fetch(__attributes_map, attr_offset);
|
|
|
|
while(attr_map.x != id) {
|
|
attr_offset += ATTR_PRIM_TYPES;
|
|
attr_map = kernel_tex_fetch(__attributes_map, attr_offset);
|
|
}
|
|
|
|
*elem = (AttributeElement)attr_map.y;
|
|
|
|
/* return result */
|
|
return (attr_map.y == ATTR_ELEMENT_NONE) ? (int)ATTR_STD_NOT_FOUND : (int)attr_map.z;
|
|
}
|
|
|
|
ccl_device_inline void motion_curve_keys_for_step(KernelGlobals *kg, int offset, int numkeys, int numsteps, int step, int k0, int k1, float4 keys[2])
|
|
{
|
|
if(step == numsteps) {
|
|
/* center step: regular key location */
|
|
keys[0] = kernel_tex_fetch(__curve_keys, k0);
|
|
keys[1] = kernel_tex_fetch(__curve_keys, k1);
|
|
}
|
|
else {
|
|
/* center step is not stored in this array */
|
|
if(step > numsteps)
|
|
step--;
|
|
|
|
offset += step*numkeys;
|
|
|
|
keys[0] = kernel_tex_fetch(__attributes_float3, offset + k0);
|
|
keys[1] = kernel_tex_fetch(__attributes_float3, offset + k1);
|
|
}
|
|
}
|
|
|
|
/* return 2 curve key locations */
|
|
ccl_device_inline void motion_curve_keys(KernelGlobals *kg, int object, int prim, float time, int k0, int k1, float4 keys[2])
|
|
{
|
|
/* get motion info */
|
|
int numsteps, numkeys;
|
|
object_motion_info(kg, object, &numsteps, NULL, &numkeys);
|
|
|
|
/* figure out which steps we need to fetch and their interpolation factor */
|
|
int maxstep = numsteps*2;
|
|
int step = min((int)(time*maxstep), maxstep-1);
|
|
float t = time*maxstep - step;
|
|
|
|
/* find attribute */
|
|
AttributeElement elem;
|
|
int offset = find_attribute_curve_motion(kg, object, ATTR_STD_MOTION_VERTEX_POSITION, &elem);
|
|
kernel_assert(offset != ATTR_STD_NOT_FOUND);
|
|
|
|
/* fetch key coordinates */
|
|
float4 next_keys[2];
|
|
|
|
motion_curve_keys_for_step(kg, offset, numkeys, numsteps, step, k0, k1, keys);
|
|
motion_curve_keys_for_step(kg, offset, numkeys, numsteps, step+1, k0, k1, next_keys);
|
|
|
|
/* interpolate between steps */
|
|
keys[0] = (1.0f - t)*keys[0] + t*next_keys[0];
|
|
keys[1] = (1.0f - t)*keys[1] + t*next_keys[1];
|
|
}
|
|
|
|
ccl_device_inline void motion_cardinal_curve_keys_for_step(KernelGlobals *kg, int offset, int numkeys, int numsteps, int step, int k0, int k1, int k2, int k3, float4 keys[4])
|
|
{
|
|
if(step == numsteps) {
|
|
/* center step: regular key location */
|
|
keys[0] = kernel_tex_fetch(__curve_keys, k0);
|
|
keys[1] = kernel_tex_fetch(__curve_keys, k1);
|
|
keys[2] = kernel_tex_fetch(__curve_keys, k2);
|
|
keys[3] = kernel_tex_fetch(__curve_keys, k3);
|
|
}
|
|
else {
|
|
/* center step is not stored in this array */
|
|
if(step > numsteps)
|
|
step--;
|
|
|
|
offset += step*numkeys;
|
|
|
|
keys[0] = kernel_tex_fetch(__attributes_float3, offset + k0);
|
|
keys[1] = kernel_tex_fetch(__attributes_float3, offset + k1);
|
|
keys[2] = kernel_tex_fetch(__attributes_float3, offset + k2);
|
|
keys[3] = kernel_tex_fetch(__attributes_float3, offset + k3);
|
|
}
|
|
}
|
|
|
|
/* return 2 curve key locations */
|
|
ccl_device_inline void motion_cardinal_curve_keys(KernelGlobals *kg,
|
|
int object,
|
|
int prim,
|
|
float time,
|
|
int k0, int k1, int k2, int k3,
|
|
float4 keys[4])
|
|
{
|
|
/* get motion info */
|
|
int numsteps, numkeys;
|
|
object_motion_info(kg, object, &numsteps, NULL, &numkeys);
|
|
|
|
/* figure out which steps we need to fetch and their interpolation factor */
|
|
int maxstep = numsteps*2;
|
|
int step = min((int)(time*maxstep), maxstep-1);
|
|
float t = time*maxstep - step;
|
|
|
|
/* find attribute */
|
|
AttributeElement elem;
|
|
int offset = find_attribute_curve_motion(kg, object, ATTR_STD_MOTION_VERTEX_POSITION, &elem);
|
|
kernel_assert(offset != ATTR_STD_NOT_FOUND);
|
|
|
|
/* fetch key coordinates */
|
|
float4 next_keys[4];
|
|
|
|
motion_cardinal_curve_keys_for_step(kg, offset, numkeys, numsteps, step, k0, k1, k2, k3, keys);
|
|
motion_cardinal_curve_keys_for_step(kg, offset, numkeys, numsteps, step+1, k0, k1, k2, k3, next_keys);
|
|
|
|
/* interpolate between steps */
|
|
keys[0] = (1.0f - t)*keys[0] + t*next_keys[0];
|
|
keys[1] = (1.0f - t)*keys[1] + t*next_keys[1];
|
|
keys[2] = (1.0f - t)*keys[2] + t*next_keys[2];
|
|
keys[3] = (1.0f - t)*keys[3] + t*next_keys[3];
|
|
}
|
|
|
|
#if defined(__KERNEL_AVX2__) && defined(__KERNEL_SSE__)
|
|
/* Similar to above, but returns keys as pair of two AVX registers with each
|
|
* holding two float4.
|
|
*/
|
|
ccl_device_inline void motion_cardinal_curve_keys_avx(KernelGlobals *kg,
|
|
int object,
|
|
int prim,
|
|
float time,
|
|
int k0, int k1,
|
|
int k2, int k3,
|
|
avxf *out_keys_0_1,
|
|
avxf *out_keys_2_3)
|
|
{
|
|
/* Get motion info. */
|
|
int numsteps, numkeys;
|
|
object_motion_info(kg, object, &numsteps, NULL, &numkeys);
|
|
|
|
/* Figure out which steps we need to fetch and their interpolation factor. */
|
|
int maxstep = numsteps * 2;
|
|
int step = min((int)(time*maxstep), maxstep - 1);
|
|
float t = time*maxstep - step;
|
|
|
|
/* Find attribute. */
|
|
AttributeElement elem;
|
|
int offset = find_attribute_curve_motion(kg,
|
|
object,
|
|
ATTR_STD_MOTION_VERTEX_POSITION,
|
|
&elem);
|
|
kernel_assert(offset != ATTR_STD_NOT_FOUND);
|
|
|
|
/* Fetch key coordinates. */
|
|
float4 next_keys[4];
|
|
float4 keys[4];
|
|
motion_cardinal_curve_keys_for_step(kg,
|
|
offset,
|
|
numkeys,
|
|
numsteps,
|
|
step,
|
|
k0, k1, k2, k3,
|
|
keys);
|
|
motion_cardinal_curve_keys_for_step(kg,
|
|
offset,
|
|
numkeys,
|
|
numsteps,
|
|
step + 1,
|
|
k0, k1, k2, k3,
|
|
next_keys);
|
|
|
|
const avxf keys_0_1 = avxf(keys[0].m128, keys[1].m128);
|
|
const avxf keys_2_3 = avxf(keys[2].m128, keys[3].m128);
|
|
const avxf next_keys_0_1 = avxf(next_keys[0].m128, next_keys[1].m128);
|
|
const avxf next_keys_2_3 = avxf(next_keys[2].m128, next_keys[3].m128);
|
|
|
|
/* Interpolate between steps. */
|
|
*out_keys_0_1 = (1.0f - t) * keys_0_1 + t*next_keys_0_1;
|
|
*out_keys_2_3 = (1.0f - t) * keys_2_3 + t*next_keys_2_3;
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
|
|
CCL_NAMESPACE_END
|
|
|