static gboolean
matrix_decompose_2d (const graphene_matrix_t *m,
graphene_point3d_t *scale_r,
float shear_r[3],
graphene_quaternion_t *rotate_r,
graphene_point3d_t *translate_r)
{
float A = graphene_matrix_get_value (m, 0, 0);
float B = graphene_matrix_get_value (m, 1, 0);
float C = graphene_matrix_get_value (m, 0, 1);
float D = graphene_matrix_get_value (m, 1, 1);
float scale_x, scale_y;
float shear_xy;
float rotate;
if (A * D == B * C)
return FALSE;
scale_x = sqrtf (A * A + B * B);
A /= scale_x;
B /= scale_x;
shear_xy = A * C + B * D;
C -= A * shear_xy;
D -= B * shear_xy;
scale_y = sqrtf (C * C + D * D);
C /= scale_y;
D /= scale_y;
shear_xy /= scale_y;
if (A * D < B * C)
{
A = -A;
B = -B;
C = -C;
D = -D;
shear_xy = -shear_xy;
scale_x = -scale_x;
}
rotate = atan2f (B, A);
graphene_quaternion_init (rotate_r, 0.f, 0.f, sin (rotate / 2.f), cos (rotate / 2.f));
shear_r[XY_SHEAR] = shear_xy;
graphene_point3d_init (scale_r, scale_x, scale_y, 1.f);
graphene_point3d_init (translate_r,
graphene_matrix_get_value (m, 3, 0),
graphene_matrix_get_value (m, 3, 1),
0.f);
return TRUE;
}
GRAPHENE_TEST_UNIT_END
GRAPHENE_TEST_UNIT_BEGIN (frustum_matrix_contains_point)
{
#if defined(GRAPHENE_USE_GCC)
# if GLIB_CHECK_VERSION (2, 38, 0)
g_test_skip ("Disabled when using GCC vectors");
# else
if (g_test_verbose ())
g_test_message ("Disabled when using GCC vectors");
# endif
#else
graphene_matrix_t m;
graphene_frustum_t f;
graphene_point3d_t p;
graphene_matrix_init_frustum (&m, -1.f, 1.f, -1.f, 1.f, 1.f, 100.f);
graphene_frustum_init_from_matrix (&f, &m);
g_assert_false (graphene_frustum_contains_point (&f, graphene_point3d_init (&p, 0.f, 0.f, 0.f)));
g_assert_true (graphene_frustum_contains_point (&f, graphene_point3d_init (&p, 0.f, 0.f, -50.f)));
g_assert_true (graphene_frustum_contains_point (&f, graphene_point3d_init (&p, 0.f, 0.f, -1.001f)));
g_assert_true (graphene_frustum_contains_point (&f, graphene_point3d_init (&p, -1.f, -1.f, -1.001f)));
g_assert_false (graphene_frustum_contains_point (&f, graphene_point3d_init (&p, -1.1f, -1.1f, -1.001f)));
g_assert_true (graphene_frustum_contains_point (&f, graphene_point3d_init (&p, 1.f, 1.f, -1.001f)));
g_assert_false (graphene_frustum_contains_point (&f, graphene_point3d_init (&p, 1.1f, 1.1f, -1.001f)));
#endif
}
static void
sphere_contains_point (mutest_spec_t *spec)
{
graphene_point3d_t check, zero = GRAPHENE_POINT3D_INIT_ZERO;
graphene_sphere_t *s;
s = graphene_sphere_init (graphene_sphere_alloc (), &zero, 1.f);
mutest_expect ("unit sphere to contain origin",
mutest_bool_value (graphene_sphere_contains_point (s, &zero)),
mutest_to_be_true,
NULL);
graphene_point3d_init (&check, 1.f, 0.f, 0.f);
mutest_expect ("unit sphere to contain x=1",
mutest_bool_value (graphene_sphere_contains_point (s, &check)),
mutest_to_be_true,
NULL);
graphene_point3d_init (&check, 0.f, -1.f, 0.f);
mutest_expect ("unit sphere to contain y=-1",
mutest_bool_value (graphene_sphere_contains_point (s, &check)),
mutest_to_be_true,
NULL);
graphene_point3d_init (&check, 0.f, 0.f, 1.f);
mutest_expect ("unit sphere to contain z=1",
mutest_bool_value (graphene_sphere_contains_point (s, &check)),
mutest_to_be_true,
NULL);
mutest_expect ("unit sphere to not contain (1, 1, 1)",
mutest_bool_value (graphene_sphere_contains_point (s, &GRAPHENE_POINT3D_INIT (1, 1, 1))),
mutest_not, mutest_to_be_true,
NULL);
graphene_sphere_free (s);
}
static void
sphere_translate (mutest_spec_t *spec)
{
graphene_sphere_t s;
graphene_point3d_t p;
graphene_sphere_init (&s, &GRAPHENE_POINT3D_INIT (1.f, 1.f, 1.f), 1.f);
graphene_point3d_init (&p, -1.f, -1.f, -1.f);
graphene_sphere_translate (&s, &p, &s);
graphene_sphere_get_center (&s, &p);
mutest_expect ("translating a unit sphere from (1, 1, 1) by -1 puts it at (0, 0, 0)",
mutest_bool_value (graphene_point3d_equal (&p, &GRAPHENE_POINT3D_INIT (0.f, 0.f, 0.f))),
mutest_to_be_true,
NULL);
}
static gboolean
matrix_decompose_3d (const graphene_matrix_t *m,
graphene_point3d_t *scale_r,
float shear_r[3],
graphene_quaternion_t *rotate_r,
graphene_point3d_t *translate_r,
graphene_vec4_t *perspective_r)
{
graphene_matrix_t local, perspective;
float shear_xy, shear_xz, shear_yz;
float scale_x, scale_y, scale_z;
graphene_simd4f_t dot, cross;
if (graphene_matrix_get_value (m, 3, 3) == 0.f)
return FALSE;
local = *m;
/* normalize the matrix */
graphene_matrix_normalize (&local, &local);
/* perspective is used to solve for the perspective component,
* but it also provides an easy way to test for singularity of
* the upper 3x3 component
*/
perspective = local;
perspective.value.w = graphene_simd4f_init (0.f, 0.f, 0.f, 1.f);
if (graphene_matrix_determinant (&perspective) == 0.f)
return FALSE;
/* isolate the perspective */
if (graphene_simd4f_is_zero3 (local.value.w))
{
graphene_matrix_t tmp;
/* perspective_r is the right hand side of the equation */
perspective_r->value = local.value.w;
/* solve the equation by inverting perspective and multiplying
* the inverse with the perspective vector
*/
graphene_matrix_inverse (&perspective, &tmp);
graphene_matrix_transpose_transform_vec4 (&tmp, perspective_r, perspective_r);
/* clear the perspective partition */
local.value.w = graphene_simd4f_init (0.f, 0.f, 0.f, 1.f);
}
else
graphene_vec4_init (perspective_r, 0.f, 0.f, 0.f, 1.f);
/* next, take care of the translation partition */
translate_r->x = graphene_simd4f_get_x (local.value.w);
translate_r->y = graphene_simd4f_get_y (local.value.w);
translate_r->z = graphene_simd4f_get_z (local.value.w);
local.value.w = graphene_simd4f_init (0.f, 0.f, 0.f, graphene_simd4f_get_w (local.value.w));
/* now get scale and shear */
/* compute the X scale factor and normalize the first row */
scale_x = graphene_simd4f_get_x (graphene_simd4f_length4 (local.value.x));
local.value.x = graphene_simd4f_div (local.value.x, graphene_simd4f_splat (scale_x));
/* compute XY shear factor and the second row orthogonal to the first */
shear_xy = graphene_simd4f_get_x (graphene_simd4f_dot4 (local.value.x, local.value.y));
local.value.y = graphene_simd4f_sub (local.value.y, graphene_simd4f_mul (local.value.x, graphene_simd4f_splat (shear_xy)));
/* now, compute the Y scale factor and normalize the second row */
scale_y = graphene_simd4f_get_x (graphene_simd4f_length4 (local.value.y));
local.value.y = graphene_simd4f_div (local.value.y, graphene_simd4f_splat (scale_y));
shear_xy /= scale_y;
/* compute XZ and YZ shears, make the third row orthogonal */
shear_xz = graphene_simd4f_get_x (graphene_simd4f_dot4 (local.value.x, local.value.z));
local.value.z = graphene_simd4f_sub (local.value.z, graphene_simd4f_mul (local.value.x, graphene_simd4f_splat (shear_xz)));
shear_yz = graphene_simd4f_get_x (graphene_simd4f_dot4 (local.value.y, local.value.z));
local.value.z = graphene_simd4f_sub (local.value.z, graphene_simd4f_mul (local.value.y, graphene_simd4f_splat (shear_yz)));
/* next, get the Z scale and normalize the third row */
scale_z = graphene_simd4f_get_x (graphene_simd4f_length4 (local.value.z));
local.value.z = graphene_simd4f_div (local.value.z, graphene_simd4f_splat (scale_z));
shear_xz /= scale_z;
shear_yz /= scale_z;
shear_r[XY_SHEAR] = shear_xy;
shear_r[XZ_SHEAR] = shear_xz;
shear_r[YZ_SHEAR] = shear_yz;
/* at this point, the matrix is orthonormal. we check for a
* coordinate system flip. if the determinant is -1, then
* negate the matrix and the scaling factors
*/
dot = graphene_simd4f_cross3 (local.value.y, local.value.z);
cross = graphene_simd4f_dot4 (local.value.x, dot);
if (graphene_simd4f_get_x (cross) < 0.f)
{
scale_x *= -1.f;
scale_y *= -1.f;
scale_z *= -1.f;
graphene_simd4f_mul (local.value.x, graphene_simd4f_splat (-1.f));
graphene_simd4f_mul (local.value.y, graphene_simd4f_splat (-1.f));
graphene_simd4f_mul (local.value.z, graphene_simd4f_splat (-1.f));
}
graphene_point3d_init (scale_r, scale_x, scale_y, scale_z);
/* get the rotations out */
graphene_quaternion_init_from_matrix (rotate_r, &local);
return TRUE;
}
// The MAIN function, from here we start the application and run the game loop
int main()
{
// Init GLFW
glfwInit();
// Set all the required options for GLFW
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
// Create a GLFWwindow object that we can use for GLFW's functions
GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", NULL, NULL);
glfwMakeContextCurrent(window);
// Set the required callback functions
glfwSetKeyCallback(window, key_callback);
// Set this to true so GLEW knows to use a modern approach to retrieving function pointers and extensions
glewExperimental = GL_TRUE;
// Initialize GLEW to setup the OpenGL Function pointers
glewInit();
// Define the viewport dimensions
glViewport(0, 0, WIDTH, HEIGHT);
// Setup OpenGL options
glEnable(GL_DEPTH_TEST);
// Build and compile our shader program
shader our_shader = shader_new("shader.vs", "shader.frag");
// Set up vertex data (and buffer(s)) and attribute pointers
GLfloat vertices[] = {
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 1.0f, 1.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 1.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f
};
// World space positions of our cubes
graphene_point3d_t cubePositions[] = {
GRAPHENE_POINT3D_INIT(0.0f, 0.0f, 0.0f),
GRAPHENE_POINT3D_INIT( 2.0f, 5.0f, -15.0f),
GRAPHENE_POINT3D_INIT(-1.5f, -2.2f, -2.5f),
GRAPHENE_POINT3D_INIT(-3.8f, -2.0f, -12.3f),
GRAPHENE_POINT3D_INIT( 2.4f, -0.4f, -3.5f),
GRAPHENE_POINT3D_INIT(-1.7f, 3.0f, -7.5f),
GRAPHENE_POINT3D_INIT( 1.3f, -2.0f, -2.5f),
GRAPHENE_POINT3D_INIT( 1.5f, 2.0f, -2.5f),
GRAPHENE_POINT3D_INIT( 1.5f, 0.2f, -1.5f),
GRAPHENE_POINT3D_INIT(-1.3f, 1.0f, -1.5f)
};
GLuint VBO, VAO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
// Position attribute
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
// TexCoord attribute
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);
glBindVertexArray(0); // Unbind VAO
// Load and create a texture
GLuint texture1;
GLuint texture2;
// ====================
// Texture 1
// ====================
glGenTextures(1, &texture1);
glBindTexture(GL_TEXTURE_2D, texture1); // All upcoming GL_TEXTURE_2D operations now have effect on our texture object
// Set our texture parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture wrapping to GL_REPEAT
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// Set texture filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Load, create texture and generate mipmaps
int width, height;
unsigned char* image = SOIL_load_image("container.jpg", &width, &height, 0, SOIL_LOAD_RGB);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
glGenerateMipmap(GL_TEXTURE_2D);
SOIL_free_image_data(image);
glBindTexture(GL_TEXTURE_2D, 0); // Unbind texture when done, so we won't accidentily mess up our texture.
// ===================
// Texture 2
// ===================
glGenTextures(1, &texture2);
glBindTexture(GL_TEXTURE_2D, texture2);
// Set our texture parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// Set texture filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Load, create texture and generate mipmaps
image = SOIL_load_image("awesomeface.png", &width, &height, 0, SOIL_LOAD_RGB);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
glGenerateMipmap(GL_TEXTURE_2D);
SOIL_free_image_data(image);
glBindTexture(GL_TEXTURE_2D, 0);
// Game loop
while (!glfwWindowShouldClose(window))
{
// Check if any events have been activiated (key pressed, mouse moved etc.) and call corresponding response functions
glfwPollEvents();
// Render
// Clear the colorbuffer
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Bind Textures using texture units
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture1);
glUniform1i(glGetUniformLocation(our_shader.program, "ourTexture1"), 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, texture2);
glUniform1i(glGetUniformLocation(our_shader.program, "ourTexture2"), 1);
// Activate shader
shader_use(&our_shader);
// Create transformations
graphene_matrix_t view;
graphene_point3d_t view_point;
graphene_matrix_init_translate(&view, graphene_point3d_init(&view_point, 0.0f, 0.0f, -3.0f));
graphene_matrix_t projection;
graphene_matrix_init_perspective(&projection, 45.0f, (GLfloat) WIDTH / (GLfloat) HEIGHT, 0.1f, 100.0f);
// Get their uniform location
GLint modelLoc = glGetUniformLocation(our_shader.program, "model");
GLint viewLoc = glGetUniformLocation(our_shader.program, "view");
GLint projLoc = glGetUniformLocation(our_shader.program, "projection");
// Pass the matrices to the shader
GLfloat view_f[16] = {};
graphene_matrix_to_float(&view, view_f);
GLfloat proj_f[16] = {};
graphene_matrix_to_float(&projection, proj_f);
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, view_f);
// Note: currently we set the projection matrix each frame, but since the projection matrix rarely changes it's often best practice to set it outside the main loop only once.
glUniformMatrix4fv(projLoc, 1, GL_FALSE, proj_f);
glBindVertexArray(VAO);
for (GLuint i = 0; i < 10; i++)
{
// Calculate the model matrix for each object and pass it to shader before drawing
graphene_matrix_t model;
graphene_matrix_init_translate(&model, &cubePositions[i]);
GLfloat angle = 5.0f * i;
graphene_vec3_t axis;
graphene_vec3_init(&axis, -1.3f, 1.0f, -1.5f);
graphene_matrix_rotate(&model, angle, &axis);
GLfloat model_f[16] = {};
graphene_matrix_to_float(&model, model_f);
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, model_f);
glDrawArrays(GL_TRIANGLES, 0, 36);
}
glBindVertexArray(0);
// Swap the screen buffers
glfwSwapBuffers(window);
}
// Properly de-allocate all resources once they've outlived their purpose
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
// Terminate GLFW, clearing any resources allocated by GLFW.
glfwTerminate();
return 0;
}
