Category: Poser

Nodes are the essential building blocks in the Advanced interface to the Poser Material Room. They are the graphical representation of mathematical function calls, that is: calculation procedures which turn parameters (inputs) to a result (output).

Advanced

Connecting node outputs (function call results) to node inputs (function call variables) make a very flexible way to build material definitions, like a programming language. The disadvantage is that the resulting node-trees might become quite large, and incomprehensible.

The Compound node is offered to resolve this, as a way of packaging.

Let’s take an example. In the definition area of Material Room, add a Compound node. It’s empty, and looks like:

Open the node (the  button), and I can build a complete structure between the final node containing all External Outputs (left in the scheme below) and External Inputs (right in the scheme).

This example structure calculates

Output_3 = [ 2 * ( 2 * Input_1 +1) ] * [ 1 * ( 3 * Input_2 +1) ]

When done building the node can be collapsed (the  button) and will just show the outputs and inputs defined in the Material Room definition area:

Yes, you read it correctly; the compound node can offer multiple output slots.

On top of all this, the context (right-mouse-button) menu offers two additional options:

The first, Collapse, is a fast way to create a new Compound node. Just select all the relevant nodes I want to be moved into a new Compound one, and click this option. This will give me a Compound node with those nodes, plus an External Outputs and an External Inputs one. The only thing I have to do now is to create – or check – the connections between these External nodes, and the structure I’ve moved in.

The second, Expand, does the opposite. It takes the selected Compound node, moves the embedded node structure to the Material Room area, and eliminated both External nodes. In both cases, existing connections between nodes outside and inside the Compound nodes are maintained, and (de-)assigned to the External nodes as appropriate.

So

Becomes

And

And reverse.

Next >

Nodes are the essential building blocks in the Advanced interface to the Poser Material Room. They are the graphical representation of mathematical function calls, that is: calculation procedures which turn parameters (inputs) to a result (output).

Advanced

Like I can define my own surface definitions by plugging node driven effects into PoserSurface (and other root node) inputs, so I can define my own effects by combining nodes into constructions. Functions calling functions calling … and so on.

Of course the effect nodes themselves, as discussed in the various articles, are relevant bricks in such constructions. But to glue them together and to help me with the construction, the nodes from the Math group make the mortar between the bricks. And the nodes from the Variables group get the information from the scene, like the time and place of the spot on the surface for which PoserSurface is defining the material for. As node constructions can be huge, the Compound node was introduced (Poser 10/Pro 2014) to keep clear boards in the Material Room.

Next >

Although various configurations can be setup via Material Room menus, and can be managed through the Simple interface, this topic is considered Intermediate level.

Intermediate

Each object in the Poser scene is a mesh, consisting of vertices, and polygons defined as ordered groups of vertices; usually three (tri geometry), or four (quads). On one hand, an object mesh even can be formed by multiple submeshes declared to be one, even when they are not connected. On the other hand, a single continuous (sub)mesh can have its vertices and/or polygons organized into groups.

In Poser, groups are managed via the Group Editor, accessible via the Grouping Tool icon in the Editing Tools palette. The Group Editor takes a serious portion of the Figures and Props Editors chapter in the Poser Reference Manual, and reading this carefully before use is much recommended as the tool is quite powerful and can have drastic effects on the behavior of objects it’s applied to.

The tool can be used in various ways:

• To select polygons, and duplicate those into a prop. For instance: select portions of the head into a new Mask prop.
• To group polygons into Body Parts, this in turn can be affected by the bones of a figures skeleton. Those bones turn a prop into an animatable figure; this grouping is done from the Setup Room.
• To group polygons into Material Groups or Zones. See below.
• To group polygons into Hair Groups, this is done from the Hair Room. Those are the areas I can grow hair on, and apply the dynamics of wind and gravity to, according to my requirements. In http://www.book.artbeeweb.nl/book-poser/hair-room/ you can find some Hair Room tutorials to start with.
• To group vertices into Cloth Groups, this is done from the Cloth Room. Those are the areas I can apply the dynamics of body moves, wind and gravity to, according to my requirements. In http://www.book.artbeeweb.nl/book-poser/cloth-room/ you can find some Cloth Room tutorials to start with.

Material Zones

When I’m in the Group Editor, and I have selected / created a (Body Part) group of polygons, and I click the [ Assign Material.. ] button, I can either enter a new material name, or select an existing one from the list.

or

Note: in Cloth Room, the Group Editor works on vertices instead of polygons. Therefore, new material groups cannot be defined from there. The button just will not respond.

Then, from Material Room, I can define a material definition for that (Materials) zone:

But also, those Material Zones are available for defining and refining selections in groupings elsewhere (via the [Add] or [Remove] buttons). So, all vertices or polys from a Material Zone can be assigned specific dynamic properties in Cloth Room. This way, I can make portions of a dress not only look like leather or lace, but also behave as such.

And via Hair Room, I can make long and short fur or hair, both having different dynamic behavior and different colors (via Material Room) as well, by using the same groupings.

Next >

Nodes are the essential building blocks in the Advanced interface to the Poser Material Room. They are the graphical representation of mathematical function calls, that is: calculation procedures which turn parameters (inputs) to a result (output).

Advanced

This article presents a description of the following nodes from the 3D Textures group:

• Cellular
• Spots
• Marble
• Granite
• Wood
• Wave3d

The first ones are meant to fill up solid objects with a texture that has a lot of randomness in it, the latter produce deterministic patterns, with some turbulence for a more natural effect. The previous article offers descriptions of the remaining nodes from the 3D Textures group.

Cellular

This node generates a mosaic / stained glass-like pattern. The type of pattern is defined by the CellMode parameter, the Color2 / Intensity2 defines the mortar or lead (walls of the cells) and the cells are filled with either Color1 / Intensity1, or by various colors when the RandomColor option is checked.

Larger ScaleX/Y/Z values make larger patterns (so these work opposite to the scale parameters of the previous nodes).

So what do the various (Cell)Modes do?

Mode 1

Mode 2

Mode 3

Mode 4

Mode 5

In all modes the cell patterns are similar, but the use of the “mortar” is different. Mode 1 makes nice stained-glass while Mode 2 might be nice for granites. Mode 3 and 4 use the mortar to make the structure visible in an indirect way, while Mode 5 does not apply any mortar at all. That means that this mode gives me a homogeneous fill with Color1 when the RandomColor is OFF.

Do note that the texture is a 3D one, it’s continuous in all spatial directions, and mesh edges are irrelevant.

This however depends somewhat on Jitter, which controls cell-irregularity. The left render above was made with Jitter=1, the right one with Jitter=0.

Low Turbulence makes straight cell edges, high values make curves ones. The right image above with Jitter=0, Turbulence=0 changes to …

when only Turbulence is raised to 1.

Noise_Type lets me pick my favorite random number generator behind all the irregularities, and the Global_Coordinates option determines whether the pattern is relative to the object (OFF) or to the Poser space (ON). The latter is relevant when multiple objects make up one ‘thing’ and the material has to be continuous over all of them. Note that this also implies that the pattern changes when the object is moved around in an animation, so it’s meant for inanimate objects in the scene.

Spots

Spots create the kind of pattern I get when pouring red paint (Base_color) into a bucked with white (Spot_color), though I can alter the colors of course. To me the naming of the colors seems a bit in reverse given the result below, but anyway.

makes

Threshold defines the Base to Spot ratio: a low value (down to 0.0) gives more white (Spots) and a high value (up to 1.0) gives more red (Base).

Softness defines the blur at the edges, at 0 the edges are well defined (image above) and higher values makes the impression that I have been stirring the mix. With 0.4 I get…

Larger Spot_Sizes make larger spots (no surprise there) and as discussed at the other nodes above, Noise_Type lets me pick my favorite random number generator behind all the irregularities, and the Global_Coordinates option determines whether the pattern is relative to the object (OFF) or to the Poser space (ON).

Marble

No doubt I can guess the use of this one, but… what’s a proper marble pattern? As

makes

I see thick veins in one (X-) direction, and thin veins in the two other (Y, Z) directions. Larger Scales make larger patterns, Turbulence makes them wilder, and as discussed at the other nodes above, Noise_Type lets me pick my favorite random number generator behind all the irregularities, and the Global_Coordinates option determines whether the pattern is relative to the object (OFF) or to the Poser space (ON).

Granite

A no-brainer again, but what makes a granite pattern? It’s sort of various kinds of gravel mixed with clay and squeezed together into one material, so

makes

Larger Scales make larger patterns, note that the value is increased (from default 1) to 10 to get the granite effect visible. It’s a bit like the Cellular node in Mode 2, with variants of the same (Spot) color. Shades determines the amount of colors in the granite, while a low Balance pushes the colors towards the Spot_color, and a high value pushes the colors towards the Base.

As discussed at the other nodes above, Noise_Type lets me pick my favorite random number generator behind all the irregularities, and the Global_Coordinates option determines whether the pattern is relative to the object (OFF) or to the Poser space (ON).

Wood

Another no-brainer, which indeed makes the ring-patterns I expect.

makes

Larger Scales make larger patterns, and some Turbulence make them less regular and hence more natural. As discussed at the other nodes above, Noise_Type lets me pick my favorite random number generator behind all the irregularities, and the Global_Coordinates option determines whether the pattern is relative to the object (OFF) or to the Poser space (ON).

Wave3D

This is the 3D spatial equivalent of the 2D surface wave. In 3D, it’s like a sound blast, with alternating high (white) and low (black) pressure areas.

makes

The X,Y,Z parameters do NOT scale the pattern, but move the center around instead. Higher Frequencies make smaller patterns, and more frequent repetitions in the same area. Phase caters for the alternating state, and is quite valuable in animation.

The pattern is in Global Coordinates and ripples through when the object is moved around.

I’m sure one can find an artistic purpose for texturing with this node. Using it as a density driver in the Poser Atmosphere can make the sound-blast patterns visible in a room (vibrating smoke).

Next >

Nodes are the essential building blocks in the Advanced interface to the Poser Material Room. They are the graphical representation of mathematical function calls, that is: calculation procedures which turn parameters (inputs) to a result (output).

Advanced

This article presents a description of the following nodes from the 3D Textures group:

• Fractal_sum
• fBm
• Clouds
• Turbulence
• Noise

The first ones are random number or fractal based “cloudy” textures which are quite suitable for dirt patterns on walls and for atmospheric clouds. The latter or more generic helper functions. The next article offers descriptions of the remaining nodes from the 3D Textures group.

Fractal_Sum

This node returns a result between -1..+1, driven by a fractal function. Although fractal results make a strong irregular, even random impression, they differ from noise in various ways:

• The result is mathematically predetermined, repeatable
• The result in continuous in X,Y,Z

The Fractal Sum makes “mildly complex” patterns and can be considered very useful for surface patterns, like stains, dirt, rust etc.

makes

Larger X/Y/Z Scale values make smaller patterns, and as a fractal is an irregularity of an irregularity of … (etc.) and each step in this is “an Octave” (as in music), raising Octaves increases the complexity of the pattern.

Although the fractal function generates values from -1..+1 (with like a sine wave, more ‘hits’ in the extremes), these are folded into the 0..1 range. Without further measures, the 0.. -1 range is folded onto 0.. +1 and that will give a lot of high (bright) values and far less low (dark) values. The solution is to lift the result with the Bottom value, 0.5 by default. In that case, the result ranges from -0.5..+1.5 and the 0.. -0.5 is folded up onto 0.. +0.5 while 1.. 1.5 is folded down onto 1.. +0.5. That gives as much brights as darks in the pattern. Simply stated: 0.0 or lower will result in a bright, bleached pattern. Raising it will darken the pattern till it’s completely black, until 1.0 is entered exactly which turns the result completely white.

Bias and Gain get their (usual) incomprehensible explanation in the manual, sorry for that. Generally, when I consider the result of this node to be a greyscale image of some sort, Bias refers to its brightness while Gain refers to its contrasts, both as if applied by Photoshop or alike in a pre-processing stage. Both default to a 0.5 value, and lowering Bias pushes the bright details into black until all brights are gone at 0.0 while increasing Bias adds more bright details into the already bright area. This does not reduce the black areas but just removes the details, and makes hard-edged splotches. Gain works about the other way around.

makes

fBm

This is just another fractal function which offers parameters similar to Fractal_Sum, but results in more complex patterns as it’s derived from various fractal formulas combined into one.

makes

These patterns are considered especially useful for creating terrains, which requires that this node is to be plugged into the Displacement slot of PoserSurface. Though it shows too much detail for a simple stain, it might also be used for a worn, aged and rubbed one. When used for terrains, it’s advised to reduce the Bottom parameter to its default 0.0 to get rid of the black (so non-displaced, flat) areas.

What are the other parameters about?

Noise_type offers the usual choice between Original (for compatibility) and Improved (recommended), and Signed folds the 0..-1 range of fractal results back onto the 0..+1 range. This folding somewhat disables the use of the Bottom parameter, what – as already said – can be kept at its default 0.0. Frequency_Gap effects the spatial distribution of the pattern, values between 2..3 are recommended and one can leave the default as is. Lower values take the details out and higher values have no effect.

Fractal_Increment is the most interesting parameter. At 0.0 the result turns out very noisy, loose pickles everywhere. At 1.0 the result is quite consistent, and looks a lot like the simpler Fractal_Sum node. So here I can adjust the complexity and noisiness of the result, and the roughness of terrains made with it.

From 0.0   to 1.0

Clouds

Clouds, a mixture of fractal and turbulence, serve well in backgrounds as well as in driving the fog density in Poser Atmosphere. They also serve well for fine patterns in stone.

makes

There is one Scale parameter for all directions, larger values make larger patterns. Higher Complexities make richer, more detailed and crispier patterns while Bias caters for the balance between dark (Sky) and bright (Cloud) areas. Higher values make less cloudy skies. Gain serves as a mixture: low values make a closed, less detailed cloud pattern while high values make an open sky with sharp-edges clouds. Generally, when I consider the result of this node to be a greyscale image of some sort, Bias refers to its brightness while Gain refers to its contrasts, both as if applied by Photoshop or alike in a pre-processing stage.

As discussed at the other nodes above, Noise_Type lets me pick my favorite random number generator behind all the irregularities, and the Global_Coordinates option determines whether the pattern is relative to the object (OFF) or to the Poser space (ON).

Turbulence

Like Fractal_Sum is best for surface effects and fBm is best for terrain displacements, Turbulence is best for cloudy patterns as are required in a Poser Atmosphere (instead of a PoserSurface). The best way to look at it is to consider a space full of tiny droplets that make a fog, and some wind pushing some of them into other areas. So some areas get more filled, and adjacent areas get less.

makes

and the parameters can’t be a surprise anymore, they all were discussed in Fractal_Sum as well. Turbulence does make nice marbles too, as I can see in the sample above.

Noise

Noise is not a fractal, but just generates random values (brightnesses) for each point in space. So adjacent positions do not have adjacent function results, the function is not continuous.

makes

The X/Y/Z_index means the same as X/Y/Z_scale in the previously discussed nodes: larger values make smaller patterns. The result is a value between Min and Max, I can use values closer to each other to generate small color or brightness variations.

Next >

Nodes are the essential building blocks in the Advanced interface to the Poser Material Room. They are the graphical representation of mathematical function calls, that is: calculation procedures which turn parameters (inputs) to a result (output).

Advanced

3D Textures are meant to be ‘mapped’ against their position in space, such that multiple objects, eventually combined to one larger thing, show continuity in their looks. Think about a large city wall made from various block elements placed next to each other. The consequence of a texture driven by an objects position in space, is that changing position (e.g. in animation) make the texture change accordingly. This might either be utmost unwanted, or might be a really nice special effect. That’s up to me.

Let’s have a closer look. The next article offers a description of

• Fractal_sum
• fBm
• Clouds
• Turbulence
• Noise

The first ones are random number or fractal based “cloudy” textures which are quite suitable for dirt patterns on walls and for atmospheric clouds. The latter are more generic helper functions.

The article after that offers a description of

• Cellular
• Spots
• Marble
• Granite
• Wood
• Wave4d

The first ones are meant to fill up solid objects with a texture that has a lot of randomness in it, the latter produce deterministic patterns, which some turbulence for a more natural effect.

Next >

Nodes are the essential building blocks in the Advanced interface to the Poser Material Room. They are the graphical representation of mathematical function calls, that is: calculation procedures which turn parameters (inputs) to a result (output).

Advanced

The various nodes from the 2D Textures group all serve the same purpose: offering an image or tiling pattern which is to be (UV-) mapped onto the object surface. Image_Map and Movie do so with external static or dynamic sources. The other options generate patterns on their own. Let’s have a closer look at those.

In all cases: for each portion of an object that has its own UV coordinates, both U and V vary from 0.0 to 1.0. U mainly in horizontal direction, V in vertical direction.

Wave2D

This node generates a circular sine wave pattern, which is ideal for wavy displacement maps.

The U_pos, V_pos parameters determine the center of the pattern, Frequency determines the number of repetitions and by animating the Phase, the pattern starts rippling.

As a single pattern looks quite simplistic and cartoony, one can combine patterns with different frequencies (and origins, phases as well) to make more complex, realistic ones.

Made from

Brick

This node generates a brick & mortar texture, in the first place for use in the Diffuse slot, or in combination with its alternatives. But because brick and mortar behave different for specularity, and for bump/displacement, variants of the node are usually combined with some other components of the PoserSurface.

Brick_Width and Height, and Mortar_Width define the main aspects of the texture, while U_offset, V_offset define the placement of the texture on the object. Note that all of those are expected to vary within the 0..1 bound.

Turbulence makes the mortar-lines less straight and perfect, while Noise makes the mortar filling more irregular. As the manual states: Turbulence is low frequency, Noise is high frequency variation. In plain English: Turbulence affects the shape of the stones, Noise affects the structure of the mortar. I can choose between original and improved noise, the first one is meant for compatibility with older Poser versions.

Softness defines the brick-to-mortar distinction, the higher the value the more brick blends into the mortar.

Tip: believable brick textures do need serious variation in brick color and brightness. Using additional (non-brick) textures for Diffuse_Value, or plugged into to Brick_Color slot, can help a lot in this. Especially the Clouds node (from the 3D Textures collection) might be a nice one.

Tile

Although the Brick node can be used to make shiny tiles as well, all of those will be in a similar color, and all of them will be rectangular too. The Tile node makes a variation on this, by offering alternating colors, and roundish (ellipsoid) shapes as well.

Made with

Parameters are similar to Brick: Tile_Width and Height, and Mortar_Width define the main aspects of the texture, while U_offset, V_offset define the placement of the texture on the object. Note that all of those are expected to vary within the 0..1 bound.

Turbulence affects the shape of the tiles, Noise affects the structure of the mortar. I can choose between original and improved noise, the first one is meant for compatibility with older Poser versions. Softness defines the brick-to-mortar distinction, the higher the value the more brick blends into the mortar.

Weave

Weaves are meant for cloth, but of course one can make nice garden fences with it too. It’s just a matter of scale (and color, and material details). This:

Is made with

The colors speak for themselves, and the U_Scale and V_Scale determine the amount of threads on the surface (times two, as the object surface apparently has U and V from -1..1). So the plane shown above has 2x 10 (U-Scale) threads in Color-1, and 2x 20 (V-Scale) threads in Color-2 which then of course have half the thickness.

To my observation, the Height parameter has no effect at all. Larger Bias values create thicker and flatter threads, or: reduce the space between them. Larger Gain values sharpen the texture, higher values make more distinct threads, as for paper / wood strips while more fuzzy threads are fine for textile weaves. Bias and Gain vary from 0.0 to 1.0. Note: at other places Bias is defined as brightness of the underlying greyscales, and Gain is defined as its contrast, both as if applied by Photoshop or alike in a pre-processing stage.

Next >

The articles in this section discuss all Material Room nodes required for either procedural textures, and the ones explicitly aimed at node-tree building.

A procedural texture is not derived from an (eventually color filtered) external image or movie still, but is mathematically generated internally from surface or spatial coordinates. The nodes to accomplish such textures can be found in the 2D Textures and 3D Textures groups.

Materials are applied to objects, objects parts and more precise: to specific Material Zones within those objects and parts. This article  discusses the details.

Material Room supports the creation of quite elaborate node-trees, like a programming language into material definitions. This section will not address the art of such programming itself, but will present and discuss the building blocks alone. These can be found in the Variables  and Math groups.

The next subsection presents articles on defining the properties of (V) Non-objects (atmosphere, background, lights) as far as these are handled through the Material Room interface. The Appendix lists all Material Room nodes and relevant Render Settings, and their availability in the various Poser versions.