tracerays.br

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

    
    if(trinum < 0){
      if(validhit > 0 || oldhit.data.w >= 0){
	raystate.state = float4(0,0,1,0);
      }
      else{
	raystate.state = float4(1,0,0,0);
      }
    }
    else
      raystate.state = float4(0,1,0,oldraystate.state.w+1);
  }
  
  else{
    hit.data = oldhit.data;
    raystate.state = oldraystate.state;
  }
    
}

/*
kernel void krnBruteIntersectTriangle(Ray ray<>, Triangle tris[], float idx, 
				      Hit oldhit<>,TraversalDataDyn travdatdyn<>, RayState oldraystate<>,
				      out Hit hit<>, out RayState raystate<>){
  
  float det, inv_det;
  float3 edge1, edge2, pvec, tvec, qvec;
  float validhit;
  float4 newhit;  //tt,uu,vv,id

  if(oldraystate.state.y > 0){
    edge1 = tris[idx].v1 - tris[idx].v0;
    edge2 = tris[idx].v2 - tris[idx].v0;
    pvec = cross(ray.d, edge2);
    det = dot(edge1, pvec);
    inv_det = 1.0f/det;
    tvec = ray.o - tris[idx].v0;
    newhit.y = dot( tvec, pvec ) * inv_det;
    qvec = cross( tvec, edge1 );
    newhit.z = dot( ray.d, qvec ) * inv_det;
    newhit.x = dot( edge2, qvec ) * inv_det;
    newhit.w = idx;
    
    validhit = (newhit.y >= 0.0f && newhit.z >= 0.0f && (newhit.y+newhit.z) <= 1.0f &&
		newhit.x <= oldhit.data.x && newhit.x >= 0.0f) ? 1 : 0;
    
    //valid only if in voxel too...
    
    if (validhit){
      hit.data = newhit;
    }
    else{
      hit.data = oldhit.data;
    }

    
    raystate.state = float4(0, 0, 1, oldraystate.state.w+1); //only done at end of voxel
  }
}
*/

kernel void krnShadeHits(Ray ray<>, Hit hit<>, Triangle tris[],
			 ShadingInfo shadinf[], float3 pointlight,
			 RayState oldraystate<>, out Pixel pixel<>){

  float3 hitpoint, lightdir, barycoord, N, C;
  float NdotL;
  float3 newcolor;
  
  if(oldraystate.state.z > 0){
    //might need to change ordering
    barycoord = float3(hit.data.y, hit.data.z, 1.0f - hit.data.y - hit.data.z);
    
    
    N = shadinf[hit.data.w].n0*barycoord.x +
      shadinf[hit.data.w].n1*barycoord.y +
      shadinf[hit.data.w].n2*barycoord.z;
    
    C = shadinf[hit.data.w].c0*barycoord.x +
      shadinf[hit.data.w].c1*barycoord.y +
      shadinf[hit.data.w].c2*barycoord.z;
    
    hitpoint = ray.o + ray.d*hit.data.x;
    
    lightdir = pointlight - hitpoint;
    lightdir = lightdir/sqrt(dot(lightdir, lightdir)); //normalize
    
    NdotL = max(0,dot(N, lightdir)); //one sided lighting
    
    newcolor = C*NdotL;
    
    if(hit.data.w >= 0)
      pixel.data = float4(newcolor.x, newcolor.y, newcolor.z, 1);
    else
      pixel.data = float4(0,1,0,0);
    
   }
   else
     pixel.data = float4(0,0,0,0);
}

/*
reduce void reduceDoneTest(float4 raystate<>,
			   reduce float4 activerays<>) {
  activerays.x = activerays.x + raystate.x;
  activerays.y = activerays.y + raystate.y;
  activerays.z = activerays.z + raystate.z;
  activerays.w = activerays.w + raystate.w;
}
*/

kernel void krnDebug( TraversalDataDyn travdatdyn<>,
		      TraversalDataStatic travdatstatic<>,
		      float3 grid_dim,
		      RayState raystate<>,
		      out Pixel pixel<>){
  float3 val;
  
  //val = raystate.state;
  val = travdatdyn.voxno / grid_dim;
  pixel.data = float4(val.x, val.y, val.z, 1);
}

void TraceRays( float lookfromX, float lookfromY, float lookfromZ,
		float uX, float uY, float uZ,
		float vX, float vY, float vZ,
		float wX, float wY, float wZ,
		float tx, float ty,
		float gridminX, float gridminY, float gridminZ,
		float gridmaxX, float gridmaxY, float gridmaxZ,
		float griddimX, float griddimY, float griddimZ,
		float gridvsizeX, float gridvsizeY, float gridvsizeZ,
		int* grid_trilist_offset, int* grid_trilist,
		int numtris, int numvox, int trilistsize,
		float* triv0, float* triv1, float* triv2,
		float* trin0, float* trin1, float* trin2,
		float* tric0, float* tric1, float* tric2,
		float pointlightX, float pointlightY, float pointlightZ,
		float* imgbuf){
  
  int ii;
  //RayState activerays;
  
  float3 lookfrom = float3(lookfromX, lookfromY, lookfromZ);
  float3 u = float3(uX, uY, uZ);
  float3 v = float3(vX, vY, vZ);
  float3 w = float3(wX, wY, wZ);
  float2 txty = float2(tx, ty);
  float2 txty2 = float2(2.0*tx, 2.0*ty);
  float3 grid_min = float3(gridminX, gridminY, gridminZ);
  float3 grid_max = float3(gridmaxX, gridmaxY, gridmaxZ);
  float3 grid_dim = float3(griddimX, griddimY, griddimZ);
  float3 grid_vsize = float3(gridvsizeX, gridvsizeY, gridvsizeZ);
  float3 pointlight = float3(pointlightX, pointlightY, pointlightZ);
  
  iter float2 wpos_norm<W,H> = iter(float2(0,0), float2(1,1));
  
  Triangle tris <numtris>;
  ShadingInfo shadinf <numtris>;
  GridTrilistOffset listoffset<numvox>;
  GridTrilist trilist<trilistsize>;
  
  Ray rays<W,H>;
  RayState raystates<W,H>;
  Hit hits<W,H>;
  Hit candidatehits<W,H>;
  TraversalDataDyn travdatdyn<W,H>;
  TraversalDataStatic travdatstatic<W,H>;  
  Pixel pixels <W,H>;

  //doublebuffer crap
  RayState Braystates<W,H>;
  Hit Bhits<W,H>;
  TraversalDataDyn Btravdatdyn<W,H>;



  for(ii=0; ii<numtris; ii++){
    tridat[ii].v0 = float3(triv0[3*ii+0], triv0[3*ii+1], triv0[3*ii+2]);
    tridat[ii].v1 = float3(triv1[3*ii+0], triv1[3*ii+1], triv1[3*ii+2]);
    tridat[ii].v2 = float3(triv2[3*ii+0], triv2[3*ii+1], triv2[3*ii+2]);
    shadinfdat[ii].n0 = float3(trin0[3*ii+0], trin0[3*ii+1], trin0[3*ii+2]);
    shadinfdat[ii].n1 = float3(trin1[3*ii+0], trin1[3*ii+1], trin1[3*ii+2]);
    shadinfdat[ii].n2 = float3(trin2[3*ii+0], trin2[3*ii+1], trin2[3*ii+2]);
    shadinfdat[ii].c0 = float3(tric0[3*ii+0], tric0[3*ii+1], tric0[3*ii+2]);
    shadinfdat[ii].c1 = float3(tric1[3*ii+0], tric1[3*ii+1], tric1[3*ii+2]);
    shadinfdat[ii].c2 = float3(tric2[3*ii+0], tric2[3*ii+1], tric2[3*ii+2]);
  }

  streamRead(tris, tridat);
  streamRead(shadinf, shadinfdat);

  for(ii=0; ii<W*H; ii++){
    emptyhits[ii].x = 999999;
    emptyhits[ii].y = 0;
    emptyhits[ii].z = 0;
    emptyhits[ii].w = -1;
  }
  streamRead(hits, emptyhits);


  for(ii=0; ii<numvox; ii++){
    listoffsetdat[ii].listoffset = (float)grid_trilist_offset[ii];
  }
  streamRead(listoffset, listoffsetdat);

  for(ii=0; ii<trilistsize; ii++){
    trilistdat[ii].trinum = (float)grid_trilist[ii];
  }
  streamRead(trilist, trilistdat);


  

  //----------------------------------------
  //--- the actual ray tracing loop --------

  
  fprintf(stderr, "gen eye rays\n");
  krnGenEyeRays( lookfrom, u, v, w, txty, txty2, grid_min, grid_max, wpos_norm,
		 rays );

  fprintf(stderr, "setup traversal\n");
  krnSetupTraversal(rays, grid_min, grid_vsize, grid_dim,
		    travdatdyn, travdatstatic, raystates);

  fprintf(stderr, "traversing and intersecting\n");
  for(ii=0; ii<900; ii++){ //adjust depending on scene...
    //fprintf(stderr, "traverse voxel %i\n", ii);
    krnTraverseVoxel(rays, travdatstatic, travdatdyn, raystates, listoffset, grid_dim,
		     Btravdatdyn, Braystates);
    krnTraverseVoxel(rays, travdatstatic, Btravdatdyn, Braystates, listoffset, grid_dim,
		     travdatdyn, raystates);

    //fprintf(stderr, "intersect triangle %i\n", ii);
    krnIntersectTriangle(rays, tris, raystates, trilist,
			 candidatehits );
    krnValidateIntersection(rays, candidatehits, grid_min, grid_vsize, grid_dim, hits,
			    travdatdyn, raystates, trilist,
			    Bhits, Braystates);
    krnIntersectTriangle(rays, tris, Braystates, trilist,
			 candidatehits );
    krnValidateIntersection(rays, candidatehits, grid_min, grid_vsize, grid_dim, Bhits,
			    travdatdyn, Braystates, trilist,
			    hits, raystates);

  }

  //reduceDoneTest(raystates, activerays);
  
  //for(ii = 0; ii < numtris; ii++){
  //  fprintf(stderr, "intersect triangle %i\n", ii);
  //  krnBruteIntersectTriangle(rays, tris, (float)ii, hits, travdatdyn, raystates,
  //			      hits, raystates);
  //}

  fprintf(stderr, "shade hits\n");
  krnShadeHits(rays, hits, tris, shadinf, pointlight, raystates,
	       pixels);
  
  //krnDebug(travdatdyn, travdatstatic, grid_dim, raystates, pixels);
  
  streamWrite(pixels, imgbuf);
  
  fprintf(stderr, "done\n");
}