PDA

View Full Version : Invert Maxtrix ??



DarkShadow44
01-11-2010, 12:38 PM
Hi, it's me again :o

Could you tell me, how to invert a 4x4 matrix ?
I dind't find a method that I could use for OpenGL.

shader:

uniform mat4 g_ViewProjectionInverseMatrix;
uniform mat4 g_previousViewProjectionMatrix;

Main Programm:

GLfloat MATRIX[16];
glGetFloatv( GL_PROJECTION_MATRIX, MATRIX );
int matrix=glGetUniformLocation(my_program, "g_ViewProjectionInverseMatrix");
int matrixPre=glGetUniformLocation(my_program, "g_previousViewProjectionMatrix");

glUniformMatrix4fvARB(matrix,1,true,MATRIX);
glUniformMatrix4fvARB(matrixPre,1,true,MATRIXPRE);

And should I use "transpose" ?

I think my screen is only white because of the wrong (not inverted) matrices... :eek:

Dark Photon
01-11-2010, 05:53 PM
Could you tell me, how to invert a 4x4 matrix ? I dind't find a method that I could use for OpenGL.
GLSL added inverse() in 1.40. No idea what the cost is -- never used it. Short of that, probably better to grab an existing CPU math library (google opengl math library) or roll your own.



glUniformMatrix4fvARB(matrix,1,true,MATRIX);
And should I use "transpose" ?
I assume you mean the "transpose" argument to glUniformMatrix4fv. If you mean as a substitute for the inverse, then you need to know that the inverse does not always equal the transpose. It can, but only for orthonormal matrices (e.g. rotation matrices). However, parallel and perspective projection transforms are generally not orthonormal.

That said, the OpenGL red book has closed-form definitions for the parallel and perspective projection transforms in the appendices -- I'd just use them and save yourself the trouble. For instance: here (http://fly.cc.fer.hr/~unreal/theredbook/appendixg.html).

Pierre Boudier
01-12-2010, 08:09 AM
added inverse() in 1.40. No idea what the cost is -- never used it.

if the matrix is the same for all vertices, it seems better to upload the inverse as a uniform instead of recomputing the inverse for each vertex. (regardless of the speed of .inverse in GLSL)

DarkShadow44
01-12-2010, 11:00 AM
The compiler doesn't find .inverse, but that doesn't matter.
Now that is my motion-blur shader:


#version 140
uniform sampler2DRect depthTexture;
uniform sampler2DRect colorTexture;
const int g_width=640;
const int g_height=480;
//uniform mat4 g_ViewProjectionInverseMatrix;
////uniform mat4 g_previousViewProjectionMatrix;
mat4 g_ViewProjectionInverseMatrix;
//mat4 g_previousViewProjectionMatrix;

out vec4 gl_FragColor;
void main()
{
vec2 texCoord;
float zOverW;
vec4 tmp1;
vec4 tmp2;
vec4 H;
vec4 worldPos;
vec4 previousPos;
vec2 velocity;
vec4 color;
int i;



g_ViewProjectionInverseMatrix=gl_ProjectionMatrixI nverse;
mat4 g_previousViewProjectionMatrix=gl_ProjectionMatrix ;
//g_previousViewProjectionMatrix=

// Shader Code That Extracts the Per-Pixel World-Space Positions of the Objects That Were Rendered to the Depth Buffer
// Get the depth buffer value at this pixel.
zOverW = texture2DRect(depthTexture, gl_FragCoord.xy).x;

// H is the viewport position at this pixel in the range -1 to 1.
H = vec4((gl_FragCoord.x/float(g_width))*2.0 - 1.0, (1.0 - (gl_FragCoord.y/float(g_height)))*2.0 - 1.0, zOverW, 1.0);

// Transform by the view-projection inverse.
tmp1 = H * g_ViewProjectionInverseMatrix;
// Divide by w to get world position.
worldPos = tmp1/tmp1.w;

// Shader Code That Computes the Per-Pixel Velocity Vectors That Determine the Direction to Blur the Image
// Use the world position, and transform by the previous view-projection matrix.
tmp2 = worldPos * g_previousViewProjectionMatrix;
// Convert to nonhomogenous points [-1,1] by dividing by w.
previousPos = tmp2/tmp2.w;

// Use this frame's position and last frame's to compute the pixel velocity.
velocity = ((H - previousPos)/2.0).xy;
velocity.x *= float(g_width);
velocity.y *= float(g_height);

// Shader Code That Uses the Velocity Vector at the Current Pixel to Sample the Color Buffer Multiple Times to Achieve the Motion Blur Effect
// Get the initial color at this pixel.
color = texture2DRect(colorTexture, gl_FragCoord.xy);

texCoord = gl_FragCoord.xy + velocity;
// i had to unroll because my glsl driver doesn't even like loops!
color += texture2DRect(colorTexture, texCoord);
texCoord += velocity;
color += texture2DRect(colorTexture, texCoord);

// Average all of the samples to get the final blur color.
gl_FragColor = color/3.0;
gl_FragDepth = zOverW;
}



Her is the whole code (from the NEHE sample :)).
I use "my_program" with the shader on top; the uniforms are not used here (except textures).
Do you see any significant errors ?

/**************************************
* *
* Jeff Molofee's Basecode Example *
* nehe.gamedev.net *
* 2001 *
* *
* All Code / Tutorial Commenting *
* by Jeff Molofee ( NeHe ) *
* *
**************************************/

bool use=true;

#include <windows.h> // Header File For Windows
#include <gl/glew.h>
#include <gl\gl.h> // Header File For The OpenGL32 Library
#include <gl\glu.h> // Header File For The GLu32 Library
#include <gl\glaux.h> // Header File For The GLaux Library
#include "NeHeGL.h" // Header File For NeHeGL
#include <math.h> // We'll Need Some Math
#include <stdio.h>

#pragma comment( lib, "opengl32.lib" ) // Search For OpenGL32.lib While Linking
#pragma comment( lib, "glu32.lib" ) // Search For GLu32.lib While Linking
#pragma comment( lib, "glaux.lib" ) // Search For GLaux.lib While Linking
#pragma comment(lib,"glew32.lib")

#ifndef CDS_FULLSCREEN // CDS_FULLSCREEN Is Not Defined By Some
#define CDS_FULLSCREEN 4 // Compilers. By Defining It This Way,
#endif // We Can Avoid Errors

GL_Window* g_window;
Keys* g_keys;

// User Defined Variables
float vertexes[4][3]; // Holds Float Info For 4 Sets Of Vertices
float normal[3]; // An Array To Store The Normal Data
GLuint BlurTexture; // An Unsigned Int To Store The Texture Number
GLuint DepthTexture;
GLhandleARB ProgramObject;
GLhandleARB VertexShaderObject;
GLhandleARB FragmentShaderObject;


void CheckError(GLhandleARB glObject) ;
GLhandleARB my_program;
GLhandleARB my_program_pre;

int LoadShaderv(const char* name,GLhandleARB program);
int LoadShaderf(const char* name,GLhandleARB program);


GLuint EmptyTexture() // Create An Empty Texture
{
GLuint txtnumber; // Texture ID
unsigned int* data; // Stored Data

// Create Storage Space For Texture Data (128x128x4)
data = (unsigned int*)new GLuint[((640 * 480)* 4 * sizeof(unsigned int))];
ZeroMemory(data,((640 * 480)* 4 * sizeof(unsigned int))); // Clear Storage Memory

glGenTextures(1, &amp;txtnumber); // Create 1 Texture
glBindTexture(GL_SAMPLER_2D_RECT_ARB, txtnumber); // Bind The Texture
glTexImage2D(GL_SAMPLER_2D_RECT_ARB, 0, 4, 640, 480, 0,
GL_RGBA, GL_UNSIGNED_BYTE, data); // Build Texture Using Information In data
glTexParameteri(GL_SAMPLER_2D_RECT_ARB,GL_TEXTURE_ MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_SAMPLER_2D_RECT_ARB,GL_TEXTURE_ MAG_FILTER,GL_LINEAR);

delete [] data; // Release data

return txtnumber; // Return The Texture ID
}

void ReduceToUnit(float vector[3]) // Reduces A Normal Vector (3 Coordinates)
{ // To A Unit Normal Vector With A Length Of One.
float length; // Holds Unit Length
// Calculates The Length Of The Vector
length = (float)sqrt((vector[0]*vector[0]) + (vector[1]*vector[1]) + (vector[2]*vector[2]));

if(length == 0.0f) // Prevents Divide By 0 Error By Providing
length = 1.0f; // An Acceptable Value For Vectors To Close To 0.

vector[0] /= length; // Dividing Each Element By
vector[1] /= length; // The Length Results In A
vector[2] /= length; // Unit Normal Vector.
}

void calcNormal(float v[3][3], float out[3]) // Calculates Normal For A Quad Using 3 Points
{
float v1[3],v2[3]; // Vector 1 (x,y,z) & Vector 2 (x,y,z)
static const int x = 0; // Define X Coord
static const int y = 1; // Define Y Coord
static const int z = 2; // Define Z Coord

// Finds The Vector Between 2 Points By Subtracting
// The x,y,z Coordinates From One Point To Another.

// Calculate The Vector From Point 1 To Point 0
v1[x] = v[0][x] - v[1][x]; // Vector 1.x=Vertex[0].x-Vertex[1].x
v1[y] = v[0][y] - v[1][y]; // Vector 1.y=Vertex[0].y-Vertex[1].y
v1[z] = v[0][z] - v[1][z]; // Vector 1.z=Vertex[0].y-Vertex[1].z
// Calculate The Vector From Point 2 To Point 1
v2[x] = v[1][x] - v[2][x]; // Vector 2.x=Vertex[0].x-Vertex[1].x
v2[y] = v[1][y] - v[2][y]; // Vector 2.y=Vertex[0].y-Vertex[1].y
v2[z] = v[1][z] - v[2][z]; // Vector 2.z=Vertex[0].z-Vertex[1].z
// Compute The Cross Product To Give Us A Surface Normal
out[x] = v1[y]*v2[z] - v1[z]*v2[y]; // Cross Product For Y - Z
out[y] = v1[z]*v2[x] - v1[x]*v2[z]; // Cross Product For X - Z
out[z] = v1[x]*v2[y] - v1[y]*v2[x]; // Cross Product For X - Y

ReduceToUnit(out); // Normalize The Vectors
}

float right=0,up=0,zzz=0,angle=0;

void ProcessHelix() // Draws A Helix
{
GLfloat x; // Helix x Coordinate
GLfloat y; // Helix y Coordinate
GLfloat z; // Helix z Coordinate
GLfloat phi; // Angle
GLfloat theta; // Angle
GLfloat v,u; // Angles
GLfloat r; // Radius Of Twist
int twists = 5; // 5 Twists

//GLfloat glfMaterialColor[]={0.4f,0.2f,0.8f,1.0f}; // Set The Material Color
//GLfloat specular[]={1.0f,1.0f,1.0f,1.0f}; // Sets Up Specular Lighting

glLoadIdentity(); // Reset The Modelview Matrix
gluLookAt(0, 5, 50, 0, 0, 0, 0, 1, 0); // Eye Position (0,5,50) Center Of Scene (0,0,0), Up On Y Axis

glPushMatrix(); // Push The Modelview Matrix

glTranslatef(right,angle,-50); // Translate 50 Units Into The Screen
glRotatef(up/2.0f,1,0,0); // Rotate By angle/2 On The X-Axis
glRotatef(zzz/3.0f,0,1,0); // Rotate By angle/3 On The Y-Axis

// glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFF USE,glfMaterialColor);
// glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,specula r);

r=1.5f; // Radius

glBegin(GL_QUADS); // Begin Drawing Quads
for(phi=0; phi <= 360; phi+=20.0) // 360 Degrees In Steps Of 20
{
for(theta=0; theta<=360*twists; theta+=20.0) // 360 Degrees * Number Of Twists In Steps Of 20
{
v=(phi/180.0f*3.142f); // Calculate Angle Of First Point ( 0 )
u=(theta/180.0f*3.142f); // Calculate Angle Of First Point ( 0 )

x=float(cos(u)*(2.0f+cos(v) ))*r; // Calculate x Position (1st Point)
y=float(sin(u)*(2.0f+cos(v) ))*r; // Calculate y Position (1st Point)
z=float((( u-(2.0f*3.142f)) + sin(v) ) * r); // Calculate z Position (1st Point)

vertexes[0][0]=x; // Set x Value Of First Vertex
vertexes[0][1]=y; // Set y Value Of First Vertex
vertexes[0][2]=z; // Set z Value Of First Vertex

v=(phi/180.0f*3.142f); // Calculate Angle Of Second Point ( 0 )
u=((theta+20)/180.0f*3.142f); // Calculate Angle Of Second Point ( 20 )

x=float(cos(u)*(2.0f+cos(v) ))*r; // Calculate x Position (2nd Point)
y=float(sin(u)*(2.0f+cos(v) ))*r; // Calculate y Position (2nd Point)
z=float((( u-(2.0f*3.142f)) + sin(v) ) * r); // Calculate z Position (2nd Point)

vertexes[1][0]=x; // Set x Value Of Second Vertex
vertexes[1][1]=y; // Set y Value Of Second Vertex
vertexes[1][2]=z; // Set z Value Of Second Vertex

v=((phi+20)/180.0f*3.142f); // Calculate Angle Of Third Point ( 20 )
u=((theta+20)/180.0f*3.142f); // Calculate Angle Of Third Point ( 20 )

x=float(cos(u)*(2.0f+cos(v) ))*r; // Calculate x Position (3rd Point)
y=float(sin(u)*(2.0f+cos(v) ))*r; // Calculate y Position (3rd Point)
z=float((( u-(2.0f*3.142f)) + sin(v) ) * r); // Calculate z Position (3rd Point)

vertexes[2][0]=x; // Set x Value Of Third Vertex
vertexes[2][1]=y; // Set y Value Of Third Vertex
vertexes[2][2]=z; // Set z Value Of Third Vertex

v=((phi+20)/180.0f*3.142f); // Calculate Angle Of Fourth Point ( 20 )
u=((theta)/180.0f*3.142f); // Calculate Angle Of Fourth Point ( 0 )

x=float(cos(u)*(2.0f+cos(v) ))*r; // Calculate x Position (4th Point)
y=float(sin(u)*(2.0f+cos(v) ))*r; // Calculate y Position (4th Point)
z=float((( u-(2.0f*3.142f)) + sin(v) ) * r); // Calculate z Position (4th Point)

vertexes[3][0]=x; // Set x Value Of Fourth Vertex
vertexes[3][1]=y; // Set y Value Of Fourth Vertex
vertexes[3][2]=z; // Set z Value Of Fourth Vertex

calcNormal(vertexes,normal); // Calculate The Quad Normal

glNormal3f(normal[0],normal[1],normal[2]); // Set The Normal

glColor3f(1,0,1);
// Render The Quad
glVertex3f(vertexes[0][0],vertexes[0][1],vertexes[0][2]);
glVertex3f(vertexes[1][0],vertexes[1][1],vertexes[1][2]);
glVertex3f(vertexes[2][0],vertexes[2][1],vertexes[2][2]);
glVertex3f(vertexes[3][0],vertexes[3][1],vertexes[3][2]);
}
}
glEnd(); // Done Rendering Quads

glPopMatrix(); // Pop The Matrix
}

void ViewOrtho() // Set Up An Ortho View
{
glMatrixMode(GL_PROJECTION); // Select Projection
glPushMatrix(); // Push The Matrix
glLoadIdentity(); // Reset The Matrix
glOrtho( 0, 640 , 480 , 0, -1, 1 ); // Select Ortho Mode (640x480)
glMatrixMode(GL_MODELVIEW); // Select Modelview Matrix
glPushMatrix(); // Push The Matrix
glLoadIdentity(); // Reset The Matrix
}

void ViewPerspective() // Set Up A Perspective View
{
glMatrixMode( GL_PROJECTION ); // Select Projection
glPopMatrix(); // Pop The Matrix
glMatrixMode( GL_MODELVIEW ); // Select Modelview
glPopMatrix(); // Pop The Matrix
}



void DrawBlur(int times, float inc) // Draw The Blurred Image
{ // Starting Alpha Value

// Disable AutoTexture Coordinates
// glDisable(GL_TEXTURE_GEN_S);
// glDisable(GL_TEXTURE_GEN_T);
//glDisable(GL_TEXTURE_GEN_R);
//glDisable(GL_TEXTURE_GEN_Q);
//glEnable(GL_SAMPLER_2D_RECT_ARB); // Enable 2D Texture Mapping
//glDisable(GL_DEPTH_TEST); // Disable Depth Testing
//glBlendFunc(GL_SRC_ALPHA,GL_ONE); // Set Blending Mode
//glEnable(GL_BLEND); // Enable Blending

glActiveTexture(GL_TEXTURE0);
glEnable(GL_SAMPLER_2D_RECT_ARB);
glBindTexture(GL_SAMPLER_2D_RECT_ARB,DepthTexture) ; // Bind To The Blur Texture

glActiveTexture(GL_TEXTURE1);
glEnable(GL_SAMPLER_2D_RECT_ARB);
glBindTexture(GL_SAMPLER_2D_RECT_ARB,BlurTexture); // Bind To The Blur Texture

ViewOrtho(); // Switch To An Ortho View

//glTranslatef(right,-up,z);
//alphainc = alpha / times; // alphainc=0.2f / Times To Render Blur

glBegin(GL_QUADS); // Begin Drawing Quads
glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0,1);
glMultiTexCoord2fARB(GL_TEXTURE1_ARB,0,1);
glVertex2f(0,0); // First Vertex ( 0, 0 )

glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0,0);
glMultiTexCoord2fARB(GL_TEXTURE1_ARB,0,0);
glVertex2f(0,480-1); // Second Vertex ( 0, 480 )

glMultiTexCoord2fARB(GL_TEXTURE0_ARB,1,0);
glMultiTexCoord2fARB(GL_TEXTURE1_ARB,1,0);
glVertex2f(640-1,480-1); // Third Vertex ( 640, 480 )

glMultiTexCoord2fARB(GL_TEXTURE0_ARB,1,1);
glMultiTexCoord2fARB(GL_TEXTURE1_ARB,1,1);
glVertex2f(640-1,0); // Fourth Vertex ( 640, 0 )

//spost += inc; // Gradually Increase spost (Zooming Closer To Texture Center)
//alpha = alpha - alphainc; // Gradually Decrease alpha (Gradually Fading Image Out)
glEnd(); // Done Drawing Quads

ViewPerspective(); // Switch To A Perspective View
glActiveTexture(GL_TEXTURE0);
glEnable(GL_SAMPLER_2D_RECT_ARB);
glBindTexture(GL_SAMPLER_2D_RECT_ARB,0); // Bind To The Blur Texture

glActiveTexture(GL_TEXTURE1);
glEnable(GL_SAMPLER_2D_RECT_ARB);
glBindTexture(GL_SAMPLER_2D_RECT_ARB,0); // Bind To The Blur Texture
glEnable(GL_DEPTH_TEST); // Enable Depth Testing

}

float bblur=0;

BOOL Initialize (GL_Window* window, Keys* keys) // Any GL Init Code & User Initialiazation Goes Here
{
g_window = window;
g_keys = keys;

// Start Of User Initialization
angle = 0.0f; // Set Starting Angle To Zero

BlurTexture = EmptyTexture(); // Create Our Empty Texture
DepthTexture = EmptyTexture(); // Create Our Empty Texture
glViewport(0 , 0,window->init.width ,window->init.height); // Set Up A Viewport
glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
glLoadIdentity(); // Reset The Projection Matrix
gluPerspective(50, (float)window->init.width/(float)window->init.height, 5, 2000); // Set Our Perspective
glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
glLoadIdentity(); // Reset The Modelview Matrix

glEnable(GL_DEPTH_TEST); // Enable Depth Testing

//GLfloat global_ambient[4]={0.2f, 0.2f, 0.2f, 1.0f}; // Set Ambient Lighting To Fairly Dark (No Color)
//GLfloat light0pos[4]= {0.0f, 5.0f, 10.0f, 1.0f}; // Set The Light Position
//GLfloat light0ambient[4]= {0.2f, 0.2f, 0.2f, 1.0f}; // More Ambient Light
//GLfloat light0diffuse[4]= {0.3f, 0.3f, 0.3f, 1.0f}; // Set The Diffuse Light A Bit Brighter
//GLfloat light0specular[4]={0.8f, 0.8f, 0.8f, 1.0f}; // Fairly Bright Specular Lighting

//GLfloat lmodel_ambient[]= {0.2f,0.2f,0.2f,1.0f}; // And More Ambient Light
//glLightModelfv(GL_LIGHT_MODEL_AMBIENT,lmodel_ambie nt); // Set The Ambient Light Model

//glLightModelfv(GL_LIGHT_MODEL_AMBIENT, global_ambient); // Set The Global Ambient Light Model
//glLightfv(GL_LIGHT0, GL_POSITION, light0pos); // Set The Lights Position
//glLightfv(GL_LIGHT0, GL_AMBIENT, light0ambient); // Set The Ambient Light
//glLightfv(GL_LIGHT0, GL_DIFFUSE, light0diffuse); // Set The Diffuse Light
//glLightfv(GL_LIGHT0, GL_SPECULAR, light0specular); // Set Up Specular Lighting
//glEnable(GL_LIGHTING); // Enable Lighting
//glEnable(GL_LIGHT0); // Enable Light0

glShadeModel(GL_SMOOTH); // Select Smooth Shading

glMateriali(GL_FRONT, GL_SHININESS, 128);
glClearColor(0.0f, 0.0f, 0.0f, 0.5); // Set The Clear Color To Black


GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
//fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
}
//fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));

// Create Shader And Program Objects
my_program = glCreateProgramObjectARB();
my_program_pre = glCreateProgramObjectARB();
// VertexShaderObject = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
//FragmentShaderObject = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);

//LoadShader("geo_shdr.s",GL_GEOMETRY_SHADER_EXT);

int ShaderVertex=LoadShaderv("vert_shdr.s",my_program);
int ShaderFragment=LoadShaderf("frag_shdr.s",my_program);
int ShaderVertex_pre=LoadShaderv("vert_shdr.s",my_program_pre);
int ShaderFragment_pre=LoadShaderf("frag.s",my_program_pre);



// Link The Program Object
glLinkProgramARB(my_program);
CheckError(my_program);

// Link The Program Object
glLinkProgramARB(my_program_pre);
CheckError(my_program_pre);

//int uColor , uDepth;
//uColor = glGetUniformLocationARB(s2,"tex1");
//uDepth = glGetUniformLocationARB(s2,"tex2");


int u1=glGetUniformLocation(my_program, "Texture");
int u2=glGetUniformLocation(my_program, "uTexture");
int uShift=glGetUniformLocation(my_program, "uShift");

int uradial_size=glGetUniformLocation(my_program,"radial_size");


int uradial_bright=glGetUniformLocation(my_program,"radial_bright");

int uradial_origin=glGetUniformLocation(my_program,"radial_origin");

glUniform1i( u1, 0);
glUniform1i( u2, 0);

glUniform2f(uShift,1.0/640, 0.0);

glUniform2f(uradial_size,0,0);

glUniform1f(uradial_bright,1.0f);
glUniform2f(uradial_origin,0.5f,0.5f);



return TRUE; // Return TRUE (Initialization Successful)
}

void Deinitialize (void) // Any User DeInitialization Goes Here
{
glDeleteTextures(1,&amp;BlurTexture); // Delete The Blur Texture
glDeleteTextures(1,&amp;DepthTexture); // Delete The Blur Texture
}



void RenderToTexture() // Renders To A Texture
{
glViewport(0,0,640,480); // Set Our Viewport (Match Texture Size)

ProcessHelix(); // Render The Helix

glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_SAMPLER_2D_RECT_ARB,BlurTexture); // Bind To The Blur Texture

// Copy Our ViewPort To The Blur Texture (From 0,0 To 128,128... No Border)
glCopyTexImage2D(GL_SAMPLER_2D_RECT_ARB, 0, GL_RGBA, 0, 0, 640, 480, 0);

glClearColor(0.0f, 0.0f, 0.5f, 0.5); // Set The Clear Color To Medium Blue
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And Depth Buffer

glViewport(0 , 0,640 ,480); // Set Viewport (0,0 to 640x480)
}
void RenderToDepthTexture() // Renders To A Texture
{
glViewport(0,0,640,480); // Set Our Viewport (Match Texture Size)

ProcessHelix(); // Render The Helix

glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_SAMPLER_2D_RECT_ARB,DepthTexture) ; // Bind To The Blur Texture

// Copy Our ViewPort To The Blur Texture (From 0,0 To 128,128... No Border)
glCopyTexImage2D(GL_SAMPLER_2D_RECT_ARB, 0, GL_DEPTH_COMPONENT, 0, 0, 640, 480, 0);

glClearColor(0.0f, 0.0f, 0.5f, 0.5); // Set The Clear Color To Medium Blue
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And Depth Buffer

glViewport(0 , 0,640 ,480); // Set Viewport (0,0 to 640x480)
}



bool _uuse_radialblur=false;
bool _uuse_blur=false;

int _uradialblur_times=12;

GLfloat MATRIXPRE[16];

void Update (DWORD milliseconds) // Perform Motion Updates Here
{
if (g_keys->keyDown [VK_ESCAPE] == TRUE) // Is ESC Being Pressed?
{
TerminateApplication (g_window); // Terminate The Program
}

if (g_keys->keyDown [VK_F1] == TRUE) // Is F1 Being Pressed?
{
ToggleFullscreen (g_window); // Toggle Fullscreen Mode
}

if (g_keys->keyDown [VK_RIGHT] == TRUE) // Is F1 Being Pressed?
{
right+=5;
}

if (g_keys->keyDown [VK_LEFT] == TRUE) // Is F1 Being Pressed?
{
right-=5;
}

if (g_keys->keyDown [VK_UP] == TRUE) // Is F1 Being Pressed?
{
up+=5;
}

if (g_keys->keyDown [VK_DOWN] == TRUE) // Is F1 Being Pressed?
{
up-=5;
}

if (g_keys->keyDown [VK_PRIOR] == TRUE) // Is F1 Being Pressed?
{
zzz-=5;
}

if (g_keys->keyDown [VK_NEXT] == TRUE) // Is F1 Being Pressed?
{
zzz+=5;
}

if (g_keys->keyDown [VK_ADD] == TRUE) // Is F1 Being Pressed?
{
bblur+=0.005f;
}

if (g_keys->keyDown [VK_SUBTRACT] == TRUE) // Is F1 Being Pressed?
{
bblur-=0.005f;
}

if (g_keys->keyDown ['W'] == TRUE) // Is F1 Being Pressed?
{
angle++;
}

if (g_keys->keyDown ['S'] == TRUE) // Is F1 Being Pressed?
{
angle--;
}

if(g_keys->keyDown ['1'] == TRUE)
{
_uuse_blur=!_uuse_blur;
g_keys->keyDown ['1'] = FALSE;
}
if(g_keys->keyDown ['2'] == TRUE)
{
_uuse_radialblur=!_uuse_radialblur;
g_keys->keyDown ['2'] = FALSE;
}

if(g_keys->keyDown ['O'] == TRUE)
{
_uradialblur_times--;
g_keys->keyDown ['O'] = FALSE;
}

if(g_keys->keyDown ['P'] == TRUE)
{
_uradialblur_times++;
g_keys->keyDown ['P'] = FALSE;
}
GLfloat MATRIX[16];
glGetFloatv( GL_PROJECTION_MATRIX, MATRIX );
int matrix=glGetUniformLocation(my_program, "g_ViewProjectionInverseMatrix");
int matrixPre=glGetUniformLocation(my_program, "g_previousViewProjectionMatrix");

glUniformMatrix4fvARB(matrix,1,true,MATRIX);
glUniformMatrix4fvARB(matrixPre,1,true,MATRIXPRE);

int hh=glGetUniformLocation(my_program, "g_width");
int ww=glGetUniformLocation(my_program, "g_height");

glUniform1i(hh,480);
glUniform1i(ww,640);


int i;
for(i=0;i<16;i++)
{
MATRIXPRE[i]=MATRIX[i];
}

//angle += (float)(milliseconds) / 5.0f; // Update angle Based On The Clock
}

void Draw (void) // Draw The Scene
{
glUseProgramObjectARB(NULL);

glClearColor(0.0f, 0.0f, 0.0f, 0); // Set The Clear Color To Black
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear Screen And Depth Buffer
glLoadIdentity(); // Reset The View

ProcessHelix(); // Draw Our Helix
//glUseProgramObjectARB(my_program_pre);
RenderToTexture();
RenderToDepthTexture(); // Render To A Texture (NICHT SHADER !!!)
glUseProgramObjectARB(my_program);
DrawBlur(25,0.02f); // Draw The Blur Effect


glFlush (); // Flush The GL Rendering Pipeline
}


char* data;

void readShader(FILE*file)
{
fseek(file, 0, SEEK_END);
int size=ftell(file);
//size=filelength(file);
data=(char*)malloc(size);

fseek(file,-size, SEEK_CUR); //zum Anfang zurück

fread(data,size,1,file);
data[size]='\0';
}

void CheckError(GLhandleARB glObject)
{
int blen,slen ;
char* InfoLog;

glGetObjectParameterivARB(glObject, GL_OBJECT_INFO_LOG_LENGTH_ARB , &amp;blen);
if (blen > 1)
{
InfoLog=(char*)malloc( blen*sizeof(GLhandleARB));
glGetInfoLogARB(glObject, blen, &amp;slen, InfoLog);
MessageBox(HWND_DESKTOP, InfoLog,NULL,NULL);
free(InfoLog);
}
}
int LoadShaderf(const char* name,GLhandleARB program)
{


FILE *file=fopen(name,"rb");

readShader(file);
char* shader_data2=data;

fclose(file);

GLhandleARB shader;

shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);



// Load Shader Sources
glShaderSourceARB(shader, 1, (const GLcharARB**)&amp;shader_data2, NULL);

// Compile The Shaders
glCompileShaderARB(shader);
CheckError(shader);

// Attach The Shader Objects To The Program Object
glAttachObjectARB(program, shader);


return shader;
}

int LoadShaderv(const char* name,GLhandleARB program)
{


FILE *file=fopen(name,"rb");

readShader(file);
char* shader_data2=data;

fclose(file);

GLhandleARB shader;

shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);



// Load Shader Sources
glShaderSourceARB(shader, 1, (const GLcharARB**)&amp;shader_data2, NULL);

// Compile The Shaders
glCompileShaderARB(shader);
CheckError(shader);

// Attach The Shader Objects To The Program Object
glAttachObjectARB(program, shader);


return shader;
}

What did I wrong that it doesn't display anything ?
If I used the fixed pipeline (with GL_TEXTURE_2D instead of GL_SAMPLER_2D_RECT_ARB) it worked, but the shader needs "sampler2DRect")