OpenGL Discussion and Help Forums - OpenGL Shading Language

Shader Performance

tonyo_au — Sat, 18 May 2013 04:00:43 GMT

A short while ago there was a thread on measuring performance of different shader subroutines.
I have been having a look at nVidia NVPerfKit sdk. It appears to have counters that give the instruction rate by shader stage; ie vertex, tesselation, geometry and fragment.

I have not used this. Has anyone else looked at this data.

image2DArray :only first layer work

Fenado — Thu, 16 May 2013 14:32:41 GMT

I attempt to use the image load/store function.I need several images,and if they are indexed ,it's convienient for coding,so I want to use the image2DArray uniform.But it seems that only the first layer of the image2DArray works.In another word, the iimage2DArray perform like an iimage.

the fragment shader(only used by fs):

Code :

#version 420                                                                                                                                                    
coherent uniform layout(r32i) iimage2DArray sigmal;                                                                       
out vec4 FragColor;                                                                                                                                                 
void main()                                                                       
{                                                                               
    ivec2 coord = ivec2(gl_FragCoord.xy);
    int increment=100;
    int v=imageAtomicAdd(sigmal,ivec3(coord,**1**),increment);  //the promlem is that it seems 
                                                            //the coordinate z has no influence
    FragColor =vec4(coord/screenSize,v/1000.0f,1);
 
}

the c++ code: binding:

Code :

glGenTextures(1,&image);
glBindTexture(GL_TEXTURE_2D_ARRAY,image);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB,0);
//Allocate the storage.
glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_R32I, width, height, layerCount);
 
glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, width, height, layerCount, GL_RED_INTEGER, GL_INT, clearData);     //
 
glBindImageTexture(0, image, 0, GL_TRUE, 0, GL_READ_WRITE, GL_R32I);
 
//Always set reasonable texture parameters
glTexParameteri(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

render:

Code :

glBindTexture(GL_TEXTURE_2D_ARRAY,image);
shader.use();
shader.setUniform("sigmal",0);
glBindVertexArray(vao);
glDrawArrays(GL_TRIANGLES, 0, 6);
shader.unuse();
glMemoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT);
int *data=new int[viewport[2]*viewport[3]*layerCount];
glBindTexture(GL_TEXTURE_2D_ARRAY,image);
glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB,0);
glGetTexImage(GL_TEXTURE_2D_ARRAY, 0 , GL_RED_INTEGER, GL_INT,data );
printf("%d %d\n",data[0],data[viewport[2]*viewport[3]]);

The printf result is data[0] which I think is the first texel of the first layer increase frame by frame,whereas,data[viewport[2]*viewport[3]] which I think is the first texel of the second layer doesn't change.I think the reasonable result is opposite.

Double precision: Extensions for trigonometry and transcendental functions?

rahulgarg — Wed, 15 May 2013 23:28:59 GMT

The standard double precision extension only defines addition, multiplication, divison, square-root and a few clamping and comparison functions for double precision datatype. I was wondering if any vendor provides an extension that also provides trigonometry and transcendental functions for double precision?

Beginner: Implementing both colours and textures in fragment shader (for picking)

Quantumcat — Sun, 12 May 2013 01:34:05 GMT

Hi all, this is my first post.

I am learning about shaders in a very piecemeal fashion so don't be surprised if I seem to not understand really obvious things.

I have to implement picking in a program (for uni) with shaders with objects that are arrays of vertices and texture co-ordinates parsed from Collada files.

I started off trying to do ray picking but I just couldn't make it work. I then decided to try colour id picking because that's what I did in my previous graphics course which didn't introduce shaders.

I always wanted to draw some axes on the screen to help with debugging but never could, I didn't really understand what the shader we were given did at the time so I didn't worry about it. But now if I want to implement colour id picking I will have to be able to draw in colour and not in textures.

I've now learned a tiny bit about shaders and tried this in my fragment shader:

Code :

varying  vec2 vTexCoord; 
uniform sampler2D myTexture;
 
void main (void)  
{
	if(gl_Color.r <= 0.01 && gl_Color.g <= 0.01 && gl_Color.b <= 0.01)
	{
		gl_FragColor =  texture2D(myTexture, vTexCoord); 
	}
	else
	{
		gl_FragColor = gl_Color; 
	}
}

The shader used to just have gl_FragColor = texture2D(myTexture, vTexCoord); in the main ().

In my drawing part, if not in picking mode I enable textures and colour in black, and if in picking mode I disable textures and draw in the colour id of the object.

I may have mistakes in my drawing code, but I am sure that my shader code has mistakes because my matrix handles return -1. I can't seem to find any info on the net about testing what colour you have in the shader and doing different things based on the colour. So my shader code was just a blind guess as to what might work but I can't think of any other guesses to try.

Thanks heaps if anyone can help. And/or point me to some good shader tutorials.

Problem of environment mapping

LaLaChen — Wed, 08 May 2013 16:50:11 GMT

Hi, all.

I encounter a odd phenomenon when I make a environment mapping effect on a cube.

It is shown as follow :

Does some one encounter same situation as like as mine ?

(P.S I calculate the reflect vector in world matrix, I don't use the gl_NormalMatrix. My cube only have a translation, no rotation and scale.)

Attached Thumbnails

Shadow mapping with multiple shadows

xrwnis — Mon, 06 May 2013 17:17:50 GMT

I've implemented shadow mapping using ARB extensions following the tutorial on paulsprojects.net/tutorials/smt/smt.html I've modified the code to add another light source. I've created and initialized 2 more matrices (lightViewMatrix2 and lightProjectionMatrix2) and another shadowMap texture. At step 3 of the tutorial, after binding the first shadowmap texture, I've binded the second one. The result I get is that I see only the intersections between the 2 shadows produced by the 2 different light sources. I've initialized all the matrices in the init function as shown in the tutorial, this is my display function.

Code :

void Display(void){
//First pass - from light's point of view
//Calculate & save matrices LIGHT 1
glPushMatrix();
    glLoadIdentity();
    gluLookAt(  lightPosition[0], lightPosition[1], lightPosition[2],
                0.0f, 0.0f , 0.0f,
                0.0f, 1.0f, 0.0f);
    glGetFloatv(GL_MODELVIEW_MATRIX, lightViewMatrix);
glPopMatrix();
 
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(lightProjectionMatrix);
 
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(lightViewMatrix);
 
//Use viewport the same size as the shadow map
glViewport(0, 0, shadowMapSize, shadowMapSize);
 
//Draw back faces into the shadow map
glCullFace(GL_FRONT);
 
//Disable color writes, and use flat shading for speed
glShadeModel(GL_FLAT);
glColorMask(0, 0, 0, 0);
 
//Draw the scene
DrawScene();
 
//Read the depth buffer into the shadow map texture
glBindTexture(GL_TEXTURE_2D, shadowMapTexture[0]);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, shadowMapSize, shadowMapSize);
 
 
//First pass - from light's point of view
//Calculate & save matrices LIGHT 2
glPushMatrix();
    glLoadIdentity();
    gluLookAt(  lightPosition2[0], lightPosition2[1], lightPosition2[2],
                0.0f, 0.0f , 0.0f,
                0.0f, 1.0f, 0.0f);
    glGetFloatv(GL_MODELVIEW_MATRIX, lightViewMatrix2);
glPopMatrix();
 
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(lightProjectionMatrix2);
 
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(lightViewMatrix2);
 
//Use viewport the same size as the shadow map
glViewport(0, 0, shadowMapSize, shadowMapSize);
 
//Draw the scene
DrawScene();
 
//Read the depth buffer into the shadow map texture
glBindTexture(GL_TEXTURE_2D, shadowMapTexture[1]);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, shadowMapSize, shadowMapSize);
 
//restore states
glCullFace(GL_BACK);
glShadeModel(GL_SMOOTH);
glColorMask(1, 1, 1, 1);
 
 
//2nd pass - Draw from camera's point of view
glClear(GL_DEPTH_BUFFER_BIT);
 
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(cameraProjectionMatrix);
 
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(cameraViewMatrix);
 
glViewport(0, 0, windowWidth, windowHeight);
 
float white2[3]={0.2f,0.2f,0.2f};
 
//light to represent shadowed areas
glLightfv(GL_LIGHT1, GL_POSITION, VECTOR4D(lightPosition));
glLightfv(GL_LIGHT1, GL_AMBIENT, white2);
glLightfv(GL_LIGHT1, GL_DIFFUSE, white2);
glLightfv(GL_LIGHT1, GL_SPECULAR, black1);
glEnable(GL_LIGHT1);
glEnable(GL_LIGHTING);
 
DrawScene();
 
 
//3rd pass
//Draw with bright light LIGHT1
glLightfv(GL_LIGHT1, GL_DIFFUSE, white1);
glLightfv(GL_LIGHT1, GL_SPECULAR, white1);
 
//Calculate texture matrix for projection
//This matrix takes us from eye space to the light's clip space
//It is postmultiplied by the inverse of the current view matrix when specifying texgen
static MATRIX4X4 biasMatrix(0.5f, 0.0f, 0.0f, 0.0f,
                            0.0f, 0.5f, 0.0f, 0.0f,
                            0.0f, 0.0f, 0.5f, 0.0f,
                            0.5f, 0.5f, 0.5f, 1.0f);    //bias from [-1, 1] to [0, 1]
 
MATRIX4X4 textureMatrix=biasMatrix*lightProjectionMatrix*lightViewMatrix;
 
//Set up texture coordinate generation.
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_S, GL_EYE_PLANE, textureMatrix.GetRow(0));
glEnable(GL_TEXTURE_GEN_S);
 
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_T, GL_EYE_PLANE, textureMatrix.GetRow(1));
glEnable(GL_TEXTURE_GEN_T);
 
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_R, GL_EYE_PLANE, textureMatrix.GetRow(2));
glEnable(GL_TEXTURE_GEN_R);
 
glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_Q, GL_EYE_PLANE, textureMatrix.GetRow(3));
glEnable(GL_TEXTURE_GEN_Q);
 
//Bind & enable shadow map texture
glBindTexture(GL_TEXTURE_2D, shadowMapTexture[0]);
glEnable(GL_TEXTURE_2D);
 
//Enable shadow comparison
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE);
 
//Shadow comparison should be true (ie not in shadow) if r<=texture
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);
 
//Shadow comparison should generate an INTENSITY result
glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_INTENSITY);
 
//Set alpha test to discard false comparisons
glAlphaFunc(GL_GEQUAL, 0.99f);
glEnable(GL_ALPHA_TEST);
 
DrawScene();
 
//3rd pass
//Draw with bright light LIGHT2
 
MATRIX4X4 textureMatrix2=biasMatrix*lightProjectionMatrix2*lightViewMatrix2;
 
//Set up texture coordinate generation.
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_S, GL_EYE_PLANE, textureMatrix2.GetRow(0));
glEnable(GL_TEXTURE_GEN_S);
 
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_T, GL_EYE_PLANE, textureMatrix2.GetRow(1));
glEnable(GL_TEXTURE_GEN_T);
 
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_R, GL_EYE_PLANE, textureMatrix2.GetRow(2));
glEnable(GL_TEXTURE_GEN_R);
 
glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_Q, GL_EYE_PLANE, textureMatrix2.GetRow(3));
glEnable(GL_TEXTURE_GEN_Q);
 
//Bind & enable shadow map texture
glBindTexture(GL_TEXTURE_2D, shadowMapTexture[1]);
glEnable(GL_TEXTURE_2D);
 
//Enable shadow comparison
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE);
 
//Shadow comparison should be true (ie not in shadow) if r<=texture
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);
 
//Shadow comparison should generate an INTENSITY result
glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_INTENSITY);
 
//Set alpha test to discard false comparisons
glAlphaFunc(GL_GEQUAL, 0.99f);
glEnable(GL_ALPHA_TEST);
 
DrawScene();
 
//Disable textures and texgen
glDisable(GL_TEXTURE_2D);
 
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_R);
glDisable(GL_TEXTURE_GEN_Q);
 
//Restore other states
glDisable(GL_LIGHTING);
glDisable(GL_ALPHA_TEST);
 
 
//Set matrices for ortho
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(-1.0f, 1.0f, -1.0f, 1.0f);
 
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
 
//reset matrices
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
 
glFinish();
glutSwapBuffers();}

Spec. clarification: gl_VertexID, is the generation by glDrawElements optional?

yousry — Fri, 03 May 2013 07:55:01 GMT

The Specification defines:

gl_VertexID is a vertex language input variable that holds an integer index for the vertex. The index is impliclty generated by glDrawArrays and other commands that do not reference the content of the GL_ELEMENT_ARRAY_BUFFER, or explicitly generated from the content of the GL_ELEMENT_ARRAY_BUFFER by commands such as glDrawElements.

I would like to know, if the "or" part of the specification is optional. Since this is ignored by a server released few days ago. Also I would like to know if re-indexing with random ordering is allowed e.g:

index_x < index_y => gl_VertexID_x > gl_VertexID_y == true

GLSL function execution time estimation

Aleksandar — Sun, 28 Apr 2013 23:12:12 GMT

On the first glance the following question looks silly, but after trying to answer on it I realized it is quite difficult (or even impossible).

How can we estimate execution time of some function inside a shader?

I have made a sample vertex shader like this:

Code :

#version 330
out  float out_val;
void main(void)
{
    out_val = someFun(gl_VertexID * 1e-6);
}

allocate 80MB buffer for transform feedback, embrace glDrawArrays() with glQueryCounter()

Code :

glQueryCounter(m_nStartTimeID, GL_TIMESTAMP);
glDrawArrays(GL_POINTS, first, count);
glQueryCounter(m_nEndTimeID, GL_TIMESTAMP);

and call it for count=1e7.

Can you guess what happens? Elapsed time does not depend on the complexity of the function. There is a fixed portion for setup (about 14.7us on my laptop) and a portion that directly depends on the number of vertices (about 22.5ms for 1e7 vertices).

Does anybody have any suggestion on measuring GLSL function execution time?

In fact, I need to compare efficiency of some implementations. So it is not important to have absolute values. On the other hand, I don't want to measure execution time of the application when they are applied, since it is quite specific and subjected to optimization related to certain implementation.

Thank you in advance!

scrolling normal maps to scrolling bump map

Johnathon332 — Sun, 28 Apr 2013 14:15:51 GMT

I was wondering if it was possible to have 2 scrolling normal maps which can then be applied to a texture to create a moving bump map? Where the texture will be stationary if that makes sense. I can attempt to clarify further, sorry I am not good at explaining myself.

Shader error and Identity Matrix

Alecto — Sun, 28 Apr 2013 07:30:43 GMT

Hi. I have a simple shader line gl_Position = u_MVPMatrix *(u_InverseBindMatrix) *(a_Position); I have u_inversebindmatrix set to Identity matrix using Matrix.setidentityM(); If I render without the line *u_InverseBindMatrix, then my cube shows up. If I leave it in, however, nothing shows up. I thought the identity matrix left equations unchanged. Any ideas?

Texture not animating only shows black model

Johnathon332 — Sat, 27 Apr 2013 09:48:08 GMT

hey guys I am trying to animate my texture using a bump map however it just comes up as a black model...well kind of dark blue

Code :

attribute highp vec3  inVertex;
 
uniform highp   mat4  MVPMatrix;
uniform mediump vec3  LightDir;
uniform mediump vec3  EyePos;
uniform mediump vec2  inTexCoord;
uniform mediump vec2 watermovementX;
uniform mediump vec2 watermovementY;
uniform mediump vec2 waterSX;
uniform mediump vec2 waterSY;
 
varying mediump vec3  EyeDir;
varying mediump vec2  TexCoord;
varying mediump vec2  TexCoord2;
varying mediump vec2  RefCoord;
varying mediump float WaterToEyeLength;
 
void main()
{
	// Transform position
	gl_Position = MVPMatrix * vec4(inVertex,1.0);
	mediump vec2 waterCoord = inTexCoord;
	TexCoord = waterCoord.xy * waterSX; //this line scales the bump map
	TexCoord += watermovementX; //this line translates the bump map
	TexCoord2 = waterCoord.xy * waterSY;
	TexCoord2 += watermovementY;
 
	RefCoord = inTexCoord;
	mediump vec3 WaterToEye = EyePos - inVertex;
	WaterToEyeLength = length(WaterToEye);
}

FRAGMENT

Code :

uniform sampler2D  n_mapTex;
uniform sampler2D  n_mapTex2;
uniform sampler2D  reflectionTex;
uniform lowp float distortion;
uniform lowp vec4  WaterColour;
 
varying mediump vec2  TexCoord;
varying mediump vec2  TexCoord2;
varying mediump vec2  RefCoord;
varying mediump float WaterToEye;
 
void main()
{	
	//calculate water movement
	lowp vec3 aNormal = vec3(0.0, 0.0, 1.0);
	aNormal = texture2D(n_mapTex, TexCoord).xyz;
	aNormal += texture2D(n_mapTex, TexCoord2).xyz;
	aNormal -= 1.0;
	lowp vec2 watermovement = aNormal.st;
	mediump vec2 texMove = watermovement * (distortion/WaterToEye);
	gl_FragColor = texture2D(reflectionTex, texMove);
}

code to update

Code :

waterTran += water_Vel * DT;
	waterTran = PVRTVec2(	fmod(waterTran.x, 1.0f), fmod(waterTran.y, 1.0f));
	waterTran2 += water_Vel2 * DT;
	waterTran2 = PVRTVec2(	fmod(waterTran2.x, 1.0f), fmod(waterTran2.y, 1.0f));
 
 
	glUniform2fv(m_ShaderProgram.auiLoc[eW_Move],1, &waterTran.x);
	glUniform2fv(m_ShaderProgram.auiLoc[eWaterS],1, &water_S.x);
	glUniform2fv(m_ShaderProgram.auiLoc[eW_Move2],1, &waterTran2.x);
	glUniform2fv(m_ShaderProgram.auiLoc[eWaterS2],1, &water_S2.x);
	glUniform1f(m_ShaderProgram.auiLoc[eDist], pertubation);

DT = delta time

opengl origin....

qawded — Sat, 27 Apr 2013 04:11:01 GMT

i am very new to opengl ...please let me know where is the origin of opengl window....
and by default is it orthographic projection??

uniform struct array

LaLaChen — Fri, 26 Apr 2013 16:59:46 GMT

Hi, all.

I try to write a structure and declare an array as follow :

Code :

struct ShadowMapping
{
	mat4            light_coordinate_system;
	sampler2DShadow shadow_map;
	int             shadow_map_width;
	int             shadow_map_height;
};
 
...
 
//shadow mapping info
uniform ShadowMapping shadow_mapping_list[8]; //declaration
uniform int           shadow_mapping_number;

Then I use the array in my shading program(fragment shader).

If the condition in for loop is large than 1, I won't get all location of variables in my shader.

So how can I use the uniform struct array in my shader?

P.S. I post my code occurring the problem.

Code :

 
        int i;
        for( i = 0 ; i < shadow_mapping_number ; i++)//if I modify the shadow_mapping_number to a constant 1, it's working. Otherwise, it's failure.
	{
		//use the uniform struct array by the form : shadow_mapping_list[i].light_coordinate_system, and etc... .
	}

And my version of glsl is #version 120
Graphics card is Nvidia GTX 460

By the way, the complied result is on error occurred in any shader.

Thanks.

Extracting a value from a fragment shader

frigopie — Wed, 24 Apr 2013 17:03:59 GMT

Hi all,

I am implementing hdr light adaptation, until I found a small technical problem.
I need to calculate this value inside a fragment shader where I make other things too:

Attachment 1016

I have the LumAverage value (from a 1x1 sampler2D texture), but how can I export the LumAdapted calculated value in order to use it in the next frame (it will be LumAdapted_i-1 in the next frame)?

Thanks for you time ;)

cube map shader texture binding

AJOM566 — Tue, 23 Apr 2013 22:44:41 GMT

Hi,
I have set up a few classes which basically encapsulate the dynamic cube map generation code as in the superbible, 4th ed. p 616 based on framebufferobjects.
Now, I want to provide this texture(cube) to a shader for coloring a sphere. The shader code seems to be correct, because if I use static images, it looks ok.
However, when I try to generate images dynamically, something goes wrong: I get (static) random images (which are currently on the gpu memory) painted onto the sphere.
For painting the 6 sides of the texture-cube, I use glFramebufferTexture2D as in the book, but I am not sure what really goes wrong.
How do I bind the texture-cube to the shader-variable?
Currently, I use something like:
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP, cubeMapId);
setUniformValue(cubeMapTexLocation, 0); // cubeMapTexLocation is the location of the cubeMapTex variable, a samplerCube, in the shader

Is there an easy way to check the 6 images in the framebuffer after having rendered them (GL_TEXTURE_CUBE_MAP_POSITIVE_X,...?

Any ideas what is wrong here?