OpenGL Programming Pt2

Question 1

Q1: Why do we need to load external models in OpenGL?

Answer 1

A1: Because real 3D models have thousands of vertices and can’t be manually hardcoded — they must be loaded from files like .obj.

Question 2

Q2: What is the purpose of a model file in 3D graphics?

Answer 2

A2: It stores the vertex positions, normals, and indices that describe a 3D object’s shape and structure.

Question 3

Q3: What are common sources of 3D models?

Answer 3

A3: Engineering/scientific data or assets created in modeling software like Blender, Maya, or 3ds Max.

Question 4

Q4: What model format is commonly used in OpenGL teaching examples?

Answer 4

A4: .obj (Wavefront Object).

Question 5

Q5: What are the advantages of the OBJ format?

Answer 5

A5: It’s text-based, human-readable, platform-independent, and easy to find or create.

Question 6

Q6: What is a disadvantage of the OBJ format?

Answer 6

A6: It’s slow to load for large models because it’s not binary and may include redundant data.

Question 7

Q7: What library is used to load .obj models?

Answer 7

A7: TinyOBJLoader — a lightweight C++ library that parses OBJ files and provides vertices, normals, and indices.

Question 8

Q8: What kind of data does TinyOBJLoader extract?

Answer 8

Vertex positions

Normals

Indices (faces)

Material information

Question 9

Q9: Why are arrays like vertices and normals declared as pointers?

Answer 9

A9: Because their sizes aren’t known until the model file is read, so memory is allocated dynamically.

Question 10

Q10: What is a bounding box?

Answer 10

A10: The smallest 3D box that completely encloses a model — defined by (xmin, xmax, ymin, ymax, zmin, zmax).

Question 11

Q11: Why compute a bounding box when loading a model?

Answer 11

To know the model’s size and position

To scale or center it in view

To position the camera correctly

Question 12

Q12: Why can’t we use sizeof(vertices) when uploading data to the GPU?

Answer 12

A12: Because vertices is a pointer, not a fixed array — you must use num_vertices * sizeof(GLfloat) instead.

Question 13

Q13: What buffers are used to send data to the GPU?

Answer 13

VBO (Vertex Buffer Object) for vertices and normals

EBO (Element Buffer Object) for indices

Question 14

Q14: Why is glBufferSubData used after glBufferData?

Answer 14

A14: To fill different parts of the same buffer (e.g., first the vertices, then the normals).

Question 15

Q15: Why might your model disappear after “cleaning” your Visual Studio project?

Answer 15

A15: The .obj model file has the same extension as compiled .obj files, so Visual Studio deletes it when cleaning. Keep it in a separate folder.

Question 16

Q16: What happens if vertex order and normal order don’t match?

Answer 16

A16: Lighting will be incorrect because normals point in the wrong directions.

Question 17

Q17: How can you fix incorrect normals in a model?

Answer 17

A17: Use a tool like MeshLab → Filters → Normals, Curvature, and Orientation → Recompute Vertex Normals.

Question 18

Q18: Why might multiple models have mismatched appearance or size?

Answer 18

A18: Different coordinate systems (Y-up vs. Z-up) and inconsistent scales between models.

Question 19

Q19: What structure is used to represent each model in code?

Answer 19

struct Mesh {
GLuint vbuffer, ibuffer;
GLuint triangles, vbytes;
GLuint program;
glm::mat4 model;
};

Question 20

Q20: What is stored inside each Mesh?

Answer 20

A20: GPU buffer IDs, triangle count, assigned shader program, and its model transformation matrix.

Question 21

Q21: Why do we normalize models after loading?

Answer 21

Q21: Why do we normalize models after loading?

Question 22

Q22: How do you normalize a model’s size?

Answer 22

Find the bounding box size in x, y, and z.

Compute the maximum dimension.

Divide all vertex coordinates by that value

Question 23

Q23: Why is normalization important in multi-object scenes?

Answer 23

A23: It ensures different models (like a monkey and bunny) appear properly scaled and centered in the same scene.

Question 24

Q24: Why shouldn’t you recompile shaders for each model?

Answer 24

A24: It’s inefficient — instead, compile them once and reuse the program across models.

Question 25

Q25: How do you reuse the same shader for multiple models?

Answer 25

A25: Store the program ID in each mesh’s struct and call glUseProgram(mesh->program) before drawing.

Question 26

Q26: How can you draw multiple copies of the same object?

Answer 26

A26: Duplicate the mesh structure, reuse the same vertex/index data, and apply different model transformations.

Question 27

Q27: Why is this approach memory efficient?

Answer 27

A27: All copies share the same geometry buffers; only the transformation matrix changes.

Question 28

Q28: How do you render multiple models in the display loop?

Answer 28

for (mesh in Model) { glUseProgram(mesh->program); set attributes; send matrices; draw elements; }

Question 29

Q29: Which matrix combination is used for each object’s final position?

Answer 29

A29: Model-View-Projection (MVP) = projection * view * model.

Question 30

Q30: Why do we use a special matrix to transform normals?

Answer 30

A30: Because scaling or rotation can distort them; we need to preserve perpendicularity for lighting.

Question 31

Q31: What is the correct matrix for transforming normals?

Answer 31

A31: The inverse transpose of the model-view matrix: glm::transpose(glm::inverse(glm::mat3(view * model))).

Question 32

Q32: What does TinyOBJLoader do in the OpenGL pipeline?

Answer 32

A32: It reads model data from a .obj file and provides vertices, normals, and indices for GPU upload.

Question 33

Q33: What’s the purpose of the bounding box?

Answer 33

A33: To determine model size and positioning for scaling, centering, and camera setup.

Question 34

Q34: Why is rescaling models important?

Answer 34

A34: Ensures all models fit within a consistent space for unified viewing.

Question 35

Q35: What’s the role of the Mesh structure?

Answer 35

A35: To store all rendering-related data and transformation info for each object in the scene.

Question 36

Q36: Why use the inverse transpose for normals?

Answer 36

A36: To correct distortions caused by non-uniform scaling and preserve accurate lighting.