Using Gl, glm, glew, this project renders in various objects into different scenes. There are 2 scenes - both containing various realistic elements including light. In addition, there is an object editor where the user can change the rotation, scale and position of the object, as well as the texture and shape of the object.
Rotation around the side-to-side axis is the '_pitch' (y-direction in game), rotation around the vertical axis is called '_yaw' (x-direction in game). Using these values and some angular maths the camera is updated every frame to get smooth movement.
void Camera::UpdateCameraVectors()
{
_front.x = cos(radians(_yaw)) * cos(radians(_pitch));
_front.y = sin(radians(_pitch));
_front.z = sin(radians(_yaw)) * cos(radians(_pitch));
_front = normalize(_front);
_right = normalize( cross(_front, _worldUp));
_up = normalize( cross(_right, _front));
}
Function to create the game window. Includes various 'gl' and 'glfw' functions to se the paramaters and various elements of the game window.
void Game::InitWindow(const char* title, GLboolean resizable)
{
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, GLMAJORVERSION);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, GLMINORVERSION);
glfwWindowHint(GLFW_RESIZABLE, resizable);
GLFWwindow* window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, title, NULL, NULL);
glfwGetFramebufferSize(window, &_frameBufferWidth, &_frameBufferHeight);
glViewport(0, 0, _frameBufferWidth, _frameBufferHeight);
glfwMakeContextCurrent(window);
_window = window;
if (_window == nullptr)
{
cout << "Window could not initialise" << endl;
glfwTerminate();
}
}
Using a function built in with 'gl', the user can send information to a shader file (.glsl) which can then be manipulated to produce a realisitc light effect using various equations. The equations use these values as well as other values passed in by the material - ambient, diffuse and specular. The final value calculated is then outputted and applied to the various scene objects.
void Light::SendToShader(Shader& shader)
{
shader.SetVector3f(_position, "light._position");
shader.Set1f(_intensity, "light._intensity");
shader.SetVector3f(_colour, "light._colour");
}
This function loads in a texture from a file using a 'SOIL' function. The texture paramaters are then set with a series of 'gl' functions. Next the mipmap is generated, the texture is binded and then the image data is cleared ready for the next texture to be loaded in.
void Texture::LoadFromFile(const char* path)
{
if (_texture)
{
glDeleteTextures(1, &_texture);
}
unsigned char* image = SOIL_load_image(path, &_width, &_height, NULL, SOIL_LOAD_RGBA);
glGenTextures(1, &_texture);
glBindTexture(_type, _texture);
glTexParameteri(_type, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(_type, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(_type, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(_type, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
if (image)
{
glTexImage2D(_type, 0, GL_RGBA, _width, _height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);
glGenerateMipmap(GL_TEXTURE_2D);
}
else
{
cout << "Texture error could not load image: " << path << endl;
}
glActiveTexture(0);
glBindTexture(_type, 0);
SOIL_free_image_data(image);
}
As it is a University assigment I recieved a mark for hitting certain criteria. Here is a breakdown of the marks;
Read in at least one scene object from file.
Read in multiple different scene objects from file and store in an appropriate data structure.
Render correctly with appropriate face winding, back face culling and depth testing enabled.
Render some text to the screen, either for a menu system or in game data.
Camera Movement in response to user input or an object tracking camera.
Animation/Movement of scene objects without continuous user input.
Can manipulate scene objects through user input.
At least one textured object. Can just be a cube.
A flexible texturing implementation on complex objects.
Implementation of Materials and Lighting on at least one scene object.
Read in and render 3D objects from standard file formats such as *.obj.
Implementation and rendering of a hierarchical scene graph.
Complexity and Inventiveness of scene.
Use of appropriate structures with clean, tidy and maintainable code.
Additional Gameplay elements.
Written report on the project.
A video capture of the game in action.