# Index * [Intro](#cgl) * [Platforms](#target-platforms) * [Features](#what-does-cgl-provide) * [Showreels](#showreels)
# CGL CGL (C Graphics Library) is a multipurpose library mainly for recreational coding / demo scenes / prototyping / small games / experimentation. This has a **lot of utilities for graphics**. And best of all all of it is inside a single header file `cgl.h`. Also CGL is made purely in C but is also compatible with C++. **NOTE** : Do not think that header only means its going to increase compile time as the implementation needs be enabled only for 1 file using `#define CGL_IMPLEMENTATION`. See [Examples](./examples)
## Target Platforms - Windows - Linux - MacOS (untested) - WebAssembly (Beta) - Android (Coming Soon)
## What does CGL Provide? * cgl-rs - A Rust wrapper ( https://crates.io/crates/cgl-rs ) * cgl-py - A python wrapper ( https://pypi.org/project/cgl-py ) * Windowing library (Optional) - You can completely disable it by `#define CGL_EXCLUDE_WINDOW_API` - This windowing library is primarily a wrapper GLFW along with a few extra functionalities. **Example** : In case you are using some library like `nuklear` for GUI it will mess up all `glfw` callbacks so with CGL you can restore the CGL callbacks with a call to `CGL_window_resecure_callbacks` * Utility functionalities - Reading/Writing files - Random float/int/bool/vec2/vec3/color generation - CRC32/CRC64 - ROT13 encryption - General Purpose Hashing Functions [refer here]( http://www.azillionmonkeys.com/qed/hash.html) - Colored printf (red, green, blue, gray/yellow) - Point/Triangle intersection check - 3D transform API (matrix calculation, etc) - TODO: [ MD5 / SHA 256 / SHA 128 / AES ] * Noise API - Multiple faster Alternatives to libc's rand - Procedural Coherent Noise Algorithms - Perlin's Noise (Improved Version) - OpenSimplex2 - Value Noise - Worley Noise (or Cellular Noise) - Fractals like FBm, Rigid, Billow, PingPong - Parameters for Octaves/Lacunarity/Weighted Strength/Gain * Triangulation - Bower Watson Algorithm for Delaunay Triangulator * Artificial Intelligence - Neural Netowrks - Backpropagation - Serializing/Deserializing networks - Multi Variable Linear Regression * Graph Algorithms - A* Path Finding (general purpose) - N Dimensional Spatial Partition and Localization (n dimensional version of a quad tree) * Data structures - List(dynamic array) + Stack (implemented together) - Hashtable -> This hastable is general purpose. Key can be string or a n-bit buffer. The value can be anything int, string, float, custom types, ... - Hashtable Iterator -> Iterate through the hashtable using a [simple](https://github.com/Jaysmito101/cgl/blob/main/examples/using_hashtable_iterator.c) API * Logger - Can be enabled/disabled by `#define CGL_DISABLE_LOGGER` - Log to multiple log files simultaneously - Log to console with colored output for seperate log levels - Logger with auto timestamps * Cross Platform Networking (Optional) - You can disable all networking by `#define CGL_EXCLUDE_NETWORKING` - Low-level sockets - SSL sockets (optional) (requires OpenSSL) - HTTP/HTTPS request (beta) * General Purpose Markov Chains (Optional) [Example](./examples/markov_text_generation.c) - Can work with any type of data ( text / image / etc. ) - Train/Generate with 3 - 4 lines of code - Trainer implemented for text generation (n-gram based) - Custom trainer API for custom scenarios * Cross Platform Threading - Threads - Mutex - Condition Variables (TODO) - NOTE: Implemented using `Win32 Threads` on Windows and `pthread` on Linux. (on Linux you need to link `pthread` to build) * Bloom - Apply bloom to any tuxtures with just 1 line of code - Implementation based of Unity's bloom - Custom thresholding - Custom downsample/upsample passes - Entirely done in Compute Shaders * 2D Collision Detection - Detect collisions between 2D polygons - Generate Seperating Axes for polygons - Get Overlap distance - GJK (Gilbert–Johnson–Keerthi distance algorithm) - EPA (Expanding Polytope Algorithm) - SAT (Seperate Axis Theorem) * Marching Square - Fully Customizablt Marcher - Linear Interpolation supported - Generates 2D Mesh (Triangles) for CGL * Toon Post Processor - Outline Effect - Toon Shading Effect - Hatching Effect - All in a single post process call ( no per object calculation) - Completely implemented in Compute Shader - Customizable * CGL Ray Cast - Fast 2D Ray Cast - Custom Walls - Bake to Triangle Mesh - Public ray cast functions * CGL Node Editor - Very fast as its powered by CGL Widgets - Custom nodes, pins, links - Minimal & Powerful - Render your own nodes & links type API - Zoom In/Out - Global Offsets * CGL Audio API - Cross Platform (OpenAL backend) - Simple API - WAV File Loader/Sampler * CSV API - CSV parser - CSV serializer - CSV document data structure * CGL Widgets (Optional) - You can disable it by `#define CGL_EXCLUDE_WIDGETS` - API Like [p5.js](https://p5js.org/) - Text widgets (render high quality crisp text without loading or baking any font) - Batch Renderer backend (very fast even for a large number of widgets) - draw (filled or stroked) : - triangle [`CGL_widgets_add_triangle`] - general quad [`CGL_widgets_add_quad`] - rectangle [`CGL_widgets_add_rect` `CGL_widgets_add_rect2f`] - line [`CGL_widgets_add_line`] - circle [`CGL_widgets_add_circle` `CGL_widgets_add_circle2f`] - oval [`CGL_widgets_add_oval`, `CGL_widgets_add_oval2f`] - arc - Plot - Scatter plot - Bar Graph (vertical/horizontal) - Pie Chart - Plot a function - font based text widgets (load custom font for high quality text rendering with widgets api) - Surrport for rendering 3D meshes with widgets API - Support for Textures to Widgtes API (efficient) - Advanced Bezier Curve( lines or dotted) widget - Add individual vertices - Adjust stroke color/thickness - Customize Batch renderer max vertices capacity (for low memory systems) * Math library - Advanced Matrix Library (this is seperate from matrix lib for graphics) - Linear Algebra for matrixx math - vec2/vec3/vec4 - mat3/mat4 (for graphics) - add/sub/mul/div/scale/length/normalize/lerp/min/max/equal for vec2/vec3/vec4 - rotate_x/rotate_y/rotate_z for vec3 - scale/translate/rotate_x/rotate_y/rotate_z/add/sub/mul for mat4 - perspective for mat4 - transpose for mat4/(mat3 TODO) - Rotation Matrices using Goldman's Method - look_at matrix - Quaternion math - Transform vectors - **NOTE:** Most of math functions are implemented via macros so will be **totally inclined** and quite fast without any unnecessary function calls * High Level OpenGL API for (Optional) - You can completely disable it by `#define CGL_EXCLUDE_GRAPHICS_API` - Texture (2D / 2D Array / Cube map) - Framebuffers - SSBO (Shader Storage Buffer Object) - UBO (Uniform Buffer Object) - Shaders - Vertex & Fragment (Geometry Shader not included as its not very widely used) - Compute Shader API * CGL Mesh API - CGL has a high level API for handling meshes - 2 types of meshes are there - CPU mesh -> stores the data also used for mesh operations like - generate triangle - generate quad - load OBJ (beta) - generate cube - generate plane - generate cylinder - generate sphere - generate mesh out of any parametric surface function [refer here](https://stackoverflow.com/a/31326534/14911094) - calculate normals - perform operation on meshes - add 2 meshes - offset vertices - etc . - GPU mesh -> the pointer to the data stored on GPU side (internally handles the Vertex buffer, Index buffer, Vertex Array) and can used for - render - render instanced - render wireframe - render wireframe instanced * CGL camera - CGL provides a proper camera abstraction - Perspective & Orthographic - It internally handles all matrix calculations (just input the position and rotation) - Auto calculates the Up, Right, Front vectors * Text Rendering (Optional) (Requires [FreeType2](http://freetype.org/)) - You can completely disable it with `#define CGL_EXCLUDE_TEXT_RENDER` - Load Fonts from `.ttf` files - Bake bitmaps for characters - Bake textures from strings * Trail Renderer - Fast 3D Trail Renderer - Bake to mesh - Custom Shader support - Fully customizable * Sky Renderer (Optional) - You can completely disable it with `#define CGL_EXCLUDE_SKY_RENDERER` - Supports both a Sky Box (cube mesh) and Sky Sphere/Dome (sphere mesh) - Supports Cube map Textured Sky - Supports Realtime Procedurally Generated Sky ( + procedural clouds) - Render a beautiful sky with just 3 - 5 lines of code * Phong Renderer (Optional) - You can disable it via `#define CGL_EXCLUDE_PHONG_RENDERER` - It has: - Phone Pipeline -> it is the pipeline holding shader data and global engine data. Options available are - enable/disable blinn correction - enable/disable depth test - enable/disable gamma correction - setup ambient lighting - add/remove lights - Phong Light -> It can be of 3 types: - Directional -> it takes (direction, color, intensity) - Point -> it takes (position, color, itensity, constant, linear, quadratic) - Spot (TODO) - Phong Material - dissuse texture/color - specular texture/color - shininess - normal maps (TODO) * Tilemap Renderer (Optional) - You can disable it with `#define CGL_EXCLUDE_TILEMAP_RENDERER` - Renders a NxN tilemap with a single line of code - Each tile can have following states - clear (transparent or disabled) - solid color - texture -> Texture can be supplied via: - texture 2d array -> you need to provide depth for each tile - tileset or texture atlas -> you have to provide bounds (normalized 0.0-1.0) of the area of the alas to be used on tile - NOTE: this tile render renders only 4 vertices and has only 1 draw call (not a instanced call so its quite fast ## Things that are being worked on: * PBR renderer (optional) * IBL (optional) ## Showreels Checkout out: [here](https://www.youtube.com/@jaysmito101/shorts) **For more see [Examples](./examples)