Particle Structure Addon for Blender 3D

I AM SO EXCITED TO SHARE THIS!!!!

 - Said me about a year ago.

This is a standalone Blender addon that takes whatever meshes or objects you have selected, and fills them with particles of like-shaped objects or meshes.

Before

AFTER!!!

All you do to use the addon is hit space to open the search tool, then type:

  Add Particle Structure

Or you can just go to;

  Add > Add Particle Structure

And that's it!!

- Download Here -

Procedurally Playful Facebook Page is Operational!

I have a new "like" page on Facebook:

Link - Procedurally Playful

On a side note, I also have 3 new tools in the works. One is a fun little script, the other is a full blown Blender Addon, and the THIRD, well... the third is something I think every procedural generation enthusiast, game developer, environment developer, machine learning enthusiast, and 3D developer and/or animator should be excited about.

You'll see. ;)

As for that, here's a few pics of one of the tools I made doing what it does best:

Procedural Biome Generator - Update (Plus Download Link)

I've finished the first draft of my biome generator! (Without foliage thus far.)

Part of the work need to be completed was the ground color generator and a lot of math behind the temperature vs. rainfall biome selector. All of these things are finished, the first draft is ready for recreational release, and I will now move on to the foliage generation. This will be released in V2 of the Biome Generator.

If look closely you can see the ground color change slightly from dark to bright. These are two forest based biomes.

As you can see, there's a bit of variety in color added to create slightly more complex (Yet low polygon) groundscape. The shrubbery will be added in version 2.

The generator works by taking any selected landscape, and starting from the top descending to the bottom, it begins to assign a biome to each individual face. This generator works via individual faces instead of a more complex blending algorithm simply because this is a proof-of-concept tool, AND a cool excuse to make low-poly artwork.

Just remember this is version 1, and there's a lot I could clean up, but for now, I'm just trying to get this out there, and I'll try to clean my code up around V.3.

You can use it by doing the following:

Copy/Paste the following code into Blender 3D's Python Interpreter:


def create_biome(temp1,temp2,rain1=40,rain2=40): #Rainfall is default 40 cm. temp in C.
    land = bpy.context.object
    temperature_range = abs(temp1-temp2)
    rainfall_range = abs(rain1-rain2)
    height = land.dimensions.z
    material0 = bpy.data.materials.new(name='Cold Red Grass')
    material0.diffuse_color = (0.67, 0.14, 0.07)
    land.data.materials.append(material0)
    material1 = bpy.data.materials.new(name='Rocks and Gravel')
    material1.diffuse_color = (0.52, 0.43, 0.22)
    land.data.materials.append(material1)
    material2 = bpy.data.materials.new(name='Desert Shrub')
    material2.diffuse_color = (0.18, 0.34, 0.22)
    land.data.materials.append(material2)
    material3 = bpy.data.materials.new(name='Dead Grass')
    material3.diffuse_color = (0.53, 0.26, 0.16)
    land.data.materials.append(material3)
    material4 = bpy.data.materials.new(name='Rocks/Leaves/Sticks')
    material4.diffuse_color = (0.51, 0.28, 0.14)
    land.data.materials.append(material4)
    material5 = bpy.data.materials.new(name='Light Foliage/Moss')
    material5.diffuse_color = (0.13, 0.38, 0.03)
    land.data.materials.append(material5)
    material6 = bpy.data.materials.new(name='Desert Sand')
    material6.diffuse_color = (1, 0.37, 0.13)
    land.data.materials.append(material6)
    material7 = bpy.data.materials.new(name='Dense Grass/Shrub')
    material7.diffuse_color = (0.16, 0.48, 0.02)
    land.data.materials.append(material7)
    material8 = bpy.data.materials.new(name='Dense Shrub')
    material8.diffuse_color = (0.03, 0.30, 0)
    land.data.materials.append(material8)
    material9 = bpy.data.materials.new(name='Charred Earth')
    material9.diffuse_color = (0.49, 0.15, 0.07)
    land.data.materials.append(material9)
    materialsnow = bpy.data.materials.new(name='Snow')
    materialsnow.diffuse_color = (1.0, 1.0, 1.0)
    land.data.materials.append(materialsnow)
    for x in land.data.polygons:    #Begins to assign materials to polygons from top to bottom.
        m = x.center.z + (height / 2) + 0.01 #math modifiers to find temperature at point.
        j = height / m
        if temp1 >= temp2:
            temp_proxy = (temperature_range / j) + min(temp1,temp2) #determines temperature at specified height.
        elif temp1 < temp2:    #GET THIS WORKING HERE.
            temp_proxy = temperature_range - (temperature_range / j) + min(temp1,temp2)
            #temp_proxy = (temperature_range / j) + min(temp1,temp2) #determines temperature at
        if rain1 >= rain2:
            rainfall = (rainfall_range / j) + min(rain1,rain2)
        if rain1 < rain2:
            rainfall = rainfall_range - (rainfall_range / j) + min(rain1,rain2)
        graphline = 165+(temp_proxy*10) #This is to cut the diagonal line on the biome graph.
        if rainfall > graphline:    #This corrects any rainfall above what is actually realistic.
            rainfall == graphline-1
        """ -------------------Begin material assignment-------------- """
        if temp_proxy < -5: # and (temp_proxy > graphline): #Tundra
            sl = 15 * abs(temp_proxy + 5)
            snow = ranyn(sl)        #This math causes more snow for lower temperature.
            if snow == 1:
                x.material_index = 10
            elif snow == 0:
                x.material_index = choice([0,1])    #Assign proper Biome Color to polygon
        if (temp_proxy >= -5) and (temp_proxy < 3) and (rainfall >= 30): #taiga.
            x.material_index = choice([1,7,7,7])
            plant(x,1,'Pine')  """ THIS IS A TEST """
        if (temp_proxy >= -5) and (temp_proxy < 13) and (rainfall < 30): #Desert and Grassland
            x.material_index = choice([1,2,3])
        if (temp_proxy >= 3) and (temp_proxy < 20) and (rainfall >= 30) and (rainfall < 85): #Woodland/Shrubland
            x.material_index = choice([7,3])
        if (temp_proxy >= 3) and (temp_proxy < 20) and (rainfall >= 85): #Temperate Deciduous Forest
            x.material_index = choice([7,4])
        if (temp_proxy >= 3) and (temp_proxy < 20) and (rainfall >= 215) and (rainfall < 215): #Temperate Rain Forest
            x.material_index = choice([4,5,5])
        if (temp_proxy >= 13) and (temp_proxy < 28) and (rainfall < 30): #Subtropical Desert
            x.material_index = choice([6,6,6,2])
        if (temp_proxy >= 20) and (temp_proxy < 28) and (rainfall >= 30) and (rainfall < 265): #Tropical Seasonal Forest
            x.material_index = choice([7,7,4])
        if (temp_proxy >= 20) and (temp_proxy < 28) and (rainfall >= 265): #Tropical Rain Forest
            x.material_index = choice([8,8,8,4])
        if temp_proxy >= 28: #Mars.
            x.material_index = choice([1,9])

Once you've done that, you can use the tool by selecting the landscape you want biome-ified and calling the following function: (Just copy paste this into your interpreter if you don't understand what I'm talking about.)

create_biome(-15,10,40,60)
 
The function works using the following parameters:

create_biome(
    Starting_Temperature, 
    Ending_Temperature, 
    Starting_Rainfall,
    Ending_Rainfall
    )

#Temperature in celcius and Rainfall in centimeters. 

You can use the following chart as a sort of cheat sheet:

Enjoy the first draft! Feel free to modify or make it your own! (This version anyway!)

Click the link below for download link: 
  
Download Here
 

Procedural Landscape Update - Biome Generator

I'm creating a new tool for the landscape generator, surnamed the Biome Generator.

What it does is assign a biome or range of biomes to a selected landscape. (Or whatever is selected really.)

I haven't created the meshes for the trees, shrubs and grass yet, but all it does now is assign a floor material. (Assigns each face with the specified biomes floor or ground color, such as dirt, sand, moss, or swamp shrubs.)

Looks cool right?

Here's one with a much more realistic biome range. (Tundra to taiga)

The green is supposed to be a (plantless) taiga floor, while the grey is tundra dirt.

Now obviously I need to add meshes to represent plant life and snow for the tundra, and you probably noticed I didn't use actual ground textures, just basic solid colors. This is because this is considered low-poly artwork, and though I could use real textures, this is only a proof of concept, so shading each polygon a single solid color is a good start for me.

Now what is a biome?

A biome is a group or neighborhood of a specific range of plants and animals within a certain region, climate, or temperature.

The how the biome generator works is based off of this diagram:

In the generator, you input a range of temperature vs. a range of rainfall, and (Although those aren't the ONLY things that determine biome, I wanted to give developers some degree of imaginative freedom.) based on the combination of the two, it creates a range of biomes starting from the top of a landscape to the bottom. You can make it unrealistic or not.

It's still a work-in-progress, and I'll post the code and much better images when I DO make more progress, (Trees, shrubs, rocks, snow, etc...) but stay tuned!

Procedural Landscape Generator Script

One of the most common things made via procedural generation is landscapes.

I figured I would try my hand at it, seeing as it's not THAT complicated...
I'm also making this because there's this job I really want, and I figured this would be some good supplemental content alongside my resume.

I mean there's always the "Landscape" addon in Blender 3D that generates landscapes automatically, but I don't want that! I want to be able to do this myself!
Plus how useful would that be to be able to us with other stuff??

So I started by creating a simple script that did simply randomized the Z location of a plane's vertices. It looked something like this:

But that's not a landscape, that's a bed of nails, perhaps a bed of rocks. Nobody wants to live in that.

I then moved on to creating a script that subdivided and then randomized the vertices Z locations in iterations. Each iteration is x number of subdivisions with y sized random location, plus with each iteration, the randomness value of each Z vertice location depreciates. I initially got the math a little wrong, and although it was looking a little wavy like a landscape, it still looked like a bed of nails.

So after some repair, I finally created the Landscape Generator Script!
You can change size of the mesh, the number of iterations, the height of the randomness, the depreciation value of the randomness, initial smoothing after each iteration (courtesy of the subdivide tool.), and the random seed.

Now it looks WAY more like a landscape! I'll add a feature that allows me to control plateaus, sea level, and perhaps something that'll smooth the edges of the mesh out a bit, as if to create an island, but for now, this will do.

I will add that you can still make your landscapes look ridiculous. Here's some generated with uselessly out-of-scope values:

SUPER MOUNTAIN RANGE!!

I think it actually looks really nice...

To use simply copy/paste the following lines into your python interpreter:

from random import *

def landscapemake(size,sigma,iterations,antiintensity,cuts_per_it,smooth=1,ranseed=2):

    bpy.ops.mesh.primitive_plane_add(radius=size/2)

    seed(ranseed)

    for it in range(iterations):

        bpy.ops.object.mode_set(mode='EDIT')        #throw mesh in editmode and subdivide.

        bpy.ops.mesh.subdivide(number_cuts=cuts_per_it,smoothness=smooth,fractal=0)

        bpy.ops.object.mode_set(mode='OBJECT') 

        for vertex in bpy.context.object.data.vertices:     #Here we modify the verts themselves.

            intense_mod = (antiintensity/iterations)*it  #This is to control sigma over time.

            itcopy = (it*intense_mod)+1     #This decreases sigma over time and avoids /ing by 0.

            height = gauss(0,sigma/itcopy)

            vertex.co.z += height

And then use the following line to execute the script:

landscapemake(10,.4,4,5,2,1,2)

To explain what those values are:

landscapemake(Size,
    SigmaHeight,
    NumberofIterations, 
    IntensityReduction,
    SubdivisionsPerIteration,
    Smooth,
    RandomSeed)

At this point, you pretty much just need to enjoy it. There's not much to it. It was also an incredibly simple script to create!

I'll create a tutorial in time. For now, just enjoy this thing and stay tuned!!

Download Script Here

Procedurally Generated Coloring Book Pages

What... am I... Doing?

I've always had a huge fascination with those adult coloring books that keep getting released. I had some ideas and thought I'd try my own hand...

I took some procedural graphics I made a little while earlier, moved the camera to a cozy spot, added some freestyle edges, and turned them into black and white pages. Here's what turned up.

Some of these are obviously going to look better than others. The top was my first attempt and for a coloring page, I found it a bit too roomy.

As for the last two images, I couldn't decide which was preferable.

So where is this going?

Well, for those interested, I am planning on compiling an adult coloring book full of graphics completely developed via procedural generation like unto the ones in this article.

The newer images will all contain some similar graphics, some voxel generated landscapes and meshes like unto the others I've posted on this blog, and some newer ideas I have in mind. The quality will be better, there WILL be makeshift backgrounds, and it will all be VERY COOL.

So be excited!!

These first few pages are free, and are a look of what is to come. Do stay tuned!

For an example of what an adult coloring book is, here's a look.

Why would you create a scientific coloring book? 

 

I was inspired by this fibonacci coloring book. Take a look!


If you'd actually like to color these pages, you can either save each image directly from this post, or just download a zip folder here:

 - Download


Hope you like em! You can either print em or even open them in Photoshop, Gimp, or Krita if your really up to coloring digitally.

Speed Scripting: Cube... Clouds.

I was thinking "I really need to get started using Blender again, it's been a week or so."

And I had an idea I wanted to pop out, and a few minutes of time.

So I made it; here it is!

The Random Cube Cloud Generator

It makes cloud-ish clusters like this:

What it does is basically create random cube clusters in random locations within a certain area.

You can determine how many clusters, the size of the clusters, how many cubes per cluster, the size of the cubes, and the size of the area in which the clusters spawn.

It could be modified to make clouds, weird terrain, or... something. I'll probably play with it and post about it later.

To use:

 

1. Copy/Paste all the text from the file to your blender python interpreter.

2. The following is how to use the script:

cubouds(quantity, range, cluster size, quantity of cluster cubes, cube size)

So an example you could copy/paste is this:

cubouds(15,20,5,7,.5)    #Just play with these parameters.

Here's a download link:

Download Here 

Stay tuned for more awesomeness!!! 

Voxel Landscape Script

Cubes. YAY.

Yes. It happened. I was playing with cubes, it was bound to happen. 

I messed with the Voxel Blob script and managed to create a funky landscape tool.

It looks really awesome...

Since I built it off of my voxel blob script, I can also use addbase() to create custom start locations!!

Progress 1

Progress 2

AND if you want to save memory (or cubes) you can create a plane or whatever shape you want in any spot, and it will refuse to place cubes beyond that point. So I can use a plane to keep the script from needlessly a pile of awesome where I'm not going to see it.

Progress 3

OH and I should mention I made a script for assigning awesome colors to objects in a scene based on elevation. I'll post that if you want too.

You can user that in conjunction with anything really, not just voxel stuff. Here's a scene I made via the landscape tool, and that colorizer;

ALSO... the landscape generator actually has this behavior where it tries reach upward until the cubes reach about 9 blender units on Z, where it then pans out horizontally, and then begins reaching upward again around 12 blender units on the z axis. You can see in the image above where it tries to thin out and reach up, and where it tries to pan out and cover a wider area.

The best way to achieve this result is by using addbase() to create base points around the area where it tries to pan out, (0, 10, & 16 are the points where it pans out.) otherwise it just gets stunted and makes funky mountains and... tower things. Still pretty cool.



So to USE the Voxel Landscape tool, simply add as many base cubes as you like with;

addbase(x,y,z) #This is used to add custom start locations

Then use the following to generate cubes;

cubecraft(quantity)     #You can use this repeatedly to add more and more.

I usually generate larger stuff in smaller increments just so I don't irreversibly freeze Blender over.

Here's the download link for the Voxel Landscape Generator. The color assignment script download and tutorial will be in the next section...

Download Voxel Generator
 

MAKE COLORS...

NOW, for the color assignment script, what it does is assign a number of materials you've created to several objects. Based on how far up the Z axis on the object is, is what will determine which material is assigned. There were several examples of this above, but here's another one;

For this I created 18 materials. One for each Blender unit on the Z axis. It always starts with zero. You could change that if you want, but for now it starts on zero.

To use it you it simply select whatever objects in a scene you want colorized, and copy these first 3 lines into Blenders python interpreter;

#Get the objects you want colored selected before running this.
golst = []       
for x in bpy.context.selected_objects:
    golst.append(x)

Then go ahead and either select a totally hidden object, or create one that's meant to be disposed of later and create every material you want in the scene. Starting with whatever material is lowest on the Z axis, and ascending to the whatever material will be highest on the Z axis.

Once you've finished creating the materials, make sure the same object containing the materials is selected, and run the next 3 lines;

john = []
for x in bpy.context.object.data.materials:
    john.append(x) 

Then go ahead and run the following lines;

for x in golst:        #The bottom colors go first.
    loc = x.location.z
    for r in range(len(john)):
        if loc > r-.5 and loc < r+.5:
            x.data.materials.append(john[r])

BAM!!! ENTER COLOR!!!

You can download the whole color script here: 

Download Color Assignment

Voxel Blob V.2

I totally remade the Voxel Blob script. It behaves slightly differently, and It just works in a much simpler, faster, and more manageable manner.

You can see it's a bit more compact. The first one looked almost like voxelated coral. -Which was cool I might add, but this version is designed for customizability.

And I also added a little function to add base cubes wherever you like, for the sake of having SOME control over how it produces itself. It merely determines start locations. You can use more then one at a time. (As many times as you like!)

Here's a couple rounds of addbase()

Here is what came of it.

I AM DONE WITH GREY.

If you'd like to play with it, (It's much easier to manipulate then my previous version) (And it has comments this time!) here's how to use it, and a download link:

First just copy all the text in the .py file to your blender python console,

To add base cubes just type;

addbase(x,y,z)

To add a heaping voxel blob onto your base cubes, (Without any base cubes, it just starts at (0,0,0)) just type;

cubecraft(quantity)

And that's it! You can continue to uses cubecraft() as many times as you like to continually add onto your... blob. Your awesome blob. Awesome Bob.

 - Download Here -



Stay tuned for whatever!!