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;

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;
const float decay = 0.4;

const vec3 lightSource = vec3(6,4,3);

//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 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 = pow(decay,ray.depth)*sph.colour;
			intersect.t=u;
		}
	}
	
    
}

void plane_intersect(Plane pl, inout 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 >epsilon){
			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 += pow(ray.depth,-2)*col;
			intersect.normal = normalize(pl.normal);
			intersect.t = u;
		}
	}
}

Sphere sphere[numSpheres];
Plane plane;
void Intersect(inout Ray r, inout Intersection i)
{	float closest = FLT_MAX;
	Intersection intersect;
	
	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;
		}
	}
	// For each object in the scene, do intersect function
	plane_intersect(plane, 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;
}

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

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;
	i.hit = 0;
	i.colour=vec3(0,0,0);
	for(int d = 0; d < 6;d++){
		ray.depth = d;
		i.t = closest;
		Intersect(ray,i);
		if (i.hit != 0) {
			if (i.t<closest){
				closest = i.t;
				colour += pow(decay,d)*vec4(i.colour,1);
				if (computeShadow(i)) {
					colour = vec4(colour.xyz/2,0);
					// add blinn phong shading
				}
				
			}
			ray.origin = i.point;
			ray.origin += epsilon * i.normal;
			ray.dir = reflect(ray.dir,i.normal);
		} else {
			break;
		}
		
	}
	outcolour = colour;
}























]]></R2TFrag>
</pipeline>