Exemplo n.º 1
0
void m4x4_rotate(matrix_4x4* mtx, float angle, float x, float y, float z, bool bRightSide)
{
	float axis[3];
	float sine = sinf(angle);
	float cosine = cosf(angle);
	float one_minus_cosine = 1.0f - cosine;
	matrix_4x4 rm, om;
	vector_4f vec = { { 1.0f, z, y, x } };
	v4f_norm4(&vec);
	axis[0] = vec.x;
	axis[1] = vec.y;
	axis[2] = vec.z;

	m4x4_zeros(&rm);

	rm.r[0].x = cosine + (one_minus_cosine * axis[0] * axis[0]);
	rm.r[0].y = (one_minus_cosine * axis[0] *  axis[1]) - (axis[2] * sine);
	rm.r[0].z = (one_minus_cosine * axis[0] * axis[2]) + (axis[1] * sine);

	rm.r[1].x = (one_minus_cosine * axis[0] * axis[1]) + (axis[2] * sine);
	rm.r[1].y = cosine + (one_minus_cosine * axis[1] * axis[1]);
	rm.r[1].z = (one_minus_cosine * axis[1] * axis[2]) - (axis[0] * sine);

	rm.r[2].x = (one_minus_cosine * axis[0] * axis[2]) - (axis[1] * sine);
	rm.r[2].y = (one_minus_cosine * axis[1] * axis[2]) + (axis[0] * sine);
	rm.r[2].z = cosine + (one_minus_cosine * axis[2] * axis[2]);
	
	rm.r[3].w = 1.0f;

	if (bRightSide) m4x4_multiply(&om, mtx, &rm);
	else            m4x4_multiply(&om, &rm, mtx);
	m4x4_copy(mtx, &om);
}
Exemplo n.º 2
0
/** 
 * Calculate a perspective projection transformation.
 * 
 * @param m the matrix to save the transformation in
 * @param fovy the field of view in the y direction
 * @param aspect the view aspect ratio
 * @param zNear the near clipping plane
 * @param zFar the far clipping plane
 */
void m4x4_perspective(GLfloat *m, GLfloat fovy, GLfloat aspect, GLfloat zNear, GLfloat zFar)
{
   GLfloat tmp[16];
   m4x4_identity(tmp);

   float sine, cosine, cotangent, deltaZ;
   GLfloat radians = fovy / 2.0 * M_PI / 180.0;

   deltaZ = zFar - zNear;
   sine = sinf(radians);
   cosine = cosf(radians);

   if ((deltaZ == 0) || (sine == 0) || (aspect == 0))
      return;

   cotangent = cosine / sine;

   tmp[0] = cotangent / aspect;
   tmp[5] = cotangent;
   tmp[10] = -(zFar + zNear) / deltaZ;
   tmp[11] = -1;
   tmp[14] = -2 * zNear * zFar / deltaZ;
   tmp[15] = 0;

   m4x4_copy(m, tmp);
}
Exemplo n.º 3
0
void glPushMatrix() {
	int mode = ctr_state.matrix_current;
	int depth = ctr_state.matrix_depth[mode];
	matrix_4x4 *mat = &ctr_state.matrix[mode][depth];
	if (mat == 0 || depth < 0 || depth >= 30) {
		return;
	}
	m4x4_copy(mat + 1, mat);
	ctr_state.matrix_depth[mode]++;
}
Exemplo n.º 4
0
/** 
 * Transposes a 4x4 matrix.
 *
 * @param m the matrix to transpose
 */
static void m4x4_transpose(GLfloat *m)
{
   const GLfloat t[16] = {
      m[0], m[4], m[8],  m[12],
      m[1], m[5], m[9],  m[13],
      m[2], m[6], m[10], m[14],
      m[3], m[7], m[11], m[15]};

   m4x4_copy(m, t);
}
Exemplo n.º 5
0
/** 
 * Creates an identity 4x4 matrix.
 * 
 * @param m the matrix make an identity matrix
 */
static void m4x4_identity(GLfloat *m)
{
   static const GLfloat t[16] = {
      1.0, 0.0, 0.0, 0.0,
      0.0, 1.0, 0.0, 0.0,
      0.0, 0.0, 1.0, 0.0,
      0.0, 0.0, 0.0, 1.0,
   };

   m4x4_copy(m, t);
}
Exemplo n.º 6
0
void m4x4_translate(matrix_4x4* mtx, float x, float y, float z)
{
	matrix_4x4 tm, om;

	m4x4_identity(&tm);
	tm.m[3] = x;
	tm.m[7] = y;
	tm.m[11] = z;

	m4x4_multiply(&om, mtx, &tm);
	m4x4_copy(mtx, &om);
}
Exemplo n.º 7
0
void m4x4_translate(matrix_4x4* mtx, float x, float y, float z)
{
	matrix_4x4 tm, om;

	m4x4_identity(&tm);
	tm.r[0].w = x;
	tm.r[1].w = y;
	tm.r[2].w = z;

	m4x4_multiply(&om, mtx, &tm);
	m4x4_copy(mtx, &om);
}
Exemplo n.º 8
0
/** 
 * Multiplies two 4x4 matrices.
 * 
 * The result is stored in matrix m.
 * 
 * @param m the first matrix to multiply
 * @param n the second matrix to multiply
 */
static void m4x4_multiply(GLfloat *m, const GLfloat *n)
{
   GLfloat tmp[16];
   const GLfloat *row, *column;
   div_t d;
   int i, j;

   for (i = 0; i < 16; i++) {
      tmp[i] = 0;
      d = div(i, 4);
      row = n + d.quot * 4;
      column = m + d.rem;
      for (j = 0; j < 4; j++)
         tmp[i] += row[j] * column[j * 4];
   }
   m4x4_copy(m, tmp);
}
Exemplo n.º 9
0
void m4x4_rotate_z(matrix_4x4* mtx, float angle, bool bRightSide)
{
	matrix_4x4 rm, om;

	float cosAngle = cosf(angle);
	float sinAngle = sinf(angle);

	m4x4_zeros(&rm);
	rm.m[0] = cosAngle;
	rm.m[1] = sinAngle;
	rm.m[4] = -sinAngle;
	rm.m[5] = cosAngle;
	rm.m[10] = 1.0f;
	rm.m[15] = 1.0f;

	if (bRightSide) m4x4_multiply(&om, mtx, &rm);
	else            m4x4_multiply(&om, &rm, mtx);
	m4x4_copy(mtx, &om);
}
Exemplo n.º 10
0
void m4x4_rotate_z(matrix_4x4* mtx, float angle, bool bRightSide)
{
	matrix_4x4 rm, om;

	float cosAngle = cosf(angle);
	float sinAngle = sinf(angle);

	m4x4_zeros(&rm);
	rm.r[0].x = cosAngle;
	rm.r[0].y = sinAngle;
	rm.r[1].x = -sinAngle;
	rm.r[1].y = cosAngle;
	rm.r[2].z = 1.0f;
	rm.r[3].w = 1.0f;

	if (bRightSide) m4x4_multiply(&om, mtx, &rm);
	else            m4x4_multiply(&om, &rm, mtx);
	m4x4_copy(mtx, &om);
}
Exemplo n.º 11
0
/**
 * Draws a gear in GLES 2 mode.
 *
 * @param gear the gear to draw
 * @param transform the current transformation matrix
 * @param x the x position to draw the gear at
 * @param y the y position to draw the gear at
 * @param angle the rotation angle of the gear
 * @param color the color of the gear
 */
static void draw_gearGLES2(gear_t *gear, GLfloat *transform,
      GLfloat x, GLfloat y, GLfloat angle)
{
   // The direction of the directional light for the scene */
   static const GLfloat LightSourcePosition[4] = { 5.0, 5.0, 10.0, 1.0};

   GLfloat model_view[16];
   GLfloat normal_matrix[16];
   GLfloat model_view_projection[16];

   /* Translate and rotate the gear */
   m4x4_copy(model_view, transform);
   m4x4_translate(model_view, x, y, 0);
   m4x4_rotate(model_view, angle, 0, 0, 1);

   /* Create and set the ModelViewProjectionMatrix */
   m4x4_copy(model_view_projection, state->ProjectionMatrix);
   m4x4_multiply(model_view_projection, model_view);

   glUniformMatrix4fv(state->ModelViewProjectionMatrix_location, 1, GL_FALSE,
                      model_view_projection);
   glUniformMatrix4fv(state->ModelViewMatrix_location, 1, GL_FALSE,
                      model_view);
   /* Set the LightSourcePosition uniform in relation to the object */
   glUniform4fv(state->LightSourcePosition_location, 1, LightSourcePosition);

   glUniform1i(state->DiffuseMap_location, 0);

   /* 
    * Create and set the NormalMatrix. It's the inverse transpose of the
    * ModelView matrix.
    */
   m4x4_copy(normal_matrix, model_view);
   m4x4_invert(normal_matrix);
   m4x4_transpose(normal_matrix);
   glUniformMatrix4fv(state->NormalMatrix_location, 1, GL_FALSE, normal_matrix);

   /* Set the gear color */
   glUniform4fv(state->MaterialColor_location, 1, gear->color);

   if (state->useVBO) {
     glBindBuffer(GL_ARRAY_BUFFER, gear->vboId);
  	 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gear->iboId);
   }

   /* Set up the position of the attributes in the vertex buffer object */
   // setup where vertex data is
   glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,
         sizeof(vertex_t), gear->vertex_p);
   // setup where normal data is
   glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE,
         sizeof(vertex_t), gear->normal_p);
   // setup where uv data is
   glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE,
         sizeof(vertex_t), gear->texCoords_p);

   /* Enable the attributes */
   glEnableVertexAttribArray(0);
   glEnableVertexAttribArray(1);
   glEnableVertexAttribArray(2);

   // Bind texture surface to current vertices
   glBindTexture(GL_TEXTURE_2D, state->texId);
    
   glDrawElements(state->drawMode, gear->tricount, GL_UNSIGNED_SHORT,
                   gear->index_p);

   /* Disable the attributes */
   glDisableVertexAttribArray(2);
   glDisableVertexAttribArray(1);
   glDisableVertexAttribArray(0);
 
}