raytracer.cpp

来自「Ray tracing on PS3, using the accelerati」· C++ 代码 · 共 399 行 · 第 1/2 页

    for (int j = 0; (count < 15) && tAlloc && (j < objects->num_triangles); j++) {
      (*(objects->triangles+j)).intersectPacket(sray, shit, 0.01f);
    }
    occluded = spu_cmpgt(distanceToLight, shit.t);
    
    color.r = spu_sel(spu_add(color.r, curr.r), color.r, occluded);
    color.g = spu_sel(spu_add(color.g, curr.g), color.g, occluded);
    color.b = spu_sel(spu_add(color.b, curr.b), color.b, occluded);
#else
    color.r = spu_add(color.r, curr.r);
    color.g = spu_add(color.g, curr.g);
    color.b = spu_add(color.b, curr.b);
#endif //SHADOWS
    
#else
    vector float grayShade = _dot_product3_v(hit.nx, hit.ny, hit.nz, dirToLightx, dirToLighty, dirToLightz);
    // TODO: FINISH THIS, YOU LEFT FOR DINNER!!!!
    color.r = color.g = color.b = grayShade;
#endif
    
  }
  
  // add the ambient lighting term

  vector unsigned char splat0 = (vector unsigned char) {0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3};
  vector unsigned char splat1 = (vector unsigned char) {4,5,6,7,4,5,6,7,4,5,6,7,4,5,6,7};
  vector unsigned char splat2 = (vector unsigned char) {8,9,10,11,8,9,10,11,8,9,10,11,8,9,10,11};
 
  // Compute and add the ambient term to the color, regardless of light sources
#if(SHADING)
  RGBPacket amb_term;
  RGBPacket diffuse_color;
  diffuse_color.r = diffuse_color.g = diffuse_color.b = zero_v;
  material_getDiffuseColor(objects->materials, diffuse_color, hit, x, y, z, changed);

  amb_term.r = spu_shuffle(ambient_light, ambient_light, splat0);
  amb_term.g = spu_shuffle(ambient_light, ambient_light, splat1);
  amb_term.b = spu_shuffle(ambient_light, ambient_light, splat2);
  amb_term.r = spu_mul(amb_term.r, diffuse_color.r);
  amb_term.g = spu_mul(amb_term.g, diffuse_color.g);
  amb_term.b = spu_mul(amb_term.b, diffuse_color.b);
  amb_term.r = spu_add(color.r, amb_term.r);
  amb_term.g = spu_add(color.g, amb_term.g);
  amb_term.b = spu_add(color.b, amb_term.b);  

  color.r = spu_sel(color.r, amb_term.r, changed);
  color.g = spu_sel(color.g, amb_term.g, changed);
  color.b = spu_sel(color.b, amb_term.b, changed);
#endif

  
  // Only add this code to the method if we're bouncing, since it has an inefficient, hard-to-predict branch
#if (MAX_BOUNCES>0)
  
  vector float clipweight = spu_splats((float)CLIPPING_WEIGHT);  

  
  if ((bounces > 0)) {
  
    vector unsigned int sign_bit = spu_splats((unsigned int) 0x80000000);
    vector float rayDotn = _dot_product3_v(hit.nx, hit.ny, hit.nz, r.dx, r.dy, r.dz);
    RGBPacket reflectiveColor;
    reflectiveColor.r = reflectiveColor.g = reflectiveColor.b = zero_v;
    material_getReflectiveColor(objects->materials, reflectiveColor, hit, x, y, z, changed);
    material_bumpNormal(objects->materials, hit, x,y,z,changed);
    vector unsigned int colorgtclip = spu_cmpgt(reflectiveColor.r, clipweight);
    colorgtclip = spu_or(colorgtclip, spu_cmpgt(reflectiveColor.g, clipweight));
    colorgtclip = spu_or(colorgtclip, spu_cmpgt(reflectiveColor.b, clipweight));
    colorgtclip = spu_gather(colorgtclip);

    vector float clipt_v = spu_splats((float)CLIPPING_T);
    vector unsigned int reflectiver = spu_cmpgt(reflectiveColor.r, zero_v);
    vector unsigned int reflectiveg = spu_cmpgt(reflectiveColor.g, zero_v);
    vector unsigned int reflectiveb = spu_cmpgt(reflectiveColor.b, zero_v);
    vector unsigned int  reflective = spu_or(reflectiver, reflectiveg);
    vector unsigned int frontSide = spu_cmpgt(zero_v, rayDotn);	
    vector unsigned int clipgthit = spu_cmpgt(clipt_v, hit.t);
    reflective = spu_or(reflective, reflectiveb);
    // Make sure we actually have a hit at this point...
    reflective = spu_and(reflective, changed);
    //clipgthit = spu_gather(clipgthit);
    //reflective = spu_and(reflective, spu_cmpgt(spu_splats((float)bounces), zero_v));
    // As we trace packets, we must trace one whole packet even if only one ray reflects... bummer.
    reflective = spu_and(reflective, clipgthit);
    //reflective = spu_and(reflective, colorgtclip);
    reflectiveb = spu_gather(reflective);
    int recurse = (spu_extract(reflectiveb, 0) > 0);
    // recurse for reflection...
    if (recurse) {
      RayPacket ref;
      HitPacket refHit;
      RGBPacket bounceColor;
      vector float rnx, rny, rnz;
      rnx = (vector float) spu_xor((vector unsigned int)hit.nx, sign_bit);
      rny = (vector float) spu_xor((vector unsigned int)hit.ny, sign_bit);
      rnz = (vector float) spu_xor((vector unsigned int)hit.nz, sign_bit);
      rnx = spu_sel(rnx, hit.nx, frontSide);
      rny = spu_sel(rny, hit.ny, frontSide);
      rnz = spu_sel(rnz, hit.nz, frontSide);
      _reflect_vec3_v(&ref.dx, &ref.dy, &ref.dz,r.dx,r.dy, r.dz, rnx, rny, rnz);
      ref.dx = spu_sel(zero_v, ref.dx, reflective);
      ref.dy = spu_sel(zero_v, ref.dy, reflective);
      ref.dz = spu_sel(zero_v, ref.dz, reflective);
      // Shouldn't have to spu_sel the x,y, and z, since a ray with zero direction shouldn't hit anything anyhow
      ref.x0 = x;
      ref.y0 = y;
      ref.z0 = z;
      refHit.t = max_v;
      refHit.nx = refHit.ny = refHit.nz = zero_v;
      bounceColor = tracePacket(ref, refHit, 0.01f, bounces - 1, refIndex);
      reflectiveColor.r = spu_mul(bounceColor.r, reflectiveColor.r);
      reflectiveColor.g = spu_mul(bounceColor.g, reflectiveColor.g);
      reflectiveColor.b = spu_mul(bounceColor.b, reflectiveColor.b);
      reflectiveColor.r = spu_add(color.r, reflectiveColor.r);
      reflectiveColor.g = spu_add(color.g, reflectiveColor.g);
      reflectiveColor.b = spu_add(color.b, reflectiveColor.b);
      color.r = spu_sel(color.r, reflectiveColor.r, reflective);
      color.g = spu_sel(color.g, reflectiveColor.g, reflective);
      color.b = spu_sel(color.b, reflectiveColor.b, reflective);    
    }
#if (MAX_BOUNCES>1)
    // Do the same for refraction..
    RGBPacket transparentColor;
    transparentColor.r = transparentColor.g = transparentColor.b = zero_v;
    material_getTransparentColor(objects->materials, transparentColor, hit, x, y, z, changed);
    colorgtclip = spu_cmpgt(transparentColor.r, clipweight);
    colorgtclip = spu_or(colorgtclip, spu_cmpgt(transparentColor.g, clipweight));
    colorgtclip = spu_or(colorgtclip, spu_cmpgt(transparentColor.b, clipweight));
    colorgtclip = spu_gather(colorgtclip);
    vector unsigned int refractiver = spu_cmpgt(transparentColor.r, zero_v);
    vector unsigned int refractiveg = spu_cmpgt(transparentColor.g, zero_v);
    vector unsigned int refractiveb = spu_cmpgt(transparentColor.b, zero_v);
    vector unsigned int refractive;
    refractive = spu_or(refractiver, refractiveg);
    refractive = spu_or(refractive, refractiveb);
    refractive = spu_and(refractive, clipgthit);
    //refractive = spu_and(refractive, colorgtclip);
    recurse = (spu_extract(spu_gather(refractive), 0) > 0);
    if (recurse) {
      RayPacket refray;
      vector float negnx, negny, negnz;
      // TODO: I believe this method is not implemented yet.... parameters may change
      vector float RI;
      material_getRefractiveIndex(objects->materials,RI,  hit, x, y, z, changed);
      negnx = (vector float) spu_xor((vector unsigned int) hit.nx, sign_bit);
      negny = (vector float) spu_xor((vector unsigned int) hit.ny, sign_bit);
      negnz = (vector float) spu_xor((vector unsigned int) hit.nz, sign_bit);
      negnx = spu_sel(negnx, hit.nx, frontSide);
      negny = spu_sel(negny, hit.ny, frontSide);
      negnz = spu_sel(negnz, hit.nz, frontSide);
      vector float newRI = spu_sel(one_v, RI, frontSide);
      RI = spu_sel(RI, one_v, frontSide);
      vector unsigned int valid = transmit_vec3_v(refray.dx, refray.dy, refray.dz,
						  negnx, negny, negnz,
						  r.dx, r.dy, r.dz,
						  RI, newRI);
      refray.x0 = x;
      refray.y0 = y; 
      refray.z0 = z;
      HitPacket mHit;
      mHit.t = max_v; 
      mHit.nx = mHit.ny = mHit.nz = zero_v;
      RGBPacket bounceColor;
      valid = spu_and(valid, refractive);
      bounceColor = tracePacket(refray, mHit, 0.01f, bounces - 1, newRI);
      transparentColor.r = spu_mul(transparentColor.r, bounceColor.r);
      transparentColor.g = spu_mul(transparentColor.g, bounceColor.g);
      transparentColor.b = spu_mul(transparentColor.b, bounceColor.b);
      transparentColor.r = spu_add(transparentColor.r, color.r);
      transparentColor.g = spu_add(transparentColor.g, color.g);
      transparentColor.b = spu_add(transparentColor.b, color.b);
      color.r = spu_sel(color.r, transparentColor.r, valid);
      color.g = spu_sel(color.g, transparentColor.g, valid);
      color.b = spu_sel(color.b, transparentColor.b, valid);
    }
#endif
     }
#endif
  /*
  if (spu_extract(changed, 0)) {
    printf("tracePacket: hit updated: %f %f %f %f\n", spu_extract(hit.t, 0), spu_extract(hit.nx, 0), spu_extract(hit.ny, 0), spu_extract(hit.nz, 0));
  }
  */
  // For now, normal vizualization...
  /*
  color.r = spu_sel(zero_v, fabsf4(hit.nx), changed);
  color.g = spu_sel(zero_v, fabsf4(hit.ny), changed);
  color.b = spu_sel(zero_v, fabsf4(hit.nz), changed);
  */
  // ... and depth visualization
  /*
  color.r = spu_sel(zero_v, spu_mul(spu_sub(hit.t, one_v), half), changed);
  color.g = spu_sel(zero_v, spu_mul(spu_sub(hit.t, one_v), half), changed);
  color.b = spu_sel(zero_v, spu_mul(spu_sub(hit.t, one_v), half), changed);
  */
  return color;
}