Index

• Intro
• Platforms
• Features
• 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

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
• 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 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

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

• 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

**For more see Examples