<p align="center"><img width="300" src="https://raw.githubusercontent.com/Jaysmito101/cgl/main/images/CGL_logo_low_mid_res.png" border="0">
</p>



<p align="center">

<img src="https://img.shields.io/github/issues-pr/Jaysmito101/cgl?style=for-the-badge" />
<img alt="Lines of code" src="https://img.shields.io/tokei/lines/github/Jaysmito101/cgl?style=for-the-badge" />
<img src="https://img.shields.io/github/repo-size/Jaysmito101/cgl?style=for-the-badge" />
<img alt="Maintenance" src="https://img.shields.io/maintenance/yes/2023?style=for-the-badge" />
<a href="https://patreon.com/jaysmito101"><img src="https://img.shields.io/endpoint.svg?url=https%3A%2F%2Fshieldsio-patreon.vercel.app%2Fapi%3Fusername%3Djaysmito101%26type%3Dpledges&style=for-the-badge" alt="Support me on Patreon" /></a>

</p>

<br/>



# Index
* [Intro](#cgl)
* [Platforms](#target-platforms)
* [Features](#what-does-cgl-provide)
* [Showreels](#showreels)

<br>

# 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)

<br>

## Target Platforms

- <b><i>Windows</b></i>
- <b><i>Linux</b></i>
- <b><i>MacOS (untested)</b></i>
- <b><i>WebAssembly (Beta)</b></i>
- <b><i>Android (Coming Soon)</b></i>

<br>

## 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)

<br>
