dypsilon

Frontend Development

Attention: the list was moved to

https://github.com/dypsilon/frontend-dev-bookmarks

This page is not maintained anymore, please update your bookmarks.

---

selfsame

Generating Procedural Game Worlds with Wave Function Collapse

Wave Function Collapse (WFC) by @exutumno is a new algorithm that can generate procedural patterns from a sample image. It's especially exciting for game designers, letting us draw our ideas instead of hand coding them. We'll take a look at the kinds of output WFC can produce and the meaning of the algorithm's parameters. Then we'll walk through setting up WFC in javascript and the Unity game engine.

The traditional approach to this sort of output is to hand code algorithms that generate features, and combine them to alter your game map. For example you could sprinkle some trees at random coordinates, draw roads with a brownian motion, and add rooms with a Binary Space Partition. This is powerful but time consuming, and your original vision can someti

jagregory

So you've cloned somebody's repo from github, but now you want to fork it and contribute back. Never fear!

Technically, when you fork "origin" should be your fork and "upstream" should be the project you forked; however, if you're willing to break this convention then it's easy.

* Off the top of my head *

1. Fork their repo on Github
2. In your local, add a new remote to your fork; then fetch it, and push your changes up to it

    git remote add my-fork git@github...my-fork.git

gre

/*
 * This work is free. You can redistribute it and/or modify it under the
 * terms of the Do What The Fuck You Want To Public License, Version 2,
 * as published by Sam Hocevar. See the COPYING file for more details.
 */
/*
 * Easing Functions - inspired from http://gizma.com/easing/
 * only considering the t value for the range [0, 1] => [0, 1]
 */
EasingFunctions = {

Flafla2

public class Perlin {

	public int repeat;
	
	public Perlin(int repeat = -1) {
		this.repeat = repeat;
	}

	public double OctavePerlin(double x, double y, double z, int octaves, double persistence) {
		double total = 0;

nadako

abstract ArrayRead<T>(Array<T>) from Array<T> {
    @:arrayAccess inline function get(i:Int):T return this[i];
    public var length(get,never):Int;
    inline function get_length() return this.length;
}

markknol

Links to Haxe Macro related tutorials and articles

• The official Haxe sources:

  • https://haxe.org/manual/macro.html
  • http://api.haxe.org/haxe/macro/
  • http://code.haxe.org/category/macros/

  Getting better all the time, this is the definitive guide though quite meaty and requires a good couple of passes before things make sense. Learn from simple examples and practicing, use the manual as a reference.

• Macronauts: Macro workshop

ruby0x1

// Modified version of a tilt shift shader from Martin Jonasson (http://grapefrukt.com/)
// Read http://notes.underscorediscovery.com/ for context on shaders and this file
// License : MIT

uniform sampler2D tex0;
varying vec2 tcoord;
varying vec4 color;

    /*
        Take note that blurring in a single pass (the two for loops below) is more expensive than separating

hamaluik

package com.blazingmammothgames.util;

#if neko
	import neko.vm.Thread;
	import neko.vm.Mutex;
#elseif cpp
	import cpp.vm.Thread;
	import cpp.vm.Mutex;
#end

banksean

// Ported from Stefan Gustavson's java implementation
// http://staffwww.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
// Read Stefan's excellent paper for details on how this code works.
//
// Sean McCullough banksean@gmail.com

/**
 * You can pass in a random number generator object if you like.
 * It is assumed to have a random() method.
 */