Jump to content


  • Content count

  • Donations

    0.00 CAD 
  • Joined

  • Last visited

  • Days Won


Everything posted by malexander

  1. A Lot Of Rbd Fun

    If you want anyone to download this, you may want to provide more details and log in as a user... otherwise, your post looks suspiciously like a virus (which it may well be).
  2. Dd Uses Houdini On Stealth

    The story is also on www.sidefx.com, with a few nice pics as well (may need to reload the page a couple of times to get the stealth story up).
  3. Reloading File Sequences For All Files?

    You could also: 1) Select Tools->Clear Compositing Cache (Alt+Shift+R) to clear the files (and everything else too, but since File nodes tend to be most of your base generators, this isn't as bad as it sounds) or, in 8.0, 2) Check the 'Reload All Files' toggle in the Composite Output driver (if you are using one). It will then reload all the Files nodes every time before it renders.
  4. The Next Generation

    Thought this was interesting. Even though Sony & MS are pushing threaded games, it's no surprise that game developers aren't too happy with that or the CPUs they've chosen. It looks like a vast amount of the silicon will sit idle on these new consoles, because developers simply can't find any appropriate tasks to keep them busy. http://www.anandtech.com/video/showdoc.aspx?i=2461 A shame, but multithreaded software is really tough to write, so I can't imagine a lot of games actually using more than 1 thread (or, more than 1 thread running anywhere near 100% CPU capacity). I guess developers will have to hope that more mutlithreaded game engines become available (like Unreal 3.0). Nvidia has stated that they're going to thread their drivers, which would help, but frankly, I fear for driver stability, especially if it makes it into their mainstream drivers. With the advent of dual-core as a buzzword, seems like everyone's diving into what could be some pretty hot water
  5. Google Earth

    Ah... but watch out! Google's headed the way of the dinosaur -- better click on that link pretty darn quick! http://news.softpedia.com/news/Ballmer-Goo...ears-1948.shtml Statements from Microsoft are frequently good for a daily chuckle.
  6. Large Convolution Kernel?

    The convolve COP also accepts an image as a second input for the kernel data. If you could make a 15x1 image of your kernel (in FP, likely, since it has negative components) , then you could feed it into the convolve COP to do the job. Even if you had to generate the kernel through a VEX generator, the convolve COP / kernel generator COP combination would likely be much faster than the 15 independent lookups that the Hilbert convolve VEX cop would need to perform. You could create a digital asset out of the small network to create a Hilbert Transform COP, if you needed this operation frequently.
  7. How Does One Create This Effect

    Uuh.. yes. Timefilter will work great, filtersize 90, Filter Range set to "After Current", write out frame 1. So many ways to do things, I forget ones I've written.... Thanks Jason.
  8. How Does One Create This Effect

    There's a File OP chooser in Houdini which can do this really fast. 1) In a network editor, press ` (backtick) 2) Change to the dir where your images are, and turn off 'Filter Sequences of files into single entries' (icon beside the Pattern box) 3) Select all the image files (left drag, or LMB click first, Shift+LMB click last) 4) Accept! 90 File COPs will be created for you, one for each filename. To wire them all into a layer COP, put down a layer COP, then select all the file COPs, then wire the first file COP into the layer. I normally use it for importing all of my image sequences at the beginning of a comp, but it works just as well for this.
  9. vex multithreading problem ?

    I've found that multithreading VEX only makes an impact if the amount of work that you're doing per point (or pixel) is really heavy (like 50+ lines). VEX batches data together in groups, and that overhead must be single threaded, while the excution of the code is multithreaded. So, if the work per-pixel or per-point is small, the execution phase will be a smaller percentage of the total cook time for a group, and you won't see as much of a benefit from the threading.
  10. Gatorade Commercial - Digital Domain

    VEX does have a few limitations which makes unable to be used for certain algorithms. For SOPs, VEX cannot create or alter topology, which means that the majority of SOPs can't be programmed in VEX. In COPs there are more opportunities to use VEX because image processing is similar to shading, but many COPs give hints to the cook engine which vastly improve performance which couldn't be done with VEX (like collapsing transforms and color correction, and optimizing out contant regions). Finally, you can't do a 'pre-run' in VEX to figure out global data (like 'what is the average color of the image') , nor can you do multiple discrete passes over an image to implement an algorithm in stages. In short, there are some things VEX can't do, and other things VEX can't do very optimally. However, the things VEX can do, it does very well
  11. Gatorade Commercial - Digital Domain

    Compositing in H8 has received incremental updates, so the 'What's New' list there won't sound all that interesting, as there aren't any major features introduced. However, interactive cooking is much faster and a couple of troublesome workflows have been polished. The biggest advances to compositing aren't very compositing related, but they'll definitely have an impact on COPs: The first is support for 1D and 3D LUTs, and the ability to generate these through the color correction COPs in Houdini. These integrate into the COPs viewer, flipbooks and mplay, providing much needed general color correction throughout Houdini. The second advance is in ROPs, which allows ROPs to be wired together in a dependency tree. When rendering a ROP, it will render all its input ROPs first. This really ties COPs in with the rest of the package, and smoothes out the process of compositing large numbers of layers in a shot. You can build a large ROP tree with all your rendering passes, simulations bakes & composite nets, and then render the final composited sequence with one click on the final ROP.
  12. Deep Raster Problem

    If you do end up with a few holes, you could use a Median filter (Median Cop) to remove the specks. But your image shows large bands of 'bad' depths, so you'd still be stuck with those. If all else fails, try rendering out your scene as a Z map only, minus reflections and anything fancy, and see if the artifacts are still there.
  13. By The Lake.

    Talking about DOF in compositing, I'd recommend using the DOF Cop with the Defocus Cop. Set the option 'Per Pixel Defocus' in defocus. It looks a little nicer, and it's actually a bit faster. Your render times will also drop, which is always good.
  14. Morpning

    The only way of getting at the rotoshape CVs is through ch() expressions. The channels involved are: numcurves - total # of curves c[index]numpoints - total # of points in curve 'index' (index starts at 1) c[index]pnt[p] - point 'p' of curve 'index' (X,Y) However, it would be quite a chore to get this information into VOPs, since it's all variable, and would have to be done in loops somehow. I can't think of any way to do it offhand.
  15. PPU what does this mean to simulation?

    It means you have to buy yet another PCI-E card to run a bunch of future programs At 130 million transistors, able to handle 30000 RBD objects and deal with collision detection in hardware, it sounds as or more complex than a graphics card GPU. But just how it fits into a system has me a little baffled; because it has its own API (like OpenGL for physics), this means that a software package (like, say, Houdini) would need to support that API *and* have its own physics API, for those users that don't have the card or chip in their system. As a developer, doing twice the work isn't very desirable. And hardware APIs have this way of being limited by the hardware specs, somewhat limiting their usefulness (as an example, the latest OpenGL drivers *still* don't support non-power of 2 textures, making image processing via the GPU a pain). That being said, handling 30000 RBD objects is great, but how complex can each object be? Do they have to be made up of tris? Quads? Or is a tri an object? What simulation parameters can you adjust (bounciness, gravity, etc). Does it support deforming RBD geo? How finely can it sub-sample? It sounds great on paper, but the details are so scant that it's really hard to tell how powerful the unit actually is. It sounds like it's targeted towards games (or marketing departments), so I'd be surprised if it could do RBD like most of us would expect. "Whitepapers" like this always make me a little nervous. Lots of hype, no specs... suddenly people seem to expect that your app should run 100's of times faster. Many poeple don't understand the hardware's limitations (because the press releases rarely mention them) and come to blame your app instead. I'll be curious to see how long the "PPU" lasts, or to at least see a decent spec sheet Personally, I'd rather have dozens more SSE registers, better SSE vector/matrix math support and better SSE compiler support - sort of like what Motorola has done with Altivec - rather than yet another hardware processor & API.
  16. fetch chop

    On the 'Channel' page of the Fetch CHOP, there's a parm named 'Channel Range'. Set this to "Use Start/End", and enter the Start & End range of your animation (by default, in seconds; Common page - Units parm to change to frames). This will fetch that range instead of the one frame the expression happens to be at.
  17. Morpning

    No *easy* way, no... To properly do morphing, you need a good set of interactive tools, so any VEX/VOP solution would be very cumbersome.
  18. Non-IFD Rop Driver?

    Yep, there's nothing too magical about ROPs All the sequencing work is done by ROP_Node, so all you really need to do fill in the blanks (startRender/renderFrame/endRender) to output your data. The only other thing you may want is the Render button/Frame Range controls. You can build that into your own template list using the fragment: void newDriverOperator(OP_OperatorTable *table) { OP_VariablePair *vp = new OP_VariablePair(ROP_Node::myVariableList); OP_TemplatePair *tp1 = new OP_TemplatePair(ROP_MyDriver::myTemplateList); OP_TemplatePair *tp = new OP_TemplatePair(ROP_Node::getROPbaseTemplate(), tp1); table->addOperator(new OP_Operator("mydriver", "MyDriver", ROP_MyDriver::myConstructor, tp, 0, 0, vp, OP_FLAG_GENERATOR)); } (please excuse any type-os)
  19. Non-IFD Rop Driver?

    The model for a ROP is fairly simple; it uses 3 basic methods: virtual int startRender(int nframes, float tstart, float tend); virtual ROP_RENDER_CODE renderFrame(float time, UT_Interrupt *boss); virtual ROP_RENDER_CODE endRender(); startRender() is called before any frames are rendered; it will let you know how many frames are about to be rendered, the start time and the end time. Return 1 if you can proceed with the render, 0 for failure. renderFrame() is where you do the output work for a given frame. (boss is usually null, if you want to put interruption queries in your code, use UTgetInterrupt()). The render code return value determines how to proceed: ROP_ABORT_RENDER (stop rendering now), ROP_CONTINUE_RENDER (go onto the next frame) or ROP_RETRY_RENDER (redo this frame again). endRender() is called when all the frames are finished, allowing you to cleanup and free any resources. After that, ROPs are fairly similar to other OPs - you'll want to evaluate your parms & determine what to write out. I know this is a bit vague, but there's really no restrictions on what you can do inside a ROP renderFrame() method, so it's a little hard to tell you what to do next.
  20. obj info into chops

    The two inputs are optional. They allow you to compare an object with a set of transform channels (t*,r*,s*,p*), or to compare two sets of transform channels together. Usually, though, it's used to compare 2 objects' transforms.
  21. Hashes and Caching

    You can use a UT_TokenString & OP_Node::getHashCode() to get a very unique description of parameters set on a node & its descendents (or, OP_Node::getParmHashCode() for just that node). They can get rather large depending on the network size, however they're heavily optimized for both space and comparison time. COPs uses them for its smart caching. Since a UT_TokenString has an 'int getHashCode()' method, as well as operator==() and operator=(), it would be pretty easy to make a UT_HashTokenString class. Might solve half your problem
  22. Non Linear Animation

    The CHOPs tutorials from 4.0 should still work fine, for the most part. CHOPs hasn't changed all that much since then, so 90% of the CHOPs tutorials should work as advertised. There may be slightly easier ways to do certain things now, though.
  23. Gelato is a renderer that uses an Nvidia QuadroFX to do some of the rendering calculations. The QuadroFX doesn't render the scene in hardware, it just helps the CPU with parallel computation. It was designed by Nvidia, and the chief architect is Larry Gritz (so it can't be that bad ). There's a plugin for both Maya and 3D Max, and also a RIB stream converter (which you'd probably use with Houdini). You need a QuadroFX 700 or higher. Apparently Frantic Films has incorporated it into their pipeline for an upcoming film (Frantic Film story). There's more technical information at Nvidia's site, as well. (Nvidia Gelato)
  24. You can call 'float FSTART()' and float 'FEND()' to get the start/end frames. To see if the user has turned on frame range rendering, call 'int DORANGE()' to see if the toggle is enabled. (See ROP_Node.h)
  25. Can you trigger an opscript...

    You can use a Math CHOP to subtract 'X' from the channel, and then pipe that into a Logic CHOP. The logic CHOP converts the channels to binary (0/1, on/off), and by default anything greater than zero is a '1', otherwise it's '0'. So by subtracting X from the channel, you're essentially programming in the v > X expression. A logic CHOP has 4 script parms for different conditions: - when a 0-1 transistion occurs (off->on) - when a 1-0 transistion occurs (on->off) - when 1 (on) - when 0 (off) It sounds like you'll want to use 'Off to on'. Incidently, in order for the script to be executed, the logic CHOP must be cooked - so you'll need to setup a dummy chopf() expression in another op which does cook to get logic to cook.