This is RenderMan 21 Documentation you are viewing. The Rmanwiki home page will redirect you to the current documentation.

Page tree

You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 3 Next »

Contents

PxrMultiTexture was built to reference up to 10 textures, blend them in various ways and allow for various map selection methods.

Like all texture style nodes, this node takes a manifold which describes
either a 2D domain to apply a the texture to. The default behavior
if no manifold is attached, is to apply over the s,t domain defined on the
geometry.

WARNING: PxrMultiTexture is only compatible with PxrRoundCube and PxrTileManifold. Other manifolds are NOT usable with this pattern.

PxrMultiTexture doesn't support Texture atlas format files: it makes no sense for its usage. This plugin does support `Rtx <includedRtxPlugins.html>`_ procedural texture plugins, though.


Parameters

Multi Manifold

Provides the domain over which to apply the textures, through either PxrRoundCube or PxrTileManifold. Defaults to s,t.

This input is only compatible with nodes providing a "resultMulti" output, like PxrRoundCube or PxrTileManifold.

 Tech Notes
RIB
struct manifoldMulti


Textures

Filename (0 to 9)

The filename of the texture. You should have at least one texture in slot 0.

 Tech Notes
RIB
string filename0
Default
""


Texture Parameters

These parameters are valid for all textures (0 to 9).

First Channel Offset

Offsets the first channel to be looked up.

| *RIB*: ``int firstChannel``
| *Default*: 0

**Invert T**

Inverts the t parameter for the texture lookup.

| *RIB*: ``int invertT``
| *Default*: 1

**Filter**

Selects different reconstruction filters that can be used during texture
lookup. The filters available for PxrTexture are:

- 0: Nearest
- 1: Box
- 2: Bilinear
- 3: Bspline
- 4: Mitchell
- 5: Catmullrom
- 6: Gaussian
- 7: Lagrangian

| *RIB*: ``int filter``
| *Default*: 1

**Blur**

Specifies how much to blur the image retrieved from the texture file.

| *RIB*: ``float blur``
| *Default*: 0.0

**Mip Interpolate**

Selects whether to interpolate between adjacent resolutions in the
multi-resolution texture, resulting in smoother transitions between
levels.

| *RIB*: ``int lerp``
| *Default*: 1

**Missing Color**

If there is an error opening the texture, use this color.

| *RIB*: ``color missingColor``
| *Default*: |1.0,0.0,1.0|

**Missing Alpha**

If there is an error opening the texture, use this alpha.

| *RIB*: ``float missingAlpha``
| *Default*: 1.0

**Linearize**

Apply the reverse sRGB transform your texture. If you are painting
textures in sRGB space (default for most paint packages) but viewing your
data in data linear space, your textures will look washed out. This will
apply the sRGB transform to your texture, which should make it appear
visually linear again.

| *RIB*: ``int linearize``
| *Default*: 0


Randomize
=========

Manifold patterns outputing an multi manifold encode which texture should be used using a 2D coordinate system. PxrMultiTexture can use those coordinates to compute a random seed to drive local variations.

**Random Source**

For each object to get a different variation, you need to select something unique about them to create a unique seed. You have a choice between the object's id and the object's name.
These attributes are created by the software outputing the RIB and depending on your host, one may work better than the other.

- 0: Object id (Attribute "identifier" "float id")
- 1: Object Name (Attribute "identifier" "string name")

| *RIB*: ``int randomSource``
| *Default*: 0

**Seed**

When set to zero, all PxrMultiTexture patterns using the same manifold will compute the same random seed. If you want one of these patterns to compute a different variation, set the randomSeed to a non-zero value:

| *RIB*: ``float randomSeed``
| *Default*: 0.0

**Hue**

Limit random hue shift. Ranges from 0 (no variation) to 1 (full
variation).

| *RIB*: ``float randomHue``
| *Default*: 0.0

**Saturation**

Limit random saturation scale. Ranges from 0 (no variation) to 1 (full
variation).

| *RIB*: ``float randomSaturation``
| *Default*: 0.0

**Luminance**

Limit random luminance scale. Ranges from 0 (no variation) to 1 (full
variation).

| *RIB*: ``float randomLuminance``
| *Default*: 0.0

**Gamma**

Limit random gamma variation. Ranges from 0 (no variation) to 1 (full
variation).

| *RIB*: ``float randomGamma``
| *Default*: 0.0

**Hue Mode**

How the color hue will be varied:

- 0: Centered -- the variation will be centered around the current value.
- 1: Additive -- the variation will be added to the current value.
- 2: Substractive -- the variation will be substracted from the current value.

| *RIB*: ``int hueMode``
| *Default*: 0

**Saturation Mode**

How the color saturation will be varied:

- 0: Centered -- the variation will be centered around the current value.
- 1: Additive -- the variation will be added to the current value.
- 2: Substractive -- the variation will be substracted from the current value.

| *RIB*: ``int saturationMode``
| *Default*: 0

**Luminance Mode**

How the color luminance will be varied:

- 0: Centered -- the variation will be centered around the current value.
- 1: Additive -- the variation will be added to the current value.
- 2: Substractive -- the variation will be substracted from the current value.

| *RIB*: ``int luminanceMode``
| *Default*: 0

**Gamma Mode**

How the color gamma will be varied:

- 0: Centered -- the variation will be centered around the current value.
- 1: Additive -- the variation will be added to the current value.
- 2: Substractive -- the variation will be substracted from the current value.

| *RIB*: ``int gammaMode``
| *Default*: 0


Output Parameters
=================

**resultRGB**

The filtered color result. Note that all results are looked up starting
at the *startChannel* offset.

**resultR**

The R channel result

**resultG**

The G channel result

**resultB**

The B channel result

**resultA**

If alpha is present and resultRGB is connected it returns the channel
after RGB. If RGB is not connected it returns the first channel.

**resultA**

If alpha is present and resultRGB is connected it returns the channel
after RGB. If RGB is not connected it returns the first channel.