Sign in to follow this  
Geri

OpenGL TitaniumGL, opengl multiwrapper for your game (opengl,d3d,multicore soft-render)

Recommended Posts

This tool can be very usefull for some developers, so i post it here, i hope this is the right place, becouse i dont want to spam.

Let me introduct TitaniumGL:TitaniumGL for windows is an opengl to d3d wrapper (its more a whole virtual graphics card implementation anyways) to your application, targetted to end users who got broken opengl drivers on they systems. And of course, developers who are developing C/B category games, and want d3d support, by adding my dll to their softwares.

TitaniumGL can come with your game: no separate installation or programming needed. You just only need to copy TitaniumGL to your application's .exe directory. You not need to program d3d rendering path.

WHY this is good for you?
Currently, the most built-in drivers in Windows has no OpenGL acceleration, only D3D. Most end-users does not even know, what is a ,,driver''. With TitaniumGL, you can reach them easilly. Some users has old SiS/Intel/etc based hardware in they computer, and they got no OpenGL acceleration. Reach these peoples easilly, get bigger market, than your comptetitors.

...Or at least, be an emo to get d3d and opengl support also :D

Its also good if you dont want titaniumgl in your game. But maybee its a good idea to test your game with TitaniumGL too: the software alreday has 20.000 user (2011 04 11).

[url="http://TitaniumGL.tk"]http://TitaniumGL.tk[/url]

Share this post


Link to post
Share on other sites
This seems interesting (although I imagine it'll get moved to Your Announcements). A couple of suggestions though. I think in general, announcements that are easily readable and nicely formatted and that have clickable links tend to get more attention and interest (usually when I see a mess of text and raw URLs I just skip over it, and I imagine I'm not the only one). You can edit your post easily though using the 'edit' button in the upper right.

I had a thread a while back about OpenGL support on Windows. I don't remember there being any clear consensus on the matter, but from what I've read on these forums and elsewhere, I do get the impression that use of OpenGL might present casual users with potential roadblocks that they wouldn't encounter with Direct3D. Of course there are cross-platform solutions available that hide these details from the developer, more or less (Unity, Ogre), but for someone who wants to write their own renderer for whatever reason, the problem remains.

Anyway, maybe you could at least make your links clickable - that would make your post a little easier to navigate, I think.

Share this post


Link to post
Share on other sites
Thank you for the replys!

jyk: i will edit the opening thread's links, after i found out how to use this forum (i used it long time ago) :3
I am happy that you enjoy the project. i was tought that i will get a much more negative reply on the project, becouse the most of developers dont see this kind of problems.

Kambiz: issues can happend, becouse this is the first release. i am not even yet tested it on several newer os-es, like win7 or vista (of course i tested it all computers that i was can reach until now to ensure maximal compatibility). After i will get bugreports from various systems, i will able to found this bugs and fix them. The crash you noticed probably happends on newer systems, i am alreday on the fixing of it.

Share this post


Link to post
Share on other sites
Kambiz: i investigated your report. I tryed the first three demo from that site. Second and third runs. First is crashing, but it seems that the bug is in the demo's code.

i also got some new screenshots

http://legend.uw.hu/kepek/tgl/quake3_5.jpg

(minor bugs: some blending bugs)

http://legend.uw.hu/kepek/tgl/wolf.jpg

(minor bugs: white textures on a few places)

both shots from d3d mode.

Share this post


Link to post
Share on other sites
in d3d and software mode, i support the folowing extensions:

GL_ARB_multitexture
GL_ARB_texture_env_crossbar
GL_ARB_texture_non_power_of_two
GL_ARB_transpose_matrix
GL_ARB_vertex_buffer_object
GL_EXT_abgr
GL_EXT_bgr
GL_EXT_bgra
GL_EXT_blend_logic_op
GL_EXT_cmyka
GL_EXT_compiled_vertex_array
GL_EXT_draw_range_elements
GL_EXT_generate_mipmap
GL_EXT_multi_draw_arrays
GL_EXT_rescale_normal
GL_EXT_texture_env_combine
GL_EXT_texture_object
GL_EXT_vertex_array
GL_SGIS_generate_mipmap
WGL_ARB_extensions_string
WGL_EXT_extension_string
WGL_EXT_extensions_string
WGL_EXT_swap_control

i return 1.3 as version string

Share this post


Link to post
Share on other sites
i made some fixes on the webpage (in the english), but the qualify of the language is still projecting the feeling of a ,,oh look its a cheap shaddy eastern european product'' - according to UK persons report :3 :D

Share this post


Link to post
Share on other sites
I am also skeptic about the usefulness of your library.
Quote:
Original post by Geri
FIRST CASE: Most of end-users are not informaticans, and cant install device drivers.

People who use 3d application and play games have also drivers installed, it is unlikely that my game is the only application on someones PC that requires hardware accelerations. There are exceptions but I don't think that "most" users will have no proper drivers installed. Can you reference any statistic to verify your claim?
I think if the user can install my application, he can install drivers too. It is the same procedure.

Quote:
Original post by Geri
SECOND CASE: Some end users has very low-end and old VGA card (old integrated intel, Neomagic, old SiS, 3dlabs or S3 vga-s), and they does not even support OpenGL, or they are using newer operating system that does not contains OpenGL acceleration to it anymore. Probably the power of these systems are enough to your game to run.

When we use OpenGL in our software we want hardware acceleration. If we could live without or if we were developing for very low end hardware we would use other API. There are also high level 2D APIs available that have software and hardware accelerated back-ends (QT, Cairo).
When using your library one has to use GL 1.3, but then what about all the users who have 'gaming cards' and propers drivers installed?

Share this post


Link to post
Share on other sites
If the proper drivers are installed, TitaniumGL is like a glass, it would not ruin the qualify of the vga-driver.

(installing a driver and an application is does not the same procedure. If he/she installs your game, she just place dvdrom in, then press next - next - finish probably. to install a driver, need to know the graphics card, need to know where he/she can found the drivers. Its like charging the accumulator in your car. You can drive it does not means that you can charge its accumulator too. If your application is MEANT only for hardcore gamers, your community will of course know, how to install a vga driver, otherwise, its not so sure. I am even sucked with some stuffs becouse some end users never seen .rar files, and they wasnt able to google it... ;))

Share this post


Link to post
Share on other sites
Quote:
Original post by Geri
If the proper drivers are installed, TitaniumGL is like a glass, it would not ruin the qualify of the vga-driver.

This is not what I meant, I mean we develop with a minimum specification in mind, if the minimum is Netbook, we have no reason to use OpenGL at all. If it is an average gaming PC, we would target OpenGL 2 at least (1.3 is very very old) and use shaders but then the code becomes in compatible with your library.
There is no scenario where your library is useful as fall-back.

You should really show us statistics and tell us in numbers how much bigger our target group will be if we use your library.

For example
http://store.steampowered.com/hwsurvey/
shows that 95% of the users have DX9 cards (~OGL 2).
While your library is cheap, it restricts one to GL 1.3 and it is a potential source of bugs. One would need to debug not only on different hardware but also using your library.

Share this post


Link to post
Share on other sites
Quote:
Original post by Geri
we would target OpenGL 2 at least


Who want to create a shader based AAA game with very much money, should be able to get time and write a d3d rendering core to it anyways. But well, as i see it (i tested a bounch of shareware games of nowdays on the internet), some of them was only used opengl 1.1, most of them only needed multitexture and vbo as extension. I was found only a few that requied 2.0 features to run, like 1 from 10. It seems the most of succesfull game-developers just want to create games, not shader effects, and i want to help them.


About the statistics: i don't has any other statistics, except that two on my webpage. About market share statistics, i dont have current values, but as you can see, most of PC-s are comes with preinstalled windows. Most of windows drivers has no built-in opengl acceleration. Only the 4-5% of the peoples are informatics and/or gamers - others will be never in they life will change they vga driver. This reason is existed even before windows xp: Quake2 also has built in d3d drivers, and some versions of Quake3 demo can also fallback to d3d rendering (quake3 demo even uses a compiled-in opengl to d3d wrapper in this situations) so it wasnt me to first come up with this idea. It was Carmack :D

Share this post


Link to post
Share on other sites
Quote:
Original post by Geri
Quote:
Original post by Geri
we would target OpenGL 2 at least


Who want to create a shader based AAA game with very much money, should be able to get time and write a d3d rendering core to it anyways. But well, as i see it (i tested a bounch of shareware games of nowdays on the internet), some of them was only used opengl 1.1, most of them only needed multitexture and vbo as extension. I was found only a few that requied 2.0 features to run, like 1 from 10. It seems the most of succesfull game-developers just want to create games, not shader effects, and i want to help them.


That's wrong. Creating games includes creating shaders to do some effects. But anyways, GL is moving away from fixed function in favour to shaders. See OpenGL 3 for that.

Consider, if i were to develop a game, i wouldn't like to be constrained by some random library.

Share this post


Link to post
Share on other sites
Quote:
Original post by Geri
Quote:
Original post by Geri
we would target OpenGL 2 at least


Who want to create a shader based AAA game with very much money, should be able to get time and write a d3d rendering core to it anyways. But well, as i see it (i tested a bounch of shareware games of nowdays on the internet), some of them was only used opengl 1.1, most of them only needed multitexture and vbo as extension. I was found only a few that requied 2.0 features to run, like 1 from 10. It seems the most of succesfull game-developers just want to create games, not shader effects, and i want to help them.


Windows Vista and Windows7 however allready have a OpenGL1.4 -> D3D wrapper, so your software is only really useful for XP machines (Which only have a OpenGL1.1 software driver by default), the number of XP machines being used is decreasing quite rapidly though.

Share this post


Link to post
Share on other sites
HuntsMan:

If you call my library random wich is working and has tryable version, then i call you as a ,,random people'' who are not a code writer (you even called yourself as ,,if i were develop a game'')

Kambiz, HuntsMan:

http://sourceforge.net/search/?type_of_search=soft&words=opengl+game&search=Search

Here, some OpenGL games. I just looked the first ~100 of them. I just typed opengl and game keyword. I looked the screenshots randomly there, i checked source codes also, and i saw mostly only fixed function, and a few that requied shaders. Of course this not means that my wrapper will be compatible with them for first try! This is just for correcting the misinformations that you both posted.

The reality is different than imagination - therefore i ask you two to please stop placing disinformations to my topic, becouse it can affray some developers who are want to buy.

Please ask only technically things and not philisophically - i suggest to create a new topic for you if you both want to just wondering about the shader usage in today's video games.

(this NOT means that i am now angry at you, dudes!)



SimonForsman: Thank you for the information. As some bugreports what i recived, most computers even on win7 was returned ,,generic gdi'' ogl 1.1 software renderer with built-in drivers for some reason (d3d was worked fine), so there also can be this to be a problem. And i hope this will be the same in win8 too :3

Share this post


Link to post
Share on other sites
Quote:
Original post by SimonForsman
Windows Vista and Windows7 however allready have a OpenGL1.4 -> D3D wrapper, so your software is only really useful for XP machines (Which only have a OpenGL1.1 software driver by default), the number of XP machines being used is decreasing quite rapidly though.
Microsoft has been including the proper driver downloads in Windows Update for like 5 years now...

Share this post


Link to post
Share on other sites
Quote:
Original post by Geri
Windows update needs internet. Only 26,6% of peoples has internet access according to internet usage statics, wich can be viewed on http://www.internetworldstats.com/stats.htm
Otherwise, the proper drivers are pre-installed by the system manufacturer. They just aren't updated without internet access.

Share this post


Link to post
Share on other sites
I like the idea of your library, but I would only use it if it had GL2.0 suppport :/
Developing with GLSL shaders is much less effort for me than using the old fixed-function pipeline. It lets me focus on writing my game and not on learning obscure API details!

Share this post


Link to post
Share on other sites
Daaark: lot of manufacturers just check the device manager, and if they see the card name, they are install no drivers for the vga. This can mostly happend with small computer stores. Also can happend for computers buyd without os, and os installed by the neighbour ,,Stevie'' :D

Hodgman: currently i am not planning to expand it above OpenGL 1.3, but *MAYBEE* if recive a lot of request, i can add a extension that allows to acces d3d9 pixel shaders. Or if i found some LGPL-ed glsl to hlsl conversion tool, it would be much compatibyer. But this would not result opengl 2.0 features to come in, and the compatibility would be very crap anyway. So if you got no fixed funct fallback in your engine, i suggest you to not buy the software, as you sayd. Later if you will write a fallback in your software becouse of different reasons, and you would use the wrapper, contact me and i help you to place the library into your software.

Share this post


Link to post
Share on other sites
If your market are small indy developers that release small plat-form/puzzle games, there could be an interest for it.

However I agree with other posters that to be more generally useful, it needs to support GL 2. No offense, but Quake 3 and Return to Castle Wolfenstein are almost a decade old. You're not proving anything by supporting them.

By the way:

Quote:
TitaniumGL is also capable, to render your game with multicore cpu rendering


Can you elaborate ? How can it do that ? Have you done some benchmarks ?

Y.

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this  

  • Announcements

  • Forum Statistics

    • Total Topics
      628388
    • Total Posts
      2982403
  • Similar Content

    • By test opty
      Hi all,
       
      I'm starting OpenGL using a tut on the Web. But at this point I would like to know the primitives needed for creating a window using OpenGL. So on Windows and using MS VS 2017, what is the simplest code required to render a window with the title of "First Rectangle", please?
       
       
    • By DejayHextrix
      Hi, New here. 
      I need some help. My fiance and I like to play this mobile game online that goes by real time. Her and I are always working but when we have free time we like to play this game. We don't always got time throughout the day to Queue Buildings, troops, Upgrades....etc.... 
      I was told to look into DLL Injection and OpenGL/DirectX Hooking. Is this true? Is this what I need to learn? 
      How do I read the Android files, or modify the files, or get the in-game tags/variables for the game I want? 
      Any assistance on this would be most appreciated. I been everywhere and seems no one knows or is to lazy to help me out. It would be nice to have assistance for once. I don't know what I need to learn. 
      So links of topics I need to learn within the comment section would be SOOOOO.....Helpful. Anything to just get me started. 
      Thanks, 
      Dejay Hextrix 
    • By mellinoe
      Hi all,
      First time poster here, although I've been reading posts here for quite a while. This place has been invaluable for learning graphics programming -- thanks for a great resource!
      Right now, I'm working on a graphics abstraction layer for .NET which supports D3D11, Vulkan, and OpenGL at the moment. I have implemented most of my planned features already, and things are working well. Some remaining features that I am planning are Compute Shaders, and some flavor of read-write shader resources. At the moment, my shaders can just get simple read-only access to a uniform (or constant) buffer, a texture, or a sampler. Unfortunately, I'm having a tough time grasping the distinctions between all of the different kinds of read-write resources that are available. In D3D alone, there seem to be 5 or 6 different kinds of resources with similar but different characteristics. On top of that, I get the impression that some of them are more or less "obsoleted" by the newer kinds, and don't have much of a place in modern code. There seem to be a few pivots:
      The data source/destination (buffer or texture) Read-write or read-only Structured or unstructured (?) Ordered vs unordered (?) These are just my observations based on a lot of MSDN and OpenGL doc reading. For my library, I'm not interested in exposing every possibility to the user -- just trying to find a good "middle-ground" that can be represented cleanly across API's which is good enough for common scenarios.
      Can anyone give a sort of "overview" of the different options, and perhaps compare/contrast the concepts between Direct3D, OpenGL, and Vulkan? I'd also be very interested in hearing how other folks have abstracted these concepts in their libraries.
    • By aejt
      I recently started getting into graphics programming (2nd try, first try was many years ago) and I'm working on a 3d rendering engine which I hope to be able to make a 3D game with sooner or later. I have plenty of C++ experience, but not a lot when it comes to graphics, and while it's definitely going much better this time, I'm having trouble figuring out how assets are usually handled by engines.
      I'm not having trouble with handling the GPU resources, but more so with how the resources should be defined and used in the system (materials, models, etc).
      This is my plan now, I've implemented most of it except for the XML parts and factories and those are the ones I'm not sure of at all:
      I have these classes:
      For GPU resources:
      Geometry: holds and manages everything needed to render a geometry: VAO, VBO, EBO. Texture: holds and manages a texture which is loaded into the GPU. Shader: holds and manages a shader which is loaded into the GPU. For assets relying on GPU resources:
      Material: holds a shader resource, multiple texture resources, as well as uniform settings. Mesh: holds a geometry and a material. Model: holds multiple meshes, possibly in a tree structure to more easily support skinning later on? For handling GPU resources:
      ResourceCache<T>: T can be any resource loaded into the GPU. It owns these resources and only hands out handles to them on request (currently string identifiers are used when requesting handles, but all resources are stored in a vector and each handle only contains resource's index in that vector) Resource<T>: The handles given out from ResourceCache. The handles are reference counted and to get the underlying resource you simply deference like with pointers (*handle).  
      And my plan is to define everything into these XML documents to abstract away files:
      Resources.xml for ref-counted GPU resources (geometry, shaders, textures) Resources are assigned names/ids and resource files, and possibly some attributes (what vertex attributes does this geometry have? what vertex attributes does this shader expect? what uniforms does this shader use? and so on) Are reference counted using ResourceCache<T> Assets.xml for assets using the GPU resources (materials, meshes, models) Assets are not reference counted, but they hold handles to ref-counted resources. References the resources defined in Resources.xml by names/ids. The XMLs are loaded into some structure in memory which is then used for loading the resources/assets using factory classes:
      Factory classes for resources:
      For example, a texture factory could contain the texture definitions from the XML containing data about textures in the game, as well as a cache containing all loaded textures. This means it has mappings from each name/id to a file and when asked to load a texture with a name/id, it can look up its path and use a "BinaryLoader" to either load the file and create the resource directly, or asynchronously load the file's data into a queue which then can be read from later to create the resources synchronously in the GL context. These factories only return handles.
      Factory classes for assets:
      Much like for resources, these classes contain the definitions for the assets they can load. For example, with the definition the MaterialFactory will know which shader, textures and possibly uniform a certain material has, and with the help of TextureFactory and ShaderFactory, it can retrieve handles to the resources it needs (Shader + Textures), setup itself from XML data (uniform values), and return a created instance of requested material. These factories return actual instances, not handles (but the instances contain handles).
       
       
      Is this a good or commonly used approach? Is this going to bite me in the ass later on? Are there other more preferable approaches? Is this outside of the scope of a 3d renderer and should be on the engine side? I'd love to receive and kind of advice or suggestions!
      Thanks!
    • By nedondev
      I 'm learning how to create game by using opengl with c/c++ coding, so here is my fist game. In video description also have game contain in Dropbox. May be I will make it better in future.
      Thanks.
  • Popular Now