Introduction to Ani3D exercises

Download Ani3D exercises

Download code_epita_ani3d.tar.gz
(Linux/MacOS)

Download code_epita_ani3d.zip
(Windows)

• The lab classes use a library called CGP - Computer Graphics Programming lib - that can be accessed separately (without the exercises) on github.

Introductory scene

• - Each exercise is described as a unique program (with its own main) and must be compiled separately.
• - A CMakeLists.txt is associated to each program for its compilation (+ a Makefile for Unix systems).

• Adapt the directory to be compiled to your exercise

• - Your C++ compiler should be compatible with C++14.
• - Glad is used to load function for OpenGL 3.3.
• - GLFW is used to create a window and handle mouse/key events.
• - ImGUI is used to handle GUI.

• - Rotation: left clic + mouse displacement
• - Get close/away from the center: right clic + vertical mouse displacement
• - Panning (= translation in view plane): CTRL + left clic + mouse displacement
• - Move forward/backward (= translation in orthogonal view plane): CTRL + right droit + vertical mouse displacement

General information on the code structure and editing

General structure of the code

• scenes_[your-class]/ Contains the code associated to each 3D scene related to your class.
• • - One exercise starts with an independant main file (+ possible other files) and associated CMakeLists.txt for its compilation.
  • - The specific data and drawing calls of each exercise will be set in the files scene.cpp/hpp. The main.cpp file will only consists in the general call structure (initialization, events handling, animation loop). Most of the time, you will modify the code in scene.hpp (or other specific sub-files), and won't have to modify anything in main.cpp.
  • - Changing exercise consists in compiling the code from another directory.
  • - All your code will take place in these directories (unless you want to modify the library).

• library/cgp/ Contains the actual source code of the CGP library: set of structures and functions to ease generating your 3D scene.
• library/third_party External library used by CGP such as glad (OpenGL loader), imgui (GUI), lodepng (loader for png images), etc.

Code editor

• - C++ code completion (in particular complete function names, display expected arguments and types, objects arguments, etc.)
• - Efficient switch between files and jump to the signature and code of any function and object.

• Note: Visual Studio Code and other lightweights text editor usually doesn't provide by default correct C++ code completion.

• If you are not already familiar with C++ code editor (in Linux/Mac), you may try QtCreator, a C++ IDE able to load complete project from the CMakeLists.txt, and providing usefull tool such as code completion and structure navigation (in Windows, Visual Studio is the default IDE for C++).
• • See instructions to use QtCreator

• Finally, note that the code should be executed from the root of the code directory (the directory containing the CMakeLists.txt of the corresponding exercise) in order to load external files at runtime. You may need to parameterize your run directory in your IDE (ex. QtCreator) to start the executable within it.

Use of the code library and program structure

Adding a shape in the scene

• a. Create a class attribute of type mesh_drawable in the definition of the class scene_structure in the file scene.hpp

mesh_drawable sphere;

• b. Initialize the content of the sphere in the function initialize()

mesh sphere_mesh = mesh_primitive_sphere();
sphere.initialize_data_on_gpu(sphere_mesh);

• c. Call the drawing of the mesh_drawable variable at the end of the display_frame function

draw(sphere, environment);

• - mesh storing buffer on data (per vertex: position, normal, uv, color, and triangle connectivity) on CPU
• • • This structure allows to conveniently access to all the data defining a mesh from the C++ code. However these data are not on the GPU, so a mesh cannot be directly displayed.

• - mesh_drawable storing VBOs associated to these buffer once sent on the GPU memory (in the sub-structure mesh_drawable_gpu_data) as well as its VAO. The structure also stores uniform parameters that are sent to the shader at every draw call. A default shader and texture id are also be stored with the structure.
• • This structure only stores the index corresponding to elements on GPU. You cannot modify individual per-vertex elements easily from this structure.

• - the mesh structure (sphere_mesh) is used to initialize the positions and the connectivity of a meshed sphere shape stored on the CPU. This structure is only stored temporary in the initialization function, and used to fill the VBO in the mesh_drawable variable (sphere) using the call [mesh_drawable].initialize_data_on_gpu([mesh]) .
• - the mesh_drawable variable must be defined as a "class-level" attribute (and not as a local variable in a single function) as it is used in both the initialization, and the drawing_frame.

Modification of the sphere

// to add after "sphere.initialize(sphere_mesh, "Sphere");"
sphere.model.scaling = 0.2f; // coordinates are multiplied by 0.2 in the shader
sphere.model.translation = {1,2,0}; // coordinates are offseted by {1,2,0} in the shader
sphere.material.color = { 1,0.5f,0.5f }; // sphere will appear red (r,g,b components in [0,1])

• - The previous variables are used as "uniform variables" by the shader during the draw call.
• - These parameters are simple variables on which you can assign new values at any time (they are all attached to a default value when initializing a mesh_drawable).

Load external mesh

• - Create the class attribute (in the scene_structure in the file scene.hpp):

mesh_drawable camel;

• - Load the mesh from the file and initialize mesh_drawable in the function initialize().

// mesh_load_file_obj: read a .obj file and return a mesh structure
mesh camel_mesh = mesh_load_file_obj("assets/camel.obj");

// Classical initialization of a mesh_drawable structure
camel.initialize_data_on_gpu(camel_mesh);

// Adjusting size and position of the shape
camel.model.scaling = 0.5f;
camel.model.translation = { -1,1,0.5f };

• - Add the draw call in the function display_scene()

draw(camel, environment);

Wireframe draw

draw_wireframe(ground, environment);
draw_wireframe(sphere, environment);
draw_wireframe(cube, environment);
draw_wireframe(camel, environment);

// Wireframe displayed in red thanks to the third argument {r,g,b}
draw_wireframe(camel, environment, {1,0,0});

Checkbox interface

• a) Create a boolean class attribute storing if the wireframe display should be activated or not. To keep a clear structure, this variable can be added in the gui_parameters class (in file scene.hpp), which is itself a variable of the scene structure (gui).

• > Add the following variable in the definition of the structure struct gui_parameters (in the file scene.hpp) to store a boolean state indicating when the wireframe should be displayed or not

struct gui_parameters {
    ...
    bool display_wireframe = false;
};

• b) In the function display_gui() (in scene.cpp) add a Checkbox (handled by ImGui library) and link it to the variable display_wireframe in adding this line of code

ImGui::Checkbox("Wireframe", &gui.display_wireframe);

• c) In the function display_frame() call draw_wireframe only in the case where the value of display_wireframe is True.

if (gui_display_wireframe==true) {
    draw_wireframe(ground, environment);
    draw_wireframe(sphere, environment);
    draw_wireframe(cube, environment);
    draw_wireframe(camel, environment);
}

• Check that you can now interactively display the wireframe representation of the sphere.

Placing several similar elements

• > Add multiple cones in your scene using the following syntax:

// (In the scene_structure header)
std::vector<vec3> cone_positions;
mesh_drawable cone;

// (In the initialization function)
cone.initialize_data_on_gpu( mesh_primitive_cone(0.1f, 0.2f) );
const int N_cone = 40;
for (int k = 0; k < N_cone; ++k)
{
    float x = rand_interval(-2, 2);
    float z = rand_interval(-2, 2);

    cone_positions.push_back( {x,-1,z} );
}

// (In the display_frame function)
for (int k = 0; k < cone_positions.size(); ++k)
{
    cone.model.translation = cone_positions[k];
    draw(cone, environment);
}

• - Only one cone is created and stored in memory

• - This single cone is displayed several times at different pre-stored positions

• - What would have happend if the loop initializing the variable cone_positions was placed in the display_frame function instead of initialization ?

Exercise

• Adapt the code to model the following scene

• Note that trees should not intersect each others
• • (your algorithm doesn't have to be optimal in complexity)