Quantcast
Channel: AMD Developer Forums: Message List - OpenGL & Vulkan
Viewing all articles
Browse latest Browse all 631
↧

Re: Re: infinite loop when compiling glsl compute shader

December 13, 2013, 1:01 am
$
0
0

One sample

(original SL code is HLSL, converted with a dirty tool to GLSL syntax, with a lot of "define" at the beginning of the file)

(I'm not sure the converted code is OK, currently I'm trying to compile all my shaders to be able to test them)

 

float SL_step(float b, float a) { return step(b,a); }

vec2 SL_step(vec2 b, vec2 a) { return step(b,a); }

vec2 SL_step(float b, vec2 a) { return step(vec2(b),a); }

vec2 SL_step(vec2 b, float a) { return step(b,vec2(a)); }

vec3 SL_step(vec3 b, vec3 a) { return step(b,a); }

vec3 SL_step(float b, vec3 a) { return step(vec3(b),a); }

vec3 SL_step(vec3 b, float a) { return step(b,vec3(a)); }

vec4 SL_step(vec4 b, vec4 a) { return step(b,a); }

vec4 SL_step(float b, vec4 a) { return step(vec4(b),a); }

vec4 SL_step(vec4 b, float a) { return step(b,vec4(a)); }

bvec4 SL_notEqual(ivec4 a, int b) { return notEqual(a, ivec4(b) ); }

bvec4 SL_notEqual(int a, ivec4 b) { return notEqual(ivec4(a), b ); }

bvec4 SL_notEqual(ivec4 a, ivec4 b) { return notEqual(a, b ); }

bool SL_notEqual(int a, int b) { return (a != b); }

bvec4 SL_notEqual(uvec4 a, uint b) { return notEqual(a, uvec4(b) ); }

bvec4 SL_notEqual(uint a, uvec4 b) { return notEqual(uvec4(a), b ); }

bvec4 SL_notEqual(uvec4 a, uvec4 b) { return notEqual(a, b ); }

bool SL_notEqual(uint a, uint b) { return (a != b); }

bvec4 SL_notEqual(vec4 a, float b) { return notEqual(a, vec4(b) ); }

bvec4 SL_notEqual(float a, vec4 b) { return notEqual(vec4(a), b ); }

bvec4 SL_notEqual(vec4 a, vec4 b) { return notEqual(a, b ); }

bool SL_notEqual(float a, float b) { return (a != b); }

bvec4 SL_equal(vec4 a, float b) { return equal(a, vec4(b) ); }

bvec4 SL_equal(float a, vec4 b) { return equal(vec4(a), b ); }

bvec4 SL_equal(vec4 a, vec4 b) { return equal(a, b ); }

bvec3 SL_equal(vec3 a, float b) { return equal(a, vec3(b) ); }

bvec3 SL_equal(float a, vec3 b) { return equal(vec3(a), b ); }

bvec3 SL_equal(vec3 a, vec3 b) { return equal(a, b ); }

bvec2 SL_equal(vec2 a, float b) { return equal(a, vec2(b) ); }

bvec2 SL_equal(float a, vec2 b) { return equal(vec2(a), b ); }

bvec2 SL_equal(vec2 a, vec2 b) { return equal(a, b ); }

bool SL_equal(float a, float b) { return (a > b); }

bvec4 SL_greaterThan(vec4 a, float b) { return greaterThan(a, vec4(b) ); }

bvec4 SL_greaterThan(float a, vec4 b) { return greaterThan(vec4(a), b ); }

bvec4 SL_greaterThan(vec4 a, vec4 b) { return greaterThan(a, b ); }

bvec3 SL_greaterThan(vec3 a, float b) { return greaterThan(a, vec3(b) ); }

bvec3 SL_greaterThan(float a, vec3 b) { return greaterThan(vec3(a), b ); }

bvec3 SL_greaterThan(vec3 a, vec3 b) { return greaterThan(a, b ); }

bvec2 SL_greaterThan(vec2 a, float b) { return greaterThan(a, vec2(b) ); }

bvec2 SL_greaterThan(float a, vec2 b) { return greaterThan(vec2(a), b ); }

bvec2 SL_greaterThan(vec2 a, vec2 b) { return greaterThan(a, b ); }

bool SL_greaterThan(float a, float b) { return (a > b); }

bvec4 SL_greaterThan(uvec4 a, uint b) { return greaterThan(a, uvec4(b) ); }

bvec4 SL_greaterThan(uint a, uvec4 b) { return greaterThan(uvec4(a), b ); }

bvec4 SL_greaterThan(uvec4 a, uvec4 b) { return greaterThan(a, b ); }

bvec3 SL_greaterThan(uvec3 a, uint b) { return greaterThan(a, uvec3(b) ); }

bvec3 SL_greaterThan(uint a, uvec3 b) { return greaterThan(uvec3(a), b ); }

bvec3 SL_greaterThan(uvec3 a, uvec3 b) { return greaterThan(a, b ); }

bvec2 SL_greaterThan(uvec2 a, uint b) { return greaterThan(a, uvec2(b) ); }

bvec2 SL_greaterThan(uint a, uvec2 b) { return greaterThan(uvec2(a), b ); }

bvec2 SL_greaterThan(uvec2 a, uvec2 b) { return greaterThan(a, b ); }

bool SL_greaterThan(uint a, uint b) { return (a > b); }

bvec4 SL_greaterThan(ivec4 a, int b) { return greaterThan(a, ivec4(b) ); }

bvec4 SL_greaterThan(int a, ivec4 b) { return greaterThan(ivec4(a), b ); }

bvec4 SL_greaterThan(ivec4 a, ivec4 b) { return greaterThan(a, b ); }

bvec3 SL_greaterThan(ivec3 a, int b) { return greaterThan(a, ivec3(b) ); }

bvec3 SL_greaterThan(int a, ivec3 b) { return greaterThan(ivec3(a), b ); }

bvec3 SL_greaterThan(ivec3 a, ivec3 b) { return greaterThan(a, b ); }

bvec2 SL_greaterThan(ivec2 a, int b) { return greaterThan(a, ivec2(b) ); }

bvec2 SL_greaterThan(int a, ivec2 b) { return greaterThan(ivec2(a), b ); }

bvec2 SL_greaterThan(ivec2 a, ivec2 b) { return greaterThan(a, b ); }

bool SL_greaterThan(int a, int b) { return (a > b); }

bvec4 SL_greaterThanEqual(vec4 a, float b) { return greaterThanEqual(a, vec4(b) ); }

bvec4 SL_greaterThanEqual(float a, vec4 b) { return greaterThanEqual(vec4(a), b ); }

bvec4 SL_greaterThanEqual(vec4 a, vec4 b) { return greaterThanEqual(a, b ); }

bvec3 SL_greaterThanEqual(vec3 a, float b) { return greaterThanEqual(a, vec3(b) ); }

bvec3 SL_greaterThanEqual(float a, vec3 b) { return greaterThanEqual(vec3(a), b ); }

bvec3 SL_greaterThanEqual(vec3 a, vec3 b) { return greaterThanEqual(a, b ); }

bvec2 SL_greaterThanEqual(vec2 a, float b) { return greaterThanEqual(a, vec2(b) ); }

bvec2 SL_greaterThanEqual(float a, vec2 b) { return greaterThanEqual(vec2(a), b ); }

bvec2 SL_greaterThanEqual(vec2 a, vec2 b) { return greaterThanEqual(a, b ); }

bool SL_greaterThanEqual(float a, float b) { return (a >= b); }

bvec4 SL_greaterThanEqual(uvec4 a, uint b) { return greaterThanEqual(a, uvec4(b) ); }

bvec4 SL_greaterThanEqual(uint a, uvec4 b) { return greaterThanEqual(uvec4(a), b ); }

bvec4 SL_greaterThanEqual(uvec4 a, uvec4 b) { return greaterThanEqual(a, b ); }

bvec3 SL_greaterThanEqual(uvec3 a, uint b) { return greaterThanEqual(a, uvec3(b) ); }

bvec3 SL_greaterThanEqual(uint a, uvec3 b) { return greaterThanEqual(uvec3(a), b ); }

bvec3 SL_greaterThanEqual(uvec3 a, uvec3 b) { return greaterThanEqual(a, b ); }

bvec2 SL_greaterThanEqual(uvec2 a, uint b) { return greaterThanEqual(a, uvec2(b) ); }

bvec2 SL_greaterThanEqual(uint a, uvec2 b) { return greaterThanEqual(uvec2(a), b ); }

bvec2 SL_greaterThanEqual(uvec2 a, uvec2 b) { return greaterThanEqual(a, b ); }

bool SL_greaterThanEqual(uint a, uint b) { return (a >= b); }

bvec4 SL_greaterThanEqual(ivec4 a, int b) { return greaterThanEqual(a, ivec4(b) ); }

bvec4 SL_greaterThanEqual(int a, ivec4 b) { return greaterThanEqual(ivec4(a), b ); }

bvec4 SL_greaterThanEqual(ivec4 a, ivec4 b) { return greaterThanEqual(a, b ); }

bvec3 SL_greaterThanEqual(ivec3 a, int b) { return greaterThanEqual(a, ivec3(b) ); }

bvec3 SL_greaterThanEqual(int a, ivec3 b) { return greaterThanEqual(ivec3(a), b ); }

bvec3 SL_greaterThanEqual(ivec3 a, ivec3 b) { return greaterThanEqual(a, b ); }

bvec2 SL_greaterThanEqual(ivec2 a, int b) { return greaterThanEqual(a, ivec2(b) ); }

bvec2 SL_greaterThanEqual(int a, ivec2 b) { return greaterThanEqual(ivec2(a), b ); }

bvec2 SL_greaterThanEqual(ivec2 a, ivec2 b) { return greaterThanEqual(a, b ); }

bool SL_greaterThanEqual(int a, int b) { return (a >= b); }

vec4 SL_select(bvec4 c, vec4 a, float b) { return mix( vec4(b), a, c ); }

vec4 SL_select(bvec4 c, float a, vec4 b) { return mix( b, vec4(a), c ); }

vec4 SL_select(bvec4 c, vec4 a, vec4 b) { return mix( b, a, c ); }

vec4 SL_select(bool c, vec4 a, float b) { return mix( vec4(b), a, bvec4(c) ); }

vec4 SL_select(bool c, float a, vec4 b) { return mix( b, vec4(a), bvec4(c) ); }

vec4 SL_select(bool c, vec4 a, vec4 b) { return mix( b, a, bvec4(c) ); }

vec3 SL_select(bvec3 c, vec3 a, float b) { return mix( vec3(b), a, c ); }

vec3 SL_select(bvec3 c, float a, vec3 b) { return mix( b, vec3(a), c ); }

vec3 SL_select(bvec3 c, vec3 a, vec3 b) { return mix( b, a, c ); }

vec3 SL_select(bool c, vec3 a, float b) { return mix( vec3(b), a, bvec3(c) ); }

vec3 SL_select(bool c, float a, vec3 b) { return mix( b, vec3(a), bvec3(c) ); }

vec3 SL_select(bool c, vec3 a, vec3 b) { return mix( b, a, bvec3(c) ); }

vec2 SL_select(bvec2 c, vec2 a, float b) { return mix( vec2(b), a, c ); }

vec2 SL_select(bvec2 c, float a, vec2 b) { return mix( b, vec2(a), c ); }

vec2 SL_select(bvec2 c, vec2 a, vec2 b) { return mix( b, a, c ); }

vec2 SL_select(bool c, vec2 a, float b) { return mix( vec2(b), a, bvec2(c) ); }

vec2 SL_select(bool c, float a, vec2 b) { return mix( b, vec2(a), bvec2(c) ); }

vec2 SL_select(bool c, vec2 a, vec2 b) { return mix( b, a, bvec2(c) ); }

float SL_select(bool c, float a, float b) { return (c) ? a : b; }

uvec4 SL_select(bvec4 c, uvec4 a, uint b) { return floatBitsToUint(mix( uintBitsToFloat(uvec4(b)), uintBitsToFloat(a), c )); }

uvec4 SL_select(bvec4 c, uint a, uvec4 b) { return floatBitsToUint(mix( uintBitsToFloat(b), uintBitsToFloat(uvec4(a)), c )); }

uvec4 SL_select(bvec4 c, uint a, uint b) { return floatBitsToUint(mix( uintBitsToFloat(uvec4(b)), uintBitsToFloat(uvec4(a)), c )); }

uvec4 SL_select(bvec4 c, uvec4 a, uvec4 b) { return floatBitsToUint(mix( uintBitsToFloat(b), uintBitsToFloat(a), c )); }

uvec4 SL_select(bool c, uvec4 a, uvec4 b) { return floatBitsToUint(mix( uintBitsToFloat(b), uintBitsToFloat(a), bvec4(c) )); }

uvec4 SL_select(bool c, uint a, uvec4 b) { return floatBitsToUint(mix( uintBitsToFloat(b), uintBitsToFloat(uvec4(a)), bvec4(c) )); }

uvec4 SL_select(bool c, uvec4 a, uint b) { return floatBitsToUint(mix( uintBitsToFloat(uvec4(b)), uintBitsToFloat(a), bvec4(c) )); }

uvec3 SL_select(bvec3 c, uvec3 a, uint b) { return floatBitsToUint(mix( uintBitsToFloat(uvec3(b)), uintBitsToFloat(a), c )); }

uvec3 SL_select(bvec3 c, uint a, uvec3 b) { return floatBitsToUint(mix( uintBitsToFloat(b), uintBitsToFloat(uvec3(a)), c )); }

uvec3 SL_select(bvec3 c, uvec3 a, uvec3 b) { return floatBitsToUint(mix( uintBitsToFloat(b), uintBitsToFloat(a), c )); }

uvec3 SL_select(bool c, uvec3 a, uvec3 b) { return floatBitsToUint(mix( uintBitsToFloat(b), uintBitsToFloat(a), bvec3(c) )); }

uvec3 SL_select(bool c, uint a, uvec3 b) { return floatBitsToUint(mix( uintBitsToFloat(b), uintBitsToFloat(uvec3(a)), bvec3(c) )); }

uvec3 SL_select(bool c, uvec3 a, uint b) { return floatBitsToUint(mix( uintBitsToFloat(uvec3(b)), uintBitsToFloat(a), bvec3(c) )); }

uvec2 SL_select(bvec2 c, uvec2 a, uint b) { return floatBitsToUint(mix( uintBitsToFloat(uvec2(b)), uintBitsToFloat(a), c )); }

uvec2 SL_select(bvec2 c, uint a, uvec2 b) { return floatBitsToUint(mix( uintBitsToFloat(b), uintBitsToFloat(uvec2(a)), c )); }

uvec2 SL_select(bvec2 c, uvec2 a, uvec2 b) { return floatBitsToUint(mix( uintBitsToFloat(b), uintBitsToFloat(a), c )); }

uvec2 SL_select(bool c, uvec2 a, uvec2 b) { return floatBitsToUint(mix( uintBitsToFloat(b), uintBitsToFloat(a), bvec2(c) )); }

uvec2 SL_select(bool c, uint a, uvec2 b) { return floatBitsToUint(mix( uintBitsToFloat(b), uintBitsToFloat(uvec2(a)), bvec2(c) )); }

uvec2 SL_select(bool c, uvec2 a, uint b) { return floatBitsToUint(mix( uintBitsToFloat(uvec2(b)), uintBitsToFloat(a), bvec2(c) )); }

uint SL_select(bool c, uint a, uint b) { return (c) ? a : b; }

ivec4 SL_select(bvec4 c, ivec4 a, int b) { return floatBitsToInt(mix( intBitsToFloat(ivec4(b)), intBitsToFloat(a), c )); }

ivec4 SL_select(bvec4 c, int a, ivec4 b) { return floatBitsToInt(mix( intBitsToFloat(b), intBitsToFloat(ivec4(a)), c )); }

ivec4 SL_select(bvec4 c, ivec4 a, ivec4 b) { return floatBitsToInt(mix( intBitsToFloat(b), intBitsToFloat(a), c )); }

ivec4 SL_select(bool c, ivec4 a, ivec4 b) { return floatBitsToInt(mix( intBitsToFloat(b), intBitsToFloat(a), bvec4(c) )); }

ivec4 SL_select(bool c, int a, ivec4 b) { return floatBitsToInt(mix( intBitsToFloat(b), intBitsToFloat(ivec4(a)), bvec4(c) )); }

ivec4 SL_select(bool c, ivec4 a, int b) { return floatBitsToInt(mix( intBitsToFloat(ivec4(b)), intBitsToFloat(a), bvec4(c) )); }

ivec3 SL_select(bvec3 c, ivec3 a, int b) { return floatBitsToInt(mix( intBitsToFloat(ivec3(b)), intBitsToFloat(a), c )); }

ivec3 SL_select(bvec3 c, int a, ivec3 b) { return floatBitsToInt(mix( intBitsToFloat(b), intBitsToFloat(ivec3(a)), c )); }

ivec3 SL_select(bvec3 c, ivec3 a, ivec3 b) { return floatBitsToInt(mix( intBitsToFloat(b), intBitsToFloat(a), c )); }

ivec3 SL_select(bool c, ivec3 a, ivec3 b) { return floatBitsToInt(mix( intBitsToFloat(b), intBitsToFloat(a), bvec3(c) )); }

ivec3 SL_select(bool c, int a, ivec3 b) { return floatBitsToInt(mix( intBitsToFloat(b), intBitsToFloat(ivec3(a)), bvec3(c) )); }

ivec3 SL_select(bool c, ivec3 a, int b) { return floatBitsToInt(mix( intBitsToFloat(ivec3(b)), intBitsToFloat(a), bvec3(c) )); }

ivec2 SL_select(bvec2 c, ivec2 a, int b) { return floatBitsToInt(mix( intBitsToFloat(ivec2(b)), intBitsToFloat(a), c )); }

ivec2 SL_select(bvec2 c, int a, ivec2 b) { return floatBitsToInt(mix( intBitsToFloat(b), intBitsToFloat(ivec2(a)), c )); }

ivec2 SL_select(bvec2 c, ivec2 a, ivec2 b) { return floatBitsToInt(mix( intBitsToFloat(b), intBitsToFloat(a), c )); }

ivec2 SL_select(bool c, ivec2 a, ivec2 b) { return floatBitsToInt(mix( intBitsToFloat(b), intBitsToFloat(a), bvec2(c) )); }

ivec2 SL_select(bool c, int a, ivec2 b) { return floatBitsToInt(mix( intBitsToFloat(b), intBitsToFloat(ivec2(a)), bvec2(c) )); }

ivec2 SL_select(bool c, ivec2 a, int b) { return floatBitsToInt(mix( intBitsToFloat(ivec2(b)), intBitsToFloat(a), bvec2(c) )); }

int SL_select(bool c, int a, int b) { return (c) ? a : b; }

bool SL_or( bool a, bool b ) { return (a || b); }

bvec2 SL_or( bvec2 a, bvec2 b ) { return bvec2( (a.x || b.x), (a.y || b.y) ); }

bvec3 SL_or( bvec3 a, bvec3 b ) { return bvec3( (a.x || b.x), (a.y || b.y), (a.z || b.z) ); }

bvec4 SL_or( bvec4 a, bvec4 b ) { return bvec4( (a.x || b.x), (a.y || b.y), (a.z || b.z), (a.w || b.w) ); }

bool SL_and( bool a, bool b ) { return (a && b); }

bvec2 SL_and( bvec2 a, bvec2 b ) { return bvec2( (a.x && b.x), (a.y && b.y) ); }

bvec3 SL_and( bvec3 a, bvec3 b ) { return bvec3( (a.x && b.x), (a.y && b.y), (a.z && b.z) ); }

bvec4 SL_and( bvec4 a, bvec4 b ) { return bvec4( (a.x && b.x), (a.y && b.y), (a.z && b.z), (a.w && b.w) ); }

uniform CommonInstance {

  vec4  cCenter;

  float cScaleXY;

  float cScaleZ;

  float cQuantityNormalized;

  float cRcpQuantityNormalized;

  vec2  cRcpDim;

  vec2  cClampDimMax;

  float cQuantityScale;

  float cRcpQuantityScale;

  float cScaleRatio;

  float cDetailDistanceMax;

  uint cDimShift;

  uint cGridId;

  uint cQuantityShift;

  uint cBaseQuantityShift;

  uint cFrancoisHollande;

  uint cHarlemDesir;

  vec2  cRcpModelDim;

  uvec2  cHalfDim;

  uvec2  cMaskDim;

  uint cMaskHard;

  uint cMaskFluid;

  uint cTileMaskX;

  uint cTileShiftY;

  uint cSubTileMaskX;

  uint cSubTileShiftY;

  uint cMaskBase;

  uint cLoop;

  float cPerlinScale;

  float cRatio3;

  float cRatio2;

  float cRatioMin;

  float cDepthScale;

  float cSedimentScale;

  float cFluxScaleFluid;

  float cFluxScaleSand;

  vec4  cColorBase;

  vec4  cColorHard;

  vec4  cColorSand;

  vec4  cColorWater;

  vec4  cColorSediment;

  vec4  cColorSky0;

  vec4  cColorSky1;

  vec4  cColorPad;

  vec4  cGridMatNoScale0;

  vec4  cGridMatNoScale1;

  vec4  cGridMatNoScale2;

  vec4  cGridMatNoScale3;

  vec4  cGridMat0;

  vec4  cGridMat1;

  vec4  cGridMat2;

  vec4  cGridMat3;

  vec4  cGridMatInv0;

  vec4  cGridMatInv1;

  vec4  cGridMatInv2;

  vec4  cGridMatInv3;

  vec4  cLocalMat0;

  vec4  cLocalMat1;

  vec4  cLocalMat2;

  vec4  cLocalMat3;

} gCommonInstance ;

layout(rgba32ui) restrict readonly uniform uimageBuffer Buffer_Cursor;

  uint PackSnow( in  uvec2  _uiVal )

  { return (_uiVal.y << 16U) | (_uiVal.x); }

  uvec2  UnpackSnow( in uint _uiVal )

  { return  uvec2 ( _uiVal & 0xFFFF, _uiVal >> 16U ); }

uniform usampler2D Texture_Snow;

uniform usampler2D Texture_IceBase;

  uvec2  GetSnow( in  uvec2  _uiPos )

  { return UnpackSnow(  texelFetch(Texture_Snow, ivec2 ( ivec2 (_uiPos)),0) .r ); }

  uvec2  GetIceBase( in  uvec2  _uiPos )

  { return UnpackSnow(  texelFetch(Texture_IceBase, ivec2 ( ivec2 (_uiPos)),0) .r ); }

layout(rgba32ui) restrict writeonly uniform uimageBuffer Buffer_MinMax;

shared   uvec4  gs_MinMax;

layout (local_size_x = 256 , local_size_y = 1, local_size_z = 1) in;

void main() {

  if (  gl_LocalInvocationIndex  == 0 )

  {

  gs_MinMax.x = 0xFFFFFFFF;

  gs_MinMax.y = 0x00000000;

  gs_MinMax.z = 0xFFFFFFFF;

  gs_MinMax.w = 0x00000000;

  }

  groupMemoryBarrier();

  vec4  fInputPos = uintBitsToFloat(  imageLoad(Buffer_Cursor,int(0)).rgba  );

  vec4  fInputColor = uintBitsToFloat(  imageLoad(Buffer_Cursor,int(16)).rgba  );

  vec2  fGridPos = fInputPos.xy + 0.5;

  float fScale = fInputPos.z;

  float fAngle = -fInputPos.w;

  uvec2  uiDim =  gCommonInstance .cMaskDim  + 1;

  uint uiIterNum = (uiDim.x * uiDim.y) /  256 ;

  uvec4  uiMinMax =  uvec4 ( 0xFFFFFFFF, 0x00000000, 0xFFFFFFFF, 0x00000000 );

  for ( uint i = 0; i < uiIterNum; i++ )

  {

  uint uiGridOffset =  gl_LocalInvocationIndex  + ( 256  * i);

  uvec2  uiPos =  uvec2 ( uiGridOffset &  gCommonInstance .cMaskDim .x, uiGridOffset / uiDim.x );

  vec2  fXY =  vec2 (uiPos) - fInputPos.xy;

  vec2  fUV =  vec2 ( fXY.x * cos(fAngle) - fXY.y * sin(fAngle), fXY.x * sin(fAngle) + fXY.y * cos(fAngle) );

  bool bInside = all( SL_greaterThanEqual( fScale, abs(fUV) ) );

  uvec2  uiSnow = GetSnow( uiPos );

  uvec2  uiIceBase = GetIceBase( uiPos );

  uint uiSurface_C = ( uiIceBase.y + uiIceBase.x + uiSnow.y );

  uiMinMax.x = min( uiMinMax.x, uiSurface_C );

  uiMinMax.y = max( uiMinMax.y, uiSurface_C );

  uiMinMax.z = (bInside) ? min( uiMinMax.z, uiSurface_C ) : uiMinMax.z;

  uiMinMax.w = (bInside) ? max( uiMinMax.w, uiSurface_C ) : uiMinMax.w;

  }

  groupMemoryBarrier();

  atomicMin(gs_MinMax.x,uiMinMax.x) ;

  atomicMax(gs_MinMax.y,uiMinMax.y) ;

  atomicMin(gs_MinMax.z,uiMinMax.z) ;

  atomicMax(gs_MinMax.w,uiMinMax.w) ;

  groupMemoryBarrier();

  if (  gl_LocalInvocationIndex  == 0 )

  {

  imageStore(Buffer_MinMax,int(0),gs_MinMax) ;

  }

}

↧
Search
Viewing all articles
Browse latest Browse all 631

Trending Articles

Practice Sheet of Right form of verbs for HSC Students

September 22, 2019, 11:40 pm

Download: FK ft Shenky – Nakuyewa ”Prod by: Shenky”

February 16, 2017, 4:24 pm

How to win at Markstrat (Markstrat Tips and Tricks) – Vodites

January 5, 2014, 10:34 pm

Ominde Commission Report and Recommendations – Ominde Report of 1964

March 16, 2015, 5:14 am

Bureau of Internal Revenue: Regional Offices (Directory)

January 9, 2014, 11:06 pm

GO 53 on Enhancement of Ex-gratia upto 5 Lakhs Toddy Tappers in Telangana

March 26, 2017, 11:23 pm

Cakewalk CA-2A Leveling Amplifier v2.0.1.97 WiN, v2.0.1.96 OSX Incl Keygen

October 17, 2016, 7:20 am

Mp3 Download: Mdu - Kunjenjenjena

December 7, 2017, 8:16 am

How the kill the job , when DTP request running for long hours.

July 26, 2013, 2:41 am

Microsoft Intune から展開しているアプリのアップデートについて

October 17, 2016, 4:11 am

18-year-old girl was beaten for half an hour by two Northampton men in 'an...

September 1, 2017, 10:00 pm

Car crash in Dunton Bassett leaves driver in critical condition

October 7, 2014, 7:51 am

Macky 2, Two Others In Road Accident

March 29, 2015, 5:34 am

Application log 00000000000000089514: Could not convert queue DLVST90CLNT

May 14, 2015, 11:27 pm

Detroit mafia: D’Anna Brothers agree to plea deal

April 21, 2016, 6:56 am

Delivery block field greyed out using VA02

January 26, 2016, 2:52 pm

Muloraki Au

June 22, 2016, 1:44 am

【個人撮影】スマホのプライベート映像♪「中に出さないで///」カラオケ屋での生ハメ撮りが流出ｗ【リベンジポルノ】＠PornHub

October 12, 2017, 2:23 pm

BREAKING NEWS: Diamond Platnumz Is Reported Dead After Ghastly Car Accident

February 9, 2018, 4:56 am

FIAT 500 B0111 B0112

July 5, 2018, 10:31 am
Search