Sign in to follow this  
ajm113

OpenGL Trouble Calculating Normals

Recommended Posts

ajm113    355

Hello everyone!

 

I think this maybe more related to perhaps more of how I calculated my normals, then a OpenGL issue. But I assume the best place to ask would be OpenGL forum encase if it's the way I told OpenGL to handle my normals.

 

Anyways I dont think my normals are calculated correctly, because I'm throwing in a rotating cube into my scene using triangles, and it appears only some triangles seem to light up correctly. Otherwise most of them are simply just black. Btw my scene is drawn clockwise if that makes a difference... And I'm using glNormalPointer, glVertexPointer, etc.. to draw everything and to make my OpenGL calls optimized as much as I can. ;)

 

 

Cube class constructor: Not really important I suspect since all this does is put together the cube and does nothing with the normals, but just encase...

	Cube[0] = m_pos.m_X-m_size.m_X;
	Cube[1] = m_pos.m_Y+m_size.m_Y;
	Cube[2] = m_pos.m_Z+m_size.m_Z;

	//Vector2
	Cube[3] = m_pos.m_X+m_size.m_X;
	Cube[4] = m_pos.m_Y+m_size.m_Y;
	Cube[5] = m_pos.m_Z+m_size.m_Z;

	//Vector3
	Cube[6] = m_pos.m_X-m_size.m_X;
	Cube[7] = m_pos.m_Y-m_size.m_Y;
	Cube[8] = m_pos.m_Z+m_size.m_Z;

	//Second triangle...

	//Vector 1
	Cube[9] =  m_pos.m_X-m_size.m_X;
	Cube[10] = m_pos.m_Y-m_size.m_Y;
	Cube[11] = m_pos.m_Z+m_size.m_Z;

	//Vector2
	Cube[12] = m_pos.m_X+m_size.m_X;
	Cube[13] = m_pos.m_Y+m_size.m_Y;
	Cube[14] = m_pos.m_Z+m_size.m_Z;

	//Vector3
	Cube[15] = m_pos.m_X+m_size.m_X;
	Cube[16] = m_pos.m_Y-m_size.m_Y;
	Cube[17] = m_pos.m_Z+m_size.m_Z;

	//BACK face...
	//First triangle.

	//Vector 1

	Cube[18] = m_pos.m_X+m_size.m_X;
	Cube[19] = m_pos.m_Y+m_size.m_Y;
	Cube[20] = m_pos.m_Z-m_size.m_Z;

	//Vector2
	Cube[21] = m_pos.m_X-m_size.m_X;
	Cube[22] = m_pos.m_Y+m_size.m_Y;
	Cube[23] = m_pos.m_Z-m_size.m_Z;

	//Vector3
	Cube[24] = m_pos.m_X+m_size.m_X;
	Cube[25] = m_pos.m_Y-m_size.m_Y;
	Cube[26] = m_pos.m_Z-m_size.m_Z;

	//Second triangle...

	//Vector 1
	Cube[27] = m_pos.m_X-m_size.m_X;
	Cube[28] = m_pos.m_Y+m_size.m_Y;
	Cube[29] = m_pos.m_Z-m_size.m_Z;

	//Vector2
	Cube[30] = m_pos.m_X-m_size.m_X;
	Cube[31] = m_pos.m_Y-m_size.m_Y;
	Cube[32] = m_pos.m_Z-m_size.m_Z;

	//Vector3
	Cube[33] = m_pos.m_X+m_size.m_X;
	Cube[34] = m_pos.m_Y-m_size.m_Y;
	Cube[35] = m_pos.m_Z-m_size.m_Z;


	//LEFT face...
	//First triangle.

	//Vector 1

	Cube[36] = m_pos.m_X+m_size.m_X;
	Cube[37] = m_pos.m_Y-m_size.m_Y;
	Cube[38] = m_pos.m_Z-m_size.m_Z;

	//Vector2
	Cube[39] = m_pos.m_X+m_size.m_X;
	Cube[40] = m_pos.m_Y-m_size.m_Y;
	Cube[41] = m_pos.m_Z+m_size.m_Z;

	//Vector3
	Cube[42] = m_pos.m_X+m_size.m_X;
	Cube[43] = m_pos.m_Y+m_size.m_Y;
	Cube[44] = m_pos.m_Z+m_size.m_Z;

	//Second triangle...

	//Vector 1
	Cube[45] = m_pos.m_X+m_size.m_X;
	Cube[46] = m_pos.m_Y+m_size.m_Y;
	Cube[47] = m_pos.m_Z-m_size.m_Z;

	//Vector2
	Cube[48] = m_pos.m_X+m_size.m_X;
	Cube[49] = m_pos.m_Y-m_size.m_Y;
	Cube[50] = m_pos.m_Z-m_size.m_Z;

	//Vector3
	Cube[51] = m_pos.m_X+m_size.m_X;
	Cube[52] = m_pos.m_Y+m_size.m_Y;
	Cube[53] = m_pos.m_Z+m_size.m_Z;

	//RIGHT face...
	//First triangle.

	//Vector 1

	Cube[54] = m_pos.m_X-m_size.m_X;
	Cube[55] = m_pos.m_Y-m_size.m_Y;
	Cube[56] = m_pos.m_Z-m_size.m_Z;

	//Vector2
	Cube[57] = m_pos.m_X-m_size.m_X;
	Cube[58] = m_pos.m_Y+m_size.m_Y;
	Cube[59] = m_pos.m_Z-m_size.m_Z;

	//Vector3
	Cube[60] = m_pos.m_X-m_size.m_X;
	Cube[61] = m_pos.m_Y-m_size.m_Y;
	Cube[62] = m_pos.m_Z+m_size.m_Z;

	//Second triangle...

	//Vector 1
	Cube[63] = m_pos.m_X-m_size.m_X;
	Cube[64] = m_pos.m_Y+m_size.m_Y;
	Cube[65] = m_pos.m_Z-m_size.m_Z;

	//Vector2
	Cube[66] = m_pos.m_X-m_size.m_X;
	Cube[67] = m_pos.m_Y+m_size.m_Y;
	Cube[68] = m_pos.m_Z+m_size.m_Z;

	//Vector3
	Cube[69] = m_pos.m_X-m_size.m_X;
	Cube[70] = m_pos.m_Y-m_size.m_Y;
	Cube[71] = m_pos.m_Z+m_size.m_Z;


	//TOP face...
	//First triangle.

	//Vector 1

	Cube[72] = m_pos.m_X+m_size.m_X;
	Cube[73] = m_pos.m_Y+m_size.m_Y;
	Cube[74] = m_pos.m_Z+m_size.m_Z;

	//Vector2
	Cube[75] = m_pos.m_X-m_size.m_X;
	Cube[76] = m_pos.m_Y+m_size.m_Y;
	Cube[77] = m_pos.m_Z+m_size.m_Z;

	//Vector3
	Cube[78] = m_pos.m_X+m_size.m_X;
	Cube[79] = m_pos.m_Y+m_size.m_Y;
	Cube[80] = m_pos.m_Z-m_size.m_Z;

	//Second triangle...

	//Vector 1
	Cube[81] = m_pos.m_X-m_size.m_X;
	Cube[82] = m_pos.m_Y+m_size.m_Y;
	Cube[83] = m_pos.m_Z+m_size.m_Z;

	//Vector2
	Cube[84] = m_pos.m_X-m_size.m_X;
	Cube[85] = m_pos.m_Y+m_size.m_Y;
	Cube[86] = m_pos.m_Z-m_size.m_Z;

	//Vector3
	Cube[87] = m_pos.m_X+m_size.m_X;
	Cube[88] = m_pos.m_Y+m_size.m_Y;
	Cube[89] = m_pos.m_Z-m_size.m_Z;

	//BOTTOM face...
	//First triangle.

	//Vector 1

	Cube[90] = m_pos.m_X-m_size.m_X;
	Cube[91] = m_pos.m_Y-m_size.m_Y;
	Cube[92] = m_pos.m_Z+m_size.m_Z;

	//Vector2
	Cube[93] = m_pos.m_X+m_size.m_X;
	Cube[94] = m_pos.m_Y-m_size.m_Y;
	Cube[95] = m_pos.m_Z+m_size.m_Z;

	//Vector3
	Cube[96] = m_pos.m_X+m_size.m_X;
	Cube[97] = m_pos.m_Y-m_size.m_Y;
	Cube[98] = m_pos.m_Z-m_size.m_Z;

	//Second triangle...

	//Vector 1
	Cube[99] = m_pos.m_X-m_size.m_X;
	Cube[100] = m_pos.m_Y-m_size.m_Y;
	Cube[101] = m_pos.m_Z+m_size.m_Z;

	//Vector2
	Cube[102] = m_pos.m_X+m_size.m_X;
	Cube[103] = m_pos.m_Y-m_size.m_Y;
	Cube[104] = m_pos.m_Z-m_size.m_Z;

	//Vector3
	Cube[105] = m_pos.m_X-m_size.m_X;
	Cube[106] = m_pos.m_Y-m_size.m_Y;
	Cube[107] = m_pos.m_Z-m_size.m_Z;

	normals = GLShortcuts::calculateNormal(Cube, 12);

calculateNormal... I know it's a tiny bit messy, but it's partly because of debugging reasons...

float* GLShortcuts::calculateNormal(float vec[], size_t triangles)
{

	float* normals = new float[triangles*3];
	size_t normPos = 0;
	size_t vexPos = 0;
	
	for(size_t i = 0; i<triangles; i++)
	{

	VECTOR_3D v1 = VECTOR_3D(vec[vexPos], vec[vexPos+1], vec[vexPos+2]);
	VECTOR_3D v2 = VECTOR_3D(vec[vexPos+3], vec[vexPos+4], vec[vexPos+5]);
	VECTOR_3D v3 = VECTOR_3D(vec[vexPos+6], vec[vexPos+7], vec[vexPos+8]);

	vexPos += 9;
		
	VECTOR_3D crossVec1 = (v2 - v1);
	VECTOR_3D crossVec2 = (v3 - v1);
	VECTOR_3D normal;
	normal.m_X = crossVec2.m_Y*crossVec1.m_Z - crossVec1.m_Y*crossVec2.m_Z;
	normal.m_Y = crossVec1.m_X*crossVec2.m_Z - crossVec2.m_X*crossVec1.m_Z;
	normal.m_Z = crossVec2.m_X*crossVec1.m_Y - crossVec2.m_Y*crossVec1.m_X;
	normal.Normalize();

		normals[normPos+0] = normal.m_X;
		normals[normPos+1] = normal.m_Y; 
		normals[normPos+2] = normal.m_Z;



		normPos+=3;
	}
void CubeGL::draw(void)
{
	if(m_texId > 0)
	{
		glEnable(GL_TEXTURE_2D);
		glEnable(GL_BLEND);
	}

	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_NORMAL_ARRAY);

	glVertexPointer(3, GL_FLOAT, 0, Cube);
	glTexCoordPointer(2, GL_FLOAT, 0, UV_Coords);
	glNormalPointer(GL_FLOAT, 0, normals);

		glDrawArrays(GL_TRIANGLES, 0, 36);

	glDisableClientState(GL_VERTEX_ARRAY);
	glDisableClientState(GL_NORMAL_ARRAY);


	if(m_texId > 0)
	{
		glDisable(GL_TEXTURE_2D);
		glDisable(GL_BLEND);
	}
}

And thats the draw code. Assuming if I'm being a tard with how I'm calling the normals.

Share this post


Link to post
Share on other sites
Vortez    2714

Well you could have a look at my 3ds exporter code, it's not very clean but it always worked just fine, ill post the most revelent code, hope i wont forget anything.

// This is our 3D point class. This will be used to store the vertices of our model.
class CVector3
{
public:
float x, y, z;
void Set(float i1, float i2, float i3){this->x=i1;this->y=i2;this->z=i3;};
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// This calculates a vector between 2 points and returns the result
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CVector3 _Vector(CVector3 vPoint1, CVector3 vPoint2)
{
CVector3 vVector;
vVector.x = vPoint1.x - vPoint2.x;
vVector.y = vPoint1.y - vPoint2.y;
vVector.z = vPoint1.z - vPoint2.z;
return vVector;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// This adds 2 vectors together and returns the result
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CVector3 _AddVector(CVector3 vVector1, CVector3 vVector2)
{
CVector3 vResult;
vResult.x = vVector2.x + vVector1.x;
vResult.y = vVector2.y + vVector1.y;
vResult.z = vVector2.z + vVector1.z;
return vResult;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// This divides a vector by a single number (scalar) and returns the result
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CVector3 _DivideVectorByScaler(CVector3 vVector1, float Scaler)
{
CVector3 vResult;
vResult.x = vVector1.x / Scaler;
vResult.y = vVector1.y / Scaler;
vResult.z = vVector1.z / Scaler;
return vResult;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// This returns the cross product between 2 vectors
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CVector3 _Cross(CVector3 vVector1, CVector3 vVector2)
{
CVector3 vCross;
vCross.x = ((vVector1.y * vVector2.z) - (vVector1.z * vVector2.y));
vCross.y = ((vVector1.z * vVector2.x) - (vVector1.x * vVector2.z));
vCross.z = ((vVector1.x * vVector2.y) - (vVector1.y * vVector2.x));
return vCross;	// Return the cross product
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// This returns the normal of a vector
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CVector3 _Normalize(CVector3 vNormal)
{
double Magnitude;
Magnitude = Mag(vNormal);
vNormal.x /= (float)Magnitude;
vNormal.y /= (float)Magnitude;
vNormal.z /= (float)Magnitude;
return vNormal;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Save the vertex normals (smooth)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Model3DExport::SaveNormals(Mesh* pMesh, Matrix3 tm, CModelDataStruct* pModelData, bool SaveNonIndexed)
{
if(!Options.GenNormalsVA){return;}

UINT NumVerts = pModelData->IndexedVerticesCount;
UINT NumFaces = pModelData->FacesCount;

int Indx[3];
CVector3 vVector1, vVector2, vNormal, vPoly[3];

//Allocate memory for our normals and the shared info
CVector3 *pVertexNormals = new CVector3[NumVerts];
int *pShared = new int[NumVerts];
//Initialize our array
ZeroMemory(pVertexNormals, sizeof(CVector3) * NumVerts);
ZeroMemory(pShared, sizeof(int) * NumVerts);

///////////////////////////////////////////////////////////////////////////////
//Here we'll compute normals(this new algorithm of mine is BLAZING FAST!)...
///////////////////////////////////////////////////////////////////////////////

// Go though all of the faces of this object
UINT i = 0;
for(i = 0; i < NumFaces; i++){	

//Read the 3 face vertex
for(int j = 0; j < 3; j++){
Indx[j] = pMesh->faces[i].v[j];
Point3 v = (tm * pMesh->verts[Indx[j]]);
vPoly[j].Set(v.x, v.z, 0.0f - v.y);	
}

// Now let's calculate the face normals (Get 2 vectors and find the cross product of those 2)
vVector1 = _Vector(vPoly[0], vPoly[2]);	// Get the vector of the polygon (we just need 2 sides for the normal)
vVector2 = _Vector(vPoly[2], vPoly[1]);	// Get a second vector of the polygon

//This get our FACE normals
vNormal = _Cross(vVector1, vVector2);	// Return the cross product of the 2 vectors (normalize vector, but not a unit vector)

//Accum the value for the 3 VERTEX normals and keep track of a shared value
#ifdef _VS2010_
int j = 0;
#endif
for(j = 0; j < 3; j++){
pVertexNormals[Indx[j]] = _AddVector(pVertexNormals[Indx[j]], vNormal);
pShared[Indx[j]]++;
}
}

///////////////////////////////////////////////////////////////////////////////////////

#ifdef WRITE_TEXT_OUTPUT
char Buf[128];
ZeroMemory(&Buf[0], 128);
sprintf(&Buf[0], "Vertex Normals: {\n");
fputs(&Buf[0], TextOutF);
#endif

// Now Get The Vertex Normals and save them
for(i = 0; i < NumVerts; i++){	
pVertexNormals[i] = _DivideVectorByScaler(pVertexNormals[i], float(-pShared[i]));
pVertexNormals[i] = _Normalize(pVertexNormals[i]);	
memcpy(&pModelData->pNormalsArray[VA_INDEXED][i], &pVertexNormals[i].x, sizeof(float3));

#ifdef WRITE_TEXT_OUTPUT
sprintf(&Buf[0], " {%.4f, %.4f, %.4f},\n", pVertexNormals[i].x, pVertexNormals[i].y, pVertexNormals[i].z);
fputs(&Buf[0], TextOutF);
#endif
}

#ifdef WRITE_TEXT_OUTPUT
sprintf(&Buf[0], "}\n\n");
fputs(&Buf[0], TextOutF);
#endif

///////////////////////////////////////////////////////////////////////////////////////

// Delete temp buffers
SAFE_DELETE_ARRAY(pShared);
SAFE_DELETE_ARRAY(pVertexNormals);

if(SaveNonIndexed){
if(Options.ForceSmoothNormals){
ConvertToNonIndexed((BYTE*)pModelData->pNormalsArray[VA_NON_INDEXED], (BYTE*)pModelData->pNormalsArray[VA_INDEXED], sizeof(float3), pModelData);
} else {
SaveFacesNormals(pMesh, tm, pModelData);
}
}
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Save the face normals
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Model3DExport::SaveFacesNormals(Mesh* pMesh, Matrix3 tm, CModelDataStruct* pModelData, bool SaveNonIndexed)
{
if(!Options.GenNormalsVA){return;}

#ifdef WRITE_TEXT_OUTPUT
char Buf[128];
ZeroMemory(&Buf[0], 128);
sprintf(&Buf[0], "Faces Normals: {\n");
fputs(&Buf[0], TextOutF);
#endif

UINT NumVerts = pModelData->VerticesCount;
UINT NumFaces = pModelData->FacesCount;

CVector3 vVector1, vVector2, vNormal, vPoly[3];
int Indx[3];

// Go though all of the faces of this object
for(UINT i = 0; i < NumFaces; i++){	

//Read the 3 face vertex
for(int j = 0; j < 3; j++){
Indx[j] = pMesh->faces[i].v[j];
Point3 v = (tm * pMesh->verts[Indx[j]]);
vPoly[j].Set(v.x, v.z, 0.0f - v.y);	
}

// Now let's calculate the face normals (Get 2 vectors and find the cross product of those 2)
vVector1 = _Vector(vPoly[0], vPoly[2]);	// Get the vector of the polygon (we just need 2 sides for the normal)
vVector2 = _Vector(vPoly[2], vPoly[1]);	// Get a second vector of the polygon

//This get our FACE normals
vNormal = _Cross(vVector1, vVector2);	// Return the cross product of the 2 vectors (normalize vector, but not a unit vector)

vNormal = _DivideVectorByScaler(vNormal, -1.0f);
vNormal = _Normalize(vNormal);	

//Save them in our FACE normals array
memcpy(&pModelData->pNormalsArray[VA_NON_INDEXED][(i * 3) ], &vNormal.x, sizeof(float3));
memcpy(&pModelData->pNormalsArray[VA_NON_INDEXED][(i * 3)+1], &vNormal.x, sizeof(float3));
memcpy(&pModelData->pNormalsArray[VA_NON_INDEXED][(i * 3)+2], &vNormal.x, sizeof(float3));
#ifdef WRITE_TEXT_OUTPUT
sprintf(&Buf[0], " {%.4f, %.4f, %.4f},\n", vNormal.x, vNormal.x, vNormal.x);
fputs(&Buf[0], TextOutF);
#endif
}
#ifdef WRITE_TEXT_OUTPUT
sprintf(&Buf[0], "}\n\n");
fputs(&Buf[0], TextOutF);
#endif
}


Somehow, copy/paste ate the tabs...

 

Here's the full source code if your interested. Most stuffs in the 2 last functions are useless for you so you gonna have to clean that up smile.png

The bottom one calculate face normals, and the one before that calculate per-vertex normals.

 

I really should refactor that old code... but if it ain't broke, don't fix it? ph34r.png

 

EDIT: Also, i noticed you're calling glEnable(GL_TEXTURE_2D) but not glEnable(GL_LIGHTING), though i havent done modern opengl so i don't know if that's an error or not. Just wanted to point it out.

Edited by Vortez

Share this post


Link to post
Share on other sites
ajm113    355

I tried your example of calculating face normals, but the only result I'm getting is that two triangles lit up in odd directions... I'm wondering if it's the way I'm creating the cube, thats the problem. Even though the triangles show up normal, the normals are not and I appear to be using the correct GL calls. I.E GL_LIGHTING, GL_NORMALIZE, etc...

Share this post


Link to post
Share on other sites
ajm113    355

I did realize however just now I should be calling GL_BLEND. So now a lot more triangles light up, but it appears the normals are still a bit messed up. =/

Share this post


Link to post
Share on other sites
ajm113    355

Well it very well just could be how I'm using glNormalPointer, because I used the down and dirty method to draw a plane with two triangles, and it looked perfectly fine! D: FAIL! If someone can tell me why this could be that would be nice!

 

I.E How it should look to OpenGL.

//Draw plane...
glBegin(GL_TRIANGLES);
glNormal3f(normals[0], normals[1], normals[2]);
//Draw triangle...
glVertex3f(...);
glNormal3f(normals[3], normals[4], normals[5]);
//Draw another triangle...
glVertex3f(...);

glEnd();
Edited by ajm113

Share this post


Link to post
Share on other sites
Vortez    2714

I noticed also in your first example, you are calling glTexCoordPointer(2, GL_FLOAT, 0, UV_Coords); without first calling glEnableClientState, and i dont see what glBlend had to do with normals. My guess is some of your triangles are drawn in the wrong order, (clockwise or counterclockwise, i never remember wich one is used by default, but they should all use the same winding order)

Edited by Vortez

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this  

  • Similar Content

    • By povilaslt2
      Hello. I'm Programmer who is in search of 2D game project who preferably uses OpenGL and C++. You can see my projects in GitHub. Project genre doesn't matter (except MMO's :D).
    • By ZeldaFan555
      Hello, My name is Matt. I am a programmer. I mostly use Java, but can use C++ and various other languages. I'm looking for someone to partner up with for random projects, preferably using OpenGL, though I'd be open to just about anything. If you're interested you can contact me on Skype or on here, thank you!
      Skype: Mangodoor408
    • By tyhender
      Hello, my name is Mark. I'm hobby programmer. 
      So recently,I thought that it's good idea to find people to create a full 3D engine. I'm looking for people experienced in scripting 3D shaders and implementing physics into engine(game)(we are going to use the React physics engine). 
      And,ye,no money =D I'm just looking for hobbyists that will be proud of their work. If engine(or game) will have financial succes,well,then maybe =D
      Sorry for late replies.
      I mostly give more information when people PM me,but this post is REALLY short,even for me =D
      So here's few more points:
      Engine will use openGL and SDL for graphics. It will use React3D physics library for physics simulation. Engine(most probably,atleast for the first part) won't have graphical fron-end,it will be a framework . I think final engine should be enough to set up an FPS in a couple of minutes. A bit about my self:
      I've been programming for 7 years total. I learned very slowly it as "secondary interesting thing" for like 3 years, but then began to script more seriously.  My primary language is C++,which we are going to use for the engine. Yes,I did 3D graphics with physics simulation before. No, my portfolio isn't very impressive. I'm working on that No,I wasn't employed officially. If anybody need to know more PM me. 
       
    • By Zaphyk
      I am developing my engine using the OpenGL 3.3 compatibility profile. It runs as expected on my NVIDIA card and on my Intel Card however when I tried it on an AMD setup it ran 3 times worse than on the other setups. Could this be a AMD driver thing or is this probably a problem with my OGL code? Could a different code standard create such bad performance?
    • By Kjell Andersson
      I'm trying to get some legacy OpenGL code to run with a shader pipeline,
      The legacy code uses glVertexPointer(), glColorPointer(), glNormalPointer() and glTexCoordPointer() to supply the vertex information.
      I know that it should be using setVertexAttribPointer() etc to clearly define the layout but that is not an option right now since the legacy code can't be modified to that extent.
      I've got a version 330 vertex shader to somewhat work:
      #version 330 uniform mat4 osg_ModelViewProjectionMatrix; uniform mat4 osg_ModelViewMatrix; layout(location = 0) in vec4 Vertex; layout(location = 2) in vec4 Normal; // Velocity layout(location = 3) in vec3 TexCoord; // TODO: is this the right layout location? out VertexData { vec4 color; vec3 velocity; float size; } VertexOut; void main(void) { vec4 p0 = Vertex; vec4 p1 = Vertex + vec4(Normal.x, Normal.y, Normal.z, 0.0f); vec3 velocity = (osg_ModelViewProjectionMatrix * p1 - osg_ModelViewProjectionMatrix * p0).xyz; VertexOut.velocity = velocity; VertexOut.size = TexCoord.y; gl_Position = osg_ModelViewMatrix * Vertex; } What works is the Vertex and Normal information that the legacy C++ OpenGL code seem to provide in layout location 0 and 2. This is fine.
      What I'm not getting to work is the TexCoord information that is supplied by a glTexCoordPointer() call in C++.
      Question:
      What layout location is the old standard pipeline using for glTexCoordPointer()? Or is this undefined?
       
      Side note: I'm trying to get an OpenSceneGraph 3.4.0 particle system to use custom vertex, geometry and fragment shaders for rendering the particles.
  • Popular Now