rapid.br

用于GPU通用计算的编程语言BrookGPU 0.4

  return r?0:1;
}
kernel void CheckTriangleCollide(float3 mRx,
                                 float3 mRy,
                                 float3 mRz,
                                 float3 mT,
                                 float4 collisions<>,
                                 Tri t1List[][],
                                 Tri t2List[][],
                                 vout [1] float4 hits<>) {
  float isASentinel = (collisions.x>=0&&collisions.x<16384)?0:1;
  float4 sentinelHolder = {1,0,1,0};
  float4 triIndex = isASentinel?sentinelHolder:collisions;
  Tri t1 = t1List[triIndex.xy];
  Tri t2 = t2List[triIndex.zw];
  if ((isASentinel==0)&&TrianglesHaveContact(mRx,mRy,mRz,mT,
                                             t1,t2)) {
    hits= collisions;
    push(hits);
  }
}
kernel void CheckTriangleCollideNoCompact(float3 mRx,
                                          float3 mRy,
                                          float3 mRz,
                                          float3 mT,
                                          float4 collisions<>,
                                          Tri t1List[][],
                                          Tri t2List[][],
                                          out float4 hits<>) {
  float isASentinel = (collisions.x>=0&&collisions.x<16384)?0:1;
  float4 sentinelHolder = {1,0,1,0};
  float4 triIndex = isASentinel?sentinelHolder:collisions;
  Tri t1 = t1List[triIndex.xy];
  Tri t2 = t2List[triIndex.zw];
  if ((isASentinel==0)&&TrianglesHaveContact(mRx,mRy,mRz,mT,
                                             t1,t2)) {
    hits = collisions;
  }else {
    hits = sentinelHolder;
  }
}
kernel float GetBBSize (float3 Radius ) {
  return Radius.x;
}
kernel void Collide (Traverser currentNode<>,
                     TransposedBBox b1Tree[][], 
                     BBox b2Tree[][], 
                     vout [1]float4 nextNode<>,//xy is parent yz is first of two childs
                                               //additionally if it's <0 then it's -b-1
                     vout [1]float4 collisions<>//index into triangle list
                     ) {
  //push nextNode if currentNode has collision
  TransposedBBox b1=b1Tree[currentNode.index.xy];
  BBox b2=b2Tree[currentNode.index.zw];
  if (!obb_disjoint(currentNode.rotationX.xyz,
                    currentNode.rotationY.xyz,
                    getRotationZ(currentNode),
                    currentNode.translation.xyz,
                    b1.Radius.xyz,
                    b2.Radius.xyz)) {
    if (b1.Radius.w!=0 && b2.Radius.w!=0) {
      // it's a leaf node yo
      // check ye olde triangles
      collisions.xy = b1.Children;
      collisions.zw = b2.Children;
      push(collisions);
    }else {
      nextNode.xy = (indexof currentNode).xy;
      if (b2.Radius.w!=0 
          || (b1.Radius.w==0 && (GetBBSize(b1.Radius.xyz)
                                 >
                                 GetBBSize(b2.Radius.xyz)))) {
        nextNode.zw = b1.Children;       
      }else {
        nextNode.zw = -b2.Children-1;
      }
      push(nextNode);
    }
  }
}


kernel void CollideNoCompact (Traverser currentNode<>,
                              TransposedBBox b1Tree[][], 
                              BBox b2Tree[][], 
                              out float4 nextNode<>,//xy is parent yz is first of two childs
                              //additionally if it's <0 then it's -b-1
                              out float4 collisions<>//index into triangle list
                              ) {
  //push nextNode if currentNode has collision
  TransposedBBox b1=b1Tree[currentNode.index.xy];
  BBox b2=b2Tree[currentNode.index.zw];
  float4 sentinel={1,0,1,0};
  if (!obb_disjoint(currentNode.rotationX.xyz,
                    currentNode.rotationY.xyz,
                    getRotationZ(currentNode),
                    currentNode.translation.xyz,
                    b1.Radius.xyz,
                    b2.Radius.xyz)) {
    if (b1.Radius.w!=0 && b2.Radius.w!=0) {
      // it's a leaf node yo
      // check ye olde triangles
      collisions.xy = b1.Children;
      collisions.zw = b2.Children;
      nextNode=sentinel;
    }else {
      nextNode.xy = (indexof currentNode).xy;
      if (b2.Radius.w!=0 
          || (b1.Radius.w==0 && (GetBBSize(b1.Radius.xyz)
                                 >
                                 GetBBSize(b2.Radius.xyz)))) {
        nextNode.zw = b1.Children;       
      }else {
        nextNode.zw = -b2.Children-1;
      }
      collisions=sentinel;
    }
  }
}


kernel void updateCurrentNode(float stretchX,
                              float4 curNodeIndices<>,
                              TransposedBBox aTree[][],
                              BBox bTree[][],
                              Traverser nodes[][],
                              out Traverser nextNode<>) {
  float isASentinel = (curNodeIndices.x>=0&&curNodeIndices.x<16384)?0:1;
  float4 sentinelHolder = {1,0,1,0};
  float4 prevIndex = isASentinel?sentinelHolder:curNodeIndices;
  float2 leftOrRightChild = {isASentinel?0:modTwo(stretchX
                                                  ?
                                                  (indexof nextNode).x:(indexof nextNode).y),
                             0};
  Traverser lastNode = nodes[prevIndex.xy];
  float2 aTreeIndex = (prevIndex.z>=0)
                        ?prevIndex.zw+leftOrRightChild
                        :lastNode.index.xy;
  float2 bTreeIndex = (prevIndex.z>=0)
                         ?lastNode.index.zw
                         :-prevIndex.zw-1+leftOrRightChild;
  //  float3 lastNodeRotationz = cross(lastNode.Rotationx.xyz,
  //                            lastNode.Rotationy)*lastNode.Rotationx.w;
  if (prevIndex.z>=0) {
    TransposedBBox a =aTree[aTreeIndex];
    /*
    float3 rot_transpX;
    float3 rot_transpY;
    float3 rot_transpZ;
    float3 aRotationz = cross(a.Rotationx.xyz,a.Rotationy)*a.Rotationx.w;
    getMatrixTranspose (a.Rotationx.xyz,
                        a.Rotationy,
                        aRotationz,
                        rot_transpX,rot_transpY,rot_transpZ);    
    */
    float3 atransp_rotz = cross(a.transp_rotx.xyz,a.transp_roty)*a.transp_rotx.w;
    float3 outRotX,outRotY,outRotZ,trans;
    matMult(//rot_transpX,rot_transpY,rot_transpZ,
            a.transp_rotx.xyz,a.transp_roty,atransp_rotz,
            lastNode.rotationX.xyz,lastNode.rotationY.xyz,getRotationZ(lastNode),
            outRotX,outRotY,outRotZ);
    nextNode.rotationX=float4(outRotX.x,outRotX.y,outRotX.z,outRotZ.x);
    nextNode.rotationY=float4(outRotY.x,outRotY.y,outRotY.z,outRotZ.y);
    trans=matVecMult(//rot_transpX,rot_transpY,rot_transpZ,
                     a.transp_rotx.xyz,a.transp_roty,atransp_rotz,
                     lastNode.translation.xyz-a.Translation.xyz);
    nextNode.translation=float4(trans.x,trans.y,trans.z,outRotZ.z);    
  }else {
    BBox b =bTree[bTreeIndex];
    float3 bRotationz = cross(b.Rotationx.xyz,b.Rotationy)*b.Rotationx.w;
    float3 outRotX,outRotY,outRotZ,trans;
    matMult(lastNode.rotationX.xyz,
            lastNode.rotationY.xyz,
            getRotationZ(lastNode),
            b.Rotationx.xyz,
            b.Rotationy,
            bRotationz,
            outRotX,
            outRotY,
            outRotZ);            
    nextNode.rotationX=float4(outRotX.x,outRotX.y,outRotX.z,outRotZ.x);
    nextNode.rotationY=float4(outRotY.x,outRotY.y,outRotY.z,outRotZ.y);
    trans=lastNode.translation.xyz+matVecMult(lastNode.rotationX.xyz,
                                          lastNode.rotationY.xyz,
                                          getRotationZ(lastNode),
                                          b.Translation);
    nextNode.translation=float4(trans.x,trans.y,trans.z,outRotZ.z);    
  }
  nextNode.index=float4 (aTreeIndex.x,aTreeIndex.y,bTreeIndex.x,bTreeIndex.y);

}


void copyTriangle(unsigned int howMany, float t1A<>,float t1B<>, float t1C<>, Tri * tri) {
  unsigned int i;
  float3 * temp;
  temp = (float3*)malloc(sizeof(float3)*howMany);
  for(i=0;i<howMany;++i) {
    temp[i] = tri[i].A;
  }
  streamRead(t1A,temp);
  for(i=0;i<howMany;++i) {
    temp[i] = tri[i].B;
  }
  streamRead(t1B,temp);
  for(i=0;i<howMany;++i) {
    temp[i] = tri[i].C;
  }
  streamRead(t1C,temp);
  free(temp);
}
void TransposeBBoxes (unsigned int howmany, BBox * bb) {
  unsigned int i;
  for (i=0;i<howmany;++i) {
    float4 x = bb[i].Rotationx;
    float3 y = bb[i].Rotationy;
    float3 z;
    z = float3(x.w*(x.y*y.z-x.z*y.y),
               x.w*(x.z*y.x-x.x*y.z),
               x.w*(x.x*y.y-x.y*y.x));
    
    bb[i].Rotationx = float4(x.x,y.x,z.x,x.w);
    bb[i].Rotationy = float3(x.y,y.y,z.y);
    //bb[i].Rotationx = float3(x.z,y.z,z.z);
    
  }
}
void Broken() {
      printf ("Breaking\n");
}

extern int checkPassCorrectness(Traverser *, int, int);
//doCollide returns the number of intersections, stored in the intersections struct between
// the a and b models that have a trans difference between them
unsigned int doCollide (unsigned int widt1, unsigned int heit1, Tri * t1,
                        unsigned int bboxwidt1, unsigned int bboxheit1, BBox * bboxest1,
                        unsigned int widt2, unsigned int heit2, Tri * t2,
                        unsigned int bboxwidt2, unsigned int bboxheit2, BBox * bboxest2,
                        float3 rX,float3 rY, float3 rZ,
                        float3 trans,
                        float3 csRapidColliderrX,
                        float3 csRapidColliderrY,
                        float3 csRapidColliderrZ,
                        float3 csRapidColliderT,
                        float4 ** intersections) {
  unsigned int num_intersections=0;
  unsigned int temp;
  int xsize,ysize,pass=0;
  float stretchX;
  unsigned int alloc_intersections=16;
  TransposedBBox m1<bboxwidt1,bboxheit1>;
  BBox m2<bboxwidt2,bboxheit2>;
  /*  float3 t1A <widt1,heit1>;
  float3 t1B <widt1,heit1>;
  float3 t1C <widt1,heit1>;
  float3 t2A <widt2,heit2>;
  float3 t2B <widt2,heit2>;
  float3 t2C <widt2,heit2>;*/
  Tri t1List<widt1,heit1>;
  Tri t2List<widt2,heit2>;
  float4 hits<1,1>;
  float4 nextNode<1,1>;
  Traverser baseTraverser;
  Traverser trav<1,1>;
  baseTraverser.index=float4(0,0,0,0);
  baseTraverser.rotationX=float4(rX.x,rX.y,rX.z,rZ.x);
  baseTraverser.rotationY=float4(rY.x,rY.y,rY.z,rZ.y);
  baseTraverser.translation=float4(trans.x,trans.y,trans.z,rZ.z);
  streamRead(trav,&baseTraverser);
  *intersections=(float4*)malloc(alloc_intersections*sizeof(float4));
  /*copyTriangle(widt1*heit1,t1A,t1B,t1C,t1);
    copyTriangle(widt2*heit2,t2A,t2B,t2C,t2);*/
  streamRead(t1List,t1);
  streamRead(t2List,t2);
  streamRead(m2,bboxest2);
  TransposeBBoxes(bboxwidt1*bboxheit1,bboxest1);
  streamRead(m1,bboxest1);
  
  do {
     Collide(trav,m1,m2,nextNode,hits);
     xsize = (int)streamSize(nextNode).x;
     ysize = (int)streamSize(nextNode).y;     
     
     stretchX= (ysize*2>maxwid)?1.0:0.0;
     if (stretchX) xsize*=2; else ysize*=2;
     if (xsize&&ysize) {
        Traverser temp<ysize,xsize>;
        streamSwap(temp,trav);
        updateCurrentNode(stretchX,
                          nextNode,
                          m1,
                          m2,
                          temp,
                          trav);
     }
     temp = (int)streamSize(hits).x*(int)streamSize(hits).y;
     if (xsize*ysize){
       Traverser * temptrav;
       temptrav = (Traverser *)malloc(sizeof(Traverser)*xsize*ysize);
       streamWrite(trav,temptrav);
       pass++;
       checkPassCorrectness(temptrav,xsize*ysize,pass);
       free(temptrav);
     }
     printf("Pass %d Num Tri Checks %d num nodes %d %d\n",pass,temp,xsize,ysize);

     if (temp) {
       
       CheckTriangleCollide(csRapidColliderrX,csRapidColliderrY,csRapidColliderrZ,csRapidColliderT,
                            hits,
                            t1List,
                            t2List,
                            nextNode);
       streamSwap(hits,nextNode);
       temp = (int)streamSize(hits).x*(int)streamSize(hits).y;
       if (temp) {
         unsigned int i;
         while (num_intersections+temp>alloc_intersections) {
           alloc_intersections*=2;
           *intersections= (float4*)realloc(*intersections,alloc_intersections*sizeof(float4));
         }
         streamWrite(hits,*intersections+num_intersections);
         for (i=0;i<temp;++i) {
           float4 f4 = *(*intersections+num_intersections+i);
           if (!(f4.x>=0&&f4.x<streamSize(t1List).x))
             break;
           if (!(f4.y>=0&&f4.y<streamSize(t1List).y))
             break;
         }
         num_intersections+=i;
         printf ("Detected %d hits\n",i);
       }
     }
  }while(xsize&&ysize);
  return num_intersections;
}

kernel void SimpleCheckTriangleCollide(float3 mRx,
                                       float3 mRy,
                                       float3 mRz,
                                       float3 mT,
                                       float4 collisions<>,
                                       Tri t1List[][],
                                       Tri t2List[][],
                                       out float4 hits<>) {
  Tri t1 = t1List[collisions.xy];
  Tri t2 = t2List[collisions.zw];
  float4 neg1=-1;
  hits= TrianglesHaveContact(mRx,mRy,mRz,mT,
                             t1,t2)?collisions:neg1;
}