Radiance3 Raytracer::backwardTrace(const Ray& ray, int backwardBouncesLeft) const
{
Color3 pixelColor;
Tri::Intersector intersector;
float distance = inf();
// use tri tree
if (_settings._useTriTree)
{
if (_triTree.intersectRay(ray, intersector, distance))
{
pixelColor = shadePixel(intersector, ray, backwardBouncesLeft);
}
}
// or just go through array
else
{
distance = inf();
for (int i = 0; i < _triTree.size(); ++i)
{
intersector(ray, _triTree[i], distance);
if (distance < inf())
{
pixelColor = shadePixel(intersector, ray, backwardBouncesLeft);
}
}
}
return pixelColor;
}
void
RefRenderer::render() {
// render all circles
for (int circleIndex=0; circleIndex<numCircles; circleIndex++) {
int index3 = 3 * circleIndex;
float px = position[index3];
float py = position[index3+1];
float pz = position[index3+2];
float rad = radius[circleIndex];
// compute the bounding box of the circle. This bounding box
// is in normalized coordinates
float minX = px - rad;
float maxX = px + rad;
float minY = py - rad;
float maxY = py + rad;
// convert normalized coordinate bounds to integer screen
// pixel bounds. Clamp to the edges of the screen.
int screenMinX = CLAMP(static_cast<int>(minX * image->width), 0, image->width);
int screenMaxX = CLAMP(static_cast<int>(maxX * image->width)+1, 0, image->width);
int screenMinY = CLAMP(static_cast<int>(minY * image->height), 0, image->height);
int screenMaxY = CLAMP(static_cast<int>(maxY * image->height)+1, 0, image->height);
float invWidth = 1.f / image->width;
float invHeight = 1.f / image->height;
// for each pixel in the bounding box, determine the circle's
// contribution to the pixel. The contribution is computed in
// the function shadePixel. Since the circle does not fill
// the bounding box entirely, not every pixel in the box will
// receive contribution.
for (int pixelY=screenMinY; pixelY<screenMaxY; pixelY++) {
// pointer to pixel data
float* imgPtr = &image->data[4 * (pixelY * image->width + screenMinX)];
for (int pixelX=screenMinX; pixelX<screenMaxX; pixelX++) {
// When "shading" the pixel ("shading" = computing the
// circle's color and opacity at the pixel), we treat
// the pixel as a point at the center of the pixel.
// We'll compute the color of the circle at this
// point. Note that shading math will occur in the
// normalized [0,1]^2 coordinate space, so we convert
// the pixel center into this coordinate space prior
// to calling shadePixel.
float pixelCenterNormX = invWidth * (static_cast<float>(pixelX) + 0.5f);
float pixelCenterNormY = invHeight * (static_cast<float>(pixelY) + 0.5f);
shadePixel(circleIndex, pixelCenterNormX, pixelCenterNormY, px, py, pz, imgPtr);
imgPtr += 4;
}
}
}
}
/*
Loop through every pixel in the display and call shadePixel with its
coordinates, its index and the current time vector.
*/
void run_shader(void){
struct timeval tv;
double t;
while(1){
gettimeofday(&tv, NULL);
t = (tv.tv_sec) * 1000 + (tv.tv_usec) / 1000;
for(y=0; y<8; y++){
for(x=0; x<8; x++){
int pixel = getPixelPosition(x,y);
shadePixel(t, pixel, x/7.0, y/7.0);
}
}
show();
usleep(1);
}
}
