DIGM 512: Shader Writing and Programming

Winter 2012

Dr. Paul Diefenbach

pjdief at drexel dot edu

Office Hours: By Appointment

Course Description

Development of custom output shaders allows for the use and manipulation of materials for use in production render engines. This course focuses on the basic components of shaders including reflective, translucency, and illumination models.

Course Purpose

This course will introduce students to shaders for both real-time and non-real-time rendering.

Expected Learning Outcomes

This course will teach the basis of both real-time and non-real time rendering, and the lighting equations associated with each. Students will learn to write programmable shaders and use tools to create new shaders.

Format

Classes will be a combination of:

• · instruction and tutorial

• · class discussions

• · individual and group assignments

• · lab and presentation period

Class participation is an important part of your evaluation and grade. In addition, students will be required to work in teams outside of class in the computer labs, doing research online and in books and journals, and hands-on exposure to various video games.

Assignments

TBA

Project

The term project will be done individually or in small groups. Each week after the proposal, the group will give a brief 5-10 presentation on what they've accomplished the previous week, showing off new features, highlighting what worked well, what they have trouble on, and an opportunity for collecting feedback.

Project Proposal (5%) (Due week 6)

Project Status Reports (20%) (Due Week 7, 8, 9, 10)

Final Project Presentation (50%) (Due finals week)

Submission

Please place your assignments in a folder labeled with your name (first initial, last name) or team name in the DIGM512 "Submission" folder, in the folder of the assignment/project name. The DIGM512 folder is located on DigmFiles, which can be accessed from the labs or using a FTP program on your home computer.

Projects are to be put in the folder before the start of class, ready for presentation. You must present what you have; there are no late submissions.

Grading

15% - Assignments (1-3)

10% - Participation/Attendance

25% - Project Assessments

50% - Project Demo Presentation

Attendance

You are expected to attend all classes. Class participation is an important part of your grade. Unexcused absence results in a deduction in your grade. Missing 3 classes results in automatic failure. If a student must miss class, it is the student's responsibility to contact me by phone the day prior to the missed class. Students will also be responsible for getting missed notes from the other students.

Academic Integrity, Plagiarism, and Cheating Policy

http://drexel.edu/provost/policies/academic_dishonesty.asp

http://drexel.edu/studentlife/judicial/honesty.html

Students with Disability Statement

http://drexel.edu/ods/student_reg.html

Course Drop Policy

http://drexel.edu/provost/policies/course_drop.asp

Course Change Policy

The instructor reserves the right to change the course during the term at his or her discretion. These changes will be communicated to students via the syllabus, website announcement, or email

Schedule

Week 1: History and Overview of Rendering

History

Overview of Rendering

Lighting

Local vs. Global

Ray tracing

Radiosity

Rendering Math

Ray Tracing

http://www.siggraph.org/education/materials/HyperGraph/raytrace/rtrace0.htm

http://www.siggraph.org/education/materials/HyperGraph/radiosity/overview_1.htm

Interactive Cross Product Demo

Interactive Dot Product Demo

Week 2: Maya Renderers

Topics:

Maya Renderers

Shader networks/hypershade

Assignment 1:

Create a Maya shader network to combine 3 different materials that are not normally combined, i.e. Bob The Alien's rusty-furry-glass-car or her favorite breakfast, a metalic-appleskinned-frosted-donut.

Maya Renderers:

Maya Rendering Reference:

http://autodesk.com/us/maya/2011help/files/WS73099cc142f48755-4bc38c931187aa80bc9-32b3.htm

Renderer Comparison:

www.thethirdfloorinc.com/publish/_assets/417/10/02/tdw126.f.renderers-7a90.pdf

Hypershade Tutorials:

http://accad.osu.edu/~midori/Materials/maya_hypershade.htm

http://www.3dtutorialzone.com/tutorial?id=66

Maya Layered Textures:

http://www.youtube.com/watch?v=sdI3ddGFYJg

Double-sided shader

http://autodesk.com/us/maya/2011help/files/Asts_Create_doublesided_shaded_surfaces.htm

Maya Shader Networks (The One Ring):

http://www.youtube.com/watch?v=9fTPqfhKacI

More complex shader network (Apple Shader):

http://www.creativecrash.com/maya/downloads/shaders/c/procedural-apple-shader/description#tabs

Maya Shader Utilities:

http://autodesk.com/us/maya/2011help/index.html?url=./files/Render_node_utilities_Render_node_utilities.htm,topicNumber=d0e537815

Maya Real-time Rendering:

http://www.youtube.com/user/lugherini#p/u/1/rt3aPcyvKlw

Week 3&4: Rendering and Shaders

Topics:

Vertex

Pixel (Fragment)

Geometry

Maya Mental Ray shaders

Renderman shaders

Assignments:

Note: Assignments use the file //DIGMFILES/Faculty_Files/Diefenbach_Paul//DIGM512/MI_simple_shaders.zip

1) Complete the smiley face shader

2) Make smiley face bump or geometry shader

3) Compile and use 3 shaders from included weblinks below

(see Mental Ray Shader Source Code Examples)

Extra credit:

Modify any of the 3 shaders. The more the modification, the more the credit.

Mental Images Mental Ray

Writing Native Shaders

A vertex program must output a position and may return one or more colors, texture coordinate sets, and other per-vertex outputs. A fragment program, however, must reduce everything to a single color that will update the frame buffer. (In some advanced profiles, fragment programs can write additional data such as a depth value as well.)

An example of a surface shader that defines a metal surface is:

surface metal(float Ka = 1; float Ks = 1; float roughness = 0.1;){ normal Nf = faceforward(normalize(N), I); vector V = - normalize(I); Oi = Os; Ci = Os * Cs * (Ka * ambient() + Ks * specular(Nf, V, roughness));}

Shaders do the work by reading and writing special variables such as Cs (surface color), N (normal at given point), and Ci (final surface color).

Mental Ray provides a shader language to do this.

Teaching slides from Writing mental ray shaders: A perceptual introduction, the third mental ray Handbook now available from SpringerWienNewYork and Amazon.com:

http://www.writingshaders.com/teaching.html

Maya, Mel, Python, Renderman & Mental Ray Scripting in Cutter:

http://www.fundza.com/

Note: Makefile and other tempates in:

/Applications/Cutter_Help/templates/

Modified Cutter makefile for C++ compiling is in zip file for this class.

Renderman

Renderman for Maya Tutorials:

http://cgterminal.com/2011/04/30/renderman-for-maya-video-tutorials/

Virtual Statue Renderman for Maya:

http://www.scott-eaton.com/outgoing/3dWorld-Prometheus-Renderman-Eaton.pdf

Renderman Shader Tutorial:

http://penguin.ewu.edu/RenderMan/RMS_2.0/tutorialRenderManShaders.html

Renderman Shaders (free):

http://www.creativecrash.com/renderman/downloads/shaders/c/

Advanced Rendering Effects

Procedural Shaders:

web.cs.wpi.edu/~emmanuel/.../fan_wk6_Procedural_Shaders.pdf

Interactive Fractals:

http://www.dangries.com/Flash/FractalMakerExp/FractalMaker_exp.html

Understanding Fractal Shaders- Building a Marble Pattern:

http://www.davidcornette.com/glsl/noise.html

Maya Fractal Textures:

http://www.pixelstreetstudios.com/maya80/texFractal/

Fractal Noise:

http://library.creativecow.net/articles/zwar_chris/fractal_noise.php

Perlin Noise:

http://www.noisemachine.com/talk1/index.html

Simple Explanation:

http://webstaff.itn.liu.se/~stegu/TNM022-2005/perlinnoiselinks/perlin-noise-math-faq.html

The Importance of Being Noisy: Fast, High Quality Noise:

http://developer.amd.com/assets/Tatarchuk-Noise(GDC07-D3D_Day).pdf

Advanced Noise Foundations: Fourier Transforms:

http://www.fourier-series.com/f-transform/index.html

Nyquist info:

http://photo.stackexchange.com/questions/10755/what-is-the-nyquist-limit-and-what-is-its-significance-to-photographers

Pixar's Wavelet Noise Paper:

graphics.pixar.com/library/WaveletNoise/paper.pdf

Matrix, Vector, and Quaternion Math:

http://www.sacredsoftware.net/tutorials/Vectors/Vectors.xhtml

http://www.sacredsoftware.net/tutorials/Quaternions/Quaternions.xhtml

http://www.sacredsoftware.net/tutorials/Matrices/Matrices.xhtml

Week 5: Real Time Rendering

Overview of Shaders:

www.m2h.nl/files/LiteraturestudyShaders.pdf

There are two widely used shader languages out there: HLSL (or Cg, which is the same for practical purposes) and GLSL. Cg/HLSL is used by Direct3D, Xbox 360 and PS3. GLSL is used by mobile platforms (OpenGL ES 2.0), Mac OS X (OpenGL) and upcoming WebGL. Traditionally, Unity shaders are written in Cg/HLSL

HLSL

You can think HLSL as a C language for GPU programming except there are no pointer, union, bitwise operations, and function variables. There are no goto, switch, recursive function in HLSL as well. However HLSL adds vector data type, build-in constructor, swizzling and masking operators. HLSL standard library includes mathematical functions and texture processing functions.

http://en.wikipedia.org/wiki/High_Level_Shader_Language

Great Overview of not just HLSL but shader principles in general:

Programming Vertex, Geometry, and Pixel Shaders, Second Edition, by Wolfgang Engel

ShaderX2: Intro & Tutorials (DirectX 9)

http://tog.acm.org/resources/shaderx/

Other HLSL overview:

http://www.neatware.com/lbstudio/web/hlsl.html

D3D Effects Files:

(from http://www.toymaker.info/Games/html/effects_files.html)

Higher level shading languages like HLSL and Cg define rendering methods and effects files define the rendering context (based on platform etc.). Effect files can contain different rendering techniques that can be chosen based on the hardware available as well as HLSL code to define rendering. Direct3D provides a set of

interfaces to allow the easy manipulation of effects. This is similar to the use of .mi files in MentalRay.

Effect File Structure

An effect file is a text file with a .fx extension. It is split into three main sections:

• 1. Variable declarations - these are values that can be set before rendering and then used in this effect file. Examples include: textures, world matrix, lighting parameters

  2. Techniques & Passes- defines how something is to be rendered. It includes state information along with vertex and shader declarations.

  3. Functions - the shader code written in HLSL

CG

http://en.wikipedia.org/wiki/Cg_%28programming_language%29

http://http.developer.nvidia.com/CgTutorial/cg_tutorial_chapter01.html

GLSL

http://en.wikipedia.org/wiki/Glsl

http://www.lighthouse3d.com/opengl/glsl/

Shader Translators and Optimizers:

HLSL2GLSL, an existing open source project that ATI has made 4 years ago and seemingly abandoned

Unitiy's fork of this translator, named “hlsl2glslfork”, is here: http://code.google.com/p/hlsl2glslfork/

“GLSL Optimizer”: http://github.com/aras-p/glsl-optimizer

Unity3D Shaders:

Shaders in Unity can be written in one of three different ways:

• • Surface Shaders will probably be your best bet. Write your shader as a surface shader if it needs to interact properly with lighting, shadows, projectors, etc. Surface shaders also make it easy to write complex shaders in a compact way - it's a higher level of abstraction. Lighting for most surface shaders can be calculated in a deferred manner (the exception is some very custom lighting models), which allows your shader to efficiently interact with many realtime lights. You write surface shaders in a couple of lines of Cg/HLSL and a lot more code gets auto-generated from that.

  • Vertex and Fragment Shaders will be required, if you need some very exotic effects that the surface shaders can't handle, if your shader doesn't need to interact with lighting or if it's an image effect. Shader programs written this way are the most flexible way to create the effect you need (even surface shaders are automatically converted to a bunch of vertex and fragment shaders), but that comes at a price: you have to write more code and it's harder to make it interact with lighting. These shaders are written in Cg/HLSL as well. (NOTE: most other systems integrate lighting into the fragment shader, but because of Unity's mixed lighting models, you should not typically do this!)

  • Fixed Function Shaders need to be written for old hardware that doesn't support programmable shaders. You will probably want to write fixed function shaders as an n-th fallback to your fancy fragment or surface shaders, to make sure your game still renders something sensible when run on old hardware or simpler mobile platforms. Fixed function shaders are entirely written in a language called ShaderLab, which is similar to Microsoft's .FX files or NVIDIA's CgFX.

To create a new shader, either choose Assets->Create->Shader from the menubar, or duplicate an existing shader, and work from that. The new shader can be edited by double-clicking it in the Project View.

Unity3D Shader Lab:

Regardless of which type you choose, the actual meat of the shader code will always be wrapped in ShaderLab (file extension .SHADER , which is used to organize the shader structure, similar to an .MI file in Mental Ray. It looks like this:

Shader "MyShader" { Properties { _MyTexture ("My Texture", 2D) = "white" { } // other properties like colors or vectors go here as well } SubShader { // here goes the 'meat' of your // - surface shader or // - vertex and fragment shader or // - fixed function shader } SubShader { // here goes a simpler version of the SubShader above that can run on older graphics cards } }

ShaderLab shaders encompass more than just "hardware shaders". They do many things. They describe properties that are displayed in the Material Inspector, contain multiple shader implementations for different graphics hardware, configure fixed function hardware state and so on. The actual programmable shaders - like vertex and fragment programs - are just a part of the whole ShaderLab's "shader" concept.

If you want to write shaders that interact with lighting, take a look at Surface Shaders documentation.

Surface Shaders in Unity is a code generation approach that makes it much easier to write lit shaders than using low level vertex/pixel shader programs. Note that there is no custom languages, magic or ninjas involved in Surface Shaders; it just generates all the repetitive code that would have to be written by hand. You still write shader code in Cg / HLSL.

Unity3D Shader Design history, background, and theory:

http://blogs.unity3d.com/2010/07/17/unity-3-technology-surface-shaders/

http://aras-p.info/blog/2010/09/29/glsl-optimizer/

Unity3D Shader Lab:

http://unity3d.com/support/documentation/Manual/ShaderTut1.html

Example shader tutorials and source code:

http://unity3d.com/support/documentation/Manual/ShaderTut2.html

http://unity3d.com/support/documentation/Components/SL-SurfaceShaderExamples.html

Source Code for all built-in Unity Shaders:

http://unity3d.com/support/resources/assets/built-in-shaders.html

http://www.youtube.com/watch?v=37pc-eif24g

Unity Built-in Shaders:

http://unity3d.com/support/documentation/Components/Built-in%20Shader%20Guide.html

Unity Shader Performance:

http://unity3d.com/support/documentation/Components/shader-Performance.html