void LoadScene(TiXmlElement *element)
{
for ( TiXmlElement *child = element->FirstChildElement(); child!=NULL; child = child->NextSiblingElement() ) {
if ( COMPARE( child->Value(), "background" ) ) {
Color c(1,1,1);
ReadColor( child, c );
background.SetColor(c);
printf("Background %f %f %f\n",c.r,c.g,c.b);
background.SetTexture( ReadTexture(child) );
} else if ( COMPARE( child->Value(), "environment" ) ) {
Color c(1,1,1);
ReadColor( child, c );
environment.SetColor(c);
printf("Environment %f %f %f\n",c.r,c.g,c.b);
environment.SetTexture( ReadTexture(child) );
} else if ( COMPARE( child->Value(), "object" ) ) {
LoadNode( &rootNode, child );
} else if ( COMPARE( child->Value(), "material" ) ) {
LoadMaterial( child );
} else if ( COMPARE( child->Value(), "light" ) ) {
LoadLight( child );
}
}
}
void Renderer::calculatePixelColor(Node &i_rootNode, LightList &i_lightList, int offsetAlongWidth, int offsetAlongHeight)
{
HitInfo hitInfo;
Color noHitPixelColor = { 0,0,0 };
Color finalColor = { 0,0,0 };
RandomSampler sampler = RandomSampler(MIN_SAMPLE_COUNT, MAX_SAMPLE_COUNT, MIN_VARIANCE, MAX_VARIANCE);
while (sampler.needMoreSamples())
{
sampler.generateSamples(offsetAlongWidth, offsetAlongHeight);
for (int k = 0; k < sampler.getSampleBucketSize(); ++k)
{
hitInfo.Init();
Ray sampleRay = sampler.getSampleRay(k);
if (TraceRay(&i_rootNode, sampleRay, hitInfo))
{
finalColor = hitInfo.node->GetMaterial()->Shade(sampleRay, hitInfo,
i_lightList, REFLECTION_BOUNCE_COUNT, GI_BOUNCE_COUNT);
/*finalColor.r = pow(finalColor.r, 1/2.2);
finalColor.g = pow(finalColor.g, 1/2.2);
finalColor.b = pow(finalColor.b, 1/2.2);*/
sampler.setSampleColor(k, finalColor);
sampler.setIsSampleHit(k, true);
}
else
{
sampler.setSampleColor(k, background.Sample(sampleRay.dir));
}
sampler.setHitInfo(k, hitInfo);
}
}
Color tempColor = sampler.getAveragedSampleListColor();
tempColor.r = pow(tempColor.r, 1 / 2.2);
tempColor.g = pow(tempColor.g, 1 / 2.2);
tempColor.b = pow(tempColor.b, 1 / 2.2);
float depth = sampler.getAveragedDepth();
int sampleCount = sampler.getSampleBucketSize();
int pixel = offsetAlongHeight * imageWidth + offsetAlongWidth;
TCHAR* mutexName = __T("WritingMutex");
static HANDLE mutexHandle = NULL;
if( mutexHandle == NULL )
mutexHandle = OpenMutex(MUTEX_ALL_ACCESS, FALSE, mutexName);
DWORD dSuccess = WaitForSingleObject(mutexHandle, INFINITE);
assert(dSuccess == WAIT_OBJECT_0);
renderingImage[pixel] = tempColor;
operationCountImage[pixel] = Color(1.0f,0.0f,0.0f) * static_cast<float>(hitInfo.operationCount/BIGFLOAT);
zBufferImage[pixel] = depth;
sampleCountImage[pixel] = sampleCount;
bool bSuccess = ReleaseMutex(mutexHandle);
assert(bSuccess == true);
sampler.resetSampler();
}
void ShowViewport()
{
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH );
if (glutGet(GLUT_SCREEN_WIDTH) > 0 && glutGet(GLUT_SCREEN_HEIGHT) > 0){
glutInitWindowPosition( (glutGet(GLUT_SCREEN_WIDTH) - camera.imgWidth)/2, (glutGet(GLUT_SCREEN_HEIGHT) - camera.imgHeight)/2 );
}
else glutInitWindowPosition( 50, 50 );
glutInitWindowSize(camera.imgWidth, camera.imgHeight);
glutCreateWindow("Ray Tracer - CS 6620");
glutDisplayFunc(GlutDisplay);
glutReshapeFunc(GlutReshape);
glutIdleFunc(GlutIdle);
glutKeyboardFunc(GlutKeyboard);
glutMouseFunc(GlutMouse);
glutMotionFunc(GlutMotion);
Color bg = background.GetColor();
glClearColor(bg.r,bg.g,bg.b,0);
glPointSize(3.0);
glEnable( GL_CULL_FACE );
float zero[] = {0,0,0,0};
glLightModelfv( GL_LIGHT_MODEL_AMBIENT, zero );
glEnable(GL_NORMALIZE);
glLineWidth(2);
if ( camera.dof > 0 ) {
dofBuffer = new Color24[ camera.imgWidth * camera.imgHeight ];
dofImage = new Color[ camera.imgWidth * camera.imgHeight ];
memset( dofImage, 0, camera.imgWidth * camera.imgHeight * sizeof(Color) );
}
glutMainLoop();
}
void DrawScene()
{
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
const TextureMap *bgMap = background.GetTexture();
if ( bgMap ) {
glDepthMask(GL_FALSE);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
Color c = background.GetColor();
glColor3f(c.r,c.g,c.b);
if ( bgMap->SetViewportTexture() ) {
glEnable( GL_TEXTURE_2D );
glMatrixMode( GL_TEXTURE );
Matrix3 tm = bgMap->GetInverseTransform();
Point3 p = tm * bgMap->GetPosition();
float m[16] = { tm[0],tm[1],tm[2],0, tm[3],tm[4],tm[5],0, tm[6],tm[7],tm[8],0, -p.x,-p.y,-p.z,1 };
glLoadMatrixf( m );
glMatrixMode( GL_MODELVIEW );
} else {
glDisable( GL_TEXTURE_2D );
}
glBegin(GL_QUADS);
glTexCoord2f(0,1);
glVertex2f(-1,-1);
glTexCoord2f(1,1);
glVertex2f( 1,-1);
glTexCoord2f(1,0);
glVertex2f( 1, 1);
glTexCoord2f(0,0);
glVertex2f(-1, 1);
glEnd();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glDepthMask(GL_TRUE);
glDisable( GL_TEXTURE_2D );
}
glEnable( GL_LIGHTING );
glEnable( GL_DEPTH_TEST );
glPushMatrix();
Point3 p = camera.pos;
Point3 t = camera.pos + camera.dir*camera.focaldist;
Point3 u = camera.up;
if ( camera.dof > 0 ) {
Point3 v = camera.dir ^ camera.up;
float r = sqrtf(float(rand())/RAND_MAX)*camera.dof;
float a = M_PI * 2.0f * float(rand())/RAND_MAX;
p += r*cosf(a)*v + r*sinf(a)*u;
}
gluLookAt( p.x, p.y, p.z, t.x, t.y, t.z, u.x, u.y, u.z );
glRotatef( viewAngle1, 1, 0, 0 );
glRotatef( viewAngle2, 0, 0, 1 );
if ( lights.size() > 0 ) {
for ( unsigned int i=0; i<lights.size(); i++ ) {
lights[i]->SetViewportLight(i);
}
} else {
float white[] = {1,1,1,1};
float black[] = {0,0,0,0};
Point4 p(camera.pos, 1);
glEnable ( GL_LIGHT0 );
glLightfv( GL_LIGHT0, GL_AMBIENT, black );
glLightfv( GL_LIGHT0, GL_DIFFUSE, white );
glLightfv( GL_LIGHT0, GL_SPECULAR, white );
glLightfv( GL_LIGHT0, GL_POSITION, &p.x );
}
DrawNode(&rootNode);
glPopMatrix();
glDisable( GL_DEPTH_TEST );
glDisable( GL_LIGHTING );
glDisable( GL_TEXTURE_2D );
}
Color MtlBlinn::Shade(const Ray &ray, const HitInfo &hInfo, const LightList &lights, int reflection_bounceCount, int gi_bounceCount) const
{
Color ambientComp, diffuseComp, specularComp, reflectiveComp, refractiveComp, reflectionTotal, refractionTotal, noColor, diffuseReflection;
diffuseReflection = ambientComp = diffuseComp = specularComp = reflectiveComp = refractiveComp = noColor = reflectionTotal = refractionTotal = Color(0.0f, 0.0f, 0.0f);
Color fromReflection = Color(0.0f, 0.0f, 0.0f);
Color fromRefraction = Color(0.0f, 0.0f, 0.0f);
Point3 viewDirection = -ray.dir;
float schlicksConstant, ratioOfRefraction;
Color kd = diffuse.Sample(hInfo.uvw);
int hitside = HIT_FRONT;
float n1 = 1;
float n2 = ior;
for (int i = 0; i < lights.size(); i++)
{
Color lightColor = lights[i]->Illuminate(hInfo.p, hInfo.N);
/*if (lightColor != noColor)
{*/
if (lights[i]->IsAmbient())
{
ambientComp = ambientComponent(lights[i], lightColor, hInfo, diffuse.Sample(hInfo.uvw));
}
else
{
//lightColor.ClampMinMax();
Point3 rayDir = ray.dir;
globalPhotonMap.EstimateIrradiance<50>(lightColor, rayDir, 2.0f, hInfo.p, &hInfo.N);
diffuseComp = diffuseComponent(lights[i], lightColor, hInfo, diffuse.Sample(hInfo.uvw));
specularComp = specularComponent(lights[i], lightColor, viewDirection, hInfo, specular.Sample(hInfo.uvw), glossiness);
}
//}
}
/************************Refraction************************************************************/
if(refraction.Sample(hInfo.uvw) != noColor && reflection_bounceCount > 0)
{
Ray refractionRay;
HitInfo refractionRayHit;
refractionRayHit.Init();
refractionRay.p = hInfo.p;
if (hInfo.front == HIT_FRONT)
{
refractionRay.dir = getRefractionVector(viewDirection, getPerturbedNormal(hInfo.N, hInfo.p, refractionGlossiness), n1, n2);
}
else
{
refractionRay.dir = getRefractionVector(viewDirection, getPerturbedNormal( -hInfo.N, hInfo.p, refractionGlossiness), n2, n1);
}
if(TraceRay(&rootNode, refractionRay, refractionRayHit, hitside))
{
Point3 refractionDir = refractionRay.dir;
refractiveComp += refractionRayHit.node->GetMaterial()->Shade(refractionRay, refractionRayHit,
lights, --reflection_bounceCount);
refractiveComp *= refraction.Sample(hInfo.uvw);
}
else
{
refractiveComp = environment.SampleEnvironment(refractionRay.dir);
}
}
/********************Schlick's Approximation - Fresnel Reflection***************************/
schlicksConstant = pow(((n1 - n2) / (n1 + n2)), 2);
ratioOfRefraction = schlicksConstant + (1 - schlicksConstant) * pow((1 - viewDirection.Dot(hInfo.N)), 5);
reflectionTotal = ratioOfRefraction*refraction.Sample(hInfo.uvw);
refractionTotal = (1 - ratioOfRefraction)*refraction.Sample(hInfo.uvw);
///*******************************************************************************************/
//refractiv eComp *= refractionTotal; //It = (1-R) * KT'
reflectionTotal += reflection.Sample(hInfo.uvw); //Doing outside in case refraction didn't occured at all
/*********************************************************************************************/
/**********************Reflection*************************************************************/
if(reflectionTotal != noColor && reflection_bounceCount > 0)
{
Ray reflectionViewVector;
reflectionViewVector.dir = getReflectionVector(viewDirection,
getPerturbedNormal(hInfo.N, hInfo.p, reflectionGlossiness));
reflectionViewVector.p = hInfo.p;
HitInfo reflectionRayHit;
reflectionRayHit.Init();
//--reflection_bounceCount;
if (TraceRay(&rootNode, reflectionViewVector, reflectionRayHit, HIT_FRONT))
{
fromReflection += reflectionRayHit.node->GetMaterial()->Shade(reflectionViewVector,
reflectionRayHit, lights, --reflection_bounceCount);
reflectiveComp = reflectionTotal * fromReflection;
}
else
{
reflectiveComp = environment.SampleEnvironment(reflectionViewVector.dir);
}
}
/****************************************************************************************************/
if(GI_ALGO)
{
if (kd != noColor && gi_bounceCount > 0)
{
HemiSphereSampler giHemiSampler = HemiSphereSampler(__gi_sampleCount, __gi_sampleCount, 1);
giHemiSampler.generateSamples();
Point3 randomDirectionAtHitPoint = Point3(0.0f, 0.0f, 0.0f);
HitInfo diffuseReflectionHitInfo;
Ray diffuseReflectionRay;
for (int i = 0; i < giHemiSampler.getCurrentSampleCount(); ++i)
{
randomDirectionAtHitPoint = giHemiSampler.getSample(getRandomNumber(0, giHemiSampler.getCurrentSampleCount())).getOffset();
diffuseReflectionRay.p = hInfo.p;
Point3 u = Point3(0.0f, 0.0f, 0.0f);
Point3 v = Point3(0.0f, 0.0f, 0.0f);
Point3 w = Point3(0.0f, 0.0f, 0.0f);
w = hInfo.N;
getOrthoNormalBasisVector(w, u, v);
diffuseReflectionRay.dir = randomDirectionAtHitPoint.x * u +
randomDirectionAtHitPoint.y * v +
randomDirectionAtHitPoint.z *w;
diffuseReflectionHitInfo.Init();
if (TraceRay(&rootNode, diffuseReflectionRay, diffuseReflectionHitInfo, HIT_FRONT))
{
diffuseReflection = diffuseReflectionHitInfo.node->GetMaterial()->Shade(diffuseReflectionRay,
diffuseReflectionHitInfo, lights, 0, gi_bounceCount - 1);
}
else
{
diffuseReflection = environment.SampleEnvironment(diffuseReflectionRay.dir);
}
giHemiSampler.setSampleColor(i, diffuseReflection);
giHemiSampler.setIsSampleHit(i, true);
}
diffuseReflection = giHemiSampler.getAveragedSampleListColor() * diffuseReflection * kd * M_PI;
}
}
else
{
if (kd != noColor && gi_bounceCount > 0)
{
HemiSphereSampler giHemiSampler = HemiSphereSampler(__gi_sampleCount, __gi_sampleCount, 1);
giHemiSampler.generateSamples();
Point3 randomDirectionAtHitPoint = Point3(0.0f, 0.0f, 0.0f);
HitInfo diffuseReflectionHitInfo;
Ray diffuseReflectionRay;
randomDirectionAtHitPoint = giHemiSampler.getSample(getRandomNumber(0, giHemiSampler.getCurrentSampleCount())).getOffset();
diffuseReflectionRay.p = hInfo.p;
Point3 u = Point3(0.0f, 0.0f, 0.0f);
Point3 v = Point3(0.0f, 0.0f, 0.0f);
Point3 w = Point3(0.0f, 0.0f, 0.0f);
w = hInfo.N;
getOrthoNormalBasisVector(w, u, v);
diffuseReflectionRay.dir = randomDirectionAtHitPoint.x * u +
randomDirectionAtHitPoint.y * v +
randomDirectionAtHitPoint.z *w;
diffuseReflectionHitInfo.Init();
if (TraceRay(&rootNode, diffuseReflectionRay, diffuseReflectionHitInfo, HIT_FRONT))
{
diffuseReflection += diffuseReflectionHitInfo.node->GetMaterial()->Shade(diffuseReflectionRay,
diffuseReflectionHitInfo, lights, 0, gi_bounceCount - 1);
diffuseReflection = diffuseReflection * kd;
}
else
{
diffuseReflection = environment.SampleEnvironment(diffuseReflectionRay.dir);
}
}
}
return (ambientComp + diffuseComp + specularComp+ reflectiveComp + refractiveComp + diffuseReflection);
}
Color MtlBlinn::Shade(const Cone &ray, const HitInfo &hInfo, const LightList &lights, int bounceCount) const{
float bias = BIAS_SHADING;
Color shade;
Color rShade = Color(0,0,0);
Color tShade = Color(0,0,0);
const Material *mat;
mat = hInfo.node->GetMaterial();
const MtlBlinn* mb =static_cast<const MtlBlinn*>(mat);
// cout<<"HInfo front: "<<hInfo.front<<endl;
/* local copy */
Point3 P;
P.Set(hInfo.p.x,hInfo.p.y,hInfo.p.z);
Cone iRay = ray;
Color ambInt = mb->diffuse.Sample(hInfo.uvw, hInfo.duvw);
Color allOther = Color(0,0,0);
Color diffuse = mb->diffuse.Sample(hInfo.uvw, hInfo.duvw);
Color ambComponent = Color(0,0,0);
Point3 newN = hInfo.N;
for ( unsigned int i=0; i<lights.size(); i++ ) {
if(lights[i]->IsAmbient()){
// cout<<"ambient "<<endl;
Color intensity = lights[i]->Illuminate(hInfo.p);
ambComponent += (ambInt * intensity);
continue;
}
else{
// cout<<"other lighting "<<endl;
Point3 L = -lights[i]->Direction(P);
L.Normalize();
Point3 V = ray.p - P;
V.Normalize();
Point3 LplusV = L + V;
Point3 H = (L+V)/LplusV.Length();
H.Normalize();
float alpha = mb->glossiness;
// Point3 N = hInfo.N;
Point3 N = newN;
float S = H.Dot(N);
S = pow(S,alpha);
float costheta = L.Dot(N)/(L.Length() * N.Length());
Color intensity = lights[i]->Illuminate(P);
// cout<<"costheta "<<endl;
allOther += intensity * (costheta>0?costheta:0) * (diffuse + S * (mb->specular.Sample(hInfo.uvw, hInfo.duvw))) ;
}
/* finally add inta*cola + intall*costheta*(cold + s* colS)*/
shade = ambComponent + allOther;
}
/* Calculate refraction */
if(refraction.GetColor().r>0 && bounceCount>0){
//compute new jittered normal
float gloss = refractionGlossiness;
if(gloss){
float random = rand()/(float)RAND_MAX;
float rRadius = sqrtf(random) * gloss;
random = rand()/(float)RAND_MAX;
float rAngle = random * 2.0 * M_PI;
float x = rRadius * cos(rAngle);
float y = rRadius * sin(rAngle);
Point3 xAxis(1,0,0), yAxis(0,1,0), v1, v2, normalDir;
normalDir = hInfo.N;
// normalDir.Normalize();
if(normalDir.Dot(xAxis) > 0.7) v1 = normalDir.Cross(yAxis);
else v1 = normalDir.Cross(xAxis);
v2 = v1.Cross(normalDir);
v1.Normalize(); v2.Normalize();
v1 *= x;
v2 *= y;
newN = hInfo.N + v1.Length() + v2.Length();
newN.Normalize();
}
else{
newN = hInfo.N;
}
//-------------------------------------
Color reflShade = Color(0,0,0);
float R0, Refl = 0.0f, Trans = 0.0f;
HitInfo temp;
temp.Init();
// Point3 N = hInfo.N;
Point3 N = newN;
// Point3 V = Point3(iRay.p.x - hInfo.p.x, iRay.p.y - hInfo.p.y, iRay.p.z - hInfo.p.z);
Point3 V = Point3(hInfo.p.x - iRay.p.x, hInfo.p.y - iRay.p.y, hInfo.p.z - iRay.p.z);
V.Normalize();
float n1 = 1, n2 = 1;
if(hInfo.front){ /* Hitting from outside */
// temp.front = false;
n2 = ior;
// cout<<"outside "<<endl;
}
else if(!hInfo.front){ /* Transmission from the inside */
// temp.front = true;
n1 = ior;
// cout<<"intside... "<<endl;
// N = -hInfo.N;
N *= -1;
}
float ratio_n = n1 / n2;
float costheta_v = -V.Dot(N); /* refer: http://graphics.stanford.edu/courses/cs148-10-summer/docs/2006--degreve--reflection_refraction.pdf */
float sin2theta_t = ratio_n * ratio_n * (1 - costheta_v * costheta_v);
Point3 T = ratio_n * V + (ratio_n * costheta_v - sqrtf(1 - sin2theta_t)) * N ;
// cout<<ratio_n<<" "<<"cos_v "<<costheta_v<<" sin2theta_t "<<sin2theta_t<<endl;
Cone tRay = Cone(hInfo.p,T);
//tRay.dir.Normalize();
tRay.p.x = tRay.p.x + bias *tRay.dir.x; /* add bias */
tRay.p.y = tRay.p.y + bias *tRay.dir.y;
tRay.p.z = tRay.p.z + bias *tRay.dir.z;
// cout<<"B temp front: "<< temp.front<<endl;
temp.timeInstance = hInfo.timeInstance;
if(sin2theta_t <= 1){
if(RayTrace_2(tRay, temp)){ /* ray tracing after refraction */
// bounceCount--;
tShade = temp.node->GetMaterial()->Shade(tRay,temp,lights,bounceCount);
}
else{ /* no hit after refraction */
tShade = environment.SampleEnvironment(tRay.dir);
}
/* Calculate Schlick's approximation */
R0 = (n1 - n2)/(n1 + n2);
R0 *= R0;
double X = 0.0;
// if(n1 > n2){
// X = 1.0 - sqrtf(1.0 - sin2theta_t);
// }
// else{ X = 1.0 - costheta_v; }
X = 1.0 - costheta_v;
Refl = R0 + (1.0 - R0) * X * X * X * X * X;
Trans = 1.0 - Refl;
tShade.r *= exp(-absorption.r * temp.z);
tShade.g *= exp(-absorption.g * temp.z);
tShade.b *= exp(-absorption.b * temp.z);
}
else {/* Total internal reflection */
Refl = 1.0f;
}
/* Calculate reflection due to reflectance */
if(bounceCount >0){
// N = hInfo.N;
N = newN;
Point3 V = Point3(iRay.p.x - P.x, iRay.p.y - P.y, iRay.p.z - P.z);
//V.Normalize();
Point3 VR = 2 * V.Dot(N) * N - V;
//VR.Normalize();
Cone rRay = Cone(P + BIAS_SHADING * VR, VR);
rRay.dir.Normalize();
HitInfo temp1;
temp1.Init();
temp.timeInstance = hInfo.timeInstance;
if(rootNode.GetNumChild()>0){
if(RayTrace_2(rRay, temp1)){
bounceCount --;
reflShade = temp1.node->GetMaterial()->Shade(rRay, temp1, lights, bounceCount);
}
else{
reflShade = environment.SampleEnvironment(rRay.dir);
// reflShade = Color(1,100,1);
}
}
}
// cout<<"Refl: "<<Refl<<"Trans "<<Trans<<endl;
tShade = refraction.GetColor().r * (Trans * tShade + Refl * reflShade);
}
/* calculate reflection*/
if(reflection.GetColor().r>0 && bounceCount > 0){
//compute new jittered normal
float gloss = reflectionGlossiness;
if(gloss){
float random = rand()/(float)RAND_MAX;
float rRadius = sqrtf(random) * gloss;
random = rand()/(float)RAND_MAX;
float rAngle = random * 2.0 * M_PI;
float x = rRadius * cos(rAngle);
float y = rRadius * sin(rAngle);
Point3 xAxis(1,0,0), yAxis(0,1,0), v1, v2, normalDir;
normalDir = hInfo.N;
// normalDir.Normalize();
if(normalDir.Dot(xAxis) > 0.7) v1 = normalDir.Cross(yAxis);
else v1 = normalDir.Cross(xAxis);
v2 = v1.Cross(normalDir);
v1.Normalize(); v2.Normalize();
v1 *= x;
v2 *= y;
newN = hInfo.N + v1+ v2;
newN.Normalize();
}
else{
newN = hInfo.N;
}
//-------------------------------------
Point3 N = newN;//hInfo.N;
Point3 V = Point3(iRay.p.x - P.x, iRay.p.y - P.y, iRay.p.z - P.z);
// V.Normalize();
Point3 VR = 2 * V.Dot(N) * N - V;
Cone rRay = Cone(P + BIAS_SHADING * VR, VR);
rRay.dir.Normalize();
HitInfo temp;
temp.Init();
temp.timeInstance=hInfo.timeInstance;
if(rootNode.GetNumChild()>0){
if(RayTrace_2(rRay, temp)){
bounceCount--;
rShade = reflection.GetColor().r * temp.node->GetMaterial()->Shade(rRay, temp, lights, bounceCount);
}
else{
rShade = reflection.GetColor().r *environment.SampleEnvironment(rRay.dir);
// rShade = Color(1,111,1);
}
}
}
/* Add shade with reflected and refracted colors */
shade += (rShade + tShade);
return shade;
};
void doRender(void* arg){
RenderParams rarg = *((RenderParams *)arg);
//cout<<"Do render...."<<endl;
bool pixelHit=false;
HitInfo hitInfo;
hitInfo.Init();
Point2 pixLoc = rarg.pixLocation;
Cone r = rarg.ray;
int PixIndex = rarg.pixIndex;
Color shade(0,0,0);
vector<Point2> haltonXY;
float dx = rarg.PixParams.x;
float dy = rarg.PixParams.y;
float x=0;
float y=0;
_f.Normalize();
_s.Normalize();
const float pts[9]={_s.x,_u.x,-_f.x,_s.y,_u.y,-_f.y,_s.z,_u.z,-_f.z};
Matrix3 RotMat;
RotMat.Set(pts);
for(int i=0; i < MIN_N_SAMPLES; i++){
x = dx * Halton(i+1, H_BASE_1);
y = dy * Halton(i+1, H_BASE_2);
if(x > dx * 0.5) { x -= dx; }
if(y < dy * 0.5) { y -= dy; }
x += rarg.K.x;
y += rarg.K.y;
Point2 sampleLoc = Point2(x,y);
haltonXY.push_back(sampleLoc);
}
vector<Color> shades;
if(rootNode.GetNumChild()>0){
for(int i=0; i< MIN_N_SAMPLES;i++){
Point3 sampleDir = Point3(haltonXY.at(i).x, haltonXY.at(i).y, rarg.K.z);
int rindex = rand() % MAX_N_SAMPLES; //rindex = i;
Point3 randPos = rarg.ConfCirclePts.at(rindex);
Cone sampleRay = Cone(randPos, sampleDir);
sampleRay.dir = sampleRay.dir * RotMat;
sampleRay.dir -= randPos - camera.pos;
sampleRay.dir.Normalize();
sampleRay.radius = r.radius;
sampleRay.tanAngle = r.tanAngle;
r = sampleRay;
if(RayTrace_2(r, hitInfo)) {
pixelHit=true;
shade = hitInfo.node->GetMaterial()->Shade(r, hitInfo, lights, 8);
shades.push_back(shade);
}
hitInfo.Init();
}
if(VarianceOverThreshold(shades)){
renderImage.SetSampleCountPixel(PixIndex, 255);
hitInfo.Init();
for(int i=MIN_N_SAMPLES; i < MAX_N_SAMPLES; i++){
x = dx * Halton(i+1, H_BASE_1);
y = dy * Halton(i+1, H_BASE_2);
if(x > dx * 0.5) { x -= dx;}
if(y < dy * 0.5) { y -= dy;}
x += rarg.K.x;
y += rarg.K.y;
Point2 sampleLoc = Point2(x,y);
haltonXY.push_back(sampleLoc);
Point3 sampleDir = Point3(haltonXY.at(i).x, haltonXY.at(i).y, rarg.K.z);
int rindex = rand() % MAX_N_SAMPLES; //rindex = i;
Point3 randPos = rarg.ConfCirclePts.at(rindex);
Cone sampleRay = Cone(randPos, sampleDir);
sampleRay.dir = sampleRay.dir * RotMat;
sampleRay.dir -= randPos - camera.pos;
sampleRay.dir.Normalize();
sampleRay.radius = r.radius;
sampleRay.tanAngle = r.tanAngle;
r = sampleRay;
if(RayTrace_2(r, hitInfo)) {
pixelHit=true;
shade = hitInfo.node->GetMaterial()->Shade(r, hitInfo, lights, 5);
shades.push_back(shade);
}
hitInfo.Init();
}
shade = AverageShades(shades, (int)shades.size());
}
else{
shade = AverageShades(shades, (int)shades.size());
renderImage.SetSampleCountPixel(PixIndex, 0);
}
renderImage.PutPixel(PixIndex, shade, hitInfo.z);
}
if(!pixelHit){
Point3 uvw(pixLoc.x/ camera.imgWidth,pixLoc.y/camera.imgHeight,0);
shade = background.Sample(uvw);
renderImage.PutPixel(PixIndex, shade, BIGFLOAT);
}
pthread_mutex_lock(&setPix_mutex);
renderImage.IncrementNumRenderPixel(1);
pthread_mutex_unlock(&setPix_mutex);
}
