[OpenGL] HOW TO map-texture a subdivided icosahedron with VBOs?

bjlotus

[OpenGL] HOW TO map-texture a subdivided icosahedron with VBOs?

in Contributed Library Questions • 11 months ago

Hello there,

I'm starting with opengl and, after playing with GLGraphics, I became interested on learning a bit more about opengl.

What I'm trying to do sounds simple, but I'm getting some trouble with textures.

I'm basically computing a subdivided icosahedron, which after 3 o 4 subdivisions looks like a sphere. Then, I'm drawing this model using VBOs. This part works OK... but when i try to get it textured, the results are terrible. I'm not sure if the problem is on how I'm calculating the tex coords or the opengl calls.

This is what i got so far. Any ideas?

import processing.opengl.*; //OPENGL
import javax.media.opengl.*; // USE OF OPENGL DIRECTLY
import java.nio.FloatBuffer; //FLOATBUFFERS
import java.nio.IntBuffer; //INTBUFFERS
import com.sun.opengl.util.BufferUtil; //BUFFERS
//import com.sun.opengl.util.texture.*; //TEXTURES
import codeanticode.glgraphics.*;
PGraphicsOpenGL pgl;
GL gl;
//icosahedron
Ico ico;
//just a var for rotation testing
int rot = 0;
//texture
GLTexture tex;
void setup() {
size(800, 600, OPENGL);
frameRate(60);
pgl = (PGraphicsOpenGL) g; // g may change
gl = pgl.gl;
//buffers
int[] bufferID = new int[3];
gl.glGenBuffers(3, bufferID, 0);
//new icosahedron (lvl of subdivisions <0= regular icosahedron>), verts buffer, indices buffer, tex buffer)
ico = new Ico(2, bufferID[0], bufferID[1], bufferID[2]);
//load an img
tex = new GLTexture(this, "nebula.jpg");
}
void draw() {
frame.setTitle(str(frameRate));
background(100);
//rotation
rot++;
if (rot == 360) {
rot = 0;
}
//OpenGL calls
pgl = (PGraphicsOpenGL) g; // g may change
gl = pgl.gl;
pgl.beginGL();
setLghts(gl); //just some lights, nothing relevant
gl.glPushMatrix();
gl.glTranslatef(width/2, height/2, 0);
gl.glRotatef(rot, 1, 1, 0);
gl.glEnable(gl.GL_NORMALIZE);
gl.glScalef(50, 50, 50);
//VBO's
//set current VBO (vertices)
gl.glBindBuffer(GL.GL_ARRAY_BUFFER, ico.vertBufferID);
//supply data to the current VBO --- glBufferData(int target, int size(in bytes), Buffer data, int usage)
//size*4, since 1 float = 4 bytes.
gl.glBufferData(GL.GL_ARRAY_BUFFER, ico.vertCont*4, ico.vertBuffer, GL.GL_STATIC_DRAW);
gl.glVertexPointer(3, GL.GL_FLOAT, 0, 0);
gl.glNormalPointer(GL.GL_FLOAT, 0, 0);
//tex -----
gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY);
gl.glEnable(GL.GL_TEXTURE_2D);
gl.glBindTexture(gl.GL_TEXTURE_2D, tex.getTextureID());
gl.glBindBuffer(GL.GL_ARRAY_BUFFER, ico.texBufferID);
gl.glTexCoordPointer(2, GL.GL_FLOAT, 0, 0);
//---------
//leave no buffer ID bound.
gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
//set current VBO (indices)
gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, ico.indBufferID);
gl.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, ico.indCont*4, ico.indBuffer, GL.GL_STATIC_DRAW);
//leave no buffer ID bound.
gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
gl.glEnableClientState(GL.GL_VERTEX_ARRAY);
gl.glEnableClientState(GL.GL_NORMAL_ARRAY);
// Draw the triangles using the indices VBO
gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, ico.indBufferID);
gl.glDrawElements(GL.GL_TRIANGLES, ico.indCont, GL.GL_UNSIGNED_INT, 0);
//leave no buffer ID bound.
gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
gl.glDisableClientState(GL.GL_VERTEX_ARRAY);
gl.glDisableClientState(GL.GL_NORMAL_ARRAY);
gl.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY);
gl.glPopMatrix();
pgl.endGL();
}

The Icosahedron class (I wrote it following the "red book" and different approaches I found around)

class Ico{
float[][] vertices; //vertices
int[][] indices; //indices
ArrayList<Float> vertAL; //AL vertices
ArrayList<Integer> indAL; //AL indices
int vertCont, indCont, lvl; //vertices/indices count, subdivide level
int vertBufferID; //Buffer ID vertices
int indBufferID; //Buffer ID indices
int texBufferID; //Buffer ID texturas
FloatBuffer vertBuffer; //Buffer vertices
IntBuffer indBuffer; //Buffer indices
FloatBuffer texBuffer; //Buffer texturas
//CONSTRUCTOR
//computes the icosahedron data (normals and vertices are the same)
Ico(int lvl, int vertBufferID, int indBufferID, int texBufferID){
this.lvl = lvl;
this.vertBufferID = vertBufferID;
this.indBufferID = indBufferID;
this.texBufferID = texBufferID;
vertAL = new ArrayList<Float>();
indAL = new ArrayList<Integer>();
float x = .525731112119133606;
float z = .850650808352039932;
//vertices
vertices = new float[][] {
{-x, 0.0, z}, {x, 0.0, z}, {-x, 0.0, -z}, {x, 0.0, -z},
{0.0, z, x}, {0.0, z, -x}, {0.0, -z, x}, {0.0, -z, -x},
{z, x, 0.0}, {-z, x, 0.0}, {z, -x, 0.0}, {-z, -x, 0.0}
};
//indices
indices = new int[][] {
{0,4,1}, {0,9,4}, {9,5,4}, {4,5,8}, {4,8,1},
{8,10,1}, {8,3,10}, {5,3,8}, {5,2,3}, {2,7,3},
{7,10,3}, {7,6,10}, {7,11,6}, {11,0,6}, {0,1,6},
{6,1,10}, {9,0,11}, {9,11,2}, {9,2,5}, {7,2,11}
};
//add vertices to ArrayList
for (float[] v : vertices) {
vertAL.add(v[0]); vertAL.add(v[1]); vertAL.add(v[2]);
}
//subdivide each face as many times lvl
for (int[] f: indices) {
subdivide(f[0], f[1], f[2], vertAL, indAL, lvl);
}
//vertices and indices count
vertCont = vertAL.size();
indCont = indAL.size();
//vertices Buffer
vertBuffer = BufferUtil.newFloatBuffer(vertCont);
for (float v : vertAL){ vertBuffer.put(v); }
vertBuffer.rewind();
//indices Buffer
indBuffer = BufferUtil.newIntBuffer(indCont);
for (int i : indAL){ indBuffer.put(i); }
indBuffer.rewind();
//texture coords Buffer
texBuffer = BufferUtil.newFloatBuffer(vertCont*2); //nro. de caras * 3 vert * 2 uv cords
for (int i=0; i<vertCont; i+=3){
//get point
float[]punto = new float[]{vertAL.get(i), vertAL.get(i+1), vertAL.get(i+2)};
//calculate u and v
float[] uv = calcTexCoord(punto);
texBuffer.put(uv[0]);
texBuffer.put(uv[1]);
}
texBuffer.rewind();
}
// Given a point P on a unit sphere, calculate texture coords [u, v]
float[] calcTexCoord(float[] P){
// using spherical coords
// a is the angle from z axis [0, pi]
// t is the angle from x-axis [0, 2pi]
float a, t;
a = acos(P[2]);
float tmp = sin(a);
// check for poles
if(Math.abs(tmp) < 0.001) {
t = 0.0;
}
else {
float tmp2 = P[0]/tmp;
// clamp to [-1, 1] - due to small numerical errors
tmp2 = Math.min(Math.max(tmp2, -1.0), 1.0);
t = acos(tmp2);
if(P[1] < 0.0) {
t = 2.0*PI - t;
}
}
// convert to [0, 1]
float v = 1.0 - a/PI;
float u = t/(2.0*PI);
return new float[]{u, v};
}
//faces subdivision
void subdivide(int v1, int v2, int v3, ArrayList<Float> vertices, ArrayList<Integer> faces, int level) {
if (level == 0) {
faces.add(v1);
faces.add(v2);
faces.add(v3);
}
else {
float a1 = (vertices.get(3*v1) + vertices.get(3*v2));
float a2 = (vertices.get(3*v1+1) + vertices.get(3*v2+1));
float a3 = (vertices.get(3*v1+2) + vertices.get(3*v2+2));
float length = (float)Math.sqrt(a1*a1+a2*a2+a3*a3);
a1 /= length;
a2 /= length;
a3 /= length;
int indexA = vertices.size()/3;
vertices.add(a1);
vertices.add(a2);
vertices.add(a3);
float b1 = (vertices.get(3*v3) + vertices.get(3*v2));
float b2 = (vertices.get(3*v3+1) + vertices.get(3*v2+1));
float b3 = (vertices.get(3*v3+2) + vertices.get(3*v2+2));
length = (float)Math.sqrt(b1*b1+b2*b2+b3*b3);
b1 /= length;
b2 /= length;
b3 /= length;
int indexB = vertices.size()/3;
vertices.add(b1);
vertices.add(b2);
vertices.add(b3);
float c1 = (vertices.get(3*v1) + vertices.get(3*v3));
float c2 = (vertices.get(3*v1+1) + vertices.get(3*v3+1));
float c3 = (vertices.get(3*v1+2) + vertices.get(3*v3+2));
length = (float)Math.sqrt(c1*c1+c2*c2+c3*c3);
c1 /= length;
c2 /= length;
c3 /= length;
int indexC = vertices.size()/3;
vertices.add(c1);
vertices.add(c2);
vertices.add(c3);
subdivide(v1,indexA,indexC,vertices,faces,level-1);
subdivide(indexA,v2,indexB,vertices,faces,level-1);
subdivide(indexC,indexB,v3,vertices,faces,level-1);
subdivide(indexA,indexB,indexC,vertices,faces,level-1);
}
}
}

Without textures, the model displays perfect.

It'd be great to have some input from you guys, any correction/suggestion/tip/advice would be gladly welcome.

Thanks in advance!

Replies(11)

amnon.owed

Re: [OpenGL] HOW TO map-texture a subdivided icosahedron with VBOs?

11 months ago

When trying to run your code I get an error on the line with setLghts(gl); When removing that line the code runs, but I don't see anything, except for a grey screen. Also I noticed you are not using the GLGraphics renderer. Also, are you sure you want to do this with direct opengl calls? The GLGraphics library was designed to make your life simpler by wrapping some of those functionalities into helper classes. For example, in this case, the GLModel class.

bjlotus

Re: [OpenGL] HOW TO map-texture a subdivided icosahedron with VBOs?

11 months ago

Hi there,

Thanks for replying. I didn't include the setLights() function, it just calls some lights :). If you run the code including an img. texture, you should see the model. Maybe set some quick lights on it.

Regarding GLGraphics: I've been playing with it, but i got stucked with this issue. Andrés already posted some hours ago it's a bug, and though there's a small workaround which works with the standard GLGraphics lights (I tested this a minute ago), I couln't set some specific lights, i.e. the ones described here. Also tried to map textures on this GLModel, but the results were similar... thou it was like a week ago and probably the texcoords also were incorrect.

So, this was my first attempt to set everything mannualy (trying to learn a bit at the same time). The only thing I can't figure out is how to map the textures.

Here's a pde with the icosahedron, without the texture code i posted. It's a bit messy since it's just a test.

amnon.owed

Re: [OpenGL] HOW TO map-texture a subdivided icosahedron with VBOs?

11 months ago

I've been playing around with this, learning a bit about creating vbo's manually. Unfortunately I'm as much a beginner in this area as you, so I can't be of much assistance. However from what I've read I think (disclaimer!) there are some problems with your code:

You do almost everything in draw() including sending data to the vbo over and over again. This defeats the purpose of the vbo. You only need to send most of that stuff to the GPU once and then you can use it.
Despite references to normals, there are actually no normals sent to the vbo.
Currently there is no working link between the texture coordinates generated and the texture coordinates used by the vbo. This is probably the biggest problem and unfortunately I haven't been able to solve it either. Once there is an actual connection, it remains to be seen if the texcoords themselves are all right, but at the moment the opengl calls are the more immediate problem in my opinion.

bjlotus

Re: [OpenGL] HOW TO map-texture a subdivided icosahedron with VBOs?

11 months ago

Hey Amnon, thanks for passin by again.

Regarding what you´re saying:

1. I set the buffers when computing the model, the calls I´m doing in the draw are part of the render process i think (binding buffers and get the data to be drawn). I´m new to this, so i might be wrong.

2. Normals are set using the vetex data. With these sperical models, the normals and the vertex are the same normalized values. Therefore, there´s no need to create a separate buffer for this model specifically. In fact, if you run the pde i posted, you should see the lights working perfectly on the model, which indicates normals are ok.

3. This is the main problem i guess. The link exists, since it displays (horribly) part of the texture randomly. I´m binding the the texcoords buffer and enabling the texture for use. In fact if I use enviroment mapping (which doesn´t rely in texcoord, opengl calculates it), using something like:

gl.glTexGeni(GL.GL_S, GL.GL_TEXTURE_GEN_MODE, GL.GL_SPHERE_MAP);
gl.glTexGeni(GL.GL_T, GL.GL_TEXTURE_GEN_MODE, GL.GL_SPHERE_MAP);
gl.glEnable(GL.GL_TEXTURE_GEN_S);
gl.glEnable(GL.GL_TEXTURE_GEN_T);

you should see the texture mapped, but this is a different approach, usefull to simulate a reflection.,

I don´t wanna give up on this, i´ll keep on trying. Let me know by the way if figure out something ;)

Cheers,

amnon.owed

Re: [OpenGL] HOW TO map-texture a subdivided icosahedron with VBOs?

11 months ago

Well, let me add my $0.02 again.

1. The only line you really need in draw is glDrawElements. However many of the other are neat to use as well. The main problematic lines which I was talking about are the glBufferData lines. I believe those lines send data to the GPU. And so they could/should be only done once. See my adapted code (so far) below.

2. Could be. Indeed I don't think the normals are the problem here. Just something I noticed.

3. I didn't say there is no link with texture, I said there is no link with texture coordinates. Try setting all your coordinates to 0,0 or 1,1. The image will look the same (also see my code unfortunately). So really the texture coordinates are not getting through. However the texture itself is indeed display, I have no idea where it's getting it's texture coordinates from...

For clarity let me just post what I have, even though it's not working correctly either. I will give it a shot again. I was also contemplating on using the vertex, indices and texture coords with a GLModel to see if that works.

Main tab

import processing.opengl.*;
import javax.media.opengl.*;
import com.sun.opengl.util.BufferUtil;
import java.nio.*;
import codeanticode.glgraphics.*;
PGraphicsOpenGL pgl;
GL gl;
Icosahedron ico;
int rot;
void setup(){
size(800, 600, OPENGL);
pgl = (PGraphicsOpenGL) g;
gl = pgl.gl;
ico = new Icosahedron(this, 2);
}
void draw(){
frame.setTitle(int(frameRate) + " fps");
pgl.beginGL();
gl.glClearColor(0.0, 0.0, 0.0, 1.0);
gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
gl.glEnable(GL.GL_LIGHTING);
gl.glEnable(GL.GL_LIGHT0);
gl.glLightfv(GL.GL_LIGHT0, GL.GL_SPECULAR, new float[] { 1, 1, 1, 1 }, 0);
gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, new float[] {-1000, 600, 2000, 0 }, 0);
if (mousePressed) { if (mouseButton == LEFT) { rot++; } else if (mouseButton == RIGHT) { rot--; } }
ico.display(width/2, height/2, 0, rot % 360, 10+mouseX);
pgl.endGL();
}

Icosahedron class

class Icosahedron {
int vertCount, indCount, texCount;
int vertBufferID, indBufferID, texBufferID;
FloatBuffer vertBuffer;
IntBuffer indBuffer;
FloatBuffer texBuffer;
float dr, dg, db;
GLTexture tex;
Icosahedron(PApplet parent, int level){
tex = new GLTexture(parent, "UV.jpg");
int[] bufferID = new int[3];
gl.glGenBuffers(3, bufferID, 0);
vertBufferID = bufferID[0];
indBufferID = bufferID[1];
texBufferID = bufferID[2];
ArrayList <Float> vertAL = new ArrayList <Float> ();
ArrayList <Integer> indAL = new ArrayList <Integer> ();
float x = .525731112119133606;
float z = .850650808352039932;
float[][] vertices = new float[][] {
{-x, 0.0, z}, {x, 0.0, z}, {-x, 0.0, -z}, {x, 0.0, -z},
{0.0, z, x}, {0.0, z, -x}, {0.0, -z, x}, {0.0, -z, -x},
{z, x, 0.0}, {-z, x, 0.0}, {z, -x, 0.0}, {-z, -x, 0.0}
};
int[][] indices = new int[][] {
{0,4,1}, {0,9,4}, {9,5,4}, {4,5,8}, {4,8,1},
{8,10,1}, {8,3,10}, {5,3,8}, {5,2,3}, {2,7,3},
{7,10,3}, {7,6,10}, {7,11,6}, {11,0,6}, {0,1,6},
{6,1,10}, {9,0,11}, {9,11,2}, {9,2,5}, {7,2,11}
};
for (float[] v : vertices) {
vertAL.add(v[0]); vertAL.add(v[1]); vertAL.add(v[2]);
}
for (int[] f: indices) {
subdivide(f[0], f[1], f[2], vertAL, indAL, level);
}
vertCount = vertAL.size();
indCount = indAL.size();
texCount = vertCount / 3 * 2;
vertBuffer = BufferUtil.newFloatBuffer(vertCount);
for (float v : vertAL){ vertBuffer.put(v); }
vertBuffer.rewind();
indBuffer = BufferUtil.newIntBuffer(indCount);
for (int i : indAL){ indBuffer.put(i); }
indBuffer.rewind();
texBuffer = BufferUtil.newFloatBuffer(texCount);
for (int i=0; i<vertCount; i+=3){
PVector vert = new PVector(vertAL.get(i), vertAL.get(i+1), vertAL.get(i+2));
vert.normalize();
float[] uv = getTextureCoord(vert);
texBuffer.put(uv[0]);
texBuffer.put(uv[1]);
}
texBuffer.rewind();
initVBO();
}
void subdivide(int v1, int v2, int v3, ArrayList<Float> vertices, ArrayList<Integer> faces, int level) {
if (level == 0) {
faces.add(v1);
faces.add(v2);
faces.add(v3);
} else {
float a1 = (vertices.get(3*v1) + vertices.get(3*v2));
float a2 = (vertices.get(3*v1+1) + vertices.get(3*v2+1));
float a3 = (vertices.get(3*v1+2) + vertices.get(3*v2+2));
float length = sqrt(a1*a1+a2*a2+a3*a3);
a1 /= length;
a2 /= length;
a3 /= length;
int indexA = vertices.size()/3;
vertices.add(a1);
vertices.add(a2);
vertices.add(a3);
float b1 = (vertices.get(3*v3) + vertices.get(3*v2));
float b2 = (vertices.get(3*v3+1) + vertices.get(3*v2+1));
float b3 = (vertices.get(3*v3+2) + vertices.get(3*v2+2));
length = sqrt(b1*b1+b2*b2+b3*b3);
b1 /= length;
b2 /= length;
b3 /= length;
int indexB = vertices.size()/3;
vertices.add(b1);
vertices.add(b2);
vertices.add(b3);
float c1 = (vertices.get(3*v1) + vertices.get(3*v3));
float c2 = (vertices.get(3*v1+1) + vertices.get(3*v3+1));
float c3 = (vertices.get(3*v1+2) + vertices.get(3*v3+2));
length = sqrt(c1*c1+c2*c2+c3*c3);
c1 /= length;
c2 /= length;
c3 /= length;
int indexC = vertices.size()/3;
vertices.add(c1);
vertices.add(c2);
vertices.add(c3);
subdivide(v1,indexA,indexC,vertices,faces,level-1);
subdivide(indexA,v2,indexB,vertices,faces,level-1);
subdivide(indexC,indexB,v3,vertices,faces,level-1);
subdivide(indexA,indexB,indexC,vertices,faces,level-1);
}
}
float[] getTextureCoord(PVector normal) {
float targetU;
float targetV;
float normalisedX = 0;
float normalisedZ = -1;
if (((normal.x * normal.x) + (normal.z * normal.z)) > 0) {
normalisedX = sqrt((normal.x * normal.x) / ((normal.x * normal.x) + (normal.z * normal.z)));
if (normal.x < 0) { normalisedX = -normalisedX; }
normalisedZ = sqrt((normal.z * normal.z) / ((normal.x * normal.x) + (normal.z * normal.z)));
if (normal.z < 0) { normalisedZ = -normalisedZ; }
}
if (normalisedZ == 0) {
targetU = (normalisedX * PI) / 2;
} else {
targetU = atan(normalisedX / normalisedZ);
if (normalisedZ < 0) { targetU += PI; }
}
if (targetU < 0) { targetU += 2 * PI; }
targetU /= 2 * PI;
targetV = (-normal.y + 1) / 2;
return new float[] { targetU, targetV };
}
void initVBO() {
gl.glBindBuffer(GL.GL_ARRAY_BUFFER, vertBufferID);
gl.glBufferData(GL.GL_ARRAY_BUFFER, vertCount*4, vertBuffer, GL.GL_STATIC_DRAW);
gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, indBufferID);
gl.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, indCount*4, indBuffer, GL.GL_STATIC_DRAW);
gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
gl.glEnable(GL.GL_TEXTURE_2D);
gl.glEnable(gl.GL_NORMALIZE);
gl.glShadeModel(gl.GL_FLAT);
}
void display(float tx, float ty, float tz, int rot, float sc) {
gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SPECULAR, new float[] { 1.0, 1.0, 1.0, 1.0 }, 0);
gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT, new float[] { 0.1, 0.1, 0.1, 1.0 }, 0);
gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_EMISSION, new float[] { 0.0, 0.0, 0.0, 1.0 }, 0);
gl.glMaterialf( GL.GL_FRONT_AND_BACK, GL.GL_SHININESS, 16.0);
gl.glPushMatrix();
gl.glTranslatef(tx, ty, tz);
gl.glRotatef(rot, 1, 1, 0);
gl.glScalef(sc, sc, sc);
gl.glBindBuffer(GL.GL_ARRAY_BUFFER, vertBufferID);
gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, indBufferID);
gl.glBindTexture(gl.GL_TEXTURE_2D, tex.getTextureID());
gl.glEnableClientState(GL.GL_VERTEX_ARRAY);
gl.glEnableClientState(GL.GL_NORMAL_ARRAY);
gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY);
gl.glVertexPointer(3,GL.GL_FLOAT, 0, 0);
gl.glNormalPointer(GL.GL_FLOAT, 0, 0);
gl.glTexCoordPointer(2, GL.GL_FLOAT, 0, 0);
gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE);
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR);
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR);
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT);
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT);
gl.glDrawElements(GL.GL_TRIANGLES, indCount, GL.GL_UNSIGNED_INT, 0);
gl.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY);
gl.glDisableClientState(GL.GL_NORMAL_ARRAY);
gl.glDisableClientState(GL.GL_VERTEX_ARRAY);
gl.glPopMatrix();
}
}

bjlotus

Re: [OpenGL] HOW TO map-texture a subdivided icosahedron with VBOs?

11 months ago

Hi Amnon,

1. I think you´re right about this. I´ve basically took those lines from java examples and noticed they used it on each render loop... Anyway, your code runs perfect. Nice cleaning by the way :)

Just a question, If you generate the buffer IDs inside the class, won´t that generate any problem when loading several models?

3. At least you got all the faces mapped! heh.. the only thing I noticed here is that, when you set those glTexParameterf, you´re defining some opengl modes to map the model, therefore (I think i´ve read this somewhere) the texcoords are automatically defined by opengl, ignoring the ones we set on the buffer. Note that if you comment/erase the getTextureCoord function and the loop populating the buffer, the result is the same.

I´ll try to investigate a little more about it.

Thank you!

amnon.owed

Re: [OpenGL] HOW TO map-texture a subdivided icosahedron with VBOs?

11 months ago

With regard to your points. Generating IDs inside the class doesn't create problems, because it will still generate increasing IDs. I've tried it with multiple instances and it works fine. Indeed the tex coords are still the big problem. In my code there wasn't yet a line that sends the coords to the vbo (the ones I tried didn't work anyway), so it's still on the tdl.

Haven't had time to look into this further yet, but for future reference let me just post a link to a clean implementation of the icosahedron in Cinder here that perhaps could be used/ported.

bjlotus

Re: [OpenGL] HOW TO map-texture a subdivided icosahedron with VBOs?

11 months ago

Good, that's what I thought when I read your code, but couldn't test it until now (been at university for hoursss...).

I'll check that link. If I miraculously get this to work I'll come back and post it.

Thanks for your time Amnon.

*****EDIT*****

ALMOST THERE!

not perfect thoug, there's a big seam on the texture (I've read about this problem before here, so i'll try to figure it out).

Here's what I changed, based on your mods. The initVBO:

void initVBO() {
//bind and set data for vertices
gl.glBindBuffer(GL.GL_ARRAY_BUFFER, vertBufferID);
gl.glBufferData(GL.GL_ARRAY_BUFFER, vertCount*4, vertBuffer, GL.GL_STATIC_DRAW);
gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
int texCount = (2*vertCount)/3;
//bind and set data for textures
gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, texBufferID);
gl.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, texCount*4, texBuffer, GL.GL_STATIC_DRAW);
gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
//bind and set data for indices
gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, indBufferID);
gl.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, indCount*4, indBuffer, GL.GL_STATIC_DRAW);
gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
//tex enable + normalize normals for scaling + flat lights
gl.glEnable(GL.GL_TEXTURE_2D);
gl.glEnable(gl.GL_NORMALIZE);
gl.glShadeModel(gl.GL_FLAT);
}

and the display()... (note I commented the texture parameters):

void display(float tx, float ty, float tz, int rot, float sc) {
gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SPECULAR, new float[] { 1.0, 1.0, 1.0, 1.0 }, 0);
gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT, new float[] { 0.1, 0.1, 0.1, 1.0 }, 0);
gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_EMISSION, new float[] { 0.0, 0.0, 0.0, 1.0 }, 0);
gl.glMaterialf( GL.GL_FRONT_AND_BACK, GL.GL_SHININESS, 16.0);
gl.glPushMatrix();
gl.glTranslatef(tx, ty, tz);
gl.glRotatef(rot, 1, 1, 0);
gl.glScalef(sc, sc, sc);
//bind vertices buffer and set the vertices/normals pointer
gl.glBindBuffer(GL.GL_ARRAY_BUFFER, vertBufferID);
gl.glVertexPointer(3,GL.GL_FLOAT, 0, 0);
gl.glNormalPointer(GL.GL_FLOAT, 0, 0);
gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
//bind texture buffer and pointer
gl.glBindBuffer(GL.GL_ARRAY_BUFFER, texBufferID);
gl.glTexCoordPointer(2, GL.GL_FLOAT, 0, 0);
gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
//enable texture
gl.glBindTexture(gl.GL_TEXTURE_2D, tex.getTextureID());
gl.glEnableClientState(GL.GL_VERTEX_ARRAY);
gl.glEnableClientState(GL.GL_NORMAL_ARRAY);
gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY);
//gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE);
//gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR);
//gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR);
//gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT);
//gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT);
//bind indices buffer and draw
gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, indBufferID);
gl.glDrawElements(GL.GL_TRIANGLES, indCount, GL.GL_UNSIGNED_INT, 0);
gl.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY);
gl.glDisableClientState(GL.GL_NORMAL_ARRAY);
gl.glDisableClientState(GL.GL_VERTEX_ARRAY);
gl.glPopMatrix();
}

Thanks for pointing me in the right direction... let's see if I can get rid of that seam.

amnon.owed

Re: [OpenGL] HOW TO map-texture a subdivided icosahedron with VBOs?

11 months ago

Ah cool. Indeed it's getting closer now.

Note there was a mirror error in the getTextureCoord() method. To fix it change the last line to:

return new float[] { targetU, 1-targetV };

Haven't found a way to solve the seam problem so far.

bjlotus

Re: [OpenGL] HOW TO map-texture a subdivided icosahedron with VBOs?

11 months ago

Nice.

regarding the seam, I'm just reading at this (the 1st. answer), I'll try to port it to processing.

bjlotus

Re: [OpenGL] HOW TO map-texture a subdivided icosahedron with VBOs?

11 months ago

ough... accidentally deleted my previous post... so here i go again... this is a fixseam method i tried to port from the previously mentioned solution:

void fixSeam(){
ArrayList <Integer> newIndices = new ArrayList <Integer> ();
int corrections = 0;
Map<Integer, Integer> correctionList = new HashMap<Integer, Integer>();
for(int i=indAL.size()-3; i>=0; i-=3){
//get the face's vertices
PVector v1 = new PVector(vertAL.get(indAL.get(i)*3), vertAL.get((indAL.get(i)*3)+1), vertAL.get((indAL.get(i)*3)+2));
PVector v2 = new PVector(vertAL.get(indAL.get(i+1)*3), vertAL.get((indAL.get(i+1)*3)+1), vertAL.get((indAL.get(i+1)*3)+2));
PVector v3 = new PVector(vertAL.get(indAL.get(i+2)*3), vertAL.get((indAL.get(i+2)*3)+1), vertAL.get((indAL.get(i+2)*3)+2));
v1.normalize();
v2.normalize();
v3.normalize();
float[] uv1 = getTextureCoord (v1);
float[] uv2 = getTextureCoord (v2);
float[] uv3 = getTextureCoord (v3);
//way2 ----------------------------------------------------
PVector puv1 = new PVector(uv1[0], uv1[1], 0);
PVector puv2 = new PVector(uv2[0], uv2[1], 0);
PVector puv3 = new PVector(uv3[0], uv3[1], 0);
PVector cr = new PVector();
PVector.cross(PVector.sub(puv1, puv2), PVector.sub(puv3, puv2), cr);
if(cr.z <= 0){
Boolean corrected = false;
//println(cr.z);
for (int j = i; j < i + 3; j++){
int ind = indAL.get(j);
PVector vert = new PVector(vertAL.get(indAL.get(i)*3), vertAL.get((indAL.get(i)*3)+1), vertAL.get((indAL.get(i)*3)+2));
float[] vertuv = getTextureCoord (vert);
/// 0.9 UV fudge factor
if(vertuv[0] >= 0.9f){
/// need to correct this vertex.
if(correctionList.containsKey(ind)){
newIndices.add(correctionList.get(ind));
}else{
float u = vertuv[0] -= 1;
//texAL.set(indAL.get(j)*2, u);
corrected = true;
vertAL.add(vert.x);
vertAL.add(vert.y);
vertAL.add(vert.z);
texAL.add(u);
texAL.add(vertuv[1]);
int correctedVertexIndex = vertAL.size()-1;
correctionList.put(ind, correctedVertexIndex);
newIndices.add(correctedVertexIndex);
}
}else{
newIndices.add(ind);
}
}
if(corrected){
corrections++;
}
}else{
newIndices.addAll(indAL.subList(i, i+3));
}
}
println("corrected "+ corrections +" of "+ newIndices.size()/3);
indAL.clear();
indAL.addAll(newIndices);
}

I've also created a texAL arraylist to store the values before sending the data to the buffer.

So the end of the class constructor looks like:

vertCount = vertAL.size();
indCount = indAL.size();
for (int i=0; i<vertCount; i+=3){
PVector vert = new PVector(vertAL.get(i), vertAL.get(i+1), vertAL.get(i+2));
vert.normalize();
float[] uv = getTextureCoord(vert);
texAL.add(uv[0]);
texAL.add(uv[1]);
}
texCount = texAL.size();
fixSeam();
//fixSeam2();
vertBuffer = BufferUtil.newFloatBuffer(vertAL.size());
for (float v : vertAL){ vertBuffer.put(v); }
vertBuffer.rewind();
indBuffer = BufferUtil.newIntBuffer(indAL.size());
for (int i : indAL){ indBuffer.put(i); }
indBuffer.rewind();
texBuffer = BufferUtil.newFloatBuffer(texAL.size());
for (float i : texAL){ texBuffer.put(i); }
texBuffer.rewind();
initVBO();
}

This function it's not working though... I may be doing something wrong for sure.

Another one i tried is:

void fixSeam2(){
for(int i = 0; i<indCount; i+=3){
float texAdd1 = 0;
float texAdd2 = 0;
float texAdd3 = 0;
PVector v1 = new PVector(vertAL.get(indAL.get(i)*3), vertAL.get((indAL.get(i)*3)+1), vertAL.get((indAL.get(i)*3)+2));
PVector v2 = new PVector(vertAL.get(indAL.get(i+1)*3), vertAL.get((indAL.get(i+1)*3)+1), vertAL.get((indAL.get(i+1)*3)+2));
PVector v3 = new PVector(vertAL.get(indAL.get(i+2)*3), vertAL.get((indAL.get(i+2)*3)+1), vertAL.get((indAL.get(i+2)*3)+2));
v1.normalize();
v2.normalize();
v3.normalize();
float[] uv1 = getTextureCoord (v1);
float[] uv2 = getTextureCoord (v2);
float[] uv3 = getTextureCoord (v3);
if (uv2[0] - uv1[0] > 0.2 || uv3[0] - uv1[0] > 0.2){
texAdd1 = 1;
}
if (uv1[0] - uv2[0] > 0.2 || uv3[0] - uv2[0] > 0.2){
texAdd2 = 1;
}
if (uv1[0] - uv3[0] > 0.2 || uv2[0] - uv3[0] > 0.2){
texAdd3 = 1;
}
texAL.set(indAL.get(i)*2, uv1[0]+texAdd1);
texAL.set(indAL.get(i+1)*2, uv2[0]+texAdd2);
texAL.set(indAL.get(i+2)*2, uv3[0]+texAdd3);
}
}

but it looks like it partially fixes the seam, while messing other faces. I'm getting a little confusing on how to detect the seam verts... I think I understand why the seam displays, but I'm not being able to figure how to solve it.

Top Reply