Features

Magnum Math Utility Containers OpenGL Corrade Core SceneGraph TextureTools Text Trade Primitives Shaders Platform MeshTools Ui Shapes DebugTools PluginManager TestSuite BulletIntegration OvrIntegration Extras Audio Interconnect Primitives Importers Fonts Font converters Audio importers Image converters Math converters Extensions

The fol­low­ing pages pro­vide a high-lev­el over­view of the fea­ture set of­fered by Mag­num. For greater de­tail please read doc­u­men­ta­tion linked from the sec­tions be­low. You can al­so click on var­i­ous parts of the ar­chi­tec­ture di­a­gram.

Our “Zen Gar­den” phi­los­o­phy

  • Con­sis­tent cod­ing, build­ing, test­ing and de­ploy­ing ex­pe­ri­ence across all plat­forms
  • Light­weight core with mod­u­lar and ex­ten­si­ble ad­dons that en­able di­verse use cas­es
  • Clean code with high test cov­er­age, built and test­ed at least once a week on all plat­forms to en­sure con­tin­u­ous re­li­a­bil­i­ty and sta­bil­i­ty
  • Ac­tive­ly main­tained ex­ten­sive doc­u­men­ta­tion
  • First-class sup­port and friend­ly com­mu­ni­ty (Git­ter chat, mail­ing list)
  • Pre­mi­um sup­port and con­sult­ing of­fers (see the Pre­mi­um Ser­vices page for de­tails)

Sup­port­ed plat­forms

  • Lin­ux and em­bed­ded Lin­ux
  • Win­dows with both MSVC and MinGW, Win­dows RT (Store/Phone)
  • mac­OS, iOS
  • An­droid
  • Web (We­bAssem­bly or asm.js), through Em­scripten

Plat­form ab­strac­tion

Cor­rade is a stand­alone li­brary that forms the base de­pen­den­cy for Mag­num. In its min­i­mal form it pro­vides plat­form ab­strac­tion and low-lev­el util­i­ties that are not di­rect­ly re­lat­ed to graph­ics. See the Cor­rade project page for de­tails.

Low-lev­el util­i­ties

Set of con­ve­nience class­es and func­tions to make writ­ing of com­mand-line ap­pli­ca­tions ac­tu­al­ly en­joy­able; with min­i­mal dif­fer­ences across var­i­ous desk­top, mo­bile and web plat­forms.

  • OS, filesys­tem and ter­mi­nal en­vi­ron­ment ac­cess with con­sis­tent UTF-8 en­cod­ing across all plat­forms
  • Col­ored out­put that prints to con­sole on desk­top and iOS, brows­er con­sole on web and log­cat on An­droid
  • String, Uni­code, hash­ing and oth­er util­i­ties

Sim­ple con­tain­ers

Da­ta struc­ture im­ple­men­ta­tions that have no di­rect equiv­a­lent in the STL or are bet­ter tai­lored to spe­cif­ic use cas­es than equiv­a­lent gen­er­al stan­dard im­ple­men­ta­tions. Some are present sim­ply to bridge dif­fer­ences be­tween C++11, C++14 and C++17.

  • Light­weight C ar­ray wrap­pers with abil­i­ty to con­trol item ini­tial­iza­tion
  • Non-own­ing ar­ray views with util­i­ties for ar­ray slic­ing and cast­ing
  • Type-safe bit­fields, in­tru­sive list and more

Core API

The base Mag­num li­brary con­tains the min­i­mal set of APIs for graph­ics de­vel­op­ment. Apart from Cor­rade it has no ex­ter­nal de­pen­den­cies to make port­ing to new plat­forms as fric­tion­less as pos­si­ble.

Math li­brary

De­signed pri­mar­i­ly for graph­ics with em­pha­sis on im­ple­men­ta­tion sim­plic­i­ty and de­bug per­for­mance. Pro­vides vec­tor and ma­trix op­er­a­tions, com­plex num­bers, quater­nions and their du­al coun­ter­parts. In­tu­itive trans­for­ma­tion APIs in both 2D and 3D.

  • Strong types and lit­er­als for en­ter­ing ra­di­ans, de­grees and half-floats
  • Hex col­or lit­er­als, sRGB, HSV and XYZ col­orspace sup­port
  • Dis­tance and in­ter­sec­tion cal­cu­la­tion, ma­trix de­com­po­si­tion al­go­rithms

OpenGL wrap­ping lay­er

Ab­stracts away plat­form dif­fer­ences and ex­ten­sions, re­sult­ing in a sin­gle API cov­er­ing desk­top OpenGL, OpenGL ES and We­bGL. De­pend­ing on the GPU driv­er, the back­end se­lects the most suit­able fea­ture im­ple­men­ta­tion, giv­ing pri­or­i­ty to re­cent ex­ten­sions.

  • OpenGL 2.1 to 4.5, OpenGL ES 2.0, 3.0, 3.1, We­bGL 1 / 2 + ex­ten­sions
  • DSA-like API with state track­ing, elim­i­na­tion of re­dun­dant GL calls, fea­ture em­u­la­tion on old­er driv­ers
  • Can co-ex­ist with oth­er ren­der­ers shar­ing the same OpenGL con­text, ex­change live OpenGL ob­jects with third-par­ty code

Ex­tra func­tion­al­i­ty »

While you can stay with just the core Mag­num li­brary, there are ad­di­tion­al opt-in li­braries and tools pro­vid­ing fea­tures that can make de­vel­op­ment of your ap­pli­ca­tion eas­i­er. APIs for as­set man­age­ment, mesh and tex­ture tools, de­bug­ging and pro­to­typ­ing util­i­ties, com­mand-line util­i­ties and much more.

Plug­ins & ex­ten­sions »

The li­braries are ex­ten­si­ble via plug­ins for as­set load­ing and con­ver­sion or, for ex­am­ple, text ren­der­ing. Mag­num pro­vides a rich set of plug­ins for load­ing com­mon im­age and scene for­mats, au­dio for­mats and im­age for­mat con­ver­sion. It’s al­so pos­si­ble to in­te­grate math li­brary of your choice for seam­less use with core Mag­num APIs.