1st Annual Houdini Hacker Contest

[Wolfwood]

The Contest:

Using no more than 42 nodes in Houdini create an image or animation for everyones viewing pleasure.

This contest is similar to the Demo Scene that those hacker types have. In the "Demo Scene" crazy programmers create images and animations using a super tiny program. The contest forces you to be not only artistic but also technical since you have to be very efficient and clever in how create your networks. For some examples of "real" demos from the Demo Scene you can go to www.scene.org. Here are some of the best from the previous year. http://www.scene.org/awards.php?year=2004

(Notice how some of them are only 4k.)

A good example of creating a lot of content with very little input can be seen here

http://odforce.net/forum/index.php?showtopic=3156

This contest is open to everyone, including SESI employees, (I'm talking to you Wagner). (Well open to everyone but the judges.) Also, using the retail or apprentice version of Houdini is perfectly fine.

Most importantly, the main point of this contest is learning. By having a node limit you are forcing yourself to try new avenues and approaches, and best of all, when the contest is all over you'll get to see everyone else's hackery.

Submission:

Note: You are allowed to have multiple submissions, just as long as the submissions are fairly different from each other. Submitting two hip files where the only difference is a node or two isn't acceptable. But if you have completely different ideas and want to submit each the go for it.

All entries should be zipped and contain the following 3 files.

Hip or Hipnc file-

We will be verifying the hip files in the Production Builds of Houdini (version 7 and 8) and whatever the latest version of Houdini 8 is at the end of the contest.

Final output- (Image/animation/interactivity)

Images should be in tiff/jpeg/png format, animations should be compressed in a semi popular/common codec.

Interactivity is another option. Instead of rendering out a picture/animation you can also set up your Houdini session to do something like particles interacting with the mouse pointer using the Mouse CHOP. A long long time ago back when version 6 of Houdini came out, a interactive Pong clone was made using Objects, POPs and CHOPs. Doing stuff like this is also perfectly ok.

readme.txt-

Inside the readme should be contact info, (email address, or odforce forum handle)

Also directions on how to "reproduce" your final image/animation. (Render mantra1, hit play in the playbar etc)

If your entry is a interactive demo, then make sure you describe exactly how start the demo. ie)

1- Go to Objects

2- Hit Scroll Lock

3- Hit Play.

If are submitting a animation make sure specify which codec you used.

Email submissions to-

houdini-hacker [at] stickylight [dot] com

If your submission is more than 3-4MB, it might be too large for email. In these cases you can upload via ftp. (For ftp access information please send me a PM).

Please post questions to the forums at odforce.

Deadline:

Before December 1st, 2005 GMT. (All of November)

After the deadline all the entries will be posted on odForce for everyone to enjoy (and learn from).

Prizes:

First Place-

One copy of The Magic Of Houdini

One copy of the Gnomon Workshop DVD Houdini 101: Interface and Workflow

Second and Third Place-

Will get to choose either

One copy of The Magic Of Houdini

or

One copy of the Gnomon Workshop DVD Houdini 101: Interface and Workflow

Judging:

Our team of judges (judges TBA) will judge your final images/animation for their artistic quality AND the hip files for their technical merits. When I say technical quality I don't mean you have to use tons of expressions/scripts/etc, it just means we are checking to make sure you followed the rules below.

When Judging the submissions we will be looking for a couple of things:

(Note this isn't meant to be super strict, these are just to give you an idea of what we like to see)

Proceduralism-

This one is the most important. The point of having a limit on the number of nodes you can use is to force you to use proceduralism to create as much content as nothing. Simply modeling a character with a bunch of edit/ poly-extrudes poly-splits sops isn't really procedural. However creating a simple character and the procedurally growing spike, plants, and teapots out of its head using the SOP Solver is procedural. (Keyframing is ok, but keyframing a character walking won't be ranked as high as a character moving procedurally.)

Artistic-

Is your rendering interesting? Visual aesthetic?

Technical Hackery-

You only have 42 nodes. Are you using them wisely? Could you have combined 3 SOPs into one? Technical Hackery doesn't mean obfuscation. It means are you using different tricks to get the most out of you network. Also these are just things we are looking for, but if you don't have tons of "technical hackery" it doesn't mean we won't be impressed.

The "Whoa, how did they do that?" Factor-

Getting us to say, "Damn I didn't know you could do that." is always a good thing.

Good Clever vs Bad Clever-

An example of "good clever" would be using POPs/DOPs to procedural do a lot of your modeling based off a COP network. "Bad clever" would be embedding a 10 meg hip file with 1000s of nodes into an embedded OTL then extracting it, opening it up as a subprocess hscript session, rendering it then reading the result in. Then again, starting up a subprocess hscript session and keeping within the 42 node limit is a good clever. Confusing? Good.

Rules:

*No more than 42 nodes maybe created. All nodes count toward this total, Subnets, ROPs, even the various network OPs (ie chopnet). So when you start out make sure you do a File->New to clear out any of the default stuff. Note, you may not create more than 42 nodes total, in other words, you can't start off with say 42 nodes then during a script create 23 more, then delete the extra nodes when you are done with them.

*Becareful, container nodes also count. (POPNets and CHOPNets for example). So if you aren't using any particles or chops make sure you get rid of /part/popnet1 or /ch/ch1.

*Some of the Object nodes in Houdini have SOPs in them that aren't needed either. Like the Null Object, has a control and point sop that can be deleted.

*VOPs and VOPNets do NOT count toward the 42 nodes used. The reasoning for this is because you can write the VEX Code by hand in a HDA and someone who was good at doing this has a huge advantage over someone using VOPs (since you need to use a lot of VOPs to do simple operations). Remember though, VOPs and VOPNets do not count, however their instances (SHOPs, VEX SOPs, etc) do count.

*No locked OPs (CHOPs/SOPs). Everything must be generated procedurally on the fly.

*No pre-existing external resources. (textures, geo, etc) You are allowed to generate data procedurally from your Houdini session. (Stuff like shadow maps, textures, point clouds etc.)

*One exception to the no "external resources rule" is that you ARE allowed to use an input source to drive/seed your procedural networks. Input is allowed (audio/video) if its uniqueness isn't a factor. In other words, if I supply a different audio file the hip file will generate a different result, but just as cool. Like a character dancing to music, it doesn't matter what the input music is, it will work properly with whatever waveform. If you are using an input source make sure you include a small sample with your submission.

*You must specify how to activate the Hip file to "demo your demo". Ie) hit the Play Button or render the Mantra ROP. The judges will use only one form of activation. (We won't render the mantra1 ROP, then hit play button, then render the mantra2 ROP...if you have render dependencies you can use the Render Dependencies in Houdini 8, but that will cut into the number of nodes you are have available. Be clever and figure out other ways. (Hint Logic CHOP, pre/post-render scripts.)

*You may use OTLs but they must be embedded into your Hip file. You are allowed to source/exread the sections inside an OTL, but you may not reference textures/geo/channels that are in OTLs. Remember even though you are allowed to source scripts inside of OTLs, any opadds that you do count towards the 42 nodes. So be careful.

*Houdini Digitial Assets (HDAs) are allowed, however the HDA counts as a node along with all the nodes inside of it. Forexample, if you use the Color SOP that counts as 9 nodes. The Color Sop is 1, plus the 8 inside that make it.

*When lighting your scene remember to delete the geometry inside your lights/camera. The nodes inside those objects will count.

*Caution: Some Houdini nodes are actually HDAs, use with caution, (Color SOP).

Misc:

If you have any general questions please post in this forum.

If you have any questions that you want to keep private cause they'll "spoil the surprise" then you can send me a PM.

Also, this contest is not affiliated with Side Effects Software Inc. or the authors of the prizes in anyway... (well..I do spam on the sesi forums a lot...but that doesn't count.)

Good luck and have fun.

Edit #1- 11-01-05

Edited grammar. (Thanks ben)

Edit #2- 11-02-05

Added a bit about allowing interactive submissions. (Where you hip file does something based on user input.)

Edit #3- 11-06-05

Added a note about allowing multiple submissions.

[michael]

sounds like great fun Jim....

ps....I'm moving this to the WIP section and making it sticky

[antoinedurr]

So I assume that at some point you will do an:

opcf /

opscript -r . > numlines

unix grep opadd numlines | wc -l

and make sure the result is 42 or less. My question, assuming the above is true, is *when* will you do this? When the file's just loaded, but before you hit 'go', or after you hit 'go'?

[michael]

I believe the idea is that whatever the /result/ of your work is (pic/avi etc) must have been created with a total of 42 nodes...so if, in the course of your session, you have a script that creates 10 nodes - those nodes add to your total...even if your script deletes them later

[Wolfwood]

So I assume that at some point you will do an:

  opcf /

  opscript -r . > numlines

  unix grep opadd numlines | wc -l

and make sure the result is 42 or less.  My question, assuming the above is true, is *when* will you do this?  When the file's just loaded, but before you hit 'go', or after you hit 'go'?

22285[/snapback]

All the above... No more that 42 can be added. (Through opadd, opread, etc) You can start off with 18 nodes....opadd 24 more in while whatever is rendering/running. That's perfectly fine....but say you start off with 18 nodes, opadd 24 more, then delete those 24, the add 24 new ones....that is bad and will be smacked with a meatball sub.

Back to your question, as far as checking the hip files there are a few automated ways....(the opscript way above, checking the performance monitor, etc). But ultimately each hip file will get a nice dissection done on it too.

Plus at the end of contest all the hip files will be posted, and if someone found out some ultra hacky method of tricking us then the community will tar and feather them.

[deecue]

very cool jim.. this will be great..

[deecue]

just thought of a question.. what about playback and performance issues? can a flipbook render be used without considering it as an actual node?

i.e. you don't want the animation to be rendered, just played back through the viewport. but because computers can vary or maybe you have simulations going on, realtime is not an option but needed for the look.. so can one request the scene to be viewed through a flipbook render?

[Wolfwood]

just thought of a question.. what about playback and performance issues? can a flipbook render be used without considering it as an actual node?

i.e. you don't want the animation to be rendered, just played back through the viewport. but because computers can vary or maybe you have simulations going on, realtime is not an option but needed for the look.. so can one request the scene to be viewed through a flipbook render?

22298[/snapback]

Yea, while doing testing or trying out different things you can do whatever you want. Its just the final result that is submitted has to adhere to the limit.

[crunch]

Please note:  I reserve to the right to make minor corrections to the rules during the first week.  (To close loopholes and add clarity if people ask questions).

Here's a command file which counts OPs in the .hip file. It's not officially part of the contest, but it can be useful in designing your entry.

#
#  Given the command line arguments, count all the operators inside
#  Only consider operators which count to the 42 total
#  Add this to the net total.
#  Run the script without any arguments
#
set root = 0
if ($argc == 1) then
    setenv OPCOUNT = 0
    countop.cmd /
    set root = 1
endif

for i = 1 to `$argc-1`
    set op = ${arg$i}
    set t = `optypeinfo($op, "n")`
    if ($t == "OBJ" || $t == "SOP" || $t == "ROP" || $t == "POP" \
      || $t == "CHOP" || $t == "SHOP") then
        setenv OPCOUNT = `$OPCOUNT+1`
        echo $OPCOUNT $t $op
    endif
    set kids = `run("opglob $op/*")`
    if ("$kids" != "") then
        countop.cmd $kids
    endif
end

if ($root) then
    echo Total: $OPCOUNT Ops
endif

Here's the output when run on the default scene file:

hscript Version 9.0.30 (Compiled on 10/25/05)
/ -> countop.cmd
1 OBJ /obj/model
2 OBJ /obj/ambient1
3 OBJ /obj/light1
4 SOP /obj/light1/point_cone_switch
5 SOP /obj/light1/final_light
6 SOP /obj/light1/areashape_switch
... (stuff deleted because it's just noise)
91 SOP /obj/cam1/file1
92 ROP /out/fast_mantra
93 ROP /out/mantra_sel
94 ROP /out/mantra1
Total: 94 Ops
/ ->

[Wolfwood]

I just made a small addition to the rules.

One of the original intents of the contest was to allow submissions of interactive Hip files. Unfortunately during the different drafts of the rules the parts about interactive submissions got removed by mistake.

Interactive submissions are setting up your hip file in a wait where the user can interact with it. So instead of rendering out an image or animation you could build an interactive network.

Some examples of interactive Hip files are,

-Making a Pong clone using Particles, Objects, and CHOPs. (Using the keyboard chop for input).

-Interactive Particle flocking, using the mouse to control particle motion

[ykcosmo]

I will try my best..........>_<

[Wolfwood]

Couple of things,

-Since a week has pasted since the first posting the rules aren't changeable anymore.

-The last big change to the rules is you are allowed to have multiple submissions. (Just as long as they are completely different, doing slight variations won't cut it.)

-Best part of all, we've already had a few submissions. One of the "submittors", Crunch, asked if I could post his submissions to help inspire everyone else. So here they are.

[Wolfwood]

The first one Crunch submitted was a cute little calculator based on selection scripts. (Note, this wasn't an "official" submission, it was an example to ask if interactive demos were valid..which they are.)

[Note: I made a few small modifications, I changed the path to the selection script from just button.cmd to "$HIP/button.cmd" because this windoze box was having trouble with the path.]

calc.zip

[Wolfwood]

Crunch's second,

The obligatory global illuminated scene of a bunch of scattered

objects.

Who Am I

--------

    OdForce handle:  crunch

Instructions

------------

    There's a shell script enclosed called RUNME.sh

    Run the shell script.

    Go for coffee, or lunch, or maybe even dinner

    Ta da!

Notes

-----

    - Note the use of ray_motionfactor to speed up depth of field

computations (see the camera render tab)  See how fast it

renders :-)

    - Irradiance caching is used to speed up the render.  However,

      since the threads are fairly heavy geometry, irradiance caching

      doesn't help too much.

    - The shaders were initially written as stand-alone VEX shaders,

      so the VOP networks are fairly obscure (inline VOPs).  However,

      both shaders boil down to a single line of VEX code.

    - The irradiance uses a cone angle of 60 degrees.  This isn't

      physically accurate, but since the irradiance is computed over a

      smaller solid angle, you end up with smoother shading.

screws_23ops.zip

[altbighead]

really nice..

I think I will go with less technical oriented submission.

[Wolfwood]

I made a modification to Crunch's script that he posted, I added checks for container nodes (like ChopNets) and also DOPs and COPs since those count too.

(I also changed countop.cmd to $arg0 cause I'm cool.)

Also note, this script is just a tool and isn't the only check that will be done on your networks.

#
#  Given the command line arguments, count all the operators inside
#  Only consider operators which count to the 42 total
#  Add this to the net total.
#  Run the script without any arguments
#
set root = 0
if ($argc == 1) then
   setenv OPCOUNT = 0
   $arg0 /
   set root = 1
endif

for i = 1 to `$argc-1`
   set op = ${arg$i}
   set t = `optypeinfo($op, "n")`
   if ( $t == "OBJ"    || \
        $t == "SOP"    || \
        $t == "ROP"    || \
        $t == "POP"    || \
        $t == "CHOP"   || \
        $t == "SHOP"   || \
        $t == "IMG"    || \
        $t == "CHOPNET" || \
        $t == "COP2"   || \
        $t == "PART"   || \
        $t == "DOP" ) then
       setenv OPCOUNT = `$OPCOUNT+1`
       echo $OPCOUNT $t $op
   endif
   set kids = `run("opglob $op/*")`
   if ("$kids" != "") then
       $arg0 $kids
   endif
end

if ($root) then
   echo Total: $OPCOUNT Ops
endif

[Wolfwood]

Hey everyone, here is a little trick that might help slim down your SOP/POP networks.

The group parameter on nodes is actually very flexible. In addition to accepting a list of points/primitives or group names it also supports pattern matching and range matching, much like the Group SOP.

Take a look at the attached hip file. In /obj/model I've made a spikey platform of doom, inside there are three different methods to making the platform. Two of the methods use five nodes, but one of them only uses four nodes and a range matching expression.

hdox://houdini/content/base/model_group_lang.xml

This isn't just useful for this contest, by cutting back on group nodes it can cut down memory usage of networks that use large data sets. (Like geos that are 100MBs)

groupTrick.zip

[Jason]

I made a modification to Crunch's script that he posted, I added checks for container nodes (like ChopNets) and also DOPs and COPs since those count too. 

Sorry if you've mentioned this somewhere earlier, but do Null operators count? I use them just for placeholders - for usability and readability.

[Wolfwood]

Sorry if you've mentioned this somewhere earlier, but do Null operators count? I use them just for placeholders - for usability and readability.

22518[/snapback]

Yea they count, (even though they don't do anything...well besides the Object Null).

If you use Null SOPs/POPs/CHOPs

You can do something like

set nullList = `run("opfind -t null -T SOP")`
set nullList = $nullList `run("opfind -t null -T POP")`
set nullList = $nullList `run("opfind -t null -T CHOP")`
set nullList = $nullList `run("opfind -t null -T COP2")`

foreach null ( $nullList )
    opcf $null
    opcf ..
    set nullInput = `opinput("$null",0)`
    set nullOutputs = ""
    set numNullOutputs = `opnoutputs("$null")`
    for i=0 to $numNullOutputs
        set outNode = `opoutput("$null",$i)`
        set numNodeInputs = `opninputs("$outName")`
        for j=0 to $numNodeInputs
            if (`opinput("$outNode",$j)`=="$null")
                opwire $nullInput -$j $outNode
            endif
        end
    end
    oprm $null
end

To remove all your nulls when you are ready to submit.

[koen]

Hello all,

I have just submittted my entry for the contest. If anybody is as curious for the entries as I am, he might enjoy the quicktime I created to show mine.

It is a 4 MB quicktime sorenson 3 video:

http://www.stickylight.com/public/hh/Kv_Lo...ominos_V2.8.mov

Back work now to make up for time spend on this great contest. Thanks to the odforce crew for organising!

Cheers,

Koen Vroeijenstijn