Vector

typedef enum VPacketPubType VPacketPubType

Here we define the nodal effects associated to that packet, this is how we can present nodes in the schematic with copnnections that oparate on the packet.

ILxVectorPacket

class ILxVectorPacket

Packet types are defined as servers and so may be expanded by plug-ins. Packets define their categories as a server tag.

Public Functions

unsigned int Size(LXtObjectID self)

They are defined using the ILxVectorPacket interface. The first six methods control the lifecycle of packets.

  • Size the size of the packet in bytes for data packets. Must be a constant. The size can be 0 for object packets.

  • Interface the packet COM interface for object packets. Should be NULL if the packet is data only.

  • Initialize set the initial state of the packet when first allocated. Packets are initialized to all zero bytes by default, but any additional state such as object allocation should be done here.

  • Reset reset the state of the packet to what it would have been right after initialization. This is called when an existing packet is going to be reused without having to free it and re-initialze.

  • Copy copy the contents of one packet to another. Both packets will have been initialized.

  • Cleanup free anything allocated in the packet. This is called just before the packet itself is freed. There are also some additional methods needed, particularly for blending packets during shader evaluation.

  • Blend This is like interpolate, but it also uses a blending mode to decide how to blend values.

  • Invert This inverts a packet, which is mostly used by the texture engine and doesn’t always make sense for all packets. Finally we have some methods to expose vector packets as inputs for nodal shaders. There is very little reason to use these for custom shading packets. They are mostly useful for fundamental packets that present sample information that can’t be read any other way.

  • NodeCount This returns the number of nodal connections on the packet.

  • NodeName This returns the internal name of the output by index.

  • NodeType This returns type information by index. VPacketPubType is one of float, double, or int, and ‘count’ is the number of components. We also return the actual data type name (DISTANCE, PERCENT, etc.) and the vector type.

  • NodeGet This returns the value for a node connection given by index. The packet is passed in as input. The data pointer returned points at the value as a location inside the packet, or the first element of an array of values for vector values.

const LXtGUID *Interface(LXtObjectID self)
LxResult Initialize(LXtObjectID self, void *packet)
void Reset(LXtObjectID self, void *packet)
LxResult Copy(LXtObjectID self, void *packet, void *from)
void Cleanup(LXtObjectID self, void *packet)
LxResult Blend(LXtObjectID self, void *packet, void *p0, void *p1, float t, int mode)
LxResult Invert(LXtObjectID self, void *packet)
unsigned int NodeCount(LXtObjectID self)
LxResult NodeName(LXtObjectID self, unsigned int index, const char **name)
LxResult NodeType(LXtObjectID self, unsigned int index, VPacketPubType *dataType, unsigned int *count, const char **exoType, const char **vecType)
LxResult NodeGet(LXtObjectID self, unsigned int index, void *packet, void **data)

ILxVectorPacket1

class ILxVectorPacket1

Packet types are defined as servers and so may be expanded by plug-ins. Packets define their categories as a server tag.

Public Functions

unsigned int Size(LXtObjectID self)

This is the old interface we keep for translation

const LXtGUID *Interface(LXtObjectID self)
LxResult Initialize(LXtObjectID self, void *packet)
void Reset(LXtObjectID self, void *packet)
LxResult Copy(LXtObjectID self, void *packet, void *from)
void Cleanup(LXtObjectID self, void *packet)
LxResult Save(LXtObjectID self, void *packet, unsigned int n, LXtObjectID writestream)
LxResult Load(LXtObjectID self, void *packet, unsigned int n, LXtObjectID readstream)
LxResult Interpolate(LXtObjectID self, void *packet, void *p0, void *p1, float t)
LxResult Blend(LXtObjectID self, void *packet, void *p0, void *p1, float t, int mode)
LxResult Invert(LXtObjectID self, void *packet)

  • LXsVPK_CATEGORY

ILxPacketService

class ILxPacketService

Public Functions

LxResult ScriptQuery(LXtObjectID self, void **ppvObj)

The lookup is available to plug-in clients as a global service with a Lookup() method to get offset from name, and a Name() method to get the name from the offset. The FastPacket() interface is provided to get the packet from a raw sample vector object without having to query for the interface. This speeds up texture evaluations.

LxResult Lookup(LXtObjectID self, const char *category, const char *name, unsigned int *offset)
LxResult Name(LXtObjectID self, const char *category, unsigned int offset, const char **name)
void *FastPacket(LXtObjectID self, LXtObjectID vector, unsigned int offset)
LxResult CreateVectorType(LXtObjectID self, const char *category, void **ppvObj)

These two methods allow clients to create simple vector types. The first method allocates an empty vector type, and the second method allows packets to be added to the definition.

LxResult AddPacket(LXtObjectID self, LXtObjectID vtype, const char *name, unsigned int flags)
unsigned GetOffset(const char *category, const char *name)

User Class Only:

bool PacketObject(ILxUnknownID vector, unsigned int offset, CLxLocalizedObject &loc)
bool NewVectorType(const char *category, CLxLoc_VectorType &vtype)
LXfVT_SET

The VectorType is defined by an interface, which can be implemented by each client in its own way.

  • Category This method returns the Category of this vector type

  • Test Returns the packet flags for the VectorType, which indicate how the type object intends to use the packet. GET means read-only, SET means write-only, and GET+SET means read+write. GET packets may also be optional, in which case the packet will only be used if present.

  • LXfVT_GET

  • LXfVT_OPTIONAL

ILxVectorType

class ILxVectorType

Public Functions

const char *Category(LXtObjectID self)

  • Count Given a packet flag, returns the number of packets that match one of the basic flags settings above.

  • ByIndex Returns the offset for the packet of the given type at the given index. As a convenience it also set the packet flags if ‘flags’ is set, this is actually an important optimization for faster vtype processing.

unsigned int Test(LXtObjectID self, unsigned int offset)
unsigned int Count(LXtObjectID self, unsigned int type)
unsigned int ByIndex(LXtObjectID self, unsigned int type, unsigned int index, unsigned int *flags)

ILxVectorStack

class ILxVectorStack

Public Functions

void *Optional(LXtObjectID self, unsigned int offset)

The two variants are stacks and lists. The stack interface adds methods for pushing and popping, and the list interface allows access to the current value index.

LxResult Readable(LXtObjectID self, unsigned int offset, void **packet)
LxResult Writable(LXtObjectID self, unsigned int offset, void **packet)
LxResult SetPacket(LXtObjectID self, unsigned int offset, void *pdat)
LxResult Push(LXtObjectID self)
LxResult Pop(LXtObjectID self)
void *Read(unsigned int offset)

User Class Only:

void *Write(unsigned int offset)
bool ReadObject(unsigned int offset, CLxLocalizedObject &loc)
bool WriteObject(unsigned int offset, CLxLocalizedObject &loc)

ILxVectorList

class ILxVectorList

Public Functions

void *Optional(LXtObjectID self, unsigned int offset)
LxResult Readable(LXtObjectID self, unsigned int offset, void **packet)
LxResult Writable(LXtObjectID self, unsigned int offset, void **packet)
LxResult SetPacket(LXtObjectID self, unsigned int offset, void *pdat)
LxResult Append(LXtObjectID self, unsigned int *index)
unsigned int Current(LXtObjectID self)
LxResult SetCurrent(LXtObjectID self, unsigned int index)
unsigned int Count(LXtObjectID self)
void Clear(LXtObjectID self)
void *Read(unsigned int offset)

User Class Only:

void *Write(unsigned int offset)
bool ReadObject(unsigned int offset, CLxLocalizedObject &loc)
bool WriteObject(unsigned int offset, CLxLocalizedObject &loc)
LXsCATEGORY_SAMPLE

A Sample is an arbitrary position in 3D space with a set of properties like a size, a set of values measured in different references, etc. The packets that make up the sample vector are in the “sample” cateogry.

LXpSamplePosition

struct st_LXpSamplePosition

In general the offset should NOT be looked up in the shader\texture evaluate function because it is too slow. It is better to get the offset during setup like when reading channel values. Textures and shaders are computed using mostly geometric data. This includes the set of positions in the various reference spaces, the set of object transformation matrices, the ray information for ray tracing contexts, and the spot information. The ‘uv’ array actually contains any features requested for the surface beyond the standard 12, and ‘duv’ and ‘dpduv’ is filled in for those features only if the corresponding shader requests the sample-transform packet.

Public Members

LXtVector wPos
LXtVector wVel
LXtVector oPos
LXtVector uPos
float spot
float bias
int infinite
float *uv
float *duv
LXtFVector *dpduv
int *offset
float *dpduvLen
LXtVector pPos

LXpSampleTransform

struct st_LXpSampleTransform

Public Members

LXtMatrix transform
LXtMatrix invert
LXtVector scale
LXtVector wpos

LXpSampleRay

struct st_LXpSampleRay

Public Members

LXtVector origin
LXtFVector dir
LXtFVector color
LXtFVector abc
float dist
float prevDist
float nearClip
float farClip
float importance
float prevSpot
float cone
float eta
float wavelength
int bounces
int thread
unsigned int flags
int rayID
LXfRAY_SCOPE_POLYGONS

Flags are used to specify which elements should be tested against a ray, what information to compute at the hit point, and the reason for firing the ray.

  • LXfRAY_SCOPE_VOLUMETRICS

  • LXfRAY_SCOPE_ENVIRONMENT

  • LXfRAY_SCOPE_BACKFACE

  • LXfRAY_SCOPE_BACKONLY

  • LXfRAY_SCOPE_SAMESURF

  • LXfRAY_SCOPE_OTHERSURF

  • LXfRAY_SCOPE_IMPLICITSURF

  • LXfRAY_EVAL_NORMAL

  • LXfRAY_EVAL_MATERIAL

  • LXfRAY_EVAL_OPACITY

  • LXfRAY_EVAL_SHADING

  • LXfRAY_EVAL_IRRADIANCE

  • LXfRAY_EVAL_PERSPENV

  • LXfRAY_EVAL_NOFOG

  • LXfRAY_TYPE_CAMERA

  • LXfRAY_TYPE_SHADOW

  • LXfRAY_TYPE_REFLECT

  • LXfRAY_TYPE_REFRACT

  • LXfRAY_TYPE_INDIRECT

  • LXfRAY_TYPE_CAUSTIC

  • LXfRAY_TYPE_SUBSURFACE

  • LXfRAY_TYPE_SHADOWMAP

  • LXfRAY_TYPE_TEXTURE

  • LXfRAY_TYPE_OCCLUSION

  • LXfRAY_TYPE_SHADOWVOL

  • LXfRAY_TYPE_CLIPPING

  • LXfRAY_TYPE_SHADOW_INFO

  • LXfRAY_TYPE_PREPASS

LXpSampleClip

struct st_LXpSampleClip

Public Members

void *elt
float dist
float delta

LXpSampleParms

struct st_LXpSampleParms

The first six members here are the colored and textured material coefficients. They are multiplied by the corresponding amounts before being used by the default shading functions.

Public Members

LXtFVector diffCol
LXtFVector specCol
LXtFVector reflCol
LXtFVector tranCol
LXtFVector subsCol
LXtFVector lumiCol
LXtFVector exitCol
LXtFVector clipCol
LXtFVector anisoDir
LXtFVector anisoDpdu
LXtFVector anisoDpdv
LXtFVector dif0
LXtFVector sss0
float diffAmt
float specAmt
float reflAmt
float tranAmt
float subsAmt
float lumiAmt
float coatAmt
float dissAmt
float bumpAmt
float bumpAmp
float diffRough
float clipVal
float rough
float aniso
float anisoCos
float anisoSin
float specExpU
float specExpV
float specFres
float reflFres
float refIndex
float disperse
float tranRough
float tranDist
float subsDist
float subsDepth
float subsPhase
int reflType
int reflRays
int tranRays
int subsRays
int flags
int uvOffset
int vectOffset
int clearBump
int clipEnable
int clipMatte
int clipped
int radInterpol
int brdfType
int shaderModel
float coatRough
float coatBump
float projCulling
float metallic
float normAmt
float sheen
float sheenTint
float specTint
float flatness
float importance

LXpSampleUnrealParms

struct st_LXpSampleUnrealParms

// SampleParms for Unreal4

Public Members

LXtFVector baseColor
LXtFVector emissiveColor
float specular
float opacity

LXpSampleUnityParms

struct st_LXpSampleUnityParms

// SampleParms for Unity5

Public Members

LXtFVector baseAlbedo
LXtFVector albedo
LXtFVector albedo2
LXtFVector emission
LXtFVector tangentNorm
LXtFVector vT
LXtFVector vB
LXtFVector vN
float emissiveLevel
float smoothness
float dielectricSpec
float normalScale
float normalScale2
float heightScale
float detailMask

LXpSampleGLTFParms

struct st_LXpSampleGLTFParms

// SampleParms for glTF

Public Members

LXtFVector baseBaseColor
LXtFVector baseColor
LXtFVector albedo2
LXtFVector baseEmission
LXtFVector emission
LXtFVector tangentNorm
LXtFVector vT
LXtFVector vB
LXtFVector vN
float emissiveLevel
float baseRoughness
float roughness
float baseMetallic
float metallic
float normalScale
float ambientOcclusionScale
int shadeModel

LXpSampleAXFParms

struct st_LXpSampleAXFParms

// SampleParms for AXF

Public Members

LXtFVector baseColorChanVal
LXtFVector baseColorTxtVal
LXtFVector specularColorChanVal
LXtFVector specularColorTxtVal
LXtFVector tangentNorm
LXtFVector vT
LXtFVector vB
LXtFVector vN
float normalScale
float tRoughness
float bRoughness
float roughnessScale
float fresnelChanVal
float fresnelTxtVal
float alphaChanVal
float alphaTxtVal
float anisotropyStrength
float clearcoatAmount
float clearcoatIORTxtVal
float displacementDistance

LXpSampleRecolorParms

struct st_LXpSampleRecolorParms

// SampleParms for Recolouring

Public Members

LXtFVector recolorOriginal
LXtFVector recolorFrom
LXtFVector recolorTo
LXtFVector matMap

LXpSampleMask

struct st_LXpSampleMask

This is used for shader masking.

Public Members

float groupOpacity
float layerOpacity
int layerOverride
float layerOpacityMasked

LXpSampleGroupMask

struct st_LXpSampleGroupMask

Public Members

float groupOpacity

LXpSampleDriver

struct st_LXpSampleDriver

This is used for texturing as custom channels.

Public Members

float a
float b
float c
float d

LXpSampleStencil

struct st_LXpSampleStencil

This packet is used for sample stenciling (AKA clip mapping) which happens at the ray/geometry intersection level before any shading is computed. ‘textureCount’ holds the number of stencil textures for a given a slice. It is important because some shaders like materials simply clear the stencil value, which means they don’t need all the texturing data normally passed to shaders. So if the number of textures is 0 we can skip the texture evaluation setup entirely, which greatly speeds up raytracing. ‘texturePass’ is true when the stencil slice is evaluated for the number of textures.

Public Members

float value
int textureCount
int texturePass
int additive

LXpSampleVolume

struct st_LXpSampleVolume

This packet is used for volumetric rendering.

Public Members

LXtFVector scatter
LXtFVector absorb
LXtFVector ambient
LXtFVector luminosity
float scatterAmt
float absorbAmt
float luminosityAmt
float attenuate
float shift

LXpSampleFluid

struct st_LXpSampleFluid

Public Members

float pressure
float temperature
float fuel

LXpSampleDensity

struct st_LXpSampleDensity

This packet is used for volume density rendering.

Public Members

float density
float density0
float level

LXpSampleDissolve

struct st_LXpSampleDissolve

This packet is used for sample dissolve.

Public Members

float dissolve

LXpSampleFacet

struct st_LXpSampleFacet

To compute things like bump and UV derivatives we need to know what the microfacet is.

Public Members

LXtVector wPos[3]
LXtVector oPos[3]
LXtVector uPos[3]
int flags

  • LXfFACET_OBJECT_POSITION

  • LXfFACET_DISPLACED

  • LXfFACET_NORMALIZED

LXpSampleBump

struct st_LXpSampleBump

Bump evaluation uses the Bump packet. Bump is evaluated on the microfacet: each vertex of the microfacet is displaced using the bumpHeight, the local normal and the bump amplitude. The resulting displaced normal is the ‘bump’ vector in the packet.

Public Members

LXtVector dp
LXtVector bump
float bumpAmplitude
float bumpHeight
float rndWidth
int bumpMapping
int texturePass
int edgePass
int textureCount
int shadeCount
int shadeIndex
LXsP_SAMPLE_POSITION

These sample vector packets can be accessed with the following names.

  • LXsP_SAMPLE_XFRM

  • LXsP_SAMPLE_RAY

  • LXsP_SAMPLE_CLIP

  • LXsP_SAMPLE_PARMS

  • LXsP_SAMPLE_RECOL_PARMS

  • LXsP_SAMPLE_UE_PARMS

  • LXsP_SAMPLE_UT_PARMS

  • LXsP_SAMPLE_GLTF_PARMS

  • LXsP_SAMPLE_AXF_PARMS

  • LXsP_SAMPLE_MASK

  • LXsP_SAMPLE_DRIVER

  • LXsP_SAMPLE_STENCIL

  • LXsP_SAMPLE_VOLUME

  • LXsP_SAMPLE_DENSITY

  • LXsP_SAMPLE_DISSOLVE

  • LXsP_SAMPLE_FACET

  • LXsP_SAMPLE_BUMP

  • LXsP_SAMPLE_FLUID

LXpTextureInput

struct st_LXpTextureInput

Textures are shaders that set an effect, they all take one packet as input: TextureInput and produce one output packet: TextureOutput. This packet is then converted by the texture engine into a final TextureValue packet which is then applied to the various effects. Thus the evaluation sequence goes like this: TextureInput -> TextureOutput -> TextureValue. Texture input consists of the position of the sample in texture space, the spot size in texture space and the evaluation context.

Public Members

LXtFVector tPos
LXtFVector uvw
LXtFVector uvw0
LXtFVector scale
LXtFVector dpdu
LXtFVector dpdv
float tSize[2]
float tSpot
float octaveMult
int adaptiveFreq
int context
int axis
int uvOffset
int partOffset
int uvTile[2]
float uvWrap[2]
LXtMatrix uvXfrm
LXtMatrix uvRotXfrm
float uvRot
int legacyUVRot
int useUDIM
int noTile
int projOnly
int sampleMesh
int ignoreAlpha
float sampleScale
int offRange
float idParm
int particleIdx
int particleEval
float particleRadius
void *particleData
int tangentType
int *idxTloc
int nodalEval
int perSample
int hasTBasis
LXiTILE_RESET

These are the UV tiling options:

  • LXiTILE_REPEAT

  • LXiTILE_MIRROR

  • LXiTILE_EDGE

  • LXiCULLING_ENABLED

  • LXiCULLING_DISABLED

LXiTANGENT_DPDU_DPDV

These are the normal map tangent vector options:

  • LXiTANGENT_DPDU_CROSS

LXpTextureOutput

struct st_LXpTextureOutput

The result of a texture computation is stored in the PackOutput structure which holds all the possible outputs. ‘direct’ is the flag that tells the texture engine how to compute the texture value packet. If this is false, ‘blend’ will be used to interpolate between the two colors, values, and alphas. ‘value’ the two texture values. Direct textures should only set the first value. ‘color’ color values. ‘alpha’ alpha values. ‘range’ indicates the min and max values. ‘blend’ is the parameter to use to interpolate between the two sets of values for indirect textures.

Public Members

int direct
double value[2]
LXtVector color[2]
double alpha[2]
double range[2]
double blend

LXpTextureValue

struct st_LXpTextureValue

Finally the texture output is converted into values after applying the ‘blend’ and the layer’s invert option. ‘value’ is the base value derived from the texture output after blend and invert are applied. ‘rgb’ is the texture output base color multiplied by the texture value. ‘alpha’ is the texture alpha channel.

Public Members

double value
double alpha
LXtVector color

LXpTextureLocator

struct st_LXpTextureLocator

The texture locator packet contains the position and transformation of the locator used for the texture evaluation.

Public Members

LXtVector wPos
LXtVector oPos
LXtMatrix xfrm
LXtMatrix iXfrm
LXtMatrix irXfrm
LXtFVector textureOffset
float textureOffsetAmp

  • LXsP_TEXTURE_INPUT

  • LXsP_TEXTURE_OUTPUT

  • LXsP_TEXTURE_VALUE

  • LXsP_TEXTURE_LOCATOR

LXpSampleSurfNormal

struct st_LXpSampleSurfNormal

Surface samples have different normals for different purposes. ‘gNorm’ is always the true geometric normal of the micropolygon. The purpose of ‘uNorm’ is to allow baking normal maps of displaced surfaces (it’s what the final normal is compared against). ‘wNorm0’ is the starting point for bump mapping, and ‘wNorm’ is the fully bump mapped normal which should be used for shading. The CC appended versions are for clearcoat normal mapping, which will use a separate normal map for clearcoat, if coatNormal is nonzero.

Public Members

LXtFVector gNorm
LXtFVector uNorm
LXtFVector wNorm0
LXtFVector wNorm
LXtFVector tangent
LXtFVector normalMap
LXtFVector objectNrm
int oAxis
int wAxis
int back
int coatNormal
LXtFVector wNormCC
LXtFVector normalMapCC

LXpSampleSurfSmooth

struct st_LXpSampleSurfSmooth

Surface smoothing parameters are stored in this packet. This allows the material engine to get this information down to the polygonal data, for computing face normals. These values do not vary over the surface.

Public Members

float smooth
float csa
int dblSided

  • LXsP_SURF_NORMAL

  • LXsP_SURF_SMOOTH

LXpDisplace

struct st_LXpDisplace

This packet is used to store the displacement values used by the renderer, that is the maximum displacement and the textured displacement height.

Public Members

LXtFVector dPos
LXtFVector vDsp
float max
float amplitude
float dist
int enable
int maxPass

  • LXsP_DISPLACE

LXpShaderType

struct st_LXpShaderType

This packet is used to store the surface element shader type. This value is used during shader evaluation to filter out shader groups of the wrong type.

Public Members

int type
int hidden
int layerIndex

  • LXsP_SHADER_TYPE

LXpGroupLayer

struct st_LXpGroupLayer

This is used for group layering.

  • Enum is true when we count the layers,

  • Count is the number of layers (set by the enumeration)

  • Index is the current layer index during shader evaluation.

Public Members

int layerEnum
int layerScope
int layerCount
int layerIndex
int layerTotal

  • LXsP_GROUP_LAYER

LXpFurParms

struct st_LXpFurParms

This packet is used to store the fur values used by the renderer, that is the maximum fur size, ect.

Public Members

float minDist
float length
float width
float flex
float density
float display
float bumpAmp
float curles
float clumps
float clumpDens
float clumpSize
float clumpStray
float clumpStrayAmp
int clumpIntr
float curlRad
float curlSelf
int curlMode
float taper
float yOffset
float stripRot
float rootBend
int bendDir
float rate
float blendAngle
float blendAmount
float posJitter
float sclJitter
float nrmJitter
float grwJitter
float kinkAmp
float kinkAmpTip
float kinkScl
float kinkYScl
float kinkOff
float frizAmp
float frizAmpTip
float frizScl
float frizOff
int maxSegment
int type
int furOnly
int randomSeed
int adaptive
int autoFade
int culling
int billboard
int glColorOverride
int useIC
LXtFVector glColor
LXtFVector glRootColor
int widthMode
float widthAbs
int guides
int guideSurf
int guideBound
float guideSize
float guideLen
char *guideTag
LXtID4 guideType
void *guideItem
void *taprGrad
void *flexGrad
void *jitrGrad
void *clmpGrad
void *curlGrad
void *frizGrad
void *kinkGrad
const char *densityMap
const char *lengthMap
const char *vectorMap
const char *clumpMap
const char *curlMap
const char *blendMap
const char *rangeMap
const char *bendMap
const char *widthMap
int vectorBound
LXtFVector bump
LXtFVector vec
float bumpHeight
float max
float dist
int enable
int cylinders
int tgtShade
int maxPass
int bumpPass
LXi_FUR_GUIDE_NONE

The guides are either ignored, or used for clumping or used for hair interpolation.

  • LXi_FUR_GUIDE_CLUMP

  • LXi_FUR_GUIDE_NORMAL

  • LXi_FUR_GUIDE_DIRLEN

  • LXi_FUR_GUIDE_SHAPE

  • LXi_FUR_GUIDE_INTERPOLATE

  • LXi_FUR_BILLBOARD_OFF

  • LXi_FUR_BILLBOARD_TREE

  • LXi_FUR_BILLBOARD_LEAF

  • LXi_FUR_BILLBOARD_FEATHER

  • LXi_FUR_BEND_DOWN

  • LXi_FUR_BEND_NORMAL

  • LXi_FUR_WIDTH_RELATIVE

  • LXi_FUR_WIDTH_ABSOLUTE

  • LXsP_FUR_PARMS

LXpParticleSample

struct st_LXpParticleSample

This packet is used for the particles base parameters. ‘ID’ is a float that is unique to each particle and can be used ‘lenParm’ is a parameter that indicates the position along the curve in the particle for hair/curve particles. ‘useLen’ is set to true by textures which change the particle/hair attributes along its length.

Public Members

LXtFVector vel
LXtFVector normal
LXtFVector bump
LXtFVector vector
float idParm
float lenParm
float minDist
float density
float size
float dissolve
float age
int useLen
float uv[2]
float duv[2]
float dpdu[3]
float dpdv[3]
float lum
float rgb[3]

  • LXsP_PARTICLE_SAMPLE

LXpShadeOpacity

struct st_LXpShadeOpacity

The opacity packet is used in special cases such as shadow evaluation.

Public Members

LXtFVector opa

LXpShadeComponents

struct st_LXpShadeComponents

The standard shading output is divided into six components (diffuse, specular, mirror reflection, transparency, subsurface scattering and luminosity) stored in the LXpShadeComponents packet, and a combined final color stored in the LXpShadeOutput packet. Both packets also contains fields related to various optional render outputs.

Public Members

LXtFVector diff
LXtFVector diffDir
LXtFVector diffInd
LXtFVector diffUns
LXtFVector spec
LXtFVector refl
LXtFVector tran
LXtFVector subs
LXtFVector lumi
LXtFVector illum
LXtFVector illumDir
LXtFVector illumInd
LXtFVector illumUns
LXtFVector volLum
LXtFVector volOpa

LXpShadeOutput

struct st_LXpShadeOutput

Public Members

LXtFVector color
LXtFVector mVec
LXtFVector sNorm
LXtFVector gNorm
LXtFVector uv
LXtFVector dpdu
LXtFVector dpdv
LXtFVector icVal
float alpha
float depth
float volDepth
float shadow
float occlAmb
float occlRef
float sInc

LXpShadeDiffuse

struct st_LXpShadeDiffuse

Public Members

LXtFVector val

LXpShadeSpecular

struct st_LXpShadeSpecular

Public Members

LXtFVector val

LXpShadeMirror

struct st_LXpShadeMirror

Public Members

LXtFVector val

LXpShadeTransparency

struct st_LXpShadeTransparency

Public Members

LXtFVector val

LXpShadeSubsurface

struct st_LXpShadeSubsurface

Public Members

LXtFVector val

LXpShadeLuminosity

struct st_LXpShadeLuminosity

Public Members

LXtFVector val

  • LXsP_SHADE_CLOSURE

  • LXsP_SHADE_OPACITY

  • LXsP_SHADE_COMPONENTS

  • LXsP_SHADE_OUTPUT

  • LXsP_SHADE_DIFFUSE

  • LXsP_SHADE_SPECULAR

  • LXsP_SHADE_MIRROR

  • LXsP_SHADE_TRANSPARENCY

  • LXsP_SHADE_SUBSURFACE

  • LXsP_SHADE_LUMINOSITY

LXpShadeFlags

struct st_LXpShadeFlags

This packet is used to create a surface shader slice that returns flags specifying whether the surface is double sided, whether it can possibly be transparent, whether it casts or receives shadows, its visibility to the camera and to rays, and whether to use physically-based shading.

Public Members

void *lightGroup
float shadeRate
float dirMult
float indMult
float indSat
float indSatOut
float alphaVal
float eta
unsigned int indType
unsigned int alphaType
unsigned int lightLink
unsigned int flags
char shadeEffect[32]
float rndAngle

  • LXfSURF_DOUBLE

  • LXfSURF_TRANSP

  • LXfSURF_SHADCAST

  • LXfSURF_SHADRECV

  • LXfSURF_VISCAM

  • LXfSURF_VISIND

  • LXfSURF_VISREFL

  • LXfSURF_VISREFR

  • LXfSURF_VISSUBS

  • LXfSURF_VISOCCL

  • LXfSURF_PHYSICAL

  • LXfSURF_REFLSPEC

  • LXfSURF_REFLBLUR

  • LXfSURF_SAMESURF

  • LXfSURF_TANSHADE

  • LXfSURF_CLIPPING

  • LXfSURF_CMPSHADE

  • LXfSURF_IMPSHADE

  • LXfSURF_CLPMATTE

  • LXfSURF_RNDSAME

  • LXfSURF_RNDWIDTH

  • LXfSURF_RADINTER

  • LXfSURF_USEREFIDX

  • LXfSURF_HIDDEN

  • LXfSURF_SPECREFIDX

  • LXfSURF_PERRAYFRES

  • LXsP_SHADE_FLAGS

LXpShadeLPE

struct st_LXpShadeLPE

This packet is used to communicate the light path expression label of a shader to a renderer.

Public Members

char *lpeLabel

  • LXsP_SHADE_LPE

  • SVPs_SHADE_LPE

LXpShadeFog

struct st_LXpShadeFog

Public Members

LXtFVector fogCol
float fogStart
float fogEnd
float fogDensity
float fogHeight
float fogFalloff
unsigned int fogType
unsigned int fogEnv

  • LXsP_SHADE_FOG

  • SVPs_SHADE_FOG

LXs_FX_ANISODIR

Texture effects are like vector packet definitions. They specify the way textures operate on the sample vector. The LXs_FX_ENVCOLOR and LXs_FX_ENVALTITUDE apply to environments.

  • LXs_FX_BUMP

  • LXs_FX_COATAMOUNT

  • LXs_FX_COATROUGH

  • LXs_FX_COATBUMP

  • LXs_FX_DIFFAMOUNT

  • LXs_FX_DIFFCOLOR

  • LXs_FX_DIFFROUGH

  • LXs_FX_DISPLACE

  • LXs_FX_DRIVERA

  • LXs_FX_DRIVERB

  • LXs_FX_DRIVERC

  • LXs_FX_DRIVERD

  • LXs_FX_ENVALTITUDE

  • LXs_FX_ENVCOLOR

  • LXs_FX_GROUPMASK

  • LXs_FX_LAYERMASK

  • LXs_FX_LUMIAMOUNT

  • LXs_FX_LUMICOLOR

  • LXs_FX_NORMAL

  • LXs_FX_NORMAL_COAT

  • LXs_FX_OBJNORMAL

  • LXs_FX_SPECAMOUNT

  • LXs_FX_SPECCOLOR

  • LXs_FX_SPECFRESNEL

  • LXs_FX_STENCIL

  • LXs_FX_REFLAMOUNT

  • LXs_FX_REFLCOLOR

  • LXs_FX_REFLFRESNEL

  • LXs_FX_RNDWIDTH

  • LXs_FX_ROUGH

  • LXs_FX_SUBSAMOUNT

  • LXs_FX_SUBSCOLOR

  • LXs_FX_SP_DENSITY

  • LXs_FX_SP_NORMAL

  • LXs_FX_SP_HEADING

  • LXs_FX_SP_SIZE

  • LXs_FX_PART_DENS

  • LXs_FX_PART_DISS

  • LXs_FX_PART_SIZE

  • LXs_FX_TRANAMOUNT

  • LXs_FX_TRANCOLOR

  • LXs_FX_TRANROUGH

  • LXs_FX_VECDISP

  • LXs_FX_RGBA

  • LXs_FX_DISSOLVE

  • LXs_FX_TXTROFFSET

  • LXs_FX_CULLING

  • LXs_FX_UE_METALLIC

  • LXs_FX_UE_BASE

  • LXs_FX_UE_ROUGH

  • LXs_FX_UE_SPEC

  • LXs_FX_UE_EMIS

  • LXs_FX_UE_NORMAL

  • LXs_FX_UE_BUMP

  • LXs_FX_UE_AO

  • LXs_FX_UE_SSS

  • LXs_FX_UE_COATAMOUNT

  • LXs_FX_UE_COATROUGH

  • LXs_FX_UE_OPACITY

  • LXs_FX_UT_METALLIC

  • LXs_FX_UT_ALBEDO

  • LXs_FX_UT_SMOOTH

  • LXs_FX_UT_EMIS

  • LXs_FX_UT_NORMAL

  • LXs_FX_UT_BUMP

  • LXs_FX_UT_AO

  • LXs_FX_UT_DetailMask

  • LXs_FX_UT_ALBEDO2

  • LXs_FX_UT_NORMAL2

  • LXs_FX_GLTF_METALLIC

  • LXs_FX_GLTF_BASE_COLOR

  • LXs_FX_GLTF_ROUGHNESS

  • LXs_FX_GLTF_EMIS

  • LXs_FX_GLTF_NORMAL

  • LXs_FX_GLTF_AO

  • LXs_FX_AXF_SPECULAR_COLOR

  • LXs_FX_AXF_BASE_COLOR

  • LXs_FX_AXF_SPECULAR_LOBE

  • LXs_FX_AXF_NORMAL

  • LXs_FX_AXF_ANISOTROPIC_ROTATION

  • LXs_FX_AXF_ALPHA

  • LXs_FX_AXF_HEIGHT

  • LXs_FX_AXF_FRESNEL

  • LXs_FX_AXF_CLEARCOAT_NORMAL

  • LXs_FX_AXF_CLEARCOAT_IOR

  • LXs_FX_METALLIC

  • LXs_FX_SPECTINT

  • LXs_FX_SHEEN

  • LXs_FX_SHEENTINT

  • LXs_FX_FLATNESS

  • LXs_FX_ANISOTROPIC

  • LXs_FX_RECOLOR_ORIGINAL

  • LXs_FX_RECOLOR_FROM

  • LXs_FX_RECOLOR_TO

  • LXs_FX_MATERIAL_MAP

  • LXs_FX_FUR_BEND

  • LXs_FX_FUR_BUMP

  • LXs_FX_FUR_CLDENS

  • LXs_FX_FUR_CLUMPS

  • LXs_FX_FUR_CURLS

  • LXs_FX_FUR_CYLINDERS

  • LXs_FX_FUR_DENSITY

  • LXs_FX_FUR_DIRECTION

  • LXs_FX_FUR_FLEX

  • LXs_FX_FUR_GROWJIT

  • LXs_FX_FUR_KINK

  • LXs_FX_FUR_FRIZZ

  • LXs_FX_FUR_KINK_TIP

  • LXs_FX_FUR_FRIZZ_TIP

  • LXs_FX_FUR_STRAYS

  • LXs_FX_FUR_GUIDE_NONE

  • LXs_FX_FUR_GUIDE_DIRLENGTH

  • LXs_FX_FUR_GUIDE_SHAPE

  • LXs_FX_FUR_GUIDE_RANGE

  • LXs_FX_FUR_GUIDE_DIRECTION

  • LXs_FX_FUR_GUIDE_CLUMP

  • LXs_FX_FUR_LENGTH

  • LXs_FX_FUR_STRIPS

  • LXs_FX_FUR_VECTOR

LXs_FX_OUTPUT_FINAL_COLOR

Render output effects are reserved for use with render outputs.

  • LXs_FX_OUTPUT_ALPHA

  • LXs_FX_OUTPUT_LIGHT_PATH_EXPRESSION

  • LXs_FX_OUTPUT_DIFFUSE_SHADING_TOTAL

  • LXs_FX_OUTPUT_DIFFUSE_SHADING_DIRECT

  • LXs_FX_OUTPUT_DIFFUSE_SHADING_INDIRECT

  • LXs_FX_OUTPUT_DIFFUSE_SHADING_UNSHADOWED

  • LXs_FX_OUTPUT_SPECULAR_SHADING

  • LXs_FX_OUTPUT_REFLECTION_SHADING

  • LXs_FX_OUTPUT_TRANSPARENT_SHADING

  • LXs_FX_OUTPUT_SUBSURFACE_SHADING

  • LXs_FX_OUTPUT_LUMINOUS_SHADING

  • LXs_FX_OUTPUT_VOL_SCATTERING

  • LXs_FX_OUTPUT_VOL_OPACITY

  • LXs_FX_OUTPUT_VOL_DEPTH

  • LXs_FX_OUTPUT_DEPTH

  • LXs_FX_OUTPUT_MOTION

  • LXs_FX_OUTPUT_SHADOW_DENSITY

  • LXs_FX_OUTPUT_AMBIENT_OCCLUSION

  • LXs_FX_OUTPUT_REFLECTION_OCCLUSION

  • LXs_FX_OUTPUT_SHADING_NORMAL

  • LXs_FX_OUTPUT_SHADING_INCIDENCE

  • LXs_FX_OUTPUT_GEOMETRIC_NORMAL

  • LXs_FX_OUTPUT_SURFACE_ID

  • LXs_FX_OUTPUT_SEGMENT_ID

  • LXs_FX_OUTPUT_OBJECT_COORDINATES

  • LXs_FX_OUTPUT_WORLD_COORDINATES

  • LXs_FX_OUTPUT_UV_COORDINATES

  • LXs_FX_OUTPUT_DPDU_VECTOR

  • LXs_FX_OUTPUT_DPDV_VECTOR

  • LXs_FX_OUTPUT_IC_POSITIONS

  • LXs_FX_OUTPUT_IC_VALUES

  • LXs_FX_OUTPUT_DIFFUSE_COLOR

  • LXs_FX_OUTPUT_DIFFUSE_AMOUNT

  • LXs_FX_OUTPUT_DIFFUSE_ROUGHNESS

  • LXs_FX_OUTPUT_DIFFUSE_ENERGY_CONSERVATION

  • LXs_FX_OUTPUT_ROUGHNESS

  • LXs_FX_OUTPUT_DIFFUSE_COEFFICIENT

  • LXs_FX_OUTPUT_SPECULAR_COEFFICIENT

  • LXs_FX_OUTPUT_REFLECTION_COEFFICIENT

  • LXs_FX_OUTPUT_TRANSPARENT_AMOUNT

  • LXs_FX_OUTPUT_TRANSPARENT_COLOR

  • LXs_FX_OUTPUT_SUBSURFACE_AMOUNT

  • LXs_FX_OUTPUT_SUBSURFACE_COLOR

  • LXs_FX_OUTPUT_ALBEDO

  • LXs_FX_OUTPUT_ILLUMINATION_SHADING_TOTAL

  • LXs_FX_OUTPUT_ILLUMINATION_SHADING_DIRECT

  • LXs_FX_OUTPUT_ILLUMINATION_SHADING_INDIRECT

  • LXs_FX_OUTPUT_ILLUMINATION_SHADING_UNSHADOWED

  • LXs_FX_OUTPUT_SHADING_SAMPLES

  • LXs_FX_OUTPUT_VARIANCE

  • LXs_FX_OUTPUT_PARTICLE_ID

  • LXs_FX_OUTPUT_PARTICLE_AGE

  • LXs_FX_OUTPUT_PARTICLE_VEL

  • LXs_FX_OUTPUT_RECOLOR_TO

  • LXs_FX_OUTPUT_RECOLOR_TO_WHITE

  • LXs_FX_OUTPUT_MATERIAL_MAP

LXs_FX_SHADER_FULL_SHADING

Shader shading effects are reserved for use with shaders.

  • LXs_FX_SHADER_DIFFUSE_SHADING

  • LXs_FX_SHADER_SPECULAR_SHADING

  • LXs_FX_SHADER_REFLECTION_SHADING

  • LXs_FX_SHADER_TRANSPARENT_SHADING

  • LXs_FX_SHADER_SUBSURFACE_SHADING

  • LXs_FX_SHADER_LUMINOUS_SHADING

  • LXs_FX_SHADER_FOG_SHADING

LXsSHADE_SURFACE

Texture Layers exist in various shading categories: render, light, environment, camera, output, scene. There is also the ‘procedural’ category which is used by texture layers that can be found in all environments (image maps for example). The ‘output’ category is reserved for shaders that produce an output used by render buffers. The ‘scene’ category is for animation shaders, for example a noise evaluated on a deformer or a gradient evaluated on a force item.

  • LXsSHADE_LIGHT

  • LXsSHADE_ENVIRONMENT

  • LXsSHADE_PROCEDURAL

  • LXsSHADE_OUTPUT

  • LXsSHADE_CAMERA

  • LXsSHADE_SCENE

  • LXsSHADE_SGEN

LXi_TFX_SCALAR

Texture effects are listed in the UI in the shader tree in the ‘Effect’ column they are extensible and can change any read and write to any number of packets. An example of texture effect would be the ‘diffuse color’ effect, it reads the LXpSampleParms packet, extracts the ‘diffCol’ color value, passes that value to texture evaluation and finally replaces ‘diffCol’ in that same packet. The texture effect interface is polymorphic with the vector type interface. It has three additional methods used to describe how the effect operates on the sample vector.

  • Type This returns the effect data type and read/write flags. The base type is one of scalar, color. Optional flags include indicating if an effect is read or write (or both), if the effect is used as a gradient input, or if it’s displayed as black and white (for scalar effects).

  • LXi_TFX_COLOR

  • LXf_TFX_READ

  • LXf_TFX_WRITE

  • LXf_TFX_INPUT

  • LXf_TFX_BW

ILxTextureEffect

class ILxTextureEffect

Texture effects are defined as servers and so may be expanded by plug-ins. They also define their category as a server tag.

Public Functions

unsigned int Type(LXtObjectID self)

  • Get This sets the float value from the ‘get’ vector packets

  • Set This sets the texture output value in the ‘set’ sample vector packets.

const char *TypeName(LXtObjectID self)
LxResult Get(LXtObjectID self, LXtObjectID sv, float *val, void *item)
LxResult Set(LXtObjectID self, LXtObjectID sv, const float *val, void *item)

  • LXsTFX_CATEGORY

ILxPacketEffect

class ILxPacketEffect

Public Functions

LxResult Packet(LXtObjectID self, const char **packet)

Alternatively, this interface let’s you define all the effects for a packet, this is a faster way to define texture effects for custom materials and shaders

unsigned int Count(LXtObjectID self)
LxResult ByIndex(LXtObjectID self, int index, const char **name, const char **typeName, int *type)
LxResult Get(LXtObjectID self, int index, void *packet, float *val, void *item)
LxResult Set(LXtObjectID self, int index, void *packet, const float *val, void *item)