# OpenGL Windows XP: Console with OpenGL and Dev cpp

## Recommended Posts

Hey all. I've been using Dev CPP since I moved back to Windows when my Mac died. I like it because it's light weight, but I have a big problem. The debugger might as well not be there because I can't even watch variables. It's plain broken. I'm honestly fine with just printing variables to the console, but I'm using open GL, so I don't have a console (one of my big annoyances with Windows). So I'm wondering if there is some code I can use to enable a command line or if Dev CPP has some option that will give me a console window. Any help would be appreciated. thanks :)

##### Share on other sites
Step 1: Don't use Dev-C++. Here's the real stuff.
Step 2: Let us know if you're still having problems.

##### Share on other sites
Step 3: if you got this far and didnt read promit's post. READ PROMIT's POST. preferably while deleting dev-cpp

##### Share on other sites
Further readings on why not to use Dev-C++.

That said, Visual Studio will only solve your debugger woes (Code::Blocks would probably also do that, if you need something smaller than VS because, for example, you need to run from a memory stick or some such).

However, the answer to your question about getting the console back is to use Win32 API functions for doing so. Look up AllocConsole() on MSDN. After that you can use freopen() to reattach stdout to the console provided to you by AllocConsole(). If you need further assistance with this, ask.

Although really, once you abandon Dev-C++ for something with a real debugger you probably won't need to be doing printf()-style debugging through a console anyway.

##### Share on other sites
Yeah, I had installed VC just in case I got this answer. But what I'm not sure about is the fact that I've only ever used the gcc gnu compiler because I know my code will be generally cross platform. Will that change if I'm using Microsoft's IDE/compiler? That is to say, is their version of C++ different?

##### Share on other sites
Quote:
 Original post by guest42is the fact that I've only ever used the gcc gnu compiler because I know my code will be generally cross platform. Will that change if I'm using Microsoft's IDE/compiler? That is to say, is their version of C++ different?
You used GCC because it would be cross platform, but you're worried that it won't work on a different platform.

Are you seeing the problem? (Hint: if your code doesn't work on VC++, that is an indication that it is not cross platform.)

##### Share on other sites
if your code is standard compliant, it will compile on any c++ compiler which is also standard compliant.

(all compilers deviate slightly from the standard, but not by much, and not enough to give you any major headaches).

use visual c++ on windows, and the latest gcc on whatever. the version of mingw with devc++ is so old that its got a walking frame and arthritis.

##### Share on other sites
People still use Dev-C++ for the same reasons you find people still using Microsoft Visual C++ 6.0. They're just plain reluctant to change. Either that, or the silly old tutorials that they first read about writing your first game mentioned Dev-C++ as THE compiler to use. In which case, their research skills are sub-par.

I say leave guest42 with Dev-C++. The more fools using the wrong technology and tool-sets only means more room at the top of the food chain for the rest of us.

##### Share on other sites
The GNU compilers sort of give you a false sense that your code is cross-platform -- what people generally are confused about is that:

1) They believe that the GNU compilers are somehow most-compliant to the language standard (or some even believe that the GNU compilers set the standard!)

2) They believe that because their code compiles on the GNU compilers, and that GNU compilers have been ported to every platform that their code is therefor cross-platform.

Neither of these is true, of course:

In the first case, Microsoft's recent C++ compilers have been *more* standard compliant than the GNU C++ compiler, G++ -- just because something is "open source" doesn't automatically mean that it has the best standards compliance, especially with something as complex, ill-defined, and just-plain-odd as C++.

In the second case, GNU's compilers have their own syntax for extensions, inline assembly and whatnot -- and if you use any of these, your code will likely not compile on other compilers -- remember, the platform is comprised of many things: The compiler, libraries, run-time, operating system and the hardware -- to be truly cross-platform, you must write code that is neutral to all of these. In short, there's far more to "cross-platform" than simply choosing a widely-available compiler.

##### Share on other sites
Ah, thanks Matt, I appreciate the straight answer. I just wasn't sure how different Microsoft's C++ standards were from Gnu's, but I'll go on faith that it shouldn't be a big deal. Now to figure out how to set up OpenGL/Glut/Glui all over again.

##### Share on other sites
Quote:
 Original post by guest42Now to figure out how to set up OpenGL/Glut/Glui all over again.
If you could set up an OpenGL window in Dev-C++ I really don't see why you would need to rewrite the code for other tools if you're building for Windows in the end. It's all WinAPI stuff after all (or whatever you're using, it's still Windows-specific, not tool-specific) =S

PS: I'm pretty sure that you can set up an OpenGL window even if it's a console application. Just create one as usual. Although yeah, don't use a console as a replacement for a debugger.

##### Share on other sites
Create a Console App and then just write Windows / OpenGL code as always.
When you run your app you will see OpenGL window created and also the console in background.

## Create an account

Register a new account

• ### Forum Statistics

• Total Topics
627741
• Total Posts
2978887
• ### 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.

• 10
• 10
• 21
• 14
• 14