Direct3D to OpenGL abstraction layer(github.com) |
Direct3D to OpenGL abstraction layer(github.com) |
slides here: http://adrienb.fr/blog/wp-content/uploads/2013/04/PortingSou...
So if you have rolled your own DirectX-only engine this is awesome of course, but do people really do that?
That's completely wrong. PS3 never used OpenGL and PS4 doesn't do either.
Unreal while having somewhat working Mac port is usually ported via Cedega and not the Mac version which is largely unmaintained. The Linux port of Unreal was never merged back either. Presently there is no reasonable OpenGL renderer. CryEngine also does not use OpenGL.
It sort of does. PS3 uses OpenGL ES 1.0 with extensions and then there is a separate graphics library, LibGCM, that is lower level.
Details here (although this use says it doesn't use OpenGL and then says that its API is based on OpenGL + extensions, so it is a bit confusing):
http://scalibq.wordpress.com/2010/05/15/sony%E2%80%99s-plays...
EDIT: HEre is a PS3 developer saying that PS3 is OpenGL ES:
http://www.khronos.org/assets/uploads/developers/library/sig...
You are right that CryEngine doesn't use OpenGL it seems, but at least they are pretty close with PSGL and they also seem to be working on Linux support.
http://scalibq.wordpress.com/2010/05/15/sony%E2%80%99s-plays...
Never understood how it got born.
i'm pretty sure it would have worked at some point because the docs indicated that it had. however - writing a gl like layer over the top of the rsx stuff is not a particular challenge - the functionality maps extremely well.
I think a lot of games featured in Humble Bundles used to be that way. A lot of games used to be (and some still are) initially only released on Windows with Mac/Linux ports released later.
I always wrote them so that all DirectX and Windows specific code was abstracted behind platform-agnostic generic interfaces. So, in theory, OpenGL support would be as simple as coding an OpenGL implementation of my generic graphics API. Probably a day or two's work, but I haven't had a compelling reason to do the OpenGL implementation yet.
i mean, there are more open source games that use OpenGL than DirectX, and are already cross platform as a result. similarly, i would imagine if a AAA game studio wanted to do such a thing, they would roll their own (or just use GL in the first place).
perhaps i'm being too cynical (but this is hacker news..)
there are already DX->GL compatibility layers, although most of them are in house, by companies that produce ports (ala Feral Games).
yes, i entirely agree with you.. almost. ideally, i'd like DirectX to.. go away, forever. proprietary APIs that result in lock in to a software or hardware platform are seriously holding back computing in general. and i'd never recommend anyone use AMD's Mantle for the same reason (which is a massive waste of everyone's time)
In fact, it's MIT: http://opensource.org/licenses/MIT
Even the latest version of Wine patched with the Command Stream WIP is 5 times faster.
This is a library, intended to be used in your application in lieu of calling the APIs directly. You cannot take a full application and ask this library to run it.
But yeah, this is awesome. As a side note, developers who want to make games run on OSX and Linux should just stop targeting DirectX. This is good for already-existing games and port them over, but in 2014 if you're still writing games in DirectX, you're most likely doing it wrong.
No, you are not. There is no wrong and right, it's just a stupid statement. OpenGL is years behind D3D (not DirectX, it's not comparable!) in many areas, and writing using the whole DX stack can be much nicer than setting up a GL stack with a lot of different libraries.
http://programmers.stackexchange.com/questions/60544/why-do-...
But this lib is for those countless DX9 games already in existence. Valve is making SteamOS ports as easy as possible.
It is better if the game does GL directly, which is why something the game can link in works better.
Wine is a reimplementation of the WinAPI on Linux, so Windows applications can use the same functions in WinAPI even if they are on Linux.
Also, most AAA engines (such as Unreal Engine) already have an abstraction layer for OpenGL and DirectX so their games can run independently of which one is missing.
i have to say its good to see this but i'm mildly disappointed too... DirectX --> OpenGL is one thing, but a properly cross platform rendering interface that will work with DX, its flavour on 360, the novelties of Win8 and Xbone as well as PS3 gcm and gx/gx2 on nintendo platforms whilst dealing with the quirks of desktop vs. es gl? that would still be a pretty run of the mill technical achievement of no particular note.
aside from that i don't like the code. singleton class instance? why not use the static keyword so the compiler knows what you want and can optimise accordingly and save you the potential to shoot yourself in the foot. and when did 2500 lines become an acceptable file size for a header? also did we forget that you can nest folders, or name files with modern 1990s style filenames...
i need to open source my stuff...
http://venturebeat.com/2014/03/11/steamos-gets-a-powerful-ne...
Not much that code is portable across the respective OpenGL flavors.
Since Valve has already written this for their own purposes, it'll cost next to nothing for this to be published if they can stop people expecting support, and they might get a few bug reports into the bargain.
And this is Valve releasing their particular variant mostly targeted at other major game studios. There is no reason every studio should be forced to create their own in house compatibility layer.
Very true. The performance impact of both Direct3D and OpenGL is actually huge, so it is best to avoid it when you can using lower level interfaces that speak directly to the GPU.
For a long time, console game development was obscure and unaccessible (and to a large extent, this is still the case), so aspiring game developers had somewhat of a tunnel vision when it came to game platforms.
Except Acorn, Atari, Amiga, Mac OS (<= 9) never had real OpenGL support as well.
Of course, if you are targeting Windows XP... you got to think back a lot further than that. In some ways theres some elegance in how you can write GLES2 shader code and have it run everywhere, including on mobile, and just check extensions for everything else you use.
Personally I use the ES3 subset of 4.3 right now. Same code works perfectly on ES3 mobile HW and 4.3 desktop HW. The only features it lacks are geometry and tesselation shaders.
I'm also using compute shaders right now, even though they are not supported in ES3 they are going to be supported in the ES next update. And that gives me effectively everything geometry shaders etc can ever bring.
By using those I'm saved from checking any extensions. And there is not much they could even bring to the table.
fp64, draw_indirect, multi_draw_indirect, shader_buffer_load, bindless_texture.
These are all killer features in writing fast renderers.
Not to mention vendor specific extensions and workarounds driver bugs.
So one ends with multiple code paths, if several versions are to be supported. Similar to how HTML or POSIX are portable, but then again not so much.
I'm not a video games programmer, but judging by the benchmarks it seems the most efficient graphics stack is based around AMD's Mantle: http://hothardware.com/News/AMD-Mantle-vs-DirectX-Benchmarks...
John Carmack suggests the OpenGL extensions that NVidia have developed give comparable performance to Mantle: http://n4g.com/news/1376571/john-carmack-nvidias-opengl-exte...
Explain please?
You can practically issue render commands only from one thread. And there is no way to save bunch of commands anymore as display lists were deprecated. Also it's still very much state machine based. So you have to do a lot of individual calls to set everything up for actual draw call.
I personally love OpenGL and use it on my work. However this is one of the biggest drawbacks on OpenGL currently.
OpenGL has context sharing, which means several contexts in different threads sharing the same objects. You can issue commands as long as you synchronise access to objects yourself. In practice, that means filling buffers, rendering to an off-screen framebuffer, etc. from other threads.
This leads to developers pursuing various less optimal solutions that all involve more startup time for users and less predictable performance and robustness for developers (at least when compared to the solution D3D has offered for more than 10 years). So when people say OpenGL is years behind D3D this is one of the things they mean. D3D isn't perfect here either. There is a fair amount of configuration-specific recompilation going on, but the formats are more compact than the optimized/minimized GLSL source formats people are pursuing on OpenGL and while the startup time (shader create time) is still too long, it is still much better than OpenGL. Shader robustness is generally more predictable and better on D3D but it's hard to disentangle shader pipeline issues from driver quality.
To be fair multicore is also an issue for OpenGL, but D3D isn't great at that either. The current spec for D3D11 includes a multicore rendering feature called "deferred contexts" but performance scaling using that feature has been disappointing so it isn't a clear win for D3D. Other APIs (e.g. hardware-specific console graphics APIs) expose more of the GPU command buffer and reducing abstraction there allows for a real solution to the multicore rendering problem. There should be a vendor neutral solution here, but so far neither of the APIs has delivered one that is close to the hardware-specific solutions in performance scaling.
Happy times. The music in Screamer 1 was better though, more noodly guitar music in the style of Satriani.
Which is kind of understandable - I use Mesa as my "assumed" OGL level, and it just hit 3.3. So you absolutely can't assume anything from the 4 line.
Though I still couldn't use geometry shaders as an assumption, because as recently as Sandy Bridge Intel GPUs didn't support it. Add on if you want to port to mobile you need to refactor to GLES2.
If it works on Windows, then I wonder if it really matters. I've seen a lot of games (e.g. Team Fortress 2) still offer multithreading as an option in the UI, so there's already two code paths there.
D3D multithreading works (even, to a lesser extent, with D3D9!), and this is one of the reasons why our D3D9 renderer is dramatically faster than our GL one - we can offload a subset of rendering work to helper threads instead of keeping it all locked on the thread that owns the window.
TF2/etc do offer a multithreaded rendering option, but IIRC on Windows their engine still uses D3D. Also, note that it's an option, because the feature used to be very unstable (still might be, actually) - I suspect people using the GL version of those games may have to disable it on certain hardware/driver configurations.
In D3D it works as OpenGL display lists would, except with arbitrary commands. So you have multiple threads composing the scene and then a single thread just issues few commands to replay the command buffers created by the other threads.
It would be rather simple to implement the same in OpenGL as we already have the display list concept, even if it originally was made to reduce the amount of glvertex3f calls.
"complete lack" was maybe bit of an exaggeration, however in practice it is true.
MS-DOS was a Microsoft platform, but not DOS itself:
> http://en.wikipedia.org/wiki/DR-DOS
Also Glide was not a Microsoft API.
DR-DOS actually came with the first PC I bought and it was for all effects a MS-DOS clone, hence a DOS clone, like PC-DOS from IBM and a few others on those days.
Under this argumentation GNU/Linux or even OS X is a UNIX clone and both should be abbreviated to UNIX (or UN*X to avoid trademark violations ;-) ). Indeed both originate from UNIX clones - but then new features were added that made them better than the original in a sense. The same happened to DR-DOS. Read DR-DOS' wikipedia article to read about features that DR-DOS added over Microsoft's original.