This repository contains the implementation of my first CENG589 Digital Geometry Processing course assignment, focusing on geodesic distances, descriptors (Gaussian curvature and average geodesic distance), farthest point sampling, and Laplacian smoothing. The assignment is based on the Dijkstra's Shortest Path algorithm and utilizes the Coin3D Open Inventor renderer for visualization.

Features:

• Computation of geodesic distances between mesh vertices using Dijkstra's algorithm. The algorithm is implemented using a array, min-heap, and fibonacci heap.
• Calculation of Gaussian curvature and average geodesic distance for each vertex.
• Visualization of geodesic paths between query points on the mesh.
• Sampling of points using farthest point sampling (FPS) and computing geodesic distances to the samples.
• Smoothing of models using Laplacian smoothing.
• Coloring of triangles based on quality using the circum-radius to minimum edge length ratio.
• Supports the .off file format for representing input meshes.

Vulpix is a real-time ray tracing renderer built using the Vulkan API. Inspired by the captivating Fire-type Pokemon of the same name. Vulpix combines the power of Vulkan and the art of ray tracing to bring you stunningly lifelike graphics. The project was implemented in C++ and OpenGL. You can find more detail about the project here

Features:

• Vulkan support: Vulpix is built on the Vulkan API, harnessing its power for high-performance rendering and efficient GPU utilization.
• Vulkan Ray Tracing Extension (VK_KHR_ray_tracing) support: Vulpix enables real-time ray tracing, allowing for interactive and dynamic rendering of virtual scenes.
• Quaternion-based camera: Vulpix utilizes quaternion-based camera controls, providing smooth and intuitive camera manipulation for navigating the virtual scene.
• OBJ file loader: Vulpix supports loading scene geometry from OBJ files, allowing you to import complex models and scenes into the renderer.

This is a Flight Simulator project implemented in OpenGL as part of a CENG469 Computer Graphics course assignment. The goal of the assignment was to implement environment mapping and reflection capabilities using cubemaps. The project was implemented in C++ and OpenGL. You can find more detail about the project here

Project Structure:
The codebase follows a mini-game engine design, with separate classes for different functionalities:

• Camera.h: This class helps to control the view of the scene and manage the camera movement.
• Mesh.h: This class is responsible for storing mesh data in buffers and handling mesh-related operations.
• Shader.h: This class creates shaders, sends uniform data to the corresponding shaders, and manages the rendering pipeline.
• Renderer.h: This class binds the buffers as shader attributes, renders objects using index buffers, and loads textures.
• UAV.h: This class handles the flight mechanisms and calculations for the airplane.
• SkyBox.h: This class handles the skybox calculations and rendering.

This project aims to render smooth Bezier surfaces in OpenGL using height information provided through input.txt files. Bezier surfaces are a popular way to represent complex curved shapes, and this implementation allows you to visualize and manipulate them in a 3D environment.

Features:

• Render smooth Bezier surfaces in real-time.
• Accepts height information from input.txt files.
• Interactively manipulate the rendered surfaces using various controls.
• Shows the diffuse and specular shading effects of the given point light(s) on the surface

This is a basic multi-threaded Ray Tracer implementation for CENG477 Computer Graphics course.

Some of the properties of the Ray Tracer as follows:

• Having strong OOP features
• Multi-threaded rendering
• Parsing XML scene files and rendering images in PPM format
• An extensible abstract shape intersection base class called Shape, and derived Sphere, Triangle, and Mesh classes
• Point and Ambient Lights
• Cameras, Image planes
• Diffuse Shading
• Ambient Shading
• Bling-Phong (Specular) Shading
• Mirrorness
• Shadows

This is a basic software rasterizer, implemented Modeling Transformation, Viewing Transformation, and Rasterization stages of the Forward Rendering Pipeline in C++.

Some of the properties of the Software Rasterizer as follows:

• Supported two types of projection transformations: orthographic projection and perspective projection.
• Used the midpoint algorithm to draw triangle edges and use the barycentric coordinates based algorithm to rasterize triangle faces.
• Liang-Barsky Clipping algorithm is used
• In both wireframe and solid modes, triangles whose backface is facing the viewer will be culled.
• Having strong OOP features
• Parsing XML scene files and rendering images in PPM format