procedural

MakeSomeNoise

3D Graphics / By

MakeSomeNoise v1.1.2 is Released

 

What’s MakeSomeNoise?

MakeSomeNoise is a free tool I built for generating procedural noise textures, texture atlas (sprite sheets), and image sequences. It’s a standalone Windows app, just download and run.

What does it do?

  • Mix two layers of noise using common weighted blending modes.
  • 6 different kinds of noise (for now, more are coming).
  • Explore the 3d noise space and preview the noise animating through Z slice at user-defined speed and frame numbers.
  • Export the result as a single frame, atlas or image sequence with clean naming for your use.

Built-in Learning Guide

I added a complete “Guide To Noise” right in the app. Click the help button and you get detailed explanations for every noise algorithm—the history, how it works, when to use it, and pro tips. I wanted to make this tool educational, not just functional. Whether you’re learning about noise for the first time or just need a quick refresher on how these noise functions work it’s all there.

Export Previews & Animation Playback 

You can now preview before export. Want to see what that 16-frame atlas will look like? Preview it. Need to check your animation sequence? Play it back at any FPS from 1-60. There’s also a handy right-click menu for copying the preview to clipboard or jumping straight to your export folder.

Smarter File Management

The app now automatically manages file versions for you (_v00, _v01, etc.), so you’ll never accidentally overwrite that perfect noise pattern you made. Export paths are now fully visible prior to export.

Cleaner, Smoother Experience

I’ve been squashing bugs and polishing the UI. Better tooltips everywhere, improved thread management (no more crashes when you spam sliders), and generally just a more responsive app.

The Licensing Thing

Quick note: The app itself is free to use for anything, including commercial projects. You just can’t sell the app or bundle it for profit without asking me first. But anything you generate with it (textures, images, animations) is completely yours under CC0. Use them commercially, sell them, whatever. No attribution needed (though it’s always appreciated 😊).

Download It!

Ready to make some noise? Head over to the GitHub Release Page and grab the executable. It’s a single 120MB file—download, double-click, and you’re good to go.

First run might take a few seconds while Windows Defender does its thing, but after that it’s smooth sailing.

If you’ve got ideas or feature requests, hit me up on GitHub!

Download: MakeSomeNoise v1.1.2 on GitHub

Happy noise-making! 🎨

– Andy

Procedural Glyphs, another method

2D Graphics, Creative Work, Houdini / By

I thought I was done with the procedural glyphs project but it occured to me there was another approach I could take and I had to give it a try. The results are a bit closer to feeling handwritten. What would be really interesting would be to develop a continuous cursive-like script with some form of punctuation.

Update: Cursive writing GET.

Procedural Hatching

2D Graphics, Examples, Shaders, Unity / By
I’ve been using Shadershop as a tool to explore useful procedural functions. In this case I needed procedural hatching. A square wave was quick to define:
  In this case, all that we need to do is call a couple of floor functions. Frequency, phase and amplitude are easy enough to adjust after the fact just as you would any other periodic function. (A simpler method to create a square wave is to use a rounding function, but I wanted to see where Shadershop’s approach took me.)
  I then extrapolated this function into a vector2, skewed it with a 2×2 matrix, and voila. Shadershop makes figuring this kind of thing out much easier by using a visual workflow and graphing your function as you go. Very handy!

  You can do something similar with a 1d random function fract(sin(x)*999) to achieve a periodic 2d noise pattern.

  A simple crosshatch shader in unity can be made by adding two of the above square wave functions. In this case I used a min and max function to change the “pulse length” of the square wave. You can get a similar look by using the more common approach of establishing a sine wave which you then clip/threshold. I’m not sure which method would be faster… Here’s the basic shader:
 

Shader "Unlit/Test"
{
    Properties
    {
      _Density ("Density", Range(1,400)) = 150
      _Rotation ("Rotation", Range(0,360)) = 45.0
      _Width ("Width", Range(0,1)) = 0.4
    }
    SubShader
    {
        Pass
        {
          CGPROGRAM
          #pragma vertex vert
          #pragma fragment frag
          #include "UnityCG.cginc"
          struct v2f
          {
              float2 uv : TEXCOORD0;
              float4 vertex : SV_POSITION;
          };
          float _Density;
          float _Rotation;
          float _Width;
          v2f vert (float4 pos : POSITION, float2 uv : TEXCOORD0)
          {
              v2f o;
              o.vertex = UnityObjectToClipPos(pos);
              o.uv = uv * _Density;
              return o;
          }
            
          fixed4 frag (v2f i) : SV_Target
          {
            float sn, cs;
            sincos(radians(_Rotation), sn, cs);
            float2x2 mt = float2x2(cs, -sn, sn, cs); 
            float2 c = i.uv;
            c.xy = mul ( c.xy, mt );
            float hatch = max(abs(floor((c.x/2 - 0.5)/-1) 
                          + floor(c.x/2)+1),
                          abs(floor(((c.x-_Width)/2 - 0.5)/-1) 
                          + floor((c.x-_Width)/2)+1))
                          - min(abs(floor((c.y/2 - 0.5)/-1) 
                          + floor(c.y/2)+1),
                          abs(floor(((c.y-_Width)/2 - 0.5)/-1) 
                          + floor((c.y-_Width)/2)+1));
            return hatch;
          }
          ENDCG
      }
  }
}

  The problem with this kind of approach is that it’s overly complex. All of that min/max/floor stuff can be replaced with a much shorter step function. Same look, much more direct.
 

{
  float sn, cs;
  sincos(radians(_Rotation), sn, cs);
  float2x2 mt = float2x2(cs, -sn, sn, cs); 
  float2 c = i.uv;
  c.xy = mul ( c.xy, mt );
  float hatch = abs(step(1-_Width,sin(c.x)))
              + abs(step(1-_Width,sin(c.y)));
  return hatch;
}

  I added some lighting to the shader and here’s the result. Procedural and written entirely in notepad!

Experiment

3D Graphics, Houdini / By

Took a few of the basic assets I’ve made so far and applied them together to get this abstract shell-like shape. Yep.

And the obligatory randomized polyextrude with a couple assets for making hex grids. It had to happen.