src/MiniCL/cl_MiniCL_Defs.h

   1 /*
   2 Bullet Continuous Collision Detection and Physics Library, Copyright (c) 2007 Erwin Coumans
   3
   4 This software is provided 'as-is', without any express or implied warranty.
   5 In no event will the authors be held liable for any damages arising from the use of this software.
   6 Permission is granted to anyone to use this software for any purpose,
   7 including commercial applications, and to alter it and redistribute it freely,
   8 subject to the following restrictions:
   9
  10 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
  11 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
  12 3. This notice may not be removed or altered from any source distribution.
  13
  14 */
  15
  16 #include <float.h>
  17 #include <math.h>
  18 #include "LinearMath/btScalar.h"
  19
  20 #include "MiniCL/cl.h"
  21
  22
  23 #define __kernel
  24 #define __global
  25 #define __local
  26 #define get_global_id(a)        __guid_arg
  27 #define get_local_id(a)         ((__guid_arg) % gMiniCLNumOutstandingTasks)
  28 #define get_local_size(a)       (gMiniCLNumOutstandingTasks)
  29 #define get_group_id(a)         ((__guid_arg) / gMiniCLNumOutstandingTasks)
  30
  31 //static unsigned int as_uint(float val) { return *((unsigned int*)&val); }
  32
  33
  34 #define CLK_LOCAL_MEM_FENCE             0x01
  35 #define CLK_GLOBAL_MEM_FENCE    0x02
  36
  37 static void barrier(unsigned int a)
  38 {
  39         // TODO : implement
  40 }
  41
  42 //ATTRIBUTE_ALIGNED16(struct) float8
  43 struct float8
  44 {
  45         float s0;
  46         float s1;
  47         float s2;
  48         float s3;
  49         float s4;
  50         float s5;
  51         float s6;
  52         float s7;
  53
  54         float8(float scalar)
  55         {
  56                 s0=s1=s2=s3=s4=s5=s6=s7=scalar;
  57         }
  58 };
  59
  60
  61 float select( float arg0, float arg1, bool select)
  62 {
  63         if (select)
  64                 return arg0;
  65         return arg1;
  66 }
  67
  68 #define __constant
  69
  70
  71 struct float3
  72 {
  73         float x,y,z;
  74
  75         float3& operator+=(const float3& other)
  76         {
  77                 x += other.x;
  78                 y += other.y;
  79                 z += other.z;
  80                 return *this;
  81         }
  82
  83         float3& operator-=(const float3& other)
  84         {
  85                 x -= other.x;
  86                 y -= other.y;
  87                 z -= other.z;
  88                 return *this;
  89         }
  90
  91 };
  92
  93 static float dot(const float3&a ,const float3& b)
  94 {
  95         float3 tmp;
  96         tmp.x = a.x*b.x;
  97         tmp.y = a.y*b.y;
  98         tmp.z = a.z*b.z;
  99         return tmp.x+tmp.y+tmp.z;
 100 }
 101
 102 static float3 operator-(const float3& a,const float3& b)
 103 {
 104         float3 tmp;
 105         tmp.x = a.x - b.x;
 106         tmp.y = a.y - b.y;
 107         tmp.z = a.z - b.z;
 108         return tmp;
 109 }
 110
 111 static float3 operator*(const float& scalar,const float3& b)
 112 {
 113         float3 tmp;
 114         tmp.x = scalar * b.x;
 115         tmp.y = scalar * b.y;
 116         tmp.z = scalar * b.z;
 117         return tmp;
 118 }
 119
 120 static float3 operator*(const float3& a,const float& scalar)
 121 {
 122         float3 tmp;
 123         tmp.x = a.x * scalar;
 124         tmp.y = a.y * scalar;
 125         tmp.z = a.z * scalar;
 126         return tmp;
 127 }
 128
 129
 130 static float3 operator*(const float3& a,const float3& b)
 131 {
 132         float3 tmp;
 133         tmp.x = a.x * b.x;
 134         tmp.y = a.y * b.y;
 135         tmp.z = a.z * b.z;
 136         return tmp;
 137 }
 138
 139
 140 //ATTRIBUTE_ALIGNED16(struct) float4
 141 struct float4
 142 {
 143         union
 144         {
 145                 struct {
 146                         float x;
 147                         float y;
 148                         float z;
 149                 };
 150                 float3 xyz;
 151         };
 152         float w;
 153
 154         float4() {}
 155
 156         float4(float v0, float v1, float v2, float v3)
 157         {
 158                 x=v0;
 159                 y=v1;
 160                 z=v2;
 161                 w=v3;
 162
 163         }
 164         float4(float3 xyz, float scalarW)
 165         {
 166                 x = xyz.x;
 167                 y = xyz.y;
 168                 z = xyz.z;
 169                 w = scalarW;
 170         }
 171
 172         float4(float v)
 173         {
 174                 x = y = z = w = v;
 175         }
 176         float4 operator*(const float4& other)
 177         {
 178                 float4 tmp;
 179                 tmp.x = x*other.x;
 180                 tmp.y = y*other.y;
 181                 tmp.z = z*other.z;
 182                 tmp.w = w*other.w;
 183                 return tmp;
 184         }
 185
 186
 187
 188         float4 operator*(const float& other)
 189         {
 190                 float4 tmp;
 191                 tmp.x = x*other;
 192                 tmp.y = y*other;
 193                 tmp.z = z*other;
 194                 tmp.w = w*other;
 195                 return tmp;
 196         }
 197
 198
 199
 200         float4& operator+=(const float4& other)
 201         {
 202                 x += other.x;
 203                 y += other.y;
 204                 z += other.z;
 205                 w += other.w;
 206                 return *this;
 207         }
 208
 209         float4& operator-=(const float4& other)
 210         {
 211                 x -= other.x;
 212                 y -= other.y;
 213                 z -= other.z;
 214                 w -= other.w;
 215                 return *this;
 216         }
 217
 218         float4& operator *=(float scalar)
 219         {
 220                 x *= scalar;
 221                 y *= scalar;
 222                 z *= scalar;
 223                 w *= scalar;
 224                 return (*this);
 225         }
 226
 227
 228
 229
 230
 231 };
 232
 233 static float4 fabs(const float4& a)
 234 {
 235         float4 tmp;
 236         tmp.x = a.x < 0.f ? 0.f  : a.x;
 237         tmp.y = a.y < 0.f ? 0.f  : a.y;
 238         tmp.z = a.z < 0.f ? 0.f  : a.z;
 239         tmp.w = a.w < 0.f ? 0.f  : a.w;
 240         return tmp;
 241 }
 242 static float4 operator+(const float4& a,const float4& b)
 243 {
 244         float4 tmp;
 245         tmp.x = a.x + b.x;
 246         tmp.y = a.y + b.y;
 247         tmp.z = a.z + b.z;
 248         tmp.w = a.w + b.w;
 249         return tmp;
 250 }
 251
 252
 253 static float8 operator+(const float8& a,const float8& b)
 254 {
 255         float8 tmp(0);
 256         tmp.s0  = a.s0 + b.s0;
 257         tmp.s1  = a.s1 + b.s1;
 258         tmp.s2  = a.s2 + b.s2;
 259         tmp.s3  = a.s3 + b.s3;
 260         tmp.s4  = a.s4 + b.s4;
 261         tmp.s5  = a.s5 + b.s5;
 262         tmp.s6  = a.s6 + b.s6;
 263         tmp.s7  = a.s7 + b.s7;
 264         return tmp;
 265 }
 266
 267
 268 static float4 operator-(const float4& a,const float4& b)
 269 {
 270         float4 tmp;
 271         tmp.x = a.x - b.x;
 272         tmp.y = a.y - b.y;
 273         tmp.z = a.z - b.z;
 274         tmp.w = a.w - b.w;
 275         return tmp;
 276 }
 277
 278 static float8 operator-(const float8& a,const float8& b)
 279 {
 280         float8 tmp(0);
 281         tmp.s0  = a.s0 - b.s0;
 282         tmp.s1  = a.s1 - b.s1;
 283         tmp.s2  = a.s2 - b.s2;
 284         tmp.s3  = a.s3 - b.s3;
 285         tmp.s4  = a.s4 - b.s4;
 286         tmp.s5  = a.s5 - b.s5;
 287         tmp.s6  = a.s6 - b.s6;
 288         tmp.s7  = a.s7 - b.s7;
 289         return tmp;
 290 }
 291
 292 static float4 operator*(float a,const float4& b)
 293 {
 294         float4 tmp;
 295         tmp.x = a * b.x;
 296         tmp.y = a * b.y;
 297         tmp.z = a * b.z;
 298         tmp.w = a * b.w;
 299         return tmp;
 300 }
 301
 302 static float4 operator/(const float4& b,float a)
 303 {
 304         float4 tmp;
 305         tmp.x = b.x/a;
 306         tmp.y = b.y/a;
 307         tmp.z = b.z/a;
 308         tmp.w = b.w/a;
 309         return tmp;
 310 }
 311
 312
 313
 314
 315
 316 static float dot(const float4&a ,const float4& b)
 317 {
 318         float4 tmp;
 319         tmp.x = a.x*b.x;
 320         tmp.y = a.y*b.y;
 321         tmp.z = a.z*b.z;
 322         tmp.w = a.w*b.w;
 323         return tmp.x+tmp.y+tmp.z+tmp.w;
 324 }
 325
 326 static float length(const float4&a)
 327 {
 328         float l = sqrtf(a.x*a.x+a.y*a.y+a.z*a.z);
 329         return l;
 330 }
 331
 332 static float4 normalize(const float4&a)
 333 {
 334         float4 tmp;
 335         float l = length(a);
 336         tmp = 1.f/l*a;
 337         return tmp;
 338 }
 339
 340
 341
 342 static float4 cross(const float4&a ,const float4& b)
 343 {
 344         float4 tmp;
 345         tmp.x =  a.y*b.z - a.z*b.y;
 346         tmp.y = -a.x*b.z + a.z*b.x;
 347         tmp.z =  a.x*b.y - a.y*b.x;
 348         tmp.w = 0.f;
 349         return tmp;
 350 }
 351
 352 static float max(float a, float b)
 353 {
 354         return (a >= b) ? a : b;
 355 }
 356
 357
 358 static float min(float a, float b)
 359 {
 360         return (a <= b) ? a : b;
 361 }
 362
 363 static float fmax(float a, float b)
 364 {
 365         return (a >= b) ? a : b;
 366 }
 367
 368 static float fmin(float a, float b)
 369 {
 370         return (a <= b) ? a : b;
 371 }
 372
 373 struct int2
 374 {
 375         int x,y;
 376 };
 377
 378 struct uint2
 379 {
 380         unsigned int x,y;
 381 };
 382
 383 //typedef int2 uint2;
 384
 385 typedef unsigned int uint;
 386
 387 struct int4
 388 {
 389         int x,y,z,w;
 390 };
 391
 392 struct uint4
 393 {
 394         unsigned int x,y,z,w;
 395         uint4() {}
 396         uint4(uint val) { x = y = z = w = val; }
 397         uint4& operator+=(const uint4& other)
 398         {
 399                 x += other.x;
 400                 y += other.y;
 401                 z += other.z;
 402                 w += other.w;
 403                 return *this;
 404         }
 405 };
 406 static uint4 operator+(const uint4& a,const uint4& b)
 407 {
 408         uint4 tmp;
 409         tmp.x = a.x + b.x;
 410         tmp.y = a.y + b.y;
 411         tmp.z = a.z + b.z;
 412         tmp.w = a.w + b.w;
 413         return tmp;
 414 }
 415 static uint4 operator-(const uint4& a,const uint4& b)
 416 {
 417         uint4 tmp;
 418         tmp.x = a.x - b.x;
 419         tmp.y = a.y - b.y;
 420         tmp.z = a.z - b.z;
 421         tmp.w = a.w - b.w;
 422         return tmp;
 423 }
 424
 425 #define native_sqrt sqrtf
 426 #define native_sin sinf
 427 #define native_cos cosf
 428 #define native_powr powf
 429
 430 #define GUID_ARG ,int __guid_arg
 431 #define GUID_ARG_VAL ,__guid_arg
 432
 433
 434 #define as_int(a) (*((int*)&(a)))
 435
 436 extern "C" int gMiniCLNumOutstandingTasks;
 437 //      extern "C" void __kernel_func();
 438
 439