ffx_a.h
1 //============================================================================================================================== 2 // 3 // [A] SHADER PORTABILITY 1.20210629 4 // 5 //============================================================================================================================== 6 // FidelityFX Super Resolution Sample 7 // 8 // Copyright (c) 2021 Advanced Micro Devices, Inc. All rights reserved. 9 // Permission is hereby granted, free of charge, to any person obtaining a copy 10 // of this software and associated documentation files(the "Software"), to deal 11 // in the Software without restriction, including without limitation the rights 12 // to use, copy, modify, merge, publish, distribute, sublicense, and / or sell 13 // copies of the Software, and to permit persons to whom the Software is 14 // furnished to do so, subject to the following conditions : 15 // The above copyright notice and this permission notice shall be included in 16 // all copies or substantial portions of the Software. 17 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE 20 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 23 // THE SOFTWARE. 24 //------------------------------------------------------------------------------------------------------------------------------ 25 // MIT LICENSE 26 // =========== 27 // Copyright (c) 2014 Michal Drobot (for concepts used in "FLOAT APPROXIMATIONS"). 28 // ----------- 29 // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation 30 // files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, 31 // modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the 32 // Software is furnished to do so, subject to the following conditions: 33 // ----------- 34 // The above copyright notice and this permission notice shall be included in all copies or substantial portions of the 35 // Software. 36 // ----------- 37 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE 38 // WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 39 // COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 40 // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 41 //------------------------------------------------------------------------------------------------------------------------------ 42 // ABOUT 43 // ===== 44 // Common central point for high-level shading language and C portability for various shader headers. 45 //------------------------------------------------------------------------------------------------------------------------------ 46 // DEFINES 47 // ======= 48 // A_CPU ..... Include the CPU related code. 49 // A_GPU ..... Include the GPU related code. 50 // A_GLSL .... Using GLSL. 51 // A_HLSL .... Using HLSL. 52 // A_HLSL_6_2 Using HLSL 6.2 with new 'uint16_t' and related types (requires '-enable-16bit-types'). 53 // A_NO_16_BIT_CAST Don't use instructions that are not availabe in SPIR-V (needed for running A_HLSL_6_2 on Vulkan) 54 // A_GCC ..... Using a GCC compatible compiler (else assume MSVC compatible compiler by default). 55 // ======= 56 // A_BYTE .... Support 8-bit integer. 57 // A_HALF .... Support 16-bit integer and floating point. 58 // A_LONG .... Support 64-bit integer. 59 // A_DUBL .... Support 64-bit floating point. 60 // ======= 61 // A_WAVE .... Support wave-wide operations. 62 //------------------------------------------------------------------------------------------------------------------------------ 63 // To get #include "ffx_a.h" working in GLSL use '#extension GL_GOOGLE_include_directive:require'. 64 //------------------------------------------------------------------------------------------------------------------------------ 65 // SIMPLIFIED TYPE SYSTEM 66 // ====================== 67 // - All ints will be unsigned with exception of when signed is required. 68 // - Type naming simplified and shortened "A<type><#components>", 69 // - H = 16-bit float (half) 70 // - F = 32-bit float (float) 71 // - D = 64-bit float (double) 72 // - P = 1-bit integer (predicate, not using bool because 'B' is used for byte) 73 // - B = 8-bit integer (byte) 74 // - W = 16-bit integer (word) 75 // - U = 32-bit integer (unsigned) 76 // - L = 64-bit integer (long) 77 // - Using "AS<type><#components>" for signed when required. 78 //------------------------------------------------------------------------------------------------------------------------------ 79 // TODO 80 // ==== 81 // - Make sure 'ALerp*(a,b,m)' does 'b*m+(-a*m+a)' (2 ops). 82 //------------------------------------------------------------------------------------------------------------------------------ 83 // CHANGE LOG 84 // ========== 85 // 20200914 - Expanded wave ops and prx code. 86 // 20200713 - Added [ZOL] section, fixed serious bugs in sRGB and Rec.709 color conversion code, etc. 87 //============================================================================================================================== 88 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 89 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 90 //_____________________________________________________________/\_______________________________________________________________ 91 //============================================================================================================================== 92 // COMMON 93 //============================================================================================================================== 94 #define A_2PI 6.28318530718 95 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 96 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 97 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 98 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 99 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 100 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 101 //_____________________________________________________________/\_______________________________________________________________ 102 //============================================================================================================================== 103 // 104 // 105 // CPU 106 // 107 // 108 //============================================================================================================================== 109 #ifdef A_CPU 110 // Supporting user defined overrides. 111 #ifndef A_RESTRICT 112 #define A_RESTRICT __restrict 113 #endif 114 //------------------------------------------------------------------------------------------------------------------------------ 115 #ifndef A_STATIC 116 #define A_STATIC static 117 #endif 118 //------------------------------------------------------------------------------------------------------------------------------ 119 // Same types across CPU and GPU. 120 // Predicate uses 32-bit integer (C friendly bool). 121 typedef uint32_t AP1; 122 typedef float AF1; 123 typedef double AD1; 124 typedef uint8_t AB1; 125 typedef uint16_t AW1; 126 typedef uint32_t AU1; 127 typedef uint64_t AL1; 128 typedef int8_t ASB1; 129 typedef int16_t ASW1; 130 typedef int32_t ASU1; 131 typedef int64_t ASL1; 132 //------------------------------------------------------------------------------------------------------------------------------ 133 #define AD1_(a) ((AD1)(a)) 134 #define AF1_(a) ((AF1)(a)) 135 #define AL1_(a) ((AL1)(a)) 136 #define AU1_(a) ((AU1)(a)) 137 //------------------------------------------------------------------------------------------------------------------------------ 138 #define ASL1_(a) ((ASL1)(a)) 139 #define ASU1_(a) ((ASU1)(a)) 140 //------------------------------------------------------------------------------------------------------------------------------ 141 A_STATIC AU1 AU1_AF1(AF1 a){union{AF1 f;AU1 u;}bits;bits.f=a;return bits.u;} 142 //------------------------------------------------------------------------------------------------------------------------------ 143 #define A_TRUE 1 144 #define A_FALSE 0 145 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 146 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 147 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 148 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 149 //_____________________________________________________________/\_______________________________________________________________ 150 //============================================================================================================================== 151 // 152 // CPU/GPU PORTING 153 // 154 //------------------------------------------------------------------------------------------------------------------------------ 155 // Get CPU and GPU to share all setup code, without duplicate code paths. 156 // This uses a lower-case prefix for special vector constructs. 157 // - In C restrict pointers are used. 158 // - In the shading language, in/inout/out arguments are used. 159 // This depends on the ability to access a vector value in both languages via array syntax (aka color[2]). 160 //============================================================================================================================== 161 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 162 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 163 //_____________________________________________________________/\_______________________________________________________________ 164 //============================================================================================================================== 165 // VECTOR ARGUMENT/RETURN/INITIALIZATION PORTABILITY 166 //============================================================================================================================== 167 #define retAD2 AD1 *A_RESTRICT 168 #define retAD3 AD1 *A_RESTRICT 169 #define retAD4 AD1 *A_RESTRICT 170 #define retAF2 AF1 *A_RESTRICT 171 #define retAF3 AF1 *A_RESTRICT 172 #define retAF4 AF1 *A_RESTRICT 173 #define retAL2 AL1 *A_RESTRICT 174 #define retAL3 AL1 *A_RESTRICT 175 #define retAL4 AL1 *A_RESTRICT 176 #define retAU2 AU1 *A_RESTRICT 177 #define retAU3 AU1 *A_RESTRICT 178 #define retAU4 AU1 *A_RESTRICT 179 //------------------------------------------------------------------------------------------------------------------------------ 180 #define inAD2 AD1 *A_RESTRICT 181 #define inAD3 AD1 *A_RESTRICT 182 #define inAD4 AD1 *A_RESTRICT 183 #define inAF2 AF1 *A_RESTRICT 184 #define inAF3 AF1 *A_RESTRICT 185 #define inAF4 AF1 *A_RESTRICT 186 #define inAL2 AL1 *A_RESTRICT 187 #define inAL3 AL1 *A_RESTRICT 188 #define inAL4 AL1 *A_RESTRICT 189 #define inAU2 AU1 *A_RESTRICT 190 #define inAU3 AU1 *A_RESTRICT 191 #define inAU4 AU1 *A_RESTRICT 192 //------------------------------------------------------------------------------------------------------------------------------ 193 #define inoutAD2 AD1 *A_RESTRICT 194 #define inoutAD3 AD1 *A_RESTRICT 195 #define inoutAD4 AD1 *A_RESTRICT 196 #define inoutAF2 AF1 *A_RESTRICT 197 #define inoutAF3 AF1 *A_RESTRICT 198 #define inoutAF4 AF1 *A_RESTRICT 199 #define inoutAL2 AL1 *A_RESTRICT 200 #define inoutAL3 AL1 *A_RESTRICT 201 #define inoutAL4 AL1 *A_RESTRICT 202 #define inoutAU2 AU1 *A_RESTRICT 203 #define inoutAU3 AU1 *A_RESTRICT 204 #define inoutAU4 AU1 *A_RESTRICT 205 //------------------------------------------------------------------------------------------------------------------------------ 206 #define outAD2 AD1 *A_RESTRICT 207 #define outAD3 AD1 *A_RESTRICT 208 #define outAD4 AD1 *A_RESTRICT 209 #define outAF2 AF1 *A_RESTRICT 210 #define outAF3 AF1 *A_RESTRICT 211 #define outAF4 AF1 *A_RESTRICT 212 #define outAL2 AL1 *A_RESTRICT 213 #define outAL3 AL1 *A_RESTRICT 214 #define outAL4 AL1 *A_RESTRICT 215 #define outAU2 AU1 *A_RESTRICT 216 #define outAU3 AU1 *A_RESTRICT 217 #define outAU4 AU1 *A_RESTRICT 218 //------------------------------------------------------------------------------------------------------------------------------ 219 #define varAD2(x) AD1 x[2] 220 #define varAD3(x) AD1 x[3] 221 #define varAD4(x) AD1 x[4] 222 #define varAF2(x) AF1 x[2] 223 #define varAF3(x) AF1 x[3] 224 #define varAF4(x) AF1 x[4] 225 #define varAL2(x) AL1 x[2] 226 #define varAL3(x) AL1 x[3] 227 #define varAL4(x) AL1 x[4] 228 #define varAU2(x) AU1 x[2] 229 #define varAU3(x) AU1 x[3] 230 #define varAU4(x) AU1 x[4] 231 //------------------------------------------------------------------------------------------------------------------------------ 232 #define initAD2(x,y) {x,y} 233 #define initAD3(x,y,z) {x,y,z} 234 #define initAD4(x,y,z,w) {x,y,z,w} 235 #define initAF2(x,y) {x,y} 236 #define initAF3(x,y,z) {x,y,z} 237 #define initAF4(x,y,z,w) {x,y,z,w} 238 #define initAL2(x,y) {x,y} 239 #define initAL3(x,y,z) {x,y,z} 240 #define initAL4(x,y,z,w) {x,y,z,w} 241 #define initAU2(x,y) {x,y} 242 #define initAU3(x,y,z) {x,y,z} 243 #define initAU4(x,y,z,w) {x,y,z,w} 244 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 245 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 246 //_____________________________________________________________/\_______________________________________________________________ 247 //============================================================================================================================== 248 // SCALAR RETURN OPS 249 //------------------------------------------------------------------------------------------------------------------------------ 250 // TODO 251 // ==== 252 // - Replace transcendentals with manual versions. 253 //============================================================================================================================== 254 #ifdef A_GCC 255 A_STATIC AD1 AAbsD1(AD1 a){return __builtin_fabs(a);} 256 A_STATIC AF1 AAbsF1(AF1 a){return __builtin_fabsf(a);} 257 A_STATIC AU1 AAbsSU1(AU1 a){return AU1_(__builtin_abs(ASU1_(a)));} 258 A_STATIC AL1 AAbsSL1(AL1 a){return AL1_(__builtin_llabs(ASL1_(a)));} 259 #else 260 A_STATIC AD1 AAbsD1(AD1 a){return fabs(a);} 261 A_STATIC AF1 AAbsF1(AF1 a){return fabsf(a);} 262 A_STATIC AU1 AAbsSU1(AU1 a){return AU1_(abs(ASU1_(a)));} 263 A_STATIC AL1 AAbsSL1(AL1 a){return AL1_(labs((long)ASL1_(a)));} 264 #endif 265 //------------------------------------------------------------------------------------------------------------------------------ 266 #ifdef A_GCC 267 A_STATIC AD1 ACosD1(AD1 a){return __builtin_cos(a);} 268 A_STATIC AF1 ACosF1(AF1 a){return __builtin_cosf(a);} 269 #else 270 A_STATIC AD1 ACosD1(AD1 a){return cos(a);} 271 A_STATIC AF1 ACosF1(AF1 a){return cosf(a);} 272 #endif 273 //------------------------------------------------------------------------------------------------------------------------------ 274 A_STATIC AD1 ADotD2(inAD2 a,inAD2 b){return a[0]*b[0]+a[1]*b[1];} 275 A_STATIC AD1 ADotD3(inAD3 a,inAD3 b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2];} 276 A_STATIC AD1 ADotD4(inAD4 a,inAD4 b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2]+a[3]*b[3];} 277 A_STATIC AF1 ADotF2(inAF2 a,inAF2 b){return a[0]*b[0]+a[1]*b[1];} 278 A_STATIC AF1 ADotF3(inAF3 a,inAF3 b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2];} 279 A_STATIC AF1 ADotF4(inAF4 a,inAF4 b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2]+a[3]*b[3];} 280 //------------------------------------------------------------------------------------------------------------------------------ 281 #ifdef A_GCC 282 A_STATIC AD1 AExp2D1(AD1 a){return __builtin_exp2(a);} 283 A_STATIC AF1 AExp2F1(AF1 a){return __builtin_exp2f(a);} 284 #else 285 A_STATIC AD1 AExp2D1(AD1 a){return exp2(a);} 286 A_STATIC AF1 AExp2F1(AF1 a){return exp2f(a);} 287 #endif 288 //------------------------------------------------------------------------------------------------------------------------------ 289 #ifdef A_GCC 290 A_STATIC AD1 AFloorD1(AD1 a){return __builtin_floor(a);} 291 A_STATIC AF1 AFloorF1(AF1 a){return __builtin_floorf(a);} 292 #else 293 A_STATIC AD1 AFloorD1(AD1 a){return floor(a);} 294 A_STATIC AF1 AFloorF1(AF1 a){return floorf(a);} 295 #endif 296 //------------------------------------------------------------------------------------------------------------------------------ 297 A_STATIC AD1 ALerpD1(AD1 a,AD1 b,AD1 c){return b*c+(-a*c+a);} 298 A_STATIC AF1 ALerpF1(AF1 a,AF1 b,AF1 c){return b*c+(-a*c+a);} 299 //------------------------------------------------------------------------------------------------------------------------------ 300 #ifdef A_GCC 301 A_STATIC AD1 ALog2D1(AD1 a){return __builtin_log2(a);} 302 A_STATIC AF1 ALog2F1(AF1 a){return __builtin_log2f(a);} 303 #else 304 A_STATIC AD1 ALog2D1(AD1 a){return log2(a);} 305 A_STATIC AF1 ALog2F1(AF1 a){return log2f(a);} 306 #endif 307 //------------------------------------------------------------------------------------------------------------------------------ 308 A_STATIC AD1 AMaxD1(AD1 a,AD1 b){return a>b?a:b;} 309 A_STATIC AF1 AMaxF1(AF1 a,AF1 b){return a>b?a:b;} 310 A_STATIC AL1 AMaxL1(AL1 a,AL1 b){return a>b?a:b;} 311 A_STATIC AU1 AMaxU1(AU1 a,AU1 b){return a>b?a:b;} 312 //------------------------------------------------------------------------------------------------------------------------------ 313 // These follow the convention that A integer types don't have signage, until they are operated on. 314 A_STATIC AL1 AMaxSL1(AL1 a,AL1 b){return (ASL1_(a)>ASL1_(b))?a:b;} 315 A_STATIC AU1 AMaxSU1(AU1 a,AU1 b){return (ASU1_(a)>ASU1_(b))?a:b;} 316 //------------------------------------------------------------------------------------------------------------------------------ 317 A_STATIC AD1 AMinD1(AD1 a,AD1 b){return a<b?a:b;} 318 A_STATIC AF1 AMinF1(AF1 a,AF1 b){return a<b?a:b;} 319 A_STATIC AL1 AMinL1(AL1 a,AL1 b){return a<b?a:b;} 320 A_STATIC AU1 AMinU1(AU1 a,AU1 b){return a<b?a:b;} 321 //------------------------------------------------------------------------------------------------------------------------------ 322 A_STATIC AL1 AMinSL1(AL1 a,AL1 b){return (ASL1_(a)<ASL1_(b))?a:b;} 323 A_STATIC AU1 AMinSU1(AU1 a,AU1 b){return (ASU1_(a)<ASU1_(b))?a:b;} 324 //------------------------------------------------------------------------------------------------------------------------------ 325 A_STATIC AD1 ARcpD1(AD1 a){return 1.0/a;} 326 A_STATIC AF1 ARcpF1(AF1 a){return 1.0f/a;} 327 //------------------------------------------------------------------------------------------------------------------------------ 328 A_STATIC AL1 AShrSL1(AL1 a,AL1 b){return AL1_(ASL1_(a)>>ASL1_(b));} 329 A_STATIC AU1 AShrSU1(AU1 a,AU1 b){return AU1_(ASU1_(a)>>ASU1_(b));} 330 //------------------------------------------------------------------------------------------------------------------------------ 331 #ifdef A_GCC 332 A_STATIC AD1 ASinD1(AD1 a){return __builtin_sin(a);} 333 A_STATIC AF1 ASinF1(AF1 a){return __builtin_sinf(a);} 334 #else 335 A_STATIC AD1 ASinD1(AD1 a){return sin(a);} 336 A_STATIC AF1 ASinF1(AF1 a){return sinf(a);} 337 #endif 338 //------------------------------------------------------------------------------------------------------------------------------ 339 #ifdef A_GCC 340 A_STATIC AD1 ASqrtD1(AD1 a){return __builtin_sqrt(a);} 341 A_STATIC AF1 ASqrtF1(AF1 a){return __builtin_sqrtf(a);} 342 #else 343 A_STATIC AD1 ASqrtD1(AD1 a){return sqrt(a);} 344 A_STATIC AF1 ASqrtF1(AF1 a){return sqrtf(a);} 345 #endif 346 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 347 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 348 //_____________________________________________________________/\_______________________________________________________________ 349 //============================================================================================================================== 350 // SCALAR RETURN OPS - DEPENDENT 351 //============================================================================================================================== 352 A_STATIC AD1 AClampD1(AD1 x,AD1 n,AD1 m){return AMaxD1(n,AMinD1(x,m));} 353 A_STATIC AF1 AClampF1(AF1 x,AF1 n,AF1 m){return AMaxF1(n,AMinF1(x,m));} 354 //------------------------------------------------------------------------------------------------------------------------------ 355 A_STATIC AD1 AFractD1(AD1 a){return a-AFloorD1(a);} 356 A_STATIC AF1 AFractF1(AF1 a){return a-AFloorF1(a);} 357 //------------------------------------------------------------------------------------------------------------------------------ 358 A_STATIC AD1 APowD1(AD1 a,AD1 b){return AExp2D1(b*ALog2D1(a));} 359 A_STATIC AF1 APowF1(AF1 a,AF1 b){return AExp2F1(b*ALog2F1(a));} 360 //------------------------------------------------------------------------------------------------------------------------------ 361 A_STATIC AD1 ARsqD1(AD1 a){return ARcpD1(ASqrtD1(a));} 362 A_STATIC AF1 ARsqF1(AF1 a){return ARcpF1(ASqrtF1(a));} 363 //------------------------------------------------------------------------------------------------------------------------------ 364 A_STATIC AD1 ASatD1(AD1 a){return AMinD1(1.0,AMaxD1(0.0,a));} 365 A_STATIC AF1 ASatF1(AF1 a){return AMinF1(1.0f,AMaxF1(0.0f,a));} 366 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 367 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 368 //_____________________________________________________________/\_______________________________________________________________ 369 //============================================================================================================================== 370 // VECTOR OPS 371 //------------------------------------------------------------------------------------------------------------------------------ 372 // These are added as needed for production or prototyping, so not necessarily a complete set. 373 // They follow a convention of taking in a destination and also returning the destination value to increase utility. 374 //============================================================================================================================== 375 A_STATIC retAD2 opAAbsD2(outAD2 d,inAD2 a){d[0]=AAbsD1(a[0]);d[1]=AAbsD1(a[1]);return d;} 376 A_STATIC retAD3 opAAbsD3(outAD3 d,inAD3 a){d[0]=AAbsD1(a[0]);d[1]=AAbsD1(a[1]);d[2]=AAbsD1(a[2]);return d;} 377 A_STATIC retAD4 opAAbsD4(outAD4 d,inAD4 a){d[0]=AAbsD1(a[0]);d[1]=AAbsD1(a[1]);d[2]=AAbsD1(a[2]);d[3]=AAbsD1(a[3]);return d;} 378 //------------------------------------------------------------------------------------------------------------------------------ 379 A_STATIC retAF2 opAAbsF2(outAF2 d,inAF2 a){d[0]=AAbsF1(a[0]);d[1]=AAbsF1(a[1]);return d;} 380 A_STATIC retAF3 opAAbsF3(outAF3 d,inAF3 a){d[0]=AAbsF1(a[0]);d[1]=AAbsF1(a[1]);d[2]=AAbsF1(a[2]);return d;} 381 A_STATIC retAF4 opAAbsF4(outAF4 d,inAF4 a){d[0]=AAbsF1(a[0]);d[1]=AAbsF1(a[1]);d[2]=AAbsF1(a[2]);d[3]=AAbsF1(a[3]);return d;} 382 //============================================================================================================================== 383 A_STATIC retAD2 opAAddD2(outAD2 d,inAD2 a,inAD2 b){d[0]=a[0]+b[0];d[1]=a[1]+b[1];return d;} 384 A_STATIC retAD3 opAAddD3(outAD3 d,inAD3 a,inAD3 b){d[0]=a[0]+b[0];d[1]=a[1]+b[1];d[2]=a[2]+b[2];return d;} 385 A_STATIC retAD4 opAAddD4(outAD4 d,inAD4 a,inAD4 b){d[0]=a[0]+b[0];d[1]=a[1]+b[1];d[2]=a[2]+b[2];d[3]=a[3]+b[3];return d;} 386 //------------------------------------------------------------------------------------------------------------------------------ 387 A_STATIC retAF2 opAAddF2(outAF2 d,inAF2 a,inAF2 b){d[0]=a[0]+b[0];d[1]=a[1]+b[1];return d;} 388 A_STATIC retAF3 opAAddF3(outAF3 d,inAF3 a,inAF3 b){d[0]=a[0]+b[0];d[1]=a[1]+b[1];d[2]=a[2]+b[2];return d;} 389 A_STATIC retAF4 opAAddF4(outAF4 d,inAF4 a,inAF4 b){d[0]=a[0]+b[0];d[1]=a[1]+b[1];d[2]=a[2]+b[2];d[3]=a[3]+b[3];return d;} 390 //============================================================================================================================== 391 A_STATIC retAD2 opAAddOneD2(outAD2 d,inAD2 a,AD1 b){d[0]=a[0]+b;d[1]=a[1]+b;return d;} 392 A_STATIC retAD3 opAAddOneD3(outAD3 d,inAD3 a,AD1 b){d[0]=a[0]+b;d[1]=a[1]+b;d[2]=a[2]+b;return d;} 393 A_STATIC retAD4 opAAddOneD4(outAD4 d,inAD4 a,AD1 b){d[0]=a[0]+b;d[1]=a[1]+b;d[2]=a[2]+b;d[3]=a[3]+b;return d;} 394 //------------------------------------------------------------------------------------------------------------------------------ 395 A_STATIC retAF2 opAAddOneF2(outAF2 d,inAF2 a,AF1 b){d[0]=a[0]+b;d[1]=a[1]+b;return d;} 396 A_STATIC retAF3 opAAddOneF3(outAF3 d,inAF3 a,AF1 b){d[0]=a[0]+b;d[1]=a[1]+b;d[2]=a[2]+b;return d;} 397 A_STATIC retAF4 opAAddOneF4(outAF4 d,inAF4 a,AF1 b){d[0]=a[0]+b;d[1]=a[1]+b;d[2]=a[2]+b;d[3]=a[3]+b;return d;} 398 //============================================================================================================================== 399 A_STATIC retAD2 opACpyD2(outAD2 d,inAD2 a){d[0]=a[0];d[1]=a[1];return d;} 400 A_STATIC retAD3 opACpyD3(outAD3 d,inAD3 a){d[0]=a[0];d[1]=a[1];d[2]=a[2];return d;} 401 A_STATIC retAD4 opACpyD4(outAD4 d,inAD4 a){d[0]=a[0];d[1]=a[1];d[2]=a[2];d[3]=a[3];return d;} 402 //------------------------------------------------------------------------------------------------------------------------------ 403 A_STATIC retAF2 opACpyF2(outAF2 d,inAF2 a){d[0]=a[0];d[1]=a[1];return d;} 404 A_STATIC retAF3 opACpyF3(outAF3 d,inAF3 a){d[0]=a[0];d[1]=a[1];d[2]=a[2];return d;} 405 A_STATIC retAF4 opACpyF4(outAF4 d,inAF4 a){d[0]=a[0];d[1]=a[1];d[2]=a[2];d[3]=a[3];return d;} 406 //============================================================================================================================== 407 A_STATIC retAD2 opALerpD2(outAD2 d,inAD2 a,inAD2 b,inAD2 c){d[0]=ALerpD1(a[0],b[0],c[0]);d[1]=ALerpD1(a[1],b[1],c[1]);return d;} 408 A_STATIC retAD3 opALerpD3(outAD3 d,inAD3 a,inAD3 b,inAD3 c){d[0]=ALerpD1(a[0],b[0],c[0]);d[1]=ALerpD1(a[1],b[1],c[1]);d[2]=ALerpD1(a[2],b[2],c[2]);return d;} 409 A_STATIC retAD4 opALerpD4(outAD4 d,inAD4 a,inAD4 b,inAD4 c){d[0]=ALerpD1(a[0],b[0],c[0]);d[1]=ALerpD1(a[1],b[1],c[1]);d[2]=ALerpD1(a[2],b[2],c[2]);d[3]=ALerpD1(a[3],b[3],c[3]);return d;} 410 //------------------------------------------------------------------------------------------------------------------------------ 411 A_STATIC retAF2 opALerpF2(outAF2 d,inAF2 a,inAF2 b,inAF2 c){d[0]=ALerpF1(a[0],b[0],c[0]);d[1]=ALerpF1(a[1],b[1],c[1]);return d;} 412 A_STATIC retAF3 opALerpF3(outAF3 d,inAF3 a,inAF3 b,inAF3 c){d[0]=ALerpF1(a[0],b[0],c[0]);d[1]=ALerpF1(a[1],b[1],c[1]);d[2]=ALerpF1(a[2],b[2],c[2]);return d;} 413 A_STATIC retAF4 opALerpF4(outAF4 d,inAF4 a,inAF4 b,inAF4 c){d[0]=ALerpF1(a[0],b[0],c[0]);d[1]=ALerpF1(a[1],b[1],c[1]);d[2]=ALerpF1(a[2],b[2],c[2]);d[3]=ALerpF1(a[3],b[3],c[3]);return d;} 414 //============================================================================================================================== 415 A_STATIC retAD2 opALerpOneD2(outAD2 d,inAD2 a,inAD2 b,AD1 c){d[0]=ALerpD1(a[0],b[0],c);d[1]=ALerpD1(a[1],b[1],c);return d;} 416 A_STATIC retAD3 opALerpOneD3(outAD3 d,inAD3 a,inAD3 b,AD1 c){d[0]=ALerpD1(a[0],b[0],c);d[1]=ALerpD1(a[1],b[1],c);d[2]=ALerpD1(a[2],b[2],c);return d;} 417 A_STATIC retAD4 opALerpOneD4(outAD4 d,inAD4 a,inAD4 b,AD1 c){d[0]=ALerpD1(a[0],b[0],c);d[1]=ALerpD1(a[1],b[1],c);d[2]=ALerpD1(a[2],b[2],c);d[3]=ALerpD1(a[3],b[3],c);return d;} 418 //------------------------------------------------------------------------------------------------------------------------------ 419 A_STATIC retAF2 opALerpOneF2(outAF2 d,inAF2 a,inAF2 b,AF1 c){d[0]=ALerpF1(a[0],b[0],c);d[1]=ALerpF1(a[1],b[1],c);return d;} 420 A_STATIC retAF3 opALerpOneF3(outAF3 d,inAF3 a,inAF3 b,AF1 c){d[0]=ALerpF1(a[0],b[0],c);d[1]=ALerpF1(a[1],b[1],c);d[2]=ALerpF1(a[2],b[2],c);return d;} 421 A_STATIC retAF4 opALerpOneF4(outAF4 d,inAF4 a,inAF4 b,AF1 c){d[0]=ALerpF1(a[0],b[0],c);d[1]=ALerpF1(a[1],b[1],c);d[2]=ALerpF1(a[2],b[2],c);d[3]=ALerpF1(a[3],b[3],c);return d;} 422 //============================================================================================================================== 423 A_STATIC retAD2 opAMaxD2(outAD2 d,inAD2 a,inAD2 b){d[0]=AMaxD1(a[0],b[0]);d[1]=AMaxD1(a[1],b[1]);return d;} 424 A_STATIC retAD3 opAMaxD3(outAD3 d,inAD3 a,inAD3 b){d[0]=AMaxD1(a[0],b[0]);d[1]=AMaxD1(a[1],b[1]);d[2]=AMaxD1(a[2],b[2]);return d;} 425 A_STATIC retAD4 opAMaxD4(outAD4 d,inAD4 a,inAD4 b){d[0]=AMaxD1(a[0],b[0]);d[1]=AMaxD1(a[1],b[1]);d[2]=AMaxD1(a[2],b[2]);d[3]=AMaxD1(a[3],b[3]);return d;} 426 //------------------------------------------------------------------------------------------------------------------------------ 427 A_STATIC retAF2 opAMaxF2(outAF2 d,inAF2 a,inAF2 b){d[0]=AMaxF1(a[0],b[0]);d[1]=AMaxF1(a[1],b[1]);return d;} 428 A_STATIC retAF3 opAMaxF3(outAF3 d,inAF3 a,inAF3 b){d[0]=AMaxF1(a[0],b[0]);d[1]=AMaxF1(a[1],b[1]);d[2]=AMaxF1(a[2],b[2]);return d;} 429 A_STATIC retAF4 opAMaxF4(outAF4 d,inAF4 a,inAF4 b){d[0]=AMaxF1(a[0],b[0]);d[1]=AMaxF1(a[1],b[1]);d[2]=AMaxF1(a[2],b[2]);d[3]=AMaxF1(a[3],b[3]);return d;} 430 //============================================================================================================================== 431 A_STATIC retAD2 opAMinD2(outAD2 d,inAD2 a,inAD2 b){d[0]=AMinD1(a[0],b[0]);d[1]=AMinD1(a[1],b[1]);return d;} 432 A_STATIC retAD3 opAMinD3(outAD3 d,inAD3 a,inAD3 b){d[0]=AMinD1(a[0],b[0]);d[1]=AMinD1(a[1],b[1]);d[2]=AMinD1(a[2],b[2]);return d;} 433 A_STATIC retAD4 opAMinD4(outAD4 d,inAD4 a,inAD4 b){d[0]=AMinD1(a[0],b[0]);d[1]=AMinD1(a[1],b[1]);d[2]=AMinD1(a[2],b[2]);d[3]=AMinD1(a[3],b[3]);return d;} 434 //------------------------------------------------------------------------------------------------------------------------------ 435 A_STATIC retAF2 opAMinF2(outAF2 d,inAF2 a,inAF2 b){d[0]=AMinF1(a[0],b[0]);d[1]=AMinF1(a[1],b[1]);return d;} 436 A_STATIC retAF3 opAMinF3(outAF3 d,inAF3 a,inAF3 b){d[0]=AMinF1(a[0],b[0]);d[1]=AMinF1(a[1],b[1]);d[2]=AMinF1(a[2],b[2]);return d;} 437 A_STATIC retAF4 opAMinF4(outAF4 d,inAF4 a,inAF4 b){d[0]=AMinF1(a[0],b[0]);d[1]=AMinF1(a[1],b[1]);d[2]=AMinF1(a[2],b[2]);d[3]=AMinF1(a[3],b[3]);return d;} 438 //============================================================================================================================== 439 A_STATIC retAD2 opAMulD2(outAD2 d,inAD2 a,inAD2 b){d[0]=a[0]*b[0];d[1]=a[1]*b[1];return d;} 440 A_STATIC retAD3 opAMulD3(outAD3 d,inAD3 a,inAD3 b){d[0]=a[0]*b[0];d[1]=a[1]*b[1];d[2]=a[2]*b[2];return d;} 441 A_STATIC retAD4 opAMulD4(outAD4 d,inAD4 a,inAD4 b){d[0]=a[0]*b[0];d[1]=a[1]*b[1];d[2]=a[2]*b[2];d[3]=a[3]*b[3];return d;} 442 //------------------------------------------------------------------------------------------------------------------------------ 443 A_STATIC retAF2 opAMulF2(outAF2 d,inAF2 a,inAF2 b){d[0]=a[0]*b[0];d[1]=a[1]*b[1];return d;} 444 A_STATIC retAF3 opAMulF3(outAF3 d,inAF3 a,inAF3 b){d[0]=a[0]*b[0];d[1]=a[1]*b[1];d[2]=a[2]*b[2];return d;} 445 A_STATIC retAF4 opAMulF4(outAF4 d,inAF4 a,inAF4 b){d[0]=a[0]*b[0];d[1]=a[1]*b[1];d[2]=a[2]*b[2];d[3]=a[3]*b[3];return d;} 446 //============================================================================================================================== 447 A_STATIC retAD2 opAMulOneD2(outAD2 d,inAD2 a,AD1 b){d[0]=a[0]*b;d[1]=a[1]*b;return d;} 448 A_STATIC retAD3 opAMulOneD3(outAD3 d,inAD3 a,AD1 b){d[0]=a[0]*b;d[1]=a[1]*b;d[2]=a[2]*b;return d;} 449 A_STATIC retAD4 opAMulOneD4(outAD4 d,inAD4 a,AD1 b){d[0]=a[0]*b;d[1]=a[1]*b;d[2]=a[2]*b;d[3]=a[3]*b;return d;} 450 //------------------------------------------------------------------------------------------------------------------------------ 451 A_STATIC retAF2 opAMulOneF2(outAF2 d,inAF2 a,AF1 b){d[0]=a[0]*b;d[1]=a[1]*b;return d;} 452 A_STATIC retAF3 opAMulOneF3(outAF3 d,inAF3 a,AF1 b){d[0]=a[0]*b;d[1]=a[1]*b;d[2]=a[2]*b;return d;} 453 A_STATIC retAF4 opAMulOneF4(outAF4 d,inAF4 a,AF1 b){d[0]=a[0]*b;d[1]=a[1]*b;d[2]=a[2]*b;d[3]=a[3]*b;return d;} 454 //============================================================================================================================== 455 A_STATIC retAD2 opANegD2(outAD2 d,inAD2 a){d[0]=-a[0];d[1]=-a[1];return d;} 456 A_STATIC retAD3 opANegD3(outAD3 d,inAD3 a){d[0]=-a[0];d[1]=-a[1];d[2]=-a[2];return d;} 457 A_STATIC retAD4 opANegD4(outAD4 d,inAD4 a){d[0]=-a[0];d[1]=-a[1];d[2]=-a[2];d[3]=-a[3];return d;} 458 //------------------------------------------------------------------------------------------------------------------------------ 459 A_STATIC retAF2 opANegF2(outAF2 d,inAF2 a){d[0]=-a[0];d[1]=-a[1];return d;} 460 A_STATIC retAF3 opANegF3(outAF3 d,inAF3 a){d[0]=-a[0];d[1]=-a[1];d[2]=-a[2];return d;} 461 A_STATIC retAF4 opANegF4(outAF4 d,inAF4 a){d[0]=-a[0];d[1]=-a[1];d[2]=-a[2];d[3]=-a[3];return d;} 462 //============================================================================================================================== 463 A_STATIC retAD2 opARcpD2(outAD2 d,inAD2 a){d[0]=ARcpD1(a[0]);d[1]=ARcpD1(a[1]);return d;} 464 A_STATIC retAD3 opARcpD3(outAD3 d,inAD3 a){d[0]=ARcpD1(a[0]);d[1]=ARcpD1(a[1]);d[2]=ARcpD1(a[2]);return d;} 465 A_STATIC retAD4 opARcpD4(outAD4 d,inAD4 a){d[0]=ARcpD1(a[0]);d[1]=ARcpD1(a[1]);d[2]=ARcpD1(a[2]);d[3]=ARcpD1(a[3]);return d;} 466 //------------------------------------------------------------------------------------------------------------------------------ 467 A_STATIC retAF2 opARcpF2(outAF2 d,inAF2 a){d[0]=ARcpF1(a[0]);d[1]=ARcpF1(a[1]);return d;} 468 A_STATIC retAF3 opARcpF3(outAF3 d,inAF3 a){d[0]=ARcpF1(a[0]);d[1]=ARcpF1(a[1]);d[2]=ARcpF1(a[2]);return d;} 469 A_STATIC retAF4 opARcpF4(outAF4 d,inAF4 a){d[0]=ARcpF1(a[0]);d[1]=ARcpF1(a[1]);d[2]=ARcpF1(a[2]);d[3]=ARcpF1(a[3]);return d;} 470 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 471 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 472 //_____________________________________________________________/\_______________________________________________________________ 473 //============================================================================================================================== 474 // HALF FLOAT PACKING 475 //============================================================================================================================== 476 // Convert float to half (in lower 16-bits of output). 477 // Same fast technique as documented here: ftp://ftp.fox-toolkit.org/pub/fasthalffloatconversion.pdf 478 // Supports denormals. 479 // Conversion rules are to make computations possibly "safer" on the GPU, 480 // -INF & -NaN -> -65504 481 // +INF & +NaN -> +65504 482 A_STATIC AU1 AU1_AH1_AF1(AF1 f){ 483 static AW1 base[512]={ 484 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, 485 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, 486 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, 487 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, 488 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, 489 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, 490 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0002,0x0004,0x0008,0x0010,0x0020,0x0040,0x0080,0x0100, 491 0x0200,0x0400,0x0800,0x0c00,0x1000,0x1400,0x1800,0x1c00,0x2000,0x2400,0x2800,0x2c00,0x3000,0x3400,0x3800,0x3c00, 492 0x4000,0x4400,0x4800,0x4c00,0x5000,0x5400,0x5800,0x5c00,0x6000,0x6400,0x6800,0x6c00,0x7000,0x7400,0x7800,0x7bff, 493 0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff, 494 0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff, 495 0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff, 496 0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff, 497 0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff, 498 0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff, 499 0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff, 500 0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000, 501 0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000, 502 0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000, 503 0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000, 504 0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000, 505 0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000, 506 0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8001,0x8002,0x8004,0x8008,0x8010,0x8020,0x8040,0x8080,0x8100, 507 0x8200,0x8400,0x8800,0x8c00,0x9000,0x9400,0x9800,0x9c00,0xa000,0xa400,0xa800,0xac00,0xb000,0xb400,0xb800,0xbc00, 508 0xc000,0xc400,0xc800,0xcc00,0xd000,0xd400,0xd800,0xdc00,0xe000,0xe400,0xe800,0xec00,0xf000,0xf400,0xf800,0xfbff, 509 0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff, 510 0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff, 511 0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff, 512 0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff, 513 0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff, 514 0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff, 515 0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff}; 516 static AB1 shift[512]={ 517 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 518 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 519 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 520 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 521 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 522 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 523 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x17,0x16,0x15,0x14,0x13,0x12,0x11,0x10,0x0f, 524 0x0e,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d, 525 0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x18, 526 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 527 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 528 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 529 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 530 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 531 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 532 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 533 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 534 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 535 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 536 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 537 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 538 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 539 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x17,0x16,0x15,0x14,0x13,0x12,0x11,0x10,0x0f, 540 0x0e,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d, 541 0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x18, 542 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 543 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 544 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 545 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 546 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 547 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, 548 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18}; 549 union{AF1 f;AU1 u;}bits;bits.f=f;AU1 u=bits.u;AU1 i=u>>23;return (AU1)(base[i])+((u&0x7fffff)>>shift[i]);} 550 //------------------------------------------------------------------------------------------------------------------------------ 551 // Used to output packed constant. 552 A_STATIC AU1 AU1_AH2_AF2(inAF2 a){return AU1_AH1_AF1(a[0])+(AU1_AH1_AF1(a[1])<<16);} 553 #endif 554 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 555 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 556 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 557 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 558 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 559 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 560 //_____________________________________________________________/\_______________________________________________________________ 561 //============================================================================================================================== 562 // 563 // 564 // GLSL 565 // 566 // 567 //============================================================================================================================== 568 #if defined(A_GLSL) && defined(A_GPU) 569 #ifndef A_SKIP_EXT 570 #ifdef A_HALF 571 #extension GL_EXT_shader_16bit_storage:require 572 #extension GL_EXT_shader_explicit_arithmetic_types:require 573 #endif 574 //------------------------------------------------------------------------------------------------------------------------------ 575 #ifdef A_LONG 576 #extension GL_ARB_gpu_shader_int64:require 577 #extension GL_NV_shader_atomic_int64:require 578 #endif 579 //------------------------------------------------------------------------------------------------------------------------------ 580 #ifdef A_WAVE 581 #extension GL_KHR_shader_subgroup_arithmetic:require 582 #extension GL_KHR_shader_subgroup_ballot:require 583 #extension GL_KHR_shader_subgroup_quad:require 584 #extension GL_KHR_shader_subgroup_shuffle:require 585 #endif 586 #endif 587 //============================================================================================================================== 588 #define AP1 bool 589 #define AP2 bvec2 590 #define AP3 bvec3 591 #define AP4 bvec4 592 //------------------------------------------------------------------------------------------------------------------------------ 593 #define AF1 float 594 #define AF2 vec2 595 #define AF3 vec3 596 #define AF4 vec4 597 //------------------------------------------------------------------------------------------------------------------------------ 598 #define AU1 uint 599 #define AU2 uvec2 600 #define AU3 uvec3 601 #define AU4 uvec4 602 //------------------------------------------------------------------------------------------------------------------------------ 603 #define ASU1 int 604 #define ASU2 ivec2 605 #define ASU3 ivec3 606 #define ASU4 ivec4 607 //============================================================================================================================== 608 #define AF1_AU1(x) uintBitsToFloat(AU1(x)) 609 #define AF2_AU2(x) uintBitsToFloat(AU2(x)) 610 #define AF3_AU3(x) uintBitsToFloat(AU3(x)) 611 #define AF4_AU4(x) uintBitsToFloat(AU4(x)) 612 //------------------------------------------------------------------------------------------------------------------------------ 613 #define AU1_AF1(x) floatBitsToUint(AF1(x)) 614 #define AU2_AF2(x) floatBitsToUint(AF2(x)) 615 #define AU3_AF3(x) floatBitsToUint(AF3(x)) 616 #define AU4_AF4(x) floatBitsToUint(AF4(x)) 617 //------------------------------------------------------------------------------------------------------------------------------ 618 AU1 AU1_AH1_AF1_x(AF1 a){return packHalf2x16(AF2(a,0.0));} 619 #define AU1_AH1_AF1(a) AU1_AH1_AF1_x(AF1(a)) 620 //------------------------------------------------------------------------------------------------------------------------------ 621 #define AU1_AH2_AF2 packHalf2x16 622 #define AU1_AW2Unorm_AF2 packUnorm2x16 623 #define AU1_AB4Unorm_AF4 packUnorm4x8 624 //------------------------------------------------------------------------------------------------------------------------------ 625 #define AF2_AH2_AU1 unpackHalf2x16 626 #define AF2_AW2Unorm_AU1 unpackUnorm2x16 627 #define AF4_AB4Unorm_AU1 unpackUnorm4x8 628 //============================================================================================================================== 629 AF1 AF1_x(AF1 a){return AF1(a);} 630 AF2 AF2_x(AF1 a){return AF2(a,a);} 631 AF3 AF3_x(AF1 a){return AF3(a,a,a);} 632 AF4 AF4_x(AF1 a){return AF4(a,a,a,a);} 633 #define AF1_(a) AF1_x(AF1(a)) 634 #define AF2_(a) AF2_x(AF1(a)) 635 #define AF3_(a) AF3_x(AF1(a)) 636 #define AF4_(a) AF4_x(AF1(a)) 637 //------------------------------------------------------------------------------------------------------------------------------ 638 AU1 AU1_x(AU1 a){return AU1(a);} 639 AU2 AU2_x(AU1 a){return AU2(a,a);} 640 AU3 AU3_x(AU1 a){return AU3(a,a,a);} 641 AU4 AU4_x(AU1 a){return AU4(a,a,a,a);} 642 #define AU1_(a) AU1_x(AU1(a)) 643 #define AU2_(a) AU2_x(AU1(a)) 644 #define AU3_(a) AU3_x(AU1(a)) 645 #define AU4_(a) AU4_x(AU1(a)) 646 //============================================================================================================================== 647 AU1 AAbsSU1(AU1 a){return AU1(abs(ASU1(a)));} 648 AU2 AAbsSU2(AU2 a){return AU2(abs(ASU2(a)));} 649 AU3 AAbsSU3(AU3 a){return AU3(abs(ASU3(a)));} 650 AU4 AAbsSU4(AU4 a){return AU4(abs(ASU4(a)));} 651 //------------------------------------------------------------------------------------------------------------------------------ 652 AU1 ABfe(AU1 src,AU1 off,AU1 bits){return bitfieldExtract(src,ASU1(off),ASU1(bits));} 653 AU1 ABfi(AU1 src,AU1 ins,AU1 mask){return (ins&mask)|(src&(~mask));} 654 // Proxy for V_BFI_B32 where the 'mask' is set as 'bits', 'mask=(1<<bits)-1', and 'bits' needs to be an immediate. 655 AU1 ABfiM(AU1 src,AU1 ins,AU1 bits){return bitfieldInsert(src,ins,0,ASU1(bits));} 656 //------------------------------------------------------------------------------------------------------------------------------ 657 // V_MED3_F32. 658 AF1 AClampF1(AF1 x,AF1 n,AF1 m){return clamp(x,n,m);} 659 AF2 AClampF2(AF2 x,AF2 n,AF2 m){return clamp(x,n,m);} 660 AF3 AClampF3(AF3 x,AF3 n,AF3 m){return clamp(x,n,m);} 661 AF4 AClampF4(AF4 x,AF4 n,AF4 m){return clamp(x,n,m);} 662 //------------------------------------------------------------------------------------------------------------------------------ 663 // V_FRACT_F32 (note DX frac() is different). 664 AF1 AFractF1(AF1 x){return fract(x);} 665 AF2 AFractF2(AF2 x){return fract(x);} 666 AF3 AFractF3(AF3 x){return fract(x);} 667 AF4 AFractF4(AF4 x){return fract(x);} 668 //------------------------------------------------------------------------------------------------------------------------------ 669 AF1 ALerpF1(AF1 x,AF1 y,AF1 a){return mix(x,y,a);} 670 AF2 ALerpF2(AF2 x,AF2 y,AF2 a){return mix(x,y,a);} 671 AF3 ALerpF3(AF3 x,AF3 y,AF3 a){return mix(x,y,a);} 672 AF4 ALerpF4(AF4 x,AF4 y,AF4 a){return mix(x,y,a);} 673 //------------------------------------------------------------------------------------------------------------------------------ 674 // V_MAX3_F32. 675 AF1 AMax3F1(AF1 x,AF1 y,AF1 z){return max(x,max(y,z));} 676 AF2 AMax3F2(AF2 x,AF2 y,AF2 z){return max(x,max(y,z));} 677 AF3 AMax3F3(AF3 x,AF3 y,AF3 z){return max(x,max(y,z));} 678 AF4 AMax3F4(AF4 x,AF4 y,AF4 z){return max(x,max(y,z));} 679 //------------------------------------------------------------------------------------------------------------------------------ 680 AU1 AMax3SU1(AU1 x,AU1 y,AU1 z){return AU1(max(ASU1(x),max(ASU1(y),ASU1(z))));} 681 AU2 AMax3SU2(AU2 x,AU2 y,AU2 z){return AU2(max(ASU2(x),max(ASU2(y),ASU2(z))));} 682 AU3 AMax3SU3(AU3 x,AU3 y,AU3 z){return AU3(max(ASU3(x),max(ASU3(y),ASU3(z))));} 683 AU4 AMax3SU4(AU4 x,AU4 y,AU4 z){return AU4(max(ASU4(x),max(ASU4(y),ASU4(z))));} 684 //------------------------------------------------------------------------------------------------------------------------------ 685 AU1 AMax3U1(AU1 x,AU1 y,AU1 z){return max(x,max(y,z));} 686 AU2 AMax3U2(AU2 x,AU2 y,AU2 z){return max(x,max(y,z));} 687 AU3 AMax3U3(AU3 x,AU3 y,AU3 z){return max(x,max(y,z));} 688 AU4 AMax3U4(AU4 x,AU4 y,AU4 z){return max(x,max(y,z));} 689 //------------------------------------------------------------------------------------------------------------------------------ 690 AU1 AMaxSU1(AU1 a,AU1 b){return AU1(max(ASU1(a),ASU1(b)));} 691 AU2 AMaxSU2(AU2 a,AU2 b){return AU2(max(ASU2(a),ASU2(b)));} 692 AU3 AMaxSU3(AU3 a,AU3 b){return AU3(max(ASU3(a),ASU3(b)));} 693 AU4 AMaxSU4(AU4 a,AU4 b){return AU4(max(ASU4(a),ASU4(b)));} 694 //------------------------------------------------------------------------------------------------------------------------------ 695 // Clamp has an easier pattern match for med3 when some ordering is known. 696 // V_MED3_F32. 697 AF1 AMed3F1(AF1 x,AF1 y,AF1 z){return max(min(x,y),min(max(x,y),z));} 698 AF2 AMed3F2(AF2 x,AF2 y,AF2 z){return max(min(x,y),min(max(x,y),z));} 699 AF3 AMed3F3(AF3 x,AF3 y,AF3 z){return max(min(x,y),min(max(x,y),z));} 700 AF4 AMed3F4(AF4 x,AF4 y,AF4 z){return max(min(x,y),min(max(x,y),z));} 701 //------------------------------------------------------------------------------------------------------------------------------ 702 // V_MIN3_F32. 703 AF1 AMin3F1(AF1 x,AF1 y,AF1 z){return min(x,min(y,z));} 704 AF2 AMin3F2(AF2 x,AF2 y,AF2 z){return min(x,min(y,z));} 705 AF3 AMin3F3(AF3 x,AF3 y,AF3 z){return min(x,min(y,z));} 706 AF4 AMin3F4(AF4 x,AF4 y,AF4 z){return min(x,min(y,z));} 707 //------------------------------------------------------------------------------------------------------------------------------ 708 AU1 AMin3SU1(AU1 x,AU1 y,AU1 z){return AU1(min(ASU1(x),min(ASU1(y),ASU1(z))));} 709 AU2 AMin3SU2(AU2 x,AU2 y,AU2 z){return AU2(min(ASU2(x),min(ASU2(y),ASU2(z))));} 710 AU3 AMin3SU3(AU3 x,AU3 y,AU3 z){return AU3(min(ASU3(x),min(ASU3(y),ASU3(z))));} 711 AU4 AMin3SU4(AU4 x,AU4 y,AU4 z){return AU4(min(ASU4(x),min(ASU4(y),ASU4(z))));} 712 //------------------------------------------------------------------------------------------------------------------------------ 713 AU1 AMin3U1(AU1 x,AU1 y,AU1 z){return min(x,min(y,z));} 714 AU2 AMin3U2(AU2 x,AU2 y,AU2 z){return min(x,min(y,z));} 715 AU3 AMin3U3(AU3 x,AU3 y,AU3 z){return min(x,min(y,z));} 716 AU4 AMin3U4(AU4 x,AU4 y,AU4 z){return min(x,min(y,z));} 717 //------------------------------------------------------------------------------------------------------------------------------ 718 AU1 AMinSU1(AU1 a,AU1 b){return AU1(min(ASU1(a),ASU1(b)));} 719 AU2 AMinSU2(AU2 a,AU2 b){return AU2(min(ASU2(a),ASU2(b)));} 720 AU3 AMinSU3(AU3 a,AU3 b){return AU3(min(ASU3(a),ASU3(b)));} 721 AU4 AMinSU4(AU4 a,AU4 b){return AU4(min(ASU4(a),ASU4(b)));} 722 //------------------------------------------------------------------------------------------------------------------------------ 723 // Normalized trig. Valid input domain is {-256 to +256}. No GLSL compiler intrinsic exists to map to this currently. 724 // V_COS_F32. 725 AF1 ANCosF1(AF1 x){return cos(x*AF1_(A_2PI));} 726 AF2 ANCosF2(AF2 x){return cos(x*AF2_(A_2PI));} 727 AF3 ANCosF3(AF3 x){return cos(x*AF3_(A_2PI));} 728 AF4 ANCosF4(AF4 x){return cos(x*AF4_(A_2PI));} 729 //------------------------------------------------------------------------------------------------------------------------------ 730 // Normalized trig. Valid input domain is {-256 to +256}. No GLSL compiler intrinsic exists to map to this currently. 731 // V_SIN_F32. 732 AF1 ANSinF1(AF1 x){return sin(x*AF1_(A_2PI));} 733 AF2 ANSinF2(AF2 x){return sin(x*AF2_(A_2PI));} 734 AF3 ANSinF3(AF3 x){return sin(x*AF3_(A_2PI));} 735 AF4 ANSinF4(AF4 x){return sin(x*AF4_(A_2PI));} 736 //------------------------------------------------------------------------------------------------------------------------------ 737 AF1 ARcpF1(AF1 x){return AF1_(1.0)/x;} 738 AF2 ARcpF2(AF2 x){return AF2_(1.0)/x;} 739 AF3 ARcpF3(AF3 x){return AF3_(1.0)/x;} 740 AF4 ARcpF4(AF4 x){return AF4_(1.0)/x;} 741 //------------------------------------------------------------------------------------------------------------------------------ 742 AF1 ARsqF1(AF1 x){return AF1_(1.0)/sqrt(x);} 743 AF2 ARsqF2(AF2 x){return AF2_(1.0)/sqrt(x);} 744 AF3 ARsqF3(AF3 x){return AF3_(1.0)/sqrt(x);} 745 AF4 ARsqF4(AF4 x){return AF4_(1.0)/sqrt(x);} 746 //------------------------------------------------------------------------------------------------------------------------------ 747 AF1 ASatF1(AF1 x){return clamp(x,AF1_(0.0),AF1_(1.0));} 748 AF2 ASatF2(AF2 x){return clamp(x,AF2_(0.0),AF2_(1.0));} 749 AF3 ASatF3(AF3 x){return clamp(x,AF3_(0.0),AF3_(1.0));} 750 AF4 ASatF4(AF4 x){return clamp(x,AF4_(0.0),AF4_(1.0));} 751 //------------------------------------------------------------------------------------------------------------------------------ 752 AU1 AShrSU1(AU1 a,AU1 b){return AU1(ASU1(a)>>ASU1(b));} 753 AU2 AShrSU2(AU2 a,AU2 b){return AU2(ASU2(a)>>ASU2(b));} 754 AU3 AShrSU3(AU3 a,AU3 b){return AU3(ASU3(a)>>ASU3(b));} 755 AU4 AShrSU4(AU4 a,AU4 b){return AU4(ASU4(a)>>ASU4(b));} 756 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 757 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 758 //_____________________________________________________________/\_______________________________________________________________ 759 //============================================================================================================================== 760 // GLSL BYTE 761 //============================================================================================================================== 762 #ifdef A_BYTE 763 #define AB1 uint8_t 764 #define AB2 u8vec2 765 #define AB3 u8vec3 766 #define AB4 u8vec4 767 //------------------------------------------------------------------------------------------------------------------------------ 768 #define ASB1 int8_t 769 #define ASB2 i8vec2 770 #define ASB3 i8vec3 771 #define ASB4 i8vec4 772 //------------------------------------------------------------------------------------------------------------------------------ 773 AB1 AB1_x(AB1 a){return AB1(a);} 774 AB2 AB2_x(AB1 a){return AB2(a,a);} 775 AB3 AB3_x(AB1 a){return AB3(a,a,a);} 776 AB4 AB4_x(AB1 a){return AB4(a,a,a,a);} 777 #define AB1_(a) AB1_x(AB1(a)) 778 #define AB2_(a) AB2_x(AB1(a)) 779 #define AB3_(a) AB3_x(AB1(a)) 780 #define AB4_(a) AB4_x(AB1(a)) 781 #endif 782 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 783 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 784 //_____________________________________________________________/\_______________________________________________________________ 785 //============================================================================================================================== 786 // GLSL HALF 787 //============================================================================================================================== 788 #ifdef A_HALF 789 #define AH1 float16_t 790 #define AH2 f16vec2 791 #define AH3 f16vec3 792 #define AH4 f16vec4 793 //------------------------------------------------------------------------------------------------------------------------------ 794 #define AW1 uint16_t 795 #define AW2 u16vec2 796 #define AW3 u16vec3 797 #define AW4 u16vec4 798 //------------------------------------------------------------------------------------------------------------------------------ 799 #define ASW1 int16_t 800 #define ASW2 i16vec2 801 #define ASW3 i16vec3 802 #define ASW4 i16vec4 803 //============================================================================================================================== 804 #define AH2_AU1(x) unpackFloat2x16(AU1(x)) 805 AH4 AH4_AU2_x(AU2 x){return AH4(unpackFloat2x16(x.x),unpackFloat2x16(x.y));} 806 #define AH4_AU2(x) AH4_AU2_x(AU2(x)) 807 #define AW2_AU1(x) unpackUint2x16(AU1(x)) 808 #define AW4_AU2(x) unpackUint4x16(pack64(AU2(x))) 809 //------------------------------------------------------------------------------------------------------------------------------ 810 #define AU1_AH2(x) packFloat2x16(AH2(x)) 811 AU2 AU2_AH4_x(AH4 x){return AU2(packFloat2x16(x.xy),packFloat2x16(x.zw));} 812 #define AU2_AH4(x) AU2_AH4_x(AH4(x)) 813 #define AU1_AW2(x) packUint2x16(AW2(x)) 814 #define AU2_AW4(x) unpack32(packUint4x16(AW4(x))) 815 //============================================================================================================================== 816 #define AW1_AH1(x) halfBitsToUint16(AH1(x)) 817 #define AW2_AH2(x) halfBitsToUint16(AH2(x)) 818 #define AW3_AH3(x) halfBitsToUint16(AH3(x)) 819 #define AW4_AH4(x) halfBitsToUint16(AH4(x)) 820 //------------------------------------------------------------------------------------------------------------------------------ 821 #define AH1_AW1(x) uint16BitsToHalf(AW1(x)) 822 #define AH2_AW2(x) uint16BitsToHalf(AW2(x)) 823 #define AH3_AW3(x) uint16BitsToHalf(AW3(x)) 824 #define AH4_AW4(x) uint16BitsToHalf(AW4(x)) 825 //============================================================================================================================== 826 AH1 AH1_x(AH1 a){return AH1(a);} 827 AH2 AH2_x(AH1 a){return AH2(a,a);} 828 AH3 AH3_x(AH1 a){return AH3(a,a,a);} 829 AH4 AH4_x(AH1 a){return AH4(a,a,a,a);} 830 #define AH1_(a) AH1_x(AH1(a)) 831 #define AH2_(a) AH2_x(AH1(a)) 832 #define AH3_(a) AH3_x(AH1(a)) 833 #define AH4_(a) AH4_x(AH1(a)) 834 //------------------------------------------------------------------------------------------------------------------------------ 835 AW1 AW1_x(AW1 a){return AW1(a);} 836 AW2 AW2_x(AW1 a){return AW2(a,a);} 837 AW3 AW3_x(AW1 a){return AW3(a,a,a);} 838 AW4 AW4_x(AW1 a){return AW4(a,a,a,a);} 839 #define AW1_(a) AW1_x(AW1(a)) 840 #define AW2_(a) AW2_x(AW1(a)) 841 #define AW3_(a) AW3_x(AW1(a)) 842 #define AW4_(a) AW4_x(AW1(a)) 843 //============================================================================================================================== 844 AW1 AAbsSW1(AW1 a){return AW1(abs(ASW1(a)));} 845 AW2 AAbsSW2(AW2 a){return AW2(abs(ASW2(a)));} 846 AW3 AAbsSW3(AW3 a){return AW3(abs(ASW3(a)));} 847 AW4 AAbsSW4(AW4 a){return AW4(abs(ASW4(a)));} 848 //------------------------------------------------------------------------------------------------------------------------------ 849 AH1 AClampH1(AH1 x,AH1 n,AH1 m){return clamp(x,n,m);} 850 AH2 AClampH2(AH2 x,AH2 n,AH2 m){return clamp(x,n,m);} 851 AH3 AClampH3(AH3 x,AH3 n,AH3 m){return clamp(x,n,m);} 852 AH4 AClampH4(AH4 x,AH4 n,AH4 m){return clamp(x,n,m);} 853 //------------------------------------------------------------------------------------------------------------------------------ 854 AH1 AFractH1(AH1 x){return fract(x);} 855 AH2 AFractH2(AH2 x){return fract(x);} 856 AH3 AFractH3(AH3 x){return fract(x);} 857 AH4 AFractH4(AH4 x){return fract(x);} 858 //------------------------------------------------------------------------------------------------------------------------------ 859 AH1 ALerpH1(AH1 x,AH1 y,AH1 a){return mix(x,y,a);} 860 AH2 ALerpH2(AH2 x,AH2 y,AH2 a){return mix(x,y,a);} 861 AH3 ALerpH3(AH3 x,AH3 y,AH3 a){return mix(x,y,a);} 862 AH4 ALerpH4(AH4 x,AH4 y,AH4 a){return mix(x,y,a);} 863 //------------------------------------------------------------------------------------------------------------------------------ 864 // No packed version of max3. 865 AH1 AMax3H1(AH1 x,AH1 y,AH1 z){return max(x,max(y,z));} 866 AH2 AMax3H2(AH2 x,AH2 y,AH2 z){return max(x,max(y,z));} 867 AH3 AMax3H3(AH3 x,AH3 y,AH3 z){return max(x,max(y,z));} 868 AH4 AMax3H4(AH4 x,AH4 y,AH4 z){return max(x,max(y,z));} 869 //------------------------------------------------------------------------------------------------------------------------------ 870 AW1 AMaxSW1(AW1 a,AW1 b){return AW1(max(ASU1(a),ASU1(b)));} 871 AW2 AMaxSW2(AW2 a,AW2 b){return AW2(max(ASU2(a),ASU2(b)));} 872 AW3 AMaxSW3(AW3 a,AW3 b){return AW3(max(ASU3(a),ASU3(b)));} 873 AW4 AMaxSW4(AW4 a,AW4 b){return AW4(max(ASU4(a),ASU4(b)));} 874 //------------------------------------------------------------------------------------------------------------------------------ 875 // No packed version of min3. 876 AH1 AMin3H1(AH1 x,AH1 y,AH1 z){return min(x,min(y,z));} 877 AH2 AMin3H2(AH2 x,AH2 y,AH2 z){return min(x,min(y,z));} 878 AH3 AMin3H3(AH3 x,AH3 y,AH3 z){return min(x,min(y,z));} 879 AH4 AMin3H4(AH4 x,AH4 y,AH4 z){return min(x,min(y,z));} 880 //------------------------------------------------------------------------------------------------------------------------------ 881 AW1 AMinSW1(AW1 a,AW1 b){return AW1(min(ASU1(a),ASU1(b)));} 882 AW2 AMinSW2(AW2 a,AW2 b){return AW2(min(ASU2(a),ASU2(b)));} 883 AW3 AMinSW3(AW3 a,AW3 b){return AW3(min(ASU3(a),ASU3(b)));} 884 AW4 AMinSW4(AW4 a,AW4 b){return AW4(min(ASU4(a),ASU4(b)));} 885 //------------------------------------------------------------------------------------------------------------------------------ 886 AH1 ARcpH1(AH1 x){return AH1_(1.0)/x;} 887 AH2 ARcpH2(AH2 x){return AH2_(1.0)/x;} 888 AH3 ARcpH3(AH3 x){return AH3_(1.0)/x;} 889 AH4 ARcpH4(AH4 x){return AH4_(1.0)/x;} 890 //------------------------------------------------------------------------------------------------------------------------------ 891 AH1 ARsqH1(AH1 x){return AH1_(1.0)/sqrt(x);} 892 AH2 ARsqH2(AH2 x){return AH2_(1.0)/sqrt(x);} 893 AH3 ARsqH3(AH3 x){return AH3_(1.0)/sqrt(x);} 894 AH4 ARsqH4(AH4 x){return AH4_(1.0)/sqrt(x);} 895 //------------------------------------------------------------------------------------------------------------------------------ 896 AH1 ASatH1(AH1 x){return clamp(x,AH1_(0.0),AH1_(1.0));} 897 AH2 ASatH2(AH2 x){return clamp(x,AH2_(0.0),AH2_(1.0));} 898 AH3 ASatH3(AH3 x){return clamp(x,AH3_(0.0),AH3_(1.0));} 899 AH4 ASatH4(AH4 x){return clamp(x,AH4_(0.0),AH4_(1.0));} 900 //------------------------------------------------------------------------------------------------------------------------------ 901 AW1 AShrSW1(AW1 a,AW1 b){return AW1(ASW1(a)>>ASW1(b));} 902 AW2 AShrSW2(AW2 a,AW2 b){return AW2(ASW2(a)>>ASW2(b));} 903 AW3 AShrSW3(AW3 a,AW3 b){return AW3(ASW3(a)>>ASW3(b));} 904 AW4 AShrSW4(AW4 a,AW4 b){return AW4(ASW4(a)>>ASW4(b));} 905 #endif 906 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 907 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 908 //_____________________________________________________________/\_______________________________________________________________ 909 //============================================================================================================================== 910 // GLSL DOUBLE 911 //============================================================================================================================== 912 #ifdef A_DUBL 913 #define AD1 double 914 #define AD2 dvec2 915 #define AD3 dvec3 916 #define AD4 dvec4 917 //------------------------------------------------------------------------------------------------------------------------------ 918 AD1 AD1_x(AD1 a){return AD1(a);} 919 AD2 AD2_x(AD1 a){return AD2(a,a);} 920 AD3 AD3_x(AD1 a){return AD3(a,a,a);} 921 AD4 AD4_x(AD1 a){return AD4(a,a,a,a);} 922 #define AD1_(a) AD1_x(AD1(a)) 923 #define AD2_(a) AD2_x(AD1(a)) 924 #define AD3_(a) AD3_x(AD1(a)) 925 #define AD4_(a) AD4_x(AD1(a)) 926 //============================================================================================================================== 927 AD1 AFractD1(AD1 x){return fract(x);} 928 AD2 AFractD2(AD2 x){return fract(x);} 929 AD3 AFractD3(AD3 x){return fract(x);} 930 AD4 AFractD4(AD4 x){return fract(x);} 931 //------------------------------------------------------------------------------------------------------------------------------ 932 AD1 ALerpD1(AD1 x,AD1 y,AD1 a){return mix(x,y,a);} 933 AD2 ALerpD2(AD2 x,AD2 y,AD2 a){return mix(x,y,a);} 934 AD3 ALerpD3(AD3 x,AD3 y,AD3 a){return mix(x,y,a);} 935 AD4 ALerpD4(AD4 x,AD4 y,AD4 a){return mix(x,y,a);} 936 //------------------------------------------------------------------------------------------------------------------------------ 937 AD1 ARcpD1(AD1 x){return AD1_(1.0)/x;} 938 AD2 ARcpD2(AD2 x){return AD2_(1.0)/x;} 939 AD3 ARcpD3(AD3 x){return AD3_(1.0)/x;} 940 AD4 ARcpD4(AD4 x){return AD4_(1.0)/x;} 941 //------------------------------------------------------------------------------------------------------------------------------ 942 AD1 ARsqD1(AD1 x){return AD1_(1.0)/sqrt(x);} 943 AD2 ARsqD2(AD2 x){return AD2_(1.0)/sqrt(x);} 944 AD3 ARsqD3(AD3 x){return AD3_(1.0)/sqrt(x);} 945 AD4 ARsqD4(AD4 x){return AD4_(1.0)/sqrt(x);} 946 //------------------------------------------------------------------------------------------------------------------------------ 947 AD1 ASatD1(AD1 x){return clamp(x,AD1_(0.0),AD1_(1.0));} 948 AD2 ASatD2(AD2 x){return clamp(x,AD2_(0.0),AD2_(1.0));} 949 AD3 ASatD3(AD3 x){return clamp(x,AD3_(0.0),AD3_(1.0));} 950 AD4 ASatD4(AD4 x){return clamp(x,AD4_(0.0),AD4_(1.0));} 951 #endif 952 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 953 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 954 //_____________________________________________________________/\_______________________________________________________________ 955 //============================================================================================================================== 956 // GLSL LONG 957 //============================================================================================================================== 958 #ifdef A_LONG 959 #define AL1 uint64_t 960 #define AL2 u64vec2 961 #define AL3 u64vec3 962 #define AL4 u64vec4 963 //------------------------------------------------------------------------------------------------------------------------------ 964 #define ASL1 int64_t 965 #define ASL2 i64vec2 966 #define ASL3 i64vec3 967 #define ASL4 i64vec4 968 //------------------------------------------------------------------------------------------------------------------------------ 969 #define AL1_AU2(x) packUint2x32(AU2(x)) 970 #define AU2_AL1(x) unpackUint2x32(AL1(x)) 971 //------------------------------------------------------------------------------------------------------------------------------ 972 AL1 AL1_x(AL1 a){return AL1(a);} 973 AL2 AL2_x(AL1 a){return AL2(a,a);} 974 AL3 AL3_x(AL1 a){return AL3(a,a,a);} 975 AL4 AL4_x(AL1 a){return AL4(a,a,a,a);} 976 #define AL1_(a) AL1_x(AL1(a)) 977 #define AL2_(a) AL2_x(AL1(a)) 978 #define AL3_(a) AL3_x(AL1(a)) 979 #define AL4_(a) AL4_x(AL1(a)) 980 //============================================================================================================================== 981 AL1 AAbsSL1(AL1 a){return AL1(abs(ASL1(a)));} 982 AL2 AAbsSL2(AL2 a){return AL2(abs(ASL2(a)));} 983 AL3 AAbsSL3(AL3 a){return AL3(abs(ASL3(a)));} 984 AL4 AAbsSL4(AL4 a){return AL4(abs(ASL4(a)));} 985 //------------------------------------------------------------------------------------------------------------------------------ 986 AL1 AMaxSL1(AL1 a,AL1 b){return AL1(max(ASU1(a),ASU1(b)));} 987 AL2 AMaxSL2(AL2 a,AL2 b){return AL2(max(ASU2(a),ASU2(b)));} 988 AL3 AMaxSL3(AL3 a,AL3 b){return AL3(max(ASU3(a),ASU3(b)));} 989 AL4 AMaxSL4(AL4 a,AL4 b){return AL4(max(ASU4(a),ASU4(b)));} 990 //------------------------------------------------------------------------------------------------------------------------------ 991 AL1 AMinSL1(AL1 a,AL1 b){return AL1(min(ASU1(a),ASU1(b)));} 992 AL2 AMinSL2(AL2 a,AL2 b){return AL2(min(ASU2(a),ASU2(b)));} 993 AL3 AMinSL3(AL3 a,AL3 b){return AL3(min(ASU3(a),ASU3(b)));} 994 AL4 AMinSL4(AL4 a,AL4 b){return AL4(min(ASU4(a),ASU4(b)));} 995 #endif 996 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 997 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 998 //_____________________________________________________________/\_______________________________________________________________ 999 //============================================================================================================================== 1000 // WAVE OPERATIONS 1001 //============================================================================================================================== 1002 #ifdef A_WAVE 1003 // Where 'x' must be a compile time literal. 1004 AF1 AWaveXorF1(AF1 v,AU1 x){return subgroupShuffleXor(v,x);} 1005 AF2 AWaveXorF2(AF2 v,AU1 x){return subgroupShuffleXor(v,x);} 1006 AF3 AWaveXorF3(AF3 v,AU1 x){return subgroupShuffleXor(v,x);} 1007 AF4 AWaveXorF4(AF4 v,AU1 x){return subgroupShuffleXor(v,x);} 1008 AU1 AWaveXorU1(AU1 v,AU1 x){return subgroupShuffleXor(v,x);} 1009 AU2 AWaveXorU2(AU2 v,AU1 x){return subgroupShuffleXor(v,x);} 1010 AU3 AWaveXorU3(AU3 v,AU1 x){return subgroupShuffleXor(v,x);} 1011 AU4 AWaveXorU4(AU4 v,AU1 x){return subgroupShuffleXor(v,x);} 1012 //------------------------------------------------------------------------------------------------------------------------------ 1013 #ifdef A_HALF 1014 AH2 AWaveXorH2(AH2 v,AU1 x){return AH2_AU1(subgroupShuffleXor(AU1_AH2(v),x));} 1015 AH4 AWaveXorH4(AH4 v,AU1 x){return AH4_AU2(subgroupShuffleXor(AU2_AH4(v),x));} 1016 AW2 AWaveXorW2(AW2 v,AU1 x){return AW2_AU1(subgroupShuffleXor(AU1_AW2(v),x));} 1017 AW4 AWaveXorW4(AW4 v,AU1 x){return AW4_AU2(subgroupShuffleXor(AU2_AW4(v),x));} 1018 #endif 1019 #endif 1020 //============================================================================================================================== 1021 #endif 1022 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1023 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1024 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1025 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1026 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1027 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1028 //_____________________________________________________________/\_______________________________________________________________ 1029 //============================================================================================================================== 1030 // 1031 // 1032 // HLSL 1033 // 1034 // 1035 //============================================================================================================================== 1036 #if defined(A_HLSL) && defined(A_GPU) 1037 #ifdef A_HLSL_6_2 1038 #define AP1 bool 1039 #define AP2 bool2 1040 #define AP3 bool3 1041 #define AP4 bool4 1042 //------------------------------------------------------------------------------------------------------------------------------ 1043 #define AF1 float32_t 1044 #define AF2 float32_t2 1045 #define AF3 float32_t3 1046 #define AF4 float32_t4 1047 //------------------------------------------------------------------------------------------------------------------------------ 1048 #define AU1 uint32_t 1049 #define AU2 uint32_t2 1050 #define AU3 uint32_t3 1051 #define AU4 uint32_t4 1052 //------------------------------------------------------------------------------------------------------------------------------ 1053 #define ASU1 int32_t 1054 #define ASU2 int32_t2 1055 #define ASU3 int32_t3 1056 #define ASU4 int32_t4 1057 #else 1058 #define AP1 bool 1059 #define AP2 bool2 1060 #define AP3 bool3 1061 #define AP4 bool4 1062 //------------------------------------------------------------------------------------------------------------------------------ 1063 #define AF1 float 1064 #define AF2 float2 1065 #define AF3 float3 1066 #define AF4 float4 1067 //------------------------------------------------------------------------------------------------------------------------------ 1068 #define AU1 uint 1069 #define AU2 uint2 1070 #define AU3 uint3 1071 #define AU4 uint4 1072 //------------------------------------------------------------------------------------------------------------------------------ 1073 #define ASU1 int 1074 #define ASU2 int2 1075 #define ASU3 int3 1076 #define ASU4 int4 1077 #endif 1078 //============================================================================================================================== 1079 #define AF1_AU1(x) asfloat(AU1(x)) 1080 #define AF2_AU2(x) asfloat(AU2(x)) 1081 #define AF3_AU3(x) asfloat(AU3(x)) 1082 #define AF4_AU4(x) asfloat(AU4(x)) 1083 //------------------------------------------------------------------------------------------------------------------------------ 1084 #define AU1_AF1(x) asuint(AF1(x)) 1085 #define AU2_AF2(x) asuint(AF2(x)) 1086 #define AU3_AF3(x) asuint(AF3(x)) 1087 #define AU4_AF4(x) asuint(AF4(x)) 1088 //------------------------------------------------------------------------------------------------------------------------------ 1089 AU1 AU1_AH1_AF1_x(AF1 a){return f32tof16(a);} 1090 #define AU1_AH1_AF1(a) AU1_AH1_AF1_x(AF1(a)) 1091 //------------------------------------------------------------------------------------------------------------------------------ 1092 AU1 AU1_AH2_AF2_x(AF2 a){return f32tof16(a.x)|(f32tof16(a.y)<<16);} 1093 #define AU1_AH2_AF2(a) AU1_AH2_AF2_x(AF2(a)) 1094 #define AU1_AB4Unorm_AF4(x) D3DCOLORtoUBYTE4(AF4(x)) 1095 //------------------------------------------------------------------------------------------------------------------------------ 1096 AF2 AF2_AH2_AU1_x(AU1 x){return AF2(f16tof32(x&0xFFFF),f16tof32(x>>16));} 1097 #define AF2_AH2_AU1(x) AF2_AH2_AU1_x(AU1(x)) 1098 //============================================================================================================================== 1099 AF1 AF1_x(AF1 a){return AF1(a);} 1100 AF2 AF2_x(AF1 a){return AF2(a,a);} 1101 AF3 AF3_x(AF1 a){return AF3(a,a,a);} 1102 AF4 AF4_x(AF1 a){return AF4(a,a,a,a);} 1103 #define AF1_(a) AF1_x(AF1(a)) 1104 #define AF2_(a) AF2_x(AF1(a)) 1105 #define AF3_(a) AF3_x(AF1(a)) 1106 #define AF4_(a) AF4_x(AF1(a)) 1107 //------------------------------------------------------------------------------------------------------------------------------ 1108 AU1 AU1_x(AU1 a){return AU1(a);} 1109 AU2 AU2_x(AU1 a){return AU2(a,a);} 1110 AU3 AU3_x(AU1 a){return AU3(a,a,a);} 1111 AU4 AU4_x(AU1 a){return AU4(a,a,a,a);} 1112 #define AU1_(a) AU1_x(AU1(a)) 1113 #define AU2_(a) AU2_x(AU1(a)) 1114 #define AU3_(a) AU3_x(AU1(a)) 1115 #define AU4_(a) AU4_x(AU1(a)) 1116 //============================================================================================================================== 1117 AU1 AAbsSU1(AU1 a){return AU1(abs(ASU1(a)));} 1118 AU2 AAbsSU2(AU2 a){return AU2(abs(ASU2(a)));} 1119 AU3 AAbsSU3(AU3 a){return AU3(abs(ASU3(a)));} 1120 AU4 AAbsSU4(AU4 a){return AU4(abs(ASU4(a)));} 1121 //------------------------------------------------------------------------------------------------------------------------------ 1122 AU1 ABfe(AU1 src,AU1 off,AU1 bits){AU1 mask=(1u<<bits)-1;return (src>>off)&mask;} 1123 AU1 ABfi(AU1 src,AU1 ins,AU1 mask){return (ins&mask)|(src&(~mask));} 1124 AU1 ABfiM(AU1 src,AU1 ins,AU1 bits){AU1 mask=(1u<<bits)-1;return (ins&mask)|(src&(~mask));} 1125 //------------------------------------------------------------------------------------------------------------------------------ 1126 AF1 AClampF1(AF1 x,AF1 n,AF1 m){return max(n,min(x,m));} 1127 AF2 AClampF2(AF2 x,AF2 n,AF2 m){return max(n,min(x,m));} 1128 AF3 AClampF3(AF3 x,AF3 n,AF3 m){return max(n,min(x,m));} 1129 AF4 AClampF4(AF4 x,AF4 n,AF4 m){return max(n,min(x,m));} 1130 //------------------------------------------------------------------------------------------------------------------------------ 1131 AF1 AFractF1(AF1 x){return x-floor(x);} 1132 AF2 AFractF2(AF2 x){return x-floor(x);} 1133 AF3 AFractF3(AF3 x){return x-floor(x);} 1134 AF4 AFractF4(AF4 x){return x-floor(x);} 1135 //------------------------------------------------------------------------------------------------------------------------------ 1136 AF1 ALerpF1(AF1 x,AF1 y,AF1 a){return lerp(x,y,a);} 1137 AF2 ALerpF2(AF2 x,AF2 y,AF2 a){return lerp(x,y,a);} 1138 AF3 ALerpF3(AF3 x,AF3 y,AF3 a){return lerp(x,y,a);} 1139 AF4 ALerpF4(AF4 x,AF4 y,AF4 a){return lerp(x,y,a);} 1140 //------------------------------------------------------------------------------------------------------------------------------ 1141 AF1 AMax3F1(AF1 x,AF1 y,AF1 z){return max(x,max(y,z));} 1142 AF2 AMax3F2(AF2 x,AF2 y,AF2 z){return max(x,max(y,z));} 1143 AF3 AMax3F3(AF3 x,AF3 y,AF3 z){return max(x,max(y,z));} 1144 AF4 AMax3F4(AF4 x,AF4 y,AF4 z){return max(x,max(y,z));} 1145 //------------------------------------------------------------------------------------------------------------------------------ 1146 AU1 AMax3SU1(AU1 x,AU1 y,AU1 z){return AU1(max(ASU1(x),max(ASU1(y),ASU1(z))));} 1147 AU2 AMax3SU2(AU2 x,AU2 y,AU2 z){return AU2(max(ASU2(x),max(ASU2(y),ASU2(z))));} 1148 AU3 AMax3SU3(AU3 x,AU3 y,AU3 z){return AU3(max(ASU3(x),max(ASU3(y),ASU3(z))));} 1149 AU4 AMax3SU4(AU4 x,AU4 y,AU4 z){return AU4(max(ASU4(x),max(ASU4(y),ASU4(z))));} 1150 //------------------------------------------------------------------------------------------------------------------------------ 1151 AU1 AMax3U1(AU1 x,AU1 y,AU1 z){return max(x,max(y,z));} 1152 AU2 AMax3U2(AU2 x,AU2 y,AU2 z){return max(x,max(y,z));} 1153 AU3 AMax3U3(AU3 x,AU3 y,AU3 z){return max(x,max(y,z));} 1154 AU4 AMax3U4(AU4 x,AU4 y,AU4 z){return max(x,max(y,z));} 1155 //------------------------------------------------------------------------------------------------------------------------------ 1156 AU1 AMaxSU1(AU1 a,AU1 b){return AU1(max(ASU1(a),ASU1(b)));} 1157 AU2 AMaxSU2(AU2 a,AU2 b){return AU2(max(ASU2(a),ASU2(b)));} 1158 AU3 AMaxSU3(AU3 a,AU3 b){return AU3(max(ASU3(a),ASU3(b)));} 1159 AU4 AMaxSU4(AU4 a,AU4 b){return AU4(max(ASU4(a),ASU4(b)));} 1160 //------------------------------------------------------------------------------------------------------------------------------ 1161 AF1 AMed3F1(AF1 x,AF1 y,AF1 z){return max(min(x,y),min(max(x,y),z));} 1162 AF2 AMed3F2(AF2 x,AF2 y,AF2 z){return max(min(x,y),min(max(x,y),z));} 1163 AF3 AMed3F3(AF3 x,AF3 y,AF3 z){return max(min(x,y),min(max(x,y),z));} 1164 AF4 AMed3F4(AF4 x,AF4 y,AF4 z){return max(min(x,y),min(max(x,y),z));} 1165 //------------------------------------------------------------------------------------------------------------------------------ 1166 AF1 AMin3F1(AF1 x,AF1 y,AF1 z){return min(x,min(y,z));} 1167 AF2 AMin3F2(AF2 x,AF2 y,AF2 z){return min(x,min(y,z));} 1168 AF3 AMin3F3(AF3 x,AF3 y,AF3 z){return min(x,min(y,z));} 1169 AF4 AMin3F4(AF4 x,AF4 y,AF4 z){return min(x,min(y,z));} 1170 //------------------------------------------------------------------------------------------------------------------------------ 1171 AU1 AMin3SU1(AU1 x,AU1 y,AU1 z){return AU1(min(ASU1(x),min(ASU1(y),ASU1(z))));} 1172 AU2 AMin3SU2(AU2 x,AU2 y,AU2 z){return AU2(min(ASU2(x),min(ASU2(y),ASU2(z))));} 1173 AU3 AMin3SU3(AU3 x,AU3 y,AU3 z){return AU3(min(ASU3(x),min(ASU3(y),ASU3(z))));} 1174 AU4 AMin3SU4(AU4 x,AU4 y,AU4 z){return AU4(min(ASU4(x),min(ASU4(y),ASU4(z))));} 1175 //------------------------------------------------------------------------------------------------------------------------------ 1176 AU1 AMin3U1(AU1 x,AU1 y,AU1 z){return min(x,min(y,z));} 1177 AU2 AMin3U2(AU2 x,AU2 y,AU2 z){return min(x,min(y,z));} 1178 AU3 AMin3U3(AU3 x,AU3 y,AU3 z){return min(x,min(y,z));} 1179 AU4 AMin3U4(AU4 x,AU4 y,AU4 z){return min(x,min(y,z));} 1180 //------------------------------------------------------------------------------------------------------------------------------ 1181 AU1 AMinSU1(AU1 a,AU1 b){return AU1(min(ASU1(a),ASU1(b)));} 1182 AU2 AMinSU2(AU2 a,AU2 b){return AU2(min(ASU2(a),ASU2(b)));} 1183 AU3 AMinSU3(AU3 a,AU3 b){return AU3(min(ASU3(a),ASU3(b)));} 1184 AU4 AMinSU4(AU4 a,AU4 b){return AU4(min(ASU4(a),ASU4(b)));} 1185 //------------------------------------------------------------------------------------------------------------------------------ 1186 AF1 ANCosF1(AF1 x){return cos(x*AF1_(A_2PI));} 1187 AF2 ANCosF2(AF2 x){return cos(x*AF2_(A_2PI));} 1188 AF3 ANCosF3(AF3 x){return cos(x*AF3_(A_2PI));} 1189 AF4 ANCosF4(AF4 x){return cos(x*AF4_(A_2PI));} 1190 //------------------------------------------------------------------------------------------------------------------------------ 1191 AF1 ANSinF1(AF1 x){return sin(x*AF1_(A_2PI));} 1192 AF2 ANSinF2(AF2 x){return sin(x*AF2_(A_2PI));} 1193 AF3 ANSinF3(AF3 x){return sin(x*AF3_(A_2PI));} 1194 AF4 ANSinF4(AF4 x){return sin(x*AF4_(A_2PI));} 1195 //------------------------------------------------------------------------------------------------------------------------------ 1196 AF1 ARcpF1(AF1 x){return rcp(x);} 1197 AF2 ARcpF2(AF2 x){return rcp(x);} 1198 AF3 ARcpF3(AF3 x){return rcp(x);} 1199 AF4 ARcpF4(AF4 x){return rcp(x);} 1200 //------------------------------------------------------------------------------------------------------------------------------ 1201 AF1 ARsqF1(AF1 x){return rsqrt(x);} 1202 AF2 ARsqF2(AF2 x){return rsqrt(x);} 1203 AF3 ARsqF3(AF3 x){return rsqrt(x);} 1204 AF4 ARsqF4(AF4 x){return rsqrt(x);} 1205 //------------------------------------------------------------------------------------------------------------------------------ 1206 AF1 ASatF1(AF1 x){return saturate(x);} 1207 AF2 ASatF2(AF2 x){return saturate(x);} 1208 AF3 ASatF3(AF3 x){return saturate(x);} 1209 AF4 ASatF4(AF4 x){return saturate(x);} 1210 //------------------------------------------------------------------------------------------------------------------------------ 1211 AU1 AShrSU1(AU1 a,AU1 b){return AU1(ASU1(a)>>ASU1(b));} 1212 AU2 AShrSU2(AU2 a,AU2 b){return AU2(ASU2(a)>>ASU2(b));} 1213 AU3 AShrSU3(AU3 a,AU3 b){return AU3(ASU3(a)>>ASU3(b));} 1214 AU4 AShrSU4(AU4 a,AU4 b){return AU4(ASU4(a)>>ASU4(b));} 1215 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1216 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1217 //_____________________________________________________________/\_______________________________________________________________ 1218 //============================================================================================================================== 1219 // HLSL BYTE 1220 //============================================================================================================================== 1221 #ifdef A_BYTE 1222 #endif 1223 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1224 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1225 //_____________________________________________________________/\_______________________________________________________________ 1226 //============================================================================================================================== 1227 // HLSL HALF 1228 //============================================================================================================================== 1229 #ifdef A_HALF 1230 #ifdef A_HLSL_6_2 1231 #define AH1 float16_t 1232 #define AH2 float16_t2 1233 #define AH3 float16_t3 1234 #define AH4 float16_t4 1235 //------------------------------------------------------------------------------------------------------------------------------ 1236 #define AW1 uint16_t 1237 #define AW2 uint16_t2 1238 #define AW3 uint16_t3 1239 #define AW4 uint16_t4 1240 //------------------------------------------------------------------------------------------------------------------------------ 1241 #define ASW1 int16_t 1242 #define ASW2 int16_t2 1243 #define ASW3 int16_t3 1244 #define ASW4 int16_t4 1245 #else 1246 #define AH1 min16float 1247 #define AH2 min16float2 1248 #define AH3 min16float3 1249 #define AH4 min16float4 1250 //------------------------------------------------------------------------------------------------------------------------------ 1251 #define AW1 min16uint 1252 #define AW2 min16uint2 1253 #define AW3 min16uint3 1254 #define AW4 min16uint4 1255 //------------------------------------------------------------------------------------------------------------------------------ 1256 #define ASW1 min16int 1257 #define ASW2 min16int2 1258 #define ASW3 min16int3 1259 #define ASW4 min16int4 1260 #endif 1261 //============================================================================================================================== 1262 // Need to use manual unpack to get optimal execution (don't use packed types in buffers directly). 1263 // Unpack requires this pattern: https://gpuopen.com/first-steps-implementing-fp16/ 1264 AH2 AH2_AU1_x(AU1 x){AF2 t=f16tof32(AU2(x&0xFFFF,x>>16));return AH2(t);} 1265 AH4 AH4_AU2_x(AU2 x){return AH4(AH2_AU1_x(x.x),AH2_AU1_x(x.y));} 1266 AW2 AW2_AU1_x(AU1 x){AU2 t=AU2(x&0xFFFF,x>>16);return AW2(t);} 1267 AW4 AW4_AU2_x(AU2 x){return AW4(AW2_AU1_x(x.x),AW2_AU1_x(x.y));} 1268 #define AH2_AU1(x) AH2_AU1_x(AU1(x)) 1269 #define AH4_AU2(x) AH4_AU2_x(AU2(x)) 1270 #define AW2_AU1(x) AW2_AU1_x(AU1(x)) 1271 #define AW4_AU2(x) AW4_AU2_x(AU2(x)) 1272 //------------------------------------------------------------------------------------------------------------------------------ 1273 AU1 AU1_AH2_x(AH2 x){return f32tof16(x.x)+(f32tof16(x.y)<<16);} 1274 AU2 AU2_AH4_x(AH4 x){return AU2(AU1_AH2_x(x.xy),AU1_AH2_x(x.zw));} 1275 AU1 AU1_AW2_x(AW2 x){return AU1(x.x)+(AU1(x.y)<<16);} 1276 AU2 AU2_AW4_x(AW4 x){return AU2(AU1_AW2_x(x.xy),AU1_AW2_x(x.zw));} 1277 #define AU1_AH2(x) AU1_AH2_x(AH2(x)) 1278 #define AU2_AH4(x) AU2_AH4_x(AH4(x)) 1279 #define AU1_AW2(x) AU1_AW2_x(AW2(x)) 1280 #define AU2_AW4(x) AU2_AW4_x(AW4(x)) 1281 //============================================================================================================================== 1282 #if defined(A_HLSL_6_2) && !defined(A_NO_16_BIT_CAST) 1283 #define AW1_AH1(x) asuint16(x) 1284 #define AW2_AH2(x) asuint16(x) 1285 #define AW3_AH3(x) asuint16(x) 1286 #define AW4_AH4(x) asuint16(x) 1287 #else 1288 #define AW1_AH1(a) AW1(f32tof16(AF1(a))) 1289 #define AW2_AH2(a) AW2(AW1_AH1((a).x),AW1_AH1((a).y)) 1290 #define AW3_AH3(a) AW3(AW1_AH1((a).x),AW1_AH1((a).y),AW1_AH1((a).z)) 1291 #define AW4_AH4(a) AW4(AW1_AH1((a).x),AW1_AH1((a).y),AW1_AH1((a).z),AW1_AH1((a).w)) 1292 #endif 1293 //------------------------------------------------------------------------------------------------------------------------------ 1294 #if defined(A_HLSL_6_2) && !defined(A_NO_16_BIT_CAST) 1295 #define AH1_AW1(x) asfloat16(x) 1296 #define AH2_AW2(x) asfloat16(x) 1297 #define AH3_AW3(x) asfloat16(x) 1298 #define AH4_AW4(x) asfloat16(x) 1299 #else 1300 #define AH1_AW1(a) AH1(f16tof32(AU1(a))) 1301 #define AH2_AW2(a) AH2(AH1_AW1((a).x),AH1_AW1((a).y)) 1302 #define AH3_AW3(a) AH3(AH1_AW1((a).x),AH1_AW1((a).y),AH1_AW1((a).z)) 1303 #define AH4_AW4(a) AH4(AH1_AW1((a).x),AH1_AW1((a).y),AH1_AW1((a).z),AH1_AW1((a).w)) 1304 #endif 1305 //============================================================================================================================== 1306 AH1 AH1_x(AH1 a){return AH1(a);} 1307 AH2 AH2_x(AH1 a){return AH2(a,a);} 1308 AH3 AH3_x(AH1 a){return AH3(a,a,a);} 1309 AH4 AH4_x(AH1 a){return AH4(a,a,a,a);} 1310 #define AH1_(a) AH1_x(AH1(a)) 1311 #define AH2_(a) AH2_x(AH1(a)) 1312 #define AH3_(a) AH3_x(AH1(a)) 1313 #define AH4_(a) AH4_x(AH1(a)) 1314 //------------------------------------------------------------------------------------------------------------------------------ 1315 AW1 AW1_x(AW1 a){return AW1(a);} 1316 AW2 AW2_x(AW1 a){return AW2(a,a);} 1317 AW3 AW3_x(AW1 a){return AW3(a,a,a);} 1318 AW4 AW4_x(AW1 a){return AW4(a,a,a,a);} 1319 #define AW1_(a) AW1_x(AW1(a)) 1320 #define AW2_(a) AW2_x(AW1(a)) 1321 #define AW3_(a) AW3_x(AW1(a)) 1322 #define AW4_(a) AW4_x(AW1(a)) 1323 //============================================================================================================================== 1324 AW1 AAbsSW1(AW1 a){return AW1(abs(ASW1(a)));} 1325 AW2 AAbsSW2(AW2 a){return AW2(abs(ASW2(a)));} 1326 AW3 AAbsSW3(AW3 a){return AW3(abs(ASW3(a)));} 1327 AW4 AAbsSW4(AW4 a){return AW4(abs(ASW4(a)));} 1328 //------------------------------------------------------------------------------------------------------------------------------ 1329 AH1 AClampH1(AH1 x,AH1 n,AH1 m){return max(n,min(x,m));} 1330 AH2 AClampH2(AH2 x,AH2 n,AH2 m){return max(n,min(x,m));} 1331 AH3 AClampH3(AH3 x,AH3 n,AH3 m){return max(n,min(x,m));} 1332 AH4 AClampH4(AH4 x,AH4 n,AH4 m){return max(n,min(x,m));} 1333 //------------------------------------------------------------------------------------------------------------------------------ 1334 // V_FRACT_F16 (note DX frac() is different). 1335 AH1 AFractH1(AH1 x){return x-floor(x);} 1336 AH2 AFractH2(AH2 x){return x-floor(x);} 1337 AH3 AFractH3(AH3 x){return x-floor(x);} 1338 AH4 AFractH4(AH4 x){return x-floor(x);} 1339 //------------------------------------------------------------------------------------------------------------------------------ 1340 AH1 ALerpH1(AH1 x,AH1 y,AH1 a){return lerp(x,y,a);} 1341 AH2 ALerpH2(AH2 x,AH2 y,AH2 a){return lerp(x,y,a);} 1342 AH3 ALerpH3(AH3 x,AH3 y,AH3 a){return lerp(x,y,a);} 1343 AH4 ALerpH4(AH4 x,AH4 y,AH4 a){return lerp(x,y,a);} 1344 //------------------------------------------------------------------------------------------------------------------------------ 1345 AH1 AMax3H1(AH1 x,AH1 y,AH1 z){return max(x,max(y,z));} 1346 AH2 AMax3H2(AH2 x,AH2 y,AH2 z){return max(x,max(y,z));} 1347 AH3 AMax3H3(AH3 x,AH3 y,AH3 z){return max(x,max(y,z));} 1348 AH4 AMax3H4(AH4 x,AH4 y,AH4 z){return max(x,max(y,z));} 1349 //------------------------------------------------------------------------------------------------------------------------------ 1350 AW1 AMaxSW1(AW1 a,AW1 b){return AW1(max(ASU1(a),ASU1(b)));} 1351 AW2 AMaxSW2(AW2 a,AW2 b){return AW2(max(ASU2(a),ASU2(b)));} 1352 AW3 AMaxSW3(AW3 a,AW3 b){return AW3(max(ASU3(a),ASU3(b)));} 1353 AW4 AMaxSW4(AW4 a,AW4 b){return AW4(max(ASU4(a),ASU4(b)));} 1354 //------------------------------------------------------------------------------------------------------------------------------ 1355 AH1 AMin3H1(AH1 x,AH1 y,AH1 z){return min(x,min(y,z));} 1356 AH2 AMin3H2(AH2 x,AH2 y,AH2 z){return min(x,min(y,z));} 1357 AH3 AMin3H3(AH3 x,AH3 y,AH3 z){return min(x,min(y,z));} 1358 AH4 AMin3H4(AH4 x,AH4 y,AH4 z){return min(x,min(y,z));} 1359 //------------------------------------------------------------------------------------------------------------------------------ 1360 AW1 AMinSW1(AW1 a,AW1 b){return AW1(min(ASU1(a),ASU1(b)));} 1361 AW2 AMinSW2(AW2 a,AW2 b){return AW2(min(ASU2(a),ASU2(b)));} 1362 AW3 AMinSW3(AW3 a,AW3 b){return AW3(min(ASU3(a),ASU3(b)));} 1363 AW4 AMinSW4(AW4 a,AW4 b){return AW4(min(ASU4(a),ASU4(b)));} 1364 //------------------------------------------------------------------------------------------------------------------------------ 1365 AH1 ARcpH1(AH1 x){return rcp(x);} 1366 AH2 ARcpH2(AH2 x){return rcp(x);} 1367 AH3 ARcpH3(AH3 x){return rcp(x);} 1368 AH4 ARcpH4(AH4 x){return rcp(x);} 1369 //------------------------------------------------------------------------------------------------------------------------------ 1370 AH1 ARsqH1(AH1 x){return rsqrt(x);} 1371 AH2 ARsqH2(AH2 x){return rsqrt(x);} 1372 AH3 ARsqH3(AH3 x){return rsqrt(x);} 1373 AH4 ARsqH4(AH4 x){return rsqrt(x);} 1374 //------------------------------------------------------------------------------------------------------------------------------ 1375 AH1 ASatH1(AH1 x){return saturate(x);} 1376 AH2 ASatH2(AH2 x){return saturate(x);} 1377 AH3 ASatH3(AH3 x){return saturate(x);} 1378 AH4 ASatH4(AH4 x){return saturate(x);} 1379 //------------------------------------------------------------------------------------------------------------------------------ 1380 AW1 AShrSW1(AW1 a,AW1 b){return AW1(ASW1(a)>>ASW1(b));} 1381 AW2 AShrSW2(AW2 a,AW2 b){return AW2(ASW2(a)>>ASW2(b));} 1382 AW3 AShrSW3(AW3 a,AW3 b){return AW3(ASW3(a)>>ASW3(b));} 1383 AW4 AShrSW4(AW4 a,AW4 b){return AW4(ASW4(a)>>ASW4(b));} 1384 #endif 1385 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1386 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1387 //_____________________________________________________________/\_______________________________________________________________ 1388 //============================================================================================================================== 1389 // HLSL DOUBLE 1390 //============================================================================================================================== 1391 #ifdef A_DUBL 1392 #ifdef A_HLSL_6_2 1393 #define AD1 float64_t 1394 #define AD2 float64_t2 1395 #define AD3 float64_t3 1396 #define AD4 float64_t4 1397 #else 1398 #define AD1 double 1399 #define AD2 double2 1400 #define AD3 double3 1401 #define AD4 double4 1402 #endif 1403 //------------------------------------------------------------------------------------------------------------------------------ 1404 AD1 AD1_x(AD1 a){return AD1(a);} 1405 AD2 AD2_x(AD1 a){return AD2(a,a);} 1406 AD3 AD3_x(AD1 a){return AD3(a,a,a);} 1407 AD4 AD4_x(AD1 a){return AD4(a,a,a,a);} 1408 #define AD1_(a) AD1_x(AD1(a)) 1409 #define AD2_(a) AD2_x(AD1(a)) 1410 #define AD3_(a) AD3_x(AD1(a)) 1411 #define AD4_(a) AD4_x(AD1(a)) 1412 //============================================================================================================================== 1413 AD1 AFractD1(AD1 a){return a-floor(a);} 1414 AD2 AFractD2(AD2 a){return a-floor(a);} 1415 AD3 AFractD3(AD3 a){return a-floor(a);} 1416 AD4 AFractD4(AD4 a){return a-floor(a);} 1417 //------------------------------------------------------------------------------------------------------------------------------ 1418 AD1 ALerpD1(AD1 x,AD1 y,AD1 a){return lerp(x,y,a);} 1419 AD2 ALerpD2(AD2 x,AD2 y,AD2 a){return lerp(x,y,a);} 1420 AD3 ALerpD3(AD3 x,AD3 y,AD3 a){return lerp(x,y,a);} 1421 AD4 ALerpD4(AD4 x,AD4 y,AD4 a){return lerp(x,y,a);} 1422 //------------------------------------------------------------------------------------------------------------------------------ 1423 AD1 ARcpD1(AD1 x){return rcp(x);} 1424 AD2 ARcpD2(AD2 x){return rcp(x);} 1425 AD3 ARcpD3(AD3 x){return rcp(x);} 1426 AD4 ARcpD4(AD4 x){return rcp(x);} 1427 //------------------------------------------------------------------------------------------------------------------------------ 1428 AD1 ARsqD1(AD1 x){return rsqrt(x);} 1429 AD2 ARsqD2(AD2 x){return rsqrt(x);} 1430 AD3 ARsqD3(AD3 x){return rsqrt(x);} 1431 AD4 ARsqD4(AD4 x){return rsqrt(x);} 1432 //------------------------------------------------------------------------------------------------------------------------------ 1433 AD1 ASatD1(AD1 x){return saturate(x);} 1434 AD2 ASatD2(AD2 x){return saturate(x);} 1435 AD3 ASatD3(AD3 x){return saturate(x);} 1436 AD4 ASatD4(AD4 x){return saturate(x);} 1437 #endif 1438 //============================================================================================================================== 1439 // HLSL WAVE 1440 //============================================================================================================================== 1441 #ifdef A_WAVE 1442 // Where 'x' must be a compile time literal. 1443 AF1 AWaveXorF1(AF1 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);} 1444 AF2 AWaveXorF2(AF2 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);} 1445 AF3 AWaveXorF3(AF3 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);} 1446 AF4 AWaveXorF4(AF4 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);} 1447 AU1 AWaveXorU1(AU1 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);} 1448 AU2 AWaveXorU1(AU2 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);} 1449 AU3 AWaveXorU1(AU3 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);} 1450 AU4 AWaveXorU1(AU4 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);} 1451 //------------------------------------------------------------------------------------------------------------------------------ 1452 #ifdef A_HALF 1453 AH2 AWaveXorH2(AH2 v,AU1 x){return AH2_AU1(WaveReadLaneAt(AU1_AH2(v),WaveGetLaneIndex()^x));} 1454 AH4 AWaveXorH4(AH4 v,AU1 x){return AH4_AU2(WaveReadLaneAt(AU2_AH4(v),WaveGetLaneIndex()^x));} 1455 AW2 AWaveXorW2(AW2 v,AU1 x){return AW2_AU1(WaveReadLaneAt(AU1_AW2(v),WaveGetLaneIndex()^x));} 1456 AW4 AWaveXorW4(AW4 v,AU1 x){return AW4_AU1(WaveReadLaneAt(AU1_AW4(v),WaveGetLaneIndex()^x));} 1457 #endif 1458 #endif 1459 //============================================================================================================================== 1460 #endif 1461 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1462 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1463 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1464 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1465 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1466 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1467 //_____________________________________________________________/\_______________________________________________________________ 1468 //============================================================================================================================== 1469 // 1470 // 1471 // GPU COMMON 1472 // 1473 // 1474 //============================================================================================================================== 1475 #ifdef A_GPU 1476 // Negative and positive infinity. 1477 #define A_INFP_F AF1_AU1(0x7f800000u) 1478 #define A_INFN_F AF1_AU1(0xff800000u) 1479 //------------------------------------------------------------------------------------------------------------------------------ 1480 // Copy sign from 's' to positive 'd'. 1481 AF1 ACpySgnF1(AF1 d,AF1 s){return AF1_AU1(AU1_AF1(d)|(AU1_AF1(s)&AU1_(0x80000000u)));} 1482 AF2 ACpySgnF2(AF2 d,AF2 s){return AF2_AU2(AU2_AF2(d)|(AU2_AF2(s)&AU2_(0x80000000u)));} 1483 AF3 ACpySgnF3(AF3 d,AF3 s){return AF3_AU3(AU3_AF3(d)|(AU3_AF3(s)&AU3_(0x80000000u)));} 1484 AF4 ACpySgnF4(AF4 d,AF4 s){return AF4_AU4(AU4_AF4(d)|(AU4_AF4(s)&AU4_(0x80000000u)));} 1485 //------------------------------------------------------------------------------------------------------------------------------ 1486 // Single operation to return (useful to create a mask to use in lerp for branch free logic), 1487 // m=NaN := 0 1488 // m>=0 := 0 1489 // m<0 := 1 1490 // Uses the following useful floating point logic, 1491 // saturate(+a*(-INF)==-INF) := 0 1492 // saturate( 0*(-INF)== NaN) := 0 1493 // saturate(-a*(-INF)==+INF) := 1 1494 AF1 ASignedF1(AF1 m){return ASatF1(m*AF1_(A_INFN_F));} 1495 AF2 ASignedF2(AF2 m){return ASatF2(m*AF2_(A_INFN_F));} 1496 AF3 ASignedF3(AF3 m){return ASatF3(m*AF3_(A_INFN_F));} 1497 AF4 ASignedF4(AF4 m){return ASatF4(m*AF4_(A_INFN_F));} 1498 //------------------------------------------------------------------------------------------------------------------------------ 1499 AF1 AGtZeroF1(AF1 m){return ASatF1(m*AF1_(A_INFP_F));} 1500 AF2 AGtZeroF2(AF2 m){return ASatF2(m*AF2_(A_INFP_F));} 1501 AF3 AGtZeroF3(AF3 m){return ASatF3(m*AF3_(A_INFP_F));} 1502 AF4 AGtZeroF4(AF4 m){return ASatF4(m*AF4_(A_INFP_F));} 1503 //============================================================================================================================== 1504 #ifdef A_HALF 1505 #ifdef A_HLSL_6_2 1506 #define A_INFP_H AH1_AW1((uint16_t)0x7c00u) 1507 #define A_INFN_H AH1_AW1((uint16_t)0xfc00u) 1508 #else 1509 #define A_INFP_H AH1_AW1(0x7c00u) 1510 #define A_INFN_H AH1_AW1(0xfc00u) 1511 #endif 1512 1513 //------------------------------------------------------------------------------------------------------------------------------ 1514 AH1 ACpySgnH1(AH1 d,AH1 s){return AH1_AW1(AW1_AH1(d)|(AW1_AH1(s)&AW1_(0x8000u)));} 1515 AH2 ACpySgnH2(AH2 d,AH2 s){return AH2_AW2(AW2_AH2(d)|(AW2_AH2(s)&AW2_(0x8000u)));} 1516 AH3 ACpySgnH3(AH3 d,AH3 s){return AH3_AW3(AW3_AH3(d)|(AW3_AH3(s)&AW3_(0x8000u)));} 1517 AH4 ACpySgnH4(AH4 d,AH4 s){return AH4_AW4(AW4_AH4(d)|(AW4_AH4(s)&AW4_(0x8000u)));} 1518 //------------------------------------------------------------------------------------------------------------------------------ 1519 AH1 ASignedH1(AH1 m){return ASatH1(m*AH1_(A_INFN_H));} 1520 AH2 ASignedH2(AH2 m){return ASatH2(m*AH2_(A_INFN_H));} 1521 AH3 ASignedH3(AH3 m){return ASatH3(m*AH3_(A_INFN_H));} 1522 AH4 ASignedH4(AH4 m){return ASatH4(m*AH4_(A_INFN_H));} 1523 //------------------------------------------------------------------------------------------------------------------------------ 1524 AH1 AGtZeroH1(AH1 m){return ASatH1(m*AH1_(A_INFP_H));} 1525 AH2 AGtZeroH2(AH2 m){return ASatH2(m*AH2_(A_INFP_H));} 1526 AH3 AGtZeroH3(AH3 m){return ASatH3(m*AH3_(A_INFP_H));} 1527 AH4 AGtZeroH4(AH4 m){return ASatH4(m*AH4_(A_INFP_H));} 1528 #endif 1529 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1530 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1531 //_____________________________________________________________/\_______________________________________________________________ 1532 //============================================================================================================================== 1533 // [FIS] FLOAT INTEGER SORTABLE 1534 //------------------------------------------------------------------------------------------------------------------------------ 1535 // Float to integer sortable. 1536 // - If sign bit=0, flip the sign bit (positives). 1537 // - If sign bit=1, flip all bits (negatives). 1538 // Integer sortable to float. 1539 // - If sign bit=1, flip the sign bit (positives). 1540 // - If sign bit=0, flip all bits (negatives). 1541 // Has nice side effects. 1542 // - Larger integers are more positive values. 1543 // - Float zero is mapped to center of integers (so clear to integer zero is a nice default for atomic max usage). 1544 // Burns 3 ops for conversion {shift,or,xor}. 1545 //============================================================================================================================== 1546 AU1 AFisToU1(AU1 x){return x^(( AShrSU1(x,AU1_(31)))|AU1_(0x80000000));} 1547 AU1 AFisFromU1(AU1 x){return x^((~AShrSU1(x,AU1_(31)))|AU1_(0x80000000));} 1548 //------------------------------------------------------------------------------------------------------------------------------ 1549 // Just adjust high 16-bit value (useful when upper part of 32-bit word is a 16-bit float value). 1550 AU1 AFisToHiU1(AU1 x){return x^(( AShrSU1(x,AU1_(15)))|AU1_(0x80000000));} 1551 AU1 AFisFromHiU1(AU1 x){return x^((~AShrSU1(x,AU1_(15)))|AU1_(0x80000000));} 1552 //------------------------------------------------------------------------------------------------------------------------------ 1553 #ifdef A_HALF 1554 AW1 AFisToW1(AW1 x){return x^(( AShrSW1(x,AW1_(15)))|AW1_(0x8000));} 1555 AW1 AFisFromW1(AW1 x){return x^((~AShrSW1(x,AW1_(15)))|AW1_(0x8000));} 1556 //------------------------------------------------------------------------------------------------------------------------------ 1557 AW2 AFisToW2(AW2 x){return x^(( AShrSW2(x,AW2_(15)))|AW2_(0x8000));} 1558 AW2 AFisFromW2(AW2 x){return x^((~AShrSW2(x,AW2_(15)))|AW2_(0x8000));} 1559 #endif 1560 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1561 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1562 //_____________________________________________________________/\_______________________________________________________________ 1563 //============================================================================================================================== 1564 // [PERM] V_PERM_B32 1565 //------------------------------------------------------------------------------------------------------------------------------ 1566 // Support for V_PERM_B32 started in the 3rd generation of GCN. 1567 //------------------------------------------------------------------------------------------------------------------------------ 1568 // yyyyxxxx - The 'i' input. 1569 // 76543210 1570 // ======== 1571 // HGFEDCBA - Naming on permutation. 1572 //------------------------------------------------------------------------------------------------------------------------------ 1573 // TODO 1574 // ==== 1575 // - Make sure compiler optimizes this. 1576 //============================================================================================================================== 1577 #ifdef A_HALF 1578 AU1 APerm0E0A(AU2 i){return((i.x )&0xffu)|((i.y<<16)&0xff0000u);} 1579 AU1 APerm0F0B(AU2 i){return((i.x>> 8)&0xffu)|((i.y<< 8)&0xff0000u);} 1580 AU1 APerm0G0C(AU2 i){return((i.x>>16)&0xffu)|((i.y )&0xff0000u);} 1581 AU1 APerm0H0D(AU2 i){return((i.x>>24)&0xffu)|((i.y>> 8)&0xff0000u);} 1582 //------------------------------------------------------------------------------------------------------------------------------ 1583 AU1 APermHGFA(AU2 i){return((i.x )&0x000000ffu)|(i.y&0xffffff00u);} 1584 AU1 APermHGFC(AU2 i){return((i.x>>16)&0x000000ffu)|(i.y&0xffffff00u);} 1585 AU1 APermHGAE(AU2 i){return((i.x<< 8)&0x0000ff00u)|(i.y&0xffff00ffu);} 1586 AU1 APermHGCE(AU2 i){return((i.x>> 8)&0x0000ff00u)|(i.y&0xffff00ffu);} 1587 AU1 APermHAFE(AU2 i){return((i.x<<16)&0x00ff0000u)|(i.y&0xff00ffffu);} 1588 AU1 APermHCFE(AU2 i){return((i.x )&0x00ff0000u)|(i.y&0xff00ffffu);} 1589 AU1 APermAGFE(AU2 i){return((i.x<<24)&0xff000000u)|(i.y&0x00ffffffu);} 1590 AU1 APermCGFE(AU2 i){return((i.x<< 8)&0xff000000u)|(i.y&0x00ffffffu);} 1591 //------------------------------------------------------------------------------------------------------------------------------ 1592 AU1 APermGCEA(AU2 i){return((i.x)&0x00ff00ffu)|((i.y<<8)&0xff00ff00u);} 1593 AU1 APermGECA(AU2 i){return(((i.x)&0xffu)|((i.x>>8)&0xff00u)|((i.y<<16)&0xff0000u)|((i.y<<8)&0xff000000u));} 1594 #endif 1595 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1596 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1597 //_____________________________________________________________/\_______________________________________________________________ 1598 //============================================================================================================================== 1599 // [BUC] BYTE UNSIGNED CONVERSION 1600 //------------------------------------------------------------------------------------------------------------------------------ 1601 // Designed to use the optimal conversion, enables the scaling to possibly be factored into other computation. 1602 // Works on a range of {0 to A_BUC_<32,16>}, for <32-bit, and 16-bit> respectively. 1603 //------------------------------------------------------------------------------------------------------------------------------ 1604 // OPCODE NOTES 1605 // ============ 1606 // GCN does not do UNORM or SNORM for bytes in opcodes. 1607 // - V_CVT_F32_UBYTE{0,1,2,3} - Unsigned byte to float. 1608 // - V_CVT_PKACC_U8_F32 - Float to unsigned byte (does bit-field insert into 32-bit integer). 1609 // V_PERM_B32 does byte packing with ability to zero fill bytes as well. 1610 // - Can pull out byte values from two sources, and zero fill upper 8-bits of packed hi and lo. 1611 //------------------------------------------------------------------------------------------------------------------------------ 1612 // BYTE : FLOAT - ABuc{0,1,2,3}{To,From}U1() - Designed for V_CVT_F32_UBYTE* and V_CVT_PKACCUM_U8_F32 ops. 1613 // ==== ===== 1614 // 0 : 0 1615 // 1 : 1 1616 // ... 1617 // 255 : 255 1618 // : 256 (just outside the encoding range) 1619 //------------------------------------------------------------------------------------------------------------------------------ 1620 // BYTE : FLOAT - ABuc{0,1,2,3}{To,From}U2() - Designed for 16-bit denormal tricks and V_PERM_B32. 1621 // ==== ===== 1622 // 0 : 0 1623 // 1 : 1/512 1624 // 2 : 1/256 1625 // ... 1626 // 64 : 1/8 1627 // 128 : 1/4 1628 // 255 : 255/512 1629 // : 1/2 (just outside the encoding range) 1630 //------------------------------------------------------------------------------------------------------------------------------ 1631 // OPTIMAL IMPLEMENTATIONS ON AMD ARCHITECTURES 1632 // ============================================ 1633 // r=ABuc0FromU1(i) 1634 // V_CVT_F32_UBYTE0 r,i 1635 // -------------------------------------------- 1636 // r=ABuc0ToU1(d,i) 1637 // V_CVT_PKACCUM_U8_F32 r,i,0,d 1638 // -------------------------------------------- 1639 // d=ABuc0FromU2(i) 1640 // Where 'k0' is an SGPR with 0x0E0A 1641 // Where 'k1' is an SGPR with {32768.0} packed into the lower 16-bits 1642 // V_PERM_B32 d,i.x,i.y,k0 1643 // V_PK_FMA_F16 d,d,k1.x,0 1644 // -------------------------------------------- 1645 // r=ABuc0ToU2(d,i) 1646 // Where 'k0' is an SGPR with {1.0/32768.0} packed into the lower 16-bits 1647 // Where 'k1' is an SGPR with 0x???? 1648 // Where 'k2' is an SGPR with 0x???? 1649 // V_PK_FMA_F16 i,i,k0.x,0 1650 // V_PERM_B32 r.x,i,i,k1 1651 // V_PERM_B32 r.y,i,i,k2 1652 //============================================================================================================================== 1653 // Peak range for 32-bit and 16-bit operations. 1654 #define A_BUC_32 (255.0) 1655 #define A_BUC_16 (255.0/512.0) 1656 //============================================================================================================================== 1657 #if 1 1658 // Designed to be one V_CVT_PKACCUM_U8_F32. 1659 // The extra min is required to pattern match to V_CVT_PKACCUM_U8_F32. 1660 AU1 ABuc0ToU1(AU1 d,AF1 i){return (d&0xffffff00u)|((min(AU1(i),255u) )&(0x000000ffu));} 1661 AU1 ABuc1ToU1(AU1 d,AF1 i){return (d&0xffff00ffu)|((min(AU1(i),255u)<< 8)&(0x0000ff00u));} 1662 AU1 ABuc2ToU1(AU1 d,AF1 i){return (d&0xff00ffffu)|((min(AU1(i),255u)<<16)&(0x00ff0000u));} 1663 AU1 ABuc3ToU1(AU1 d,AF1 i){return (d&0x00ffffffu)|((min(AU1(i),255u)<<24)&(0xff000000u));} 1664 //------------------------------------------------------------------------------------------------------------------------------ 1665 // Designed to be one V_CVT_F32_UBYTE*. 1666 AF1 ABuc0FromU1(AU1 i){return AF1((i )&255u);} 1667 AF1 ABuc1FromU1(AU1 i){return AF1((i>> 8)&255u);} 1668 AF1 ABuc2FromU1(AU1 i){return AF1((i>>16)&255u);} 1669 AF1 ABuc3FromU1(AU1 i){return AF1((i>>24)&255u);} 1670 #endif 1671 //============================================================================================================================== 1672 #ifdef A_HALF 1673 // Takes {x0,x1} and {y0,y1} and builds {{x0,y0},{x1,y1}}. 1674 AW2 ABuc01ToW2(AH2 x,AH2 y){x*=AH2_(1.0/32768.0);y*=AH2_(1.0/32768.0); 1675 return AW2_AU1(APermGCEA(AU2(AU1_AW2(AW2_AH2(x)),AU1_AW2(AW2_AH2(y)))));} 1676 //------------------------------------------------------------------------------------------------------------------------------ 1677 // Designed for 3 ops to do SOA to AOS and conversion. 1678 AU2 ABuc0ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0))); 1679 return AU2(APermHGFA(AU2(d.x,b)),APermHGFC(AU2(d.y,b)));} 1680 AU2 ABuc1ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0))); 1681 return AU2(APermHGAE(AU2(d.x,b)),APermHGCE(AU2(d.y,b)));} 1682 AU2 ABuc2ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0))); 1683 return AU2(APermHAFE(AU2(d.x,b)),APermHCFE(AU2(d.y,b)));} 1684 AU2 ABuc3ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0))); 1685 return AU2(APermAGFE(AU2(d.x,b)),APermCGFE(AU2(d.y,b)));} 1686 //------------------------------------------------------------------------------------------------------------------------------ 1687 // Designed for 2 ops to do both AOS to SOA, and conversion. 1688 AH2 ABuc0FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0E0A(i)))*AH2_(32768.0);} 1689 AH2 ABuc1FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0F0B(i)))*AH2_(32768.0);} 1690 AH2 ABuc2FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0G0C(i)))*AH2_(32768.0);} 1691 AH2 ABuc3FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0H0D(i)))*AH2_(32768.0);} 1692 #endif 1693 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1694 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1695 //_____________________________________________________________/\_______________________________________________________________ 1696 //============================================================================================================================== 1697 // [BSC] BYTE SIGNED CONVERSION 1698 //------------------------------------------------------------------------------------------------------------------------------ 1699 // Similar to [BUC]. 1700 // Works on a range of {-/+ A_BSC_<32,16>}, for <32-bit, and 16-bit> respectively. 1701 //------------------------------------------------------------------------------------------------------------------------------ 1702 // ENCODING (without zero-based encoding) 1703 // ======== 1704 // 0 = unused (can be used to mean something else) 1705 // 1 = lowest value 1706 // 128 = exact zero center (zero based encoding 1707 // 255 = highest value 1708 //------------------------------------------------------------------------------------------------------------------------------ 1709 // Zero-based [Zb] flips the MSB bit of the byte (making 128 "exact zero" actually zero). 1710 // This is useful if there is a desire for cleared values to decode as zero. 1711 //------------------------------------------------------------------------------------------------------------------------------ 1712 // BYTE : FLOAT - ABsc{0,1,2,3}{To,From}U2() - Designed for 16-bit denormal tricks and V_PERM_B32. 1713 // ==== ===== 1714 // 0 : -127/512 (unused) 1715 // 1 : -126/512 1716 // 2 : -125/512 1717 // ... 1718 // 128 : 0 1719 // ... 1720 // 255 : 127/512 1721 // : 1/4 (just outside the encoding range) 1722 //============================================================================================================================== 1723 // Peak range for 32-bit and 16-bit operations. 1724 #define A_BSC_32 (127.0) 1725 #define A_BSC_16 (127.0/512.0) 1726 //============================================================================================================================== 1727 #if 1 1728 AU1 ABsc0ToU1(AU1 d,AF1 i){return (d&0xffffff00u)|((min(AU1(i+128.0),255u) )&(0x000000ffu));} 1729 AU1 ABsc1ToU1(AU1 d,AF1 i){return (d&0xffff00ffu)|((min(AU1(i+128.0),255u)<< 8)&(0x0000ff00u));} 1730 AU1 ABsc2ToU1(AU1 d,AF1 i){return (d&0xff00ffffu)|((min(AU1(i+128.0),255u)<<16)&(0x00ff0000u));} 1731 AU1 ABsc3ToU1(AU1 d,AF1 i){return (d&0x00ffffffu)|((min(AU1(i+128.0),255u)<<24)&(0xff000000u));} 1732 //------------------------------------------------------------------------------------------------------------------------------ 1733 AU1 ABsc0ToZbU1(AU1 d,AF1 i){return ((d&0xffffff00u)|((min(AU1(trunc(i)+128.0),255u) )&(0x000000ffu)))^0x00000080u;} 1734 AU1 ABsc1ToZbU1(AU1 d,AF1 i){return ((d&0xffff00ffu)|((min(AU1(trunc(i)+128.0),255u)<< 8)&(0x0000ff00u)))^0x00008000u;} 1735 AU1 ABsc2ToZbU1(AU1 d,AF1 i){return ((d&0xff00ffffu)|((min(AU1(trunc(i)+128.0),255u)<<16)&(0x00ff0000u)))^0x00800000u;} 1736 AU1 ABsc3ToZbU1(AU1 d,AF1 i){return ((d&0x00ffffffu)|((min(AU1(trunc(i)+128.0),255u)<<24)&(0xff000000u)))^0x80000000u;} 1737 //------------------------------------------------------------------------------------------------------------------------------ 1738 AF1 ABsc0FromU1(AU1 i){return AF1((i )&255u)-128.0;} 1739 AF1 ABsc1FromU1(AU1 i){return AF1((i>> 8)&255u)-128.0;} 1740 AF1 ABsc2FromU1(AU1 i){return AF1((i>>16)&255u)-128.0;} 1741 AF1 ABsc3FromU1(AU1 i){return AF1((i>>24)&255u)-128.0;} 1742 //------------------------------------------------------------------------------------------------------------------------------ 1743 AF1 ABsc0FromZbU1(AU1 i){return AF1(((i )&255u)^0x80u)-128.0;} 1744 AF1 ABsc1FromZbU1(AU1 i){return AF1(((i>> 8)&255u)^0x80u)-128.0;} 1745 AF1 ABsc2FromZbU1(AU1 i){return AF1(((i>>16)&255u)^0x80u)-128.0;} 1746 AF1 ABsc3FromZbU1(AU1 i){return AF1(((i>>24)&255u)^0x80u)-128.0;} 1747 #endif 1748 //============================================================================================================================== 1749 #ifdef A_HALF 1750 // Takes {x0,x1} and {y0,y1} and builds {{x0,y0},{x1,y1}}. 1751 AW2 ABsc01ToW2(AH2 x,AH2 y){x=x*AH2_(1.0/32768.0)+AH2_(0.25/32768.0);y=y*AH2_(1.0/32768.0)+AH2_(0.25/32768.0); 1752 return AW2_AU1(APermGCEA(AU2(AU1_AW2(AW2_AH2(x)),AU1_AW2(AW2_AH2(y)))));} 1753 //------------------------------------------------------------------------------------------------------------------------------ 1754 AU2 ABsc0ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0))); 1755 return AU2(APermHGFA(AU2(d.x,b)),APermHGFC(AU2(d.y,b)));} 1756 AU2 ABsc1ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0))); 1757 return AU2(APermHGAE(AU2(d.x,b)),APermHGCE(AU2(d.y,b)));} 1758 AU2 ABsc2ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0))); 1759 return AU2(APermHAFE(AU2(d.x,b)),APermHCFE(AU2(d.y,b)));} 1760 AU2 ABsc3ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0))); 1761 return AU2(APermAGFE(AU2(d.x,b)),APermCGFE(AU2(d.y,b)));} 1762 //------------------------------------------------------------------------------------------------------------------------------ 1763 AU2 ABsc0ToZbU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)))^0x00800080u; 1764 return AU2(APermHGFA(AU2(d.x,b)),APermHGFC(AU2(d.y,b)));} 1765 AU2 ABsc1ToZbU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)))^0x00800080u; 1766 return AU2(APermHGAE(AU2(d.x,b)),APermHGCE(AU2(d.y,b)));} 1767 AU2 ABsc2ToZbU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)))^0x00800080u; 1768 return AU2(APermHAFE(AU2(d.x,b)),APermHCFE(AU2(d.y,b)));} 1769 AU2 ABsc3ToZbU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)))^0x00800080u; 1770 return AU2(APermAGFE(AU2(d.x,b)),APermCGFE(AU2(d.y,b)));} 1771 //------------------------------------------------------------------------------------------------------------------------------ 1772 AH2 ABsc0FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0E0A(i)))*AH2_(32768.0)-AH2_(0.25);} 1773 AH2 ABsc1FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0F0B(i)))*AH2_(32768.0)-AH2_(0.25);} 1774 AH2 ABsc2FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0G0C(i)))*AH2_(32768.0)-AH2_(0.25);} 1775 AH2 ABsc3FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0H0D(i)))*AH2_(32768.0)-AH2_(0.25);} 1776 //------------------------------------------------------------------------------------------------------------------------------ 1777 AH2 ABsc0FromZbU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0E0A(i)^0x00800080u))*AH2_(32768.0)-AH2_(0.25);} 1778 AH2 ABsc1FromZbU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0F0B(i)^0x00800080u))*AH2_(32768.0)-AH2_(0.25);} 1779 AH2 ABsc2FromZbU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0G0C(i)^0x00800080u))*AH2_(32768.0)-AH2_(0.25);} 1780 AH2 ABsc3FromZbU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0H0D(i)^0x00800080u))*AH2_(32768.0)-AH2_(0.25);} 1781 #endif 1782 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1783 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1784 //_____________________________________________________________/\_______________________________________________________________ 1785 //============================================================================================================================== 1786 // HALF APPROXIMATIONS 1787 //------------------------------------------------------------------------------------------------------------------------------ 1788 // These support only positive inputs. 1789 // Did not see value yet in specialization for range. 1790 // Using quick testing, ended up mostly getting the same "best" approximation for various ranges. 1791 // With hardware that can co-execute transcendentals, the value in approximations could be less than expected. 1792 // However from a latency perspective, if execution of a transcendental is 4 clk, with no packed support, -> 8 clk total. 1793 // And co-execution would require a compiler interleaving a lot of independent work for packed usage. 1794 //------------------------------------------------------------------------------------------------------------------------------ 1795 // The one Newton Raphson iteration form of rsq() was skipped (requires 6 ops total). 1796 // Same with sqrt(), as this could be x*rsq() (7 ops). 1797 //============================================================================================================================== 1798 #ifdef A_HALF 1799 // Minimize squared error across full positive range, 2 ops. 1800 // The 0x1de2 based approximation maps {0 to 1} input maps to < 1 output. 1801 AH1 APrxLoSqrtH1(AH1 a){return AH1_AW1((AW1_AH1(a)>>AW1_(1))+AW1_(0x1de2));} 1802 AH2 APrxLoSqrtH2(AH2 a){return AH2_AW2((AW2_AH2(a)>>AW2_(1))+AW2_(0x1de2));} 1803 AH3 APrxLoSqrtH3(AH3 a){return AH3_AW3((AW3_AH3(a)>>AW3_(1))+AW3_(0x1de2));} 1804 AH4 APrxLoSqrtH4(AH4 a){return AH4_AW4((AW4_AH4(a)>>AW4_(1))+AW4_(0x1de2));} 1805 //------------------------------------------------------------------------------------------------------------------------------ 1806 // Lower precision estimation, 1 op. 1807 // Minimize squared error across {smallest normal to 16384.0}. 1808 AH1 APrxLoRcpH1(AH1 a){return AH1_AW1(AW1_(0x7784)-AW1_AH1(a));} 1809 AH2 APrxLoRcpH2(AH2 a){return AH2_AW2(AW2_(0x7784)-AW2_AH2(a));} 1810 AH3 APrxLoRcpH3(AH3 a){return AH3_AW3(AW3_(0x7784)-AW3_AH3(a));} 1811 AH4 APrxLoRcpH4(AH4 a){return AH4_AW4(AW4_(0x7784)-AW4_AH4(a));} 1812 //------------------------------------------------------------------------------------------------------------------------------ 1813 // Medium precision estimation, one Newton Raphson iteration, 3 ops. 1814 AH1 APrxMedRcpH1(AH1 a){AH1 b=AH1_AW1(AW1_(0x778d)-AW1_AH1(a));return b*(-b*a+AH1_(2.0));} 1815 AH2 APrxMedRcpH2(AH2 a){AH2 b=AH2_AW2(AW2_(0x778d)-AW2_AH2(a));return b*(-b*a+AH2_(2.0));} 1816 AH3 APrxMedRcpH3(AH3 a){AH3 b=AH3_AW3(AW3_(0x778d)-AW3_AH3(a));return b*(-b*a+AH3_(2.0));} 1817 AH4 APrxMedRcpH4(AH4 a){AH4 b=AH4_AW4(AW4_(0x778d)-AW4_AH4(a));return b*(-b*a+AH4_(2.0));} 1818 //------------------------------------------------------------------------------------------------------------------------------ 1819 // Minimize squared error across {smallest normal to 16384.0}, 2 ops. 1820 AH1 APrxLoRsqH1(AH1 a){return AH1_AW1(AW1_(0x59a3)-(AW1_AH1(a)>>AW1_(1)));} 1821 AH2 APrxLoRsqH2(AH2 a){return AH2_AW2(AW2_(0x59a3)-(AW2_AH2(a)>>AW2_(1)));} 1822 AH3 APrxLoRsqH3(AH3 a){return AH3_AW3(AW3_(0x59a3)-(AW3_AH3(a)>>AW3_(1)));} 1823 AH4 APrxLoRsqH4(AH4 a){return AH4_AW4(AW4_(0x59a3)-(AW4_AH4(a)>>AW4_(1)));} 1824 #endif 1825 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1826 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1827 //_____________________________________________________________/\_______________________________________________________________ 1828 //============================================================================================================================== 1829 // FLOAT APPROXIMATIONS 1830 //------------------------------------------------------------------------------------------------------------------------------ 1831 // Michal Drobot has an excellent presentation on these: "Low Level Optimizations For GCN", 1832 // - Idea dates back to SGI, then to Quake 3, etc. 1833 // - https://michaldrobot.files.wordpress.com/2014/05/gcn_alu_opt_digitaldragons2014.pdf 1834 // - sqrt(x)=rsqrt(x)*x 1835 // - rcp(x)=rsqrt(x)*rsqrt(x) for positive x 1836 // - https://github.com/michaldrobot/ShaderFastLibs/blob/master/ShaderFastMathLib.h 1837 //------------------------------------------------------------------------------------------------------------------------------ 1838 // These below are from perhaps less complete searching for optimal. 1839 // Used FP16 normal range for testing with +4096 32-bit step size for sampling error. 1840 // So these match up well with the half approximations. 1841 //============================================================================================================================== 1842 AF1 APrxLoSqrtF1(AF1 a){return AF1_AU1((AU1_AF1(a)>>AU1_(1))+AU1_(0x1fbc4639));} 1843 AF1 APrxLoRcpF1(AF1 a){return AF1_AU1(AU1_(0x7ef07ebb)-AU1_AF1(a));} 1844 AF1 APrxMedRcpF1(AF1 a){AF1 b=AF1_AU1(AU1_(0x7ef19fff)-AU1_AF1(a));return b*(-b*a+AF1_(2.0));} 1845 AF1 APrxLoRsqF1(AF1 a){return AF1_AU1(AU1_(0x5f347d74)-(AU1_AF1(a)>>AU1_(1)));} 1846 //------------------------------------------------------------------------------------------------------------------------------ 1847 AF2 APrxLoSqrtF2(AF2 a){return AF2_AU2((AU2_AF2(a)>>AU2_(1))+AU2_(0x1fbc4639));} 1848 AF2 APrxLoRcpF2(AF2 a){return AF2_AU2(AU2_(0x7ef07ebb)-AU2_AF2(a));} 1849 AF2 APrxMedRcpF2(AF2 a){AF2 b=AF2_AU2(AU2_(0x7ef19fff)-AU2_AF2(a));return b*(-b*a+AF2_(2.0));} 1850 AF2 APrxLoRsqF2(AF2 a){return AF2_AU2(AU2_(0x5f347d74)-(AU2_AF2(a)>>AU2_(1)));} 1851 //------------------------------------------------------------------------------------------------------------------------------ 1852 AF3 APrxLoSqrtF3(AF3 a){return AF3_AU3((AU3_AF3(a)>>AU3_(1))+AU3_(0x1fbc4639));} 1853 AF3 APrxLoRcpF3(AF3 a){return AF3_AU3(AU3_(0x7ef07ebb)-AU3_AF3(a));} 1854 AF3 APrxMedRcpF3(AF3 a){AF3 b=AF3_AU3(AU3_(0x7ef19fff)-AU3_AF3(a));return b*(-b*a+AF3_(2.0));} 1855 AF3 APrxLoRsqF3(AF3 a){return AF3_AU3(AU3_(0x5f347d74)-(AU3_AF3(a)>>AU3_(1)));} 1856 //------------------------------------------------------------------------------------------------------------------------------ 1857 AF4 APrxLoSqrtF4(AF4 a){return AF4_AU4((AU4_AF4(a)>>AU4_(1))+AU4_(0x1fbc4639));} 1858 AF4 APrxLoRcpF4(AF4 a){return AF4_AU4(AU4_(0x7ef07ebb)-AU4_AF4(a));} 1859 AF4 APrxMedRcpF4(AF4 a){AF4 b=AF4_AU4(AU4_(0x7ef19fff)-AU4_AF4(a));return b*(-b*a+AF4_(2.0));} 1860 AF4 APrxLoRsqF4(AF4 a){return AF4_AU4(AU4_(0x5f347d74)-(AU4_AF4(a)>>AU4_(1)));} 1861 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1862 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1863 //_____________________________________________________________/\_______________________________________________________________ 1864 //============================================================================================================================== 1865 // PQ APPROXIMATIONS 1866 //------------------------------------------------------------------------------------------------------------------------------ 1867 // PQ is very close to x^(1/8). The functions below Use the fast float approximation method to do 1868 // PQ<~>Gamma2 (4th power and fast 4th root) and PQ<~>Linear (8th power and fast 8th root). Maximum error is ~0.2%. 1869 //============================================================================================================================== 1870 // Helpers 1871 AF1 Quart(AF1 a) { a = a * a; return a * a;} 1872 AF1 Oct(AF1 a) { a = a * a; a = a * a; return a * a; } 1873 AF2 Quart(AF2 a) { a = a * a; return a * a; } 1874 AF2 Oct(AF2 a) { a = a * a; a = a * a; return a * a; } 1875 AF3 Quart(AF3 a) { a = a * a; return a * a; } 1876 AF3 Oct(AF3 a) { a = a * a; a = a * a; return a * a; } 1877 AF4 Quart(AF4 a) { a = a * a; return a * a; } 1878 AF4 Oct(AF4 a) { a = a * a; a = a * a; return a * a; } 1879 //------------------------------------------------------------------------------------------------------------------------------ 1880 AF1 APrxPQToGamma2(AF1 a) { return Quart(a); } 1881 AF1 APrxPQToLinear(AF1 a) { return Oct(a); } 1882 AF1 APrxLoGamma2ToPQ(AF1 a) { return AF1_AU1((AU1_AF1(a) >> AU1_(2)) + AU1_(0x2F9A4E46)); } 1883 AF1 APrxMedGamma2ToPQ(AF1 a) { AF1 b = AF1_AU1((AU1_AF1(a) >> AU1_(2)) + AU1_(0x2F9A4E46)); AF1 b4 = Quart(b); return b - b * (b4 - a) / (AF1_(4.0) * b4); } 1884 AF1 APrxHighGamma2ToPQ(AF1 a) { return sqrt(sqrt(a)); } 1885 AF1 APrxLoLinearToPQ(AF1 a) { return AF1_AU1((AU1_AF1(a) >> AU1_(3)) + AU1_(0x378D8723)); } 1886 AF1 APrxMedLinearToPQ(AF1 a) { AF1 b = AF1_AU1((AU1_AF1(a) >> AU1_(3)) + AU1_(0x378D8723)); AF1 b8 = Oct(b); return b - b * (b8 - a) / (AF1_(8.0) * b8); } 1887 AF1 APrxHighLinearToPQ(AF1 a) { return sqrt(sqrt(sqrt(a))); } 1888 //------------------------------------------------------------------------------------------------------------------------------ 1889 AF2 APrxPQToGamma2(AF2 a) { return Quart(a); } 1890 AF2 APrxPQToLinear(AF2 a) { return Oct(a); } 1891 AF2 APrxLoGamma2ToPQ(AF2 a) { return AF2_AU2((AU2_AF2(a) >> AU2_(2)) + AU2_(0x2F9A4E46)); } 1892 AF2 APrxMedGamma2ToPQ(AF2 a) { AF2 b = AF2_AU2((AU2_AF2(a) >> AU2_(2)) + AU2_(0x2F9A4E46)); AF2 b4 = Quart(b); return b - b * (b4 - a) / (AF1_(4.0) * b4); } 1893 AF2 APrxHighGamma2ToPQ(AF2 a) { return sqrt(sqrt(a)); } 1894 AF2 APrxLoLinearToPQ(AF2 a) { return AF2_AU2((AU2_AF2(a) >> AU2_(3)) + AU2_(0x378D8723)); } 1895 AF2 APrxMedLinearToPQ(AF2 a) { AF2 b = AF2_AU2((AU2_AF2(a) >> AU2_(3)) + AU2_(0x378D8723)); AF2 b8 = Oct(b); return b - b * (b8 - a) / (AF1_(8.0) * b8); } 1896 AF2 APrxHighLinearToPQ(AF2 a) { return sqrt(sqrt(sqrt(a))); } 1897 //------------------------------------------------------------------------------------------------------------------------------ 1898 AF3 APrxPQToGamma2(AF3 a) { return Quart(a); } 1899 AF3 APrxPQToLinear(AF3 a) { return Oct(a); } 1900 AF3 APrxLoGamma2ToPQ(AF3 a) { return AF3_AU3((AU3_AF3(a) >> AU3_(2)) + AU3_(0x2F9A4E46)); } 1901 AF3 APrxMedGamma2ToPQ(AF3 a) { AF3 b = AF3_AU3((AU3_AF3(a) >> AU3_(2)) + AU3_(0x2F9A4E46)); AF3 b4 = Quart(b); return b - b * (b4 - a) / (AF1_(4.0) * b4); } 1902 AF3 APrxHighGamma2ToPQ(AF3 a) { return sqrt(sqrt(a)); } 1903 AF3 APrxLoLinearToPQ(AF3 a) { return AF3_AU3((AU3_AF3(a) >> AU3_(3)) + AU3_(0x378D8723)); } 1904 AF3 APrxMedLinearToPQ(AF3 a) { AF3 b = AF3_AU3((AU3_AF3(a) >> AU3_(3)) + AU3_(0x378D8723)); AF3 b8 = Oct(b); return b - b * (b8 - a) / (AF1_(8.0) * b8); } 1905 AF3 APrxHighLinearToPQ(AF3 a) { return sqrt(sqrt(sqrt(a))); } 1906 //------------------------------------------------------------------------------------------------------------------------------ 1907 AF4 APrxPQToGamma2(AF4 a) { return Quart(a); } 1908 AF4 APrxPQToLinear(AF4 a) { return Oct(a); } 1909 AF4 APrxLoGamma2ToPQ(AF4 a) { return AF4_AU4((AU4_AF4(a) >> AU4_(2)) + AU4_(0x2F9A4E46)); } 1910 AF4 APrxMedGamma2ToPQ(AF4 a) { AF4 b = AF4_AU4((AU4_AF4(a) >> AU4_(2)) + AU4_(0x2F9A4E46)); AF4 b4 = Quart(b); return b - b * (b4 - a) / (AF1_(4.0) * b4); } 1911 AF4 APrxHighGamma2ToPQ(AF4 a) { return sqrt(sqrt(a)); } 1912 AF4 APrxLoLinearToPQ(AF4 a) { return AF4_AU4((AU4_AF4(a) >> AU4_(3)) + AU4_(0x378D8723)); } 1913 AF4 APrxMedLinearToPQ(AF4 a) { AF4 b = AF4_AU4((AU4_AF4(a) >> AU4_(3)) + AU4_(0x378D8723)); AF4 b8 = Oct(b); return b - b * (b8 - a) / (AF1_(8.0) * b8); } 1914 AF4 APrxHighLinearToPQ(AF4 a) { return sqrt(sqrt(sqrt(a))); } 1915 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1916 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1917 //_____________________________________________________________/\_______________________________________________________________ 1918 //============================================================================================================================== 1919 // PARABOLIC SIN & COS 1920 //------------------------------------------------------------------------------------------------------------------------------ 1921 // Approximate answers to transcendental questions. 1922 //------------------------------------------------------------------------------------------------------------------------------ 1923 //============================================================================================================================== 1924 #if 1 1925 // Valid input range is {-1 to 1} representing {0 to 2 pi}. 1926 // Output range is {-1/4 to 1/4} representing {-1 to 1}. 1927 AF1 APSinF1(AF1 x){return x*abs(x)-x;} // MAD. 1928 AF2 APSinF2(AF2 x){return x*abs(x)-x;} 1929 AF1 APCosF1(AF1 x){x=AFractF1(x*AF1_(0.5)+AF1_(0.75));x=x*AF1_(2.0)-AF1_(1.0);return APSinF1(x);} // 3x MAD, FRACT 1930 AF2 APCosF2(AF2 x){x=AFractF2(x*AF2_(0.5)+AF2_(0.75));x=x*AF2_(2.0)-AF2_(1.0);return APSinF2(x);} 1931 AF2 APSinCosF1(AF1 x){AF1 y=AFractF1(x*AF1_(0.5)+AF1_(0.75));y=y*AF1_(2.0)-AF1_(1.0);return APSinF2(AF2(x,y));} 1932 #endif 1933 //------------------------------------------------------------------------------------------------------------------------------ 1934 #ifdef A_HALF 1935 // For a packed {sin,cos} pair, 1936 // - Native takes 16 clocks and 4 issue slots (no packed transcendentals). 1937 // - Parabolic takes 8 clocks and 8 issue slots (only fract is non-packed). 1938 AH1 APSinH1(AH1 x){return x*abs(x)-x;} 1939 AH2 APSinH2(AH2 x){return x*abs(x)-x;} // AND,FMA 1940 AH1 APCosH1(AH1 x){x=AFractH1(x*AH1_(0.5)+AH1_(0.75));x=x*AH1_(2.0)-AH1_(1.0);return APSinH1(x);} 1941 AH2 APCosH2(AH2 x){x=AFractH2(x*AH2_(0.5)+AH2_(0.75));x=x*AH2_(2.0)-AH2_(1.0);return APSinH2(x);} // 3x FMA, 2xFRACT, AND 1942 AH2 APSinCosH1(AH1 x){AH1 y=AFractH1(x*AH1_(0.5)+AH1_(0.75));y=y*AH1_(2.0)-AH1_(1.0);return APSinH2(AH2(x,y));} 1943 #endif 1944 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1945 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1946 //_____________________________________________________________/\_______________________________________________________________ 1947 //============================================================================================================================== 1948 // [ZOL] ZERO ONE LOGIC 1949 //------------------------------------------------------------------------------------------------------------------------------ 1950 // Conditional free logic designed for easy 16-bit packing, and backwards porting to 32-bit. 1951 //------------------------------------------------------------------------------------------------------------------------------ 1952 // 0 := false 1953 // 1 := true 1954 //------------------------------------------------------------------------------------------------------------------------------ 1955 // AndNot(x,y) -> !(x&y) .... One op. 1956 // AndOr(x,y,z) -> (x&y)|z ... One op. 1957 // GtZero(x) -> x>0.0 ..... One op. 1958 // Sel(x,y,z) -> x?y:z ..... Two ops, has no precision loss. 1959 // Signed(x) -> x<0.0 ..... One op. 1960 // ZeroPass(x,y) -> x?0:y ..... Two ops, 'y' is a pass through safe for aliasing as integer. 1961 //------------------------------------------------------------------------------------------------------------------------------ 1962 // OPTIMIZATION NOTES 1963 // ================== 1964 // - On Vega to use 2 constants in a packed op, pass in as one AW2 or one AH2 'k.xy' and use as 'k.xx' and 'k.yy'. 1965 // For example 'a.xy*k.xx+k.yy'. 1966 //============================================================================================================================== 1967 #if 1 1968 AU1 AZolAndU1(AU1 x,AU1 y){return min(x,y);} 1969 AU2 AZolAndU2(AU2 x,AU2 y){return min(x,y);} 1970 AU3 AZolAndU3(AU3 x,AU3 y){return min(x,y);} 1971 AU4 AZolAndU4(AU4 x,AU4 y){return min(x,y);} 1972 //------------------------------------------------------------------------------------------------------------------------------ 1973 AU1 AZolNotU1(AU1 x){return x^AU1_(1);} 1974 AU2 AZolNotU2(AU2 x){return x^AU2_(1);} 1975 AU3 AZolNotU3(AU3 x){return x^AU3_(1);} 1976 AU4 AZolNotU4(AU4 x){return x^AU4_(1);} 1977 //------------------------------------------------------------------------------------------------------------------------------ 1978 AU1 AZolOrU1(AU1 x,AU1 y){return max(x,y);} 1979 AU2 AZolOrU2(AU2 x,AU2 y){return max(x,y);} 1980 AU3 AZolOrU3(AU3 x,AU3 y){return max(x,y);} 1981 AU4 AZolOrU4(AU4 x,AU4 y){return max(x,y);} 1982 //============================================================================================================================== 1983 AU1 AZolF1ToU1(AF1 x){return AU1(x);} 1984 AU2 AZolF2ToU2(AF2 x){return AU2(x);} 1985 AU3 AZolF3ToU3(AF3 x){return AU3(x);} 1986 AU4 AZolF4ToU4(AF4 x){return AU4(x);} 1987 //------------------------------------------------------------------------------------------------------------------------------ 1988 // 2 ops, denormals don't work in 32-bit on PC (and if they are enabled, OMOD is disabled). 1989 AU1 AZolNotF1ToU1(AF1 x){return AU1(AF1_(1.0)-x);} 1990 AU2 AZolNotF2ToU2(AF2 x){return AU2(AF2_(1.0)-x);} 1991 AU3 AZolNotF3ToU3(AF3 x){return AU3(AF3_(1.0)-x);} 1992 AU4 AZolNotF4ToU4(AF4 x){return AU4(AF4_(1.0)-x);} 1993 //------------------------------------------------------------------------------------------------------------------------------ 1994 AF1 AZolU1ToF1(AU1 x){return AF1(x);} 1995 AF2 AZolU2ToF2(AU2 x){return AF2(x);} 1996 AF3 AZolU3ToF3(AU3 x){return AF3(x);} 1997 AF4 AZolU4ToF4(AU4 x){return AF4(x);} 1998 //============================================================================================================================== 1999 AF1 AZolAndF1(AF1 x,AF1 y){return min(x,y);} 2000 AF2 AZolAndF2(AF2 x,AF2 y){return min(x,y);} 2001 AF3 AZolAndF3(AF3 x,AF3 y){return min(x,y);} 2002 AF4 AZolAndF4(AF4 x,AF4 y){return min(x,y);} 2003 //------------------------------------------------------------------------------------------------------------------------------ 2004 AF1 ASolAndNotF1(AF1 x,AF1 y){return (-x)*y+AF1_(1.0);} 2005 AF2 ASolAndNotF2(AF2 x,AF2 y){return (-x)*y+AF2_(1.0);} 2006 AF3 ASolAndNotF3(AF3 x,AF3 y){return (-x)*y+AF3_(1.0);} 2007 AF4 ASolAndNotF4(AF4 x,AF4 y){return (-x)*y+AF4_(1.0);} 2008 //------------------------------------------------------------------------------------------------------------------------------ 2009 AF1 AZolAndOrF1(AF1 x,AF1 y,AF1 z){return ASatF1(x*y+z);} 2010 AF2 AZolAndOrF2(AF2 x,AF2 y,AF2 z){return ASatF2(x*y+z);} 2011 AF3 AZolAndOrF3(AF3 x,AF3 y,AF3 z){return ASatF3(x*y+z);} 2012 AF4 AZolAndOrF4(AF4 x,AF4 y,AF4 z){return ASatF4(x*y+z);} 2013 //------------------------------------------------------------------------------------------------------------------------------ 2014 AF1 AZolGtZeroF1(AF1 x){return ASatF1(x*AF1_(A_INFP_F));} 2015 AF2 AZolGtZeroF2(AF2 x){return ASatF2(x*AF2_(A_INFP_F));} 2016 AF3 AZolGtZeroF3(AF3 x){return ASatF3(x*AF3_(A_INFP_F));} 2017 AF4 AZolGtZeroF4(AF4 x){return ASatF4(x*AF4_(A_INFP_F));} 2018 //------------------------------------------------------------------------------------------------------------------------------ 2019 AF1 AZolNotF1(AF1 x){return AF1_(1.0)-x;} 2020 AF2 AZolNotF2(AF2 x){return AF2_(1.0)-x;} 2021 AF3 AZolNotF3(AF3 x){return AF3_(1.0)-x;} 2022 AF4 AZolNotF4(AF4 x){return AF4_(1.0)-x;} 2023 //------------------------------------------------------------------------------------------------------------------------------ 2024 AF1 AZolOrF1(AF1 x,AF1 y){return max(x,y);} 2025 AF2 AZolOrF2(AF2 x,AF2 y){return max(x,y);} 2026 AF3 AZolOrF3(AF3 x,AF3 y){return max(x,y);} 2027 AF4 AZolOrF4(AF4 x,AF4 y){return max(x,y);} 2028 //------------------------------------------------------------------------------------------------------------------------------ 2029 AF1 AZolSelF1(AF1 x,AF1 y,AF1 z){AF1 r=(-x)*z+z;return x*y+r;} 2030 AF2 AZolSelF2(AF2 x,AF2 y,AF2 z){AF2 r=(-x)*z+z;return x*y+r;} 2031 AF3 AZolSelF3(AF3 x,AF3 y,AF3 z){AF3 r=(-x)*z+z;return x*y+r;} 2032 AF4 AZolSelF4(AF4 x,AF4 y,AF4 z){AF4 r=(-x)*z+z;return x*y+r;} 2033 //------------------------------------------------------------------------------------------------------------------------------ 2034 AF1 AZolSignedF1(AF1 x){return ASatF1(x*AF1_(A_INFN_F));} 2035 AF2 AZolSignedF2(AF2 x){return ASatF2(x*AF2_(A_INFN_F));} 2036 AF3 AZolSignedF3(AF3 x){return ASatF3(x*AF3_(A_INFN_F));} 2037 AF4 AZolSignedF4(AF4 x){return ASatF4(x*AF4_(A_INFN_F));} 2038 //------------------------------------------------------------------------------------------------------------------------------ 2039 AF1 AZolZeroPassF1(AF1 x,AF1 y){return AF1_AU1((AU1_AF1(x)!=AU1_(0))?AU1_(0):AU1_AF1(y));} 2040 AF2 AZolZeroPassF2(AF2 x,AF2 y){return AF2_AU2((AU2_AF2(x)!=AU2_(0))?AU2_(0):AU2_AF2(y));} 2041 AF3 AZolZeroPassF3(AF3 x,AF3 y){return AF3_AU3((AU3_AF3(x)!=AU3_(0))?AU3_(0):AU3_AF3(y));} 2042 AF4 AZolZeroPassF4(AF4 x,AF4 y){return AF4_AU4((AU4_AF4(x)!=AU4_(0))?AU4_(0):AU4_AF4(y));} 2043 #endif 2044 //============================================================================================================================== 2045 #ifdef A_HALF 2046 AW1 AZolAndW1(AW1 x,AW1 y){return min(x,y);} 2047 AW2 AZolAndW2(AW2 x,AW2 y){return min(x,y);} 2048 AW3 AZolAndW3(AW3 x,AW3 y){return min(x,y);} 2049 AW4 AZolAndW4(AW4 x,AW4 y){return min(x,y);} 2050 //------------------------------------------------------------------------------------------------------------------------------ 2051 AW1 AZolNotW1(AW1 x){return x^AW1_(1);} 2052 AW2 AZolNotW2(AW2 x){return x^AW2_(1);} 2053 AW3 AZolNotW3(AW3 x){return x^AW3_(1);} 2054 AW4 AZolNotW4(AW4 x){return x^AW4_(1);} 2055 //------------------------------------------------------------------------------------------------------------------------------ 2056 AW1 AZolOrW1(AW1 x,AW1 y){return max(x,y);} 2057 AW2 AZolOrW2(AW2 x,AW2 y){return max(x,y);} 2058 AW3 AZolOrW3(AW3 x,AW3 y){return max(x,y);} 2059 AW4 AZolOrW4(AW4 x,AW4 y){return max(x,y);} 2060 //============================================================================================================================== 2061 // Uses denormal trick. 2062 AW1 AZolH1ToW1(AH1 x){return AW1_AH1(x*AH1_AW1(AW1_(1)));} 2063 AW2 AZolH2ToW2(AH2 x){return AW2_AH2(x*AH2_AW2(AW2_(1)));} 2064 AW3 AZolH3ToW3(AH3 x){return AW3_AH3(x*AH3_AW3(AW3_(1)));} 2065 AW4 AZolH4ToW4(AH4 x){return AW4_AH4(x*AH4_AW4(AW4_(1)));} 2066 //------------------------------------------------------------------------------------------------------------------------------ 2067 // AMD arch lacks a packed conversion opcode. 2068 AH1 AZolW1ToH1(AW1 x){return AH1_AW1(x*AW1_AH1(AH1_(1.0)));} 2069 AH2 AZolW2ToH2(AW2 x){return AH2_AW2(x*AW2_AH2(AH2_(1.0)));} 2070 AH3 AZolW1ToH3(AW3 x){return AH3_AW3(x*AW3_AH3(AH3_(1.0)));} 2071 AH4 AZolW2ToH4(AW4 x){return AH4_AW4(x*AW4_AH4(AH4_(1.0)));} 2072 //============================================================================================================================== 2073 AH1 AZolAndH1(AH1 x,AH1 y){return min(x,y);} 2074 AH2 AZolAndH2(AH2 x,AH2 y){return min(x,y);} 2075 AH3 AZolAndH3(AH3 x,AH3 y){return min(x,y);} 2076 AH4 AZolAndH4(AH4 x,AH4 y){return min(x,y);} 2077 //------------------------------------------------------------------------------------------------------------------------------ 2078 AH1 ASolAndNotH1(AH1 x,AH1 y){return (-x)*y+AH1_(1.0);} 2079 AH2 ASolAndNotH2(AH2 x,AH2 y){return (-x)*y+AH2_(1.0);} 2080 AH3 ASolAndNotH3(AH3 x,AH3 y){return (-x)*y+AH3_(1.0);} 2081 AH4 ASolAndNotH4(AH4 x,AH4 y){return (-x)*y+AH4_(1.0);} 2082 //------------------------------------------------------------------------------------------------------------------------------ 2083 AH1 AZolAndOrH1(AH1 x,AH1 y,AH1 z){return ASatH1(x*y+z);} 2084 AH2 AZolAndOrH2(AH2 x,AH2 y,AH2 z){return ASatH2(x*y+z);} 2085 AH3 AZolAndOrH3(AH3 x,AH3 y,AH3 z){return ASatH3(x*y+z);} 2086 AH4 AZolAndOrH4(AH4 x,AH4 y,AH4 z){return ASatH4(x*y+z);} 2087 //------------------------------------------------------------------------------------------------------------------------------ 2088 AH1 AZolGtZeroH1(AH1 x){return ASatH1(x*AH1_(A_INFP_H));} 2089 AH2 AZolGtZeroH2(AH2 x){return ASatH2(x*AH2_(A_INFP_H));} 2090 AH3 AZolGtZeroH3(AH3 x){return ASatH3(x*AH3_(A_INFP_H));} 2091 AH4 AZolGtZeroH4(AH4 x){return ASatH4(x*AH4_(A_INFP_H));} 2092 //------------------------------------------------------------------------------------------------------------------------------ 2093 AH1 AZolNotH1(AH1 x){return AH1_(1.0)-x;} 2094 AH2 AZolNotH2(AH2 x){return AH2_(1.0)-x;} 2095 AH3 AZolNotH3(AH3 x){return AH3_(1.0)-x;} 2096 AH4 AZolNotH4(AH4 x){return AH4_(1.0)-x;} 2097 //------------------------------------------------------------------------------------------------------------------------------ 2098 AH1 AZolOrH1(AH1 x,AH1 y){return max(x,y);} 2099 AH2 AZolOrH2(AH2 x,AH2 y){return max(x,y);} 2100 AH3 AZolOrH3(AH3 x,AH3 y){return max(x,y);} 2101 AH4 AZolOrH4(AH4 x,AH4 y){return max(x,y);} 2102 //------------------------------------------------------------------------------------------------------------------------------ 2103 AH1 AZolSelH1(AH1 x,AH1 y,AH1 z){AH1 r=(-x)*z+z;return x*y+r;} 2104 AH2 AZolSelH2(AH2 x,AH2 y,AH2 z){AH2 r=(-x)*z+z;return x*y+r;} 2105 AH3 AZolSelH3(AH3 x,AH3 y,AH3 z){AH3 r=(-x)*z+z;return x*y+r;} 2106 AH4 AZolSelH4(AH4 x,AH4 y,AH4 z){AH4 r=(-x)*z+z;return x*y+r;} 2107 //------------------------------------------------------------------------------------------------------------------------------ 2108 AH1 AZolSignedH1(AH1 x){return ASatH1(x*AH1_(A_INFN_H));} 2109 AH2 AZolSignedH2(AH2 x){return ASatH2(x*AH2_(A_INFN_H));} 2110 AH3 AZolSignedH3(AH3 x){return ASatH3(x*AH3_(A_INFN_H));} 2111 AH4 AZolSignedH4(AH4 x){return ASatH4(x*AH4_(A_INFN_H));} 2112 #endif 2113 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2114 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2115 //_____________________________________________________________/\_______________________________________________________________ 2116 //============================================================================================================================== 2117 // COLOR CONVERSIONS 2118 //------------------------------------------------------------------------------------------------------------------------------ 2119 // These are all linear to/from some other space (where 'linear' has been shortened out of the function name). 2120 // So 'ToGamma' is 'LinearToGamma', and 'FromGamma' is 'LinearFromGamma'. 2121 // These are branch free implementations. 2122 // The AToSrgbF1() function is useful for stores for compute shaders for GPUs without hardware linear->sRGB store conversion. 2123 //------------------------------------------------------------------------------------------------------------------------------ 2124 // TRANSFER FUNCTIONS 2125 // ================== 2126 // 709 ..... Rec709 used for some HDTVs 2127 // Gamma ... Typically 2.2 for some PC displays, or 2.4-2.5 for CRTs, or 2.2 FreeSync2 native 2128 // Pq ...... PQ native for HDR10 2129 // Srgb .... The sRGB output, typical of PC displays, useful for 10-bit output, or storing to 8-bit UNORM without SRGB type 2130 // Two ..... Gamma 2.0, fastest conversion (useful for intermediate pass approximations) 2131 // Three ... Gamma 3.0, less fast, but good for HDR. 2132 //------------------------------------------------------------------------------------------------------------------------------ 2133 // KEEPING TO SPEC 2134 // =============== 2135 // Both Rec.709 and sRGB have a linear segment which as spec'ed would intersect the curved segment 2 times. 2136 // (a.) For 8-bit sRGB, steps {0 to 10.3} are in the linear region (4% of the encoding range). 2137 // (b.) For 8-bit 709, steps {0 to 20.7} are in the linear region (8% of the encoding range). 2138 // Also there is a slight step in the transition regions. 2139 // Precision of the coefficients in the spec being the likely cause. 2140 // Main usage case of the sRGB code is to do the linear->sRGB converstion in a compute shader before store. 2141 // This is to work around lack of hardware (typically only ROP does the conversion for free). 2142 // To "correct" the linear segment, would be to introduce error, because hardware decode of sRGB->linear is fixed (and free). 2143 // So this header keeps with the spec. 2144 // For linear->sRGB transforms, the linear segment in some respects reduces error, because rounding in that region is linear. 2145 // Rounding in the curved region in hardware (and fast software code) introduces error due to rounding in non-linear. 2146 //------------------------------------------------------------------------------------------------------------------------------ 2147 // FOR PQ 2148 // ====== 2149 // Both input and output is {0.0-1.0}, and where output 1.0 represents 10000.0 cd/m^2. 2150 // All constants are only specified to FP32 precision. 2151 // External PQ source reference, 2152 // - https://github.com/ampas/aces-dev/blob/master/transforms/ctl/utilities/ACESlib.Utilities_Color.a1.0.1.ctl 2153 //------------------------------------------------------------------------------------------------------------------------------ 2154 // PACKED VERSIONS 2155 // =============== 2156 // These are the A*H2() functions. 2157 // There is no PQ functions as FP16 seemed to not have enough precision for the conversion. 2158 // The remaining functions are "good enough" for 8-bit, and maybe 10-bit if not concerned about a few 1-bit errors. 2159 // Precision is lowest in the 709 conversion, higher in sRGB, higher still in Two and Gamma (when using 2.2 at least). 2160 //------------------------------------------------------------------------------------------------------------------------------ 2161 // NOTES 2162 // ===== 2163 // Could be faster for PQ conversions to be in ALU or a texture lookup depending on usage case. 2164 //============================================================================================================================== 2165 #if 1 2166 AF1 ATo709F1(AF1 c){AF3 j=AF3(0.018*4.5,4.5,0.45);AF2 k=AF2(1.099,-0.099); 2167 return clamp(j.x ,c*j.y ,pow(c,j.z )*k.x +k.y );} 2168 AF2 ATo709F2(AF2 c){AF3 j=AF3(0.018*4.5,4.5,0.45);AF2 k=AF2(1.099,-0.099); 2169 return clamp(j.xx ,c*j.yy ,pow(c,j.zz )*k.xx +k.yy );} 2170 AF3 ATo709F3(AF3 c){AF3 j=AF3(0.018*4.5,4.5,0.45);AF2 k=AF2(1.099,-0.099); 2171 return clamp(j.xxx,c*j.yyy,pow(c,j.zzz)*k.xxx+k.yyy);} 2172 //------------------------------------------------------------------------------------------------------------------------------ 2173 // Note 'rcpX' is '1/x', where the 'x' is what would be used in AFromGamma(). 2174 AF1 AToGammaF1(AF1 c,AF1 rcpX){return pow(c,AF1_(rcpX));} 2175 AF2 AToGammaF2(AF2 c,AF1 rcpX){return pow(c,AF2_(rcpX));} 2176 AF3 AToGammaF3(AF3 c,AF1 rcpX){return pow(c,AF3_(rcpX));} 2177 //------------------------------------------------------------------------------------------------------------------------------ 2178 AF1 AToPqF1(AF1 x){AF1 p=pow(x,AF1_(0.159302)); 2179 return pow((AF1_(0.835938)+AF1_(18.8516)*p)/(AF1_(1.0)+AF1_(18.6875)*p),AF1_(78.8438));} 2180 AF2 AToPqF1(AF2 x){AF2 p=pow(x,AF2_(0.159302)); 2181 return pow((AF2_(0.835938)+AF2_(18.8516)*p)/(AF2_(1.0)+AF2_(18.6875)*p),AF2_(78.8438));} 2182 AF3 AToPqF1(AF3 x){AF3 p=pow(x,AF3_(0.159302)); 2183 return pow((AF3_(0.835938)+AF3_(18.8516)*p)/(AF3_(1.0)+AF3_(18.6875)*p),AF3_(78.8438));} 2184 //------------------------------------------------------------------------------------------------------------------------------ 2185 AF1 AToSrgbF1(AF1 c){AF3 j=AF3(0.0031308*12.92,12.92,1.0/2.4);AF2 k=AF2(1.055,-0.055); 2186 return clamp(j.x ,c*j.y ,pow(c,j.z )*k.x +k.y );} 2187 AF2 AToSrgbF2(AF2 c){AF3 j=AF3(0.0031308*12.92,12.92,1.0/2.4);AF2 k=AF2(1.055,-0.055); 2188 return clamp(j.xx ,c*j.yy ,pow(c,j.zz )*k.xx +k.yy );} 2189 AF3 AToSrgbF3(AF3 c){AF3 j=AF3(0.0031308*12.92,12.92,1.0/2.4);AF2 k=AF2(1.055,-0.055); 2190 return clamp(j.xxx,c*j.yyy,pow(c,j.zzz)*k.xxx+k.yyy);} 2191 //------------------------------------------------------------------------------------------------------------------------------ 2192 AF1 AToTwoF1(AF1 c){return sqrt(c);} 2193 AF2 AToTwoF2(AF2 c){return sqrt(c);} 2194 AF3 AToTwoF3(AF3 c){return sqrt(c);} 2195 //------------------------------------------------------------------------------------------------------------------------------ 2196 AF1 AToThreeF1(AF1 c){return pow(c,AF1_(1.0/3.0));} 2197 AF2 AToThreeF2(AF2 c){return pow(c,AF2_(1.0/3.0));} 2198 AF3 AToThreeF3(AF3 c){return pow(c,AF3_(1.0/3.0));} 2199 #endif 2200 //============================================================================================================================== 2201 #if 1 2202 // Unfortunately median won't work here. 2203 AF1 AFrom709F1(AF1 c){AF3 j=AF3(0.081/4.5,1.0/4.5,1.0/0.45);AF2 k=AF2(1.0/1.099,0.099/1.099); 2204 return AZolSelF1(AZolSignedF1(c-j.x ),c*j.y ,pow(c*k.x +k.y ,j.z ));} 2205 AF2 AFrom709F2(AF2 c){AF3 j=AF3(0.081/4.5,1.0/4.5,1.0/0.45);AF2 k=AF2(1.0/1.099,0.099/1.099); 2206 return AZolSelF2(AZolSignedF2(c-j.xx ),c*j.yy ,pow(c*k.xx +k.yy ,j.zz ));} 2207 AF3 AFrom709F3(AF3 c){AF3 j=AF3(0.081/4.5,1.0/4.5,1.0/0.45);AF2 k=AF2(1.0/1.099,0.099/1.099); 2208 return AZolSelF3(AZolSignedF3(c-j.xxx),c*j.yyy,pow(c*k.xxx+k.yyy,j.zzz));} 2209 //------------------------------------------------------------------------------------------------------------------------------ 2210 AF1 AFromGammaF1(AF1 c,AF1 x){return pow(c,AF1_(x));} 2211 AF2 AFromGammaF2(AF2 c,AF1 x){return pow(c,AF2_(x));} 2212 AF3 AFromGammaF3(AF3 c,AF1 x){return pow(c,AF3_(x));} 2213 //------------------------------------------------------------------------------------------------------------------------------ 2214 AF1 AFromPqF1(AF1 x){AF1 p=pow(x,AF1_(0.0126833)); 2215 return pow(ASatF1(p-AF1_(0.835938))/(AF1_(18.8516)-AF1_(18.6875)*p),AF1_(6.27739));} 2216 AF2 AFromPqF1(AF2 x){AF2 p=pow(x,AF2_(0.0126833)); 2217 return pow(ASatF2(p-AF2_(0.835938))/(AF2_(18.8516)-AF2_(18.6875)*p),AF2_(6.27739));} 2218 AF3 AFromPqF1(AF3 x){AF3 p=pow(x,AF3_(0.0126833)); 2219 return pow(ASatF3(p-AF3_(0.835938))/(AF3_(18.8516)-AF3_(18.6875)*p),AF3_(6.27739));} 2220 //------------------------------------------------------------------------------------------------------------------------------ 2221 // Unfortunately median won't work here. 2222 AF1 AFromSrgbF1(AF1 c){AF3 j=AF3(0.04045/12.92,1.0/12.92,2.4);AF2 k=AF2(1.0/1.055,0.055/1.055); 2223 return AZolSelF1(AZolSignedF1(c-j.x ),c*j.y ,pow(c*k.x +k.y ,j.z ));} 2224 AF2 AFromSrgbF2(AF2 c){AF3 j=AF3(0.04045/12.92,1.0/12.92,2.4);AF2 k=AF2(1.0/1.055,0.055/1.055); 2225 return AZolSelF2(AZolSignedF2(c-j.xx ),c*j.yy ,pow(c*k.xx +k.yy ,j.zz ));} 2226 AF3 AFromSrgbF3(AF3 c){AF3 j=AF3(0.04045/12.92,1.0/12.92,2.4);AF2 k=AF2(1.0/1.055,0.055/1.055); 2227 return AZolSelF3(AZolSignedF3(c-j.xxx),c*j.yyy,pow(c*k.xxx+k.yyy,j.zzz));} 2228 //------------------------------------------------------------------------------------------------------------------------------ 2229 AF1 AFromTwoF1(AF1 c){return c*c;} 2230 AF2 AFromTwoF2(AF2 c){return c*c;} 2231 AF3 AFromTwoF3(AF3 c){return c*c;} 2232 //------------------------------------------------------------------------------------------------------------------------------ 2233 AF1 AFromThreeF1(AF1 c){return c*c*c;} 2234 AF2 AFromThreeF2(AF2 c){return c*c*c;} 2235 AF3 AFromThreeF3(AF3 c){return c*c*c;} 2236 #endif 2237 //============================================================================================================================== 2238 #ifdef A_HALF 2239 AH1 ATo709H1(AH1 c){AH3 j=AH3(0.018*4.5,4.5,0.45);AH2 k=AH2(1.099,-0.099); 2240 return clamp(j.x ,c*j.y ,pow(c,j.z )*k.x +k.y );} 2241 AH2 ATo709H2(AH2 c){AH3 j=AH3(0.018*4.5,4.5,0.45);AH2 k=AH2(1.099,-0.099); 2242 return clamp(j.xx ,c*j.yy ,pow(c,j.zz )*k.xx +k.yy );} 2243 AH3 ATo709H3(AH3 c){AH3 j=AH3(0.018*4.5,4.5,0.45);AH2 k=AH2(1.099,-0.099); 2244 return clamp(j.xxx,c*j.yyy,pow(c,j.zzz)*k.xxx+k.yyy);} 2245 //------------------------------------------------------------------------------------------------------------------------------ 2246 AH1 AToGammaH1(AH1 c,AH1 rcpX){return pow(c,AH1_(rcpX));} 2247 AH2 AToGammaH2(AH2 c,AH1 rcpX){return pow(c,AH2_(rcpX));} 2248 AH3 AToGammaH3(AH3 c,AH1 rcpX){return pow(c,AH3_(rcpX));} 2249 //------------------------------------------------------------------------------------------------------------------------------ 2250 AH1 AToSrgbH1(AH1 c){AH3 j=AH3(0.0031308*12.92,12.92,1.0/2.4);AH2 k=AH2(1.055,-0.055); 2251 return clamp(j.x ,c*j.y ,pow(c,j.z )*k.x +k.y );} 2252 AH2 AToSrgbH2(AH2 c){AH3 j=AH3(0.0031308*12.92,12.92,1.0/2.4);AH2 k=AH2(1.055,-0.055); 2253 return clamp(j.xx ,c*j.yy ,pow(c,j.zz )*k.xx +k.yy );} 2254 AH3 AToSrgbH3(AH3 c){AH3 j=AH3(0.0031308*12.92,12.92,1.0/2.4);AH2 k=AH2(1.055,-0.055); 2255 return clamp(j.xxx,c*j.yyy,pow(c,j.zzz)*k.xxx+k.yyy);} 2256 //------------------------------------------------------------------------------------------------------------------------------ 2257 AH1 AToTwoH1(AH1 c){return sqrt(c);} 2258 AH2 AToTwoH2(AH2 c){return sqrt(c);} 2259 AH3 AToTwoH3(AH3 c){return sqrt(c);} 2260 //------------------------------------------------------------------------------------------------------------------------------ 2261 AH1 AToThreeF1(AH1 c){return pow(c,AH1_(1.0/3.0));} 2262 AH2 AToThreeF2(AH2 c){return pow(c,AH2_(1.0/3.0));} 2263 AH3 AToThreeF3(AH3 c){return pow(c,AH3_(1.0/3.0));} 2264 #endif 2265 //============================================================================================================================== 2266 #ifdef A_HALF 2267 AH1 AFrom709H1(AH1 c){AH3 j=AH3(0.081/4.5,1.0/4.5,1.0/0.45);AH2 k=AH2(1.0/1.099,0.099/1.099); 2268 return AZolSelH1(AZolSignedH1(c-j.x ),c*j.y ,pow(c*k.x +k.y ,j.z ));} 2269 AH2 AFrom709H2(AH2 c){AH3 j=AH3(0.081/4.5,1.0/4.5,1.0/0.45);AH2 k=AH2(1.0/1.099,0.099/1.099); 2270 return AZolSelH2(AZolSignedH2(c-j.xx ),c*j.yy ,pow(c*k.xx +k.yy ,j.zz ));} 2271 AH3 AFrom709H3(AH3 c){AH3 j=AH3(0.081/4.5,1.0/4.5,1.0/0.45);AH2 k=AH2(1.0/1.099,0.099/1.099); 2272 return AZolSelH3(AZolSignedH3(c-j.xxx),c*j.yyy,pow(c*k.xxx+k.yyy,j.zzz));} 2273 //------------------------------------------------------------------------------------------------------------------------------ 2274 AH1 AFromGammaH1(AH1 c,AH1 x){return pow(c,AH1_(x));} 2275 AH2 AFromGammaH2(AH2 c,AH1 x){return pow(c,AH2_(x));} 2276 AH3 AFromGammaH3(AH3 c,AH1 x){return pow(c,AH3_(x));} 2277 //------------------------------------------------------------------------------------------------------------------------------ 2278 AH1 AHromSrgbF1(AH1 c){AH3 j=AH3(0.04045/12.92,1.0/12.92,2.4);AH2 k=AH2(1.0/1.055,0.055/1.055); 2279 return AZolSelH1(AZolSignedH1(c-j.x ),c*j.y ,pow(c*k.x +k.y ,j.z ));} 2280 AH2 AHromSrgbF2(AH2 c){AH3 j=AH3(0.04045/12.92,1.0/12.92,2.4);AH2 k=AH2(1.0/1.055,0.055/1.055); 2281 return AZolSelH2(AZolSignedH2(c-j.xx ),c*j.yy ,pow(c*k.xx +k.yy ,j.zz ));} 2282 AH3 AHromSrgbF3(AH3 c){AH3 j=AH3(0.04045/12.92,1.0/12.92,2.4);AH2 k=AH2(1.0/1.055,0.055/1.055); 2283 return AZolSelH3(AZolSignedH3(c-j.xxx),c*j.yyy,pow(c*k.xxx+k.yyy,j.zzz));} 2284 //------------------------------------------------------------------------------------------------------------------------------ 2285 AH1 AFromTwoH1(AH1 c){return c*c;} 2286 AH2 AFromTwoH2(AH2 c){return c*c;} 2287 AH3 AFromTwoH3(AH3 c){return c*c;} 2288 //------------------------------------------------------------------------------------------------------------------------------ 2289 AH1 AFromThreeH1(AH1 c){return c*c*c;} 2290 AH2 AFromThreeH2(AH2 c){return c*c*c;} 2291 AH3 AFromThreeH3(AH3 c){return c*c*c;} 2292 #endif 2293 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2294 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2295 //_____________________________________________________________/\_______________________________________________________________ 2296 //============================================================================================================================== 2297 // CS REMAP 2298 //============================================================================================================================== 2299 // Simple remap 64x1 to 8x8 with rotated 2x2 pixel quads in quad linear. 2300 // 543210 2301 // ====== 2302 // ..xxx. 2303 // yy...y 2304 AU2 ARmp8x8(AU1 a){return AU2(ABfe(a,1u,3u),ABfiM(ABfe(a,3u,3u),a,1u));} 2305 //============================================================================================================================== 2306 // More complex remap 64x1 to 8x8 which is necessary for 2D wave reductions. 2307 // 543210 2308 // ====== 2309 // .xx..x 2310 // y..yy. 2311 // Details, 2312 // LANE TO 8x8 MAPPING 2313 // =================== 2314 // 00 01 08 09 10 11 18 19 2315 // 02 03 0a 0b 12 13 1a 1b 2316 // 04 05 0c 0d 14 15 1c 1d 2317 // 06 07 0e 0f 16 17 1e 1f 2318 // 20 21 28 29 30 31 38 39 2319 // 22 23 2a 2b 32 33 3a 3b 2320 // 24 25 2c 2d 34 35 3c 3d 2321 // 26 27 2e 2f 36 37 3e 3f 2322 AU2 ARmpRed8x8(AU1 a){return AU2(ABfiM(ABfe(a,2u,3u),a,1u),ABfiM(ABfe(a,3u,3u),ABfe(a,1u,2u),2u));} 2323 //============================================================================================================================== 2324 #ifdef A_HALF 2325 AW2 ARmp8x8H(AU1 a){return AW2(ABfe(a,1u,3u),ABfiM(ABfe(a,3u,3u),a,1u));} 2326 AW2 ARmpRed8x8H(AU1 a){return AW2(ABfiM(ABfe(a,2u,3u),a,1u),ABfiM(ABfe(a,3u,3u),ABfe(a,1u,2u),2u));} 2327 #endif 2328 #endif 2329 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2330 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2331 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2332 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2333 //_____________________________________________________________/\_______________________________________________________________ 2334 //============================================================================================================================== 2335 // 2336 // REFERENCE 2337 // 2338 //------------------------------------------------------------------------------------------------------------------------------ 2339 // IEEE FLOAT RULES 2340 // ================ 2341 // - saturate(NaN)=0, saturate(-INF)=0, saturate(+INF)=1 2342 // - {+/-}0 * {+/-}INF = NaN 2343 // - -INF + (+INF) = NaN 2344 // - {+/-}0 / {+/-}0 = NaN 2345 // - {+/-}INF / {+/-}INF = NaN 2346 // - a<(-0) := sqrt(a) = NaN (a=-0.0 won't NaN) 2347 // - 0 == -0 2348 // - 4/0 = +INF 2349 // - 4/-0 = -INF 2350 // - 4+INF = +INF 2351 // - 4-INF = -INF 2352 // - 4*(+INF) = +INF 2353 // - 4*(-INF) = -INF 2354 // - -4*(+INF) = -INF 2355 // - sqrt(+INF) = +INF 2356 //------------------------------------------------------------------------------------------------------------------------------ 2357 // FP16 ENCODING 2358 // ============= 2359 // fedcba9876543210 2360 // ---------------- 2361 // ......mmmmmmmmmm 10-bit mantissa (encodes 11-bit 0.5 to 1.0 except for denormals) 2362 // .eeeee.......... 5-bit exponent 2363 // .00000.......... denormals 2364 // .00001.......... -14 exponent 2365 // .11110.......... 15 exponent 2366 // .111110000000000 infinity 2367 // .11111nnnnnnnnnn NaN with n!=0 2368 // s............... sign 2369 //------------------------------------------------------------------------------------------------------------------------------ 2370 // FP16/INT16 ALIASING DENORMAL 2371 // ============================ 2372 // 11-bit unsigned integers alias with half float denormal/normal values, 2373 // 1 = 2^(-24) = 1/16777216 ....................... first denormal value 2374 // 2 = 2^(-23) 2375 // ... 2376 // 1023 = 2^(-14)*(1-2^(-10)) = 2^(-14)*(1-1/1024) ... last denormal value 2377 // 1024 = 2^(-14) = 1/16384 .......................... first normal value that still maps to integers 2378 // 2047 .............................................. last normal value that still maps to integers 2379 // Scaling limits, 2380 // 2^15 = 32768 ...................................... largest power of 2 scaling 2381 // Largest pow2 conversion mapping is at *32768, 2382 // 1 : 2^(-9) = 1/512 2383 // 2 : 1/256 2384 // 4 : 1/128 2385 // 8 : 1/64 2386 // 16 : 1/32 2387 // 32 : 1/16 2388 // 64 : 1/8 2389 // 128 : 1/4 2390 // 256 : 1/2 2391 // 512 : 1 2392 // 1024 : 2 2393 // 2047 : a little less than 4 2394 //============================================================================================================================== 2395 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2396 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2397 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2398 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2399 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2400 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2401 //_____________________________________________________________/\_______________________________________________________________ 2402 //============================================================================================================================== 2403 // 2404 // 2405 // GPU/CPU PORTABILITY 2406 // 2407 // 2408 //------------------------------------------------------------------------------------------------------------------------------ 2409 // This is the GPU implementation. 2410 // See the CPU implementation for docs. 2411 //============================================================================================================================== 2412 #ifdef A_GPU 2413 #define A_TRUE true 2414 #define A_FALSE false 2415 #define A_STATIC 2416 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2417 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2418 //_____________________________________________________________/\_______________________________________________________________ 2419 //============================================================================================================================== 2420 // VECTOR ARGUMENT/RETURN/INITIALIZATION PORTABILITY 2421 //============================================================================================================================== 2422 #define retAD2 AD2 2423 #define retAD3 AD3 2424 #define retAD4 AD4 2425 #define retAF2 AF2 2426 #define retAF3 AF3 2427 #define retAF4 AF4 2428 #define retAL2 AL2 2429 #define retAL3 AL3 2430 #define retAL4 AL4 2431 #define retAU2 AU2 2432 #define retAU3 AU3 2433 #define retAU4 AU4 2434 //------------------------------------------------------------------------------------------------------------------------------ 2435 #define inAD2 in AD2 2436 #define inAD3 in AD3 2437 #define inAD4 in AD4 2438 #define inAF2 in AF2 2439 #define inAF3 in AF3 2440 #define inAF4 in AF4 2441 #define inAL2 in AL2 2442 #define inAL3 in AL3 2443 #define inAL4 in AL4 2444 #define inAU2 in AU2 2445 #define inAU3 in AU3 2446 #define inAU4 in AU4 2447 //------------------------------------------------------------------------------------------------------------------------------ 2448 #define inoutAD2 inout AD2 2449 #define inoutAD3 inout AD3 2450 #define inoutAD4 inout AD4 2451 #define inoutAF2 inout AF2 2452 #define inoutAF3 inout AF3 2453 #define inoutAF4 inout AF4 2454 #define inoutAL2 inout AL2 2455 #define inoutAL3 inout AL3 2456 #define inoutAL4 inout AL4 2457 #define inoutAU2 inout AU2 2458 #define inoutAU3 inout AU3 2459 #define inoutAU4 inout AU4 2460 //------------------------------------------------------------------------------------------------------------------------------ 2461 #define outAD2 out AD2 2462 #define outAD3 out AD3 2463 #define outAD4 out AD4 2464 #define outAF2 out AF2 2465 #define outAF3 out AF3 2466 #define outAF4 out AF4 2467 #define outAL2 out AL2 2468 #define outAL3 out AL3 2469 #define outAL4 out AL4 2470 #define outAU2 out AU2 2471 #define outAU3 out AU3 2472 #define outAU4 out AU4 2473 //------------------------------------------------------------------------------------------------------------------------------ 2474 #define varAD2(x) AD2 x 2475 #define varAD3(x) AD3 x 2476 #define varAD4(x) AD4 x 2477 #define varAF2(x) AF2 x 2478 #define varAF3(x) AF3 x 2479 #define varAF4(x) AF4 x 2480 #define varAL2(x) AL2 x 2481 #define varAL3(x) AL3 x 2482 #define varAL4(x) AL4 x 2483 #define varAU2(x) AU2 x 2484 #define varAU3(x) AU3 x 2485 #define varAU4(x) AU4 x 2486 //------------------------------------------------------------------------------------------------------------------------------ 2487 #define initAD2(x,y) AD2(x,y) 2488 #define initAD3(x,y,z) AD3(x,y,z) 2489 #define initAD4(x,y,z,w) AD4(x,y,z,w) 2490 #define initAF2(x,y) AF2(x,y) 2491 #define initAF3(x,y,z) AF3(x,y,z) 2492 #define initAF4(x,y,z,w) AF4(x,y,z,w) 2493 #define initAL2(x,y) AL2(x,y) 2494 #define initAL3(x,y,z) AL3(x,y,z) 2495 #define initAL4(x,y,z,w) AL4(x,y,z,w) 2496 #define initAU2(x,y) AU2(x,y) 2497 #define initAU3(x,y,z) AU3(x,y,z) 2498 #define initAU4(x,y,z,w) AU4(x,y,z,w) 2499 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2500 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2501 //_____________________________________________________________/\_______________________________________________________________ 2502 //============================================================================================================================== 2503 // SCALAR RETURN OPS 2504 //============================================================================================================================== 2505 #define AAbsD1(a) abs(AD1(a)) 2506 #define AAbsF1(a) abs(AF1(a)) 2507 //------------------------------------------------------------------------------------------------------------------------------ 2508 #define ACosD1(a) cos(AD1(a)) 2509 #define ACosF1(a) cos(AF1(a)) 2510 //------------------------------------------------------------------------------------------------------------------------------ 2511 #define ADotD2(a,b) dot(AD2(a),AD2(b)) 2512 #define ADotD3(a,b) dot(AD3(a),AD3(b)) 2513 #define ADotD4(a,b) dot(AD4(a),AD4(b)) 2514 #define ADotF2(a,b) dot(AF2(a),AF2(b)) 2515 #define ADotF3(a,b) dot(AF3(a),AF3(b)) 2516 #define ADotF4(a,b) dot(AF4(a),AF4(b)) 2517 //------------------------------------------------------------------------------------------------------------------------------ 2518 #define AExp2D1(a) exp2(AD1(a)) 2519 #define AExp2F1(a) exp2(AF1(a)) 2520 //------------------------------------------------------------------------------------------------------------------------------ 2521 #define AFloorD1(a) floor(AD1(a)) 2522 #define AFloorF1(a) floor(AF1(a)) 2523 //------------------------------------------------------------------------------------------------------------------------------ 2524 #define ALog2D1(a) log2(AD1(a)) 2525 #define ALog2F1(a) log2(AF1(a)) 2526 //------------------------------------------------------------------------------------------------------------------------------ 2527 #define AMaxD1(a,b) max(a,b) 2528 #define AMaxF1(a,b) max(a,b) 2529 #define AMaxL1(a,b) max(a,b) 2530 #define AMaxU1(a,b) max(a,b) 2531 //------------------------------------------------------------------------------------------------------------------------------ 2532 #define AMinD1(a,b) min(a,b) 2533 #define AMinF1(a,b) min(a,b) 2534 #define AMinL1(a,b) min(a,b) 2535 #define AMinU1(a,b) min(a,b) 2536 //------------------------------------------------------------------------------------------------------------------------------ 2537 #define ASinD1(a) sin(AD1(a)) 2538 #define ASinF1(a) sin(AF1(a)) 2539 //------------------------------------------------------------------------------------------------------------------------------ 2540 #define ASqrtD1(a) sqrt(AD1(a)) 2541 #define ASqrtF1(a) sqrt(AF1(a)) 2542 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2543 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2544 //_____________________________________________________________/\_______________________________________________________________ 2545 //============================================================================================================================== 2546 // SCALAR RETURN OPS - DEPENDENT 2547 //============================================================================================================================== 2548 #define APowD1(a,b) pow(AD1(a),AF1(b)) 2549 #define APowF1(a,b) pow(AF1(a),AF1(b)) 2550 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2551 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2552 //_____________________________________________________________/\_______________________________________________________________ 2553 //============================================================================================================================== 2554 // VECTOR OPS 2555 //------------------------------------------------------------------------------------------------------------------------------ 2556 // These are added as needed for production or prototyping, so not necessarily a complete set. 2557 // They follow a convention of taking in a destination and also returning the destination value to increase utility. 2558 //============================================================================================================================== 2559 #ifdef A_DUBL 2560 AD2 opAAbsD2(outAD2 d,inAD2 a){d=abs(a);return d;} 2561 AD3 opAAbsD3(outAD3 d,inAD3 a){d=abs(a);return d;} 2562 AD4 opAAbsD4(outAD4 d,inAD4 a){d=abs(a);return d;} 2563 //------------------------------------------------------------------------------------------------------------------------------ 2564 AD2 opAAddD2(outAD2 d,inAD2 a,inAD2 b){d=a+b;return d;} 2565 AD3 opAAddD3(outAD3 d,inAD3 a,inAD3 b){d=a+b;return d;} 2566 AD4 opAAddD4(outAD4 d,inAD4 a,inAD4 b){d=a+b;return d;} 2567 //------------------------------------------------------------------------------------------------------------------------------ 2568 AD2 opAAddOneD2(outAD2 d,inAD2 a,AD1 b){d=a+AD2_(b);return d;} 2569 AD3 opAAddOneD3(outAD3 d,inAD3 a,AD1 b){d=a+AD3_(b);return d;} 2570 AD4 opAAddOneD4(outAD4 d,inAD4 a,AD1 b){d=a+AD4_(b);return d;} 2571 //------------------------------------------------------------------------------------------------------------------------------ 2572 AD2 opACpyD2(outAD2 d,inAD2 a){d=a;return d;} 2573 AD3 opACpyD3(outAD3 d,inAD3 a){d=a;return d;} 2574 AD4 opACpyD4(outAD4 d,inAD4 a){d=a;return d;} 2575 //------------------------------------------------------------------------------------------------------------------------------ 2576 AD2 opALerpD2(outAD2 d,inAD2 a,inAD2 b,inAD2 c){d=ALerpD2(a,b,c);return d;} 2577 AD3 opALerpD3(outAD3 d,inAD3 a,inAD3 b,inAD3 c){d=ALerpD3(a,b,c);return d;} 2578 AD4 opALerpD4(outAD4 d,inAD4 a,inAD4 b,inAD4 c){d=ALerpD4(a,b,c);return d;} 2579 //------------------------------------------------------------------------------------------------------------------------------ 2580 AD2 opALerpOneD2(outAD2 d,inAD2 a,inAD2 b,AD1 c){d=ALerpD2(a,b,AD2_(c));return d;} 2581 AD3 opALerpOneD3(outAD3 d,inAD3 a,inAD3 b,AD1 c){d=ALerpD3(a,b,AD3_(c));return d;} 2582 AD4 opALerpOneD4(outAD4 d,inAD4 a,inAD4 b,AD1 c){d=ALerpD4(a,b,AD4_(c));return d;} 2583 //------------------------------------------------------------------------------------------------------------------------------ 2584 AD2 opAMaxD2(outAD2 d,inAD2 a,inAD2 b){d=max(a,b);return d;} 2585 AD3 opAMaxD3(outAD3 d,inAD3 a,inAD3 b){d=max(a,b);return d;} 2586 AD4 opAMaxD4(outAD4 d,inAD4 a,inAD4 b){d=max(a,b);return d;} 2587 //------------------------------------------------------------------------------------------------------------------------------ 2588 AD2 opAMinD2(outAD2 d,inAD2 a,inAD2 b){d=min(a,b);return d;} 2589 AD3 opAMinD3(outAD3 d,inAD3 a,inAD3 b){d=min(a,b);return d;} 2590 AD4 opAMinD4(outAD4 d,inAD4 a,inAD4 b){d=min(a,b);return d;} 2591 //------------------------------------------------------------------------------------------------------------------------------ 2592 AD2 opAMulD2(outAD2 d,inAD2 a,inAD2 b){d=a*b;return d;} 2593 AD3 opAMulD3(outAD3 d,inAD3 a,inAD3 b){d=a*b;return d;} 2594 AD4 opAMulD4(outAD4 d,inAD4 a,inAD4 b){d=a*b;return d;} 2595 //------------------------------------------------------------------------------------------------------------------------------ 2596 AD2 opAMulOneD2(outAD2 d,inAD2 a,AD1 b){d=a*AD2_(b);return d;} 2597 AD3 opAMulOneD3(outAD3 d,inAD3 a,AD1 b){d=a*AD3_(b);return d;} 2598 AD4 opAMulOneD4(outAD4 d,inAD4 a,AD1 b){d=a*AD4_(b);return d;} 2599 //------------------------------------------------------------------------------------------------------------------------------ 2600 AD2 opANegD2(outAD2 d,inAD2 a){d=-a;return d;} 2601 AD3 opANegD3(outAD3 d,inAD3 a){d=-a;return d;} 2602 AD4 opANegD4(outAD4 d,inAD4 a){d=-a;return d;} 2603 //------------------------------------------------------------------------------------------------------------------------------ 2604 AD2 opARcpD2(outAD2 d,inAD2 a){d=ARcpD2(a);return d;} 2605 AD3 opARcpD3(outAD3 d,inAD3 a){d=ARcpD3(a);return d;} 2606 AD4 opARcpD4(outAD4 d,inAD4 a){d=ARcpD4(a);return d;} 2607 #endif 2608 //============================================================================================================================== 2609 AF2 opAAbsF2(outAF2 d,inAF2 a){d=abs(a);return d;} 2610 AF3 opAAbsF3(outAF3 d,inAF3 a){d=abs(a);return d;} 2611 AF4 opAAbsF4(outAF4 d,inAF4 a){d=abs(a);return d;} 2612 //------------------------------------------------------------------------------------------------------------------------------ 2613 AF2 opAAddF2(outAF2 d,inAF2 a,inAF2 b){d=a+b;return d;} 2614 AF3 opAAddF3(outAF3 d,inAF3 a,inAF3 b){d=a+b;return d;} 2615 AF4 opAAddF4(outAF4 d,inAF4 a,inAF4 b){d=a+b;return d;} 2616 //------------------------------------------------------------------------------------------------------------------------------ 2617 AF2 opAAddOneF2(outAF2 d,inAF2 a,AF1 b){d=a+AF2_(b);return d;} 2618 AF3 opAAddOneF3(outAF3 d,inAF3 a,AF1 b){d=a+AF3_(b);return d;} 2619 AF4 opAAddOneF4(outAF4 d,inAF4 a,AF1 b){d=a+AF4_(b);return d;} 2620 //------------------------------------------------------------------------------------------------------------------------------ 2621 AF2 opACpyF2(outAF2 d,inAF2 a){d=a;return d;} 2622 AF3 opACpyF3(outAF3 d,inAF3 a){d=a;return d;} 2623 AF4 opACpyF4(outAF4 d,inAF4 a){d=a;return d;} 2624 //------------------------------------------------------------------------------------------------------------------------------ 2625 AF2 opALerpF2(outAF2 d,inAF2 a,inAF2 b,inAF2 c){d=ALerpF2(a,b,c);return d;} 2626 AF3 opALerpF3(outAF3 d,inAF3 a,inAF3 b,inAF3 c){d=ALerpF3(a,b,c);return d;} 2627 AF4 opALerpF4(outAF4 d,inAF4 a,inAF4 b,inAF4 c){d=ALerpF4(a,b,c);return d;} 2628 //------------------------------------------------------------------------------------------------------------------------------ 2629 AF2 opALerpOneF2(outAF2 d,inAF2 a,inAF2 b,AF1 c){d=ALerpF2(a,b,AF2_(c));return d;} 2630 AF3 opALerpOneF3(outAF3 d,inAF3 a,inAF3 b,AF1 c){d=ALerpF3(a,b,AF3_(c));return d;} 2631 AF4 opALerpOneF4(outAF4 d,inAF4 a,inAF4 b,AF1 c){d=ALerpF4(a,b,AF4_(c));return d;} 2632 //------------------------------------------------------------------------------------------------------------------------------ 2633 AF2 opAMaxF2(outAF2 d,inAF2 a,inAF2 b){d=max(a,b);return d;} 2634 AF3 opAMaxF3(outAF3 d,inAF3 a,inAF3 b){d=max(a,b);return d;} 2635 AF4 opAMaxF4(outAF4 d,inAF4 a,inAF4 b){d=max(a,b);return d;} 2636 //------------------------------------------------------------------------------------------------------------------------------ 2637 AF2 opAMinF2(outAF2 d,inAF2 a,inAF2 b){d=min(a,b);return d;} 2638 AF3 opAMinF3(outAF3 d,inAF3 a,inAF3 b){d=min(a,b);return d;} 2639 AF4 opAMinF4(outAF4 d,inAF4 a,inAF4 b){d=min(a,b);return d;} 2640 //------------------------------------------------------------------------------------------------------------------------------ 2641 AF2 opAMulF2(outAF2 d,inAF2 a,inAF2 b){d=a*b;return d;} 2642 AF3 opAMulF3(outAF3 d,inAF3 a,inAF3 b){d=a*b;return d;} 2643 AF4 opAMulF4(outAF4 d,inAF4 a,inAF4 b){d=a*b;return d;} 2644 //------------------------------------------------------------------------------------------------------------------------------ 2645 AF2 opAMulOneF2(outAF2 d,inAF2 a,AF1 b){d=a*AF2_(b);return d;} 2646 AF3 opAMulOneF3(outAF3 d,inAF3 a,AF1 b){d=a*AF3_(b);return d;} 2647 AF4 opAMulOneF4(outAF4 d,inAF4 a,AF1 b){d=a*AF4_(b);return d;} 2648 //------------------------------------------------------------------------------------------------------------------------------ 2649 AF2 opANegF2(outAF2 d,inAF2 a){d=-a;return d;} 2650 AF3 opANegF3(outAF3 d,inAF3 a){d=-a;return d;} 2651 AF4 opANegF4(outAF4 d,inAF4 a){d=-a;return d;} 2652 //------------------------------------------------------------------------------------------------------------------------------ 2653 AF2 opARcpF2(outAF2 d,inAF2 a){d=ARcpF2(a);return d;} 2654 AF3 opARcpF3(outAF3 d,inAF3 a){d=ARcpF3(a);return d;} 2655 AF4 opARcpF4(outAF4 d,inAF4 a){d=ARcpF4(a);return d;} 2656 #endif