Code Samples

This series of samples only shows various GLM functionality.

Compute a Triangle's Normal

#include <glm/glm.hpp> // vec3 normalize cross
 
glm::vec3 computeNormal(
glm::vec3 const & a, 
glm::vec3 const & b,
glm::vec3 const & c)
{
        return glm::normalize(glm::cross(c - a, b - a));
}

A potentially faster, but less accurate alternative:

#include <glm/glm.hpp> // vec3 cross
#include <glm/gtx/fast_square_root.hpp> // fastNormalize
 
glm::vec3 computeNormal(
        glm::vec3 const & a, 
        glm::vec3 const & b,
        glm::vec3 const & c)
{
        return glm::fastNormalize(glm::cross(c - a, b - a));
}

Matrix Transform

#include <glm/glm.hpp> //vec3, vec4, ivec4, mat4
#include <glm/gtc/matrix_transform.hpp> //translate, rotate, scale, perspective 
#include <glm/gtc/type_ptr.hpp> //value_ptr
 
void setUniformMVP(
                GLuint Location, 
                glm::vec3 const & Translate, 
                glm::vec3 const & Rotate)
{
        glm::mat4 Projection =
        glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.f);
        glm::mat4 ViewTranslate = glm::translate(
        glm::mat4(1.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(
        Location, 1, GL_FALSE, glm::value_ptr(MVP));
}

Vector Types

#include <glm/glm.hpp> //vec2
#include <glm/gtc/type_precision.hpp> //hvec2, i8vec2, i32vec2
std::size_t const VertexCount = 4;
 
// Float quad geometry
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)
};

// Half-float quad geometry
std::size_t const PositionSizeF16 = VertexCount * sizeof(glm::hvec2);
glm::hvec2 const PositionDataF16[VertexCount] =
{
        glm::hvec2(-1.0f, -1.0f),
        glm::hvec2( 1.0f, -1.0f),
        glm::hvec2( 1.0f, 1.0f),
        glm::hvec2(-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/glm.hpp> // vec3 normalize reflect dot pow
#include <glm/gtx/random.hpp> // vecRand3
 
// vecRand3, generate a random and equiprobable normalized vec3
 
glm::vec3 lighting(
        intersection const & Intersection,
        material const & Material,
        light const & Light,
        glm::vec3 const & View)
{
        glm::vec3 Color = glm::vec3(0.0f);
        glm::vec3 LightVertor = glm::normalize(
        Light.position() - Intersection.globalPosition() +
        glm::vecRand3(0.0f, Light.inaccuracy());
        
        if(!shadow(
                Intersection.globalPosition(),
                Light.position(),
                LightVertor))
        {
                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(
                -LightVector,
                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;
}