Printable View
Sorry about that, i'm not really sure what the norm is with code indentation koz iv'e only ever learn't from books and iv'e never really started posting my code on the net untill recently so iv'e fallin into some bad habbits,Quote:
Originally Posted by EVOEx
As far as code indentation goes is it just bringing loops and conditionals out further then the rest of code like this
Or is there more to it then that?Code:while()
{
//loop 1
While()
{
//loop 2
}
}
Quote:
Originally Posted by MK27
Yea iv'e nailed it down to an array prob, but why would the same array work in one mode but not the other do they use differernt array formats, or have i just got the wrong number in the rendering functions somewhere?
What do you mean by 7D? How does that help?Quote:
Originally Posted by MK27
:) I've just got it wokring properly it had a few major flaws; lol
I changed:
glDrawArrays(GL_QUADS,0, Shizzle.ArraySize) to
glDrawArrays(GL_QUADS,0, Shizzle.ArraySize/3) to
And
glBufferData(GL_ARRAY_BUFFER, Temp.ArraySize, Temp.Array, GL_STATIC_DRAW);
to:
glBufferData(GL_ARRAY_BUFFER, sizeof(float)*Temp.ArraySize, Temp.Array, GL_STATIC_DRAW);
Where ArraySize is the amount of elements in the array
However... and i bet your all pretty sick of my questions by now, lol
If your using Glut, where would I put in the glDeleteBuffers? because i would have to break out of the main loop for that wouldn't I? unless glut has some kind of shutdown callback function I can pass by buffers to?
Thanks for all the help anyways guys, I'm pretty happy about getting this working
Not sure what you mean by "break out". If the program is just a GL program, all of it except for setup & initialization is inside the main loop (nb, I don't mean one long piece of spagetti). You only want to delete a buffer when you are done with the data. Eg, you have an object. Another object destroys it. Now you might as well delete the data for the destroyed object, since it will not be appearing again. I generally use global arrays to store the VBO indexes (they are just single ints, like pointers). Or more specifically arrays of structs with "VBO" members. That's how it is in the tutorial, I think, altho I don't delete anything because nothing disappears. In C++ I guess you would have arrays of objects.Quote:
Originally Posted by Matty_Alan
You don't need to delete the remaining buffers after the main loop is over (ie, when the program is done).
Vis. "7D", this is only relevant if you are at least 3 meters tall. Everyone else has to google. :p
Vis, your indenting, well, you have the correct idea in post #16, but what I saw first when I opened Main.cpp was this:
Tch! It does get slightly better but "slightly wack" seems to be the theme:Code:/************* DISPLAY CALLBACK FUNCTION ************/
void Display_old(void)
{
glPushMatrix();
glClear(GL_COLOR_BUFFER_BIT);
gluLookAt(b, 0.0, a , 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
int a =0, b=0;
glBegin(GL_QUADS);
while(a < Shizzle.ArraySize)//(3*4))//Sides * (Dementions * Verticies in a quad)
{
glVertex3f(Shizzle.Array[a],Shizzle.Array[a+1],Shizzle.Array[a+2]);
a= a+3;
}
glEnd();
glutSwapBuffers();
glPopMatrix();
}
No, no. How about one of the following options:Code:void Keys(int key, int x, int y)
{
if(key == GLUT_KEY_UP)
{a = a+.3;}
if(key == GLUT_KEY_DOWN)
{a = a-.3;}
if(key == GLUT_KEY_LEFT)
Oh, here's a little GL tip: it uses floats internally. With C/C++, numbers like ".3" get treated as doubles and are then converted to floats at runtime if the assignment implies this. That's not GL, that's a general principle, but it does mean you are best off indicating floats to start with if you know that's what they are going to end as (0.3f). However, that's a very minor issue, lots of people appear to care less.Code:void Keys(int key, int x, int y)
{
if(key == GLUT_KEY_UP)
{a = a+.3;} // not acceptable
if(key == GLUT_KEY_DOWN)
{a = a-.3;} // acceptable
if(key == GLUT_KEY_LEFT) b = b+.3; // also fine
The concept I had in my head was something like...Quote:
Originally Posted by MK27
I declare and load the VBO at the start of the program, however i can't delete the VBO untill glut has entered it's glutMainLoop, otherwise it wont be displayed, or it would be displayed for one frame. so anything i put after glutMainLoop() Wont happen because it's an infinate loop and by the time i terminate the program it wouldn't reach whatever comes after glutMainLoop(); which is where I would have to put the delete buffer function.
Iv'e seen alot of this 'f' and 'i' in open GL, So this is just some kind of typecasting?Quote:
Originally Posted by MK27
The VBO is where your object description is stored, the handle is a handle to video memory. If you delete it at any point, trying to render that object in the next frame will cause a disaster. Hence, you should only delete a buffer when the object data it contains is for an object that will no longer be displayed.Quote:
Originally Posted by Matty_Alan
Actually, any code you place in main() after glutMainLoop() will be executed when the MainLoop ends, which is when OGL is done (however you exit your app currently). But I doubt you can place OGL calls there (maybe). In any case, like I said, there is no need to delete buffers once the program is finished, they will be freed.Quote:
by the time i terminate the program it wouldn't reach whatever comes after glutMainLoop(); which is where I would have to put the delete buffer function.
I guess. It indicates something to the compiler about type, anyway. A decimal number without f is taken to be a double, with f it is taken as a float.Quote:
Iv'e seen alot of this 'f' and 'i' in open GL, So this is just some kind of typecasting?