I think openGl should have some kind of library that would at least help doing non-sphirical hittesting. HitTseting of obj vs obj is what I would like to see in next version to be easier to accomplish

Again, OpenGL is a low-level API.
There is no concept of ‘object’ under OpenGL, so there can not be a concept of hit-test between objects. At best there would be hit test between polygons, and that would be up to you to organize polygons so that they represents objects (in other words, it’s up to you to build or use a higher level API that encapsulates low-level OpenGL functionalities)

ya ,ya I know but what i meant by obj is a file with an .obj file extention

ya ,ya I know but what i meant by obj is a file with an .obj file extention

OpenGL has/needs no concept of files, extensions, or objects.

Yes it does. Current openGL is to basic it sould have a higher level functions. It should promote organization of NURBS and polygons in to objects.

No it should not. At least not now.
OpenGL2.0 will provide such features but it’s not the goal of OpenGL1.x

OpenGL (2.0 or 1.x) is not designed as a scene graph API. The concept of objects is not something that it should even be concerned with. GL is just fine being what it is: a rendering API that works relatively well with hardware.

Originally posted by vincoof:
No it should not. At least not now.
OpenGL2.0 will provide such features but it’s not the goal of OpenGL1.x

Why shouldn’t it be the goal of openGL 1.x why wait for openGL 2.0
Objects would be easier to deal with and it will be easier to hitTest one against the other. Not just polygon vs polygon or sphere hittesting but and object on object hitTesting. It would at lwast save me a lot of work. I am trying to make my own library that will organize polygons in to objects. I won’t wait till openGl 2.0 . I still have problems with hitTesting though

whats the difference between frequent contributor and just contributor?

If you want higher-level APIs, there already exist some which use OpenGL - glut, glaux, glow and more. OpenGL is designed to be low-level. This way, higher-level APIs have more freedom.

Frequent contributors are contributors who had posted a “certain ammount of messages”. It’s useful to see who is new to the site and who is not, though it’s not such a good analysis.

I know, I am using glut but it still a very low level.

Can anyone suggest to me how to do polygon hittesting (not sphirical)?

First, GLUT is not a scene graph! It is “a window system independent toolkit for writing OpenGL programs” that “implements a simple windowing application programming interface (API) for OpenGL.”

Second, OpenGL is what it is. If it isn’t high-level enough for you, then go find a software library that has objects, file loading, hit testing, etc. I think a game engine is probably what you’re looking for.

OpenGL drivers are buggy enough as it is. If OpenGL were made into a high-level game engine (which is what you seem to be proposing), and the entire library were rewritten by every hardware vender, developing applications for OpenGL that ran on most platforms would be a real pain. It’s best to keep higher-level features centralized in one code base, and leave the low-level stuff to the hardware venders.

More importantly, this kind of software already exists. Every other day there’s a new 3d game engine announced on the main page. Don’t you think it would be easier to use one of these than to convince the ARB to change the whole direction of OpenGL?

Where can I find one of your “game engines” for free? are there any for free?

I gave you two links in the “BSP in display lists” thread.

Originally posted by valmian:
Can anyone suggest to me how to do polygon hittesting (not sphirical)?

The hittesting is very application specific. It depends on what are your objects, what is their geometry. For example, your sphere has 700 polygons, and it has to move about a world with +5000 polygons. How fast you think you can have your engine if it were to test each of sphere.700 polygons against world.5000 polygons?

In this case, you can use angle/radius combination to calculate wether the sphere entered an object (not a polygon but another object).

Having more complex objects demands complex algorithms, but it can all be optimized.

Fake it 'till you make it!

Therefore, there is NO generic way to calculate hittest. It depends on object geometry, and in order for OpenGL to understand an “object” it would have to be something similar to a neural network that, by experience, learns how each object performs. It would also need a high-order persistent memory that actually does the learning. It would also need to know how specific objects move in space, so you would have to teach it some basic physics…
When I mean “teach” I don’t mean hardware implementation, but real-time learning of your OpenGL renderer… in which case you will have to keep your computer turned on forever, or use some hologramic memory…

Ya ya watever, I know how to do sphirical my self

Valmian, are you talking about
intersection detection?

What does that have to do with rendering?

OpenGL is an API for real-time 3D rendering,
not a solution for all 3D graphics problems.

Can we get some non-pointless threads in here?