Rotating Cube

local Mesh = love.graphics.newMesh (
    {
        {"VertexPosition", "float", 3},
        {"VertexColor", "byte", 4}
    }, {
        {0, 0, 0, love.math.gammaToLinear (0.6, 0.6, 0.6, 1.0)},
        {1, 0, 0, love.math.gammaToLinear (1.0, 0.6, 0.6, 1.0)},
        {0, 1, 0, love.math.gammaToLinear (0.6, 1.0, 0.6, 1.0)},
        {1, 1, 0, love.math.gammaToLinear (1.0, 1.0, 0.6, 1.0)},
        {0, 0, 1, love.math.gammaToLinear (0.6, 0.6, 1.0, 1.0)},
        {1, 0, 1, love.math.gammaToLinear (1.0, 0.6, 1.0, 1.0)},
        {0, 1, 1, love.math.gammaToLinear (0.6, 1.0, 1.0, 1.0)},
        {1, 1, 1, love.math.gammaToLinear (1.0, 1.0, 1.0, 1.0)}
    }, "triangles"
)

local Shader = love.graphics.newShader ([[
    #pragma language glsl3
    //
    uniform vec3 ObjectTranslation;
    uniform mat3 ObjectTransform;
    //
    uniform mat4 CameraProjection;
    //
    varying vec3 FragmentPosition;
    //
    vec4 position (mat4, vec4 P) {
        vec3 Q = (vec3 (TransformMatrix*P) - 0.5)*ObjectTransform + ObjectTranslation;
        vec4 R = vec4 (Q, 1.0)*CameraProjection;
        //
        FragmentPosition = Q;
        //
        return vec4 (R.x, -R.y, R.z*2.0 - R.w, R.w);
    }
]], [[
    #pragma language glsl3
    //
    const vec3 LightPosition = vec3 (2.0, -1.0, 1.0);
    //
    varying vec3 FragmentPosition;
    //
    uniform Image MainTex;
    //
    void effect () {
        float D = distance (FragmentPosition, LightPosition);
        float L = 1.2/(D*D);
        //
        vec4 C = vec4 (1.0);
        //
        C *= vec4 (vec3 (L), 1.0);
        C *= VaryingColor;
        C *= gammaToLinear (Texel (MainTex, vec2 (VaryingTexCoord)));
        //
        love_PixelColor = linearToGamma (C);
    }
]])

--

Mesh:setVertexMap (
    2, 4, 8, 2, 8, 6,
    1, 5, 7, 1, 7, 3,
    3, 7, 8, 3, 8, 4,
    1, 2, 6, 1, 6, 5,
    5, 6, 8, 5, 8, 7,
    1, 3, 4, 1, 4, 2
)

--

local function viewScale (VF, VR)
    local VM = math.tan (VF/2)/math.sqrt (VR*VR + 1)
    --
    return {VR*VM*2, VM*2}
end

local function projectionMatrix (VS, VO, DR)
    local VD = DR [2]/(DR [2] - DR [1])
    --
    return {VO [1], VO [2], VD, 1, -2/VS [1], 0, 0, 0, 0, -2/VS [2], 0, 0, 0, 0, -DR [1]*VD, 0}
end

local function rotate (R)
    local D = R [1]*R [1] + R [2]*R [2] + R [3]*R [3]
    --
    if D < 1e-9 then return {1, 0, 0, 0, 1, 0, 0, 0, 1} end
    --
    local A = math.sqrt (D)
    local N = {R [1]/A, R [2]/A, R [3]/A}
    --
    local C = math.cos (A)
    local S = math.sin (A)
    --
    local O = 1 - C
    --
    return {
        N [1]*N [1]*O + C, N [1]*N [2]*O + N [3]*S, N [1]*N [3]*O - N [2]*S,
        N [2]*N [1]*O - N [3]*S, N [2]*N [2]*O + C, N [2]*N [3]*O + N [1]*S,
        N [3]*N [1]*O + N [2]*S, N [3]*N [2]*O - N [1]*S, N [3]*N [3]*O + C
    }
end

local function multiply (A, B)
    return {
        A [1]*B [1] + A [2]*B [4] + A [3]*B [7],
        A [1]*B [2] + A [2]*B [5] + A [3]*B [8],
        A [1]*B [3] + A [2]*B [6] + A [3]*B [9],
        --
        A [4]*B [1] + A [5]*B [4] + A [6]*B [7],
        A [4]*B [2] + A [5]*B [5] + A [6]*B [8],
        A [4]*B [3] + A [5]*B [6] + A [6]*B [9],
        --
        A [7]*B [1] + A [8]*B [4] + A [9]*B [7],
        A [7]*B [2] + A [8]*B [5] + A [9]*B [8],
        A [7]*B [3] + A [8]*B [6] + A [9]*B [9]
    }
end

local function smooth (A, B, F, DT)
    local R = F*DT*math.pi*2
    --
    return A + (B - A)/(R + 1)*R
end

--

local Position = {{3, 0, 0}, {3, 0, 0}}

local Torque = {0, 0, 0}

local Rotation = {1, 0, 0, 0, 1, 0, 0, 0, 1}

--

function love.load ()
    love.graphics.setBackgroundColor (0.1, 0.1, 0.1)
end

function love.keypressed (Button)
    if Button == "escape" then love.event.quit () end
end

function love.mousemoved (MX, MY, DX, DY)
    if not love.mouse.isDown (1) then return end
    --
    Torque [2] = Torque [2] - DY*0.13
    Torque [3] = Torque [3] + DX*0.13
end

function love.wheelmoved (DX, DY)
    Position [1] [1] = math.min (math.max (Position [1] [1] - DY*0.25, 2), 8)
end

function love.update (DT)
    Position [2] [1] = smooth (Position [2] [1], Position [1] [1], 2, DT)
    Position [2] [2] = smooth (Position [2] [2], Position [1] [2], 2, DT)
    Position [2] [3] = smooth (Position [2] [3], Position [1] [3], 2, DT)
    --
    local DC = love.mouse.isDown (1) and 2 or 0.1
    --
    Torque [1] = smooth (Torque [1], 0, DC, DT)
    Torque [2] = smooth (Torque [2], 0, DC, DT)
    Torque [3] = smooth (Torque [3], 0, DC, DT)
    --
    Rotation = multiply (Rotation, rotate ({Torque [1]*DT, Torque [2]*DT, Torque [3]*DT}))
end

function love.draw ()
    local TE = love.timer.getTime ()
    local VS = viewScale (math.rad (100), love.graphics.getWidth ()/love.graphics.getHeight ())
    --
    Shader:send ("ObjectTranslation", Position [2])
    Shader:send ("ObjectTransform", Rotation)
    Shader:send ("CameraProjection", projectionMatrix (VS, {0, 0}, {0.1, 100}))
    --
    love.graphics.push ("all")
    love.graphics.setShader (Shader)
    love.graphics.setBlendMode ("alpha", "alphamultiply")
    love.graphics.setDepthMode ("lequal", true)
    love.graphics.setMeshCullMode ("back")
    love.graphics.draw (Mesh)
    love.graphics.pop ()
end