Esempio n. 1
0
/*
 *	Takes care of orbit and rotation
 */
void UpdatePlanetMovement(GLint t)
{
	GLuint i;
	mat4 ModelToWorld;
	for(i = 0; i < numberOfPlanets; i++)
	{
		t = glutGet(GLUT_ELAPSED_TIME) -  planetsList[i].timeOfCreation;

		vec3 arbAxis = {0,1,0};
		ModelToWorld = ArbRotate(planetsList[i].rotationalAxis, planetsList[i].rotationalSpeed*(GLfloat)t); //IdentityMatrix(); //Rotation around own axis
		ModelToWorld = Mult(T(planetsList[i].startingPosition.x, planetsList[i].startingPosition.y, planetsList[i].startingPosition.z), ModelToWorld); //Offset

		if(!(planetsList[i].startingPosition.x == planetsList[0].startingPosition.x 
		  && planetsList[i].startingPosition.y == planetsList[0].startingPosition.y 
		  && planetsList[i].startingPosition.z == planetsList[0].startingPosition.z )) //Dont try to orbit when already at 0
		{	
			if(fabs(planetsList[i].startingPosition.x) - arbAxis.x + 
			   fabs(planetsList[i].startingPosition.y) - arbAxis.y + 
			   fabs(planetsList[i].startingPosition.z) - arbAxis.z == 0)
				arbAxis = SetVector(1,0,0);

			arbAxis = Normalize(CrossProduct(VectorSub(planetsList[i].startingPosition, planetsList[0].startingPosition), arbAxis));

			ModelToWorld = Mult(T(planetsList[0].center.x, planetsList[0].center.y, planetsList[0].center.z), ModelToWorld);
			ModelToWorld = Mult(ArbRotate(arbAxis, planetsList[i].orbitalSpeed*(GLfloat)t), ModelToWorld); //Orbit
			ModelToWorld = Mult(T(-planetsList[0].center.x, -planetsList[0].center.y, -planetsList[0].center.z), ModelToWorld);
		}
		planetsList[i].ModelToWorldMatrix = ModelToWorld;
	}
}
void myKeys(unsigned char key, int x, int y)
{
  switch (key)
   {
   case 'w':
     sceneModelMatrix = Mult(sceneModelMatrix, T(0.0,0.0,0.2));
     break;
   case 's':
     sceneModelMatrix = Mult(sceneModelMatrix, T(0.0,0.0,-0.2));
     break;
   case 'j':
    sceneModelMatrix = Mult(sceneModelMatrix, ArbRotate(axis, 0.3));
    break;
   case 'k':
    sceneModelMatrix = Mult(sceneModelMatrix,ArbRotate(axis, -0.3));
    break;
   case 't':
        sphereModelMatrix = Mult(sphereModelMatrix, T(0.0,0.0,-0.2));
        break;
   case 'g':
        sphereModelMatrix = Mult(sphereModelMatrix, T(0.0,0.0,0.2));
        break;

   case 'f':
        sphereModelMatrix = Mult(T(0.0,-0.2,0.0), sphereModelMatrix);
        break;
   case 'h':
        sphereModelMatrix = Mult(T(0.0,0.2,0.0), sphereModelMatrix);
        break;

   case 'p':
     if(isMoving == 1){
        isMoving = 0;
        printf("%s\n", "ismoving is 0");
        }
     else if(isMoving == 0){
        printf("%s\n", "ismoving is 1");
        isMoving = 1;
        }

        break;
   default:
     break;
    }
}
Esempio n. 3
0
File: zpr.c Progetto: Seanberite/CG
void zprMouseFunc(int x, int y)
{
    if(_mouseLeft)
    {
        angle_y = (float)(x - lastX) *0.002;
        angle_x = (float)(y - lastY) *0.002;
//        tmpMat1 = ArbRotate(right, angle_x);
        tmpMat1 = ArbRotate(right, -angle_x); // Reversed, also looks more reasonable (but wasn't interesting before the Mac version got isFlipped.)
        tmpMat2 = ArbRotate(up, -angle_y); // Reversed; I think this feels better /Ingemar 130901

        rotMat = Mult(tmpMat2, tmpMat1);
        updateCameraMatrix(&rotMat);

        lastX = x;
        lastY = y;
    }

  printf("%d %d\n", x, y);
  printf("diff: x: %3.5f  y: %3.5f\n", angle_y, angle_x);
}
Esempio n. 4
0
void punshControl(Model* map, mat4 view)
{
		
		vec3 mapNorm = vec3(0,0,1);
		vec3 camPos = VectorAdd(player->getPos(),vec3(0,2.0,0));
		vec3 mapToCam = VectorSub(player->getPos(),player->getLook());

		//Put text in front of the cam
		vec3 mapPos = VectorSub(camPos,mapToCam);
		mat4 translate=  T(mapPos.x,mapPos.y,mapPos.z);
		view = Mult(view, translate);

		//Rotate in around Y-axis
		vec3 mapToCamXZ = mapToCam;
		mapToCamXZ.y = 0;
		mapToCamXZ = Normalize(mapToCamXZ);
		vec3 upVec = CrossProduct(mapNorm, mapToCamXZ);
		GLfloat angle = acos(DotProduct(mapNorm, mapToCamXZ));
		mat4 billRotMat = ArbRotate(upVec, angle);

		view = Mult(view,billRotMat);

		//Rotate in around XZ-axis
		mapToCam = Normalize(mapToCam);
		angle = acos(DotProduct(mapToCamXZ,mapToCam));
		
		if (mapToCam.y < 0)
			billRotMat = ArbRotate(vec3(1,0,0), angle);	
		else
			billRotMat = ArbRotate(vec3(-1,0,0), angle);

		view = Mult(view,billRotMat);		
		
		mat4 viewCompass = view;
		view = Mult(view,T(0,0,-0.1));
		glUniformMatrix4fv(glGetUniformLocation(billBoardProgram, "camMatrix"), 1, GL_TRUE, player->getCamMatrix().m);
		glUniformMatrix4fv(glGetUniformLocation(billBoardProgram, "mdlMatrix"), 1, GL_TRUE, view.m);
		DrawModel(map, billBoardProgram, "inPosition",  NULL, "inTexCoord"); 

}
Esempio n. 5
0
void zprMouseFunc(int x, int y)
{
//	printf("MouseFunc\n");

    if(_mouseLeft)
    {
        angle_y = (float)(x - lastX) *0.002;
        angle_x = (float)(y - lastY) *0.002;
//        tmpMat1 = ArbRotate(right, angle_x);
        tmpMat1 = ArbRotate(right, -angle_x); // Reverse this too - only Linux???
        tmpMat2 = ArbRotate(up, -angle_y); // Reversed; I think this feels better /Ingemar 130901

        rotMat = Mult(tmpMat2, tmpMat1);
        updateCameraMatrix(&rotMat);

        lastX = x;
        lastY = y;
    }

//	printf("%d %d\n", x, y);
//	printf("diff: x: %3.5f  y: %3.5f\n", angle_y, angle_x);
}
Esempio n. 6
0
void mouse(int x, int y)
{
    vec3 camRight = Normalize(CrossProduct(camDir, camUp));
    mat4 rot1;
    mat4 rot2;
    int dx = x - halfWindowWidth;
    int dy = y - halfWindowHeight;
    rot1 = ArbRotate(camRight, - dy * CAM_ROT_SPEED);
    rot2 = Ry(-dx * CAM_ROT_SPEED);
    rot2 = Mult(rot2, rot1);
    camDir = Normalize(MultVec3(rot2, camDir));
    glutWarpPointer(halfWindowWidth, halfWindowHeight);
}
Esempio n. 7
0
void DrawMap(Model* map, Model* compass, mat4 view)
{
		vec3 mapNorm = vec3(0,0,1);
		vec3 camPos = VectorAdd(player->getPos(),vec3(0,2.0,0));
		vec3 mapToCam = VectorSub(player->getPos(),player->getLook());

		//Put map in front of the cam
		vec3 mapPos = VectorSub(camPos,mapToCam);
		mat4 translate=  T(mapPos.x,mapPos.y,mapPos.z);
		view = Mult(view, translate);

		//Rotate in around Y-axis
		vec3 mapToCamXZ = mapToCam;
		mapToCamXZ.y = 0;
		mapToCamXZ = Normalize(mapToCamXZ);
		vec3 upVec = CrossProduct(mapNorm, mapToCamXZ);
		GLfloat angle = acos(DotProduct(mapNorm, mapToCamXZ));
		mat4 billRotMat = ArbRotate(upVec, angle);
		view = Mult(view,billRotMat);

		//Rotate in around XZ-axis
		mapToCam = Normalize(mapToCam);
		angle = acos(DotProduct(mapToCamXZ,mapToCam));
		
		if (mapToCam.y < 0)
			billRotMat = ArbRotate(vec3(1,0,0), angle);	
		else
			billRotMat = ArbRotate(vec3(-1,0,0), angle);

		view = Mult(view,billRotMat);
		
		//Rotate map 
		mat4 viewCompass = view;
		view = Mult(view,ArbRotate(vec3(0,0,1), mapAngle));		

		view = Mult(view,T(0,0,-0.1));
		glUniformMatrix4fv(glGetUniformLocation(billBoardProgram, "camMatrix"), 1, GL_TRUE, player->getCamMatrix().m);
		glUniformMatrix4fv(glGetUniformLocation(billBoardProgram, "mdlMatrix"), 1, GL_TRUE, view.m);
		DrawModel(map, billBoardProgram, "inPosition",  NULL, "inTexCoord"); 
		
		//Kompass
		viewCompass = Mult(viewCompass,T(-0.35,-0.3,0.1));
		GLfloat compassAngle = acos(DotProduct(vec3(0,0,1),mapToCamXZ));
		if (mapToCam.x < 0)
			viewCompass = Mult(viewCompass,ArbRotate(vec3(0,0,1), compassAngle));
		else
			viewCompass = Mult(viewCompass,ArbRotate(vec3(0,0,-1), compassAngle));
		
		glActiveTexture(GL_TEXTURE5);
		glBindTexture(GL_TEXTURE_2D, compassTex);
		glUniform1i(glGetUniformLocation(billBoardProgram, "tex1"), 5);

		glUniformMatrix4fv(glGetUniformLocation(billBoardProgram, "mdlMatrix"), 1, GL_TRUE, viewCompass.m);
		DrawModel(compass, billBoardProgram, "inPosition",  NULL, "inTexCoord");

}
Esempio n. 8
0
void keyboardControl(unsigned char key, int x, int y)
{
    vec3 camRight = Normalize(CrossProduct(camDir, camUp));
    mat4 rot;
    switch(key) {
        case GLUT_KEY_F:
            rot = ArbRotate(camRight, CAM_ROT_SPEED);
            camDir = Normalize(MultVec3(rot, camDir)); break;
        case GLUT_KEY_H:
            glutToggleFullScreen(); break;
        case GLUT_KEY_ESC:
            glutExit(); break;
            //        default:
            //printf("Key code: %d\n", key);
    }
 }
Esempio n. 9
0
void UploadObjectMatricesArbRot(float x, float y, float z, vec3 rAxis, float rAngle, mat4 view, mat4 projection, GLuint prg)
{
	mat4 transMatrix = T(x,y,z);
   mat4 invTransMatrix = T(-x,-y,-z);
   mat4 rotMatrix = ArbRotate(rAxis, rAngle);
   mat4 total = Mult(transMatrix, rotMatrix);
   total = Mult(total, invTransMatrix);
   total = Mult(total, transMatrix);
   mat3 normalMatrix = mat4tomat3(total);
   
   glUniformMatrix4fv(glGetUniformLocation(prg, "viewMatrix"), 1, GL_TRUE, view.m);
   glUniformMatrix3fv(glGetUniformLocation(prg, "normalMatrix"), 1, GL_TRUE, normalMatrix.m);
   glUniformMatrix4fv(glGetUniformLocation(prg, "mdlMatrix"), 1, GL_TRUE, total.m);
   glUniformMatrix4fv(glGetUniformLocation(prg, "projectionMatrix"), 1, GL_TRUE, projection.m);

}
Esempio n. 10
0
void DrawBillboard(Model* bm, int inx, int inz, mat4 view)
{
	GLfloat x = (GLfloat) inx;
	GLfloat z = (GLfloat) inz;

	if(randXZ->xz[inx][(int)z].x == -9999.0)
	{
		GLfloat randX;
		GLfloat randZ;
		TreeRandomNumberGen(&randX, &randZ, inx, inz);
		randXZ->xz[inx][(int)z].x = randX;
		randXZ->xz[inx][(int)z].z = randZ;
	}
	
	
	x = x + randXZ->xz[inx][inz].x;
	z = z + randXZ->xz[inx][inz].z;

	vec3 billVec = VectorSub(player->getPos(),vec3(x,0,z));
	vec3 playerLookAt = VectorSub(player->getPos(),player->getLook());
	billVec.y = 0;	
	playerLookAt.y = 0;
	if(Norm(billVec) < treeRenderingDistance && DotProduct(playerLookAt,billVec) > 0)
	{
		billVec = Normalize(billVec);		
		playerLookAt.y = 0.0;
		mat4 translate=  T(x, world->findHeight(x, z), z);
		view = Mult(view, translate);
		vec3 billNorm = vec3(0,0,1);
		vec3 upVec = CrossProduct(billNorm, billVec);
		GLfloat cosAngle = DotProduct(billNorm, billVec);		
		GLfloat angle = acos(cosAngle);		
		mat4 billRotMat = ArbRotate(upVec, angle);

		view = Mult(view,billRotMat);	
		glUniformMatrix4fv(glGetUniformLocation(billBoardProgram, "camMatrix"), 1, GL_TRUE, player->getCamMatrix().m);
		glUniformMatrix4fv(glGetUniformLocation(billBoardProgram, "mdlMatrix"), 1, GL_TRUE, view.m);
		DrawModel(bm, billBoardProgram, "inPosition",  NULL, "inTexCoord"); 
	}
}
Esempio n. 11
0
void display(void)
{
  //Read input_____________________________________________
   GLfloat t =(GLfloat)glutGet(GLUT_ELAPSED_TIME)/1000; //Scale with constant to make animation slower.


if (glutKeyIsDown('w'))
    { 
      keyz = keyz +1;
    }
  else if (glutKeyIsDown('s'))
    { 
      keyz = keyz -1;
    }
  else if (glutKeyIsDown('a'))
    { 
      keyx = keyx +1;
    }
  else if (glutKeyIsDown('d'))
    { 
      keyx = keyx -1;
    }
  else if (glutKeyIsDown('e'))
    { 
      keyy = keyy +1;
    }
  else if (glutKeyIsDown('q'))
    { 
      keyy = keyy -1;
    }
  else if (glutKeyIsDown('r'))
    { 
      exit(0);
    }
  // Clear the screen____________________________________
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	
  mat4 total, modelView, camMatrix;
	
  printError("pre display");

  vec3 pos = SetVector(keyx,keyy,keyz);
  vec3 up = SetVector(0,1,0);

  //Mouse control_____________________________________________
  //fmin and fmax doesn't really make sense but looks good. 
  GLfloat mousexlocal = 0;
  GLfloat mouseylocal = 0;

  if (mousex < 350 ||  mousex > 250)
    {
      mousexlocal = 300-mousex;
    }
  else
    {
      mousexlocal = 0;
    }

  deltaphi = deltaphi + deltaphi*-mousexlocal;
  deltaphi = fmin(0.0001,deltaphi);
  deltaphi = fmax(deltaphi,2 * PI - 0.0001);
  forward = MultVec3(Ry(deltaphi*-mousexlocal), forward);

  vec3 crossvec = CrossProduct(forward,up);

  if (mousey < 350 || mousey > 250)
    {
      mouseylocal = 300-mousey;
    }  
  else
    {
      mouseylocal = 0;
    }

  deltatheta = deltatheta + deltatheta* -mouseylocal;
  deltatheta = fmin(0.0001,deltatheta);
  deltatheta = fmax(deltatheta,2*PI - 0.0001);
  forward = MultVec3( ArbRotate(crossvec,deltatheta*-mouseylocal), forward);

  //Create camera matrix_____________________________________________
  

  GLfloat x = cos(t)*5 + 35;//Mult(Ry(2*5),x);
  GLfloat z = sin(t)*5 + 75;//Mult(Ry
  //GLfloat z = 65;
  GLfloat y = getHeight(&ttex,x,z) + 0.8;
  
  //  pos.y = pos.yy;

  camMatrix = lookAtv(pos,VectorAdd(forward,pos),up);

  modelView = IdentityMatrix();
  total = Mult(camMatrix, modelView);

  glUseProgram(program);
  glUniformMatrix4fv(glGetUniformLocation(program, "mdlMatrix"), 1, GL_TRUE, total.m);
  glBindTexture(GL_TEXTURE_2D, tex1);		// Bind Our Texture tex1
  DrawModel(tm, program,"inPosition", "inNormal", "inTexCoord");


  //total = Mult(Ry(2*t),T(10,0,0));
  total = T(x,y,z);
  total = Mult(camMatrix,total);

  glUniformMatrix4fv(glGetUniformLocation(program, "mdlMatrix"), 1, GL_TRUE, total.m);
  glBindTexture(GL_TEXTURE_2D, tex2);		// Bind Our Texture tex1
  DrawModel(bunny, program, "inPosition", "inNormal", "inTexCoord");

  printError("display 2");
	
  glutSwapBuffers();
}
Esempio n. 12
0
File: main.c Progetto: ErikHK/tsbk03
void OnTimer(int value)
{
	glutTimerFunc(20, &OnTimer, value);

	old_t = t;
	t = (GLfloat)glutGet(GLUT_ELAPSED_TIME)/1000.0;
	delta_t = (t - old_t);
	//printf("%f\n", delta_t);

	GLfloat tmpppp[3] = {cow.pos.x, cow.pos.y, cow.pos.z};
	glUniform3fv(glGetUniformLocation(g_shader, "cow_pos"), 1, tmpppp);


	turn_cow(&cow, -m_angle);
	update_cow(&cow, delta_t);
	update_fence(&ff, &cow, delta_t);
	move_cow(&cow, m_angle);
	update_floor(&f, &cow);
	update_wall(&wall, &cow, delta_t);
	update_ball(&ball, &cow, delta_t);
	update_farmer(&farmer);
        if(keyIsDown('k'))
	update_ragdoll(&ragdoll, delta_t);

	if(check_collision_2(&cow.bb, &wall.bb))
	{
	  //printf("yey\n");
	  glUniform1i(glGetUniformLocation(g_shader, "collision"), 1);
	  //cow.momentum = SetVector(-cow.momentum.x, cow.momentum.y, -cow.momentum.z);
	  //wall_collision(wall, cow);
	}
	else
	  glUniform1i(glGetUniformLocation(g_shader, "collision"), 0);



	//printf("%f, %f\n", delta_t, old_t);
	glUniform1f(glGetUniformLocation(g_shader, "time"), t);


	mat4 proj_matrix = frustum(-1, 1, -1, 1, 1, 750.0);
	mat4 cam_matrix = lookAt(cam_dist*cos(m_angle)+cow.pos.x, 9+cow.pos.y,  cam_dist*sin(m_angle)+cow.pos.z, cow.pos.x, 8.5+cow.pos.y, cow.pos.z, 0.0, 1.0, 0.0);
	//mat4 cam_matrix = lookAt(200+200*cos(cam_angle), 0,  200, 0, 8, 0, 0.0, 1.0, 0.0);

	//g_shader = loadShaders("shader.vert" , "shader.frag");
	//glUseProgram(g_shader);

	glUniformMatrix4fv(glGetUniformLocation(g_shader, "proj_matrix"), 1, GL_TRUE, proj_matrix.m);
	glUniformMatrix4fv(glGetUniformLocation(g_shader, "cam_matrix"), 1, GL_TRUE, cam_matrix.m);
	//glutDisplayFunc(DisplayWindow);

	//draw_cow(&cow, g_shader);
	//draw_bone(&bone, g_shader);

	mat4 tmp, testjoint, testjoint2;
	testjoint = IdentityMatrix();

	joint_s * j = &head_joint[0];
	joint_s * jc = j->child[0];
	joint_s * jcc = jc->child[0];
	//joint_s * jp = j->parent;
	//joint_s * jpp = jp->parent;

	float Ms[8][4*4];
	float legMs[8][4*4];
	float currpos[8*3] = {0};
	float bonepos[8*3] = {0};
	float legcurrpos[8*3] = {0};
	float legbonepos[8*3] = {0};
	//GLfloat * Mtmp = Ms;
	int i=0, ii=0;
	//jc->R = ArbRotate(SetVector(0,0,1), cos(4*t/(i+1))/2.5);
	//j->R = ArbRotate(SetVector(0,0,1), 0);
	j->R = ArbRotate(SetVector(0,0,1), sin(4*t/(3+1))/1.2);
	//jcc->R = ArbRotate(SetVector(0,0,1), cos(8*t/(2+1))/4);
	mat4 Mpacc, Minvacc, tmptrans, tmppp, invtrans;
	tmppp = IdentityMatrix();


	float freq = 7;//Norm(cow.speed)/4;

	if(Norm(cow.momentum) < .5)
	  freq = 0;
	else if(Norm(cow.momentum) > 5)
	  freq = 20;
	//printf("%f\n", freq);

	j = &thigh_joint[0];
	jc = j->child[0];
	j->R = ArbRotate(SetVector(0,0,1), sin(freq*t)/1.5);
	jc->R = ArbRotate(SetVector(0,0,1), cos(freq*t)/2.5);

	j = &thigh_joint[1];
	jc = j->child[0];
	j->R = ArbRotate(SetVector(0,0,1), -cos(freq*t)/2.5);
	jc->R = ArbRotate(SetVector(0,0,1), sin(freq*t)/2.5);


	j = &thigh_joint[2];
	jc = j->child[0];
	j->R = ArbRotate(SetVector(0,0,1), sin(freq*t)/1.5);
	jc->R = ArbRotate(SetVector(0,0,1), cos(freq*t)/2.5);

	j = &thigh_joint[3];
	jc = j->child[0];
	j->R = ArbRotate(SetVector(0,0,1), -cos(freq*t)/2.5);
	jc->R = ArbRotate(SetVector(0,0,1), sin(freq*t)/2.5);


	j = &legbase_joint[0];
	//j->R = ArbRotate(SetVector(1,0,0), -cos(7*t/(i+1)));
	//j->R = ArbRotate(SetVector(1,0,0), -M_PI/6);

	j = &thigh_joint[0];
	//j->R = Mult(ArbRotate(SetVector(1,0,0), cos(7*t/(i+1))), j->R);
	//j->R = Mult(ArbRotate(SetVector(1,0,0), M_PI/6), j->R);

	i = 0;
	tmppp = IdentityMatrix();
	//legbase_joint[0].R = ArbRotate(SetVector(0,0,1), cos(3*t)/2);

	//legs
	calc_bone_transform(&legbase_joint[0], 0);
	calc_bone_transform(&legbase_joint[1], 0);
	calc_bone_transform(&legbase_joint[2], 0);
	calc_bone_transform(&legbase_joint[3], 0);

	j = &tail_joint[0];
	j->R = ArbRotate(SetVector(0,0,1), -M_PI/2.5);
	j = &tail_joint[1];
	j->R = ArbRotate(SetVector(0,0,1), -M_PI/8.5);

	//j = &tail_joint[1];
	//j->R = ArbRotate(SetVector(0,0,1), 0);
	j = &tail_joint[2];
	//j->R = ArbRotate(SetVector(0,0,1), 0);
	j = &tail_joint[3];
	j->R = ArbRotate(SetVector(0,0,1), 0);

	//body
	j = &body_joint[1];
	//j->R = ArbRotate(SetVector(0,0,1), cos(t*7)/9.5);
	j->R = ArbRotate(SetVector(0,1,0), m_angle + cow.angle);
	j->R = Mult(j->R, ArbRotate(SetVector(0,0,1), cos(freq*t)/9));

	calc_bone_transform(&body_joint[0],0);

	//tail
	//j = &tail_joint[1];
	//j->R = ArbRotate(SetVector(0,0,1), -M_PI/2.5);

	//j = &tail_joint[1];
	//j->R = ArbRotate(SetVector(0,0,1), 0);

	//j = &tail_joint[2];
	//j->R = ArbRotate(SetVector(0,0,1), 0);

	//j = &tail_joint[3];
	//j->R = ArbRotate(SetVector(0,0,1), 0);

	//calc_bone_transform(&tail_joint[0],0);

	//head
	j = &head_joint[0];

	j->R = ArbRotate(SetVector(0,0,1), sin(7*t)/9.5);

	calc_bone_transform(&head_joint[0],0);



	j = &farmer.skeleton.joints[2];
	//j->R = Rx(cos(4*t));
	j->R = Mult(Rx(M_PI/2.2 + sin(5*t)/11), Ry(cos(-5*t)/2));

	j = &farmer.skeleton.joints[3];
	//j->R = Rx(cos(4*t));
	j->R = Mult(Rx(-M_PI/2.2 + sin(5*t)/11), Ry(cos(5*t)/2));

	//left shoulder (her right)
	//jc = &farmer.skeleton.joints[3];
	//jc->R = Rx(-sin(3*t));

	jc = &farmer.skeleton.joints[4];
	jc->R = Ry(M_PI/3 + cos(5*t)/8);

	jc = &farmer.skeleton.joints[5];
	jc->R = Ry(-M_PI/3 + cos(5*t)/8);


	jc = &farmer.skeleton.joints[10];
	//jc->R = Rz(M_PI/3);
	jc->R = Rz(.5-cos(5*t));

	jc = &farmer.skeleton.joints[12];
	jc->R = Rz((-1-cos(5*t))/2);


	jc = &farmer.skeleton.joints[11];
	//jc->R = Rz(M_PI/3);
	jc->R = Rz(.5+cos(5*t));

	jc = &farmer.skeleton.joints[13];
	jc->R = Rz((-1-cos(5*t))/2);


	calc_bone_transform(&farmer.skeleton.joints[0], 0);
	calc_bone_transform(&farmer.skeleton.joints[2], 0);
	calc_bone_transform(&farmer.skeleton.joints[3], 0);
	//calc_bone_transform(&farmer.skeleton.joints[4], 0);
	calc_bone_transform(&farmer.skeleton.joints[1], 0);

	calc_bone_transform(&farmer.skeleton.joints[10], 0);

	calc_bone_transform(&farmer.skeleton.joints[11], 0);
//	calc_bone_transform(&farmer.skeleton.joints[8], 0);
//	calc_bone_transform(&farmer.skeleton.joints[9], 0);

	glutPostRedisplay();
}
Esempio n. 13
0
static void
zprKey(unsigned char key, int x, int y)
{
  float speed = 0.3, rotSpeed = 0.3;
    GLfloat speedX = 0, speedY = 0, speedZ = 0,
    angle = 0.0,
    dX = 0, dY = 0, dZ = 0;

    bool turnedX = false, turnedY = false;

 //   printf("%c\n", key);

  switch (key)
   {
   case 'i':
     speedY = speed;
     break;
   case 'k':
     speedY = -speed;
     break;
   case 'j':
     speedX = -speed;
     break;
   case 'l':
     speedX = speed;
     break;

   case 'd':
        angle = -rotSpeed;
        turnedY = true;
     break;
   case 'a':
        angle = rotSpeed;
        turnedY = true;
     break;
   case 'w':
     speedZ = -speed;
     break;
   case 's':
     speedZ = speed;
     break;

   case 'q':
    angle = -rotSpeed;
    turnedX = true;
     break;
   case 'e':
    angle = rotSpeed;
    turnedX = true;
     break;
   }

    dX = (GLfloat) _cameraMatrix->m[0] * speedX + _cameraMatrix->m[4] * speedY + _cameraMatrix->m[8] * speedZ;
    dY = (GLfloat) _cameraMatrix->m[1] * speedX + _cameraMatrix->m[5] * speedY + _cameraMatrix->m[9] * speedZ;
    dZ = (GLfloat) _cameraMatrix->m[2] * speedX + _cameraMatrix->m[6] * speedY + _cameraMatrix->m[10] * speedZ;

    camera.x += dX;
    camera.y += dY;
    camera.z += dZ;

    lookAtPoint.x += dX;
    lookAtPoint.y += dY;
    lookAtPoint.z += dZ;

    if(turnedY)
    {
        tMat = T(-camera.x, -camera.y, -camera.z);
        rotMat = ArbRotate(up, angle);
        lookAtPoint = MultVec3(tMat, lookAtPoint);
        lookAtPoint = MultVec3(rotMat, lookAtPoint);
        tMat = T(camera.x, camera.y, camera.z);
        lookAtPoint = MultVec3(tMat, lookAtPoint);
    }
    if(turnedX)
    {
        tMat = T(-lookAtPoint.x, -lookAtPoint.y, -lookAtPoint.z);
        rotMat = ArbRotate(right, angle);
        camera = MultVec3(tMat, camera);
        camera = MultVec3(rotMat, camera);
        tMat = T(lookAtPoint.x, lookAtPoint.y, lookAtPoint.z);
        camera = MultVec3(tMat, camera);
    }
    updateCameraMatrix(0);
}
Esempio n. 14
0
void display()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	sfDrawString(20, -20, "SELECT ZXCVBN");
	sfDrawString(-20, -20, "SELECT 123456");

	glUniform1i(glGetUniformLocation(program, "texRepeat"), texRepeat); // Texture repeat

	switch (leftSelection)
	{
	case kSingleNearest:
		sfDrawString(-20, 20, "Single texture, nearest");
		glBindTexture(GL_TEXTURE_2D, miptex);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		break;
	case kSingleLinear:
		sfDrawString(-20, 20, "Single texture, linear");
		glBindTexture(GL_TEXTURE_2D, miptex);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		break;
	case kMipmapNearestNearest:
		sfDrawString(-20, 20, "Mipmap, nearest level, nearest texel");
		glBindTexture(GL_TEXTURE_2D, miptex);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
		break;
	case kMipmapLinearNearest:
		sfDrawString(-20, 20, "Mipmap, linear level, nearest texel");
		glBindTexture(GL_TEXTURE_2D, miptex);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
		break;
	case kMipmapNearestLinear:
		sfDrawString(-20, 20, "Mipmap, nearest level, linear texel");
		glBindTexture(GL_TEXTURE_2D, miptex);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
		break;
	case kMipmapLinearLinear:
		sfDrawString(-20, 20, "Mipmap, linear level, linear texel");
		glBindTexture(GL_TEXTURE_2D, miptex);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
		break;
	}
	
	mat4 tr, rot, sc, m;
	Point3D axis = {1,1,1};
	
	glUseProgram(program); // Not really needed since simplefont restores the shader.
	
	glUniformMatrix4fv(glGetUniformLocation(program, "projMatrix"), 1, GL_TRUE, projectionMatrix.m);
	
	tr = T(1, 0, 0);
	rot = ArbRotate(axis, myTime*M_PI/180);
	m = Mult(worldToViewMatrix, tr);
	m = Mult(m, rot);
	glUniformMatrix4fv(glGetUniformLocation(program, "modelviewMatrix"), 1, GL_TRUE, m.m);
	glBindVertexArray(vertexArrayObjID);	// Select VAO
	glDrawArrays(GL_TRIANGLES, 0, 36*3);	// draw object
	
	rot = Ry(myTime*M_PI/180);
	tr = T(1, 0, 0);
	sc = S(0.5, 0.5, 0.5);
	m = Mult(m, rot);
	m = Mult(m, tr);
	m = Mult(m, sc);
	glUniformMatrix4fv(glGetUniformLocation(program, "modelviewMatrix"), 1, GL_TRUE, m.m);
	glBindVertexArray(vertexArrayObjID);	// Select VAO
	glDrawArrays(GL_TRIANGLES, 0, 36*3);	// draw object
	
	switch (rightSelection)
	{
	case kSingleNearest:
		sfDrawString(20, 40, "Single texture, nearest");
		glBindTexture(GL_TEXTURE_2D, miptex); // singletex);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		break;
	case kSingleLinear:
		sfDrawString(20, 40, "Single texture, linear");
		glBindTexture(GL_TEXTURE_2D, miptex); // singletex);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		break;
	case kMipmapNearestNearest:
		sfDrawString(20, 40, "Mipmap, nearest level, nearest texel");
		glBindTexture(GL_TEXTURE_2D, miptex);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
		break;
	case kMipmapLinearNearest:
		sfDrawString(20, 40, "Mipmap, linear level, nearest texel");
		glBindTexture(GL_TEXTURE_2D, miptex);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
		break;
	case kMipmapNearestLinear:
		sfDrawString(20, 40, "Mipmap, nearest level, linear texel");
		glBindTexture(GL_TEXTURE_2D, miptex);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
		break;
	case kMipmapLinearLinear:
		sfDrawString(20, 40, "Mipmap, linear level, linear texel");
		glBindTexture(GL_TEXTURE_2D, miptex);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
		break;
	}
	
	tr = T(-1, 0, 0);
	rot = ArbRotate(axis, myTime*M_PI/180);
	m = Mult(worldToViewMatrix, tr);
	m = Mult(m, rot);
	glUniformMatrix4fv(glGetUniformLocation(program, "modelviewMatrix"), 1, GL_TRUE, m.m);
	glBindVertexArray(vertexArrayObjID);	// Select VAO
	glDrawArrays(GL_TRIANGLES, 0, 36*3);	// draw object

	rot = Ry(myTime*M_PI/180);
	tr = T(1, 0, 0);
	sc = S(0.5, 0.5, 0.5);
	m = Mult(m, rot);
	m = Mult(m, tr);
	m = Mult(m, sc);
	glUniformMatrix4fv(glGetUniformLocation(program, "modelviewMatrix"), 1, GL_TRUE, m.m);
	glBindVertexArray(vertexArrayObjID);	// Select VAO
	glDrawArrays(GL_TRIANGLES, 0, 36*3);	// draw object

	glutSwapBuffers();
}
Esempio n. 15
0
void display(void)
{

  // Clear the screen____________________________________


if((cam.x < goalx + 2 && cam.x > goalx - 2) && (cam.z < goalz + 2 && cam.z > goalz - 2))
{
	
	third_person = true;

}
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);



  // Variables
    
  mat4 total, modelView, camMatrix;
  GLfloat t =(GLfloat)glutGet(GLUT_ELAPSED_TIME)/1000; //Scale with constant to make animation slower.
 


  //Read input_____________________________________________
  if (third_person)
    {

	goal_found = true;

      if (glutKeyIsDown('t'))
	{ 
	  third_person = false;  
	}
  
  vec3 pos =  {200, 200, 150};// SetVector(keyx,keyy,keyz);
      //Mouse control_____________________________________________
      //fmin and fmax doesn't really make sense but looks good. 
      GLfloat mousexlocal = 0;
      GLfloat mouseylocal = 0;

      if (mousex < 350 ||  mousex > 250)
	{
	  mousexlocal = 300-mousex;
	}
      else
	{
	  mousexlocal = 0;
	}

      deltaphi = deltaphi + deltaphi*-mousexlocal;
      deltaphi = fmin(0.0001,deltaphi);
      deltaphi = fmax(deltaphi,2 * PI - 0.0001);
      forward = MultVec3(Ry(deltaphi*-mousexlocal), forward);

      vec3 crossvec = CrossProduct(forward,up);

      if (mousey < 350 || mousey > 250)
	{
	  mouseylocal = 300-mousey;
	}  
      else
	{
	  mouseylocal = 0;
	}

      deltatheta = deltatheta + deltatheta* -mouseylocal;
      deltatheta = fmin(0.0001,deltatheta);
      deltatheta = fmax(deltatheta,2*PI - 0.0001);
      forward = MultVec3( ArbRotate(crossvec,deltatheta*-mouseylocal), forward);

      //Create camera matrix_____________________________________________
      camMatrix = lookAtv(pos,VectorAdd(forward,pos),up);
    }




// FIRST PERSON VIEW --------------------------------------------------------
  else
    {
      
      vec3 moveVec;
      
      if (glutKeyIsDown('w')) // forwards, obviously
	{
	  vec3 oldcam = cam; //Save old position to check if its legal.
	  moveVec = ScalarMult(VectorSub(cam, SetVector(lookAtPoint.x, cam.y, lookAtPoint.z)), 0.1); // VectorSub makes a vector in the direction we're looking.
	  cam = VectorSub(cam, moveVec); // The new camera position is the old camera position + the move vector
	  cam.y = getHeight(&ttex,cam.x, cam.z)+2; // Get the correct height from the new position  
	  GLfloat maze_height = getHeight(&ttexm, cam.x, cam.z); // Get the height of the maze at the new (possible) camera position
	  GLfloat ground_height = getHeight(&ttex, cam.x, cam.z); // Get the height of the ground at the new (possible) camera position


	  //Check if the new position is legal
	    if ((ground_height - maze_height) < ground_height) // If 0, shouldn't move ever: OK!
						   // When does it start to move??
	      {
		printf("woot");
		cam = oldcam;
	      }
	}
       else if (glutKeyIsDown('t'))
	 {
	   third_person = true;
	 }

       GLfloat mousexlocal = 0;
      GLfloat mouseylocal = 0;

      if (mousex < 350 ||  mousex > 250)
	{
	  mousexlocal = 300-mousex;
	}
      else
	{
	  mousexlocal = 0;
	}

      deltaphi = deltaphi + deltaphi*-mousexlocal;
      deltaphi = fmin(0.0001,deltaphi);
      deltaphi = fmax(deltaphi,2 * PI - 0.0001);
      forward = MultVec3(Ry(deltaphi*-mousexlocal), forward);

      vec3 crossvec = CrossProduct(forward,up);

      if (mousey < 350 || mousey > 250)
	{
	  mouseylocal = 300-mousey;
	}  
      else
	{
	  mouseylocal = 0;
	}

      deltatheta = deltatheta + deltatheta* -mouseylocal;
      deltatheta = fmin(0.0001,deltatheta);
      deltatheta = fmax(deltatheta,2*PI - 0.0001);
      forward = MultVec3( ArbRotate(crossvec,deltatheta*-mouseylocal), forward);
      lookAtPoint = VectorAdd(forward,cam);
      //Create camera matrix_____________________________________________
      camMatrix = lookAtv(cam,lookAtPoint,up);

    }

  
  // --------------------------------------------------------//
  // SKYBOX
  // --------------------------------------------------------//

	glDisable(GL_DEPTH_TEST);
	glDisable(GL_CULL_FACE);

	glUseProgram(programSky);
	glActiveTexture(GL_TEXTURE2);
	//glBindTexture(GL_TEXTURE_2D, tex2);
	trans = T(0.0, 0.0, 0.0);

       	rot = Rx(0);
	total = Mult(trans, rot);
       	glUniformMatrix4fv(glGetUniformLocation(programSky, "mdlMatrix"), 1, GL_TRUE, total.m);

	lookSky = camMatrix;

	lookSky.m[3] = 0;
	lookSky.m[7] = 0;
	lookSky.m[11] = 0;

	glUniformMatrix4fv(glGetUniformLocation(programSky, "lookMatrix"), 1, GL_TRUE, lookSky.m);
	glUniformMatrix4fv(glGetUniformLocation(programSky, "projectionMatrix"), 1, GL_TRUE, projectionMatrix.m);

	glUniform1i(glGetUniformLocation(programSky, "texUnit2"), 2); // Texture unit 2
	DrawModel(skybox, programSky, "in_Position", NULL, "inTexCoord");


	glUseProgram(program);
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_CULL_FACE);

	//------------------------------------------------------//
	//------------------------------------------------------//



 
  modelView = IdentityMatrix();
  total = Mult(camMatrix, modelView);

  glActiveTexture(GL_TEXTURE1);
  glUseProgram(program);
  glUniformMatrix4fv(glGetUniformLocation(program, "mdlMatrix"), 1, GL_TRUE, total.m);
  glBindTexture(GL_TEXTURE_2D, tex2);		// Bind Our Texture tex1
  DrawModel(tm, program,"inPosition", "inNormal", "inTexCoord");

  glUseProgram(program);
  glUniformMatrix4fv(glGetUniformLocation(program, "mdlMatrix"), 0, GL_TRUE, total.m);
  glBindTexture(GL_TEXTURE_2D, tex1);		// Bind Our Texture tex1
  DrawModel(mm, program,"inPosition", "inNormal", "inTexCoord");

  GLfloat y = getHeight(&ttexm, 200, 147);
  mat4 trans = T(goalx, 2, goalz);
  mat4 scale = S(1, 1, 1);
 total = Mult(total, trans);
 total = Mult(total, scale);

 
 if (goal_found)
{
	char* string = "GOOD JOB!! You won :D";
	sfDrawString(100, 100, string);
	//while(true){};
}



  glUniformMatrix4fv(glGetUniformLocation(program, "mdlMatrix"), 1, GL_TRUE, total.m);
  glBindTexture(GL_TEXTURE_2D, tex3);		// Bind Our Texture tex1


  DrawModel(goal, program,"inPosition", "inNormal", "inTexCoord");


  



  printError("display 2");
	
  glutSwapBuffers();
  printf("x %f\n", cam.x);
  printf("y %f\n", cam.y);
  printf("z %f\n", cam.z);
  
  /* if ( (cam.x < 95) && (cam.x > 85) && */
  /*      (cam.z < 85) && (cam.z > 75)) */

  
}
void init(void)
{
	dumpInfo();  // shader info

	// GL inits
	glClearColor(0.1, 0.1, 0.3, 0);
	glClearDepth(1.0);

	glEnable(GL_TEXTURE_2D);
	glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);
    glCullFace(GL_BACK);


    // Load shader
    shader = loadShaders("shaders/projekt.vert", "shaders/projekt.frag");
    phongshader = loadShaders("shaders/phong.vert", "shaders/phong.frag");
    passShader = loadShaders("shaders/plaintextureshader.vert", "shaders/plaintextureshader.frag");
    joinshader = loadShaders("shaders/joinshader.vert", "shaders/joinshader.frag");
    lightShader = loadShaders("shaders/illuminati.vert", "shaders/illuminati.frag");
    cameraDepthShader = loadShaders("shaders/cameraDepth.vert", "shaders/cameraDepth.frag");
    lightDepthShader = loadShaders("shaders/lightDepth.vert", "shaders/lightDepth.frag");
    thickness = loadShaders("shaders/thickness.vert", "shaders/thickness.frag");

    //shadow shaders

    projTexShaderId = loadShaders("shaders/depth1V.vert", "shaders/depth1F.frag");
    projTexShaderId2 = loadShaders("shaders/depth2V.vert", "shaders/depth2F.frag");
    projTexMapUniform = glGetUniformLocation(projTexShaderId,"textureUnit");
    plainShaderId = loadShaders("shaders/plain.vert", "shaders/plain.frag");


    // Init FBOs
	fbo_phong = initFBO(W, H, 0);
	//fbo2 = initFBO(W, H, 0);
    fbo_depth = initFBO2(W,H, 0, 1);
    fbo_depth2 = initFBO2(W,H, 0, 1);
	fbo3 = initFBO(W, H, 0);
    fbo_sub = initFBO(W,H,0);
    fbo_lightDepth = initFBO(W,H,0);


    squareModel = LoadDataToModel(
            square, NULL, squareTexCoord, NULL,
            squareIndices, 4, 6);

    cam = SetVector(0, 0, 0.01);
    point = SetVector(0, 0, -10);
    axis = SetVector(0, 1, 0);


	// load the model
    bunny = LoadModelPlus("objects/bunny2/bunny_unwrap_noextras_blender.obj");
    LoadTGATextureSimple("textures/badBunny.tga", &thicknessBunny);
    modelMatrix = Mult( modelMatrix, ArbRotate(axis, -0.6));
    statue = LoadModelPlus("good_objects/statue_unwrapped_blender.obj");
    LoadTGATextureSimple("textures/statue.tga", &thicknessStatue);

    box = LoadModelPlus("good_objects/box_standard_blender.obj");
    LoadTGATextureSimple("textures/box.tga", &thicknessBox);

    box_bulge = LoadModelPlus("good_objects/box_bulge.obj");
    box_valley = LoadModelPlus("good_objects/box_valley.obj");
    box_stretched = LoadModelPlus("good_objects/box_stretched.obj");

    // load the scenemodels
    bottom = LoadModelPlus("objects/bottom.obj");
    side1 = LoadModelPlus("objects/side1.obj");
    side2 = LoadModelPlus("objects/side2.obj");

    // load sphere
    sphere = LoadModelPlus("objects/sphere.obj");
    printf("%d vertices\n", sphere->numVertices);
    printf("%d indices\n", sphere->numIndices);

    //Light stuff
    lightPosition = SetVector(-5.0,5.0,-4.0);
    sphereModelMatrix = Mult(T(lightPosition.x, lightPosition.y, lightPosition.z), sphereModelMatrix);
    lightColor = SetVector(1.0,1.0,1.0);

    //Colors
    bunnyColor = SetVector(1.0,0.4,1.0);
    sceneColor = SetVector(0.2,0.2,0.7);

    glutTimerFunc(5, &OnTimer, 0);

    moveValue = 0.002;
    moveX = moveValue;

	zprInit(&viewMatrix, cam, point);


    //modelMatrix = Mult( T(0.0, -2.4,0.0),modelMatrix);

}
Esempio n. 17
0
void Body::setRot(GLfloat x, GLfloat y, GLfloat z, GLfloat a)
{
	_rotation = ArbRotate(vec3(x, y, z), a);
}
Esempio n. 18
0
void display(void)
{
	ballXPos = ballXPos + 0.03;
	ballZPos = ballZPos + 0.03;
	int d = floor(ballXPos * 5.0);
	int e = floor(ballZPos * 5.0);

	dx = ballXPos * 5.0 - d;
	dz = ballZPos * 5.0 - e; 
	
	
	if(dx+dz<1){
		dyx = tm->vertexArray[(d+1 + e * texWidth)*3+1] - tm->vertexArray[(d + e * texWidth)*3+1];	
		dyz = tm->vertexArray[(d + (e+1) * texWidth)*3+1] - tm->vertexArray[(d + e * texWidth)*3+1];
		ballYPos = dyx*dx+dyz*dz + tm->vertexArray[(d + e * texWidth)*3+1];
		
	} 
	else{
		dyx = tm->vertexArray[(d+1 + e * texWidth)*3+1] - tm->vertexArray[((d+1) + (e+1) * texWidth)*3+1];	
		dyz = tm->vertexArray[(d + (e+1) * texWidth)*3+1] - tm->vertexArray[((d+1) + (e+1) * texWidth)*3+1];
		dx = (ceil(ballXPos * 5.0)-ballXPos * 5.0);
		dz = (ceil(ballZPos * 5.0)-ballZPos * 5.0);
		ballYPos = dyx*dx+dyz*dz + tm->vertexArray[((d+1) + (e+1) * texWidth)*3+1];
	}
	
	
		

	
	
	//printf("%lf\n",ballYPos);

	
	vec3 lookingDir = Normalize(VectorSub(l, p));
	vec3 walkSideways = Normalize(CrossProduct(lookingDir, v));
	
	if (glutKeyIsDown('a')) { 
	 p = VectorSub(p, walkSideways);
	 l = VectorSub(l, walkSideways);
	}
	
	if (glutKeyIsDown('d')) { 
	  p = VectorAdd(p, walkSideways);
	 l = VectorAdd(l, walkSideways);
	}

	if (glutKeyIsDown('w')) { 	
		p = VectorAdd(p, lookingDir);
		l = VectorAdd(l, lookingDir);
		} 
		
	if (glutKeyIsDown('s')) { 
		p = VectorSub(p, lookingDir);
		l = VectorSub(l, lookingDir);
	 }
		
	if (glutKeyIsDown('l')) { 
		trans = T(-p.x, -p.y, -p.z);
		trans2 = T(p.x, p.y, p.z);
		rot = Ry(-0.05);
		l = MultVec3(trans2, MultVec3(rot, MultVec3(trans, l)));
	}
	
	if (glutKeyIsDown('j')) { 
		trans = T(-p.x, -p.y, -p.z);
		trans2 = T(p.x, p.y, p.z);
		rot = Ry(0.05);
		l = MultVec3(trans2, MultVec3(rot, MultVec3(trans, l)));
	}
	
	if (glutKeyIsDown('i')) { 
	 trans = T(-p.x, -p.y, -p.z);
		trans2 = T(p.x, p.y, p.z);
		rotateUpDown = ArbRotate(walkSideways, 0.05);
		l = MultVec3(trans2, MultVec3(rotateUpDown, MultVec3(trans, l)));
	}
	if (glutKeyIsDown('k')) { 
	 trans = T(-p.x, -p.y, -p.z);
		trans2 = T(p.x, p.y, p.z);
		rotateUpDown = ArbRotate(walkSideways, -0.05);
		l = MultVec3(trans2, MultVec3(rotateUpDown, MultVec3(trans, l)));
	}


	// clear the screen
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		
	printError("pre display");
	
	glUseProgram(program);

	// Build matrix
	camMatrix = lookAtv(p,l,v);
	modelView = IdentityMatrix();
	total = Mult(camMatrix, modelView);
	glUniformMatrix4fv(glGetUniformLocation(program, "mdlMatrix"), 1, GL_TRUE, modelView.m);
	glUniformMatrix4fv(glGetUniformLocation(program, "cameraMatrix"), 1, GL_TRUE, camMatrix.m);
	DrawModel(tm, program, "inPosition", "inNormal", "inTexCoord");

	//Draw sphere
	modelToWorld = T(ballXPos, ballYPos, ballZPos);
	glUniformMatrix4fv(glGetUniformLocation(program, "mdlMatrix"), 1, GL_TRUE, modelToWorld.m);
	DrawModel(sphere, program, "inPosition", "inNormal", NULL);


	printError("display 2");
	
	glutSwapBuffers();
}
Esempio n. 19
0
void Body::setRotAcceleration(GLfloat x, GLfloat y, GLfloat z, GLfloat dda)
{
	_rotationAcceleration = ArbRotate(vec3(x, y, z), dda);
}
Esempio n. 20
0
void Body::setRotVelocity(GLfloat x, GLfloat y, GLfloat z, GLfloat da)
{
	_rotationVelocity = ArbRotate(vec3(x, y, z), da);
}