[CoherentNoise] [ThreadNinja] Strange random bug while multithreading

Scripting
1

Quick Background:
I’m a self-taught hobbyist (tinkering since Unity 3.5) who is working on my first long term project. I typically can overcome any problem or bug by taking a stroll through google results for a few days, maybe even a week or two. Tons of online resources. One particular issue, though, has become an outlier this month. The heart of the issue lies in a subject way over my head. Multithreading. Before I dive head first into research for several weeks, if not months, I’d like to throw the problem your way and see if anyone has any quick and dirty solutions. I’d rather not halt progress.

The Bug:
My goal is to generate height maps using the ‘CoherentNoise’ library on several threads to speed up world generation process. The height maps are for individual terrains which are tiled together to emulate a massive finite world. Everything works perfectly when done on a single background ‘ThreadNinja’ thread (by Ciela Spike). When I dispatch several threads to handle a portion of the total terrains, the results aren’t consistent. The failure appears to caused by the ‘Function’ generator since that’s the only generator acting up. Or perhaps I’m using ThreadNinja poorly.

Note: I’m generating textures which are applied to tiled quads to make investigation easier.

Single Background Thread Code:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using CoherentNoise;
using CoherentNoise.Generation;
using CoherentNoise.Generation.Displacement;
using CoherentNoise.Generation.Fractal;
using CoherentNoise.Generation.Modification;
using CoherentNoise.Generation.Patterns;
using CoherentNoise.Generation.Voronoi;
using CoherentNoise.Texturing;
using CielaSpike;
using System.Threading;

public class FuncTestSingleThread : MonoBehaviour {

    [Header("World Settings")]
    [Space(10)]
    public GameObject prefab;
    public int seed = 1;
    public int size = 64;
    public int count = 5;

    [Header("Mask Settings")]
    [Space(10)]
    public float freq = 3f;
    public float power = 0.1f;
    public int octaves = 3;
    public float iscale = 1.1f;
    int xindex = 0;
    int yindex = 0;
    public AnimationCurve curve;

    [Header("Mountainous Terrain Settings")]
    [Space(10)]
    public float ridgeExp = 0.4f;
    public float ridgeOffset = .75f;
    public float ridgeGain = 13.0f;
    public float ridgeFreq = 0.5f;
    public int ridgeOctaves = 8;

    // other stuff
    Vector3 mypos;
    Quaternion myq;

    void Start(){
        mypos = transform.position;
        myq = Quaternion.identity;
        StartCoroutine(StartAsync());

    }


    IEnumerator StartAsync(){
        Debug.Log("StartAsync()");
        Task task;
        yield return this.StartCoroutineAsync(FuncToThread(), out task);
        Debug.Log ("DONE!");
    }


    IEnumerator FuncToThread(){
        LogAsync ("FuncToThread Started");
        //
        Function opt = new Function((x,y,z) => { return curve.Evaluate(Vector2.Distance (new Vector2(x,y), new Vector2(count*0.5f,count*0.5f))/(count/2 * iscale));});

        Turbulence trb = new Turbulence (opt, seed);
        trb.Power = power;
        trb.Frequency = freq;
        trb.OctaveCount = octaves;

        RidgeNoise mts = new RidgeNoise (seed);
        mts.Exponent = ridgeExp;
        mts.Offset = ridgeOffset;
        mts.Gain = ridgeGain;
        mts.Frequency = ridgeFreq;
        mts.OctaveCount = ridgeOctaves;

        Generator hmap = (mts * 0.5f + 0.25f) * trb;

        for (int tileX = 0; tileX < count; tileX++) {
            for (int tileY = 0; tileY < count; tileY++) {
                int i = 0;
                //float highest = -10f;
                //float lowest = 10f;
                yield return Ninja.JumpToUnity;
                Texture2D img = new Texture2D(size,size);
                Color[] pixels = new Color[size*size];
                GameObject tile = Instantiate(prefab, mypos + new Vector3(tileX, tileY, 0), myq, transform);
                yield return Ninja.JumpBack;

                for (int x = 0; x < size; x++) {
                    for (int y = 0; y < size; y++) {
                        float sx = (float)x / (size - 1f) + (float)tileY;
                        float sy = (float)y / (size - 1f) + (float)tileX;
                        float num = hmap.GetValue (sx, sy, 0f);
                        pixels[i] = new Color (num, num, num, 1);
                        i++;
                    }
                }
                yield return Ninja.JumpToUnity;
                img.SetPixels (pixels);
                img.Apply (true);
                tile.GetComponent<Renderer> ().material.SetTexture("_EmissionMap", (Texture)img);
                yield return Ninja.JumpBack;
            }
        }
        yield return Ninja.JumpToUnity;
    }


    private void LogAsync(string msg)
    {
        Debug.Log("[LogAsync]   " + msg);
    }
}

Single Background Results:

Multiple background Threads Code:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using CoherentNoise;
using CoherentNoise.Generation;
using CoherentNoise.Generation.Displacement;
using CoherentNoise.Generation.Fractal;
using CoherentNoise.Generation.Modification;
using CoherentNoise.Generation.Patterns;
using CoherentNoise.Generation.Voronoi;
using CoherentNoise.Texturing;
using CielaSpike;
using System.Threading;

public class FuncTestMultiThread : MonoBehaviour {

    [Header("World Settings")]
    [Space(10)]
    public GameObject prefab;
    public int seed = 1;
    public int size = 64;
    public int chunkGridRoot = 5;

    [Header("Mask Settings")]
    [Space(10)]
    public float freq = 3f;
    public float power = 0.1f;
    public int octaves = 3;
    public float iscale = 1.1f;
    int xindex = 0;
    int yindex = 0;
    public AnimationCurve curve;

    [Header("Mountainous Terrain Settings")]
    [Space(10)]
    public float ridgeExp = 0.4f;
    public float ridgeOffset = .75f;
    public float ridgeGain = 13.0f;
    public float ridgeFreq = 0.5f;
    public int ridgeOctaves = 8;

    // other stuff
    Vector3 mypos;
    Quaternion myq;
    int coreCount;
    int chunkCount;


    void Start(){
        mypos = transform.position;
        myq = Quaternion.identity;
        coreCount = SystemInfo.processorCount;
        chunkCount = chunkGridRoot * chunkGridRoot;
        StartCoroutine(StartAsync());
    }


    IEnumerator StartAsync(){
        int cc = coreCount > 1 ? coreCount - 1 : 1;        // reserve one core, hopefully this helps the main thread run quicker
        Task[] tasks;                                    // array of tasks -- ThreadNinja
        int num = Mathf.CeilToInt(chunkCount / cc);        // max chunks for all threads except the last
        int sc = 0;                                        // start chunk
        int ec = 0;                                        // end chunk
        Debug.Log ("START");

        if (cc >= chunkCount) {                            // if there less chunks (or same number of chunks) than targeted threads
            tasks = new Task[chunkCount];
            for (int i = 0; i < chunkCount; i++) {
                // there is no 'yeild return' here because it prevents the threads from running at the same time
                this.StartCoroutineAsync (FuncToThread (i, i, i), out tasks [i]);
            }
        } else {                                        // There are more chunks than targeted threads.
            tasks = new Task[cc];
            for (int c = 0; c < cc; c++) {                // For each targeted thread...
                if (c == cc - 1) {                        // if this is the last thread... 
                    sc = ec;
                    ec = chunkCount;
                }else if(c==0){                            // if this is the first thread...
                    sc = 0;
                    ec = num;
                } else {                                // if this is not the first or last thread...
                    sc += num;
                    ec += num;
                }
                Debug.Log ("Thread " + c+ "  start chunk: " + sc + "  end chunk: " +ec);
                // there is no 'yeild return' here because it prevents the threads from running at the same time
                this.StartCoroutineAsync (FuncToThread (c, sc, ec), out tasks [c]);        // start thread
            }
        }
        Debug.Log ("GenChunk() FINISHED.");
        yield return null;
    }


    IEnumerator FuncToThread(int threadnumber, int startchunk, int endchunk){
        LogAsync ("FuncToThread Started");

        // opt might be the source of the error
        Function opt = new Function((x,y,z) => { return curve.Evaluate(Vector2.Distance (new Vector2(x,y), new Vector2(chunkGridRoot*0.5f,chunkGridRoot*0.5f))/(chunkGridRoot/2 * iscale));});

        Turbulence trb = new Turbulence (opt, seed);
        trb.Power = power;
        trb.Frequency = freq;
        trb.OctaveCount = octaves;

        RidgeNoise mts = new RidgeNoise (seed);
        mts.Exponent = ridgeExp;
        mts.Offset = ridgeOffset;
        mts.Gain = ridgeGain;
        mts.Frequency = ridgeFreq;
        mts.OctaveCount = ridgeOctaves;

        Generator hmap = (mts * 0.5f + 0.25f) * trb;

        for (int chunk = startchunk; chunk < endchunk; chunk++) {
            int i = 0;                                                // used to track 1d index during a 2d loop
            float tileX = chunk % chunkGridRoot;                    // breaking a 1d into a 2d array, x index
            float tileY = Mathf.Floor(chunk / chunkGridRoot);        // breaking a 1d into a 2d array, y index
            yield return Ninja.JumpToUnity;                            // ThreadNinja starts working on the main thread
            Texture2D img = new Texture2D(size,size);        // Our chunk image ('tile' == 'chunk')
            Color[] pixels = new Color[size*size];            // img pixels. Our 'heightmap', which is texture2D at this time for demonstration
            GameObject tile = Instantiate(prefab, mypos + new Vector3(tileX, tileY, 0), myq, transform); // Our quad (prefab set in inspector)
            tile.name = "Chunk("+chunk+")_X"+tileX+"_Y"+tileY;
            yield return Ninja.JumpBack;                            // ThreadNinja returns to this background thread

            for (int x = 0; x < size; x++) {                            // 2d loop to fill pixels
                for (int y = 0; y < size; y++) {                        // ^
                    float sx = (float)x / (size - 1) + (float)tileY;    // 'CoherentNoise'operates on 0..1, increments of 1 shift the generator by a full tile
                    float sy = (float)y / (size - 1) + (float)tileX;    // ^
                    float num = hmap.GetValue(sx,sy, 0);                    // change 'hmap' to 'trb' or 'opt' to view precursors
                    pixels[i] = new Color (num, num, num, 1);                // grayscale image, so rgb are all the same value. alpha is 1.
                    i++;                                                    // increment pixel indexor
                }
            }

            // generate terrain and chunk component data
            yield return Ninja.JumpToUnity;                        // ThreadNinja starts working on the main thread again.
            // apply component data
            img.SetPixels (pixels);
            img.Apply (true);
            tile.GetComponent<Renderer> ().material.SetTexture("_EmissionMap", (Texture)img); // emission, not, albedo, so lighting doesn't screw with our inspection
            yield return Ninja.JumpBack;                        // ThreadNinja returns to this background thread         
        }
        yield return Ninja.JumpToUnity;        // chunks loop is finished.                                    // The loop is finished. ThreadNinja goes back to the main thread again.
    }
     

    private void LogAsync(string msg)                        // used as a debugger while outside Unity's main loop
    {
        Debug.Log("[LogAsync]   " + msg);
    }
}

Multiple background Threads Result:

2

Without looking at anything too deeply, Unity3D is single-threaded for the purposes of you interacting with the Unity API. That means you need to provide marshaling that uses only C# primitives that marshal delegates back to some other in-thread queue to apply any changes or request data from Unity objects.

If your code needs a “multi-threaded feel” to it, then use Unity3D’s coroutines, which are basically poor-man’s threads that are guaranteed to execute serially and all in the main thread, where you have full access to all Unity objects.

In short, don’t use System.Threading threads in Unity unless you really know WTF you’re trying to accomplish and where the benefits will be.

3

Actually, there are ways to communicate with the main thread that are relatively simple. I tend to have a script that maintains a list of objects inheriting from an Interface that it runs every Update. Marshaling is definitely not needed.

OP:
Threading problems can be difficult to trace, and your description of your problem is too vague to be much use. “Not consistent” doesn’t tell us enough…not consistent with what? Does the same seed result in different noise?

The problem with scripts that do multi-threading for you is that there are pitfalls in multi-threading that you need to be aware of when using it. You need to know how to make those scripts in the first place, and THEN they’re useful. So learn multi-threading. It’s actually pretty simple, once you know how to do it, and will likely only take you a few days to a week to get to know. Once you know it, you have a powerful tool under your belt.

4

I wouldn’t mind taking a look at it (not right now, at the shop on my linux machine, and it really doesn’t like the linux build of unity).

What is this ‘Turbulence’ class you’re using? Is this part of the CoherrentNoise library you reference in the script? Where’d you get that?

From the looks of your results in the video, I think it’s a maths issue. But just reading code here in the browser is a nuisance… so I’d like more hands on to see what it probably is. If you have a small demo project of it already done up that you could zip up and share, I’ll certainly look at it in an hour or so when I get home.

5

**Unity 5.5.1f1 Project_:__** https://drive.google.com/open?id=0B4z6sM8WThTYdVRIdTNYQ3FzUnc_

You’re right. Spike’s ThreadNinja library is supposed to provide a high level approach to threading / multithreading. Without a solid foundation on threading it is possible I’m using the library wrong. I may link this forum thread in Spike’s asset forum thread later on.

I don’t think I can dodge it any longer, so I’ve started digging into C# threading. Any discrepancies unique to Unity I should be aware of right away? I’ve read it can be a bit tricky to work with Unity’s main thread efficiently.

I’ve linked the project, but I’ll try explaining it better. I’m chaining CoherentNoise functions to generate terrain heightmaps. Currently the heightmaps are rendered as grayscale images on tiled quads. This process takes a while to complete, so I’ve implemented ThreadNinja to retain a tolerable frame rate during the generation process. My implementation of the process works wonderfully when performed on a single ThreadNinja thread. My bug occurs when the process is performed over several ThreadNinja threads. Sometimes The multithreaded version of my process works perfectly, and other times there are large sections of the heightmaps with values of 0f. The bug results aren’t consistent and I am getting no errors in the unity console. The bug appears to be a math issue that occurs during the chained progression of the CoherentNoise generators.

I have a suspicion:
One of the generators ‘Function’ takes in a function that accepts three floats (x,y,z) and returns a single float value. When this generator is isolated and generates the heightmaps, the results have math errors (black and white dots, as well as large black blocks, where they theoretically shouldn’t be). The method the ‘Function’ generator works with uses Unity’s Vector2 and Vector2.Distance, and AnimationCurve and AnimationCurve.Evaluate. Perhaps there is an issue with multiple threads accessing these things.

I think so too, detailed above.

6

The only discrepancy is that Unity’s main thread won’t let you interact with it from another thread…but there are quite safe ways of interacting.

I can tell you certainly that none of those are the problem. I’ve used all of those with multi-threading, without any problems. Unless there was some new multi-threading breaking bug in the very latest update (unlikely).

Running the code on my machine, it looks like your threads are deadlocking at some point. My guess is that it’s due to how Thread Ninja uses a single lock object to “jump” between the main thread and the background thread. If multiple threads attempt to call either of the Ninja.Jump methods, then you’ll wind up with deadlock. I’m not familiar with that library, but this whole coroutine way of dealing with threads is confusing and makes the whole thing harder to sort out than it should be.

Rather than “jumping” between processing on the main thread and your own thread, you should do whatever preliminary work you can on the main thread (create all the textures and GameObjects at once), then dispatch your threads to do their own processing, and finally gather all their results when the threads have finished their work. If you can structure things so that you aren’t doing those yield return statements, I’m willing to bet that your deadlock problem will go away.

7

Adding to the speculation, it’s possible that your math-heavy calculations are working just fine, and the failure is when doing the img.SetPixels() or img.Apply(). Within the generation loops, try keeping a sum of all the pixel values. Just before calling img.SetPixels(), do a Debug.Log(pixelSum). If that value is always some large number for every single tile, but the height map still comes out as all black for some tiles, then you know that your generation is fine, and the issue just lies with transferring the data over from the raw pixel array into a texture. On the other hand, if the sum is actually zero, then you know that the generator is failing to produce the proper pixel values for whatever reason.

8

So I ran some tests with it earlier today, but then I ended up going to Ft. Laudy Daudy to play an escape room… now I’m back, but gotta eat fried chicken… long story short, I’m quickly typing out my findings.

Anyways…

Cleaned up the code a little bit because some of the unnecessary stuff in it was confusing me.

using System.Collections;
using UnityEngine;
using CoherentNoise;
using CoherentNoise.Generation;
using CoherentNoise.Generation.Displacement;
using CoherentNoise.Generation.Fractal;
using CielaSpike;

public class FuncTestMultiThread : MonoBehaviour {

    [Header("World Settings")]
    [Space(10)]
    public GameObject prefab;
    public int seed = 1;
    public int size = 64;
    public int chunkGridRoot = 5;

    [Header("Mask Settings")]
    [Space(10)]
    public float freq = 3f;
    public float power = 0.1f;
    public int octaves = 3;
    public float iscale = 1.1f;
    public AnimationCurve curve;

    [Header("Mountainous Terrain Settings")]
    [Space(10)]
    public float ridgeExp = 0.4f;
    public float ridgeOffset = .75f;
    public float ridgeGain = 13.0f;
    public float ridgeFreq = 0.5f;
    public int ridgeOctaves = 8;

    // other stuff
    Vector3 mypos;



    void Start(){
        mypos = transform.position;
        StartCoroutine(StartAsync());
    }


    IEnumerator StartAsync()
    {
        int chunkCount = chunkGridRoot * chunkGridRoot;
        int cc = Mathf.Max(SystemInfo.processorCount - 1, 1); // reserve one core, hopefully this helps the main thread run quicker
        Debug.Log ("START");
       
        int subcnt = Mathf.CeilToInt((float)chunkCount / cc);
        for(int i = 0; i < cc; i++)
        {
            int sc = i * subcnt;
            int ec = Mathf.Min(sc + subcnt, chunkCount);
            this.StartCoroutineAsync(FuncToThread(i, sc, ec));
        }


        Debug.Log ("GenChunk() FINISHED.");
        yield return null;
    }


    IEnumerator FuncToThread(int threadnumber, int startchunk, int endchunk){
        LogAsync ("FuncToThread Started");

        // opt might be the source of the error
        Function opt = new Function((x, y, z) =>
        {
            float v = 0f;
            v = Vector2.Distance(new Vector2(x, y), new Vector2(chunkGridRoot / 2f, chunkGridRoot / 2f));
            v = v / (iscale * chunkGridRoot * 0.5f);
            //v = curve.Evaluate(v);
            return v;
        });

        Turbulence trb = new Turbulence(opt, seed);
        trb.Power = power;
        trb.Frequency = freq;
        trb.OctaveCount = octaves;

        RidgeNoise mts = new RidgeNoise(seed);
        mts.Exponent = ridgeExp;
        mts.Offset = ridgeOffset;
        mts.Gain = ridgeGain;
        mts.Frequency = ridgeFreq;
        mts.OctaveCount = ridgeOctaves;

        Generator hmap = (mts * 0.5f + 0.25f) * trb;

        for (int chunk = startchunk; chunk < endchunk; chunk++) {
            float tileX = chunk % chunkGridRoot;                    // breaking a 1d into a 2d array, x index
            float tileY = Mathf.Floor(chunk / chunkGridRoot);        // breaking a 1d into a 2d array, y index
            Color[] pixels = new Color[size * size];            // img pixels. Our 'heightmap', which is texture2D at this time for demonstration

            for (int x = 0; x < size; x++) {                            // 2d loop to fill pixels
                for (int y = 0; y < size; y++) {                        // ^
                    float sx = ((float)x / size) + tileX;
                    float sy = ((float)y / size) + tileY;
                    float num = hmap.GetValue(sx,sy, 0);                    // change 'hmap' to 'trb' or 'opt' to view precursors
                    pixels[(x + y * size)] = new Color (num, num, num, 1);                // grayscale image, so rgb are all the same value. alpha is 1.                                                    // increment pixel indexor
                }
            }

            // generate terrain and chunk component data
            yield return Ninja.JumpToUnity;                     // ThreadNinja starts working on the main thread again.
            Texture2D img = new Texture2D(size, size);      // Our chunk image ('tile' == 'chunk')
            GameObject tile = Instantiate(prefab, mypos + new Vector3(tileX, tileY, 0), Quaternion.identity, transform); // Our quad (prefab set in inspector)
            tile.name = "Chunk(" + chunk + ")_X" + tileX + "_Y" + tileY;
            img.SetPixels (pixels);
            img.Apply (true);
            tile.GetComponent<Renderer> ().material.SetTexture("_EmissionMap", (Texture)img); // emission, not, albedo, so lighting doesn't screw with our inspection
            yield return Ninja.JumpBack;                        // ThreadNinja returns to this background thread           
        }
    }
       

    private void LogAsync(string msg)                        // used as a debugger while outside Unity's main loop
    {
        Debug.Log("[LogAsync]   " + msg);
    }
}

A few issues arised.

  1. your pixels indexing was rotated weird ending up with odd results. Fixed that.

  2. same goes for your sx,sy, probably because you noticed the rotation issue and attempted to fix it, but it just added in more oddness

  3. and the BIG culprit… AnimationCurve.Evaluate

Turns out that the AnimationCurve is not thread safe. Removing it from the scenario makes it work no matter what. But including it makes everything break. There must be stateful field inside the AnimationCurve implementation that doesn’t allow it to be called at the same time.

There is also a stateful issue with the Generator Functions, but it only occurs if you define 1 Generator used for all threads. But your code has one for each thread, so it doesn’t occur. So you’re good there.

Anyways… this all sort of makes sense, Unity outright says all of its library should not be considered thread safe. It just happens some is by coincidence (like the Vector2 methods).

Maybe find an alternative for the AnimationCurve that is thread safe?

1 Like
9

This really surprises me…I have multi-threaded code that uses AnimationCurves without any issue.

An easy work-around, since AnimationCurves are structs, is just to create a local reference so you get a local copy, rather than using your global reference.[/code][/QUOTE]

10

10/10 would definitely debug with @lordofduct again

11

They’re not structs (or at least not in my version)… but they are clonable.

And yep… fixed the problem:

using System.Collections;
using UnityEngine;
using CoherentNoise;
using CoherentNoise.Generation;
using CoherentNoise.Generation.Displacement;
using CoherentNoise.Generation.Fractal;
using CielaSpike;

public class FuncTestMultiThread : MonoBehaviour {

    [Header("World Settings")]
    [Space(10)]
    public GameObject prefab;
    public int seed = 1;
    public int size = 64;
    public int chunkGridRoot = 5;

    [Header("Mask Settings")]
    [Space(10)]
    public float freq = 3f;
    public float power = 0.1f;
    public int octaves = 3;
    public float iscale = 1.1f;
    public AnimationCurve curve;

    [Header("Mountainous Terrain Settings")]
    [Space(10)]
    public float ridgeExp = 0.4f;
    public float ridgeOffset = .75f;
    public float ridgeGain = 13.0f;
    public float ridgeFreq = 0.5f;
    public int ridgeOctaves = 8;

    // other stuff
    Vector3 mypos;



    void Start(){
        mypos = transform.position;
        StartCoroutine(StartAsync());
    }


    IEnumerator StartAsync()
    {
        int chunkCount = chunkGridRoot * chunkGridRoot;
        int cc = Mathf.Max(SystemInfo.processorCount - 1, 1); // reserve one core, hopefully this helps the main thread run quicker
        Debug.Log ("START");
     
        int subcnt = Mathf.CeilToInt((float)chunkCount / cc);
        for(int i = 0; i < cc; i++)
        {
            int sc = i * subcnt;
            int ec = Mathf.Min(sc + subcnt, chunkCount);
            this.StartCoroutineAsync(FuncToThread(i, sc, ec));
        }


        Debug.Log ("GenChunk() FINISHED.");
        yield return null;
    }


    IEnumerator FuncToThread(int threadnumber, int startchunk, int endchunk){
        LogAsync ("FuncToThread Started");

        // opt might be the source of the error
        var crv = new AnimationCurve(curve.keys); //clone for posterity
        Function opt = new Function((x, y, z) =>
        {
            float v = 0f;
            v = Vector2.Distance(new Vector2(x, y), new Vector2(chunkGridRoot / 2f, chunkGridRoot / 2f));
            v = v / (iscale * chunkGridRoot * 0.5f);
            v = crv.Evaluate(v);
            return v;
        });

        Turbulence trb = new Turbulence(opt, seed);
        trb.Power = power;
        trb.Frequency = freq;
        trb.OctaveCount = octaves;

        RidgeNoise mts = new RidgeNoise(seed);
        mts.Exponent = ridgeExp;
        mts.Offset = ridgeOffset;
        mts.Gain = ridgeGain;
        mts.Frequency = ridgeFreq;
        mts.OctaveCount = ridgeOctaves;

        Generator hmap = (mts * 0.5f + 0.25f) * trb;

        for (int chunk = startchunk; chunk < endchunk; chunk++) {
            float tileX = chunk % chunkGridRoot;                    // breaking a 1d into a 2d array, x index
            float tileY = Mathf.Floor(chunk / chunkGridRoot);        // breaking a 1d into a 2d array, y index
            Color[] pixels = new Color[size * size];            // img pixels. Our 'heightmap', which is texture2D at this time for demonstration

            for (int x = 0; x < size; x++) {                            // 2d loop to fill pixels
                for (int y = 0; y < size; y++) {                        // ^
                    float sx = ((float)x / size) + tileX;
                    float sy = ((float)y / size) + tileY;
                    float num = hmap.GetValue(sx,sy, 0);                    // change 'hmap' to 'trb' or 'opt' to view precursors
                    pixels[(x + y * size)] = new Color (num, num, num, 1);                // grayscale image, so rgb are all the same value. alpha is 1.                                                    // increment pixel indexor
                }
            }

            // generate terrain and chunk component data
            yield return Ninja.JumpToUnity;                     // ThreadNinja starts working on the main thread again.
            Texture2D img = new Texture2D(size, size);      // Our chunk image ('tile' == 'chunk')
            GameObject tile = Instantiate(prefab, mypos + new Vector3(tileX, tileY, 0), Quaternion.identity, transform); // Our quad (prefab set in inspector)
            tile.name = "Chunk(" + chunk + ")_X" + tileX + "_Y" + tileY;
            img.SetPixels (pixels);
            img.Apply (true);
            tile.GetComponent<Renderer> ().material.SetTexture("_EmissionMap", (Texture)img); // emission, not, albedo, so lighting doesn't screw with our inspection
            yield return Ninja.JumpBack;                        // ThreadNinja returns to this background thread         
        }
    }
     

    private void LogAsync(string msg)                        // used as a debugger while outside Unity's main loop
    {
        Debug.Log("[LogAsync]   " + msg);
    }
}
1 Like
12

Whoops! Been dealing with the equivalent in ParticleSystems, and assumed it was the same. That would explain why I haven’t experienced this…I had forgotten that the curves a ParticleSystem uses are different. Very embarrassing.

13

I’ve yet to do this. Sounds like a blast!

I didn’t know about this.

Huh. Here I am thinking a fix was going to super complicated. Ran your script version many times with expected and weird variables and not one issue. Same goes for testing Unity’s terrain objects. The fix seems so glaringly obvious now. Lesson learned. I have a strong feeling I’ll be doing this a lot moving forward.

You guys are amazing and I thank you all for taking the time. This script has been credited towards lordofduct and all in this thread.

14

Oh man, it’s so much fun.

I met up with this couple who are building out a new location here in town, and my buddy and I are going to be doing the labour. After helping them out at a promotional spot at the science museum, basically having to repair all their electrical equipment on site, they decided to treat us to an escape room and dinner as a thankyou gesture.

First time doing it.

The timing worked out great too, it gave me a ton of inspiration for our gamejam this weekend.

So going to do it again next week with some buddies.

1 Like
15

Got me dreaming about an escape room or haunted house implementing AR / VR for a group or teams. I really hope someone is working on something similar!

1 Like
16

So my plans are to position ourselves to design some games (they have to change out the rooms on a regular basis). And yeah, that actually was one of the ideas we were tossing around. I want to come up with modular/adaptive games that can be catered to a team when they come in.

Often you go in and a game is designed with X teammates being there, which puts you in a pickle if you are just a duo. Vice versa if a big team goes. Having scaleable and modular game mechanics could easily fix that. AR/VR is a definite way to get some of that.

1 Like
17

Oh wow. If this becomes a reality, I beg you to document it to some degree. AR/VR is still fairly new territory and whatever you guys would implement would likely be ground-breaking to some extent. Wouldn’t dare ask for tutorials, I know they can become quite a burden while exploring new ideas. I’m pretty excited for you and hope you get the opportunity.