cw7.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;

float FLT_MAX = 3.402823e38;

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;

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

struct Intersection
{
    float t; //closest hit
    vec3 point;	// hit point
    vec3 normal;	// normal
    int hit;	//did it hit?
    vec3 colour; // colour accumulation, can be also implemented in struct Ray
};

float mag(vec3 v){
	return dot(v,v);
}

void sphere_intersect(Sphere sph, Ray ray, inout Intersection intersect)
{
	float u1,u2,u;
	vec3 deltaP = ray.origin - sph.centre;
	float sqrtarg = pow(dot(ray.dir,deltaP),2)-mag(deltaP)+pow(sph.radius,2);
	if (sqrtarg>=0){
		u1 = -1*dot(ray.dir,deltaP) + pow(sqrtarg,0.5);
		u2 = -1*dot(ray.dir,deltaP) - pow(sqrtarg,0.5);
		u = (u1<u2) ? u1 : u2;
		if (u>=0 && u<intersect.t){
			intersect.point = u*ray.dir;
			intersect.hit = 1;
			intersect.normal = intersect.point - sph.centre;
			intersect.colour = sph.colour;
			intersect.t = u;
		}
	//TODO epsilon stuff
	}
    
}

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

Sphere sphere[numSpheres];
Plane plane;
void Intersect(Ray r, inout Intersection i)
{
	// For each object in the scene, do intersect function
	plane_intersect(plane, r, i);

	for (int j=0;j<numSpheres;j++){
		sphere_intersect(sphere[j],r,i);
	}
}

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)
{
	//TODO implement shadow computation
	return vec3(0,0,0);
}

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
	// float epsilon = 1e-10;
	vec4 colour = vec4(0,0,0,1);
	//TODO implement ray tracing main loop here
	float decay = 0.5;
	float epsilon = 1e-6;
	Ray ray;
	ray.origin = (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);
	for(int depth = 0; depth < 6;depth++){
		Intersection i;
		i.t = FLT_MAX;
		i.colour = vec3(0,0,0);
		Intersect(ray,i);
		if (i.hit != 0) {
			colour += pow(decay,depth)*vec4(i.colour,0);
			
			// computeShadow(intersection) {extension}
			ray.origin = i.point;
			ray.origin += epsilon * i.normal;
			ray.dir = normalize(reflect(ray.dir,i.normal));
		} else {
			break;
		}
		
	}
	outcolour = colour;
}














]]></R2TFrag>
</pipeline>