A lightweight, self-contained library for gizmo editing commonly found in many game engines

Overview

tinygizmo

This project is a lightweight, self-contained library for gizmo editing commonly found in many game engines. It includes mechanisms for manipulating 3d position, rotation, and scale. Implemented in C++11, the library does not perform rendering directly and instead provides a per-frame buffer of world-space triangles.

An included example is built on top of GLFW (with an OpenGL 3.3 context). Known limitations include hardcoded assumptions about a right-handed, Y-up coordinate system. While the gizmos are provided with vertex normals, the example does not perform any fancy shading. Furthermore, mouse-drag input with certain gizmos at extreme interaction grazing angles is known to produce anomalous output.

Motivation

This project was born out of mild frustration with other immediate-mode gizmo libraries. Instead of 4x4 matrices and euler angles, the library exposes a rigid_transform consisting of a 3d position, rotation quaternion, and scale. The library is implemented in around 1200 lines of code, which also includes a complete 3d math library in ~400 LoC - linalg.h. Alternatives include ImGuizmo and Im3D. Tinygizmo fits in-between these projects by being fully self-contained (no dependency on Dear ImGui), and by being provided in the public domain.

Features

  • Both axis-aligned global and object-local transform modes for translational and rotational gizmos
  • Optional ability draw the gizmos with a constant screen-space scale
  • Snap-to-unit (both linear and angular)
    • Set any of the snap_ values in the gizmo_application_state struct.
  • VR ready (the user must call update(...) and draw() for each eye)
  • Hotkeys for transitioning between translation, rotation, and scaling:
    • ctrl-t to activate the translation gizmo
    • ctrl-r to activate the rotation gizmo
    • ctrl-s to activate the scale gizmo
    • ctrl-l to toggle between global and local transform modes

Attribution

This project would not have been possible without reference implementations in the public-domain workbench project.

License

This is free and unencumbered software released into the public domain. For more information, please refer to http://unlicense.org

Issues
  • [feature request] gizmo usage events - start/stop

    [feature request] gizmo usage events - start/stop

    perhaps by querying some flag of the state after updating the context - this would be very useful for easier undo/redo of actions and would also make it much easier to determine if the input is being consumed by the gizmo or not.

    enhancement 
    opened by onqtam 6
  • Feature request: gizmo size independent of distance from camera

    Feature request: gizmo size independent of distance from camera

    It would be useful to have an option (like the snapping ones) to get the gizmo scaled according to the distance from the camera so it remains with constant size on the screen no matter where it is in the world.

    cool project! thanks for making it! It is a lot simpler than the 2 other immediate mode gizmos I was evaluating!

    Also the readme should be updated - the snapping options are in gizmo_application_state and not in interaction_state

    enhancement 
    opened by onqtam 3
  • fixing build with gcc

    fixing build with gcc

    MSVC built it as a static lib without problems but GCC needs <ostream> included before it. Tried with <iosfwd> but didn't work. Using gcc (x86_64-posix-seh-rev0, Built by MinGW-W64 project) 7.1.0 under windows.

    Here are the errors I got before fixing this:

    In file included from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:0:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp: In function 'std::ostream& operator<<(std::ostream&, minalg::vec<T, 2>&)':
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:413:99: error: no match for 'operator<<' (operand types are 'std::ostream {aka std::basic_ostream<char>}' and 'char')
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 2> & b) { return a << '{' << b.x << ", " << b.y << '}'; }
                                                                                                     ~~^~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:413:34: note: candidate: template<class T> std::ostream& operator<<(std::ostream&, minalg::vec<T, 2>&)
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 2> & b) { return a << '{' << b.x << ", " << b.y << '}'; }
                                      ^~~~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:413:34: note:   template argument deduction/substitution failed:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:413:102: note:   mismatched types 'minalg::vec<T, 2>' and 'char'
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 2> & b) { return a << '{' << b.x << ", " << b.y << '}'; }
                                                                                                          ^~~
    In file included from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/memory:81:0,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.hpp:14,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/shared_ptr.h:66:5: note: candidate: template<class _Ch, class _Tr, class _Tp, __gnu_cxx::_Lock_policy _Lp> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const std::__shared_ptr<_Tp, _Lp>&)
         operator<<(std::basic_ostream<_Ch, _Tr>& __os,
         ^~~~~~~~
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/shared_ptr.h:66:5: note:   template argument deduction/substitution failed:
    In file included from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:0:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:413:102: note:   mismatched types 'const std::__shared_ptr<_Tp, _Lp>' and 'char'
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 2> & b) { return a << '{' << b.x << ", " << b.y << '}'; }
                                                                                                          ^~~
    In file included from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string:52:0,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/stdexcept:39,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/array:39,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.hpp:11,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/basic_string.h:6082:5: note: candidate: template<class _CharT, class _Traits, class _Alloc> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const std::__cxx11::basic_string<_CharT, _Traits, _Alloc>&)
         operator<<(basic_ostream<_CharT, _Traits>& __os,
         ^~~~~~~~
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/basic_string.h:6082:5: note:   template argument deduction/substitution failed:
    In file included from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:0:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:413:102: note:   mismatched types 'const std::__cxx11::basic_string<_CharT, _Traits, _Alloc>' and 'char'
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 2> & b) { return a << '{' << b.x << ", " << b.y << '}'; }
                                                                                                          ^~~
    In file included from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/basic_string.h:48:0,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string:52,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/stdexcept:39,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/array:39,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.hpp:11,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string_view:558:5: note: candidate: template<class _CharT, class _Traits> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, std::basic_string_view<_CharT, _Traits>)
         operator<<(basic_ostream<_CharT, _Traits>& __os,
         ^~~~~~~~
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string_view:558:5: note:   template argument deduction/substitution failed:
    In file included from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:0:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:413:102: note:   mismatched types 'std::basic_string_view<_CharT, _Traits>' and 'char'
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 2> & b) { return a << '{' << b.x << ", " << b.y << '}'; }
                                                                                                          ^~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp: In function 'std::ostream& operator<<(std::ostream&, minalg::vec<T, 3>&)':
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:414:99: error: no match for 'operator<<' (operand types are 'std::ostream {aka std::basic_ostream<char>}' and 'char')
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 3> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << '}'; }
                                                                                                     ~~^~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:413:34: note: candidate: template<class T> std::ostream& operator<<(std::ostream&, minalg::vec<T, 2>&)
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 2> & b) { return a << '{' << b.x << ", " << b.y << '}'; }
                                      ^~~~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:413:34: note:   template argument deduction/substitution failed:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:414:102: note:   mismatched types 'minalg::vec<T, 2>' and 'char'
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 3> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << '}'; }
                                                                                                          ^~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:414:34: note: candidate: template<class T> std::ostream& operator<<(std::ostream&, minalg::vec<T, 3>&)
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 3> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << '}'; }
                                      ^~~~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:414:34: note:   template argument deduction/substitution failed:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:414:102: note:   mismatched types 'minalg::vec<T, 3>' and 'char'
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 3> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << '}'; }
                                                                                                          ^~~
    In file included from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/memory:81:0,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.hpp:14,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/shared_ptr.h:66:5: note: candidate: template<class _Ch, class _Tr, class _Tp, __gnu_cxx::_Lock_policy _Lp> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const std::__shared_ptr<_Tp, _Lp>&)
         operator<<(std::basic_ostream<_Ch, _Tr>& __os,
         ^~~~~~~~
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/shared_ptr.h:66:5: note:   template argument deduction/substitution failed:
    In file included from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:0:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:414:102: note:   mismatched types 'const std::__shared_ptr<_Tp, _Lp>' and 'char'
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 3> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << '}'; }
                                                                                                          ^~~
    In file included from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string:52:0,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/stdexcept:39,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/array:39,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.hpp:11,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/basic_string.h:6082:5: note: candidate: template<class _CharT, class _Traits, class _Alloc> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const std::__cxx11::basic_string<_CharT, _Traits, _Alloc>&)
         operator<<(basic_ostream<_CharT, _Traits>& __os,
         ^~~~~~~~
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/basic_string.h:6082:5: note:   template argument deduction/substitution failed:
    In file included from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:0:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:414:102: note:   mismatched types 'const std::__cxx11::basic_string<_CharT, _Traits, _Alloc>' and 'char'
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 3> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << '}'; }
                                                                                                          ^~~
    In file included from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/basic_string.h:48:0,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string:52,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/stdexcept:39,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/array:39,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.hpp:11,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string_view:558:5: note: candidate: template<class _CharT, class _Traits> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, std::basic_string_view<_CharT, _Traits>)
         operator<<(basic_ostream<_CharT, _Traits>& __os,
         ^~~~~~~~
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string_view:558:5: note:   template argument deduction/substitution failed:
    In file included from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:0:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:414:102: note:   mismatched types 'std::basic_string_view<_CharT, _Traits>' and 'char'
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 3> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << '}'; }
                                                                                                          ^~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp: In function 'std::ostream& operator<<(std::ostream&, minalg::vec<T, 4>&)':
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:415:99: error: no match for 'operator<<' (operand types are 'std::ostream {aka std::basic_ostream<char>}' and 'char')
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 4> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << ", " << b.w << '}'; }
                                                                                                     ~~^~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:413:34: note: candidate: template<class T> std::ostream& operator<<(std::ostream&, minalg::vec<T, 2>&)
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 2> & b) { return a << '{' << b.x << ", " << b.y << '}'; }
                                      ^~~~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:413:34: note:   template argument deduction/substitution failed:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:415:102: note:   mismatched types 'minalg::vec<T, 2>' and 'char'
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 4> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << ", " << b.w << '}'; }
                                                                                                          ^~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:414:34: note: candidate: template<class T> std::ostream& operator<<(std::ostream&, minalg::vec<T, 3>&)
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 3> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << '}'; }
                                      ^~~~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:414:34: note:   template argument deduction/substitution failed:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:415:102: note:   mismatched types 'minalg::vec<T, 3>' and 'char'
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 4> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << ", " << b.w << '}'; }
                                                                                                          ^~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:415:34: note: candidate: template<class T> std::ostream& operator<<(std::ostream&, minalg::vec<T, 4>&)
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 4> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << ", " << b.w << '}'; }
                                      ^~~~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:415:34: note:   template argument deduction/substitution failed:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:415:102: note:   mismatched types 'minalg::vec<T, 4>' and 'char'
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 4> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << ", " << b.w << '}'; }
                                                                                                          ^~~
    In file included from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/memory:81:0,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.hpp:14,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/shared_ptr.h:66:5: note: candidate: template<class _Ch, class _Tr, class _Tp, __gnu_cxx::_Lock_policy _Lp> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const std::__shared_ptr<_Tp, _Lp>&)
         operator<<(std::basic_ostream<_Ch, _Tr>& __os,
         ^~~~~~~~
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/shared_ptr.h:66:5: note:   template argument deduction/substitution failed:
    In file included from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:0:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:415:102: note:   mismatched types 'const std::__shared_ptr<_Tp, _Lp>' and 'char'
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 4> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << ", " << b.w << '}'; }
                                                                                                          ^~~
    In file included from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string:52:0,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/stdexcept:39,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/array:39,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.hpp:11,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/basic_string.h:6082:5: note: candidate: template<class _CharT, class _Traits, class _Alloc> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const std::__cxx11::basic_string<_CharT, _Traits, _Alloc>&)
         operator<<(basic_ostream<_CharT, _Traits>& __os,
         ^~~~~~~~
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/basic_string.h:6082:5: note:   template argument deduction/substitution failed:
    In file included from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:0:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:415:102: note:   mismatched types 'const std::__cxx11::basic_string<_CharT, _Traits, _Alloc>' and 'char'
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 4> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << ", " << b.w << '}'; }
                                                                                                          ^~~
    In file included from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/basic_string.h:48:0,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string:52,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/stdexcept:39,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/array:39,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.hpp:11,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string_view:558:5: note: candidate: template<class _CharT, class _Traits> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, std::basic_string_view<_CharT, _Traits>)
         operator<<(basic_ostream<_CharT, _Traits>& __os,
         ^~~~~~~~
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string_view:558:5: note:   template argument deduction/substitution failed:
    In file included from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:0:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:415:102: note:   mismatched types 'std::basic_string_view<_CharT, _Traits>' and 'char'
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 4> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << ", " << b.w << '}'; }
                                                                                                          ^~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp: In function 'std::ostream& operator<<(std::ostream&, const minalg::mat<T, 3, M>&)':
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:416:115: error: no match for 'operator<<' (operand types are 'std::ostream {aka std::basic_ostream<char>}' and 'char')
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 3, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n'; }
                                                                                                                     ~~^~~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:413:34: note: candidate: template<class T> std::ostream& operator<<(std::ostream&, minalg::vec<T, 2>&)
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 2> & b) { return a << '{' << b.x << ", " << b.y << '}'; }
                                      ^~~~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:413:34: note:   template argument deduction/substitution failed:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:416:118: note:   mismatched types 'minalg::vec<T, 2>' and 'char'
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 3, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n'; }
                                                                                                                          ^~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:414:34: note: candidate: template<class T> std::ostream& operator<<(std::ostream&, minalg::vec<T, 3>&)
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 3> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << '}'; }
                                      ^~~~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:414:34: note:   template argument deduction/substitution failed:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:416:118: note:   mismatched types 'minalg::vec<T, 3>' and 'char'
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 3, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n'; }
                                                                                                                          ^~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:415:34: note: candidate: template<class T> std::ostream& operator<<(std::ostream&, minalg::vec<T, 4>&)
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 4> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << ", " << b.w << '}'; }
                                      ^~~~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:415:34: note:   template argument deduction/substitution failed:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:416:118: note:   mismatched types 'minalg::vec<T, 4>' and 'char'
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 3, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n'; }
                                                                                                                          ^~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:416:41: note: candidate: template<class T, int N> std::ostream& operator<<(std::ostream&, const minalg::mat<T, 3, M>&)
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 3, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n'; }
                                             ^~~~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:416:41: note:   template argument deduction/substitution failed:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:416:118: note:   mismatched types 'const minalg::mat<T, 3, M>' and 'char'
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 3, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n'; }
                                                                                                                          ^~~~
    In file included from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/memory:81:0,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.hpp:14,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/shared_ptr.h:66:5: note: candidate: template<class _Ch, class _Tr, class _Tp, __gnu_cxx::_Lock_policy _Lp> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const std::__shared_ptr<_Tp, _Lp>&)
         operator<<(std::basic_ostream<_Ch, _Tr>& __os,
         ^~~~~~~~
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/shared_ptr.h:66:5: note:   template argument deduction/substitution failed:
    In file included from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:0:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:416:118: note:   mismatched types 'const std::__shared_ptr<_Tp, _Lp>' and 'char'
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 3, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n'; }
                                                                                                                          ^~~~
    In file included from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string:52:0,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/stdexcept:39,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/array:39,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.hpp:11,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/basic_string.h:6082:5: note: candidate: template<class _CharT, class _Traits, class _Alloc> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const std::__cxx11::basic_string<_CharT, _Traits, _Alloc>&)
         operator<<(basic_ostream<_CharT, _Traits>& __os,
         ^~~~~~~~
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/basic_string.h:6082:5: note:   template argument deduction/substitution failed:
    In file included from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:0:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:416:118: note:   mismatched types 'const std::__cxx11::basic_string<_CharT, _Traits, _Alloc>' and 'char'
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 3, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n'; }
                                                                                                                          ^~~~
    In file included from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/basic_string.h:48:0,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string:52,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/stdexcept:39,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/array:39,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.hpp:11,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string_view:558:5: note: candidate: template<class _CharT, class _Traits> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, std::basic_string_view<_CharT, _Traits>)
         operator<<(basic_ostream<_CharT, _Traits>& __os,
         ^~~~~~~~
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string_view:558:5: note:   template argument deduction/substitution failed:
    In file included from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:0:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:416:118: note:   mismatched types 'std::basic_string_view<_CharT, _Traits>' and 'char'
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 3, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n'; }
                                                                                                                          ^~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp: In function 'std::ostream& operator<<(std::ostream&, const minalg::mat<T, 4, M>&)':
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:417:115: error: no match for 'operator<<' (operand types are 'std::ostream {aka std::basic_ostream<char>}' and 'char')
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 4, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n' << b.row(3) << '\n'; }
                                                                                                                     ~~^~~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:413:34: note: candidate: template<class T> std::ostream& operator<<(std::ostream&, minalg::vec<T, 2>&)
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 2> & b) { return a << '{' << b.x << ", " << b.y << '}'; }
                                      ^~~~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:413:34: note:   template argument deduction/substitution failed:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:417:118: note:   mismatched types 'minalg::vec<T, 2>' and 'char'
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 4, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n' << b.row(3) << '\n'; }
                                                                                                                          ^~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:414:34: note: candidate: template<class T> std::ostream& operator<<(std::ostream&, minalg::vec<T, 3>&)
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 3> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << '}'; }
                                      ^~~~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:414:34: note:   template argument deduction/substitution failed:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:417:118: note:   mismatched types 'minalg::vec<T, 3>' and 'char'
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 4, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n' << b.row(3) << '\n'; }
                                                                                                                          ^~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:415:34: note: candidate: template<class T> std::ostream& operator<<(std::ostream&, minalg::vec<T, 4>&)
     template<class T> std::ostream & operator << (std::ostream & a, minalg::vec<T, 4> & b) { return a << '{' << b.x << ", " << b.y << ", " << b.z << ", " << b.w << '}'; }
                                      ^~~~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:415:34: note:   template argument deduction/substitution failed:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:417:118: note:   mismatched types 'minalg::vec<T, 4>' and 'char'
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 4, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n' << b.row(3) << '\n'; }
                                                                                                                          ^~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:416:41: note: candidate: template<class T, int N> std::ostream& operator<<(std::ostream&, const minalg::mat<T, 3, M>&)
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 3, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n'; }
                                             ^~~~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:416:41: note:   template argument deduction/substitution failed:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:417:118: note:   mismatched types 'const minalg::mat<T, 3, M>' and 'char'
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 4, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n' << b.row(3) << '\n'; }
                                                                                                                          ^~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:417:41: note: candidate: template<class T, int N> std::ostream& operator<<(std::ostream&, const minalg::mat<T, 4, M>&)
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 4, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n' << b.row(3) << '\n'; }
                                             ^~~~~~~~
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:417:41: note:   template argument deduction/substitution failed:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:417:118: note:   mismatched types 'const minalg::mat<T, 4, M>' and 'char'
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 4, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n' << b.row(3) << '\n'; }
                                                                                                                          ^~~~
    In file included from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/memory:81:0,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.hpp:14,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/shared_ptr.h:66:5: note: candidate: template<class _Ch, class _Tr, class _Tp, __gnu_cxx::_Lock_policy _Lp> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const std::__shared_ptr<_Tp, _Lp>&)
         operator<<(std::basic_ostream<_Ch, _Tr>& __os,
         ^~~~~~~~
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/shared_ptr.h:66:5: note:   template argument deduction/substitution failed:
    In file included from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:0:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:417:118: note:   mismatched types 'const std::__shared_ptr<_Tp, _Lp>' and 'char'
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 4, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n' << b.row(3) << '\n'; }
                                                                                                                          ^~~~
    In file included from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string:52:0,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/stdexcept:39,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/array:39,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.hpp:11,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/basic_string.h:6082:5: note: candidate: template<class _CharT, class _Traits, class _Alloc> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const std::__cxx11::basic_string<_CharT, _Traits, _Alloc>&)
         operator<<(basic_ostream<_CharT, _Traits>& __os,
         ^~~~~~~~
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/basic_string.h:6082:5: note:   template argument deduction/substitution failed:
    In file included from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:0:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:417:118: note:   mismatched types 'const std::__cxx11::basic_string<_CharT, _Traits, _Alloc>' and 'char'
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 4, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n' << b.row(3) << '\n'; }
                                                                                                                          ^~~~
    In file included from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/bits/basic_string.h:48:0,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string:52,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/stdexcept:39,
                     from C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/array:39,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.hpp:11,
                     from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string_view:558:5: note: candidate: template<class _CharT, class _Traits> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, std::basic_string_view<_CharT, _Traits>)
         operator<<(basic_ostream<_CharT, _Traits>& __os,
         ^~~~~~~~
    C:/mingw-builds/mingw64/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/string_view:558:5: note:   template argument deduction/substitution failed:
    In file included from D:\game\third_party\tinygizmo\tiny-gizmo.cpp:4:0:
    D:\game\third_party\tinygizmo\tiny-gizmo.hpp:417:118: note:   mismatched types 'std::basic_string_view<_CharT, _Traits>' and 'char'
     template<class T, int N> std::ostream & operator << (std::ostream & a, const minalg::mat<T, 4, N> & b) { return a << '\n' << b.row(0) << '\n' << b.row(1) << '\n' << b.row(2) << '\n' << b.row(3) << '\n'; }
                                                                                                                          ^~~~
    mingw32-make[2]: *** [third_party/CMakeFiles/tinygizmo.dir/tinygizmo/tiny-gizmo.cpp.obj] Error 1
    mingw32-make[2]: Target 'third_party/CMakeFiles/tinygizmo.dir/build' not remade because of errors.
    mingw32-make[1]: *** [third_party/CMakeFiles/tinygizmo.dir/all] Error 2
    mingw32-make[1]: Target 'all' not remade because of errors.
    mingw32-make: *** [all] Error 2
    mingw32-make: Target 'default_target' not remade because of errors.
    Traceback (most recent call last):
      File "scripts/python/build.py", line 45, in <module>
      File "C:\Users\onqtam\AppData\Local\Programs\Python\Python36-32\lib\subprocess.py", line 291, in check_call
        raise CalledProcessError(retcode, cmd)
    subprocess.CalledProcessError: Command '['mingw32-make', '--keep-going', '-j8']' returned non-zero exit status 2.
    Traceback (most recent call last):
      File "./r", line 43, in <module>
        subprocess.check_call(['python', 'scripts/python/build.py', '-b', args.b, '-c', args.c])
      File "C:\Users\onqtam\AppData\Local\Programs\Python\Python36-32\lib\subprocess.py", line 291, in check_call
        raise CalledProcessError(retcode, cmd)
    subprocess.CalledProcessError: Command '['python', 'scripts/python/build.py', '-b', 'gcc', '-c', 'release']' returned non-zero exit status 1.
    
    opened by onqtam 1
Owner
Dimitri Diakopoulos
Graphics, Engines, AR/VR
Dimitri Diakopoulos
A scripting language created mainly for game engines

HCode Hammurabi's Code A scripting language created for the use in games and game engines. Currently supported features and roadmap Structs Functions

null 4 Oct 11, 2020
Animation compression is a fundamental aspect of modern video game engines

Animation compression is a fundamental aspect of modern video game engines. Not only is it important to keep the memory footprint down but it is also critical to keep the animation clip sampling performance fast.

Nicholas Frechette 957 Jun 23, 2022
The name is self explanatory.

Friday Night Funkin' - Psych Engine Engine originally used on Mind Games Mod, intended to be a fix for the vanilla version's many issues while keeping

maky 12 Feb 14, 2022
Image decoding for many popular formats for Simple Directmedia Layer.

SDL_image 2.0 The latest version of this library is available from: http://www.libsdl.org/projects/SDL_image/ This is a simple library to load image

Simple Directmedia Layer 134 Jun 21, 2022
Improved version of the X-Ray Engine, the game engine used in the world-famous S.T.A.L.K.E.R. game series by GSC Game World.

OpenXRay OpenXRay is an improved version of the X-Ray Engine, the game engine used in the world-famous S.T.A.L.K.E.R. game series by GSC Game World. S

null 2k Jun 29, 2022
Stealthy way to hijack the existing game process handle within the game launcher (currently supports Steam and Battle.net). Achieve external game process read/write with minimum footprint.

Launcher Abuser Stealthy way to hijack the existing game process handle within the game launcher (currently supports Steam and Battle.net). Achieve ex

Ricardo Nacif 75 Jun 29, 2022
Game Boy, Game Boy Color, and Game Boy Advanced Emulator

SkyEmu SkyEmu is low level cycle accurate GameBoy, GameBoy Color and Game Boy Advance emulator that I have been developing in my spare time. Its prima

Sky 67 Jun 27, 2022
A lightweight game engine written in modern C++

Halley Game Engine A lightweight game engine written in C++17. It has been used to ship Wargroove, a turn-based strategy game, on Windows, Mac (experi

Rodrigo Braz Monteiro 3.1k Jul 1, 2022
Skynet is a lightweight online game framework

Skynet is a lightweight online game framework which can be used in many other fields.

云风 11.3k Jun 27, 2022
A Tiny 2D OpenGL based C++ Game Engine that is fast, lightweight and comes with a level editor.

A Tiny 2D OpenGL based C++ Game Engine that is fast, lightweight and comes with a level editor.

Samuel Rasquinha 47 Apr 12, 2022
A cycle-accurate Game Boy and Game Boy Color Emulator, with rewind feature.

Azayaka is a free and open-source Game Boy and Game Boy Color emulator written in C++. Features Cycle-Accurate emulation. Console based Debugg

Zach Collins 14 Dec 16, 2021
The Game Boy ROM of the Game Boy bitcoin miner!

game-boy-bitcoin-miner The Game Boy ROM of the Game Boy bitcoin miner! To build this, currently this patch needs to be applied to GBDK: https://gist.g

Ghidra Ninja 78 May 29, 2022
CLUSEK-RT is a complex game engine written in C++ and the successor of the CLUSEK game engine

CLUSEK-RT is a complex game engine written in C++ and the successor of the CLUSEK game engine. This engine has been designed with a cross-platform design in mind. Thanks to Vulkan API it delivers a next-gen experience with ray tracing to both Linux and Windows platforms

Jakub Biliński 27 Jun 12, 2022
Ground Engine is an easy to use Game Engine for 3D Game Development written in C++

Ground Engine is an easy to use Game Engine Framework for 3D Game Development written in C++. It's currently under development and its creation will b

 PardCode 51 Jun 10, 2022
Minetest is an open source voxel game engine with easy modding and game creation

Minetest is an open source voxel game engine with easy modding and game creation

Minetest 7.3k Jul 3, 2022
A game made for the Game (Engineless) Jam using Raylib

Fastest Pizza Delivery A fun little 3D game made for the Game (Engineless) Jam. It is still is development but the basic gameplay is something l

Ryuzaki 2 Apr 3, 2022
SameBoy DX is a Qt-based interface of SameBoy, a free, highly accurate Game Boy and Game Boy Color emulator.

SameBoy DX SameBoy DX is a Qt-based interface of SameBoy, a free, highly accurate Game Boy and Game Boy Color emulator. Build requirements: CMake Pyth

Snowy 8 Jun 4, 2022
To recreate the board game Scotland yard and enable a single player to play the game by letting one of the roles being played by the computer based on written algorithm

Scotland Yard GAME OF SCOTLAND YARD This is a custom version of the classic board game, Scotland Yard .The game uses the London map used in the origin

Brshank 2 Nov 11, 2021
Ncurses based omok game, execute omok game in your terminal

omok_game execute omok game in your terminal Omok game played by two people. 한국어 버전(korean version)

SunjungAn 2 Dec 6, 2021