• A deferred rendering core for opaque objects.
• A forward renderer, supporting a subset of the features of the deferred renderer, for rendering translucent objects.
• A full dynamic lighting system, including both basic and variance shadow mapping. The use of deferred rendering allows for potentially hundreds of dynamic lights per scene.
• A detailed material system, allowing for artists and developers to create surfaces with a wide variety of effects such as normal mapping, environment-mapped reflections, generic refraction, surface emission, mapped specular highlights, etc, without writing a single line of shader code. All materials are immutable but are created via simple mutable builders in code, and so are effectively dynamic [0].
• A variety of postprocessing effects such as box blurring, fast approximate antialiasing (FXAA), color correction, bloom, etc. Effects can be applied in any order.
• Explicit control over all resource loading and caching. For all transient resources [1], the programmer is required to provide the renderer with explicit caches, and the caches themselves are responsible for allocating and loading resources.
• Extensive use of immutable objects for the purposes of correctness. One of the driving design concepts is that the programmer passes an immutable "snapshot" of the scene to be rendered to a rendering function, and that rendering function will always return the same image for that snapshot.
• Simplicity. The implementation consists of a few thousand shaders generated at compile-time from the Java material and light types defined in the renderer's API. All of the usual bugs that plague programmers using 3D renderers that directly expose shaders (such as passing incorrect parameters to shaders, forgetting to pass required parameters, etc), are simply not present. The system knows every possible light and material combination, statically, and knows how to pass the right parameters to the shaders that implement them. The programmer doesn't have to worry about it.
• Extensive use of static types. As with all io7m packages, there is extreme emphasis on using the type system to make it difficult to use the APIs incorrectly.
• Portability. The renderer will run on any system supporting either OpenGL >= 3.0 or OpenGL ES >= 3.

• A scene graph. The renderer expects the programmer to provide a set of instances (with associated materials) and lights once per frame, and the renderer will obediently draw exactly those instances. This frees the programmer from having to interact with a clumsy and type-unsafe "object-oriented" scene graph as with other 3D engines, and from having to try to crowbar their own program's data structures into an existing graph system.
• Spatial partitioning. The renderer knows nothing of the world the programmer is trying to render. The programmer is expected to have done the work of deciding which instances and lights contribute to the current image, and to provide only those lights and instances for the current frame. This means that the programmer is free to use any spatial partitioning system desired.
• Input handling. The renderer knows nothing about keyboards, mice, joysticks. The programmer passes an immutable snapshot of a scene to the renderer, and the renderer returns an image. This means that the programmer is free to use any input system desired without having to painfully integrate their own code with an existing input system as with other 3D engines.
• Audio. The renderer makes images, not sounds. This allows programmers to use any audio system they want in their programs.
• Skeletal animation. The input to the renderer is a set of triangle meshes in the form of vertex buffer objects. This means that the programmer is free to use any skeletal animation system desired, providing that the system is capable of producing vertex buffer objects of the correct type as a result.
• Model loading. The input to the renderer is a set of triangle meshes in the form of vertex buffer objects. This means that the programmer is free to use any model loading system desired, providing that the system is capable of producing vertex buffer objects of the correct type as a result [3].
• Future proofing. The average lifetime of a rendering system is about five years. Due to the extremely rapid pace of advancement in graphics hardware, the methods use to render graphics today will bear almost no relation to those used five years into the future. The io7m-r1 package is under no illusion that it will still be relevant in a decade's time. It is designed to get work done today, using exactly those techniques that are relevant today. It will not be indefinitely expanded and grown organically, as this would directly contradict the goal of having a minimalist and correct rendering system.
• OpenGL ES 2 support. The ES 2 standard was written as a reaction to the insane committee politics that plagued the OpenGL 2.* standards. It is crippled to the point that it essentially cannot support almost any of the rendering techniques present in the io7m-r1 package, and is becoming increasingly irrelevant as the much saner ES 3 is adopted by hardware vendors.

module LightDiffuse where

import qualified Color3
import qualified Direction
import qualified Normal
import qualified Spaces
import qualified Vector3f

diffuse ::  Direction.T Spaces.Eye -> Normal.T -> Color3.T -> Float -> Vector3f.T
diffuse stl n light_color light_intensity =
  let 
    factor       = max 0.0 (Vector3f.dot3 stl n)
    light_scaled = Vector3f.scale light_color light_intensity
  in 
    Vector3f.scale light_scaled factor

• The surface albedo; the basic color of the surface prior to any lighting.
• The surface depth properties; to give per-pixel control over "transparency" without requiring the overhead of making the material translucent.
• The surface emissive properties; to present the illusion of surfaces emitting light.
• The surface environment properties; to provide environment-mapped reflections and other effects.
• The surface normal properties; to provide per-pixel control of surface normal vectors ("normal mapping").
• The surface specular properties; to provide per-pixel control of surface specularity.

• KLightDirectional - a directional light that simulates parallel light rays without any origin. Directional lights cannot cast shadows (because directional lights do not have origins).
• KLightSphereWithoutShadow - a spherical light. A spherical light casts light in all directions from a given position in world-space, up to a given radius. The emitted light is attenuated over distance based on a configurable falloff value. This type of light is often referred to as a point light in other renderers.
• KLightProjectiveWithoutShadow - a projective light. A projective light effectively projects a given image onto the visible set from a given position in world-space, up to a given radius. The emitted light is attenuated over distance based on a configurable falloff value.
• KLightProjectiveWithShadowBasic - a projective light that can also cast basic shadows. Basic shadows are very cheap to compute, but can suffer from aliasing issues (resulting in sharp edges to shadows).
• KLightProjectiveWithShadowVariance - a projective light that can also cast variance shadows. Variance shadows are slightly more expensive to compute than basic shadows, but can be filtered by hardware, resulting in attractive soft shadows.
• KLightSpherePseudoWithShadowBasic - a pseudo-spherical light. A pseudo-spherical light behaves like a spherical light but is emulated via at most six projective lights arranged such that each light provides a section of the sphere. Individual lights can be enabled and disabled, and the lights can project basic shadows.
• KLightSpherePseudoWithShadowVariance - is to KLightSpherePseudoWithShadowBasic as KLightProjectiveWithShadowVariance is to KLightProjectiveWithShadowBasic.
• KLightSphereTexturedCubeWithoutShadow - a spherical light that projects a cube map in all directions.

cube = {
    (-0.5, -0.5, -0.5),
    ( 0.5, -0.5, -0.5),
    ( 0.5, -0.5,  0.5),
    (-0.5, -0.5,  0.5),
  
    (-0.5,  0.5, -0.5),
    ( 0.5,  0.5, -0.5),
    ( 0.5,  0.5,  0.5),
    (-0.5,  0.5,  0.5)
  }

After clipping and division by w, depth coordinates range from -1 to 1, 
corresponding to the near and far clipping planes. glDepthRange specifies a 
linear mapping of the normalized depth coordinates in this range to window 
depth coordinates. Regardless of the actual depth buffer implementation, 
window coordinate depth values are treated as though they range from 0 
through 1 (like color components). Thus, the values accepted by 
glDepthRange are both clamped to this range before they are accepted.
The setting of (0,1) maps the near plane to 0 and the far plane to 1. 
With this mapping, the depth buffer range is fully utilized.

• The material system was designed to accomodate the majority of rendering techniques seen in computer games circa 2014 (such as normal mapping, environment mapped reflections, etc). If the io7m-r1 package doesn't provide direct support for a technique, then the programmer is required to modify the io7m-r1 package to use it.

• The material system was designed to accomodate the majority of rendering techniques seen in computer games circa 2014 (such as normal mapping, environment mapped reflections, etc). Rather than having to tediously re-implement error-prone techniques such as normal mapping over and over, the programmer simply enables normal mapping for a material.
• The material system provides enough metadata about a given surface for all renderers in the io7m-r1 package to give consistently correct results regardless of the lighting in a scene. For example, other rendering systems that utilize shadow mapping often give incorrect results when a user-written shader conditionally discards pixels. Shadow mapping is implemented by rendering a depth-only image of an object from a different perspective, and so the same pixels have to be discarded when rendering the depth-only image as when rendering the actual color image. In systems where the user is required to write shaders, the system has no way of knowing that some pixels need to be discarded and often has to fall back to running the full material shader with writes to the color buffer masked. The material system in the io7m-r1 package indicates statically when this can occur, and so the system simply uses a very efficient depth-only shader to render accurate shadow maps.
• In other rendering systems (particularly those that use forward rendering), the programmer is required to write one shader per combination of material and light. That is, the programmer is expected to re-implement each of the different lighting techniques for every single material so that each can be used in any possible lighting environment. Many systems use a shader generation system to work around these sorts of problems, requiring the development of (and the programmer to learn) even more complex tools and development environments. This issue is simply not present with a static material system.
• Because the set of possible material and light types in the io7m-r1 package is fixed, the system knows exactly how to correctly send data to all of the possible shaders. The programmer is not required to laboriously configure all of the connections between shader parameters and the data that must be supplied to shaders. All of the usual classes of bugs involving forgetting to set parameters, sending parameters of the wrong type, etc, are simply not possible.
• The material system allows for extremely rapid development and previewing of materials. Because the components of the material systems are exposed as simple pseudo-algebraic Java types, it is extremely easy to put together a graphical user interface for configuring materials. Rendering systems that require programmers to write shaders typically end up implementing their own complete integrated development environments!
• Because the GLSL language is fundamentally poorly designed and entirely anti-modular, any rendering system requiring the programmer to write shaders must implement its own custom shading language to give good type errors and to work identically across all of the different possible versions of OpenGL [17]. It is simply not possible, in the io7m-r1 package, for the programmer to create a material that will work on some of the supported OpenGL versions and not others.
• The material system has predictable performance characteristics. In systems that require programmers to write their own shaders, it is standard practice for programmers to repeatedly re-visit and do tedious optimization work to get their materials to run faster. The io7m-r1 package tries to expose a very minimalist material system and delegates the work of, for example, procedural texture generation to external systems [18].

/*
 * Copyright © 2014 <code@io7m.com> http://io7m.com
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
 * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

package com.io7m.r1.documentation.examples;

import com.io7m.jfunctional.Unit;
import com.io7m.junreachable.UnreachableCodeException;
import com.io7m.r1.kernel.types.KMaterialAlbedoTextured;
import com.io7m.r1.kernel.types.KMaterialAlbedoType;
import com.io7m.r1.kernel.types.KMaterialAlbedoUntextured;
import com.io7m.r1.kernel.types.KMaterialAlbedoVisitorType;
import com.io7m.r1.types.RException;

/**
 * An example of pattern matching on materials.
 */

public final class Match0
{
  private Match0()
  {
    throw new UnreachableCodeException();
  }

  public static void whichAlbedoType(
    final KMaterialAlbedoType m)
    throws RException
  {
    m
      .albedoAccept(new KMaterialAlbedoVisitorType<Unit, UnreachableCodeException>() {
        @Override public Unit textured(
          final KMaterialAlbedoTextured mt)
        {
          System.out.println("Textured");
          return Unit.unit();
        }

        @Override public Unit untextured(
          final KMaterialAlbedoUntextured mu)
        {
          System.out.println("Untextured");
          return Unit.unit();
        }
      });
  }
}

module Albedo where

import qualified Color4
import qualified Vector4f

albedo :: Color4.T -> Float -> Color4.T -> Color4.T
albedo base mix t =
  Vector4f.interpolate base ((Vector4f.w t) * mix) t

• f is a value of type KFaceSelection, which indicates which faces in the given mesh will be rendered.
• m is a material.
• k is a reference to a mesh.
• t is a transform.
• u is a texture matrix.

1. Clear the current g-buffer, depth buffer, stencil buffer, and optionally the color buffer. The stencil buffer is cleared to 0 and the depth buffer is cleared to 1.
2. For each light group g in the scene:
   1. Enable writing to the depth and stencil buffers, and disable stencil testing.
   2. Set all non-zero values in the current stencil buffer to 1. See the section on light group stencils for the meaning behind these values.
   3. For each instance o in g:
      1. Render the surface albedo, eye-space normals, specular color, and emission level of o into the g-buffer. Normal mapping is performed during rendering, and if o does not have specular highlights, then a pure black (zero intensity) specular color is written. Effects such as environment mapping are considered to be part of the surface albedo and so are performed in this step. Depth testing is enabled, and a depth function that only results in pixels being drawn if the depth of the current pixel is less than or equal to the current depth buffer value is used. The corresponding stencil buffer value is set to 2.
   4. Disable depth buffer and stencil buffer writing. Keep depth testing enabled and set the depth function to greater than or equal. Enable the stencil test, and configure it such that only pixels with a corresponding value of 2 in the stencil buffer will be affected.
   5. For each light k in g:
      1. Render a light volume representing k. All pixels that are overlapped by k and that satisfy the depth test have lighting applied. Lighting is applied in eye-space, and the original eye-space position of the current surface is reconstructed using a position reconstruction algorithm.

• A value of 0 in the stencil buffer indicates that the current pixel has never been affected by any light group. This is the initial state of all pixels.
• A value of 1 in the stencil buffer indicates that the current pixel was previously affected by a light group.
• A value of 2 in the stencil buffer indicates that the current pixel is in the current light group and will have lighting applied.

module NormalCompress where

import qualified Vector3f
import qualified Vector2f
import qualified Normal

compress :: Normal.T -> Vector2f.T
compress n =
  let p = sqrt ((Vector3f.z n * 8.0) + 8.0)
      x = (Vector3f.x n / p) + 0.5
      y = (Vector3f.y n / p) + 0.5
  in Vector2f.V2 x y

module NormalDecompress where

import qualified Vector3f
import qualified Vector2f
import qualified Normal

decompress :: Vector2f.T -> Normal.T
decompress v =
  let fn = Vector2f.V2 ((Vector2f.x v * 4.0) - 2.0) ((Vector2f.y v * 4.0) - 2.0)
      f  = Vector2f.dot2 fn fn
      g  = sqrt (1.0 - (f / 4.0))
      x  = (Vector2f.x fn) * g
      y  = (Vector2f.y fn) * g
      z  = 1.0 - (f / 2.0)
  in Vector3f.V3 x y z

• Spherical lights with radius r are represented by unit spheres with a transform that scales them during rendering to spheres with a resulting radius of r.
• Directional lights are represented by full-screen quads.
• Projective lights are represented by frustums that are created and cached on demand to match the size and shape of the light's projection.

module ScreenToTexture where

import qualified Vector2f

screen_to_texture :: Vector2f.T -> Float -> Float -> Vector2f.T
screen_to_texture position width height =
  let u = (Vector2f.x position) / width
      v = (Vector2f.y position) / height
  in Vector2f.V2 u v

module ScreenDepthToNDC where

screen_depth_to_ndc :: Float -> Float
screen_depth_to_ndc screen_depth =
  (screen_depth * 2.0) - 1.0

module ClipSpaceZLong where

import qualified Matrix4f as M4x4;
import qualified Vector4f as V4;

clip_z_long :: M4x4.T -> V4.T -> Float
clip_z_long m eye =
  let
    m20 = M4x4.row_column m (2, 0)
    m21 = M4x4.row_column m (2, 1)
    m22 = M4x4.row_column m (2, 2)
    m23 = M4x4.row_column m (2, 3)

    k0 = (V4.x eye) * m20
    k1 = (V4.y eye) * m21
    k2 = (V4.z eye) * m22
    k3 = (V4.w eye) * m23
  in
    k0 + k1 + k2 + k3

module ClipSpaceWLong where

import qualified Matrix4f as M4x4;
import qualified Vector4f as V4;

clip_w_long :: M4x4.T -> V4.T -> Float
clip_w_long m eye =
  let
    m30 = M4x4.row_column m (3, 0)
    m31 = M4x4.row_column m (3, 1)
    m32 = M4x4.row_column m (3, 2)
    m33 = M4x4.row_column m (3, 3)

    k0 = (V4.x eye) * m30
    k1 = (V4.y eye) * m31
    k2 = (V4.z eye) * m32
    k3 = (V4.w eye) * m33
  in
    k0 + k1 + k2 + k3

module ClipSpaceZSimple where

import qualified Matrix4f as M4x4;
import qualified Vector4f as V4;

clip_z_simple :: M4x4.T -> V4.T -> Float
clip_z_simple m eye =
  let
    m22 = M4x4.row_column m (2, 2)
    m23 = M4x4.row_column m (2, 3)
  in
    ((V4.z eye) * m22) + m23

module ClipSpaceWSimple where

import qualified Matrix4f as M4x4;
import qualified Vector4f as V4;

clip_w_simple :: M4x4.T -> V4.T -> Float
clip_w_simple m eye =
  let
    m32 = M4x4.row_column m (3, 2)
    m33 = M4x4.row_column m (3, 3)
  in
    ((V4.z eye) * m32) + m33

module EyeSpaceZ where

import qualified Matrix4f as M4x4;

eye_z :: M4x4.T -> Float -> Float
eye_z m ndc_z =
  let
    m22 = M4x4.row_column m (2, 2)
    m23 = M4x4.row_column m (2, 3)
    m32 = M4x4.row_column m (3, 2)
    m33 = M4x4.row_column m (3, 3)
    
    a = (ndc_z * m33) - m32
    b = (ndc_z * m23) - m22
  in
    - (a / b)

module NDCCorners where

import qualified Vector4f as V4

near_x0y0 :: V4.T
near_x0y0 = V4.V4 (-1.0) (-1.0) (-1.0) 1.0

near_x1y0 :: V4.T
near_x1y0 = V4.V4 1.0 (-1.0) (-1.0) 1.0

near_x0y1 :: V4.T
near_x0y1 = V4.V4 (-1.0) 1.0 (-1.0) 1.0

near_x1y1 :: V4.T
near_x1y1 = V4.V4 1.0 1.0 (-1.0) 1.0

far_x0y0 :: V4.T
far_x0y0 = V4.V4 (-1.0) (-1.0) 1.0 1.0

far_x1y0 :: V4.T
far_x1y0 = V4.V4 1.0 (-1.0) 1.0 1.0

far_x0y1 :: V4.T
far_x0y1 = V4.V4 (-1.0) 1.0 1.0 1.0

far_x1y1 :: V4.T
far_x1y1 = V4.V4 1.0 1.0 1.0 1.0

module RayAndQ where

import qualified Matrix4f as M4x4
import qualified Vector4f as V4

-- | Calculate @(ray, q)@ for the given inverse projection matrix and frustum corners
ray_and_q :: M4x4.T -> (V4.T, V4.T) -> (V4.T, V4.T)
ray_and_q inverse_m (near, far) =
  let
    -- Unproject the NDC coordinates to eye-space
    near_hom    = M4x4.mult_v inverse_m near
    near_eye    = V4.div_s near_hom (V4.w near_hom)
    far_hom     = M4x4.mult_v inverse_m far
    far_eye     = V4.div_s far_hom (V4.w far_hom)
    
    -- Calculate a ray with ray.z == 1.0
    ray_initial = V4.sub4 far_eye near_eye
    ray = V4.div_s ray_initial (V4.z ray_initial)
    
    -- Subtract the scaled ray from the near corner to calculate q
    q = V4.sub4 near_eye (V4.scale ray (V4.z near_eye))
  in
    (ray, q)

module RayAndQAll where

import qualified NDCCorners
import qualified RayAndQ
import qualified Matrix4f as M4x4
import qualified Vector4f as V4

data T = T {
  q_x0y0 :: V4.T,
  q_x1y0 :: V4.T,
  q_x0y1 :: V4.T,
  q_x1y1 :: V4.T,
  ray_x0y0 :: V4.T,
  ray_x1y0 :: V4.T,
  ray_x0y1 :: V4.T,
  ray_x1y1 :: V4.T
} deriving (Eq, Ord, Show)

-- | Calculate all rays and qs for the four pairs of near/far frustum corners
calculate :: M4x4.T -> T
calculate inverse_m =
  let
    (x0y0_ray, x0y0_q) = RayAndQ.ray_and_q inverse_m (NDCCorners.near_x0y0, NDCCorners.far_x0y0)
    (x1y0_ray, x1y0_q) = RayAndQ.ray_and_q inverse_m (NDCCorners.near_x1y0, NDCCorners.far_x1y0)
    (x0y1_ray, x0y1_q) = RayAndQ.ray_and_q inverse_m (NDCCorners.near_x0y1, NDCCorners.far_x0y1)
    (x1y1_ray, x1y1_q) = RayAndQ.ray_and_q inverse_m (NDCCorners.near_x1y1, NDCCorners.far_x1y1)
  in
    T {
      q_x0y0 = x0y0_q,
      q_x1y0 = x1y0_q,
      q_x0y1 = x0y1_q,
      q_x1y1 = x1y1_q,
      ray_x0y0 = x0y0_ray,
      ray_x1y0 = x1y0_ray,
      ray_x0y1 = x0y1_ray,
      ray_x1y1 = x1y1_ray
    }

module Bilinear4 where

import qualified Vector2f as V2
import qualified Vector4f as V4

interpolate :: (V4.T, V4.T, V4.T, V4.T) -> V2.T -> V4.T
interpolate (x0y0, x1y0, x0y1, x1y1) position =
  let u0 = V4.interpolate x0y0 (V2.x position) x1y0
      u1 = V4.interpolate x0y1 (V2.x position) x1y1
  in V4.interpolate u0 (V2.y position) u1

--
-- Copyright © 2014 <code@io7m.com> http://io7m.com
-- 
-- Permission to use, copy, modify, and/or distribute this software for any
-- purpose with or without fee is hereby granted, provided that the above
-- copyright notice and this permission notice appear in all copies.
-- 
-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
-- SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
-- IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
--

package com.io7m.r1.core;

--
-- Functions for handling logarithmic depth buffers.
--

module LogDepth is

  import com.io7m.parasol.Float as F;

  function prepare_eye_z (z : float) : float =
    F.add (F.negate (z), 1.0);

  function encode_partial (
    z                 : float,
    depth_coefficient : float  
  ) : float =
    let 
      value half_co = F.multiply (depth_coefficient, 0.5);
      value clamp_z = F.maximum (0.000001, z);
    in
      F.multiply (F.log2 (clamp_z), half_co)
    end;

  function encode_full (
    z                 : float,
    depth_coefficient : float  
  ) : float =
    let 
      value half_co = F.multiply (depth_coefficient, 0.5);
      value clamp_z = F.maximum (0.000001, F.add (z, 1.0));
    in
      F.multiply (F.log2 (clamp_z), half_co)
    end;

  function decode (
    z                 : float,
    depth_coefficient : float  
  ) : float =
    let value half_co = F.multiply (depth_coefficient, 0.5); in
      F.subtract (F.power (2.0, F.divide (z, half_co)), 1.0)
    end;

end;

--
-- Copyright © 2014 <code@io7m.com> http://io7m.com
--
-- Permission to use, copy, modify, and/or distribute this software for any
-- purpose with or without fee is hereby granted, provided that the above
-- copyright notice and this permission notice appear in all copies.
--
-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
-- SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
-- IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
--

package com.io7m.r1.core;

--
-- Position reconstruction for deferred rendering.
--

module Reconstruction is

  import com.io7m.parasol.Float as F;
  import com.io7m.parasol.Vector2f as V2;
  import com.io7m.parasol.Vector3f as V3;
  import com.io7m.parasol.Vector4f as V4;

  import com.io7m.r1.core.Bilinear;
  import com.io7m.r1.core.Transform;
  import com.io7m.r1.core.Viewport;
  import com.io7m.r1.core.ViewRays;

  function reconstruct_eye (
    screen_depth : float,
    screen_uv    : vector_2f,
    m_projection : matrix_4x4f,
    view_rays    : ViewRays.t
  ) : vector_4f =
    let
      value eye_depth =
        Transform.ndc_to_eye_z (
          m_projection,
          Transform.screen_depth_to_ndc (screen_depth)
        );
    in
      reconstruct_eye_with_eye_z (
        eye_depth, 
        screen_uv, 
        m_projection, 
        view_rays
      )
    end;

  function reconstruct_eye_with_eye_z (
    eye_depth    : float,
    screen_uv    : vector_2f,
    m_projection : matrix_4x4f,
    view_rays    : ViewRays.t
  ) : vector_4f =
    let
      value origin =
        Bilinear.interpolate_3f (
          view_rays.origin_x0y0,
          view_rays.origin_x1y0,
          view_rays.origin_x0y1,
          view_rays.origin_x1y1,
          screen_uv
        );

      value ray_normal =
        Bilinear.interpolate_3f (
          view_rays.ray_x0y0,
          view_rays.ray_x1y0,
          view_rays.ray_x0y1,
          view_rays.ray_x1y1,
          screen_uv
        );
        
      value ray =
        V3.multiply_scalar (
          ray_normal,
          eye_depth
        );
    in
      new vector_4f (V3.add (origin, ray), 1.0)
    end;

end;

--
-- Copyright © 2014 <code@io7m.com> http://io7m.com
--
-- Permission to use, copy, modify, and/or distribute this software for any
-- purpose with or without fee is hereby granted, provided that the above
-- copyright notice and this permission notice appear in all copies.
--
-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
-- SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
-- IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
--

package com.io7m.r1.core;

module ViewRays is

  type t is record
    origin_x0y0 : vector_3f,
    origin_x1y0 : vector_3f,
    origin_x0y1 : vector_3f,
    origin_x1y1 : vector_3f,
    ray_x0y0    : vector_3f,
    ray_x1y0    : vector_3f,
    ray_x0y1    : vector_3f,
    ray_x1y1    : vector_3f
  end;

end;

module LogDepth where

newtype LogDepth =
  LogDepth Float
    deriving (Eq, Ord, Show)

type Depth = Float

log2 :: Float -> Float
log2 = logBase 2.0

depth_coefficient :: Float -> Float
depth_coefficient far = 2.0 / log2 (far + 1.0)

encode :: Float -> Depth -> LogDepth
encode depth_co depth =
  let hco = depth_co * 0.5 in
    LogDepth $ log2 (depth + 1.0) * hco

decode :: Float -> LogDepth -> Depth
decode depth_co (LogDepth depth) =
  let hco = depth_co * 0.5 in
    (2.0 ** (depth / hco)) - 1

--
-- Copyright © 2014 <code@io7m.com> http://io7m.com
-- 
-- Permission to use, copy, modify, and/or distribute this software for any
-- purpose with or without fee is hereby granted, provided that the above
-- copyright notice and this permission notice appear in all copies.
-- 
-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
-- SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
-- IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
--

package com.io7m.r1.core;

--
-- Functions for handling logarithmic depth buffers.
--

module LogDepth is

  import com.io7m.parasol.Float as F;

  function prepare_eye_z (z : float) : float =
    F.add (F.negate (z), 1.0);

  function encode_partial (
    z                 : float,
    depth_coefficient : float  
  ) : float =
    let 
      value half_co = F.multiply (depth_coefficient, 0.5);
      value clamp_z = F.maximum (0.000001, z);
    in
      F.multiply (F.log2 (clamp_z), half_co)
    end;

  function encode_full (
    z                 : float,
    depth_coefficient : float  
  ) : float =
    let 
      value half_co = F.multiply (depth_coefficient, 0.5);
      value clamp_z = F.maximum (0.000001, F.add (z, 1.0));
    in
      F.multiply (F.log2 (clamp_z), half_co)
    end;

  function decode (
    z                 : float,
    depth_coefficient : float  
  ) : float =
    let value half_co = F.multiply (depth_coefficient, 0.5); in
      F.subtract (F.power (2.0, F.divide (z, half_co)), 1.0)
    end;

end;

1. For each light k affecting the instance o:
   1. If k is the first light in the set, set the blending functions to (BlendFunction.BLEND_ONE, BlendFunction.BLEND_ONE_MINUS_SOURCE_ALPHA). That is, the source color will be multiplied by 1 and the destination color will be multiplied by 1 - alpha. This has the effect of setting the overall "opacity" of the object for subsequent light contributions. If k is not the first light in the set, set the blending functions to (BlendFunction.BLEND_ONE, BlendFunction.BLEND_ONE). This is the standard additive blending used to sum light contributions.
   2. Render o, lit by k.

1. Calculate the bitangent vector B from the N and T vectors. This step is performed on a per-vertex basis (in the vertex shader).
2. Construct a 3x3 tangent → object matrix M from the (T, B, N) vectors. This step is performed on a per-fragment basis (in the fragment shader) using the interpolated vectors calculated in the previous step.
3. Sample a tangent space normal vector P from the current normal map.
4. Transform the vector P with the matrix M by calculating M * P, resulting in an object space normal vector Q.
5. Transform the vector Q to eye space, in the same manner that an ordinary per-vertex normal vector would be (using the 3x3 normal matrix).

module Reflection where

import qualified Vector3f as V3

reflection :: V3.T -> V3.T -> V3.T
reflection v0 v1 = V3.sub3 v0 (V3.scale v1 (2.0 * (V3.dot3 v1 v0)))

module LightDiffuse where

import qualified Color3
import qualified Direction
import qualified Normal
import qualified Spaces
import qualified Vector3f

diffuse ::  Direction.T Spaces.Eye -> Normal.T -> Color3.T -> Float -> Vector3f.T
diffuse stl n light_color light_intensity =
  let 
    factor       = max 0.0 (Vector3f.dot3 stl n)
    light_scaled = Vector3f.scale light_color light_intensity
  in 
    Vector3f.scale light_scaled factor

module LightSpecular where

import qualified Color3
import qualified Direction
import qualified Normal
import qualified Reflection
import qualified Spaces
import qualified Specular
import qualified Vector3f

specular :: Direction.T Spaces.Eye -> Direction.T Spaces.Eye -> Normal.T -> Color3.T -> Float -> Specular.T -> Vector3f.T
specular stl view n light_color light_intensity (Specular.S surface_spec surface_exponent) =
  let 
    reflection   = Reflection.reflection view n
    factor       = (max 0.0 (Vector3f.dot3 reflection stl)) ** surface_exponent
    light_raw    = Vector3f.scale light_color light_intensity
    light_scaled = Vector3f.scale light_raw factor
  in 
    Vector3f.mult3 light_scaled surface_spec

module Attenuation where

attenuation_from_inverses :: Float -> Float -> Float -> Float
attenuation_from_inverses inverse_maximum_range inverse_falloff distance =
  max 0.0 (1.0 - (distance * inverse_maximum_range) ** inverse_falloff)

attenuation :: Float -> Float -> Float -> Float
attenuation maximum_range falloff distance =
  attenuation_from_inverses (1.0 / maximum_range) (1.0 / falloff) distance

• KLightDirectional - a directional light.
• KLightDirectionalDiffuseOnly - a diffuse-only variant of the standard directional light.

module Directional where

import qualified Color4
import qualified Direction
import qualified LightDirectional
import qualified LightDiffuse
import qualified LightSpecular
import qualified Normal
import qualified Position3
import qualified Spaces
import qualified Specular
import qualified Vector3f
import qualified Vector4f

directional :: Direction.T Spaces.Eye -> Normal.T -> Position3.T Spaces.Eye -> LightDirectional.T -> Specular.T -> Color4.T -> Vector3f.T
directional view n position light specular (Vector4f.V4 sr sg sb _) =
  let
    stl             = Vector3f.normalize (Vector3f.negation position)
    light_color     = LightDirectional.color light
    light_intensity = LightDirectional.intensity light
    light_d         = LightDiffuse.diffuse stl n light_color light_intensity
    light_s         = LightSpecular.specular stl view n light_color light_intensity specular
    lit_d           = Vector3f.mult3 (Vector3f.V3 sr sg sb) light_d
    lit_s           = Vector3f.add3 lit_d light_s
  in
    lit_s

• KLightSphereWithoutShadow - a spherical light that does not cast shadows.
• KLightSphereWithoutShadowDiffuseOnly - a spherical light that does not cast shadows and does not cause specular highlights.
• KLightSphereTexturedCubeWithoutShadow - a spherical light that does not cast shadows, with an additional color term sampled from an associated cube map.

module Spherical where

import qualified Attenuation
import qualified Color4
import qualified Direction
import qualified LightDiffuse
import qualified LightSpecular
import qualified LightSpherical
import qualified Normal
import qualified Position3
import qualified Specular
import qualified Spaces
import qualified Vector3f
import qualified Vector4f

spherical :: Direction.T Spaces.Eye -> Normal.T -> Position3.T Spaces.Eye -> LightSpherical.T -> Specular.T -> Color4.T -> Vector3f.T
spherical view n surface_position light specular (Vector4f.V4 sr sg sb _) =
  let
    position_diff   = Position3.sub3 surface_position (LightSpherical.origin light)
    stl             = Vector3f.normalize (Vector3f.negation position_diff)
    distance        = Vector3f.magnitude (position_diff)
    attenuation     = Attenuation.attenuation (LightSpherical.radius light) (LightSpherical.falloff light) distance
    light_color     = LightSpherical.color light
    light_intensity = LightSpherical.intensity light
    light_d         = LightDiffuse.diffuse stl n light_color light_intensity
    light_s         = LightSpecular.specular stl view n light_color light_intensity specular
    light_da        = Vector3f.scale light_d attenuation
    light_sa        = Vector3f.scale light_s attenuation
    lit_d           = Vector3f.mult3 (Vector3f.V3 sr sg sb) light_da
    lit_s           = Vector3f.add3 lit_d light_sa
  in 
    lit_s

• KLightProjectiveWithoutShadow - a projective light that does not project shadows.
• KLightProjectiveWithoutShadowDiffuseOnly - a projective light that does not project shadows, and does not cause specular highlights.
• KLightProjectiveWithShadowBasic - a projective light that projects basic shadows.
• KLightProjectiveWithShadowBasicDiffuseOnly - a projective light that projects basic shadows, and does not cause specular highlights.
• KLightProjectiveWithShadowVariance - a projective light that projects variance shadows.
• KLightProjectiveWithShadowVarianceDiffuseOnly - a projective light that projects variance shadows, and does not cause specular highlights.

module Projective where

import qualified Attenuation
import qualified Color3
import qualified Color4
import qualified Direction
import qualified LightDiffuse
import qualified LightSpecular
import qualified LightProjective
import qualified Normal
import qualified Position3
import qualified Specular
import qualified Spaces
import qualified Vector3f
import qualified Vector4f

projective :: Direction.T Spaces.Eye -> Normal.T -> Position3.T Spaces.Eye -> LightProjective.T -> Specular.T -> Float -> Color3.T -> Color4.T -> Vector3f.T
projective view n surface_position light specular shadow texture (Vector4f.V4 sr sg sb _) =
  let
    position_diff   = Position3.sub3 surface_position (LightProjective.origin light)
    stl             = Vector3f.normalize (Vector3f.negation position_diff)
    distance        = Vector3f.magnitude (position_diff)
    attenuation_raw = Attenuation.attenuation (LightProjective.radius light) (LightProjective.falloff light) distance
    attenuation     = attenuation_raw * shadow
    light_color     = Vector3f.mult3 (LightProjective.color light) texture
    light_intensity = LightProjective.intensity light
    light_d         = LightDiffuse.diffuse stl n light_color light_intensity
    light_s         = LightSpecular.specular stl view n light_color light_intensity specular
    light_da        = Vector3f.scale light_d attenuation
    light_sa        = Vector3f.scale light_s attenuation
    lit_d           = Vector3f.mult3 (Vector3f.V3 sr sg sb) light_da
    lit_s           = Vector3f.add3 lit_d light_sa
  in 
    lit_s

module ProjectiveMatrix where

import qualified Matrix4f

projective_matrix :: Matrix4f.T -> Matrix4f.T -> Matrix4f.T -> Matrix4f.T
projective_matrix camera_view light_view light_projection =
  case Matrix4f.inverse camera_view of
    Just cv -> Matrix4f.mult (Matrix4f.mult light_projection light_view) cv
    Nothing -> undefined -- A view matrix is always invertible

module ShadowVarianceChebyshev0 where

chebyshev :: (Float, Float) -> Float -> Float
chebyshev (d, ds) t =
  let p        = if t <= d then 1.0 else 0.0
      variance = ds - (d * d)
      du       = t - d
      p_max    = variance / (variance + (du * du))
  in max p p_max

factor :: (Float, Float) -> Float -> Float
factor = chebyshev

module ShadowVarianceChebyshev1 where

data T = T {
  minimum_variance :: Float
} deriving (Eq, Show)

chebyshev :: (Float, Float) -> Float -> Float -> Float
chebyshev (d, ds) min_variance t =
  let p        = if t <= d then 1.0 else 0.0
      variance = max (ds - (d * d)) min_variance
      du       = t - d
      p_max    = variance / (variance + (du * du))
  in max p p_max

factor :: T -> (Float, Float) -> Float -> Float
factor shadow (d, ds) t =
  chebyshev (d, ds) (minimum_variance shadow) t

module ShadowVarianceChebyshev2 where

data T = T {
  minimum_variance :: Float,
  bleed_reduction  :: Float
} deriving (Eq, Show)

chebyshev :: (Float, Float) -> Float -> Float -> Float
chebyshev (d, ds) min_variance t =
  let p        = if t <= d then 1.0 else 0.0
      variance = max (ds - (d * d)) min_variance
      du       = t - d
      p_max    = variance / (variance + (du * du))
  in max p p_max

clamp :: Float -> (Float, Float) -> Float
clamp x (lower, upper) = max (min x upper) lower

linear_step :: Float -> Float -> Float -> Float
linear_step lower upper x = clamp ((x - lower) / (upper - lower)) (0.0, 1.0)

factor :: T -> (Float, Float) -> Float -> Float
factor shadow (d, ds) t =
  let u = chebyshev (d, ds) (minimum_variance shadow) t in
    linear_step (bleed_reduction shadow) 1.0 u

• Make a temporary copy b of the current scene's color buffer.
• If masking is enabled for the material, render a mask for the instance into a temporary mask image m.
• Render the instance, using b as the refraction source, material-dependent refraction vectors, a refraction color, and optionally m for masking.

module FogFactorZ where

clamp :: Float -> (Float, Float) -> Float
clamp x (lower, upper) = max (min x upper) lower

fog_factor :: Float -> (Float, Float) -> Float
fog_factor z (near, far) =
  let r = (z - near) / (far - near) in
    clamp r (0.0, 1.0)

module FogFactorY where

clamp :: Float -> (Float, Float) -> Float
clamp x (lower, upper) = max (min x upper) lower

fog_factor :: Float -> (Float, Float) -> Float
fog_factor y (lower, upper) =
  let r = (y - lower) / (upper - lower) in
    clamp r (0.0, 1.0)