What I've been doing for the past few days...
Besides recovering from the nasty bug that just hit half the planet, anyway.
I've been playing with a program called ContextFree, and it's... slightly addicting. It essentially allows you to draw stuff via programming.
Example code:
startshape DOT
//Note: DOT is a newly declared (created) shape, unlike SQUARE and CIRCLE which are preexisting shapes within the program.
rule DOT {
SQUARE { s 2 } //the square. Note that the stuff in the brackets helps describe the actual shape. This square has a size of 2. Other things that can be
//adjusted are x and y coordinates, hue brightness and saturation (the default color is black), and how many degrees the shape has been rotated.
CIRCLE {x 0 y 0 s 1.5 h 94 sat 0.7 b .5 } //this is the green circle
CIRCLE {x .3 y .3 s .5 h 20 sat 0.7347 b 1 } //this is the yellow one
}
Gives you this:
At first, this seems kind of pointless. After all, most people could draw something this boring with MS Paint. But... ContextFree lets you use recursion while drawing. (Also, random, but I'll get to that later.)
Brief tutorial in programming:
Look at the code again. See where it says rule DOT? That part is the beginning of a method. Essentially, all the commands (SQUARE, CIRCLE, etc.) within the brackets are called whenever the program calls DOT. The phrase startshape DOT at the beginning tells it call DOT when it renders the picture.
Recursion is when a method calls itself. If you don't quite get, don't worry, I'm giving example code now.
Example code:
startshape DOT
rule DOT {
SQUARE { s 2 }
CIRCLE {x 0 y 0 s 1.5 h 94 sat 0.7 b .5 }
SPIRAL {x .3 y .3 s .5 h 20 sat 0.7347 b 1 }
}
rule SPIRAL {
CIRCLE { x .3 y .2 s .5 h 20 sat 0.7347 b 1 }
SPIRAL { x -.44 s .93 r 23 }
}
It's the same code as before, but the second circle has been replaced by a new method: SPIRAL. SPIRAL creates a circle, then calls itself. The information in the brackets tells the program how to change SPIRAL when it is called. In this case, it both rotates 23 degrees, and decreases the size by a factor of 93 percent.
That gives you this:
See? Pretty awesome.
So, I've been playing around a bit, and I ended up making this
with this code:
startshape LASSO
rule LASSO {
CIRCLE { b .1}
CIRCLE { s .9 h 5.14 sat 0.9929 b 0.8785 }
LASSO { x .3 y .3 s .9 r 190 b .15}
}
It should be noted that the picture looks very different depending on how much I rotate the recursive call on LASSO. So, I changed the rotation a bit and got enough cool shapes that I decided that making a gif out of them was necessary.
So, I changed the colors a bit, rotated and saved a few times, and ended up with different variations on this,
which I cropped and used MS gif animator on to get this:
Well, I'm having fun. Also, I'm seriously considering using this for an icon.
By the way, if I was unclear or you have any questions, please ask. I am more fond of explaining this stuff than most people are of learning about it.
I've been playing with a program called ContextFree, and it's... slightly addicting. It essentially allows you to draw stuff via programming.
Example code:
startshape DOT
//Note: DOT is a newly declared (created) shape, unlike SQUARE and CIRCLE which are preexisting shapes within the program.
rule DOT {
SQUARE { s 2 } //the square. Note that the stuff in the brackets helps describe the actual shape. This square has a size of 2. Other things that can be
//adjusted are x and y coordinates, hue brightness and saturation (the default color is black), and how many degrees the shape has been rotated.
CIRCLE {x 0 y 0 s 1.5 h 94 sat 0.7 b .5 } //this is the green circle
CIRCLE {x .3 y .3 s .5 h 20 sat 0.7347 b 1 } //this is the yellow one
}
Gives you this:
At first, this seems kind of pointless. After all, most people could draw something this boring with MS Paint. But... ContextFree lets you use recursion while drawing. (Also, random, but I'll get to that later.)
Brief tutorial in programming:
Look at the code again. See where it says rule DOT? That part is the beginning of a method. Essentially, all the commands (SQUARE, CIRCLE, etc.) within the brackets are called whenever the program calls DOT. The phrase startshape DOT at the beginning tells it call DOT when it renders the picture.
Recursion is when a method calls itself. If you don't quite get, don't worry, I'm giving example code now.
Example code:
startshape DOT
rule DOT {
SQUARE { s 2 }
CIRCLE {x 0 y 0 s 1.5 h 94 sat 0.7 b .5 }
SPIRAL {x .3 y .3 s .5 h 20 sat 0.7347 b 1 }
}
rule SPIRAL {
CIRCLE { x .3 y .2 s .5 h 20 sat 0.7347 b 1 }
SPIRAL { x -.44 s .93 r 23 }
}
It's the same code as before, but the second circle has been replaced by a new method: SPIRAL. SPIRAL creates a circle, then calls itself. The information in the brackets tells the program how to change SPIRAL when it is called. In this case, it both rotates 23 degrees, and decreases the size by a factor of 93 percent.
That gives you this:
See? Pretty awesome.
So, I've been playing around a bit, and I ended up making this
with this code:
startshape LASSO
rule LASSO {
CIRCLE { b .1}
CIRCLE { s .9 h 5.14 sat 0.9929 b 0.8785 }
LASSO { x .3 y .3 s .9 r 190 b .15}
}
It should be noted that the picture looks very different depending on how much I rotate the recursive call on LASSO. So, I changed the rotation a bit and got enough cool shapes that I decided that making a gif out of them was necessary.
So, I changed the colors a bit, rotated and saved a few times, and ended up with different variations on this,
which I cropped and used MS gif animator on to get this:
Well, I'm having fun. Also, I'm seriously considering using this for an icon.
By the way, if I was unclear or you have any questions, please ask. I am more fond of explaining this stuff than most people are of learning about it.