SIBGRAPI 2005

Interactive shader development for ray tracing using Python scripts

Abstract. Shaders describe the appearance of a surface. The creation of an efficient and quality shader requires some effort and is often done iterative. Sometimes it is even important to fine tune shaders in the display environment in which the shader is utilized. Developing a shader in a compiled language, like C++, leads to recompiling and restaring the system after changing the shader. This is a time consuming process. Being able to change the shader online leads to significant time savings. Scripting languages interpreted at run time can be used to do interactive shader development. All shader changes are visible the next frame and the workflow is not interrupted for recompiling and restarting the system. Continuous working with the model is achieved. Our ray tracing framework, written in C++, is designed to support shader-scripts and it provides an interactive interface to allow changes at run time. We decided to use Python as the scripting language mainly because of its object orientation and clear syntax. Other systems that support scripting are Renderman for off-line global illumination calculations and CG for local illumination on the graphics hardware.

[ project home page | contact authors ]

Example of a simple Phong-shader.

All objects from the module giAPI are extensions of the ray-tracing framework for Python.
This extension is needed to exchange data between C++ and Python.


import giAPI
import math

class phongMaterial:

# Diffuse colour
_dCol = giAPI.colour(0.8, 0.8, 0.8)

# Specular colour
_sCol = giAPI.colour(0.0, 0.0, 0.0)

# Shininess coefficient
_shininess = 1.0

# Half vector used for shader calculation.
_halfVec = giAPI.vector3D(1.0,1.0,1.0)

# Calculate the BRDF
def calcBRDF( __self, __inVec, __normal, __outVec, __retColour ):
fd = __outVec.mul( __normal )
if fd < 0.0:

fd = fd * -1.0

__retColour.muls( fd, __self._dCol )

giAPI.vecOpCalculateNormalizedHalfVector( __inVec, __outVec, __self._halfVec )
fs = __self._halfVec.mul( __normal )
if fs < 0.0:

fs = fs * -1.0

fs = math.pow( fs, __self._shininess )
__retColour.addMul( __self._sCol, fs )

# For Monte-Carlo Methods: Calculate the part of the BRDF the outgoing vector got sampled for.
# Not used here.
def calcBRDFPart( __self, __inVec, __normal, __outVec, __matComp, __retColour ):

__retColour.set( 1.0, 1.0, 1.0 )

# For Monte-Carlo Methods: Sample one outgoing vector.
# Not used here.
def sampleBRDF( __self, __inVec, __normal, __sampledMatComp, __newOutVec, __pdfValue ):

__newOutVec.set( 1.0, 1.0, 1.0 )
__pdfValue = 1.0