quenio / ine5420 Goto Github PK

Implement a new kind of Object in our model to represent Splines Bicubic Surfaces using forward differences.

When an object is selected on the list, its list of points should be displayed below the list of objects.

Add a label "Object" above the list of points, and a label "Points" above the list of points.

After issue #62 has been merged to develop we're having some problems with CMake and GCC.

Scanning dependencies of target graphics
[ 50%] Building CXX object CMakeFiles/graphics.dir/main.cpp.o
c++: error: unrecognized command line option ‘-Weverything’
CMakeFiles/graphics.dir/build.make:62: recipe for target 'CMakeFiles/graphics.dir/main.cpp.o' failed
make[3]: *** [CMakeFiles/graphics.dir/main.cpp.o] Error 1
CMakeFiles/Makefile2:178: recipe for target 'CMakeFiles/graphics.dir/all' failed
make[2]: *** [CMakeFiles/graphics.dir/all] Error 2
CMakeFiles/Makefile2:190: recipe for target 'CMakeFiles/graphics.dir/rule' failed
make[1]: *** [CMakeFiles/graphics.dir/rule] Error 2
Makefile:157: recipe for target 'graphics' failed
make: *** [graphics] Error 2

We're using compiler specific parameters and this should be treated accordingly.

Implement the projection of 3D objects over the 2D Window without taking into account perspective.

The world window will have to be an object on the list, just like any other, and will need to have the same operations, translation, scaling, and rotation.

In order for that to work, we need to make Window extend Object.

The point transformation methods - used in the Point, Line, Polygon and Window objects - are calculating the transformations again for every point. Instead, a list of points should be passed into these transformation methods, and the transformation matrix should be calculated once and reused for every point.

The screen's aspect ratio is causing distortion when rendering objects.

We must implement methods to add and remove objects from the World and reflect the GUI accordingly.

We need to update window rotation methods to use the normalized coordinate system from the viewport.

The Window should be displayed on the list of objects as the first/top item. When selected, the tools should manipulate the Window as if it was an object.

The line clipping menu should have an option to disable clipping.

After selecting an object we want to be able to translate it to another position, using the arrow keys.

The more you zoom into the window, the larger the point gets. The point's radius should be measured in world coordinates, and then translated to the canvas' coordinates.

Implement a new kind of Object in our model to represent Splines Bicubic Surfaces.

Implement perspective projection of 3D objects over the 2D Window.
We must take in consideration the 3D clipping methods.

Implement a new kind of Object in our model to represent Bézier Bicubic Surfaces.

Implement viewport drawing limits in canvas.

After selecting an object we want to be able to rotate clockwise and counter-clockwise, using the left and right arrow keys.

• By the default we'll be rotating around the center of the object.
• The user can click at any point to change the center of rotation.

Add. Rotate around the center of the world.

When line clipping, rotations get much slower than when clipping is disabled.

It is not possible to see on the canvas the control points that determine the shape of objects. This is specially a problem when trying to visually verify the shape of curves. The control points should be displayed when an object is selected.

We need to decouple the coordinates information from World Objects.

We need to update the window translation to use the normalized coordinate system in the viewport.

It's important to consider the user perspective, so that if the window is rotated we must translate the window accordingly.

The underlying world model already allows multiple objects being selected, but there is no way to select multiple objects from the UI.

We must implement curves as a new type of object in our world.

The first algorithm we should implement is the Bézier curve.

To increase the error reports and static analysis.

The points are being drawn as rectangles. We need to have a draw_circle primitive, so that we can draw the points.

The 3D world currently can only show 3D objects. It should be able to display 2D objects as well.

We need to update the window zooming methods to use the normalized coordinate system from the viewport.

The ability to clip B-splines.

After selecting an object we want to be able to scale it up and down, using the up and down arrow keys.

We need a small parser to read wavefront files and create our objects in the World.

More information about the file format can be found at wikipedia.

If the line's mid-point is out of the window bounds, the line won't be displayed.

Currently, the object visibility algorithm will check only the mid-point of a line to determine if the line is visible. It should instead use the clipping region codes.

We must implement a basic point clipping algorithm that will be used in case of emergencies and if the user chooses it.

We must extend our Curve object to support B-Spline curves with as many control points as needed.

Refactor B-spline function to use TransformMatrix.

As we inserted a new type of object in our world we must improve our clipping methods so that they work with curves.

Implement a Object3D class, which is comprised of a wireframe model of 3D vertices, and is able to perform the translation, scaling and rotation transformations.

We need to implement the Cohen-Sutherland clipping algorithm.

The center of the Spline is not being calculated from its control points.

Currently, you have to change the code to choose between Liang-Barsky and Cohen-Shuterland.

We need to add a Line-Clipping menu to allow switching between the methods at runtime.

• graphics.h has all the graphics model and engine.
• ui.h has all the GTK-related code.
• main.cpp has the main method, the global var World, and hooks up the button events.

Implement Coord3D, which has the x, y, and z coordinates, and is able to perform the translation, scaling, and rotation transformations.

Today, we have a single Coord type for all coordinate systems: Window, Viewport and World.

We should have different Coord types for each coordinate system in order to make it clear the conversion required between them.

Each object should have one of the following states:

• Fully visible: all points presenting the object are within the Window bounds.
• Partially visible: one or more points are outside the Window bounds.
• Hidden: all points are outside the Window bounds.

When rendering the objects, the visibility state must be verified so that:

• hidden objects are skipped during rendering.
• partially visible objects are clipped first, then rendered.
• fully visible objects are directly rendered without any transformation.

Use the Window coordinate system to determine visibility state of each object.

We need to implement a basic matrix structure and its operations.

It will be used to implement all the object transformations in the world.

We need to implement the normalized coordinate system for the world window and use it in the viewport transformation.

The ability to move the 3D objects on all axises.

Currently, the 3D object can only move on the XY plane.

We need to implement the Weiler-Atherton polygon clipping algorithm.

We must implement the Liang-Barsky clipping algorithm.

When the object is selected on the list, it should be drawn in red on the canvas.