Blitz3D Advanced: Introduction to the world of CG and OpenGL via GLDirect. by Drago (Adam Templeton)

DISCLAMERS

I assume you have some knowledge of OpenGL, with the Tutorial, which is why it Is in the Advanced 3D section since it is a Complexe topic.
I say again THIS IS NOT FOR THE FAINT HEARTED. I assume you know how openGL works.

Vertex and Pixel Shaders are not magic boxes that you can drop into your program to get cool looking water and what not,
they require the program and them to be programmed together.
since for cool looking water you might need to pass a sine wave etc.

Introduction

Welcome to my introduction to the World of Using CG with a GL compatable version of Blitz.
At the moment the only OpenGL Library in the public arena is Peter Scheutz's GLDirect
to use CG with this extension Download my CG expansion for Blitz.
which you just unpack into the Directory, you have GLdirect in, and copy over the userlibs.

So What is CG?

CG is Nvidia's Compiler to make creating Vertex and Pixel Shaders, alot easier.
CG Stands for C for Graphics, and it is a C like language for the Programming of Vertex and Pixel Shaders.
When you tell CG to load in a Shader, it Converts it to the ASM language that is used by Shaders.
CG makes sure that it uses the correct GL Extension for Your Video card, so it works on Both ATI, and Nvidia Cards.

Getting Started with CG and Blitz

Using CG in Blitz is almost 100% indentical as using it with OpenGL via C++, since I use the same names for calling the Dll as C/C++ does
This makes it useful if one day you start using C++ with openGL.
Anyway lets get started. The first thing you want to do is include the CG.bb file that is in the GL directory of GLDirect. all code assumes that you have all the GL includes in a subdirectory of you Program.

Also needed are some vars that will hold the information that you want to send and receive from the Shader, also requried is a Varable to hold a reference to the program itself

Here is some Background for those varables... A Model view Matrix holds the current world location of the model that is about to be drawn to the screen. The Projection matrix holds info about the screen, and its aspect ratio.

Loading A CG program to be used

I normally do all the initilisation for my GL programs in a function Called GLInit, so at the end of this function So here I will Explain all the Steps for loading a CG program to be able to be used in GL.

As stated in the code, this checks what your videocard will let you do with shaders, then chooses the best one that CG is able to use.

Next we get the parameters from the CG program and let blitz know how to reference them, this is so values can be passed between CG and Blitz.

Drawing a Scene

Now that the Vertex Shader is all loaded and ready to go, we can use it to take over the Vertex Transformations, yes, that is the purpose of a Vertex Shader, instead of the card handleing them normally you use the Vertex Shader, or as they are properly called in OpenGL Vertex Programs, since they Program Vertex's , to take control of them.

cgGLBindProgram(vProgram); This Binds ie: tells OpenGL to use this program for all operations untill a different program is bounded.
	cgGLEnableProfile(Profile); This Enables the Shader to be used, via the extension setup earlier.
	cgGLSetParameter4f(Light, 0.0, 0.0, 1.0, 1.0)
; This passes the value that the varible Light uses in the Shader.
; The following line tells CG to get the Current ModelView Matrix and THe Projection matrix concatenated together, and the transpose matrix is the identity matrix, so it isn't transposed.
    cgGLSetStateMatrixParameter(ModelViewProj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY)
; This line gets the current modelview matrix which is transposed by the inverese Transpose matrix to have the inverse of the model view matrix sent to the parameter ModelViewIT in the Vertex Program.
    cgGLSetStateMatrixParameter(ModelViewIT, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE);
	 glPushMatrix()
	glBegin(GL_QUADS)
        .... Some funky Cube Stuff here :)
	glEnd()
	glPopMatrix()	
	; Turns off the vertex Shader.
	cgGLDisableProfile(Profile)

An Example of a CG Program

Here is the progam that is used with the Article It looks like C code becasue C for Graphics is C :)

// define inputs from application
struct appin
{
    float4 Position     : POSITION;
    float4 Normal       : NORMAL;
};

// define outputs from vertex shader
struct vertout
{
    float4 HPosition    : POSITION;
    float4 Color0       : COLOR0;
};

vertout main(appin IN, 
             uniform float4x4 ModelViewProj,
             uniform float4x4 ModelViewIT,
             uniform float4 LightVec)
{
    vertout OUT;

// transform vertex position into homogenous clip-space
    OUT.HPosition = mul(ModelViewProj, IN.Position);

// transform normal from model-space to view-space
    float3 normalVec = normalize(mul(ModelViewIT, IN.Normal).xyz);

// store normalized light vector
    float3 lightVec = normalize(LightVec.xyz);

// calculate half angle vector     
    float3 eyeVec = float3(0.0, 0.0, 1.0);
    float3 halfVec = normalize(lightVec + eyeVec);
    
    // calculate diffuse component
    float diffuse = dot(normalVec, lightVec);

// calculate specular component
    float specular = dot(normalVec, halfVec);
    
    // The lit() function is a handy function in the standard library that 
    // can be used to accelerate your lighting calculations. 
    //
    // This function return a vector containing these values:
    //     result.x = 1.0;  
    //     result.y = max(diffuse, 0);
    //     result.z = if (result.y > 0.0) then pow(specular, 32) else 0.0
    //     result.w = 1.0;

// Use the lit function to compute lighting vector from diffuse and 
    // specular values
    float4 lighting = lit(diffuse, specular, 32);

// blue diffuse material
    float3 diffuseMaterial = float3(0.0, 0.0, 1.0);

// white specular material
    float3 specularMaterial = float3(1.0, 1.0, 1.0);

// combine diffuse and specular contributions and output final vertex color
    OUT.Color0.rgb = lighting.y * diffuseMaterial + lighting.z * specularMaterial;
    OUT.Color0.a = 1.0;

return OUT;
}

I will Explain more about CG in another Article. here is that source as vertex Shader Assemberly. This will get all you old school programers excited... well maybe not, but hey it is Assemberly :)

!!ARBvp1.0
# ARB_vertex_program generated by NVIDIA Cg compiler
# cgc version 1.1.0003, build date Mar  4 2003  12:32:10
# command line args: -profile arbvp1
# nv30vp backend compiling 'main' program
PARAM c9 = { 0, 0, 1, 0 };
PARAM c10 = { 32, 0, 0, 0 };
#vendor NVIDIA Corporation
#version 1.0.02
#profile arbvp1
#program main
#semantic main.ModelViewProj
#semantic main.ModelViewIT
#semantic main.LightVec
#var float4 IN.Position : $vin.POSITION : POSITION : 0 : 1
#var float4 IN.Normal : $vin.NORMAL : NORMAL : 0 : 1
#var float4x4 ModelViewProj :  : c[0], 4 : 1 : 1
#var float4x4 ModelViewIT :  : c[4], 4 : 2 : 1
#var float4 LightVec :  : c[8] : 3 : 1
#var float4 HPosition : $vout.POSITION : POSITION : -1 : 1
#var float4 Color0 : $vout.COLOR0 : COLOR0 : -1 : 1
TEMP R0, R1, R2;
ATTRIB v18 = vertex.normal;
ATTRIB v16 = vertex.position;
PARAM c8 = program.local[8];
PARAM c4[4] = { program.local[4..7] };
PARAM c0[4] = { program.local[0..3] };
	DP4 result.position.x, c0[0], v16;
	DP4 result.position.y, c0[1], v16;
	DP4 result.position.z, c0[2], v16;
	DP4 result.position.w, c0[3], v16;
	DP4 R0.y, c4[0], v18;
	DP4 R0.z, c4[1], v18;
	DP4 R0.w, c4[2], v18;
	DP3 R0.x, R0.yzwy, R0.yzwy;
	RSQ R0.x, R0.x;
	MUL R2.xyz, R0.x, R0.yzwy;
	DP3 R0.x, c8.xyzx, c8.xyzx;
	RSQ R0.x, R0.x;
	MUL R0.xyz, R0.x, c8.xyzx;
	DP3 R1.x, R2.xyzx, R0.xyzx;
	ADD R0.yzw, R0.xxyz, c9.xxxz;
	DP3 R0.x, R0.yzwy, R0.yzwy;
	RSQ R0.x, R0.x;
	MUL R0.xyz, R0.x, R0.yzwy;
	DP3 R1.y, R2.xyzx, R0.xyzx;
	MOV R1.zw, c10.x;
	LIT R0.yz, R1;
	MAD result.color.front.primary.xyz, R0.y, c9.xxzx, R0.z;
	MOV result.color.front.primary.w, c9.zxxz;
END
# 24 instructions
# 3 temp registers
# End of program

Conclusion

There you go, this is my quick attempt to explain the example program that I used for CG I will be doing 2 more articles one for All CG commands in blitz, and One to explain the CG language itself... As well as probably makeing this article a bit better... ;)
For a printable copy of this article, please click HERE.

This site is Copyright© 2000-2004, BlitzCoder. All rights reserved.