相关文章推荐
魁梧的单车  ·  Google JS Test ...·  4 月前    · 
面冷心慈的苦咖啡  ·  一口气看完韩国奇幻喜剧《虽然30但仍17》女 ...·  5 月前    · 
兴奋的冲锋衣  ·  大家觉得雷神笔记本怎么样，值得购买么？ - 知乎·  1 年前    · 
强悍的松鼠  ·  老前辈重出江湖？卓伟带大瓜回归，传奇娱记的辉 ...·  1 年前    · 
不羁的硬盘  ·  “高速”英语怎么说？_高速公路_The_Toll·  1 年前    · 
小百科  ›  对glm库源码的理解（二）
网站源码 const opengl
咆哮的墨镜
1 年前

GLM 库主要用于代数运算，与 Eigen、Blas 库类似。但由于 GLM 库主要应用场景是坐标变换和摄像机，因此维数受限，功能弱于 Eigen、Blas。glm 的主要优势在于 GLM 提供了使用与 GLSL（OpenGL着色语言）相同的命名约定和功能设计和实现的类和函数，因此任何了解 GLSL 的人都可以在 C++ 中使用 GLM。根据官方文档介绍， GLM 全称是 OpenGL Mathematics，是一个基于 OpenGL 着色语言的用于图形软件的纯 C++的数学库。但是就算脱离 OpenGL 环境，也可以确保能够正常使用。这篇文章首先主要详解 GLM 库的两个数据结构 vec 和 mat。

vec 表示向量 ， glm 库中有四个头文件定义了 vec ，分别是 type_vec1.hpp , type_vec2.hpp , type_vec3.hpp 和 type_vec4.hpp。分别表示一到四维的向量。

首先是一维向量的定义。 注意到这段关于 vec1 的构造函数的声明代码： 

template<typename T,qualifier Q>
struct vec<1,T,Q>{
                // -- Implicit basic constructors --
		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT;
		template<qualifier P>
		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, T, P> const& v);
                // -- Explicit basic constructors --
                GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
                template<typename U, qualifier P> 
                GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<1, U, P> const& v);

这里发现模板里面有个 qualifier Q,查看 qualifier.hpp 文件可以查看其定义：


enum qualifier
		packed_highp, ///< Typed data is tightly packed in memory and operations are executed with high precision in term of ULPs
		packed_mediump, ///< Typed data is tightly packed in memory  and operations are executed with medium precision in term of ULPs for higher performance
		packed_lowp, ///< Typed data is tightly packed in memory  and operations are executed with low precision in term of ULPs to maximize performance
#		if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
			aligned_highp, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs
			aligned_mediump, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs for higher performance
			aligned_lowp, // ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs to maximize performance
			aligned = aligned_highp, ///< By default aligned qualifier is also high precision
#		endif
		highp = packed_highp, ///< By default highp qualifier is also packed
		mediump = packed_mediump, ///< By default mediump qualifier is also packed
		lowp = packed_lowp, ///< By default lowp qualifier is also packed
		packed = packed_highp, ///< By default packed qualifier is also high precision
#		if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE && defined(GLM_FORCE_DEFAULT_ALIGNED_GENTYPES)
			defaultp = aligned_highp
#		else
			defaultp = highp
#		endif

根据其注释发现是与精度有关，一般使用defaultp就行。


查看构造函数的定义：


template<typename T, qualifier Q>
template<qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<1, T, P> const& v)
	: x(v.x)
// -- Explicit basic constructors --
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(T scalar)
	: x(scalar)
template<typename T, qualifier Q>
template<typename U, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<1, U, P> const& v)
	: x(static_cast<T>(v.x))

那么根据构造函数的声明和定义，一般我们可以按照两种方式初始化，要么直接传入一个标量，要么直接传入入另外一个 vec，但是数据类型也就是 typename 要相同：


vec<1,int,defaultp> a1(1);
vec<1,int,defaultp> a2(a1);

也可以依靠static_cast来进行类型转换：


vec<1,int,defaultp> a1(1);
vec<1,float,defaultp> a2(a1);

接着看 vec 这个类有哪些属性和方法：


struct vec<1,T,Q>{
union {T x, r, s;};
GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 1;}
GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;

还有很多运算符的重载，大家可以去看 type_vec1.hpp 和 type_vec1.inl。这里主要说关于属性的访问，可以看到有一个匿名 union ，可以通过 x,r,s 三个属性去访问。 []的重载定义如下,无论输入任何数字都是返回 x ，这个定义很符合一维向量的特性，比较省事:


template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR T & vec<1, T, Q>::operator[](typename vec<1, T, Q>::length_type)
	return x;
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& vec<1, T, Q>::operator[](typename vec<1, T, Q>::length_type) const
	return x;

可以通过以下形式访问属性：


vec<1,int,defaultp> vec1(2);
cout<<vec1.x<<endl;   //2
cout<<vec1.r<<endl;
cout<<vec1.s<<endl;
cout<<vec1[0]<<endl;
cout<<vec1[10]<<endl;   //2，不会报错！
cout<<vec1.length();  //1,访问vec1的维度，固定返回1

现在铺垫说完了，因为我们一般用的头文件是 glm.hpp ，而不是 vec1.hpp,glm.hpp 用头文件 fwd.hpp 包装了 vec1.hpp。


在 fwd.hpp 中做了如下的声明：


typedef vec<1, float, defaultp>	 vec1;
typedef vec<1, int, defaultp>	ivec1;
typedef vec<1, uint, defaultp>	uvec1;

因此我们一般按照如下使用：


ivec1 c(1);
vec1 d(1.55);
vec1 a(1.2);
ivec1 b(a);
cout << b[1] << endl;  //打印1

底层调用构造函数 vec<1, T, Q>::vec(vec<1, U, P> const& v) 来进行强制类型转换。


再来看四维向量，也就是 type_vec4.hpp 头文件。


分别看构造函数的声明代码( type_vec4.hpp )：


template<typename T, qualifier Q>
struct vec<4, T, Q>
// -- Implicit basic constructors --
GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<4, T, Q> const& v) GLM_DEFAULT;
template<qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<4, T, P> const& v);
// -- Explicit basic constructors --
GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
GLM_FUNC_DECL GLM_CONSTEXPR vec(T x, T y, T z, T w);
// -- Conversion scalar constructors --
template<typename U, qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(vec<1, U, P> const& v);

再来看看 vec4 构造函数的定义：


template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<4, T, Q> const& v)
	: x(v.x), y(v.y), z(v.z), w(v.w)
template<typename T, qualifier Q>
template<qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<4, T, P> const& v)
	: x(v.x), y(v.y), z(v.z), w(v.w)
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(T scalar)
	: x(scalar), y(scalar), z(scalar), w(scalar)
template <typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(T _x, T _y, T _z, T _w)
	: x(_x), y(_y), z(_z), w(_w)
template<typename T, qualifier Q>
template<typename U, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, U, P> const& v)
	: x(static_cast<T>(v.x))
	, y(static_cast<T>(v.x))
	, z(static_cast<T>(v.x))
	, w(static_cast<T>(v.x))

根据以上 vec4 的声明和定义可以按照以下方式构造：


vec<4,int,defaultp> a(10);    //传入一个整型标量
vec<4,int,defaultp> b(10,20,30,40);   //传入四个整型变量
vec<1,int,defaultp> c(1);
vec<4,int,defaultp> d(c);  //传入一个vec<1,U,P>
vec<4,int,defaultp> e(d);

同理 fwd.hpp 也对 vec4 做了相应的包装，只要使用头文件 <glm/glm.hpp> 就可以了。


再来看看 vec4 的属性和方法。


union { T x, r, s; };
union { T y, g, t; };
union { T z, b, p; };
union { T w, a, q; };
/// Return the count of components of the vector
GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;}
GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;

再看 vec4.inl 文件：


template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR T& vec<4, T, Q>::operator[](typename vec<4, T, Q>::length_type i)
	assert(i >= 0 && i < this->length());
	switch(i)
	     default:
	     case 0:
		return x;
	     case 1:
		return y;
	     case 2:
		return z;
	     case 3:
		return w;
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& vec<4, T, Q>::operator[](typename vec<4, T, Q>::length_type i) const
	assert(i >= 0 && i < this->length());
	switch(i)
	      default:
	      case 0:
		return x;
	      case 1:
		return y;
	      case 2:
		return z;
	      case 3:
		return w;

其他更多运算符的重载可以查看头文件。


那么我们可以访问通过 [] 或者 属性访问符访问 xyzw 、rgba 、 stpq。


mat 表示矩阵。关于 mat ，glm 支持行列分别为1到4维。为了一定的广义性， 我们这里分析 type_mat4x3.hpp ，其他的头文件也是以 type_matrxk.hpp(r,k都为1，2，3或者4)。


首先定义了 col_type 、 row_type 、type 、transpose_type 和 value_type 五种数据类型。


template<typename T, qualifier Q>
struct mat<4, 3, T, Q>
	typedef vec<3, T, Q> col_type;
	typedef vec<4, T, Q> row_type;
	typedef mat<4, 3, T, Q> type;
	typedef mat<3, 4, T, Q> transpose_type;
	typedef T value_type;

定义 col_type 表示行向量的数据类型， row_type 表示列向量的数据类型， type 表示这个矩阵的数据类型。


除了数据类型，mat 还定义了一些属性：


col_type value[4];
typedef length_t length_type;
GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 4; }
GLM_FUNC_DECL col_type & operator[](length_type i);
GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;

重载[]运算符来进行访问：


// -- Accesses --
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER typename mat<4, 3, T, Q>::col_type & mat<4, 3, T, Q>::operator[](typename mat<4, 3, T, Q>::length_type i)
	assert(i < this->length());
	return this->value[i];
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<4, 3, T, Q>::col_type const& mat<4, 3, T, Q>::operator[](typename mat<4, 3, T, Q>::length_type i) const
	assert(i < this->length());
	return this->value[i];

通过源码发现[]可以访问一行数据，也就是返回 col_type 类型的数据，因此[]可以代入0，1，2，3分别为第一到四行。再根据vec的[]访问每个分量。


再来看看构造函数的声明：


<typename T, qualifier Q>
struct mat<4, 3, T, Q>{
// -- Constructors --
GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
template<qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<4, 3, T, P> const& m);
GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T const& x);
GLM_FUNC_DECL GLM_CONSTEXPR mat(
		T const& x0, T const& y0, T const& z0,
		T const& x1, T const& y1, T const& z1,
		T const& x2, T const& y2, T const& z2,
		T const& x3, T const& y3, T const& z3);
GLM_FUNC_DECL GLM_CONSTEXPR mat(
		col_type const& v0,
		col_type const& v1,
		col_type const& v2,
		col_type const& v3);

接下来看构造函数的定义：


template<typename T, qualifier Q>
template<qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 3, T, P> const& m)
         #if GLM_HAS_INITIALIZER_LISTS
	 :value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
         #endif
         #if !GLM_HAS_INITIALIZER_LISTS
			this->value[0] = m[0];
			this->value[1] = m[1];
			this->value[2] = m[2];
			this->value[3] = m[3];
         #endif
	template<typename T, qualifier Q>
	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(T const& s)
        #if GLM_HAS_INITIALIZER_LISTS
			: value{col_type(s, 0, 0), col_type(0, s, 0), col_type(0, 0, s), col_type(0, 0, 0)}
        #endif
        #if !GLM_HAS_INITIALIZER_LISTS
			this->value[0] = col_type(s, 0, 0);
			this->value[1] = col_type(0, s, 0);
			this->value[2] = col_type(0, 0, s);
			this->value[3] = col_type(0, 0, 0);
        #endif
	template<typename T, qualifier Q>
	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat
		T const& x0, T const& y0, T const& z0,
		T const& x1, T const& y1, T const& z1,
		T const& x2, T const& y2, T const& z2,
		T const& x3, T const& y3, T const& z3
        #if GLM_HAS_INITIALIZER_LISTS
			: value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)}
        #endif
        #if !GLM_HAS_INITIALIZER_LISTS
			this->value[0] = col_type(x0, y0, z0);
			this->value[1] = col_type(x1, y1, z1);
			this->value[2] = col_type(x2, y2, z2);
			this->value[3] = col_type(x3, y3, z3);
        #endif
	template<typename T, qualifier Q>
	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3)
        #if GLM_HAS_INITIALIZER_LISTS
			: value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
        #endif
        #if !GLM_HAS_INITIALIZER_LISTS
			this->value[0] = v0;
			this->value[1] = v1;
			this->value[2] = v2;
			this->value[3] = v3;
        #endif

再由于 <glm/glm.hpp> 对type_mat4x3.hpp 的包装，因此有以下的构造 mat：


vec3 a(1, 2, 3);
vec3 b(4, 5, 6);
vec3 c(7, 8, 9);
vec3 d(10, 11, 12);
mat4x3 mat1(a, b, c, d);  //利用四个 vec3 ，也就是 col_type 来构造
mat4x3 mat2(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
mat4x3 mat3(2);
mat4x3 mat4(mat3);

如果要观察这个矩阵，可以用两层循环，外层是从0循环到length(),内层是col_type的length()。以下以构造函数只传入一个基本数据类型为例来演示打印：


mat4x3 mat(2);
for (int i = 0; i < mat.length(); ++i) {
	for (int j = 0; j < mat[0].length(); ++j) {
		cout << mat[i][j] << " ";
	cout << endl;
// 2 0 0 
// 0 2 0 
// 0 0 2
// 0 0 0 

其他的运算符重载涉及一些矩阵运算，打算在后面文章中详细讨论，有些定义有点反人类。
  
分类：




    

 Android
 
 
   
相关推荐
 
  •   
        OpenGL
      




    

     
       OpenGL & Metal Shader 编程：ShaderToy 内置全局变量
     
    前面发了一些关于 Shader 编程的文章，有读者反馈太碎片化了，希望这里能整理出来一个系列，方便系统的学习一下 Shader 编程。 由于主流的 Shader 编程网站，如 ShaderToy,
     
    •  503
      •  
     
       一看就懂的OpenGL ES教程——走进3D的世界之坐标系统（下篇）
     
    已经讲解了关于坐标系统以及从局部坐标转换到观察坐标的过程，并且轻描淡写地介绍了投影的概念，今天就来从数学角度推导下投影矩阵，并且将讲下最终从投影后的坐标系转换到屏幕坐标，即视口变换的过程，最后就是实战
     
    •  486
      •  
     
       OpenglES之裁剪测试
     
    剪裁测试用于限制绘制区域，在 OpenGL 中启用裁剪测试可以在屏幕或者帧缓冲上指定一个矩形区域，然后在该矩形区域内绘制，只有在该区域内的片元才有机会最终进入渲染显示。
     
    •  303
      •  
     
       Opengl ES之转场动画
     
    Opengl ES系列连载之在Opengl ES如何实现转场特效，神器GLTransitions来帮你...
     
    •  276
      •  
     
       Opengl关于GL_LUMINANCE被移除的兼容性问题
     
    在Opengl 3.3中，关于颜色格式的内置变量GL_LUMINANCE和GL_LUMINANCE_ALPHA居然被删除了，该如何适配呢？
     
    •  129
      •  
     
       OpenGL7-第一个3D图形
     
    1、画立方体 之前我们绘制的都是二维图形，今天开始我们将进入三维图形的绘制，三维图形是在二维(XY轴)平面基础上，增加了深度(Z轴)，所以三维图形更具有空间感。 二维变三维，图形的顶点个数会增加很多，
     
    •  254
      •  
     
       一看就懂的OpenGL ES教程——走进3D的世界之坐标系统（上篇）
     
    只有在3D的维度，才能真正理解OpenGL，也才能充分真正发挥OpenGL的作用。所以今天的主题，就是研究OpenGL是如何将一个3D的物体渲染成为2D屏幕上的图像的。
     
    •  709
      •  
     
       OpenGL5-三角形平移、旋转操作
     
    01、实现三角形的移动 上一章我们已将实现了绘制一个三角形，今天我们来对这个三角形进行平移和旋转的操作 为了平移一个三角形，需要对每个顶点坐标的分量（X、Y轴）进行平移，如下图，将点p(x,y,z)平
     
    •  494
      •  
     
       OpenGL ES教程——帧缓冲
     
    在OpenGL的渲染管线中，几何数据和纹理通过一系列变换和测试，最终被渲染成屏幕上的二维像素。那些用于存储颜色值和测试结果的二维数组的几何被称为帧缓冲区（frame buffer） 用于写入颜色值的颜
     
    •  237
      •  
     
       OpenGL4-使用顶点缓冲区绘制三角形
     
    01、缓冲区与顶点属性： 之前我们实现了，在屏幕中心上绘制了一个点，而且这个点是固定值不能修改的，现在我们想一次绘制多个点，应该怎么做呢？需要使用顶点缓冲区进行数据传递 OpenGL中想要绘制一个图形
     
    •  462
      •  
     
       OpenglES之分屏滤镜
     
    opengl ES继续肝文系列，今天我们探讨一下在opengl ES中实现分屏滤镜的一些方式技巧。。。
     
    •  387
      •  
     
       手把手带你入门 Three.js Shader 系列（一）
     
    正式开启 Three.js Shader 教程，在本篇文章里带大家看看几何体上的顶点属性，介绍下 GLSL 基础、顶点着色器、片元着色器等内容。
     
    •  1227
      •  
     
       Opengl ES之LUT滤镜(下)-3DLUT
     
    在上一篇文章中我们详细介绍了基于图片纹理的2D LUT滤镜的使用，这种方式也是目前大部分SDK在移动端的实现方式，既然有2D LUT滤镜那就有3D LUT，今天我们就来介绍下3D LUT的使用。
     
    •  358
      •  
     
       坐标系、投影矩阵与变换
     
    笛卡尔坐标系： 我们的顶点使用的是标准化的笛卡尔坐标，X、Y、Z轴都是（-1,1）的范围，映射到屏幕上就是viewport视口的中心点是原点，2D视口的左上、左下、右上、右下分别是（-1,1,0）、（
     
    •  1667
      •  
     
       OpenGL入门二：绘制三角形
     
    本文介绍了Android系统提供的GLSurfaceView的用法及绘制一个最基本的图像：三角形用到的API：设置清屏色、启用顶点缓存、设置视口、设置投影矩阵等。
     
    •  288
      •   
     OpenGL入门二：绘制三角形
      
     
    •  
    友情链接：
     
    推荐文章
    魁梧的单车  ·  Google JS Test Javascript单元测试框架-CSDN博客
    4 月前
    面冷心慈的苦咖啡  ·  一口气看完韩国奇幻喜剧《虽然30但仍17》女孩一觉醒来，变成三十 ...
    5 月前
    兴奋的冲锋衣  ·  大家觉得雷神笔记本怎么样，值得购买么？ - 知乎
    1 年前
    强悍的松鼠  ·  老前辈重出江湖？卓伟带大瓜回归，传奇娱记的辉煌经历- 知乎
    1 年前
    不羁的硬盘  ·  “高速”英语怎么说？_高速公路_The_Toll
    1 年前
    今天看啥   ·   Py中国   ·   codingpro   ·   小百科   ·   link之家   ·   卧龙AI搜索
    删除内容请联系邮箱 2879853325@qq.com
    小百科 - 百科知识指南
    © 2024 ~ 沪ICP备11025650号