Inicio>Relacionado con la programación>código fuente c#
Descargar
cglm

? Matemáticas OpenGL (glm) para C





Biblioteca matemática 2D|3D altamente optimizada, también conocida como OpenGL Mathematics (glm) para `C` . cglm proporciona muchas utilidades para ayudar a que las operaciones matemáticas sean rápidas y rápidas de escribir. Es amigable con la comunidad, no dude en informar cualquier problema o error que haya enfrentado.

Documentación

Casi todas las funciones (versiones en línea) y parámetros están documentados dentro de los encabezados correspondientes.
Documentación completa: http://cglm.readthedocs.io

? Nota para versiones anteriores:

  • _dup (duplicado) se cambia a _copiar. Por ejemplo glm_vec_dup -> glm_vec3_copy
  • Las funciones relacionadas con OpenGL se eliminan para que esta plataforma lib/tercero sea independiente
  • asegúrese de tener la última versión y no dude en informar errores y problemas
  • [corrección de error] Los ángulos de Euler se implementaron en orden inverso (extrínsecos). Se corrigió, ahora son intrínsecos. Asegúrate de tener la última versión.
  • [cambio importante] al iniciar v0.4.0, los cuaterniones se almacenan como [x, y, z, w], era [w, x, y, z] en v0.3.5 y versiones anteriores
  • [cambio de nombre de API] al iniciar v0.4.5, las funciones glm_simd cambian de nombre a glmm_
  • [nueva opción] al iniciar v0.4.5, puede deshabilitar el requisito de alineación, verifique las opciones en los documentos.
  • [cambio importante] al iniciar v0.5.0, las funciones vec3 usan glm_vec3_ espacio de nombres, era glm_vec_ hasta v0.5.0
  • [cambio importante] al iniciar v0.5.1, la alineación incorporada se elimina de los tipos vec3 y mat3
  • [cambio importante] al iniciar v0.7.3, las funciones de impresión en línea se desactivan en el modo de lanzamiento/producción para eliminar los costos de impresión (consulte las opciones en la documentación). La producción de impresión también mejoró. Puede desactivar los colores si lo necesita (ver documentación)
  • [cambio importante] al iniciar v0.8.3, cglm admite configuraciones de clipspace alternativas, por ejemplo, zurdo, cero a uno (_zo)... CGLM_FORCE_DEPTH_ZERO_TO_ONE y CGLM_FORCE_LEFT_HANDED se proporcionan para controlar el clipspace. Debería poder usar cglm con Vulkan, DirectX y Metal ahora... consulte https://cglm.readthedocs.io/en/latest/opt.html#clipspace-option-s

? Nota para desarrolladores de C++:

Si aún no conoce la biblioteca GLM original, también puede consultar: https://github.com/g-truc/glm

? Nota para los recién llegados (Importante):

  • Las variables vec4 y mat4 deben estar alineadas. (Habrá versiones no alineadas más adelante)
  • Los parámetros in y [in, out] deben inicializarse (por favor). Pero los parámetros [out] no, inicializar el parámetro out también es redundante
  • Todas las funciones están en línea. Si no desea utilizar versiones precompiladas con el prefijo glmc_, puede ignorar el proceso de compilación. Solo incluye encabezados.
  • Si su depurador lo lleva a los encabezados cglm, asegúrese de no intentar copiar vec4 a vec3 o problemas de alineación...
  • ¡Bienvenido!

? Nota para desarrolladores experimentados:

  • Desde que estoy probando esta biblioteca en mis proyectos, a veces ocurren errores; Encontrar esos errores y realizar mejoras sería más fácil con varios desarrolladores/colaboradores y sus proyectos o conocimientos. Considere realizar algunas pruebas si sospecha que algo anda mal y cualquier comentario, contribución e informe de errores siempre será bienvenido.

? ¿Asignaciones?

cglm no asigna memoria en el montón. Por lo que no proporciona ningún asignador. También debe asignar memoria para los parámetros externos si pasa el puntero de la ubicación de la memoria. No olvide que vec4 (también quat/ versor ) y mat4 deben estar alineados (16 bytes), porque cglm usa instrucciones SIMD para optimizar la mayoría de las operaciones, si están disponibles.

? ¿Vector o matriz de retorno...?

cglm admite tanto ARRAY API como STRUCT API , por lo que puede devolver estructuras si utiliza struct api ( glms_ ).

Al igual que otras bibliotecas de gráficos (especialmente OpenGL), esta biblioteca utiliza un diseño de columna principal para mantener las matrices en la memoria.
En el futuro, la biblioteca puede admitir una opción para usar el diseño de fila principal; ACTUALMENTE, si necesita un diseño de fila principal, deberá transponerlo.

Características

  • Optimizaciones escalares y simd (sse, avx, neon...)
  • opción para usar diferentes espacios de clip, por ejemplo, zurdos, cero a uno... (actualmente, el valor predeterminado es negativo uno para diestros)
  • array api y struct api, puede usar matrices o estructuras.
  • operaciones matriciales de propósito general (mat4, mat3)
  • multiplicación de matrices en cadena (solo cuadrados)
  • Operaciones vectoriales de propósito general (cruzar, punto, rotar, proyectar, ángulo...)
  • transformaciones afines
  • descomposición de la matriz (rotación de extracto, factor de escala)
  • matrices de transformación afín optimizadas (mul, inversa de cuerpo rígido)
  • cámara (mirar)
  • proyecciones (orto, perspectiva)
  • cuaterniones
  • ángulos de Euler / guiñada-inclinación-giro a matriz
  • extraer ángulos de euler
  • llamada de función en línea o precompilada
  • frustum (extraer planos de vista frustum, esquinas...)
  • cuadro delimitador (AABB en Frustum (eliminación), recortar, fusionar...)
  • esfera delimitadora
  • proyecto, desproyecto
  • funciones de facilitación
  • curvas
  • ayudantes de interpolación de curvas (S M C, deCasteljau...)
  • ayudantes para convertir tipos cglm a la biblioteca simd de Apple para pasar tipos cglm a Metal GL sin empaquetarlos en ambos lados
  • ayudantes de intersección de rayos
  • y otros...

Tiene dos opciones para llamar a una función/operación: en línea o llamada a biblioteca (enlace). Casi todas las funciones están marcadas en línea (always_inline), por lo que el compilador probablemente lo hará en línea. Para llamar a versiones precompiladas, simplemente use glmc_ (c significa 'llamar') en lugar 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 mayoría de las funciones matemáticas se optimizan manualmente con SSE2 si está disponible, ¿si no? No se preocupe, existen versiones no SSE de todas las operaciones.

Puede pasar matrices y vectores como matriz a funciones en lugar de obtener la dirección. 

  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 biblioteca contiene funciones mat4 mul e inversas de uso general, y también contiene algunas formas especiales (optimizadas) de estas funciones para matrices de transformaciones afines. Si desea multiplicar dos matrices de transformación afines, puede usar glm_mul en lugar de glm_mat4_mul y glm_inv_tr (ROT + TR) en lugar de glm_mat4_inv. 

 /* multiplication */
mat4 modelMat ;
glm_mul ( T , R , modelMat );

/* othonormal rot + tr matrix inverse (rigid-body) */
glm_inv_tr ( modelMat );

API de estructura

La API de estructura funciona de la siguiente manera: tenga en cuenta el sufijo s en los tipos, el prefijo glms_ en funciones y el prefijo GLMS_ en constantes: 

 #include 

mat4s mat = GLMS_MAT4_IDENTITY_INIT ;
mat4s inv = glms_mat4_inv ( mat );

Las funciones de estructura generalmente toman sus parámetros como valores y devuelven sus resultados, en lugar de tomar punteros y escribir parámetros. Eso significa que tus parámetros generalmente pueden ser const , si te gusta eso.

Los tipos utilizados son en realidad uniones que permiten acceder a los mismos datos de múltiples formas. Una de esas formas implica estructuras anónimas, disponibles desde C11. MSVC también lo admite para versiones anteriores de C listas para usar y GCC/Clang lo hace si habilita -fms-extensions . Para habilitar explícitamente estas estructuras anónimas, #define CGLM_USE_ANONYMOUS_STRUCT en 1 , para deshabilitarlas, en 0 . Para compatibilidad con versiones anteriores, también puede #define CGLM_NO_ANONYMOUS_STRUCT (el valor es irrelevante) para deshabilitarlos. Si no lo especifica explícitamente, cglm hará una mejor estimación según su compilador y la versión C que esté utilizando.

? Construir

CMake (todas las plataformas) 

$ mkdir build
$ cd build
$ cmake .. # [Optional] -DCGLM_SHARED=ON
$ make
$ sudo make install # [Optional]
Opciones de cmake con valores predeterminados: 
 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

Úselo como biblioteca de solo encabezado con su proyecto CMake

Esto no requiere construcción ni instalación de cglm.

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

Úselo con su proyecto CMake

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

Utilice CMake para compilar para WebAssembly

Dado que se utilizan funciones matemáticas como sinf , esto no puede apuntar a wasm32-unknown-unknown , se debe usar uno de wasi-sdk o emscripten.

Debe tener en cuenta que la compilación compartida aún no es compatible con WebAssembly.

Para compatibilidad con simd128, agregue -msimd128 a CMAKE_C_FLAGS , en la línea de comando -DCMAKE_C_FLAGS="-msimd128" .

Para las pruebas, la opción cmake CGLM_USE_TEST aún funcionaría; necesitará un tiempo de ejecución wasi para ejecutar las pruebas; consulte nuestro archivo de configuración ci para ver un ejemplo detallado.

Utilice CMake y WASI SDK para compilar para WebAssembly 
$ cmake .. 
  -DCMAKE_TOOLCHAIN_FILE=/path/to/wasi-sdk-19.0/share/cmake/wasi-sdk.cmake 
  -DWASI_SDK_PREFIX=/path/to/wasi-sdk-19.0

Donde /path/to/wasi-sdk-19.0/ es la ruta al SDK de wasi extraído.

En este caso, por defecto realizaría una compilación estática.

Utilice CMake y Emscripten SDK para compilar para WebAssembly 
$ emcmake cmake .. 
  -DCMAKE_EXE_LINKER_FLAGS= " -s STANDALONE_WASM " 
  -DCGLM_STATIC=ON

El emcmake aquí es el contenedor cmake para Emscripten desde el emsdk instalado.

Mesón (Todas las plataformas) 

$ meson build # [Optional] --default-library=static
$ cd build
$ ninja
$ sudo ninja install # [Optional]
Opciones de mesón con valores predeterminados: 
c_std = c11
buildtype = release
default_library = shared
build_tests = true # to run tests: ninja test

Úselo con su proyecto Meson

  • Ejemplo: 
 # 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)

Swift (Administrador de paquetes Swift)

Actualmente, solo se admiten las opciones de compilación predeterminadas. Agregue la dependencia cglm a su proyecto: 

 ...
Package ( 
  ...
  dependencies : [
    ...
    . package ( url : " https://github.com/recp/cglm " , . branch ( " master " ) ) ,
  ]
  ...
)

Ahora agregue cgml como una dependencia de su objetivo. Las opciones de productos son:

  • cglm para la versión incorporada de la biblioteca que solo se puede vincular estáticamente
  • cglmc para una versión compilada de la biblioteca sin limitación de enlaces 
 ...
. target (
  ...
  dependencies : [
    ...
    . product ( name : " cglm " , package : " cglm " ) ,
  ]
  ...
)
...

Unix (autoherramientas) 

$ sh autogen.sh
$ ./configure
$ make
$ make check # [Optional]
$ [sudo] make install # [Optional]

Esto también instalará los archivos pkg-config para que pueda usar pkg-config --cflags cglm y pkg-config --libs cglm para recuperar los indicadores del compilador y del enlazador.

Los archivos se instalarán en el prefijo dado (generalmente /usr/local de forma predeterminada en Linux), pero es posible que su pkg-config no esté configurado para verificar allí. Puede averiguar dónde está mirando ejecutando pkg-config --variable pc_path pkg-config y cambiando la ruta en la que están instalados los archivos a través de ./configure --with-pkgconfigdir=/your/path . Alternativamente, puede agregar la ruta del prefijo a su variable de entorno PKG_CONFIG_PATH .

Windows (MSBuild)

Los archivos de compilación y de proyecto relacionados con Windows se encuentran en la carpeta win , asegúrese de estar dentro de la carpeta cglm/win . El análisis de código está habilitado, por lo que la compilación puede tardar un poco. 

$ cd win
$ . build.bat

Si msbuild no funciona (debido a la versión múltiple de VS), intente compilar con devenv : 

$ devenv cglm.sln / Build Release

Ejecución de pruebas en Windows

Puede ver el proyecto de prueba en el mismo archivo de solución de Visual Studio. Basta con ejecutar ese proyecto para ejecutar pruebas.

Documentos de construcción

Primero necesitas instalar Sphinx: http://www.sphinx-doc.org/en/master/usage/installation.html y luego: 

$ cd docs
$ sphinx-build source build

compilará documentos en la carpeta de compilación, puede ejecutar index.html dentro de esa función.

como usar

Si desea utilizar las versiones en línea de funciones, incluya el encabezado principal 

 #include

el encabezado incluirá todos los encabezados. Luego llame a la función que desee, por ejemplo, rotar vector por eje: 

 glm_vec3_rotate ( v1 , glm_rad ( 45 ), ( vec3 ){ 1.0f , 0.0f , 0.0f });

algunas funciones están sobrecargadas :) por ejemplo, puedes normalizar el vector: 

 glm_vec3_normalize ( vec );

esto normalizará vec y almacenará el vector normalizado en vec pero si almacenará el vector normalizado en otro vector, haga esto: 

 glm_vec3_normalize_to ( vec , result );

Al igual que esta función, es posible que vea _to postfix, esta función almacena los resultados en otras variables y ahorra memoria temporal.

para llamar a versiones precompiladas, incluya el encabezado con el sufijo c , c significa llamar. Las versiones precompiladas son sólo envoltorios. 

 #include

este encabezado incluirá todos los encabezados con sufijo c. Necesitas llamar funciones con c posfix: 

 glmc_vec3_normalize ( vec );

El uso de funciones y los parámetros están documentados dentro de encabezados relacionados. Es posible que veas el mismo parámetro pasado dos veces en algunos ejemplos como este: 

 glm_mat4_mul ( m1 , m2 , m1 );

/* or */
glm_mat4_mul ( m1 , m1 , m1 );

los dos primeros parámetros son [in] y el último es el parámetro [out] . Después de multiplicar m1 y m2 , el resultado se almacena en m1 . Por eso enviamos m1 dos veces. Puedes almacenar el resultado en una matriz diferente, esto es sólo un ejemplo.

Ejemplo: cálculo de la matriz MVP

Opción 1 

 mat4 proj , view , model , mvp ;

/* init proj, view and model ... */

glm_mat4_mul ( proj , view , viewProj );
glm_mat4_mul ( viewProj , model , mvp );

Opción 2 

 mat4 proj , view , model , mvp ;

/* init proj, view and model ... */

glm_mat4_mulN (( mat4 * []){ & proj , & view , & model }, 3 , mvp );

Cómo enviar matriz a OpenGL

mat4 es una matriz de vec4 y vec4 es una matriz de flotadores. Las funciones glUniformMatrix4fv aceptan float* como value (último parámetro), por lo que puede convertir mat4 a float* o puede pasar la primera columna de la matriz como comienzo de la memoria de la matriz:

Opción 1: enviar la primera columna 

 glUniformMatrix4fv ( location , 1 , GL_FALSE , matrix [ 0 ]);

/* array of matrices */
glUniformMatrix4fv ( location , 1 , GL_FALSE , matrix [ 0 ][ 0 ]);

Opción 2: convertir matriz a tipo de puntero (también válido para matrices multidimensionales) 

 glUniformMatrix4fv ( location , 1 , GL_FALSE , ( float * ) matrix );

Puede pasar matrices de la misma manera a otras API, por ejemplo, Vulkan, DX...

Notas

  • Esta biblioteca no admite tipo doble... todavía
  • Si los encabezados no funcionan correctamente con su compilador, IDE, abra un problema, porque estoy usando GCC y clang para probarlo, tal vez a veces MSVC.

HACER:

  • Pruebas unitarias (en progreso)
  • Pruebas unitarias para comparar resultados de cglm con glm
  • Agregar información de versión
  • Operaciones no alineadas (por ejemplo, glm_umat4_mul )
  • Documentación adicional
  • Arco de neón ARM

Colaboradores

Este proyecto existe gracias a todas las personas que contribuyen. [Contribuir].

Patrocinadores

¡Gracias a todos nuestros patrocinadores! [Conviértete en patrocinador]

Patrocinadores

Apoya este proyecto convirtiéndote en patrocinador. Su logotipo aparecerá aquí con un enlace a su sitio web. [Conviértete en patrocinador]

Licencia

MIT. verifique el archivo de LICENCIA

Expandir
Información adicional
Aplicaciones relacionadas
Recomendado para ti
Información relacionada Todo