Games

3d games for the mobile platform published by Mad Processor.

Tasks included game/level design, tooling, modeling/texturing and art pipeline as well as marketing/publishing.

Parcel Panic 2

Crazy Taxi inspired game with a huge open-world island to explore, featuring bullet physics, 300K downloads

App Store

Motorblast

Mario Kart style fun racer with rockets, damage model and multiplayer, 1M downloads, top 1 in Games category in 9 countries, #14 in Games US

App Store

Uber Racer

Post-apocalyptic racer with configurable cars, 2.8M downloads, top 1 overall in 38 countries, US #2 overall, #1 in games

App Store

Procedural content

In-house game engine demo: Fully procedural landscape with OpenVDB done in houdini (mobile hardware)

Procedural grass in houdini

Idmask-based material generation in Substance Designer
(No painting was done)

Procedural game assets with scalable upgrade stages

Prop/weapon generator asset

Feather asset for texture generation

Ivy generator

Terrain generation

Live walking rig

City building
Any 2d shape produces a house according to ajustable rules. This can form the basis for further refinements and customization.


No city without a tilt shift shot:

Previz level

Adaptively tesselated geometry makes up for backgrounds or skyboxes without using textures

Temporally and spatially seamless water generator (useful for water/lava animated normal/diffuse maps)

Simple realtime bird flocking in VEX/houdini

Modeling

Misc

Open Source client/server real time data graphing system
Stream any key/value from any source to visualize.

github page

in ~/.cargo/config you can switch to lld as a linker (needs to be installed of course):

[build]
rustflags = ["-C", "link-arg=-fuse-ld=lld"]

Linking often took the most of my time when just changing a small amount of code, so the above has a big impact on day-to-day work.

If you don't need debugging symbols often, you can add

[profile.dev]
debug = false

For your project. This can speed up compilation times.

use image::{ImageBuffer, Rgb};
fn main()
{
    let green = [0, 255, 0];
    let red = [255, 0, 0];

    let mut image = ImageBuffer::<Rgb<u8>, Vec<u8>>::new(200, 200);
    image.put_pixel(5,5, Rgb(green));
    image.save("output1.png");

    for i in 1..100 {
        image.put_pixel(i, 5, Rgb(red));
    }
    image.save("output2.png");

}

For quite some time, cmder and it's ecosystem seemed like the default.

Now there is a great new option: Alacritty. https://github.com/jwilm/alacritty

Below are some settings to make it more unix-like and setup some defaults.

Config file:

Your config file is in %APPDATA%/alacritty/alacritty.yml.

Getting CTRL-c to work:

If you have issues with command sequences such as ctrl-c, consider enabling the conpty backend.

Locate enable_experimental_conpty_backend in the config file and set it to true:

enable_experimental_conpty_backend: true

Set up color schemes:

Visit this page https://github.com/jwilm/alacritty/wiki/Color-schemes and copy out a scheme, then replace the section in your config file.

See more powershell config here: https://blog.schdbr.de/powershell/

I was looking for an option that gave me rust support and windows, mac and linux builds. Travis does offer all of that and is free to use for open source projects. I spent too much time setting it up, especially with the uploading part, so here we go:

language: rust
rust:
  - nightly-2019-06-24
cache: cargo
script:
  - cargo build --release
  - git config --local user.name "Johann Woelper"
  - git config --local user.email "woelper@gmail.com"
os:
  - linux
  - osx
  - windows
before_deploy:
  - cd $TRAVIS_BUILD_DIR
  - export TRAVIS_TAG="latest"-$TRAVIS_OS_NAME
deploy:
  provider: releases
  skip_cleanup: true
  file_glob: true
  # draft: true
  overwrite: true
  name: $TRAVIS_OS_NAME
  file:
    - target/release/my_executable
    - target/release/my_executable.exe
  api_key:
    secure: <done with travis setup releases>

First of all, I wanted to pin a specific nightly version because a dependency did not work with the latest nightly - and by default travis installs the latest before building. You can now specify a specific version like nightly-2019-06-24.

Next up, on the os: section all operating systems are added

in the script: section, declare your git credentials

before deploy: will run on each VM that has spun up, so that's where we set the TRAVIS_TAG to the tag we want for our build and change to the build dir.

This will create three releases, one for each OS. If you want to have a single release make sure you have unique executable names for each operating systems - then you could set draft to true so the release does not trigger at each os build step and realease it after all builds are done.

Lastly, travis setup releases is convenient to modify your config file automatically with the correct oauth token.

cargo init --lib (from within a folder you created)

If you want to support OSX:

.cargo/config

[target.x86_64-apple-darwin]
rustflags = [
  "-C", "link-arg=-undefined",
  "-C", "link-arg=dynamic_lookup",
]

Dependencies:

Cargo.toml:

[package]
name = "mypackage"
version = "0.1.0"
authors = ["Me <me@domain.com>"]
edition = "2018"

[lib]
name = "pymod"
crate-type = ["cdylib"]

[dependencies]


[dependencies.pyo3]
version = "0.7.0"
features = ["extension-module"]

At this point, cargo build should already produce a pymod.dll/so/dylib in target/debug.

Now we need some actual code so we can play with it in python.

use pyo3::prelude::*;
use pyo3::wrap_pyfunction;
use pyo3::exceptions;

// #[pyclass] tells pyo3 that this should be treated as a python class
#[pyclass]
struct Vehicle {
    #[pyo3(get, set)]
    model: String,
    #[pyo3(get, set)]
    manufacturer: String,
    #[pyo3(get, set)]
    range: f32,
    #[pyo3(get, set)]
    price: i32
}

// This macro tells pyo3 that this function is accessible from python
#[pyfunction]
fn vehicles() -> PyResult<Vec<Vehicle>> {
    // Let's keep it simple: a vec to hold our vehicles
    let mut vehicles = vec![];

    vehicles.push(Vehicle {
        model: "Model S".to_string(),
        manufacturer: "Tesla".to_string(),
        range: 520.0,
        price: 81980
    });

    vehicles.push(Vehicle {
        model: "Leaf".to_string(),
        manufacturer: "Nissan".to_string(),
        range: 172.0,
        price: 36800
    });

    vehicles.push(Vehicle {
        model: "Urban".to_string(),
        manufacturer: "Desiknio".to_string(),
        range: 100.0,
        price: 3790
    });


    Ok(vehicles) //return positive PyResult

    //If you want exceptions, use PyErr with the pyo3::exceptions already provided for you
    //Err(PyErr::new::<exceptions::IOError, _>("Can't open ffproj"))

}

//The name of this function has to match our [lib] name in Cargo.toml
#[pymodule]
fn pymod(py: Python, m: &PyModule) -> PyResult<()> {
    m.add_wrapped(wrap_pyfunction!(vehicles))?;
    Ok(())
}

now just copy pymod.dylib to pymod.so on mac, on windows pymod.dll to pymod.pyd and on linux pymod.so to pymod.so.

In python:

import pymod

for vehicle in pymod.vehicles():
    print(vehicle.manufacturer, vehicle.model, "\n\tEuro / KM:", round(vehicle.price/vehicle.range))

Here are the pyo3 docs:

https://docs.rs/pyo3/0.7.0/pyo3/index.html

This is geared towards gentoo but should work in every system if you have your kernel sources available.

If you come across the notorious hard-to-install AC1200 USB wifi devices and want to get them to work with linux, here is how it goes:

The chipset is a bit of a mystery, this is what lsusb says:

  idVendor           0x0bda Realtek Semiconductor Corp.
  idProduct          0xb812 
  bcdDevice            2.10
  iManufacturer           1 Realtek
  iProduct                2 USB3.0 802.11ac 1200M Adapter
  iSerial                 3 123456

It's actually a 8812BU chipset from realtek. It will not work with a stock kernel and the available drivers usually do not work with a recent kernel (I use 4.19.8-gentoo)

Make sure you have the kernel sources for your current kernel and /usr/src/linux/ points to your current kernel.

You will need to clone the following repo:

git clone https://github.com/cilynx/rtl88x2BU_WiFi_linux_v5.2.4.4_26334.20180126_COEX20171012-5044
cd trl88x*
make
make install

You can test it without restarting if you modprobe 88x2bu. dmesg should show that a new network device was added.

PNG, lossy:

pngquant -f -v --ext .png --quality 70-100 --speed 2 --skip-if-larger FILE.png

speed: default 3, 1-11, more is less quality and faster processing
quality is the target quality to aim for

PNG, lossless (also, as a post-pass on the lossless png)

optipng -o7 FILE.png

-oN: 7 is the slowest and the smallest, usually -o3 is a good tradeoff.

JPG, lossy:
find . -name "*.jpg" | xargs jpegoptim -m 80 -t

JPG, lossless:

find . -name "*.jpg" | xargs jpegoptim -t

Who touched what files and when?
git log --name-status
What was my last commit again? I don't see it with git status anymore...
git show --name-status

You can put these and others into shortcuts in your ~/.gitconfig:

[alias]
    co = checkout
    ci = commit
    br = branch
    hist = log --pretty=format:\"%h %ad | %s%d [%an]\" --graph --date=short --name-status
    lg = log --name-status
    p = pull
    f = fetch
[core]
    excludesfile = /Users/you/.gitignore_global
    editor = vim

Inverse .gitignore:

sometimes (as in managing my home directories' config files) i just want to track specific files. Here's the trick:

# ignore everything
*
# add stuff to track
!.vim/
!.bashrc
!some_pattern*
# aand of course...
!.gitignore

Merging

git merge -Xignore-all-space might be helpful sometimes

Misc stuff

These are probably known to most if you use git, but it might be helpful as a primer for some.

Branch related

Create a new branch
git checkout -b <branchName>

If you want to push this to a remote, making it available to others:
git push -u origin <branchName>

Delete local branch
git branch -D bugfix

Delete remote branch
git push origin --delete <branchName>

Config related

Set editor
git config --global core.editor "vim"
(see above for more)

Handling JSON

A small example how to dump your struct to a file and read it again.

Cargo.toml:

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

use serde::{Serialize, Deserialize};
use serde_json;
use std::io::BufWriter;
use std::io::BufReader;
use std::fs::File;

#[derive(Serialize, Deserialize, Debug)]
enum CarClass {
    Race,
    Offroad,
    Hover
}

#[derive(Serialize, Deserialize, Debug)]
struct Car {
    maxspeed: f64,
    weight: f64,
    class: CarClass
}

fn main() {
    let new_car = Car {
        maxspeed: 120.0,
        weight: 4000.0,
        class: CarClass::Offroad
        };
    
    // write out the file
    let writer = BufWriter::new(File::create("car.json").unwrap());
    serde_json::to_writer_pretty(writer, &new_car).unwrap();

    // read it back again
    let reader = BufReader::new(File::open("car.json").unwrap());
    let loaded_car: Car = serde_json::from_reader(reader).unwrap();
    println!("{:?}", loaded_car);
}

Safely reading JSON

Let's revisit the above example and see how we can ditch the unwrap()s.

let's look at this line:

let loaded_car: Car = serde_json::from_reader(reader).unwrap();

we could break this up of course. The challenge is that we need to tell serde exaclty what to expect so it can deserialize the data properly. All we really know is that we get a result, and there should be a Car in it. So let's just put the _ as a placeholder in there (a.k.a. I don't care, please figure it out for me)

let loaded_car: Result<Car, _> = serde_json::from_reader(BufReader::new(&open_file));

Nice! But what if we want to go more functional and not store any intermediate variables?

We'll just apply what we learned using the turbofish (https://techblog.tonsser.com/posts/what-is-rusts-turbofish):

match serde_json::from_reader::<_, Car>(BufReader::new(open_file)) {...}

See the example in action:

#[macro_use]
extern crate serde_derive;
extern crate serde;
extern crate serde_json;
use std::io::BufWriter;
use std::io::BufReader;
use std::fs::File;

#[derive(Serialize, Deserialize, Debug)]
enum CarClass {
    Race,
    Offroad,
    Hover
}

#[derive(Serialize, Deserialize, Debug)]
struct Car {
    maxspeed: f64,
    weight: f64,
    class: CarClass
}

fn main() {

    match File::open("car.json") {
        Ok(open_file) => {
            match serde_json::from_reader::<_, Car>(BufReader::new(open_file)) {
                Ok(car) => println!("{:?}", car),
                Err(e) => println!("{:?}",e)
            }
        },
        Err(e) => println!("{:?}",e)
    }

Iterate folder:

https://doc.rust-lang.org/std/fs/fn.read_dir.html

use std::io;
use std::fs::{self, DirEntry};
use std::path::Path;


fn iterate_path(dir: &Path, cb: &Fn(&DirEntry)) -> io::Result<()> {
    if dir.is_dir() {
        for entry in fs::read_dir(dir)? {
            let entry = entry?;
            let path = entry.path();
            if path.is_dir() {
                visit_dirs(&path, cb)?;
            } else {
                cb(&entry);
            }
        }
    }
    Ok(())
}

or walkdir:

[dependencies]
walkdir = "2"

extern crate walkdir
use walkdir::WalkDir;

for entry in WalkDir::new("foo") {
    dbg!(entry);
}

Argument parsing with clap

[dependencies]
clap = "2"

extern crate clap;
use clap::{Arg, App, SubCommand};

fn main() {
    let matches = App::new("myapp")
                          .version("0.1")
                          .arg(Arg::with_name("dir")
                               .value_name("DIRECTORY")
                               .help("Sets a starting directory")
                               .takes_value(true)
                               .required(true)
                          )
                          .get_matches();
    
    let dir  = matches.value_of("dir").unwrap();
    println!("Value for root: {}", dir);

}

cargo run -- somedir

XML

use std::fs::File;
use std::io::prelude::*;
use std::io::BufReader;
use treexml::Document;

   
match File::open("yo.xml") {
    Ok(f) => {
        let mut buf_reader = BufReader::new(f);
        let doc = Document::parse(buf_reader).unwrap();
    },
    Err(_e) => ()
}

Run system command

use std::process::Command;

let output = 
Command::new("ls")
        .args(&["-l", "-R"])
        .output()
        .expect("failed to execute process");
let res = output.stdout;
println!("{:?}", res);

Gracefully handling Options and Results in iterators

fn main() {
    let animals = vec![Some("Bear"), Some("Dog"), None, Some("Cat")];
    let valid_animals = animals.iter().flat_map(|x| x).collect::<Vec<_>>()
}

Parse string to type

let i = String::from("42").parse::<i32>().unwrap();
// or let the compiler figure that out from annotating the variable
let i: i32 = String::from("42").parse().unwrap();

Defaults for structs

Derive from Default is the easiest:

#[derive(Default)]
struct Animal {
    hitpoints: i32,
    speed: f64,
    weight: f64
}
fn main() {
    // use all defaults
    let snake = Animal::default();
    //just specify one, use Default for everything else
    let birdy = Animal {
        hitpoints: 500,
        ..
        Default::default()
    };
}

If you want to have hand-crafted defaults, you need to impl your own Default:

struct Animal {
    hitpoints: i32,
    speed: f64,
    weight: f64
}

impl Default for Animal {
    fn default () -> Animal {
        Animal{hitpoints: 500, speed: 3.141, weight: 55.5}
    }
}

fn main() {
    let snake = Animal::default();
}

Building gotchas and Cargo stuff

OSX @rpath

you can use install_name_tool to add a relative library search path to your executable like that:
install_name_tool -add_rpath @executable_path/. your_binary
in case you are using a gui library like libui you can then bundle the libui.A.dylib with your app bundle.
cargo bundle is recommended for packaging the actual app.

create multiple binaries

Let's say you want a GUI app and one for the command line that has minimal size and dependencies. All you need to do is the following in your Cargo.toml:

[[bin]]
name = "cli"
path = "src/cli.rs"

[[gui]]
name = "cli"
path = "src/gui.rs"

cargo build will then build both. Run the binary of your choice with cargo run --bin cli.

Windows programs without a console window

#![windows_subsystem = "windows"]

If you use this in your crate root, no console window will be shown if you run the resulting executable.

Git dependencies

[dependencies]
rand = { git = "https://github.com/rust-lang-nursery/rand" }

But what if your repo is private? Relative url without a base?
First: if you are cloning with ssh, use the appropriate protocol and use an absolute-style url - github will accept replacing : with a /:

[dependencies]
rand = { git = "ssh://git@github.myorg.com/myuser/myrepo.git" }

In order for this to work, .cargo/config needs to specify

[net]
git-fetch-with-cli = true

This file can be in your ~ home dir or in the project itself which makes sense if other people want to build your project.

If ((Test-Path $Profile) -eq "True") {Notepad $Profile}

(create one)

New-Item -path $profile -type file -force

oh-my-posh (https://github.com/JanDeDobbeleer/oh-my-posh) is useful, together with posh-git.
in a nutshell:

Install-Module posh-git -Scope CurrentUser
Install-Module oh-my-posh -Scope CurrentUser

Add this to your profile to activate it:

# Import-Module posh-git
Import-Module oh-my-posh
# Set-Theme Paradox
# Speed up large repos
$GitPromptSettings.EnableFileStatus = $false

Some useful settings:

function f_timer($program) {
    $allArgs = $PsBoundParameters.Values + $args
    $sw = [Diagnostics.Stopwatch]::StartNew();
    iex "$allArgs";
    $sw.Stop();
    $sw.Elapsed;
}

Set-Alias which where
Set-Alias time f_timer

Although it is very handy to have it run on a local port, using WSCGI and apache makes it straightforward to do just that. There are a few gotchas though:

(this is on ubuntu 16.04, but it should apply to most OSes)

apt-get install libapache2-mod-wsgi

in /etc/apache2/sites-available:
vi subdomain.domain.com.conf

<VirtualHost *:80>
        ServerAdmin you@whatnot.com
        WSGIScriptAlias / /var/www/yourapp/app.py/
        AddType text/html .py
        ServerName subdomain.domain.com

        ErrorLog ${APACHE_LOG_DIR}/error_myapp.log
        CustomLog ${APACHE_LOG_DIR}/access_myapp.log combined
</VirtualHost>

then a2ensite subdomain.domain.com
and reload apache.

in python:

application = web.application(urls, globals()).wsgifunc()

please note that application must appear exactly as above, you can't name it anything else.

since apache does not allow you to import MyModule directly, you need to add it like this (assuming it's in the same folder as your app)

import os
import sys
CURDIR = os.path.dirname(__file__)
sys.path.append(CURDIR)
import MyModule

--- also please see http://webpy.org/cookbook/mod_wsgi-apache-ubuntu