### Code samples

Compute a triangle normal:
• #include <glm/vec3.hpp>// glm::vec3
• #include <glm/geometric.hpp>// glm::cross, glm::normalize
• void computeNormal(triangle & Triangle)
• {
• glm::vec3 const & a = Triangle.Position[0];
• glm::vec3 const & b = Triangle.Position[1];
• glm::vec3 const & c = Triangle.Position[2];
• Triangle.Normal = glm::normalize(glm::cross(c - a, b - a));
• }
Matrix transform:
• #include <glm/vec3.hpp> // glm::vec3
• #include <glm/vec4.hpp> // glm::vec4, glm::ivec4
• #include <glm/mat4x4.hpp> // glm::mat4
• #include <glm/gtc/matrix_transform.hpp> // glm::translate, glm::rotate, glm::scale, glm::perspective
• #include <glm/gtc/type_ptr.hpp> // glm::value_ptr
• void func(GLuint LocationMVP, float Translate, glm::vec2 const & Rotate)
• {
• glm::mat4 Projection = glm::perspective(glm::radians(45.0f), 4.0f / 3.0f, 0.1f, 100.f);
• glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Translate));
• glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Rotate.y, glm::vec3(-1.0f, 0.0f, 0.0f));
• glm::mat4 View = glm::rotate(ViewRotateX, Rotate.x, glm::vec3(0.0f, 1.0f, 0.0f));
• glm::mat4 Model = glm::scale(glm::mat4(1.0f), glm::vec3(0.5f));
• glm::mat4 MVP = Projection * View * Model;
• glUniformMatrix4fv(LocationMVP, 1, GL_FALSE, glm::value_ptr(MVP));
• }
Vector types:
• #include <glm/vec2.hpp>// glm::vec2
• #include <glm/packing.hpp>// glm::packUnorm2x16
• #include <glm/integer.hpp>// glm::uint
• #include <glm/gtc/type_precision.hpp>// glm::i8vec2, glm::i32vec2
• std::size_t const VertexCount = 4;
• std::size_t const PositionSizeF32 = VertexCount * sizeof(glm::vec2);
• glm::vec2 const PositionDataF32[VertexCount] =
• {
• glm::vec2(-1.0f,-1.0f),
• glm::vec2( 1.0f,-1.0f),
• glm::vec2( 1.0f, 1.0f),
• glm::vec2(-1.0f, 1.0f)
• };
• std::size_t const PositionSizeF16 = VertexCount * sizeof(glm::uint);
• glm::uint const PositionDataF16[VertexCount] =
• {
• glm::uint(glm::packUnorm2x16(glm::vec2(-1.0f, -1.0f))),
• glm::uint(glm::packUnorm2x16(glm::vec2( 1.0f, -1.0f)),
• glm::uint(glm::packUnorm2x16(glm::vec2( 1.0f, 1.0f))),
• glm::uint(glm::packUnorm2x16(glm::vec2(-1.0f, 1.0f)))
• };
• // 8 bits signed integer quad geometry
• std::size_t const PositionSizeI8 = VertexCount * sizeof(glm::i8vec2);
• glm::i8vec2 const PositionDataI8[VertexCount] =
• {
• glm::i8vec2(-1,-1),
• glm::i8vec2( 1,-1),
• glm::i8vec2( 1, 1),
• glm::i8vec2(-1, 1)
• };
• // 32 bits signed integer quad geometry
• std::size_t const PositionSizeI32 = VertexCount * sizeof(glm::i32vec2);
• glm::i32vec2 const PositionDataI32[VertexCount] =
• {
• glm::i32vec2 (-1,-1),
• glm::i32vec2 ( 1,-1),
• glm::i32vec2 ( 1, 1),
• glm::i32vec2 (-1, 1)
• };
Lighting:
• #include <glm/vec3.hpp>// glm::vec3
• #include <glm/geometric.hpp>// glm::normalize, glm::dot, glm::reflect
• #include <glm/exponential.hpp>// glm::pow
• #include <glm/gtc/random.hpp>// glm::vecRand3
• glm::vec3 lighting
• (
• intersection const & Intersection,
• material const & Material,
• light const & Light,
• glm::vec3 const & View
• )
• {
• glm::vec3 Color(0.0f);
• glm::vec3 LightVector(glm::normalize(
• Light.position() - Intersection.globalPosition() +
• glm::vecRand3(0.0f, Light.inaccuracy()));
• {
• float Diffuse = glm::dot(Intersection.normal(), LightVector);
• if(Diffuse <= 0.0f)
• return Color;
• if(Material.isDiffuse())
• Color += Light.color() * Material.diffuse() * Diffuse;
• if(Material.isSpecular())
• {
• glm::vec3 Reflect(glm::reflect(
• glm::normalize(-LightVector),
• glm::normalize(Intersection.normal())));
• float Dot = glm::dot(Reflect, View);
• float Base = Dot > 0.0f ? Dot : 0.0f;
• float Specular = glm::pow(Base, Material.exponent());
• Color += Material.specular() * Specular;
• }
• }
• return Color;
• }