marsp0 / phong-software-renderer Goto Github PK

Add a basic OBJ paraser that would be able to parse meshes/textures/light sources

Add a Camera that will be part of the Scene. The camera should implement both perspective and orthographic projections, it should also implement the view matrix.

1. Use OpenMP to parallelize the for loop that iterates over the faces of a mesh. This step should generate an output list of faces that will be rendered
2. Use a thread pool to iterate over the generated faces and rasterize the different sections

Add an action to build + test code in PRs

Instead of repeating the same vertex multiple times, we should store vertices once in a vector and use indices to retrieve the correct vertex data when necessary.

Every object should return its object -> world matrix to the renderer.

Add the below to the Model class and allow the user to switch between them.

• Euler Angles
• Quaternions
• Axis-Angle
• 3D matrix

Add attribute interpolation (for now just color i guess). Add both linear and perspective-correct interpolation.

Currently the matrix code has a couple of loops in it. Check if those will be a perf issue, i dont think so but still worth checking.

Move all the _ASSERT_TYPE functions into a single templated function. Add ability to pass additional error messages.

The rasterizer uses AABB to check which pixels to color. See what alternatives exist to not have to iterate over the entire AABB

1. create new targets for the different shaders and reflection models
   • make shader-reflection
2. Move the test into a separate executable

The Scene should handle the input logic.

1. Back face culling - https://en.wikipedia.org/wiki/Back-face_culling
2. Frustum culling

Render overlay with

• bounding boxes of models
• axis representing local coordinate systems
• world coordinate system
• camera coordinate system
  more

Add documentation to the current code + generate docs.

Now that world transform, camera transform and the projection matrix are in update the draw code to

• get the different matrices
• multiply the vertices by them
• render the cube with different colors on faces.
• no backface culling or anything like that. For now we can order the vertices in a way that would hide the back face

We want to be able to construct a model and draw it in the renderer main loop.

• the vertex shader should just get the color associated with the current vertex and pass it forward
• the fragment shader should simply use the passed color (no interpolation or fancy stuff)
• dont need to apply any transforms to the vertex, simply get the vertices and their color from the model and draw it as is

The scene parser works but is extremely ugly, refactor to avoid having 100 line functions

The Flat Rasterization does not have Z-Buffering and attribute interpolation. We should either remove it (there are a lot of visible artifacts when using it) or update it to support the above.