raw.xml

<?xml version="1.0" encoding="ISO-8859-1"?>
<pipeline>
<vertex>
<![CDATA[#version 400

uniform mat4 mvMatrix;
uniform mat4 pMatrix;
uniform mat3 normalMatrix; //mv matrix without translation

uniform vec4 lightPosition_camSpace; //light Position in camera space

in vec4 vertex_worldSpace;
in vec3 normal_worldSpace;
in vec2 textureCoordinate_input;

out data
{
	vec4 position_camSpace;
	vec3 normal_camSpace;
	vec2 textureCoordinate;
	vec4 color;
}vertexIn;

//Vertex shader compute the vectors per vertex
void main(void)
{
    //Put the vertex in the correct coordinate system by applying the model view matrix
    vec4 vertex_camSpace = mvMatrix*vertex_worldSpace;
	vertexIn.position_camSpace = vertex_camSpace;
	
    //Apply the model-view transformation to the normal (only rotation, no translation)
    //Normals put in the camera space
    vertexIn.normal_camSpace = normalize(normalMatrix*normal_worldSpace);

	//Color chosen as red
	vertexIn.color = vec4(1.0,0.0,0.0,1.0);
    
    //Texture coordinate
    vertexIn.textureCoordinate = textureCoordinate_input;
	
    gl_Position = pMatrix * vertex_camSpace;
}


























]]></vertex>
<geom>
<![CDATA[#version 400

layout(triangles) in;
layout(triangle_strip, max_vertices = 3) out;

uniform mat4 mvMatrix;
uniform mat4 pMatrix;
uniform mat3 normalMatrix; //mv matrix without translation

uniform vec4 lightPosition_camSpace; //light Position in camera space


in data
{
	vec4 position_camSpace;
	vec3 normal_camSpace;
	vec2 textureCoordinate;
	vec4 color;
}vertexIn[3];

out fragmentData
{
	vec4 position_camSpace;
	vec3 normal_camSpace;
	vec2 textureCoordinate;
	vec4 color;
} frag;


void main() {
  for(int i = 0; i < 3; i++) { // You used triangles, so it's always 3
    gl_Position = gl_in[i].gl_Position;
	frag.position_camSpace = vertexIn[i].position_camSpace;
	frag.normal_camSpace = vertexIn[i].normal_camSpace;
	frag.textureCoordinate = vertexIn[i].textureCoordinate;
	frag.color = vertexIn[i].color;
    EmitVertex();
  }
  EndPrimitive();
}

























]]></geom>
<frag>
<![CDATA[#version 400

uniform vec4 ambient;
uniform vec4 diffuse;
uniform vec4 specular;
uniform float shininess;

uniform vec4 lightPosition_camSpace; //light Position in camera space

in fragmentData
{
	vec4 position_camSpace;
	vec3 normal_camSpace;
	vec2 textureCoordinate;
	vec4 color;
} frag;


out vec4 fragColor;

//Fragment shader computes the final color
void main(void)
{
	//Not used in that task
    fragColor =  frag.color;
}

























]]></frag>
<R2TVert>
<![CDATA[#version 400
#extension GL_ARB_separate_shader_objects : enable

uniform mat4 mMatrix;
uniform mat4 mvMatrix;

in vec4 vertex_worldSpace;
in vec3 normal_worldSpace;

out vec3 dir; 

void  main () 
{ 
	vec4 vertex_modelSpace = mMatrix*vertex_worldSpace;
	
    dir = normalize ( vec3 ( vertex_modelSpace.x * 1.6,  vertex_modelSpace.y , -1.0 )); 
	
    gl_Position  = vertex_modelSpace; 
}


























]]></R2TVert>
<R2TFrag>
<![CDATA[#version 400

in vec3 dir; 
out vec4 outcolour;

#define FLT_MAX 1.0/0.0;
#define PI 3.141592

uniform mat4 mMatrix;
uniform mat4 mvMatrix;
uniform mat4 mvMatrixScene;
uniform mat4 pMatrix;
uniform mat3 normalMatrix; //mv matrix without translation

const int raytraceDepth = 42;
const int numSpheres = 6;
const float decay = 0.3;
const vec3 lightSource = vec3(6,4,3);
// Blinn-Phong
vec3 diffuse = vec3(0.1,0.1,0.1);
vec3 specular = vec3(0.1,0.1,0.1);
float ambientCoefficent = 0.5;
float shininess = 32.0;
float diffuseCoefficent = 0.5;
float specularCoefficent = 0.5;

vec3 blinn_phong(vec3 ambient, vec3 pos, vec3 normal){
	vec3 ambientFinal = ambientCoefficent*ambient;
	vec3 l = normalize(lightSource-pos);
	vec3 v = normalize(-pos);
	vec3 r = normalize(2*dot(normal,l)*normal-l);
	vec3 h = normalize(l+v);
	float d = distance(pos, lightSource);
	float distFinal = 8000/(4*PI*pow(d,2));
	
  	vec3 diffuseFinal = (diffuseCoefficent*diffuse)*dot(normal,l);
  	vec3 specularFinal = (specularCoefficent*specular)*pow(max(dot(normalize(normal),h),0),shininess);
  	vec3 colour = ambientFinal + (diffuseFinal + specularFinal)*distFinal;
	return colour;
}



//example data structures
struct Ray
{
	vec3 origin;
	vec3 dir;
	int depth;
};
struct Sphere
{
	vec3 centre;
	float radius;
	float radius2;
	vec3 colour;
};
struct Plane
{
	vec3 point;
	vec3 normal;
	vec3 colour;
};

struct Intersection
{
    float t; //closest hit
    vec3 point;	// hit point
    vec3 normal;	// normal
	vec3 bp_colour;
	vec3 colour;
    int hit;	//did it hit?
	float r; // reflection constant
};

float mag(vec3 v){
	return dot(v,v);
}
float epsilon = 1e-6;



void sphere_intersect(Sphere sph, inout Ray ray, inout Intersection intersect)
{
	float u1,u2,u;
	vec3 deltaP = (sph.centre -ray.origin);
	float d  = dot(deltaP,ray.dir);
	float sub = mag(deltaP)-d*d;
	if (sub>sph.radius2) return;
	float sqr = sqrt(sph.radius2-sub);
	u1 = d + sqr;
	u2 = d - sqr;
	if (u1<u2 && u1 > 0){
		u = u1;
	}
	if (u2<u1 && u2 > 0){
		u = u2;
	}
	if (u>0){
		intersect.point = u*ray.dir;
		intersect.hit = 1;
		intersect.normal = normalize(intersect.point - sph.centre);
		
		if (u<intersect.t){
			intersect.colour = sph.colour;
			intersect.bp_colour = blinn_phong(intersect.colour,intersect.point,intersect.normal);
			intersect.t=u;
		}
	}
	
    
}

void plane_intersect(Plane pl, inout Ray ray, inout Intersection intersect)
{	
	float denom = -dot(ray.dir,pl.normal);
	if (denom >0){
		float u = dot(ray.origin-pl.point,pl.normal)/denom;
		if (u >epsilon){ // u<intersect.t && 
			intersect.hit = 1;
			vec3 p = u*ray.dir;
			intersect.point = ray.origin + p;
			vec3 col = pl.colour;
			if (!bool((int(p.x)+int(p.z))%2)){
				col = vec3(0,0,0);
			}
			intersect.colour += col;
			intersect.bp_colour += blinn_phong(intersect.colour,intersect.point,intersect.normal);
			intersect.normal = normalize(pl.normal);
			intersect.t = u;
		}
	}
}

Sphere sphere[numSpheres];
Plane plane;
void Intersect(inout Ray r, inout Intersection i)
{	
	float closest = i.t;
	Intersection intersect;

	plane_intersect(plane, r, intersect);
	if (bool(intersect.hit) && intersect.t < closest){
		i = intersect;
		closest = intersect.t;
	}

	// For each object in the scene, do intersect function
	for (int j=0;j<numSpheres;j++){
		intersect.t = closest;
		sphere_intersect(sphere[j],r,intersect);
		if (intersect.hit == 1 && intersect.t < closest){
			i = intersect;
			closest = intersect.t;
		}
	}
	
	
}

int seed = 0;
float rnd()
{
	seed = int(mod(float(seed)*1364.0+626.0, 509.0));
	return float(seed)/509.0;
}

vec3 computeShadow(in Intersection intersect)
{
	// ray from intersect to the light source
	Ray shadowRay;
	shadowRay.dir = seed*(intersect.point -lightSource);
	shadowRay.origin = intersect.point + shadowRay.dir;
	shadowRay.depth = 1;
	Intersection i2;
	i2.t = FLT_MAX;
	// see if there are any intersections
	Intersect(shadowRay, i2);
	if (!bool(i2.hit)){
		return intersect.bp_colour;
	}
	else  {
		return intersect.colour;
	}
}

void main()
{
	//please leave the scene config unaltered for marking 
	sphere[0].centre   = vec3(-2.0, 1.5, -3.5);
	sphere[0].radius   = 1.5;
	sphere[0].colour = vec3(0.8,0.8,0.8);
	sphere[1].centre   = vec3(-0.5, 0.0, -2.0);
	sphere[1].radius   = 0.6;
	sphere[1].colour = vec3(0.3,0.8,0.3);
	sphere[2].centre   = vec3(1.0, 0.7, -2.2);
	sphere[2].radius   = 0.8;
	sphere[2].colour = vec3(0.3,0.8,0.8);
	sphere[3].centre   = vec3(0.7, -0.3, -1.2);
	sphere[3].radius   = 0.2;
	sphere[3].colour = vec3(0.8,0.8,0.3);
	sphere[4].centre   = vec3(-0.7, -0.3, -1.2);
	sphere[4].radius   = 0.2;
	sphere[4].colour = vec3(0.8,0.3,0.3);
	sphere[5].centre   = vec3(0.2, -0.2, -1.2);
	sphere[5].radius   = 0.3;
	sphere[5].colour = vec3(0.8,0.3,0.8);
	plane.point = vec3(0,-0.5, 0);
	plane.normal = vec3(0, 1.0, 0);
	plane.colour = vec3(1, 1, 1);
	seed = int(mod(dir.x * dir.y * 39786038.0, 65536.0));
	//scene definition end
	mat4 transMat1;
	transMat1[0] = vec4(-1.0,0.0,0.0,0.0);
	transMat1[1] = vec4(0.0,-1.0,0.0,0.0);
	transMat1[2] = vec4(0.0,0.0,-1.0,0.0);
	transMat1[3] = vec4(0.0,0.0,0.0,1.0);

	for (int k; k<numSpheres;k++){
		sphere[k].radius2 = pow(sphere[k].radius,2);
	}
	// float epsilon = 1e-10;
	vec4 colour = vec4(0,0,0,1);
	
	Ray ray;
	ray.origin = vec3(0,0,0); //((mvMatrixScene)*vec4(0,0,0,1)).xyz;// vec3(0,0,0);//(mvMatrix*vec4(0,0,0,1)).xyz;
	ray.dir = normalize((mvMatrixScene)*vec4(dir,0)).xyz;
	float closest = 1.0/0.0;

	Intersection i;
	for(int d = 0; d < 10;d++){
		ray.depth = d;
		i.t = closest;
		Intersect(ray,i);
		if (i.hit != 0) {
			if (i.t<closest){
				closest = i.t;
				colour += (pow(decay,pow(d,2)))*vec4(computeShadow(i),1);//pow(decay,pow(d,2))*vec4(blinn_phong(i.colour,i.point,i.normal,true),1);
			}
			ray.origin = i.point + epsilon * i.normal;
			ray.dir = reflect(ray.dir,i.normal);
		} else {
			break;
		}
		
	}
	outcolour = colour;
}


























]]></R2TFrag>
</pipeline>