# OpenGL What to use instead of GLUT?

## Recommended Posts

I haven't used a computer much in the past month, and have instead been reading up on my OpenGL Redbook. Before I started, I didn't think I would use the AUX libraries, so I picked up some GLUT tutorials. I only soaked up the basics on making windows with GLUT, but now that I'm trying to compile with it, I get linker errors. I picked it up because it seemed relatively simple, and I didn't feel like putting much time into something like that, and instead spend as much time on OpenGL as possible. So, I don't think I will use GLUT. I've read it's also slow and isn't that great. Next thing that comes to mind is SDL. I'm not a big linux junkie, but I like cross platform stuff. And licenses don't matter, I won't be making profit anytime soon... so what do all of you use?

##### Share on other sites
SDL is fun (lot's of stuff in my sig) [smile] I am using Ogre3D at the moment though for a game.

Whoops took out my sig [lol]

[Edited by - Drew_Benton on May 24, 2005 8:08:11 PM]

##### Share on other sites
I've never used SDL, but I have used GLFW. It is quite flexible and it's cross platform. Check it out.

##### Share on other sites
Ah, I didn't know of GLFW. Seems to be what I am searching for. Before I chose GLUT way back when, SDL was my primary choice. But I found it hard to find information on how to use it as a framework to OpenGL rather than a graphics library on it's own.

Good, I've tried it quickly and it and the keyboard input works as far as I need for now. Thanks++

##### Share on other sites
What you might want to give a try if you're using a standards compliant compiler is my own framework Daedalus. You can download the source from here. It compiles under Windows using the VC++Express Beta (1/2) and under Linux with make (you'll need to change a few lines in the Makefiles). It currently supports windowed and fullscreen apps, all the usual stuff you can do with windows (on Windows at least, working on Linux, should be done after this weekend). It is very easy to use input from keyboard (mouse is in the final stages of refactoring).

For some example code to setup a window and bind some keys see my journal

[Edited by - rick_appleton on May 25, 2005 4:07:37 AM]

##### Share on other sites
I actually noticed that when doing loads of searches on the subject. That and another member's framework; OGLFWF I think it was, and I forget the name of the guy but he has the ghost icon. I was considering trying yours and that out but I figured they weren't as well documented as things like GLFW (which I am coming along nicely with). So, Daedalus works only with versions of VC++? I have the one you said, but my IDE of choice is DevC++. If it doesn't work with that, then I won't really do much more than fool around with it.

##### Share on other sites
Quote:
 Original post by alien3456OGLFWF I think it was, and I forget the name of the guy but he has the ghost icon.

_the_phantom_ [wink]

##### Share on other sites

Yes, GLFW is definately better commented as it is at a much further stage of development. It's pretty stable and works well. However, it is only a Framework. So that means you'll need to handle most of the stuff yourself, only GLFW gives you an interface that works on all platforms. A large part of my platform specific code was taken from GLFW so it is partially the same, but Daedalus adds another layer over the top (most notably a C++ class for the windowing, a messaging scheme, and the possibility to bind a function to each keyboard key, and more is in the pipeline).

It should work with DevC++ as well, as long as the compiler can handle templates well. There are a few places in Daedalus that really need that. If you are willing and have the time, I would be very interested in hearing if you've been able to compile it under DevC++. I expect it shouldn't be a problem actually, since under the hood DevC++ normally uses the same GCC compiler as is used on *nix systems. And the program compiles without a hitch on those.

[Edited by - rick_appleton on May 26, 2005 1:28:52 AM]

##### Share on other sites
You could try making your own simple framework to develop in. This is what I did. I wasn't that keen on using GLUT and I didn't want to start learning an engine just quite yet, so I coded up one real quick. It's not perfect, but it gets the job done. It's always a great learning experience when you do it yourself.

## Create an account

Register a new account

• ### Forum Statistics

• Total Topics
627764
• Total Posts
2978981
• ### Similar Content

• Hello! As an exercise for delving into modern OpenGL, I'm creating a simple .obj renderer. I want to support things like varying degrees of specularity, geometry opacity, things like that, on a per-material basis. Different materials can also have different textures. Basic .obj necessities. I've done this in old school OpenGL, but modern OpenGL has its own thing going on, and I'd like to conform as closely to the standards as possible so as to keep the program running correctly, and I'm hoping to avoid picking up bad habits this early on.
Reading around on the OpenGL Wiki, one tip in particular really stands out to me on this page:
For something like a renderer for .obj files, this sort of thing seems almost ideal, but according to the wiki, it's a bad idea. Interesting to note!
So, here's what the plan is so far as far as loading goes:
Set up a type for materials so that materials can be created and destroyed. They will contain things like diffuse color, diffuse texture, geometry opacity, and so on, for each material in the .mtl file. Since .obj files are conveniently split up by material, I can load different groups of vertices/normals/UVs and triangles into different blocks of data for different models. When it comes to the rendering, I get a bit lost. I can either:
Between drawing triangle groups, call glUseProgram to use a different shader for that particular geometry (so a unique shader just for the material that is shared by this triangle group). or
Between drawing triangle groups, call glUniform a few times to adjust different parameters within the "master shader", such as specularity, diffuse color, and geometry opacity. In both cases, I still have to call glBindTexture between drawing triangle groups in order to bind the diffuse texture used by the material, so there doesn't seem to be a way around having the CPU do *something* during the rendering process instead of letting the GPU do everything all at once.
The second option here seems less cluttered, however. There are less shaders to keep up with while one "master shader" handles it all. I don't have to duplicate any code or compile multiple shaders. Arguably, I could always have the shader program for each material be embedded in the material itself, and be auto-generated upon loading the material from the .mtl file. But this still leads to constantly calling glUseProgram, much more than is probably necessary in order to properly render the .obj. There seem to be a number of differing opinions on if it's okay to use hundreds of shaders or if it's best to just use tens of shaders.
So, ultimately, what is the "right" way to do this? Does using a "master shader" (or a few variants of one) bog down the system compared to using hundreds of shader programs each dedicated to their own corresponding materials? Keeping in mind that the "master shaders" would have to track these additional uniforms and potentially have numerous branches of ifs, it may be possible that the ifs will lead to additional and unnecessary processing. But would that more expensive than constantly calling glUseProgram to switch shaders, or storing the shaders to begin with?
With all these angles to consider, it's difficult to come to a conclusion. Both possible methods work, and both seem rather convenient for their own reasons, but which is the most performant? Please help this beginner/dummy understand. Thank you!

• I want to make professional java 3d game with server program and database,packet handling for multiplayer and client-server communicating,maps rendering,models,and stuffs Which aspect of java can I learn and where can I learn java Lwjgl OpenGL rendering Like minecraft and world of tanks

• A friend of mine and I are making a 2D game engine as a learning experience and to hopefully build upon the experience in the long run.

-What I'm using:
C++;. Since im learning this language while in college and its one of the popular language to make games with why not.     Visual Studios; Im using a windows so yea.     SDL or GLFW; was thinking about SDL since i do some research on it where it is catching my interest but i hear SDL is a huge package compared to GLFW, so i may do GLFW to start with as learning since i may get overwhelmed with SDL.
-Questions
Knowing what we want in the engine what should our main focus be in terms of learning. File managements, with headers, functions ect. How can i properly manage files with out confusing myself and my friend when sharing code. Alternative to Visual studios: My friend has a mac and cant properly use Vis studios, is there another alternative to it?

• Both functions are available since 3.0, and I'm currently using glMapBuffer(), which works fine.
But, I was wondering if anyone has experienced advantage in using glMapBufferRange(), which allows to specify the range of the mapped buffer. Could this be only a safety measure or does it improve performance?
Note: I'm not asking about glBufferSubData()/glBufferData. Those two are irrelevant in this case.
• By xhcao
Before using void glBindImageTexture(    GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format), does need to make sure that texture is completeness.

• 11
• 10
• 10
• 23
• 14