Overview
OpenGL shaders are hardware accelerated shaders that are executed on the video card. OpenGL shaders only affect the viewport – they are not rendered. You can create an OpenGL shader and include it in a material to show a better representation of the material in the viewport.
Writing an OpenGL shader
Creating a new shader type
OpenGL shaders are written using GLSL (the OpenGL Shader Language). Before you can create an OpenGL shader you need to understand GLSL and its related concepts such as vertex shaders and fragment shaders.
Choose File > New operator type.
Click on SHOP Type.
In the Network Type menu, choose GLSL Shader.
Enter an internal Name for the shader and a human-readable Label.
Click Accept. The type properties window for the new shader type appears.
Click the Code tab. The node starts with some default shader code. You can use this as a starting point for creating your shader.
There are two shader targets for the viewport - GL2.1 and GL3.2. The GL2.1 shader target consists of two shaders, the vertex and fragment shader. These shaders generally use the GLSL builtin state, such as the lighting state, material state and GL matrix stacks. The GL3.2 shader target also includes an optional geometry shader, which executes between the vertex and fragment shaders on GL primitives. Both shader targets can be defined; the GL2.1 target is used for the GL2.1 and H11 viewports, while the GL3.2 target is used for the GL3.2 viewport.
The Code tab provides a simple editor for working with GLSL code. The editor has three or four text boxes: one for the vertex shader, one for the geometry shader for the GL3.2 shader, one for the fragment shader, and one for compiler output. You can drag the dividers between the three panes to resize them.
Click Test compile to try compiling the default code. The output of the compiler appears in the third pane.
See the OpenGL GLSL documentation for more information on programming in GLSL.
You cannot currently create a GLSL shader using VOPs.
Houdini GL2.1 built-in functions
Houdini will automatically load and link the following GLSL functions if they are found in the GL2.1 shader code. All the methods are fragment shader specific unless otherwise noted.
void HOUassignOutputs(vec3 emit, vec3 amb, vec3 diff, vec3 spec, float shiny, vec3 P, vec3 N, float alpha)
| Assigns the various RGB lighting components to the output color. Additional
information, such as |
void HOUassignDiffuseOnly(vec3 diff, vec3 P, vec3 N, float alpha)
| Assigns only the diffuse component. All other components are assumed to be zero. Point, Normal and alpha are required for High Quality Lighting and Transparency passes. |
void HOUassignEmissionOnly(vec3 emit, float alpha)
| Assigns the emission of the object along with the opacity. This is also used when the shader computes its own illumination, or doesn’t want its color affected by further lighting calculations. |
Note
All fragment shaders must use exactly one of the HOUassign methods to
write out their color values, instead of directly writing to gl_FragColor or gl_FragData[].
float HOUdiffuse(vec3 P, vec3 N)
| Computes the diffuse illumination given point position |
void HOUlightDiffSpec(in vec3 P, in vec3 N, inout float diff, inout float spec, in float shiny)
| Computes the specular and diffuse intensities for all lights in the scene
(up to |
HOUlightingModel(in vec3 P, in vec3 N, inout vec4 amb, inout vec4 diff, inout float spec, in float shiny)
| Computes the ambient, diffuse and specular colors for all lights in the
scene (up to |
vec3 HOUfaceForward(vec3 N, vec3 P)
| Returns the normal |
void HOUdepthPeel(vec3 P)
| Discards the fragment if the fragment fails the depth peel test. |
float HOUsampleDepth(vec2 pos, int sample)
| Returns the depth from UV coordinate |
vec3 HOUsampleNormal(vec2 pos, int sample)
| Returns the normal from UV coordinate |
Houdini GL 3.2 built-in functions
The GL3.2 viewport has similar fragment shader functions, but also includes geometry shader functions for doing polygon outlining and attribute lookups.
Fragment shader functions
void HOUassignLitOutput(vec3 point_color,vec3 emit,vec3 amb,vec3 diff,vec3 spec,vec4 wire,float alpha,float selected)
| Composites the lighting components, applies any Houdini shading (such as ghosting) and assigns the result to the fragment shader out in normal lighting mode (glH_MaterialPass is 0). The normal renderer is a forward renderer (all lighting computed on all shaded pixels). |
void HOUassignMaterialOutput(vec3 point_color,vec3 emit_color,vec3 amb_color,vec3 diff_color,vec3 spec_color,float alpha,float emit_alpha,float shiny,vec4 wire,vec3 nN,float z,float selected)
| Assigns the lighting components to the g-buffer outputs for the high
quality lighting mode ( |
void HOUapplyLightMaps(inout vec3 nN, inout vec3 mspec, inout float shiny,bool has_bump_map, bool has_spec_map, vec2 bumpCoords, vec2 specCoords, float bumpScale, int bumpComps, bool bumpBias, bool bumpInvert, vec2 bumpMapSize, bool specularShinyAdjust, vec2 shinyRange)
| Computes the normal ( |
void HOUfastLightingModel(in vec3 P,in vec3 nN,inout vec3 lAmb,inout vec3 lDiff,inout vec3 lSpec,in float sh)
| Computes the lighting components |
void HOUlightingModel(in vec3 P,in vec3 nN,inout vec3 lAmb,inout vec3 lDiff,inout vec3 lSpec,in float sh)
| Computes t he lighting components in the same way as |
float HOUwireAlpha(vec3 edgedist, int edgeflag, float cut)
| Given the edge distances and flags for all 3 triangle edges (x,y,z), and
cutoff tolerance for the inner (non-AA) section of the line, compute an
alpha for a pixel within a rendered triangle. This creates outlined
triangles based on |
vec4 HOUwireColor(vec3 edgedist, int edgeflag, float selected)
| Similar to |
Geometry shader functions
vec3 HOUedgeDistance(vec4 v0, vec4 v1, vec4 v2, out int edges))
| Given the three vertices in clip space of a triangle within a tessellated
polygon, compute the edge flags ( |
int HOUedges(vec4 v0, vec4 v1, vec4 v2)
| A stripped down version of |
bool HOUfrustumCull(vec4 v0, vec4 v1, vec4 v2)
| Returns true if the triangle with vertices v0, v1 and v2 (in clip space) is outside the current viewing frustum. This is a fast check, and some cases which are actually outside the viewing frustum may return false. In no cases will a triangle that is within the viewing frustum ever return true. |
int HOUprimitiveID(out ivec3 vertices)
| Returns the primitive ID for the current triangle, line or point. The
|
int HOUprimitiveIDEdges(out ivec3 vertices, out int edgeflags)
| This is a combination of |
int HOUvertexID(out ivec3 vertices)
| Returns a bitfield that provides some information about the current
triangle, and sets
This can be used to position primitive and vertex decorations and estimate the centroid of the polygon. |
Houdini auto-uniforms
Houdini automatically generates values for the following uniforms (all prefixed
with glH_) which may be used by all shader stages.
glH_MaterialPass
| An integer that stores the current pass being render. These passes are:
Lighting calculations should only be performed if |
glH_ViewMatrix
| The view matrix (not to be confused with OpenGL’s |
glH_InvViewMatrix
| The inverse of the view matrix (not to be confused with OpenGL’s |
glH_ObjectMatrix (GL3.2 only)
| The object transform for the geometry. |
glH_ProjectMatrix
| The transform used to convert camera space coords to clip space coords (which are -1,1 for X,Y, and Z). |
glH_InvProjectMatrix
| The inverse of the projection matrix, used to convert clip coords back into camera space. |
glH_NumSamples
| The number of samples in a multisampled (2x, 4x, 8x AA) buffer. |
glH_LightEnabled (GL2.1 only)
| An array that indicates which of OpenGL’s lights are enabled. |
glH_LightingEnabled
| An integer that is either 1 if lighting is enabled, or zero if not. |
glH_LightMask (GL3.2 only)
| A int32 bitmask of lights that are enabled. The first scene light has bit 1, the second bit 2 (0×2), the third bit 3 (0×4), etc. |
glH_ScreenSize
| A vec2 containing the current dimension of the viewport being rendered. |
glH_WireOver (GL3.2 only)
| An integer set to one when a wireframe should be drawn over the model, and zero otherwise. |
glH_WireColor (GL3.2 only)
| The constant color of the wireframe overlay. This can change colors based on selection, template drawing or ghosting. |
glH_WireThickness (GL3.2 only)
| The current wire thickness, based on the display option setting, which may change depending on the selection status. |
glH_ConstColor (GL3.2 only)
| The constant color for drawing modes such as Hidden Line Invisible and Ghost. |
glH_IsOrtho (GL3.2 only)
| An integer set to zero if the view is perspective, or one if orthographic. |
glH_SelectMode (GL3.2 only)
| The current compoent selection display mode:
Point, primitive and vertex group selections are treated as point, primitive and vertex selections, respectively. |
The follow uniforms are available, but generally only used by the HOUassign() family of built-in Houdini functions. If you do not use them (not recommended) you will need to multiply in the factors, apply the ghost color, handle the depth peeling and two-sided lighting for transparency.
glH_Emission
| A float that is 1.0 if emission is used in this pass, 0.0 if not. |
glH_Specular
| A float that is 1.0 if specular is used in this pass, 0.0 if not. |
glH_Diffuse
| A float that is 1.0 if diffuse is used in this pass, 0.0 if not. |
glH_Ambient
| A float that is 1.0 if ambient is used in this pass, 0.0 if not. |
glH_GhostColor
| A vec4 representing the ghosting color for 'ghost other objects' display mode. It is set regardless of whether the current object is ghosted, though the color will be (0,0,0,0) if the object is not ghosted. |
glH_SelectColor
| The current selection color, which can change depending on the selection type (object, component, closure, secondary). |
glH_DepthPeelEnable (GL2.1 only)
| An integer that is 1 when depth peeling is active, 0 otherwise. |
glH_DepthPeelMap (GL2.1 only)
| A 2D texture sampler containing the depth map for depth peeling. |
glH_AlphaPass
| An integer that is 1 when a transparency pass is active, 0 otherwise.
Transparency passes always light the polygon face that is facing the light.
This is used by the |
Coding guidelines
Houdini’s viewport renderer has a large number of display settings which users can change. In some cases the viewport renderer renders multiple passes in order to create a certain visual effect. For example, projective textures and shadows both require multiple passes.
To be compatible with Houdini’s various rendering modes, GLSL shaders should adhere to the following guidelines:
Use one of the
HOUassign...()methods to assign the color output of a fragment shader.Do GL lighting with
HOUlightingModel(),HOUdiffuse()orHOUlightDiffSpec(). Otherwise, only add light contributions from enabled light sources. Use theglH_LightEnabledorglH_LightMaskuniform to check which lights are enabled.
The multi-pass viewport render
When writing a GLSL shader in Houdini it is useful to understand the contexts
in which the shader will be executed. The uniform glH_MaterialPass can be used to query the pass.
| Normal Lighting Pass (0) | Ambient, diffuse, specular and emission components can all be calculated with full lighting. This may be done with the Houdini lighting functions or by the shader. |
| High Quality Lighting Pass (1) | The raw ambient, diffuse, specular and emissive components of the material should be defined but no lighting calculations should be applied. If a shader does not want to participate in HQ lighting, do the lighting computations and assign it to the emissive component. |
| Normal Pass (2) | Everything but the normal component is discarded. This is only used in the GL2.1 viewport. |
| Shadow Map Pass (3) | A shadow map is being created. Only the depth and alpha value are used, so all calculations for color can be avoided. |
When shading, the glH_AlphaPass variable is set to 1 if a transparency pass
is rendering. You may discard the fragment if your material uses transparency
and glH_AlphaPass is 0, or if your material is opaque and glH_AlphaPass is 1.
Transparency
The OpenGL viewport renderer distinguishes between transparent and opaque
materials. To properly render transparent objects, shaders must provide a hint
to the renderer. Currently you do this by declaring a parameter of type float
with the name "ogl_alpha".
GL3.2 Viewport
The GL3.2 viewport pushes many responsibilities to the GPU, in order to improve geometry update performance. This makes parts of the shaders a bit more complicated, such as the geometry shader. The geometry shader is required to lookup primitive and vertex attributes (the vertex shader can only lookup vertex attributes).
In addition, the GLSL built-ins are deprecated. These include the GL lighting uniforms, transform matrices (gl_ProjectionMatrix, gl_ModelviewMatrix), and the predefined vertex shader inputs and outputs (glVertex, glNormal, glColor, gl_MultiTexCoord#, gl_TexCoord). Instead, all information is passed through uniforms, uniform blocks, and named vertex inputs (P, Cd, Alpha, N) which correspond to their Houdini attribute names.
Besides the glH_ Houdini uniforms listed above, the GL3.2 viewport also
recognizes uniform blocks. There is a limited number of uniform blocks
available in any shader stage (see Help > About Houdini and Show Details,
in the OpenGL information for COMBINED_VERT_UNIFORM_BLOCKS and others).
Material uniform block
The definition of a Houdini material. This may be used in any shader stage.
layout(std140) uniform material
{
vec3 ambient_color;
vec3 diffuse_color;
vec3 emission_color;
vec3 specular_color;
float material_alpha;
float shininess;
bool has_diffuse_map;
bool has_bump_map;
int bumpComps;
vec2 bumpMapSize;
bool bumpBias;
bool bumpInvert;
float bumpScale;
bool has_spec_map;
bool specularShinyAdjust;
vec2 shinyRange;
};
uniform sampler2D diffuseMap;
uniform sampler2D bumpMap;
uniform sampler2D specularMap;
Light uniform block
Basic information for scene lights. The trailing digit may be 0-9 for multiple lights. Check the glH_LightMask to see if that light should contribute.
layout(std140) uniform light0
{
vec3 pos;
vec3 dir;
vec3 atten;
vec3 amb;
vec3 spec;
vec3 diff;
float coscutoff;
bool point;
} lightSource0;
Applying an OpenGL shader
| Assign a GLSL shader for the viewport only | Set an object’s surface shader to an instance of your GLSL shader, or connect an instance of your GLSL shader to the surface color output inside a material. |
| Assign both a GLSL shader for the viewport and a shader for the renderer |
|
gear menu and turn on VEX/RenderMan shader. This creates another tab where you can write VEX or RenderMan shader code.
Troubleshooting
| My Geometry is Invisible |
|
| My Geometry is Not Receiving Shadows | Some shaders emit light and don’t reflect light (e.g. the decal shader). Such a shader will, by design, not receive shadows. |