Features

Near­ly ex­haus­tive fea­ture list of Mag­num graph­ics en­gine, in­clud­ing no­table fea­tures pro­vid­ed by Cor­rade util­i­ty li­brary.

Architecture

  • In­tu­itive C++11/C++14 API with extensive documentation
  • Em­pha­sis on per­for­mance and com­pile-time poly­mor­phism
  • Ef­fort to re­duce amount of al­lo­ca­tions, mem­o­ry copy­ing and vir­tu­al calls
  • Move se­man­tics, ref­er­ence pass­ing and au­to­mat­ic mem­o­ry man­age­ment in­stead of naked point­ers
  • Strong cov­er­age with unit tests
  • Mod­u­lar­i­ty al­low­ing to re­place par­tic­u­lar fea­tures with ex­ter­nal im­ple­men­ta­tions

Platform support

Renderers

  • OpenGL 2.1 through 4.5
  • OpenGL ES 2.0, 3.0 and 3.1
  • We­bGL 1.0
  • Ad­di­tion­al fea­tures pro­vid­ed by OpenGL, OpenGL ES and We­bGL ex­ten­sions

Platforms

Toolkit integration

  • SDL2 on desk­top and Em­scripten
  • GLUT on desk­top
  • Xlib + GLX/EGL on Lin­ux and em­bed­ded Lin­ux
  • PPA­PI on Na­tive Client
  • Win­dow­less con­text cre­ation on Lin­ux (us­ing GLX), Win­dows (us­ing WGL) and OSX (us­ing CGL)
  • Sup­port for cus­tom tool­kit in­te­gra­tion

Supported compilers and build systems

  • GCC 4.7+
  • Clang 3.1+
  • GCC 4.4, 4.5, 4.6 and MSVC 2013 sup­port­ed through com­pat­i­bil­i­ty branch
  • CMake 2.8.9+

Math library

  • Vec­tor and ma­trix class­es tem­plat­ed on com­po­nent count and un­der­ly­ing type
  • 2D and 3D trans­for­ma­tion and pro­jec­tion ma­tri­ces
  • Com­plex and du­al com­plex num­bers for 2D trans­for­ma­tions
  • Quater­nions and du­al quater­nions for 3D trans­for­ma­tions
  • Com­pile-time vec­tor swiz­zling
  • Strong­ly-typed an­gle lit­er­als to avoid de­gree/ra­di­an mis­match­es
  • Vec­tor/scalar over­loads of com­mon func­tions
  • Al­go­rithms for ma­trix de­com­po­si­tion and or­thog­o­nal­iza­tion
  • Al­go­rithms for com­put­ing dis­tances and in­ter­sec­tions

OpenGL support

  • RAII wrap­pers for de­bug out­put, buf­fers, mesh­es, frame­buffers, queries, shaders, tex­tures and trans­form feed­back
  • State track­ing to avoid need­less re­bind­ing
  • Ex­ten­sion de­tec­tion with au­to­mat­ic fall­back to old­er/slow­er func­tion­al­i­ty if giv­en fea­ture is not sup­port­ed
  • Trans­par­ent sup­port for AR­B_­di­rec­t_s­tate_ac­cess and EX­T_­di­rec­t_s­tate_ac­cess ex­ten­sions
  • Fast ex­ten­sion queries in run­time

Engine subsystems

Scene graph

  • Tem­plat­ed to al­low us­ing vir­tu­al­ly any trans­for­ma­tion im­ple­men­ta­tion, 2D or 3D
  • Builtin im­ple­men­ta­tion us­ing ei­ther plain trans­la­tion, ma­tri­ces, du­al com­plex num­bers or du­al quater­nions
  • Not im­pos­ing any par­tic­u­lar ren­der­ing tech­nique or draw call or­der­ing
  • De­cou­pled fea­tures from ob­jects, al­low­ing non-lin­ear fea­ture hi­er­ar­chies
  • Au­to­mat­ic mem­o­ry man­age­ment based on ob­ject hi­er­ar­chy

Text rendering

  • Hard­ware-ac­cel­er­at­ed glyph cache
  • Fast text up­dates us­ing buf­fer map­ping
  • Sup­port for dis­tance-field glyph ren­der­ing
  • Full UTF-8 sup­port
  • Plug­in in­ter­face for font en­gines and lay­outers
  • Plug­in in­ter­face for font con­vert­ers

Audio support

  • RAII wrap­per for Ope­nAL buf­fers and sources
  • Plug­in in­ter­face for au­dio im­porters
  • Scene graph in­te­gra­tion

Collision detection

  • Both 2D and 3D col­li­sion shapes
  • AABBs, OBBs, spheres, cap­sules, cylin­ders, points, planes and lines
  • In­vert­ed col­li­sion shapes
  • Bound­ing vol­ume hi­er­ar­chies
  • Scene graph in­te­gra­tion

Resource management

  • Ref­er­ence-count­ing re­source man­ag­er with man­u­al or im­me­di­ate mem­o­ry re­claim­ing
  • In­ter­face for syn­chro­nous and asyn­chro­nous re­source load­ers
  • Re­source hot-swap­ping

Signal/slot library

  • Pure-C++ im­ple­men­ta­tion of de­sign pat­tern pop­u­lar­ized by Qt
  • No meta-com­pil­er need­ed, com­pile-time ar­gu­ment type check­ing
  • Any mem­ber, non-mem­ber or lamb­da func­tion as a slot
  • Com­pile-time sig­nal-pow­ered state ma­chine

Containers

  • RAII wrap­per around plain C ar­rays, ar­ray view
  • Enum set
  • In­tru­sive linked list

More

  • Dy­nam­ic and stat­ic plug­ins with alias­es and de­pen­den­cy man­age­ment
  • INI-style con­fig­u­ra­tion pars­er and writ­er
  • Com­mand-line ar­gu­ment pars­er
  • File sys­tem, Uni­code, string and da­ta hash­ing util­i­ties

Ready-to-use functionality

Builtin shaders

  • Tex­tured Phong shad­er
  • Tex­tured flat shad­er, ver­tex col­or shaders
  • In­ten­si­ty based and dis­tance-field shad­er for vec­tor graph­ics
  • Wire­frame mesh vi­su­al­iz­er

Primitives

  • Square and cube prim­i­tives
  • Parametrized cir­cle, sphere and cap­sule prim­i­tives

Tools

Mesh tools

  • At­tribute in­ter­leaver util­i­ty
  • In­dex ar­ray com­pres­sion util­i­ty
  • Cache-aware in­dex op­ti­miza­tion al­go­rithm
  • Sub­di­vi­sion and du­pli­cate ver­tex re­moval
  • Nor­mal com­pu­ta­tion and flip­ping
  • Batch ver­tex trans­for­ma­tion

Texture tools

  • At­las pack­ing util­i­ty
  • Dis­tance field com­pu­ta­tion

Debugging functionality

  • Pret­ty-print­er for math­e­mat­ic struc­tures, col­lec­tions and enu­mer­a­tion val­ues
  • Run-time as­ser­tions with pret­ty-print­er
  • Vi­su­al­iz­ers for col­li­sion shapes, ob­ject trans­for­ma­tions and forces
  • Frame-based pro­fil­er

Command-line utilities

  • OpenGL ex­ten­sion and ca­pa­bil­i­ty view­er
  • Font con­vert­er
  • Dis­tance field con­vert­er

Data exchange

Import and export

  • Di­rect ac­cess to raw im­port­ed da­ta for ad­di­tion­al con­ver­sions
  • Plug­in in­ter­face for me­dia im­porters
  • Plug­in in­ter­face for im­age con­vert­ers

Media support

  • BMP, GIF, HDR, JPEG, PGM, PIC, PNG, PPM, PSD and TGA im­age im­port
  • PNG and TGA im­age ex­port
  • OBJ and PLY mesh im­port
  • OpenGEX mesh, tex­ture, scene and ma­te­ri­al im­port
  • COL­LA­DA mesh, tex­ture, scene and ma­te­ri­al im­port
  • WAV au­dio im­port
  • FreeType font en­gine
  • Harf­Buzz font lay­outer
  • In­ter­nal raster font for­mat along with con­vert­er plug­in

External framework integration

  • Bul­let Physics in­te­grat­ed in­to scene graph with col­lid­er vi­su­al­iza­tion