intern/cycles/util/util_math_float3.h

   1 /*
   2  * Copyright 2011-2017 Blender Foundation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef __UTIL_MATH_FLOAT3_H__
  18 #define __UTIL_MATH_FLOAT3_H__
  19
  20 #ifndef __UTIL_MATH_H__
  21 #  error "Do not include this file directly, include util_types.h instead."
  22 #endif
  23
  24 CCL_NAMESPACE_BEGIN
  25
  26 /*******************************************************************************
  27  * Declaration.
  28  */
  29
  30 #ifndef __KERNEL_OPENCL__
  31 ccl_device_inline float3 operator-(const float3& a);
  32 ccl_device_inline float3 operator*(const float3& a, const float3& b);
  33 ccl_device_inline float3 operator*(const float3& a, const float f);
  34 ccl_device_inline float3 operator*(const float f, const float3& a);
  35 ccl_device_inline float3 operator/(const float f, const float3& a);
  36 ccl_device_inline float3 operator/(const float3& a, const float f);
  37 ccl_device_inline float3 operator/(const float3& a, const float3& b);
  38 ccl_device_inline float3 operator+(const float3& a, const float3& b);
  39 ccl_device_inline float3 operator-(const float3& a, const float3& b);
  40 ccl_device_inline float3 operator+=(float3& a, const float3& b);
  41 ccl_device_inline float3 operator-=(float3& a, const float3& b);
  42 ccl_device_inline float3 operator*=(float3& a, const float3& b);
  43 ccl_device_inline float3 operator*=(float3& a, float f);
  44 ccl_device_inline float3 operator/=(float3& a, const float3& b);
  45 ccl_device_inline float3 operator/=(float3& a, float f);
  46
  47 ccl_device_inline bool operator==(const float3& a, const float3& b);
  48 ccl_device_inline bool operator!=(const float3& a, const float3& b);
  49
  50 ccl_device_inline float dot(const float3& a, const float3& b);
  51 ccl_device_inline float dot_xy(const float3& a, const float3& b);
  52 ccl_device_inline float3 cross(const float3& a, const float3& b);
  53 ccl_device_inline float3 normalize(const float3& a);
  54 ccl_device_inline float3 min(const float3& a, const float3& b);
  55 ccl_device_inline float3 max(const float3& a, const float3& b);
  56 ccl_device_inline float3 clamp(const float3& a, const float3& mn, const float3& mx);
  57 ccl_device_inline float3 fabs(const float3& a);
  58 ccl_device_inline float3 mix(const float3& a, const float3& b, float t);
  59 ccl_device_inline float3 rcp(const float3& a);
  60 #endif  /* !__KERNEL_OPENCL__ */
  61
  62 ccl_device_inline float max3(float3 a);
  63 ccl_device_inline float len(const float3 a);
  64 ccl_device_inline float len_squared(const float3 a);
  65
  66 ccl_device_inline float3 saturate3(float3 a);
  67 ccl_device_inline float3 safe_normalize(const float3 a);
  68 ccl_device_inline float3 normalize_len(const float3 a, float *t);;
  69 ccl_device_inline float3 safe_normalize_len(const float3 a, float *t);
  70 ccl_device_inline float3 interp(float3 a, float3 b, float t);
  71
  72 ccl_device_inline bool is_zero(const float3 a);
  73 ccl_device_inline float reduce_add(const float3 a);
  74 ccl_device_inline float average(const float3 a);
  75 ccl_device_inline bool isequal_float3(const float3 a, const float3 b);
  76
  77 /*******************************************************************************
  78  * Definition.
  79  */
  80
  81 #ifndef __KERNEL_OPENCL__
  82 ccl_device_inline float3 operator-(const float3& a)
  83 {
  84 #ifdef __KERNEL_SSE__
  85         return float3(_mm_xor_ps(a.m128, _mm_castsi128_ps(_mm_set1_epi32(0x80000000))));
  86 #else
  87         return make_float3(-a.x, -a.y, -a.z);
  88 #endif
  89 }
  90
  91 ccl_device_inline float3 operator*(const float3& a, const float3& b)
  92 {
  93 #ifdef __KERNEL_SSE__
  94         return float3(_mm_mul_ps(a.m128,b.m128));
  95 #else
  96         return make_float3(a.x*b.x, a.y*b.y, a.z*b.z);
  97 #endif
  98 }
  99
 100 ccl_device_inline float3 operator*(const float3& a, const float f)
 101 {
 102 #ifdef __KERNEL_SSE__
 103         return float3(_mm_mul_ps(a.m128,_mm_set1_ps(f)));
 104 #else
 105         return make_float3(a.x*f, a.y*f, a.z*f);
 106 #endif
 107 }
 108
 109 ccl_device_inline float3 operator*(const float f, const float3& a)
 110 {
 111         /* TODO(sergey): Currently disabled, gives speedup but causes precision issues. */
 112 #if defined(__KERNEL_SSE__) && 0
 113         return float3(_mm_mul_ps(_mm_set1_ps(f), a.m128));
 114 #else
 115         return make_float3(a.x*f, a.y*f, a.z*f);
 116 #endif
 117 }
 118
 119 ccl_device_inline float3 operator/(const float f, const float3& a)
 120 {
 121         /* TODO(sergey): Currently disabled, gives speedup but causes precision issues. */
 122 #if defined(__KERNEL_SSE__) && 0
 123         __m128 rc = _mm_rcp_ps(a.m128);
 124         return float3(_mm_mul_ps(_mm_set1_ps(f),rc));
 125 #else
 126         return make_float3(f / a.x, f / a.y, f / a.z);
 127 #endif
 128 }
 129
 130 ccl_device_inline float3 operator/(const float3& a, const float f)
 131 {
 132         float invf = 1.0f/f;
 133         return a * invf;
 134 }
 135
 136 ccl_device_inline float3 operator/(const float3& a, const float3& b)
 137 {
 138         /* TODO(sergey): Currently disabled, gives speedup but causes precision issues. */
 139 #if defined(__KERNEL_SSE__) && 0
 140         __m128 rc = _mm_rcp_ps(b.m128);
 141         return float3(_mm_mul_ps(a, rc));
 142 #else
 143         return make_float3(a.x / b.x, a.y / b.y, a.z / b.z);
 144 #endif
 145 }
 146
 147 ccl_device_inline float3 operator+(const float3& a, const float3& b)
 148 {
 149 #ifdef __KERNEL_SSE__
 150         return float3(_mm_add_ps(a.m128, b.m128));
 151 #else
 152         return make_float3(a.x + b.x, a.y + b.y, a.z + b.z);
 153 #endif
 154 }
 155
 156 ccl_device_inline float3 operator-(const float3& a, const float3& b)
 157 {
 158 #ifdef __KERNEL_SSE__
 159         return float3(_mm_sub_ps(a.m128, b.m128));
 160 #else
 161         return make_float3(a.x - b.x, a.y - b.y, a.z - b.z);
 162 #endif
 163 }
 164
 165 ccl_device_inline float3 operator+=(float3& a, const float3& b)
 166 {
 167         return a = a + b;
 168 }
 169
 170 ccl_device_inline float3 operator-=(float3& a, const float3& b)
 171 {
 172         return a = a - b;
 173 }
 174
 175 ccl_device_inline float3 operator*=(float3& a, const float3& b)
 176 {
 177         return a = a * b;
 178 }
 179
 180 ccl_device_inline float3 operator*=(float3& a, float f)
 181 {
 182         return a = a * f;
 183 }
 184
 185 ccl_device_inline float3 operator/=(float3& a, const float3& b)
 186 {
 187         return a = a / b;
 188 }
 189
 190 ccl_device_inline float3 operator/=(float3& a, float f)
 191 {
 192         float invf = 1.0f/f;
 193         return a = a * invf;
 194 }
 195
 196 ccl_device_inline bool operator==(const float3& a, const float3& b)
 197 {
 198 #ifdef __KERNEL_SSE__
 199         return (_mm_movemask_ps(_mm_cmpeq_ps(a.m128, b.m128)) & 7) == 7;
 200 #else
 201         return (a.x == b.x && a.y == b.y && a.z == b.z);
 202 #endif
 203 }
 204
 205 ccl_device_inline bool operator!=(const float3& a, const float3& b)
 206 {
 207         return !(a == b);
 208 }
 209
 210 ccl_device_inline float dot(const float3& a, const float3& b)
 211 {
 212 #if defined(__KERNEL_SSE41__) && defined(__KERNEL_SSE__)
 213         return _mm_cvtss_f32(_mm_dp_ps(a, b, 0x7F));
 214 #else
 215         return a.x*b.x + a.y*b.y + a.z*b.z;
 216 #endif
 217 }
 218
 219 ccl_device_inline float dot_xy(const float3& a, const float3& b)
 220 {
 221 #if defined(__KERNEL_SSE41__) && defined(__KERNEL_SSE__)
 222         return _mm_cvtss_f32(_mm_hadd_ps(_mm_mul_ps(a,b),b));
 223 #else
 224         return a.x*b.x + a.y*b.y;
 225 #endif
 226 }
 227
 228 ccl_device_inline float3 cross(const float3& a, const float3& b)
 229 {
 230         float3 r = make_float3(a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x);
 231         return r;
 232 }
 233
 234 ccl_device_inline float3 normalize(const float3& a)
 235 {
 236 #if defined(__KERNEL_SSE41__) && defined(__KERNEL_SSE__)
 237         __m128 norm = _mm_sqrt_ps(_mm_dp_ps(a.m128, a.m128, 0x7F));
 238         return float3(_mm_div_ps(a.m128, norm));
 239 #else
 240         return a/len(a);
 241 #endif
 242 }
 243
 244 ccl_device_inline float3 min(const float3& a, const float3& b)
 245 {
 246 #ifdef __KERNEL_SSE__
 247         return float3(_mm_min_ps(a.m128, b.m128));
 248 #else
 249         return make_float3(min(a.x, b.x), min(a.y, b.y), min(a.z, b.z));
 250 #endif
 251 }
 252
 253 ccl_device_inline float3 max(const float3& a, const float3& b)
 254 {
 255 #ifdef __KERNEL_SSE__
 256         return float3(_mm_max_ps(a.m128, b.m128));
 257 #else
 258         return make_float3(max(a.x, b.x), max(a.y, b.y), max(a.z, b.z));
 259 #endif
 260 }
 261
 262 ccl_device_inline float3 clamp(const float3& a, const float3& mn, const float3& mx)
 263 {
 264         return min(max(a, mn), mx);
 265 }
 266
 267 ccl_device_inline float3 fabs(const float3& a)
 268 {
 269 #ifdef __KERNEL_SSE__
 270         __m128 mask = _mm_castsi128_ps(_mm_set1_epi32(0x7fffffff));
 271         return float3(_mm_and_ps(a.m128, mask));
 272 #else
 273         return make_float3(fabsf(a.x), fabsf(a.y), fabsf(a.z));
 274 #endif
 275 }
 276
 277 ccl_device_inline float3 mix(const float3& a, const float3& b, float t)
 278 {
 279         return a + t*(b - a);
 280 }
 281
 282 ccl_device_inline float3 rcp(const float3& a)
 283 {
 284 #ifdef __KERNEL_SSE__
 285         const float4 r(_mm_rcp_ps(a.m128));
 286         return float3(_mm_sub_ps(_mm_add_ps(r, r),
 287                                  _mm_mul_ps(_mm_mul_ps(r, r), a)));
 288 #else
 289         return make_float3(1.0f/a.x, 1.0f/a.y, 1.0f/a.z);
 290 #endif
 291 }
 292 #endif  /* !__KERNEL_OPENCL__ */
 293
 294 ccl_device_inline float max3(float3 a)
 295 {
 296         return max(max(a.x, a.y), a.z);
 297 }
 298
 299 ccl_device_inline float len(const float3 a)
 300 {
 301 #if defined(__KERNEL_SSE41__) && defined(__KERNEL_SSE__)
 302         return _mm_cvtss_f32(_mm_sqrt_ss(_mm_dp_ps(a.m128, a.m128, 0x7F)));
 303 #else
 304         return sqrtf(dot(a, a));
 305 #endif
 306 }
 307
 308 ccl_device_inline float len_squared(const float3 a)
 309 {
 310         return dot(a, a);
 311 }
 312
 313 ccl_device_inline float3 saturate3(float3 a)
 314 {
 315         return make_float3(saturate(a.x), saturate(a.y), saturate(a.z));
 316 }
 317
 318 ccl_device_inline float3 normalize_len(const float3 a, float *t)
 319 {
 320         *t = len(a);
 321         float x = 1.0f / *t;
 322         return a*x;
 323 }
 324
 325 ccl_device_inline float3 safe_normalize(const float3 a)
 326 {
 327         float t = len(a);
 328         return (t != 0.0f)? a * (1.0f/t) : a;
 329 }
 330
 331 ccl_device_inline float3 safe_normalize_len(const float3 a, float *t)
 332 {
 333         *t = len(a);
 334         return (*t != 0.0f)? a/(*t): a;
 335 }
 336
 337 ccl_device_inline float3 interp(float3 a, float3 b, float t)
 338 {
 339         return a + t*(b - a);
 340 }
 341
 342 ccl_device_inline bool is_zero(const float3 a)
 343 {
 344 #ifdef __KERNEL_SSE__
 345         return a == make_float3(0.0f);
 346 #else
 347         return (a.x == 0.0f && a.y == 0.0f && a.z == 0.0f);
 348 #endif
 349 }
 350
 351 ccl_device_inline float reduce_add(const float3 a)
 352 {
 353         return (a.x + a.y + a.z);
 354 }
 355
 356 ccl_device_inline float average(const float3 a)
 357 {
 358         return reduce_add(a)*(1.0f/3.0f);
 359 }
 360
 361 ccl_device_inline bool isequal_float3(const float3 a, const float3 b)
 362 {
 363 #ifdef __KERNEL_OPENCL__
 364         return all(a == b);
 365 #else
 366         return a == b;
 367 #endif
 368 }
 369
 370 ccl_device_inline float3 ensure_finite3(float3 v)
 371 {
 372         if(!isfinite_safe(v.x)) v.x = 0.0;
 373         if(!isfinite_safe(v.y)) v.y = 0.0;
 374         if(!isfinite_safe(v.z)) v.z = 0.0;
 375         return v;
 376 }
 377
 378 CCL_NAMESPACE_END
 379
 380 #endif /* __UTIL_MATH_FLOAT3_H__ */