C
Bibliothèque mathématique 2D|3D hautement optimisée, également connue sous le nom d'OpenGL Mathematics (glm) pour `C` . cglm fournit de nombreux utilitaires pour aider les opérations mathématiques à être rapides et rapides à écrire. Il est convivial pour la communauté, n'hésitez pas à signaler tout problème ou bug que vous avez rencontré.
Presque toutes les fonctions (versions en ligne) et paramètres sont documentés dans les en-têtes correspondants.
Documentation complète : http://cglm.readthedocs.io
glm_vec_dup -> glm_vec3_copy
CGLM_FORCE_DEPTH_ZERO_TO_ONE
et CGLM_FORCE_LEFT_HANDED
sont fournis pour contrôler l'espace de clip. Vous devriez pouvoir utiliser cglm avec Vulkan, DirectX et Metal maintenant... voir https://cglm.readthedocs.io/en/latest/opt.html#clipspace-option-s Si vous ne connaissez pas encore la bibliothèque GLM originale, vous pouvez également consulter : https://github.com/g-truc/glm
vec4
et mat4
doivent être alignées. (Il y aura des versions non alignées plus tard) cglm
n'alloue aucune mémoire sur le tas. Il ne fournit donc aucun allocateur. Vous devez également allouer de la mémoire pour les paramètres out si vous transmettez le pointeur de l'emplacement mémoire. N'oubliez pas que vec4 (également quat/ versor ) et mat4 doivent être alignés (16 octets), car cglm utilise les instructions SIMD pour optimiser la plupart des opérations si elles sont disponibles.
cglm prend en charge à la fois l'API ARRAY et l'API STRUCT , vous pouvez donc renvoyer des structures si vous utilisez struct api ( glms_
).
Comme certaines autres bibliothèques graphiques (en particulier OpenGL), cette bibliothèque utilise la disposition Column-Major pour conserver les matrices en mémoire. À l'avenir, la bibliothèque pourra prendre en charge une option permettant d'utiliser la disposition en ligne principale. ACTUELLEMENT, si vous avez besoin d'une disposition en ligne principale, vous devrez la transposer. |
Vous avez deux options pour appeler une fonction/opération : un appel en ligne ou un appel à la bibliothèque (lien). Presque toutes les fonctions sont marquées en ligne (always_inline), donc le compilateur sera probablement en ligne. Pour appeler des versions précompilées, utilisez simplement glmc_
(c signifie 'call') au lieu de glm_
.
#include /* for inline */
#include /* for library call (this also includes cglm.h) */
mat4 rot , trans , rt ;
/* ... */
glm_mul ( trans , rot , rt ); /* inline */
glmc_mul ( trans , rot , rt ); /* call from library */
La plupart des fonctions mathématiques sont optimisées manuellement avec SSE2 si disponible, sinon ? Ne vous inquiétez pas, il existe des versions non-sse de toutes les opérations
Vous pouvez transmettre des matrices et des vecteurs sous forme de tableau aux fonctions plutôt que d'obtenir une adresse.
mat4 m = {
1 , 0 , 0 , 0 ,
0 , 1 , 0 , 0 ,
0 , 0 , 1 , 0 ,
0 , 0 , 0 , 1
};
glm_translate ( m , ( vec3 ){ 1.0f , 0.0f , 0.0f });
La bibliothèque contient des fonctions mat4 mul et inverses à usage général, ainsi que des formes spéciales (optimisées) de ces fonctions pour les matrices de transformations affines. Si vous souhaitez multiplier deux matrices de transformation affine vous pouvez utiliser glm_mul au lieu de glm_mat4_mul et glm_inv_tr (ROT + TR) à la place de glm_mat4_inv
/* multiplication */
mat4 modelMat ;
glm_mul ( T , R , modelMat );
/* othonormal rot + tr matrix inverse (rigid-body) */
glm_inv_tr ( modelMat );
L'API struct fonctionne comme suit, notez le suffixe s
sur les types, le préfixe glms_
sur les fonctions et le préfixe GLMS_
sur les constantes :
#include
mat4s mat = GLMS_MAT4_IDENTITY_INIT ;
mat4s inv = glms_mat4_inv ( mat );
Les fonctions Struct prennent généralement leurs paramètres comme valeurs et renvoient leurs résultats, plutôt que de prendre des pointeurs et d'écrire dans les paramètres. Cela signifie que vos paramètres peuvent généralement être const
, si cela vous intéresse.
Les types utilisés sont en fait des unions qui permettent d'accéder aux mêmes données de plusieurs manières. L’une de ces voies fait appel à des structures anonymes, disponibles depuis C11. MSVC le prend également en charge pour les versions C antérieures et GCC/Clang le fait si vous activez -fms-extensions
. Pour activer explicitement ces structures anonymes, #define CGLM_USE_ANONYMOUS_STRUCT
à 1
, pour les désactiver, à 0
. Pour des raisons de compatibilité ascendante, vous pouvez également #define CGLM_NO_ANONYMOUS_STRUCT
(la valeur n'est pas pertinente) pour les désactiver. Si vous ne le spécifiez pas explicitement, cglm fera une meilleure estimation en fonction de votre compilateur et de la version C que vous utilisez.
$ mkdir build
$ cd build
$ cmake .. # [Optional] -DCGLM_SHARED=ON
$ make
$ sudo make install # [Optional]
option (CGLM_SHARED "Shared build" ON )
option (CGLM_STATIC "Static build" OFF )
option (CGLM_USE_C99 "" OFF ) # C11
option (CGLM_USE_TEST "Enable Tests" OFF ) # for make check - make test
Cela ne nécessite aucune construction ou installation de cglm.
cmake_minimum_required ( VERSION 3.8.2)
project (Name >)
add_executable ( ${PROJECT_NAME} src/main.c)
target_link_libraries ( ${LIBRARY_NAME} PRIVATE
cglm_headers)
add_subdirectory (external/cglm/ EXCLUDE_FROM_ALL )
cmake_minimum_required ( VERSION 3.8.2)
project (Name >)
add_executable ( ${PROJECT_NAME} src/main.c)
target_link_libraries ( ${LIBRARY_NAME} PRIVATE
cglm)
add_subdirectory (external/cglm/)
# or you can use find_package to configure cglm
Étant donné que des fonctions mathématiques telles que sinf
sont utilisées, elles ne peuvent pas être ciblées sur wasm32-unknown-unknown
, l'un des wasi-sdk ou emscripten doit être utilisé.
Il convient de noter que la construction partagée n'est pas encore prise en charge pour WebAssembly.
Pour la prise en charge de simd128, ajoutez -msimd128
à CMAKE_C_FLAGS
, en ligne de commande -DCMAKE_C_FLAGS="-msimd128"
.
Pour les tests, l'option cmake CGLM_USE_TEST
fonctionnerait toujours, vous aurez besoin d'un runtime wasi pour exécuter les tests, consultez notre fichier de configuration ci pour un exemple détaillé.
$ cmake ..
-DCMAKE_TOOLCHAIN_FILE=/path/to/wasi-sdk-19.0/share/cmake/wasi-sdk.cmake
-DWASI_SDK_PREFIX=/path/to/wasi-sdk-19.0
Où /path/to/wasi-sdk-19.0/
est le chemin d'accès au SDK Wasi extrait.
Dans ce cas, il créerait par défaut une version statique.
$ emcmake cmake ..
-DCMAKE_EXE_LINKER_FLAGS= " -s STANDALONE_WASM "
-DCGLM_STATIC=ON
L' emcmake
ici est le wrapper cmake pour Emscripten à partir d'emsdk installé.
$ meson build # [Optional] --default-library=static
$ cd build
$ ninja
$ sudo ninja install # [Optional]
c_std = c11
buildtype = release
default_library = shared
build_tests = true # to run tests: ninja test
# Clone cglm or create a cglm.wrap under /subprojects
project ( ' name ' , ' c ' )
cglm_dep = dependency ( ' cglm ' , fallback : ' cglm ' , ' cglm_dep ' )
executable ( ' exe ' , ' src/main.c ' , dependencies : cglm_dep)
Actuellement, seules les options de construction par défaut sont prises en charge. Ajoutez une dépendance cglm à votre projet :
...
Package (
...
dependencies : [
...
. package ( url : " https://github.com/recp/cglm " , . branch ( " master " ) ) ,
]
...
)
Ajoutez maintenant cgml comme dépendance à votre cible. Les choix de produits sont :
...
. target (
...
dependencies : [
...
. product ( name : " cglm " , package : " cglm " ) ,
]
...
)
...
$ sh autogen.sh
$ ./configure
$ make
$ make check # [Optional]
$ [sudo] make install # [Optional]
Cela installera également les fichiers pkg-config afin que vous puissiez utiliser pkg-config --cflags cglm
et pkg-config --libs cglm
pour récupérer les indicateurs du compilateur et de l'éditeur de liens.
Les fichiers seront installés dans le préfixe donné (généralement /usr/local
par défaut sous Linux), mais votre pkg-config n'est peut-être pas configuré pour réellement y vérifier. Vous pouvez déterminer où il cherche en exécutant pkg-config --variable pc_path pkg-config
et en modifiant le chemin sur lequel les fichiers sont installés via ./configure --with-pkgconfigdir=/your/path
. Vous pouvez également ajouter le chemin du préfixe à votre variable d'environnement PKG_CONFIG_PATH
.
Le fichier de construction et les fichiers de projet liés à Windows se trouvent dans le dossier win
, assurez-vous que vous êtes dans le dossier cglm/win
. L'analyse du code est activée, la création peut donc prendre un certain temps.
$ cd win
$ . build.bat
si msbuild
ne fonctionne pas (à cause de VS multi-versions), essayez de construire avec devenv
:
$ devenv cglm.sln / Build Release
Vous pouvez voir le projet de test dans le même fichier de solution Visual Studio. Il suffit d'exécuter ce projet pour exécuter des tests.
Vous devez d'abord installer Sphinx : http://www.sphinx-doc.org/en/master/usage/installation.html puis :
$ cd docs
$ sphinx-build source build
il compilera les documents dans le dossier de construction, vous pouvez exécuter index.html dans cette fonction.
Si vous souhaitez utiliser les versions en ligne des fonctions, incluez l'en-tête principal
#include
l'en-tête inclura tous les en-têtes. Appelez ensuite la fonction souhaitée, par exemple faire pivoter le vecteur par axe :
glm_vec3_rotate ( v1 , glm_rad ( 45 ), ( vec3 ){ 1.0f , 0.0f , 0.0f });
certaines fonctions sont surchargées :) par exemple, vous pouvez normaliser le vecteur :
glm_vec3_normalize ( vec );
cela normalisera vec et stockera le vecteur normalisé dans vec
mais si vous stockez le vecteur normalisé dans un autre vecteur, procédez comme suit :
glm_vec3_normalize_to ( vec , result );
comme cette fonction, vous pouvez voir _to
postfix, ces fonctions stockent les résultats dans d'autres variables et enregistrent la mémoire temporaire
pour appeler les versions précompilées, incluez l'en-tête avec le suffixe c
, c signifie appel. Les versions précompilées ne sont que des wrappers.
#include
cet en-tête inclura tous les en-têtes avec le suffixe c. Vous devez appeler des fonctions avec c posfix :
glmc_vec3_normalize ( vec );
L'utilisation et les paramètres des fonctions sont documentés dans les en-têtes associés. Vous pouvez voir le même paramètre passé deux fois dans certains exemples comme celui-ci :
glm_mat4_mul ( m1 , m2 , m1 );
/* or */
glm_mat4_mul ( m1 , m1 , m1 );
les deux premiers paramètres sont [in] et le dernier est le paramètre [out] . Après avoir multiplié m1 et m2 , le résultat est stocké dans m1 . C'est pourquoi nous envoyons m1 deux fois. Vous pouvez stocker le résultat dans une matrice différente, ce n'est qu'un exemple.
mat4 proj , view , model , mvp ;
/* init proj, view and model ... */
glm_mat4_mul ( proj , view , viewProj );
glm_mat4_mul ( viewProj , model , mvp );
mat4 proj , view , model , mvp ;
/* init proj, view and model ... */
glm_mat4_mulN (( mat4 * []){ & proj , & view , & model }, 3 , mvp );
mat4 est un tableau de vec4 et vec4 est un tableau de flotteurs. Les fonctions glUniformMatrix4fv
acceptent float*
comme value
(dernier paramètre), vous pouvez donc convertir mat4 en float* ou vous pouvez passer la première colonne de la matrice comme début de la mémoire de la matrice :
Option 1 : Envoyer la première colonne
glUniformMatrix4fv ( location , 1 , GL_FALSE , matrix [ 0 ]);
/* array of matrices */
glUniformMatrix4fv ( location , 1 , GL_FALSE , matrix [ 0 ][ 0 ]);
Option 2 : convertir la matrice en type pointeur (également valable pour les tableaux multidimensionnels)
glUniformMatrix4fv ( location , 1 , GL_FALSE , ( float * ) matrix );
Vous pouvez transmettre des matrices de la même manière à d'autres API, par exemple Vulkan, DX...
FAIRE:
glm_umat4_mul
) Ce projet existe grâce à toutes les personnes qui y contribuent. [Contribuer].
Merci à tous nos contributeurs ! [Devenez contributeur]
Soutenez ce projet en devenant sponsor. Votre logo apparaîtra ici avec un lien vers votre site Web. [Devenez parrain]
MIT. vérifiez le fichier LICENSE