This is a small utility class that allows us to obtain a random number between two values that are uniformly distributed in the range of ‘low’ to ‘high’. This works for floats, doubles and integers.

The inner working of this class are straight forward, our uniform(int, int) method uses the nextInt(int) method of Random class which already allows us to pass the upper bound. Float and Double work by obtaining a value in range [0.0, 1.0] and then scaling it accordingly between our ‘low’ and ‘high’

As this is meant for use in multithreaded environment I am using java.util.concurrent.ThreadLocalRandom rather than java.util.Random for performance reasons.

import java.util.concurrent.ThreadLocalRandom;

import java.util.concurrent.ThreadLocalRandom;

public class RandomUtil
{
    public static int uniform(final int low, final int high)
    {
        final ThreadLocalRandom rand = ThreadLocalRandom.current();
        return rand.nextInt(high - low) + low;
    }

    public static float uniform(final float low, final float high)
    {
        final ThreadLocalRandom rand = ThreadLocalRandom.current();
        return rand.nextFloat() * (high - low) + low;
    }

    public static double uniform(final double low, final double high)
    {
        final ThreadLocalRandom rand = ThreadLocalRandom.current();
        return rand.nextDouble() * (high - low) + low;
    }

    public static double nextDouble()
    {
        final ThreadLocalRandom rand = ThreadLocalRandom.current();
        return rand.nextDouble();
    }

    public static boolean nextBoolean()
    {
        final ThreadLocalRandom rand = ThreadLocalRandom.current();
        return rand.nextBoolean();
    }
}

DRAFT

This is a basic tutorial on how to create procedural lightning effect in Unity, this is my first attempt at using Unity so if you think there are bugs,issues or better ways of doing things let me know.

I am using a two step process

1) Generator
2) Renderer

I like to have them separated for couple different reasons but mainly to allow me to render them differently and create different lighting like effects.

Generator is responsible for generating segments and renderer is responsible for rendering segments to the screen.

My original version used a LineRenderer but I decided to go with a Mesh/MeshFilter for rendering as that gives me more control.  Each segment creates a new quad that is added to our mesh.

After 1 generation

Results after first pass.

Current status 

Implementation 

Segment class

public class Segment 
{
    public Vector2 start;

    public Vector2 end;

    public int generation;
    
    public Segment(Vector2 start, Vector2 end) : this(start, end, 0)
    {
               
    }

    public Segment(Vector3 start, Vector2 end, int generation)
    {
        this.start = start;
        this.end = end;
        this.generation = generation;
    }
}

So I been offline for a while, did not update my blog or do anything else. But I am back now. In up coming days I will post what have happen since begging of the year.