- Main Page
- Modules
- Namespaces
- Classes
- Files

# 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;
    }