• Advertisement
Sign in to follow this  

OpenGL I feel like a Noob C++ GL 4.1 and GLSL 3.3 help please!

This topic is 1425 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Please help! I am trying to render a textured quad.
For the life of me, it retains black with a textured phong shader. In fact, when I use a phong shader, it stays black, even though its the same phong shader that renders all the models around said dastardly quad.

I'm hoping the code is quite explanatory so I'm just gonna walk through it and someone with a sharper eye than I can hunt for glory. Beware, there is a LOT of code - just looked and I feel bad.. however I do have to explain a couple of classes, FreeImage, and how it all works. I have quite a big project now.. it just doesn't yet do a lot because I don't have any textures. Just some 30-second -to-load .objs that are blue, and almost shiny.

 

I digress, the 'textured' quad gets made with the line below, which calls CreateQuad inline. It's gonna have some picture of some wood or something on it. It sits at 5,5,0 world space, and is 5x5 units in area.

m_HUD->Create( *ShapeFactory::CreateQuad( 5, 5, 5, 5, true),
	         "../Shaders/basic_phong.vs", "../Shaders/basic_phong.fs" );

Heres CreateQuad. (I post this so you can spot an error in it, but it ~should~ be pretty standard. It creates a quad. I hope.)

GeometryData* // Draw with GL_QUADS, centred on x, y
	ShapeFactory::CreateQuad(int x, int y, int width, int height, bool textured)
{
	GeometryData* shape = new GeometryData();
	shape->SetTopology(7); // ..->SetTopology(GL_QUADS);
	
	float x0, x1, y0, y1;
	
	x0 = x + (width/2);	x1 = x - (width/2);
	y0 = y + (height/2);	y1 = y - (height/2);

	shape->numVertices = 4;
	shape->m_Vertices = (Cream::Vertex3D*) calloc (4, sizeof(Cream::Vertex3D) );
	shape->m_Vertices[0] = Vertex3D( x0, y1 , 0.0f );
	shape->m_Vertices[1] = Vertex3D( x1, y1 , 0.0f );
	shape->m_Vertices[2] = Vertex3D( x1, y0 , 0.0f );
	shape->m_Vertices[3] = Vertex3D( x0, y0 , 0.0f );

	shape->numNormals = 4;	
	shape->m_Normals = (Cream::Vertex3D*) calloc (4, sizeof(Cream::Vertex3D) );
	shape->m_Normals[0] = Vertex3D( 0.0f, 0.0f , 1.0f );
	shape->m_Normals[1] = Vertex3D( 0.0f, 0.0f , 1.0f );
	shape->m_Normals[2] = Vertex3D( 0.0f, 0.0f , 1.0f );
	shape->m_Normals[3] = Vertex3D( 0.0f, 0.0f , 1.0f );

	if( textured )
	{
		shape->numUVs = 4;
		shape->m_TexCoords = (Cream::Vertex2D*) calloc (4, sizeof(Cream::Vertex2D) );
		shape->m_TexCoords[0] = Vertex2D(0.0f, 1.0f);
		shape->m_TexCoords[1] = Vertex2D(1.0f, 1.0f);
		shape->m_TexCoords[2] = Vertex2D(1.0f, 0.0f);
		shape->m_TexCoords[3] = Vertex2D(0.0f, 0.0f);
	}

	shape->numIndices = 0;

	return shape;	
}

m_HUD is of type GLMesh. GLMesh::Create in short creates a VAO from that GeometryData, a Shader from those filenames, and holds a material - which contains uniforms I may want to set for the model; colour, gl texture id, texture name, etc. It has the Render method.

So, GLMesh::PreRender sets uniforms by talking to its GLShader, and it works like this: If the material says I'm textured, if it contains a texture ID for a diffuse map -- then I have a KdID, I set it. It also sets camera matrices. bOk is bOk, whether I use a texture or no, so the "1" is getting sent to map_kd in the shader.

if(material->isTextured)
{
	if( material->KdID != 0 )
	{	// both barrels and still nothing!
		glActiveTexture(GL_TEXTURE1);
		glBindTexture(GL_TEXTURE_2D, material->KdID );

		bOk = bOk && m_Shader->SetUniformInt( 1, "map_kd" );
	}
	if( material->KaID != 0 )
	{
		//glActiveTexture(GL_TEXTURE2);
		glBindTexture(GL_TEXTURE_2D, material->KaID );
	
        	bOk = bOk && m_Shader->SetUniformInt( 2, "map_ka" );		
	}
        ......
        else
        {       // always fires for non-textured shader, always works*
                bOk = bOk && m_Shader->SetUniformVec4(glm::vec4(material->Kd.GLM(), 1.0), "m_Kd");
        }

So that explains how the quad gets made and how it gets rendered, using texture unit or colour, the other data that it requires etc to exist in GL land. I'm pretty sure everything's good except setting the texture / sampler (I've said little of textures, I know).

 

I got FreeImage. It gives me bits, and I copy them, and keep them locally, then I let GL copy them and GL gives me a texture unit.

 

It gets convoluted though - as I said, I keep the texture locally and don't free them bits after I give them to OpenGL, because I want to play later - so I have a class for a texture, that lets me access those bits from FreeImage with GetPixel, SetPixel, Fill, etc, as if it were a 2D array. This I feel would be a handy thing to make heightmaps with, among other things.

So FreeImage gives me bits, FreeImage is disguised as ImageFactory.

 

The bits go to a GLBitmap Constructor ( .. bmp->GetPixel(x, y) ), along with width, height, and whether the bits need shuffling or not when they get copied.

 

The GLBitmap goes to a GLTexture, which takes the width and height and the bits and does the OpenGL stuff in GLTexture::Load. 


Cream::GLTexture Cream::LoadTexture(std::string path)
{
ImageFactory* factory = ImageFactory::Create();
 
unsigned int width(0), height(0);
bool bShuffle(false);
 
BYTE* bits = factory->Load( path, width, height, bShuffle );
 
GLBitmap* bitmap = new GLBitmap( width, height, bShuffle, bits );
 
GLTexture texture(GL_TEXTURE_2D, GL_RGBA);
 
texture.SetParam(GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
texture.SetParam(GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
texture.SetParam(GL_TEXTURE_MIN_FILTER, GL_LINEAR);
texture.SetParam(GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
texture.Load( bitmap );
 
return texture;
}

Okay, so here's the constructor for GLBitmap - a Pixel is 4 bytes, a BYTE is an unsigned char. You knew that. So we cast the bits to Pixels and we know we have w * h of them. This could be a place where things have gone wrong though.

GLBitmap(int w, int h, bool bShuffle, BYTE* bits)
{
	width = w;
	height = h;
	Pixel* src = (Pixel*)bits;

	pixels = new Pixel[w*h];

	for(int i = 0; i < w; ++i)
	{
		for(int j = 0 ; j < h; ++j)
		{			
			const Pixel& p = src[(i * h) + j];
			pixels[(i * h) + j] = (bShuffle) ? Pixel(p.B, p.G, p.R, p.A) : p ;
		}
	}
}

And finally our wrapper for an int, GLTexture, here's the Load method, that makes the actual OpenGL calls to generate a texture ID and set the bits to it.

bool GLTexture::Load( GLBitmap* bitmap )
{
	glGenTextures( 1, &m_GLID );
	glBindTexture( target, m_GLID );

	glTexImage2D( target, 0, GL_RGBA, bitmap->Width(), bitmap->Height(), 
                              0, GL_BGRA, GL_UNSIGNED_BYTE, bitmap->Data() );

	for( auto i = params.begin(); i != params.end(); ++i )
	        glTexParameteri( target, i->first, i->second );
 
	return (m_GLID!=0);
}

And so, that explains, in SetMaterial, the workings behind Cream::LoadTexture()

if(mat->isTextured)
{
	material->isTextured = true;

	if(mat->mapKd.size() != 0)	// if there is a filename
	{
		if(mat->KdID != 0)		//if there is a gl/sl tex unit id
			material->KdID = mat->KdID;	//grab it
		else
		{
			m_Textures[0] = Cream::LoadTexture( mat->mapKd ); // else load it
			material->KdID = m_Textures[0].ID();
		}
		material->mapKd = mat->mapKd;
	}
....

So where's my error.. Well I suspect a couple of things. I have a debug callback set, would it inform me of anything obvious?

- the glActiveTexture(GLTEXTURE0+n) calls - they're wrong - the wrong place, too often, wrong texture unit ?
- not sending the right value through to the sampler in the shader*, and no map is being sampled.. linked to above?
- the bits were mangled or the pointer lost by the time OpenGL gets to them in GLTexture::Load

As I say, the coloured phong shader and the textured phong shader are identical except for swapping a vec4 uniform for a sampler and a vec2 attribute, and getting the colour by sampling the texture.

Everything renders fine except the textured-not-coloured stuff.

Please find my error(s), I'll be around to let you know how much you helped! It was a long post.. apologies! A lot of code..

Thank you so, so much in advance! There's a lot I want to do with textures that I can't yet!

In fact, here's a screenshot of a mildly shiny blue cube, a white floor-grid, and a square black hole. I kid, it's that quad.

 

 

Share this post


Link to post
Share on other sites
Advertisement

Is your quad rendered with the shader on? Are you able to output a debug red color to verify the shader is on?

Are you binding the texture and sending the uniform to the shader?

Share this post


Link to post
Share on other sites
Screenshots up. See the cube and the black quad? I can render that quad using that cube's shader and get a nice yellow on it. I simply set material->isTextured to false and give the other shader names in the GLMesh constructor way at the top. And set a colour on the material.

Okay.. the generic colured shader gives me yellow, the phong shader on the quad makes it black, same phong shader as the cube.. curiouser and curiouser..!

Share this post


Link to post
Share on other sites

Could you explain what "Everything renders fine except the textured-not-coloured stuff." means? maybe a screenshot?


If I use texture shader, black. If coloured shader, fine. I say 'stuff' because I think the issue with the texturing resides in the texture stuff.. GLTexture, GLBitmap, or setting the texture / binding it. glGenTextures gives me a texture id, even when I was giving it nothing cos I had been calling FreeImage_Unload too early.. 80% sure that those are the right bytes going on the card. Lol.

Share this post


Link to post
Share on other sites

So do any of your models/shaders have a textured model? Are you sending the uniform to the shader? What does your shader look like?

Does the quad have normal? Can you at least strip your shader down to texture2D(diffuse, texCoord))...... don't know if its a lighting problem/attribute problem, uniform problem, bad texture problem..

Why don't you verify glUseProgram(0) and binding the texture shows up on your quad wihtout using a shader.

Share this post


Link to post
Share on other sites

So do any of your models/shaders have a textured model? Are you sending the uniform to the shader? What does your shader look like?
Does the quad have normal? Can you at least strip your shader down to texture2D(diffuse, texCoord))...... don't know if its a lighting problem/attribute problem, uniform problem, bad texture problem..
Why don't you verify glUseProgram(0) and binding the texture shows up on your quad wihtout using a shader.


1. What?
2. Yes. All the lighting colours vectors, a bunch of matrices, and the texture unit all go to the shader no problem. The GLMesh looks at the material in SetMaterial(), checking for a gl tex id or texture path, and loads texture via a factory (Freeimage) if it needs to. In GLMesh::Render, GLMesh::PreRenderlooks at the material it holds and sets a colour if there is no texture ids - PreRender sets uniforms. See the code in the original post.

3. Look like? There is a basic coloured pass thru shader, a phong coloured shader, and a phong textured shader. In the screenshot in the original post, the phong coloured is the cube on the right, the coloured pass thru is the XYZ and the grid, and the textured quad shader is the black quad in the middle.

I rendered the quad with the pass thru shader, uniform colour as yellow, and it was yellow. I use the textured phong shader or the coloured phong shader, and the quad is black. Verr strange.

As shown in the code in the original post, the quad has four vertices and four normals, each normal is z positive.

The phong colour and phong texture shader are identical except the change from a uniform vec4 colour to a in vec2 uv and a uniform sampler2D tex.

Share this post


Link to post
Share on other sites

What happens if you use these tex coords

 

shape->m_TexCoords[0] = Vertex2D(1.0f, 0.0f);
shape->m_TexCoords[1] = Vertex2D(0.0f, 0.0f);
shape->m_TexCoords[2] = Vertex2D(0.0f, 1.0f);
shape->m_TexCoords[3] = Vertex2D(1.0f, 1.0f);

Share this post


Link to post
Share on other sites

Sorry I disappeared - work/sleep.
 

 

What happens if you use these tex coords

 

shape->m_TexCoords[0] = Vertex2D(1.0f, 0.0f);
shape->m_TexCoords[1] = Vertex2D(0.0f, 0.0f);
shape->m_TexCoords[2] = Vertex2D(0.0f, 1.0f);
shape->m_TexCoords[3] = Vertex2D(1.0f, 1.0f);

 

Trying them now..

Legen..  You are SO AWESOME, THANKYOU!

Seriously for chewing through that first post and it was just the texture coordinates.. I'm glad though, that it was a noob error and not down to the whole mechanism of materials, geometry, vaos n shaders, and those texture classes.. there's some saving face in that, I think.

I'll let you in on a secret: I changed my phong shader fragment shader to just set fragColour as what it sampled, no lighting calcs.. something may be wrong with my normals or the phong code.. another thread, coming soon *facepalm*.

Thank you again! So was my texture' backwards' or 'inside out' or what?

..-dary!
 

Share this post


Link to post
Share on other sites

From the original post you seem to have specified the quad verts as botRight -> botLeft -> topLeft -> topRight, but the quad texcoords were

topLeft -> topRight -> botRight -> botLeft so the order didnt match.

Edited by NumberXaero

Share this post


Link to post
Share on other sites

From the original post you seem to have specified the quad verts as botRight -> botLeft -> topLeft -> topRight, but the quad texcoords were

topLeft -> topRight -> botRight -> botLeft so the order didnt match.

This is exactly my problem! I've been doing some testing with my 3 shaders.

- The basic coloured one always works on models and on the quad.
- The coloured phong shader on models works (does it..?) - the models appear blue and shiny, like the cube there. But it doesn't work on my quad - until
- The textured phong shader works on the quad - when I set all the normals to (0.0, 0.0 -1.0) - so does the coloured phong shader.

I haven't tried a texture on a mesh.. though obviously I want to. So my quad is wound all wrong! And my texturing stuff works.

So what order is the most used or correct way to wind a quad? I'm always worrying about triangles recently.

I would imagine it should be top right, bottom right, top left, bottom left? Or do you do them counter/clockwise, like a tri, - something like bottom right, top right, top left, bottom left? I'm guessing this is important for rendering meshes that are quads?

Using your texture coordinates, and making x0 negative and x1 positive, y0 negative and y1 positive (that was poor mistake I admit), and setting my normals to -Z, I get this with the textured phong shader. Is my Quad wound the wrong way?


 

Share this post


Link to post
Share on other sites

Winding and texture coord order is important for everything, I use CCW = front, but it doesnt matter you just have to make sure its consistent with your cull winding.

If your vertex winding is not what you intended then your triangles will have their front faces culled when backface culling is enabled. You see this in poorly created models that have missing triangles when view from the outside, its because the winding on all the triangle is not consistent

If your texture coordinates dont fall where they should your texture might be distored, flipped horzontally or vertically. With textures like rocks with no obvious up/down left/right it can make it difficult to notice these problems. Make a basic texture for testing. Say with a capital L on the left of the image, colored red, T at top for top another color, Bottom, Right, etc. Give it a 1 pixel border, place a circle dead center. This will help you notice flips, stretches, and tiling better. Use a white background so you can notice any strange color changes.

 

Im not sure if what Im seeing is wrong, because If have no way to gauge if that texture looks wrong or not, Its features dont say right or wrong.

Edited by NumberXaero

Share this post


Link to post
Share on other sites
I know about winding in general, I guess I meant which corner do I start from? - I am using GL_QUADS.

Im going to check my culling settings, pretty sure I'm using using counter clockwise and culling back faces.. Ill edit this post when I find out, just cooking

PS that texture has some text on it, its just a random sample.

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
  • Advertisement
  • Popular Tags

  • Advertisement
  • Popular Now

  • Similar Content

    • By reenigne
      For those that don't know me. I am the individual who's two videos are listed here under setup for https://wiki.libsdl.org/Tutorials
      I also run grhmedia.com where I host the projects and code for the tutorials I have online.
      Recently, I received a notice from youtube they will be implementing their new policy in protecting video content as of which I won't be monetized till I meat there required number of viewers and views each month.

      Frankly, I'm pretty sick of youtube. I put up a video and someone else learns from it and puts up another video and because of the way youtube does their placement they end up with more views.
      Even guys that clearly post false information such as one individual who said GLEW 2.0 was broken because he didn't know how to compile it. He in short didn't know how to modify the script he used because he didn't understand make files and how the requirements of the compiler and library changes needed some different flags.

      At the end of the month when they implement this I will take down the content and host on my own server purely and it will be a paid system and or patreon. 

      I get my videos may be a bit dry, I generally figure people are there to learn how to do something and I rather not waste their time. 
      I used to also help people for free even those coming from the other videos. That won't be the case any more. I used to just take anyone emails and work with them my email is posted on the site.

      I don't expect to get the required number of subscribers in that time or increased views. Even if I did well it wouldn't take care of each reoccurring month.
      I figure this is simpler and I don't plan on putting some sort of exorbitant fee for a monthly subscription or the like.
      I was thinking on the lines of a few dollars 1,2, and 3 and the larger subscription gets you assistance with the content in the tutorials if needed that month.
      Maybe another fee if it is related but not directly in the content. 
      The fees would serve to cut down on the number of people who ask for help and maybe encourage some of the people to actually pay attention to what is said rather than do their own thing. That actually turns out to be 90% of the issues. I spent 6 hours helping one individual last week I must have asked him 20 times did you do exactly like I said in the video even pointed directly to the section. When he finally sent me a copy of the what he entered I knew then and there he had not. I circled it and I pointed out that wasn't what I said to do in the video. I didn't tell him what was wrong and how I knew that way he would go back and actually follow what it said to do. He then reported it worked. Yea, no kidding following directions works. But hey isn't alone and well its part of the learning process.

      So the point of this isn't to be a gripe session. I'm just looking for a bit of feed back. Do you think the fees are unreasonable?
      Should I keep the youtube channel and do just the fees with patreon or do you think locking the content to my site and require a subscription is an idea.

      I'm just looking at the fact it is unrealistic to think youtube/google will actually get stuff right or that youtube viewers will actually bother to start looking for more accurate videos. 
    • By Balma Alparisi
      i got error 1282 in my code.
      sf::ContextSettings settings; settings.majorVersion = 4; settings.minorVersion = 5; settings.attributeFlags = settings.Core; sf::Window window; window.create(sf::VideoMode(1600, 900), "Texture Unit Rectangle", sf::Style::Close, settings); window.setActive(true); window.setVerticalSyncEnabled(true); glewInit(); GLuint shaderProgram = createShaderProgram("FX/Rectangle.vss", "FX/Rectangle.fss"); float vertex[] = { -0.5f,0.5f,0.0f, 0.0f,0.0f, -0.5f,-0.5f,0.0f, 0.0f,1.0f, 0.5f,0.5f,0.0f, 1.0f,0.0f, 0.5,-0.5f,0.0f, 1.0f,1.0f, }; GLuint indices[] = { 0,1,2, 1,2,3, }; GLuint vao; glGenVertexArrays(1, &vao); glBindVertexArray(vao); GLuint vbo; glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(vertex), vertex, GL_STATIC_DRAW); GLuint ebo; glGenBuffers(1, &ebo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices,GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, false, sizeof(float) * 5, (void*)0); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 2, GL_FLOAT, false, sizeof(float) * 5, (void*)(sizeof(float) * 3)); glEnableVertexAttribArray(1); GLuint texture[2]; glGenTextures(2, texture); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texture[0]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); sf::Image* imageOne = new sf::Image; bool isImageOneLoaded = imageOne->loadFromFile("Texture/container.jpg"); if (isImageOneLoaded) { glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageOne->getSize().x, imageOne->getSize().y, 0, GL_RGBA, GL_UNSIGNED_BYTE, imageOne->getPixelsPtr()); glGenerateMipmap(GL_TEXTURE_2D); } delete imageOne; glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texture[1]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); sf::Image* imageTwo = new sf::Image; bool isImageTwoLoaded = imageTwo->loadFromFile("Texture/awesomeface.png"); if (isImageTwoLoaded) { glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageTwo->getSize().x, imageTwo->getSize().y, 0, GL_RGBA, GL_UNSIGNED_BYTE, imageTwo->getPixelsPtr()); glGenerateMipmap(GL_TEXTURE_2D); } delete imageTwo; glUniform1i(glGetUniformLocation(shaderProgram, "inTextureOne"), 0); glUniform1i(glGetUniformLocation(shaderProgram, "inTextureTwo"), 1); GLenum error = glGetError(); std::cout << error << std::endl; sf::Event event; bool isRunning = true; while (isRunning) { while (window.pollEvent(event)) { if (event.type == event.Closed) { isRunning = false; } } glClear(GL_COLOR_BUFFER_BIT); if (isImageOneLoaded && isImageTwoLoaded) { glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texture[0]); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texture[1]); glUseProgram(shaderProgram); } glBindVertexArray(vao); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr); glBindVertexArray(0); window.display(); } glDeleteVertexArrays(1, &vao); glDeleteBuffers(1, &vbo); glDeleteBuffers(1, &ebo); glDeleteProgram(shaderProgram); glDeleteTextures(2,texture); return 0; } and this is the vertex shader
      #version 450 core layout(location=0) in vec3 inPos; layout(location=1) in vec2 inTexCoord; out vec2 TexCoord; void main() { gl_Position=vec4(inPos,1.0); TexCoord=inTexCoord; } and the fragment shader
      #version 450 core in vec2 TexCoord; uniform sampler2D inTextureOne; uniform sampler2D inTextureTwo; out vec4 FragmentColor; void main() { FragmentColor=mix(texture(inTextureOne,TexCoord),texture(inTextureTwo,TexCoord),0.2); } I was expecting awesomeface.png on top of container.jpg

    • By khawk
      We've just released all of the source code for the NeHe OpenGL lessons on our Github page at https://github.com/gamedev-net/nehe-opengl. code - 43 total platforms, configurations, and languages are included.
      Now operated by GameDev.net, NeHe is located at http://nehe.gamedev.net where it has been a valuable resource for developers wanting to learn OpenGL and graphics programming.

      View full story
    • By TheChubu
      The Khronos™ Group, an open consortium of leading hardware and software companies, announces from the SIGGRAPH 2017 Conference the immediate public availability of the OpenGL® 4.6 specification. OpenGL 4.6 integrates the functionality of numerous ARB and EXT extensions created by Khronos members AMD, Intel, and NVIDIA into core, including the capability to ingest SPIR-V™ shaders.
      SPIR-V is a Khronos-defined standard intermediate language for parallel compute and graphics, which enables content creators to simplify their shader authoring and management pipelines while providing significant source shading language flexibility. OpenGL 4.6 adds support for ingesting SPIR-V shaders to the core specification, guaranteeing that SPIR-V shaders will be widely supported by OpenGL implementations.
      OpenGL 4.6 adds the functionality of these ARB extensions to OpenGL’s core specification:
      GL_ARB_gl_spirv and GL_ARB_spirv_extensions to standardize SPIR-V support for OpenGL GL_ARB_indirect_parameters and GL_ARB_shader_draw_parameters for reducing the CPU overhead associated with rendering batches of geometry GL_ARB_pipeline_statistics_query and GL_ARB_transform_feedback_overflow_querystandardize OpenGL support for features available in Direct3D GL_ARB_texture_filter_anisotropic (based on GL_EXT_texture_filter_anisotropic) brings previously IP encumbered functionality into OpenGL to improve the visual quality of textured scenes GL_ARB_polygon_offset_clamp (based on GL_EXT_polygon_offset_clamp) suppresses a common visual artifact known as a “light leak” associated with rendering shadows GL_ARB_shader_atomic_counter_ops and GL_ARB_shader_group_vote add shader intrinsics supported by all desktop vendors to improve functionality and performance GL_KHR_no_error reduces driver overhead by allowing the application to indicate that it expects error-free operation so errors need not be generated In addition to the above features being added to OpenGL 4.6, the following are being released as extensions:
      GL_KHR_parallel_shader_compile allows applications to launch multiple shader compile threads to improve shader compile throughput WGL_ARB_create_context_no_error and GXL_ARB_create_context_no_error allow no error contexts to be created with WGL or GLX that support the GL_KHR_no_error extension “I’m proud to announce OpenGL 4.6 as the most feature-rich version of OpenGL yet. We've brought together the most popular, widely-supported extensions into a new core specification to give OpenGL developers and end users an improved baseline feature set. This includes resolving previous intellectual property roadblocks to bringing anisotropic texture filtering and polygon offset clamping into the core specification to enable widespread implementation and usage,” said Piers Daniell, chair of the OpenGL Working Group at Khronos. “The OpenGL working group will continue to respond to market needs and work with GPU vendors to ensure OpenGL remains a viable and evolving graphics API for all its customers and users across many vital industries.“
      The OpenGL 4.6 specification can be found at https://khronos.org/registry/OpenGL/index_gl.php. The GLSL to SPIR-V compiler glslang has been updated with GLSL 4.60 support, and can be found at https://github.com/KhronosGroup/glslang.
      Sophisticated graphics applications will also benefit from a set of newly released extensions for both OpenGL and OpenGL ES to enable interoperability with Vulkan and Direct3D. These extensions are named:
      GL_EXT_memory_object GL_EXT_memory_object_fd GL_EXT_memory_object_win32 GL_EXT_semaphore GL_EXT_semaphore_fd GL_EXT_semaphore_win32 GL_EXT_win32_keyed_mutex They can be found at: https://khronos.org/registry/OpenGL/index_gl.php
      Industry Support for OpenGL 4.6
      “With OpenGL 4.6 our customers have an improved set of core features available on our full range of OpenGL 4.x capable GPUs. These features provide improved rendering quality, performance and functionality. As the graphics industry’s most popular API, we fully support OpenGL and will continue to work closely with the Khronos Group on the development of new OpenGL specifications and extensions for our customers. NVIDIA has released beta OpenGL 4.6 drivers today at https://developer.nvidia.com/opengl-driver so developers can use these new features right away,” said Bob Pette, vice president, Professional Graphics at NVIDIA.
      "OpenGL 4.6 will be the first OpenGL release where conformant open source implementations based on the Mesa project will be deliverable in a reasonable timeframe after release. The open sourcing of the OpenGL conformance test suite and ongoing work between Khronos and X.org will also allow for non-vendor led open source implementations to achieve conformance in the near future," said David Airlie, senior principal engineer at Red Hat, and developer on Mesa/X.org projects.

      View full story
    • By _OskaR
      Hi,
      I have an OpenGL application but without possibility to wite own shaders.
      I need to perform small VS modification - is possible to do it in an alternative way? Do we have apps or driver modifictions which will catch the shader sent to GPU and override it?
  • Advertisement