Parallax Occlusion Mapping – Advances in shader land

Today was cool… at least the first part of it was, before I spend 5 hours tracking down a bug in some of the game code.

I stumbled onto a pretty cool little article geared towards a very awesome technique called “parallax occlusion mapping”. This is essentially bump mapping with some extra samples taken at each pixel to provide a realistic depth (or parallax) effect to the surface. This provides the illusion of realistic surface detail all while shading a single polygon. The article was somewhat dated and targeted for Direct3D instead of OpenGL, but I was able to port it over to GLSL 150 for OpenGL 3.2.

Here’s the original article:
http://www.gamedev.net/page/resources/_/technical/graphics-programming-and-theory/a-closer-look-at-parallax-occlusion-mapping-r3262

And here’s my port of the shader code for anyone who is interested.

in highp vec4 position;
in mediump vec3 normal;
in mediump vec2 texcoord0;
in mediump vec3 tangent;

out mediump vec2 va_texcoord;

out mediump vec3 va_eye;
out mediump vec3 va_normal2;
out mediump vec3 va_light;

uniform mat4 modelViewProjectionMatrix;
uniform mediump mat4 modelViewMatrix;
uniform mat4 modelMatrix;
uniform mat4 modelMatrixInverse;
uniform mediump vec2 textureScale;
uniform mediump vec2 bumpScale;
uniform mediump mat3 normalMatrix;
uniform float shadowBiasFactor;
uniform vec3 cameraPosition;

uniform bool doNormalize;

#define LIGHT    4

struct Light
{
  mediump vec4 worldPosition;
};

#ifdef GL_ES
highp mat3 transpose(in highp mat3 inMatrix) 
{
  highp vec3 i0 = inMatrix[0];
  highp vec3 i1 = inMatrix[1];
  highp vec3 i2 = inMatrix[2];
  //highp vec4 i3 = inMatrix[3];

  highp mat3 outMatrix = mat3(
                 vec3(i0.x, i1.x, i2.x),
                 vec3(i0.y, i1.y, i2.y),
                 vec3(i0.z, i1.z, i2.z)
                 );
  return outMatrix;
}
#endif

uniform Light lights[8];

void main()
{
  vec3 P = (modelMatrix * position).xyz;
  vec3 N = normal;
  vec3 E = P - cameraPosition;
  vec3 L = -lights[LIGHT].worldPosition.xyz - P;

  //Compute transformed normal
  vec3 eyeNormal = normalize(normalMatrix * normal);

  //Pass transformed texcoord.
  va_texcoord = texcoord0*textureScale;

  vec4 nNormal = vec4(normalize(normal), 0.0);
  vec4 nTangent = vec4(normalize(tangent), 0.0);
  vec4 nBinormal = vec4(cross(nNormal.xyz, nTangent.xyz), 0.0);
  mat3 tangentToWorldSpace;
  tangentToWorldSpace[0] = (modelMatrix * nTangent).xyz;
  tangentToWorldSpace[1] = (modelMatrix * nBinormal).xyz;
  tangentToWorldSpace[2] = (modelMatrix * nNormal).xyz;

  mat3 worldToTangentSpace = transpose(tangentToWorldSpace);

  va_eye = E * worldToTangentSpace;
  va_normal2 = N * worldToTangentSpace;
  va_light = L * worldToTangentSpace;

  //Pass GL-transformed to vertex down pipeline
  gl_Position = modelViewProjectionMatrix * position;
}

in highp vec4 position;

in mediump vec3 normal;

in mediump vec2 texcoord0;

in mediump vec3 tangent;

out mediump vec2 va_texcoord;

out mediump vec3 va_eye;

out mediump vec3 va_normal2;

out mediump vec3 va_light;

uniform mat4 modelViewProjectionMatrix;

uniform mediump mat4 modelViewMatrix;

uniform mat4 modelMatrix;

uniform mat4 modelMatrixInverse;

uniform mediump vec2 textureScale;

uniform mediump vec2 bumpScale;

uniform mediump mat3 normalMatrix;

uniform float shadowBiasFactor;

uniform vec3 cameraPosition;

uniform bool doNormalize;

#define LIGHT 4

struct Light

{

mediump vec4 worldPosition;

};

#ifdef GL_ES

highp mat3 transpose(in highp mat3 inMatrix)

{

highp vec3 i0 = inMatrix[0];

highp vec3 i1 = inMatrix[1];

highp vec3 i2 = inMatrix[2];

//highp vec4 i3 = inMatrix[3];

highp mat3 outMatrix = mat3(

vec3(i0.x, i1.x, i2.x),

vec3(i0.y, i1.y, i2.y),

vec3(i0.z, i1.z, i2.z)

);

return outMatrix;

}

#endif

uniform Light lights[8];

void main()

{

vec3 P = (modelMatrix * position).xyz;

vec3 N = normal;

vec3 E = P - cameraPosition;

vec3 L = -lights[LIGHT].worldPosition.xyz - P;

//Compute transformed normal

vec3 eyeNormal = normalize(normalMatrix * normal);

//Pass transformed texcoord.

va_texcoord = texcoord0*textureScale;

vec4 nNormal = vec4(normalize(normal), 0.0);

vec4 nTangent = vec4(normalize(tangent), 0.0);

vec4 nBinormal = vec4(cross(nNormal.xyz, nTangent.xyz), 0.0);

mat3 tangentToWorldSpace;

tangentToWorldSpace[0] = (modelMatrix * nTangent).xyz;

tangentToWorldSpace[1] = (modelMatrix * nBinormal).xyz;

tangentToWorldSpace[2] = (modelMatrix * nNormal).xyz;

mat3 worldToTangentSpace = transpose(tangentToWorldSpace);

va_eye = E * worldToTangentSpace;

va_normal2 = N * worldToTangentSpace;

va_light = L * worldToTangentSpace;

//Pass GL-transformed to vertex down pipeline

gl_Position = modelViewProjectionMatrix * position;

}

#ifdef GL_ES
#extension GL_OES_standard_derivatives : require
#extension GL_EXT_shader_texture_lod : require
#endif

precision mediump float; 

in mediump vec2 va_texcoord;
in mediump vec4 ec_pos;

in mediump vec3 va_eye;
in mediump vec3 va_normal2;
in mediump vec3 va_light;

out vec4 fragColor;

#define LIGHT    4

//Prototypes
vec4 computeLight(in mediump vec3 normal, in mediump vec4 ecPosition, in lowp float alphaFade, out lowp vec4 otherSideColor, out lowp vec4 secondaryHighlight);

//Lights
struct Light
{
  mediump vec4 worldPosition;
};

uniform vec3 cameraPosition;
uniform Light lights[8];
uniform vec4 lightModelProductSceneColor;
uniform lowp sampler2D texture0;
uniform sampler2D bumpTexture;
uniform sampler2D heightTexture;

//uniform bool lightingEnabled;

const float fHeightMapScale = 0.02;
const int nMaxSamples = 32;
const int nMinSamples = 8;

void main()
{
  // Calculate the geometric surface normal vector, the vector from
  // the viewer to the fragment, and the vector from the fragment
  // to the light.
  vec3 N = normalize(va_normal2);
  vec3 E = normalize(va_eye);
  vec3 L = normalize(va_light);

  float fParallaxLimit = -length( va_eye.xy ) / va_eye.z;
  fParallaxLimit *= -fHeightMapScale;

  vec2 vOffsetDir = normalize(va_eye.xy);
  vec2 vMaxOffset = vOffsetDir * fParallaxLimit;

  int nNumSamples = int(mix(float(nMaxSamples), float(nMinSamples), dot(E, N)));
  float fStepSize = 1.0 / float(nNumSamples);

  vec2 dx = dFdx(va_texcoord);
  vec2 dy = dFdy(va_texcoord);

  float fCurrRayHeight = 1.0;
  vec2 vCurrOffset = vec2(0.0);
  vec2 vLastOffset = vec2(0.0);

  float fLastSampledHeight = 1.0;
  float fCurrSampledHeight = 1.0;

  int nCurrSample = 0;

  while(nCurrSample < nNumSamples)
  {
    fCurrSampledHeight = textureGrad(heightTexture, va_texcoord+vCurrOffset, dx, dy).r;
    if(fCurrSampledHeight > fCurrRayHeight)
    {
      float delta1 = fCurrSampledHeight - fCurrRayHeight;
      float delta2 = ( fCurrRayHeight + fStepSize ) - fLastSampledHeight;

      float ratio = delta1/(delta1+delta2);

      vCurrOffset = (ratio) * vLastOffset + (1.0-ratio) * vCurrOffset;

      nCurrSample = nNumSamples + 1;
    }
    else
    {
      nCurrSample++;

      fCurrRayHeight -= fStepSize;

      vLastOffset = vCurrOffset;
      vCurrOffset += fStepSize * vMaxOffset;

      fLastSampledHeight = fCurrSampledHeight;
    }
  }

  vec2 vFinalCoords = va_texcoord + vCurrOffset;
  vec4 vFinalNormal = texture(bumpTexture, va_texcoord + vCurrOffset);
  lowp vec4 vFinalColor = texture(texture0, vFinalCoords); //vec4(1.0);

  vFinalNormal = vFinalNormal * 2.0 - 1.0;

  vec3 vAmbient = vFinalColor.rgb * 0.1;
  vec3 vDiffuse = vFinalColor.rgb * max( 0.0, dot( L, vFinalNormal.xyz ) ) * 0.5;

  vFinalColor.rgb = vAmbient + vDiffuse;

  fragColor = vFinalColor;
}

100

101

102

103

104

105

106

107

108

109

110

#ifdef GL_ES

#extension GL_OES_standard_derivatives : require

#extension GL_EXT_shader_texture_lod : require

#endif

precision mediump float;

in mediump vec2 va_texcoord;

in mediump vec4 ec_pos;

in mediump vec3 va_eye;

in mediump vec3 va_normal2;

in mediump vec3 va_light;

out vec4 fragColor;

#define LIGHT 4

//Prototypes

vec4 computeLight(in mediump vec3 normal, in mediump vec4 ecPosition, in lowp float alphaFade, out lowp vec4 otherSideColor, out lowp vec4 secondaryHighlight);

//Lights

struct Light

{

mediump vec4 worldPosition;

};

uniform vec3 cameraPosition;

uniform Light lights[8];

uniform vec4 lightModelProductSceneColor;

uniform lowp sampler2D texture0;

uniform sampler2D bumpTexture;

uniform sampler2D heightTexture;

//uniform bool lightingEnabled;

const float fHeightMapScale = 0.02;

const int nMaxSamples = 32;

const int nMinSamples = 8;

void main()

{

// Calculate the geometric surface normal vector, the vector from

// the viewer to the fragment, and the vector from the fragment

// to the light.

vec3 N = normalize(va_normal2);

vec3 E = normalize(va_eye);

vec3 L = normalize(va_light);

float fParallaxLimit = -length( va_eye.xy ) / va_eye.z;

fParallaxLimit *= -fHeightMapScale;

vec2 vOffsetDir = normalize(va_eye.xy);

vec2 vMaxOffset = vOffsetDir * fParallaxLimit;

int nNumSamples = int(mix(float(nMaxSamples), float(nMinSamples), dot(E, N)));

float fStepSize = 1.0 / float(nNumSamples);

vec2 dx = dFdx(va_texcoord);

vec2 dy = dFdy(va_texcoord);

float fCurrRayHeight = 1.0;

vec2 vCurrOffset = vec2(0.0);

vec2 vLastOffset = vec2(0.0);

float fLastSampledHeight = 1.0;

float fCurrSampledHeight = 1.0;

int nCurrSample = 0;

while(nCurrSample < nNumSamples)

{

fCurrSampledHeight = textureGrad(heightTexture, va_texcoord+vCurrOffset, dx, dy).r;

if(fCurrSampledHeight > fCurrRayHeight)

{

float delta1 = fCurrSampledHeight - fCurrRayHeight;

float delta2 = ( fCurrRayHeight + fStepSize ) - fLastSampledHeight;

float ratio = delta1/(delta1+delta2);

vCurrOffset = (ratio) * vLastOffset + (1.0-ratio) * vCurrOffset;

nCurrSample = nNumSamples + 1;

}

else

{

nCurrSample++;

fCurrRayHeight -= fStepSize;

vLastOffset = vCurrOffset;

vCurrOffset += fStepSize * vMaxOffset;

fLastSampledHeight = fCurrSampledHeight;

}

vec2 vFinalCoords = va_texcoord + vCurrOffset;

vec4 vFinalNormal = texture(bumpTexture, va_texcoord + vCurrOffset);

lowp vec4 vFinalColor = texture(texture0, vFinalCoords); //vec4(1.0);

vFinalNormal = vFinalNormal * 2.0 - 1.0;

vec3 vAmbient = vFinalColor.rgb * 0.1;

vec3 vDiffuse = vFinalColor.rgb * max( 0.0, dot( L, vFinalNormal.xyz ) ) * 0.5;

vFinalColor.rgb = vAmbient + vDiffuse;

fragColor = vFinalColor;

}

Some of this code is “massaged” by Verto Studio’s code converter when ran on mobile. It’s definitely a pretty cool effect! It requires 3 texture maps to work currently, a standard diffuse (color texture) map, a normal map, and a displacement or height map. Lucky for me, there’s a sick little program called “crazy bump” for mac that can generate both normal maps and displacement maps from any standard diffuse texture map!

WebGL demo

For those who want to see the shader effect in action, I got a WebGL demo which runs on chrome and safari (firefox and IE don’t work).

It’s an expensive effect however, so I’m not sure yet if I can work it in for Driveby Gangster. Either way, it’ll definitely be a nice little addition to the shader arsenal. If I do actually put it into use, I hope to eventually add self-shadowing effects as well.

What I’ve been doing

Leave a reply

Tons of stuff has been accomplished as of late. I’ll just list a few of em here.

I programmed a cool “breaking glass” shader for the street scene shop window so that when you shoot at it, it breaks
I made a “spark” particle shader for when you shoot at metal, and also programmed separate bullethole decals to appear depending on the surface you strike.
I bit the bullet and grabbed maya for finishing up some of the character animation stuff including animations for aiming the gun and getting hit by bullets
I started on and nearly finished a very awesome “beach” scene for the game. This broke one of my cardinal rules about keeping the stuff simple, but I’m accepting the risk because a game with the same level over and over again is a pretty bad user experience.

I apologize again for the lack of quality updates on here, but I’ve definitely been prioritizing working on and finishing the game over keeping this blog up to date. It’s a tradeoff I guess.

For the beach scene I modeled a cool sailboat for it entirely from scratch using verto. I have big plans for this sailboat that I’m going to keep secret for now.

One thing that I’m really excited about was a small effort that took me two days. I managed to compile the entire C++ code base to JS using emscripten. This means that I can display simple verto studio scenes in the web browser! A quick demo of this, for people running on webgl enabled browsers, should display below…

Another youtube series

Leave a reply

I’ve done so much since my last update. I have a bunch of screenshots on my desktop just waiting to be uploaded here. I’ll try to submit a “real” update this weekend.

I just wanted to post to mention that I have uploaded a new tutorial series on YouTube regarding learning shader programming! The playlist for the series is here: https://www.youtube.com/playlist?list=PLT6WFYYZE6uJco3V9_Ssq2VPRIXCPUEsE

The swift code is ported!

Leave a reply

Finally done the porting of where I was when I left off on the swift side!

Commiting this code and ready to resume actual game development!

Free the code

Leave a reply

One of the reasons why love game programming so much is that it forces you to do things that would otherwise seem quite ridiculous. I have always liked to shoot first and ask questions later when it comes to implementing an idea. Sometimes it’ll just pop in my head and then I will start working on it and before I know it…it’s done. The last week and a half has been more work than I ever wanted to do but the result is awesome. A very large portion of my entire Verto Studio graphics engine and code base has now been rewritten in C++ and is now portable to any operating system.

This means I can now load and render my Verto Studio files on Windows, Linux, anything I want without any strict dependencies on Mac anymore. As a game developer, this is an awesome feeling and I am beyond stoked. I worked very hard on the Verto Studio tech over the last three years and to finally free it from OSX/iOS is great.

I’ve moved on the actual swift code of the in-progress Driveby Gangster Game project and hopefully I’ll have that done soon next week. All-in-all I’d say the extra week of work was definitely worth it.

Screens!!

Leave a reply

Too much talk about code lately on here.

Here’s some latest screenshots. Before my decision to switch languages, I completely finished off the “practice mode”

I also recorded a gif during my testing with the bullet collision detection against arbitrary polygons in the scene.

Swift is fired

Leave a reply

So it had to happen…

The more I work on this game the more I realize that I kind of like it… and that means there’s certain things need to change. For starters, it’s definitely running longer than I expected it to (the original two-week estimate now sounds pretty “out there”). For this reason, I need to shave down on the programming time. It has become pretty obvious to me that for every 1/2 hour that I spend writing code in swift for this game, 10 minutes of it is spent screwing around with the language and that is friction then I can no longer accept. So I’m dropping swift for this game.

Since I’m switching languages and I’m going to be rewriting some code, I decided to open things up quite a bit and go back to C++. It’s going to cost me roughly a week or two to rewrite things, but the benefit is going to be huge. For starters, since this game depended on my very large and very complicated Objective-C graphics engine (Verto Studio), I now have the “opportunity” to continue rewriting all of this code in C++ (this was originally started on my github as VGLPP). This means that this game and any other game that I want to use with the ported engine will be able to run on ANY platform including windows. This is a major win for me since making a game for OSX/iOS only isn’t really that smart. I’ve been wanting to do this for awhile and my frustrations with swift finally pushed me to do it.

So that’s what I’m going to be up to for awhile. As I’ve mentioned on twitter, I’ll be streaming roughly twice a week on my twitch channel for anyone who is curiuos about the process and wants to follow along. http://twitch.tv/vertostudio3d

I’ve already gotten quite a bit done and have surpassed my biggest barrier for doing this which was finding a reasonable way to parse verto studio files (spat out by NSKeyedArchiver/NSCoder objective-c mechanisms) in a portable way in C++. TinyXML and a little of reverse engineering did the trick.

With respect to all of the “benefits” swift and Objective C were providing over a lower level language such as C++, I’ve essentially found a reasonable replacement for each one thanks to C++11′s new features.

Basic Outline of Porting to C++

Swift/Objc	C++11
Strong Pointer (Reference Counting)	std::shared_ptr
Weak Pointer (Reference Counting)	std::weak_ptr
Blocks & Closures	Lambda Functions
Protocols	Multiple Inheritence
Dynamic Typechecking via “isKindOfClass”	C++ typeid / RTTI

So you get the idea, nothings really out of reach with C++. It’s still more annoying and I’m not 100% thrilled with dealing with things like templates, header files and verbose syntax again, but I’ll take it over an unstable language any day.

Lots of code… lots

Leave a reply

I’ve been less active on here because I’ve been writing quite a bit of code. Like I said previously, I’m in the main swing of developing this game. This is where things start to get crazy. Namely, I’ve added quite a bit of classes to the project to handle everything from basic collisions and 3D math extensions to generating and displaying 3D text on the screen. I feel like (despite my previous post regarding Swift) things are keeping organized quite well and I haven’t strayed too far from my original architecture plan. I’ve spent most of my time working on the PracticeGameStateRunner class which runs the “Target Practice” initial level in the game. This mini level serves as a point for the player to learn the very simple controls and game mechanics of the game… and it’s serving excellently as a sandbox for me to test these all during development as well.

I’ll cover just a few pieces of code today to show the changes that I’ve made regarding the game State Runner protocol, and some cool stuff that I’ve been able to do with “smart” enums in swift. There’s a lot more I can talk about that I don’t want this post to go on forever.

Some Code

State runner protocol. Now I have some stuff in there to quickly respond to “game controller” and mouse events, all stemming from the game loop class.

//
//  GameState.swift
//  Gangster Driveby
//
//  Created by Mike Farrell on 10/15/14.
//  Copyright (c) 2014 Mike Farrell. All rights reserved.
//

import Foundation

protocol GameStateRunner
{
  func processLogic(#delta: Float)
  func processEvents()
  func render()

  func keyDown(keysym: SDL_Keycode)
  func keyUp(keysym: SDL_Keycode)
  func mouseMoved(event: SDL_MouseMotionEvent)
  func mouseDown(event: SDL_MouseButtonEvent)
  func mouseUp(event: SDL_MouseButtonEvent)

  func joystickDown(controllerButton button: GangsterGameLoop.ControllerButton)
  func joystickUp(controllerButton button: GangsterGameLoop.ControllerButton)
}

// GameState.swift

// Gangster Driveby

// Created by Mike Farrell on 10/15/14.

import Foundation

protocol GameStateRunner

{

func processLogic(#delta: Float)

func processEvents()

func render()

func keyDown(keysym: SDL_Keycode)

func keyUp(keysym: SDL_Keycode)

func mouseMoved(event: SDL_MouseMotionEvent)

func mouseDown(event: SDL_MouseButtonEvent)

func mouseUp(event: SDL_MouseButtonEvent)

func joystickDown(controllerButton button: GangsterGameLoop.ControllerButton)

func joystickUp(controllerButton button: GangsterGameLoop.ControllerButton)

}

Mesh Line Collider – a badly needed construct to determine whether or not a bullet-trajectory would intersect a polygonal mesh in the scene or not (and if so where). I tried porting this over to ObjC before swift and it was a nitemare. Swift’s version is definitely simpler thanks to operator overloading and multiple return values. Note the unsafe pointer craziness in swift which is considerably easier to deal with in C. (ported from http://geomalgorithms.com/a06-_intersect-2.html)

//
//  MeshLineCollider.swift
//  Gangster Driveby
//
//  Created by Mike Farrell on 10/30/14.
//  Copyright (c) 2014 Mike Farrell. All rights reserved.
//

import Foundation

class MeshLineCollider
{
  weak var entity: Entity!
  var boundingBoxCollider: MeshLineCollider?
  let verts: GrowableArray
  let faceIndices: GrowableArray

  init(meshEntity: Entity)
  {
    entity = meshEntity

    verts = entity.editVerts.mutableCopy() as GrowableArray
    entity.applyTransformToVerts(verts, andNorms: nil)

    let s: SubMesh = entity.submeshes[0] as SubMesh
    faceIndices = s.editInds.mutableCopy() as GrowableArray

    generateBoundingBoxCollider()
  }

  init(verts: GrowableArray, faces: GrowableArray)
  {
    self.verts = verts
    faceIndices = faces
    boundingBoxCollider = nil
  }

  convenience init(var verts: [float3], var faces: [uint3])
  {
    let vBuffer = UnsafeMutableBufferPointer(start: &verts, count: verts.count)
    let vgArray = GrowableArray(data: vBuffer.baseAddress, ofSize: Int32(verts.count), andElementSize:Int32(sizeof(float3)), andExtraCapacity: 0)

    let fBuffer =  UnsafeMutableBufferPointer<uint3>(start: &faces, count: faces.count)
    let fArray = GrowableArray(data: fBuffer.baseAddress, ofSize: Int32(faces.count*3), andElementSize:Int32(sizeof(uint)), andExtraCapacity: 0)

    self.init(verts: vgArray, faces: fArray)
  }

  private final func split(quad: uint4) -> (uint3, uint3)
  {
    return (uint3(x: quad.x, y: quad.y, z: quad.w), uint3(x: quad.w, y: quad.y, z: quad.z))
  }

  private func generateBoundingBoxCollider()
  {
    var bbSize = float3.zero
    entity.getBBox(&bbSize)

    let box = Box3D(dimensions: bbSize, andPosition: float3.zero)
    let boxVerts = box.generateVertices()
    entity.applyTransformToVerts(boxVerts, andNorms: nil)

    var boxInds: [uint4] = [ ]

    boxInds.append(uint4(x: 0, y: 1, z: 2, w: 3))
    boxInds.append(uint4(x: 0, y: 4, z: 5, w: 1))
    boxInds.append(uint4(x: 2, y: 6, z: 7, w: 3))
    boxInds.append(uint4(x: 3, y: 7, z: 4, w: 0))
    boxInds.append(uint4(x: 1, y: 5, z: 6, w: 2))
    boxInds.append(uint4(x: 4, y: 5, z: 6, w: 7))

    var triangles: [uint3] = [ ]
    for quad in boxInds
    {
      let spl = split(quad)
      triangles.append(spl.0)
      triangles.append(spl.1)
    }

    let fBuffer = UnsafeMutableBufferPointer<uint3>(start: &triangles, count: triangles.count)
    let fArray = GrowableArray(data: fBuffer.baseAddress, ofSize: Int32(triangles.count*3), andElementSize:Int32(sizeof(uint)), andExtraCapacity: 0)

    boundingBoxCollider = MeshLineCollider(verts: boxVerts, faces: fArray)
  }

  func debugRender()
  {
    if boundingBoxCollider != nil
    {
      boundingBoxCollider?.debugRender()
      return
    }

    glDisable(GL_CULL_FACE.e)
    glDepthRange(0.0, 0.9999);

    let vgl = VertoGLStateMachine.currentMachine()
    vgl.vertexPointerOfSize(3, type: GL_FLOAT.e, stride: 0, pointer: verts.data, bufferLength: GLsizeiptr(Int32(sizeof(float3))*verts.count))

    vgl.setPrimaryColor(makeFloat4(0.2, 0.2, 0.2, 1))
    vgl.prepareToDraw()

    vgl.drawElementsInMode(GL_TRIANGLES.e, andCount: GLsizei(faceIndices.count), type: GL_UNSIGNED_INT.e, indexPointer: faceIndices.data,
      bufferLength: GLsizeiptr(Int32(sizeof(uint))*faceIndices.count))

    glDepthRange(0.0, 1.0);
  }

  //MARK: - Collision with line

  func rayIntersection(rayOrigin ro: float3, rayDirection rd: float3, inout intersectionPoint: float3) -> IntersectionPoint?
  {
    if let bbox = boundingBoxCollider
    {
      if bbox.rayIntersection(rayOrigin: ro, rayDirection: rd, intersectionPoint: &intersectionPoint) == nil
      {
        return nil
      }
    }

    let pointSet = IntersectionPointSet()

    for i in 0..<faceIndices.count/3
    {
      let result = triangleIntersection(triangleIndex: Int(i), rayOrigin: ro, rayDirection: rd, intersectionPoint: &intersectionPoint)
      if result.0
      {
        pointSet.add(IntersectionPoint(distance: result.1, point: intersectionPoint))
      }
    }

    if !pointSet.empty()
    {
      return pointSet.nearest()
    }

    return nil
  }

  private func triangleIntersection(triangleIndex i: Int, rayOrigin ro: float3, rayDirection rd: float3, inout intersectionPoint ip: float3) -> (Bool, Float)
  {
    let smallNum: Float = 0.00000001
    var u: float3, v: float3, n: float3       // triangle vectors
    var dir: float3, w0: float3, w: float3    // ray vectors
    var r: Float, a: Float, b: Float          // params to calc ray-plane intersect

    let vData = UnsafeMutableBufferPointer<float3>(start: UnsafeMutablePointer<float3>(verts.data), count: Int(verts.count))
    let iData = UnsafeMutableBufferPointer<uint3>(start: UnsafeMutablePointer<uint3>(faceIndices.data), count: Int(faceIndices.count/3))

    let v0 = vData[Int(iData[i].x)], v1 = vData[Int(iData[i].y)], v2 = vData[Int(iData[i].z)]

    // get triangle edge vectors and plane normal
    u = v1 - v0
    v = v2 - v0
    n = u.cross(v)              // cross product
    if n == float3.zero          // triangle is degenerate
    {
      // do not deal with this case
      return (false, 0)
    }

    dir = rd
    w0 = ro - v0
    a = -n.dot(w0)
    b = n.dot(dir)
    if fabsf(b) < smallNum
    {
      return (false, 0)
    }

    // get intersect point of ray with triangle plane
    r = a / b
    if r < 0.0                    // ray goes away from triangle
    {
      return (false, 0)                   // => no intersect
    }
    // for a segment, also test if (r > 1.0) => no intersect

    // intersect point of ray and plane
    ip = ro + dir*r

    // is I inside T?
    var uu: Float, uv: Float, vv: Float, wu: Float, wv: Float, D: Float
    uu = u.dot(u)
    uv = u.dot(v)
    vv = v.dot(v)
    w = ip - v0
    wu = w.dot(u)
    wv = w.dot(v)
    D = uv * uv - uu * vv

    // get and test parametric coords
    var s: Float, t: Float
    s = (uv * wv - vv * wu) / D
    if s < 0.0 || s > 1.0         // I is outside T
    {
      return (false, 0)
    }
    t = (uv * wu - uu * wv) / D
    if t < 0.0 || (s + t) > 1.0  // I is outside T
    {
      return (false, 0)
    }

    return (true, r)                       // I is in T
  }

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

// MeshLineCollider.swift

// Gangster Driveby

// Created by Mike Farrell on 10/30/14.

import Foundation

class MeshLineCollider

{

weak var entity: Entity!

var boundingBoxCollider: MeshLineCollider?

let verts: GrowableArray

let faceIndices: GrowableArray

init(meshEntity: Entity)

{

entity = meshEntity

verts = entity.editVerts.mutableCopy() as GrowableArray

entity.applyTransformToVerts(verts, andNorms: nil)

let s: SubMesh = entity.submeshes[0] as SubMesh

faceIndices = s.editInds.mutableCopy() as GrowableArray

generateBoundingBoxCollider()

}

init(verts: GrowableArray, faces: GrowableArray)

{

self.verts = verts

faceIndices = faces

boundingBoxCollider = nil

}

convenience init(var verts: [float3], var faces: [uint3])

{

let vBuffer = UnsafeMutableBufferPointer(start: &verts, count: verts.count)

let vgArray = GrowableArray(data: vBuffer.baseAddress, ofSize: Int32(verts.count), andElementSize:Int32(sizeof(float3)), andExtraCapacity: 0)

let fBuffer = UnsafeMutableBufferPointer<uint3>(start: &faces, count: faces.count)

let fArray = GrowableArray(data: fBuffer.baseAddress, ofSize: Int32(faces.count*3), andElementSize:Int32(sizeof(uint)), andExtraCapacity: 0)

self.init(verts: vgArray, faces: fArray)

}

private final func split(quad: uint4) -> (uint3, uint3)

{

return (uint3(x: quad.x, y: quad.y, z: quad.w), uint3(x: quad.w, y: quad.y, z: quad.z))

}

private func generateBoundingBoxCollider()

{

var bbSize = float3.zero

entity.getBBox(&bbSize)

let box = Box3D(dimensions: bbSize, andPosition: float3.zero)

let boxVerts = box.generateVertices()

entity.applyTransformToVerts(boxVerts, andNorms: nil)

var boxInds: [uint4] = [ ]

boxInds.append(uint4(x: 0, y: 1, z: 2, w: 3))

boxInds.append(uint4(x: 0, y: 4, z: 5, w: 1))

boxInds.append(uint4(x: 2, y: 6, z: 7, w: 3))

boxInds.append(uint4(x: 3, y: 7, z: 4, w: 0))

boxInds.append(uint4(x: 1, y: 5, z: 6, w: 2))

boxInds.append(uint4(x: 4, y: 5, z: 6, w: 7))

var triangles: [uint3] = [ ]

for quad in boxInds

{

let spl = split(quad)

triangles.append(spl.0)

triangles.append(spl.1)

}

let fBuffer = UnsafeMutableBufferPointer<uint3>(start: &triangles, count: triangles.count)

let fArray = GrowableArray(data: fBuffer.baseAddress, ofSize: Int32(triangles.count*3), andElementSize:Int32(sizeof(uint)), andExtraCapacity: 0)

boundingBoxCollider = MeshLineCollider(verts: boxVerts, faces: fArray)

}

func debugRender()

{

if boundingBoxCollider != nil

{

boundingBoxCollider?.debugRender()

return

}

glDisable(GL_CULL_FACE.e)

glDepthRange(0.0, 0.9999);

let vgl = VertoGLStateMachine.currentMachine()

vgl.vertexPointerOfSize(3, type: GL_FLOAT.e, stride: 0, pointer: verts.data, bufferLength: GLsizeiptr(Int32(sizeof(float3))*verts.count))

vgl.setPrimaryColor(makeFloat4(0.2, 0.2, 0.2, 1))

vgl.prepareToDraw()

vgl.drawElementsInMode(GL_TRIANGLES.e, andCount: GLsizei(faceIndices.count), type: GL_UNSIGNED_INT.e, indexPointer: faceIndices.data,

bufferLength: GLsizeiptr(Int32(sizeof(uint))*faceIndices.count))

glDepthRange(0.0, 1.0);

}

//MARK: - Collision with line

func rayIntersection(rayOrigin ro: float3, rayDirection rd: float3, inout intersectionPoint: float3) -> IntersectionPoint?

{

if let bbox = boundingBoxCollider

{

if bbox.rayIntersection(rayOrigin: ro, rayDirection: rd, intersectionPoint: &intersectionPoint) == nil

{

return nil

}

let pointSet = IntersectionPointSet()

for i in 0..<faceIndices.count/3

{

let result = triangleIntersection(triangleIndex: Int(i), rayOrigin: ro, rayDirection: rd, intersectionPoint: &intersectionPoint)

if result.0

{

pointSet.add(IntersectionPoint(distance: result.1, point: intersectionPoint))

}

if !pointSet.empty()

{

return pointSet.nearest()

}

return nil

}

private func triangleIntersection(triangleIndex i: Int, rayOrigin ro: float3, rayDirection rd: float3, inout intersectionPoint ip: float3) -> (Bool, Float)

{

let smallNum: Float = 0.00000001

var u: float3, v: float3, n: float3 // triangle vectors

var dir: float3, w0: float3, w: float3 // ray vectors

var r: Float, a: Float, b: Float // params to calc ray-plane intersect

let vData = UnsafeMutableBufferPointer<float3>(start: UnsafeMutablePointer<float3>(verts.data), count: Int(verts.count))

let iData = UnsafeMutableBufferPointer<uint3>(start: UnsafeMutablePointer<uint3>(faceIndices.data), count: Int(faceIndices.count/3))

let v0 = vData[Int(iData[i].x)], v1 = vData[Int(iData[i].y)], v2 = vData[Int(iData[i].z)]

// get triangle edge vectors and plane normal

u = v1 - v0

v = v2 - v0

n = u.cross(v) // cross product

if n == float3.zero // triangle is degenerate

{

// do not deal with this case

return (false, 0)

}

dir = rd

w0 = ro - v0

a = -n.dot(w0)

b = n.dot(dir)

if fabsf(b) < smallNum

{

return (false, 0)

}

// get intersect point of ray with triangle plane

r = a / b

if r < 0.0 // ray goes away from triangle

{

return (false, 0) // => no intersect

}

// for a segment, also test if (r > 1.0) => no intersect

// intersect point of ray and plane

ip = ro + dir*r

// is I inside T?

var uu: Float, uv: Float, vv: Float, wu: Float, wv: Float, D: Float

uu = u.dot(u)

uv = u.dot(v)

vv = v.dot(v)

w = ip - v0

wu = w.dot(u)

wv = w.dot(v)

D = uv * uv - uu * vv

// get and test parametric coords

var s: Float, t: Float

s = (uv * wv - vv * wu) / D

if s < 0.0 || s > 1.0 // I is outside T

{

return (false, 0)

}

t = (uv * wu - uu * wv) / D

if t < 0.0 || (s + t) > 1.0 // I is outside T

{

return (false, 0)

}

return (true, r) // I is in T

}

Cool little WIP controller button enum nested in the game loop class

  enum ControllerButton: Int
  {
    case Shoot = 9
    case Aim = 8

    var name: String
    {
      let buttonNames: [ControllerButton: String] = [ .Shoot: "Shoot", .Aim: "Aim" ]

      return buttonNames[self]!
    }

    var obj: NSNumber
    {
      return NSNumber(integer: self.rawValue)
    }
  }

enum ControllerButton: Int

{

case Shoot = 9

case Aim = 8

var name: String

{

let buttonNames: [ControllerButton: String] = [ .Shoot: "Shoot", .Aim: "Aim" ]

return buttonNames[self]!

}

var obj: NSNumber

{

return NSNumber(integer: self.rawValue)

}

Some Screens

More about swift…

1 Reply

Okay so when you use a language daily, you begin to really pick up some opinions and feelings about it that tend to really stick with you. With swift, I definitely have some of those.

Let me focus on just two… of the things that really irk me about the freaking swift language.

Number one – Casting

This is my number one gripe with the swift language. The compiler just wont shut the hell up and do what I was intending. Now I know that apple has designed the language to absolutely not allow any implicit casting, and I understand their reasons behind this, but man, you’ve taken one benefit, and added 10-fold the costs. Requiring explicit casting takes code in swift that should look extremely simple and adds about 3-4 explicit constructor-casts to it causing the code to display as bloated, confusing ill-intended crap. What really bothers me is that this is the case even for upgrading types such as assigning a float into a double. Another problem is that in the C world (all of the APIs that we work with on a daily basis) there might be 4 or 5 different integer types (int, Sint32, GLuint, etc) and multiple float types (GLfloat, float, CGFloat, etc). Casting between these in C/C++/Objc is completely harmless 99% of the time and therefore done implicitly. In swift, I have to pepper this code with constructor casts every, single, freaking time.

In C++, you could allow implicit types by overloading the constructor so that an expression such as int x = someFloat would be the same as a constructor for int that takes a float as an argument. Swift badly needs this.

For now I’ve gotten to the point where I’ve added very simple computed properties to the various types in swift to at least make some of this casting more painless. Just a few of those extensions are below.

//
//  CastingHelpers.swift
//  Gangster Driveby
//
//  Created by Mike Farrell on 10/27/14.
//  Copyright (c) 2014 Mike Farrell. All rights reserved.
//

import Foundation

//swift is driving me crazy
extension Int
{
  var f: Float
  {
    return Float(self)
  }
}

extension Int32
{
  var f: Float
  {
    return Float(self)
  }

  var e: GLenum
  {
    return GLenum(self)
  }

  /*func c<T: IntegerLiteralConvertible>() -> T
  {
    return T(integerLiteral: i)
  }*/
}

extension Sint16
{
  var f: Float
  {
    return Float(self)
  }
}

extension UInt
{
  var f: Float
  {
    return Float(self)
  }
}

extension Double
{
  var f: Float
  {
    return Float(self)
  }
}

extension Float
{
  var cg: CGFloat
  {
    return CGFloat(self)
  }
}

// CastingHelpers.swift

// Gangster Driveby

// Created by Mike Farrell on 10/27/14.

import Foundation

//swift is driving me crazy

extension Int

{

var f: Float

{

return Float(self)

}

extension Int32

{

var f: Float

{

return Float(self)

}

var e: GLenum

{

return GLenum(self)

}

/*func c<T: IntegerLiteralConvertible>() -> T

{

return T(integerLiteral: i)

}*/

}

extension Sint16

{

var f: Float

{

return Float(self)

}

extension UInt

{

var f: Float

{

return Float(self)

}

extension Double

{

var f: Float

{

return Float(self)

}

extension Float

{

var cg: CGFloat

{

return CGFloat(self)

}

This makes it so that code that would have to look like

glDisable(GLEnum(GL_DEPTH_TEST))

let f: Float = 3.0
let f2 = f*Float(sin(0.5))

glDisable(GLEnum(GL_DEPTH_TEST))

let f: Float = 3.0

let f2 = f*Float(sin(0.5))

Can be…

glDisable(GL_DEPTH_TEST.e)

let f = (3.0).f
let f2 = f*sin(0.5).f

glDisable(GL_DEPTH_TEST.e)

let f = (3.0).f

let f2 = f*sin(0.5).f

Number two – Stability (source kit crashes)

Google swift and “sourcekit” and you’ll see, this is nowhere NEAR an actual finished language. Apple has rushed this out the door and I’m honestly sorry that I’ve decided to use it to make a game. Imagine typing code and then every half hour you get 30 seconds of a frozen spinner before ”sourcekit crashed” appears in your IDE. If you’re lucky, it’ll stop for another 5 minutes, but if you aren’t it’ll happen in a loop and you have to go delete your “ModuleCache” dir and quit and restart xcode and start working again…. until about an hour later. This is NOT how I prefer to work. I like the “idea” of swift, but its just way too unstable to use. I’m going to finish this game with it, and then probably stay away from swift for any real projects for another year or so until apple fixes this extremely annoying stability problem.

These two things may seem small, but they’re enough to waste 10 minutes of time for every hour I work on this game, and for me, that’s just completely unacceptable.

Its midnight..

Leave a reply

Recently worked alot of basic walking pattern AI for the bystander game objects, a practice range which will precede the first “day” (level) in the game, and some cool shader effects using particles for the gangster car kicking up dust while driving through the desert.

Too tired to describe more.

Pictures! Please forgive the quality of the video(s).

AI Walking Video

Parse Error

Michael L. Farrell's Game Dev Blog

Parallax Occlusion Mapping – Advances in shader land

WebGL demo

What I’ve been doing

Another youtube series

The swift code is ported!

Free the code

Screens!!

Swift is fired

Basic Outline of Porting to C++

Lots of code… lots

Some Code

Some Screens

More about swift…

Number one – Casting

Number two – Stability (source kit crashes)

Its midnight..